From f03b2f61ada98b0e4ebb438746870fbc6857ae25 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Thu, 16 Jul 2026 03:50:19 +0800
Subject: [PATCH 01/11] fix(pack): scope HMR updates to subscribed clients

---
 packages/pack/src/__test__/hmr.test.ts   | 127 +++++++++++++++++++++++
 packages/pack/src/core/hmr.ts            |  37 +++++--
 packages/pack/src/core/hmrClientState.ts |  61 +++++++++++
 3 files changed, 216 insertions(+), 9 deletions(-)
 create mode 100644 packages/pack/src/__test__/hmr.test.ts
 create mode 100644 packages/pack/src/core/hmrClientState.ts

diff --git a/packages/pack/src/__test__/hmr.test.ts b/packages/pack/src/__test__/hmr.test.ts
new file mode 100644
index 000000000..f7d4cb2ba
--- /dev/null
+++ b/packages/pack/src/__test__/hmr.test.ts
@@ -0,0 +1,127 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  deleteClientSubscriptionIfCurrent,
+  enqueueTurbopackUpdateForClient,
+  isCurrentClientSubscription,
+  unsubscribeClient,
+} from "../core/hmrClientState";
+
+function createClientState() {
+  return {
+    hmrPayloads: new Map(),
+    turbopackUpdates: [],
+    subscriptions: new Map(),
+    clientIssues: new Map(),
+  };
+}
+
+describe("HMR client delivery", () => {
+  it("queues a subscribed update only for the client that produced it", () => {
+    const clientA = { send: vi.fn(), close: vi.fn() };
+    const clientB = { send: vi.fn(), close: vi.fn() };
+    const stateA = createClientState();
+    const stateB = createClientState();
+    const clientStates = new WeakMap([
+      [clientA, stateA],
+      [clientB, stateB],
+    ]);
+    const update = {
+      type: "partial",
+      issues: [{ severity: "warning" }],
+    } as any;
+
+    enqueueTurbopackUpdateForClient(clientStates, clientA, update);
+
+    expect(stateA.turbopackUpdates).toEqual([{ ...update, issues: [] }]);
+    expect(stateB.turbopackUpdates).toEqual([]);
+  });
+
+  it("preserves distinct resources even when their instructions are equal", () => {
+    const client = { send: vi.fn(), close: vi.fn() };
+    const state = createClientState();
+    const clientStates = new WeakMap([[client, state]]);
+    const instruction = { type: "ChunkListUpdate", merged: [] };
+
+    enqueueTurbopackUpdateForClient(clientStates, client, {
+      type: "partial",
+      resource: { path: "route-a" },
+      instruction,
+      issues: [],
+    });
+    enqueueTurbopackUpdateForClient(clientStates, client, {
+      type: "partial",
+      resource: { path: "route-b" },
+      instruction,
+      issues: [],
+    });
+
+    expect(
+      state.turbopackUpdates.map((update: any) => update.resource.path),
+    ).toEqual(["route-a", "route-b"]);
+  });
+});
+
+describe("HMR subscription lifecycle", () => {
+  it("deletes a subscription before returning it so it can resubscribe", () => {
+    const subscription = { return: vi.fn() };
+    const subscriptions = new Map([["route", subscription]]);
+
+    unsubscribeClient(subscriptions, "route");
+
+    expect(subscriptions.has("route")).toBe(false);
+    expect(subscription.return).toHaveBeenCalledOnce();
+  });
+
+  it("does not let an old iterator completion delete its replacement", () => {
+    const oldSubscription = { return: vi.fn() };
+    const newSubscription = { return: vi.fn() };
+    const subscriptions = new Map([["route", newSubscription]]);
+
+    deleteClientSubscriptionIfCurrent(subscriptions, "route", oldSubscription);
+
+    expect(subscriptions.get("route")).toBe(newSubscription);
+  });
+
+  it("does not treat an old iterator error as current after resubscribing", () => {
+    const client = { send: vi.fn(), close: vi.fn() };
+    const state = createClientState();
+    const clientStates = new WeakMap([[client, state]]);
+    const oldSubscription = { return: vi.fn() };
+    const newSubscription = { return: vi.fn() };
+
+    state.subscriptions.set("route", oldSubscription);
+    unsubscribeClient(state.subscriptions, "route");
+    state.subscriptions.set("route", newSubscription);
+
+    expect(
+      isCurrentClientSubscription(
+        clientStates,
+        client,
+        state,
+        "route",
+        oldSubscription,
+      ),
+    ).toBe(false);
+    expect(
+      isCurrentClientSubscription(
+        clientStates,
+        client,
+        state,
+        "route",
+        newSubscription,
+      ),
+    ).toBe(true);
+  });
+
+  it("reports whether completion removed the current subscription", () => {
+    const subscription = { return: vi.fn() };
+    const subscriptions = new Map([["route", subscription]]);
+
+    expect(
+      deleteClientSubscriptionIfCurrent(subscriptions, "route", subscription),
+    ).toBe(true);
+    expect(
+      deleteClientSubscriptionIfCurrent(subscriptions, "route", subscription),
+    ).toBe(false);
+  });
+});
diff --git a/packages/pack/src/core/hmr.ts b/packages/pack/src/core/hmr.ts
index f4b5eee16..59435727e 100644
--- a/packages/pack/src/core/hmr.ts
+++ b/packages/pack/src/core/hmr.ts
@@ -30,6 +30,12 @@ import { acquirePersistentCacheLock } from "../utils/lockfile";
 import { normalizePath } from "../utils/normalizePath";
 import { useWorkerThreads } from "../utils/runtimePluginStratety";
 import { validateEntryPaths } from "../utils/validateEntry";
+import {
+  deleteClientSubscriptionIfCurrent,
+  enqueueTurbopackUpdateForClient,
+  isCurrentClientSubscription,
+  unsubscribeClient,
+} from "./hmrClientState";
 import { projectFactory } from "./project";
 import { Endpoint, Project, Update as TurbopackUpdate } from "./types";
 
@@ -299,12 +305,8 @@ export async function createHotReloader(
   }
   const sendEnqueuedMessagesDebounce = debounce(sendEnqueuedMessages, 2);
 
-  function sendTurbopackMessage(payload: TurbopackUpdate) {
-    payload.issues = [];
-
-    for (const client of clients) {
-      clientStates.get(client)?.turbopackUpdates.push(payload);
-    }
+  function sendTurbopackMessage(client: WSLike, payload: TurbopackUpdate) {
+    enqueueTurbopackUpdateForClient(clientStates, client, payload);
 
     hmrEventHappened = true;
     sendEnqueuedMessagesDebounce();
@@ -508,10 +510,22 @@ export async function createHotReloader(
       for await (const data of subscription) {
         processIssues(state.clientIssues, issueKey, data, false, true);
         if (data.type !== "issues") {
-          sendTurbopackMessage(data);
+          sendTurbopackMessage(client, data);
         }
       }
     } catch (e) {
+      if (
+        !isCurrentClientSubscription(
+          clientStates,
+          client,
+          state,
+          id,
+          subscription,
+        )
+      ) {
+        return;
+      }
+
       // The client might be using an HMR session from a previous server, tell them
       // to fully reload the page to resolve the issue. We can't use
       // `hotReloader.send` since that would force every connected client to
@@ -523,6 +537,12 @@ export async function createHotReloader(
       sendToClient(client, reloadAction);
       client.close();
       return;
+    } finally {
+      if (
+        deleteClientSubscriptionIfCurrent(state.subscriptions, id, subscription)
+      ) {
+        state.clientIssues.delete(issueKey);
+      }
     }
   }
 
@@ -532,8 +552,7 @@ export async function createHotReloader(
       return;
     }
 
-    const subscription = state.subscriptions.get(id);
-    subscription?.return!();
+    unsubscribeClient(state.subscriptions, id);
     state.clientIssues.delete(getClientIssueKey(id));
   }
 
diff --git a/packages/pack/src/core/hmrClientState.ts b/packages/pack/src/core/hmrClientState.ts
new file mode 100644
index 000000000..233c48d38
--- /dev/null
+++ b/packages/pack/src/core/hmrClientState.ts
@@ -0,0 +1,61 @@
+export interface TurbopackUpdateQueue<Update> {
+  turbopackUpdates: Update[];
+}
+
+export function enqueueTurbopackUpdateForClient<
+  Client extends object,
+  Update extends { issues: unknown[] },
+>(
+  clientStates: WeakMap<Client, TurbopackUpdateQueue<Update>>,
+  client: Client,
+  payload: Update,
+) {
+  payload.issues = [];
+  clientStates.get(client)?.turbopackUpdates.push(payload);
+}
+
+export interface ReturnableSubscription {
+  return?: () => unknown;
+}
+
+export function unsubscribeClient<Subscription extends ReturnableSubscription>(
+  subscriptions: Map<string, Subscription>,
+  id: string,
+) {
+  const subscription = subscriptions.get(id);
+  if (!subscription) {
+    return;
+  }
+
+  subscriptions.delete(id);
+  subscription.return?.();
+}
+
+export function deleteClientSubscriptionIfCurrent<Subscription>(
+  subscriptions: Map<string, Subscription>,
+  id: string,
+  subscription: Subscription,
+) {
+  if (subscriptions.get(id) === subscription) {
+    subscriptions.delete(id);
+    return true;
+  }
+
+  return false;
+}
+
+export function isCurrentClientSubscription<
+  Client extends object,
+  State extends { subscriptions: ReadonlyMap<string, unknown> },
+>(
+  clientStates: WeakMap<Client, State>,
+  client: Client,
+  state: State,
+  id: string,
+  subscription: unknown,
+) {
+  return (
+    clientStates.get(client) === state &&
+    state.subscriptions.get(id) === subscription
+  );
+}

From 3a3ff71b891b31948053d758dfe7513e87b25449 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Thu, 16 Jul 2026 04:15:03 +0800
Subject: [PATCH 02/11] fix(pack): harden hmr client cleanup

---
 packages/pack/src/__test__/hmr.test.ts   | 15 +++++++++++++++
 packages/pack/src/core/hmrClientState.ts | 13 ++++++++++---
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/packages/pack/src/__test__/hmr.test.ts b/packages/pack/src/__test__/hmr.test.ts
index f7d4cb2ba..d25f983b6 100644
--- a/packages/pack/src/__test__/hmr.test.ts
+++ b/packages/pack/src/__test__/hmr.test.ts
@@ -34,6 +34,7 @@ describe("HMR client delivery", () => {
 
     expect(stateA.turbopackUpdates).toEqual([{ ...update, issues: [] }]);
     expect(stateB.turbopackUpdates).toEqual([]);
+    expect(update.issues).toEqual([{ severity: "warning" }]);
   });
 
   it("preserves distinct resources even when their instructions are equal", () => {
@@ -72,6 +73,20 @@ describe("HMR subscription lifecycle", () => {
     expect(subscription.return).toHaveBeenCalledOnce();
   });
 
+  it("absorbs iterator cleanup failures after deleting the subscription", async () => {
+    const subscription = {
+      return: vi.fn(() => Promise.reject(new Error("cleanup failed"))),
+    };
+    const subscriptions = new Map([["route", subscription]]);
+
+    await expect(
+      unsubscribeClient(subscriptions, "route"),
+    ).resolves.toBeUndefined();
+
+    expect(subscriptions.has("route")).toBe(false);
+    expect(subscription.return).toHaveBeenCalledOnce();
+  });
+
   it("does not let an old iterator completion delete its replacement", () => {
     const oldSubscription = { return: vi.fn() };
     const newSubscription = { return: vi.fn() };
diff --git a/packages/pack/src/core/hmrClientState.ts b/packages/pack/src/core/hmrClientState.ts
index 233c48d38..df5fb3247 100644
--- a/packages/pack/src/core/hmrClientState.ts
+++ b/packages/pack/src/core/hmrClientState.ts
@@ -10,8 +10,8 @@ export function enqueueTurbopackUpdateForClient<
   client: Client,
   payload: Update,
 ) {
-  payload.issues = [];
-  clientStates.get(client)?.turbopackUpdates.push(payload);
+  const update = { ...payload, issues: [] } as Update;
+  clientStates.get(client)?.turbopackUpdates.push(update);
 }
 
 export interface ReturnableSubscription {
@@ -28,7 +28,14 @@ export function unsubscribeClient<Subscription extends ReturnableSubscription>(
   }
 
   subscriptions.delete(id);
-  subscription.return?.();
+  try {
+    return Promise.resolve(subscription.return?.()).then(
+      () => undefined,
+      () => undefined,
+    );
+  } catch {
+    return Promise.resolve();
+  }
 }
 
 export function deleteClientSubscriptionIfCurrent<Subscription>(

From 986946dbea947ead3e7c66c7f533da0b0d0f39f6 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Mon, 20 Jul 2026 14:05:35 +0800
Subject: [PATCH 03/11] fix(pack): harden hmr disconnect cleanup

---
 packages/pack/src/__test__/hmr.test.ts   | 31 ++++++++++++++++++++++++
 packages/pack/src/core/hmr.ts            |  9 +++----
 packages/pack/src/core/hmrClientState.ts | 31 ++++++++++++++++++------
 3 files changed, 57 insertions(+), 14 deletions(-)

diff --git a/packages/pack/src/__test__/hmr.test.ts b/packages/pack/src/__test__/hmr.test.ts
index d25f983b6..9f3e95623 100644
--- a/packages/pack/src/__test__/hmr.test.ts
+++ b/packages/pack/src/__test__/hmr.test.ts
@@ -3,6 +3,7 @@ import {
   deleteClientSubscriptionIfCurrent,
   enqueueTurbopackUpdateForClient,
   isCurrentClientSubscription,
+  unsubscribeAllClientSubscriptions,
   unsubscribeClient,
 } from "../core/hmrClientState";
 
@@ -63,6 +64,36 @@ describe("HMR client delivery", () => {
 });
 
 describe("HMR subscription lifecycle", () => {
+  it("safely cleans every subscription when a client disconnects", async () => {
+    const remainingSizes: number[] = [];
+    const subscriptions = new Map([
+      [
+        "throwing",
+        {
+          return: vi.fn(() => {
+            remainingSizes.push(subscriptions.size);
+            throw new Error("cleanup failed");
+          }),
+        },
+      ],
+      [
+        "rejecting",
+        {
+          return: vi.fn(() => {
+            remainingSizes.push(subscriptions.size);
+            return Promise.reject(new Error("async cleanup failed"));
+          }),
+        },
+      ],
+    ]);
+
+    const cleanup = unsubscribeAllClientSubscriptions(subscriptions);
+
+    expect(subscriptions.size).toBe(0);
+    expect(remainingSizes).toEqual([0, 0]);
+    await expect(cleanup).resolves.toBeUndefined();
+  });
+
   it("deletes a subscription before returning it so it can resubscribe", () => {
     const subscription = { return: vi.fn() };
     const subscriptions = new Map([["route", subscription]]);
diff --git a/packages/pack/src/core/hmr.ts b/packages/pack/src/core/hmr.ts
index 59435727e..c7b8c623d 100644
--- a/packages/pack/src/core/hmr.ts
+++ b/packages/pack/src/core/hmr.ts
@@ -34,6 +34,7 @@ import {
   deleteClientSubscriptionIfCurrent,
   enqueueTurbopackUpdateForClient,
   isCurrentClientSubscription,
+  unsubscribeAllClientSubscriptions,
   unsubscribeClient,
 } from "./hmrClientState";
 import { projectFactory } from "./project";
@@ -617,9 +618,7 @@ export async function createHotReloader(
 
         client.on("close", () => {
           // Remove active subscriptions
-          for (const subscription of subscriptions.values()) {
-            subscription.return?.();
-          }
+          void unsubscribeAllClientSubscriptions(subscriptions);
           clientStates.delete(client);
           clients.delete(client);
         });
@@ -726,9 +725,7 @@ export async function createHotReloader(
     unregisterClient(ws) {
       const state = clientStates.get(ws);
       if (state) {
-        for (const subscription of state.subscriptions.values()) {
-          subscription.return?.();
-        }
+        void unsubscribeAllClientSubscriptions(state.subscriptions);
       }
       clientStates.delete(ws);
       clients.delete(ws);
diff --git a/packages/pack/src/core/hmrClientState.ts b/packages/pack/src/core/hmrClientState.ts
index df5fb3247..3336afe23 100644
--- a/packages/pack/src/core/hmrClientState.ts
+++ b/packages/pack/src/core/hmrClientState.ts
@@ -18,6 +18,28 @@ export interface ReturnableSubscription {
   return?: () => unknown;
 }
 
+function returnSubscription(subscription: ReturnableSubscription) {
+  try {
+    return Promise.resolve(subscription.return?.()).then(
+      () => undefined,
+      () => undefined,
+    );
+  } catch {
+    return Promise.resolve();
+  }
+}
+
+export function unsubscribeAllClientSubscriptions<
+  Subscription extends ReturnableSubscription,
+>(subscriptions: Map<string, Subscription>) {
+  const activeSubscriptions = [...subscriptions.values()];
+  subscriptions.clear();
+
+  return Promise.all(activeSubscriptions.map(returnSubscription)).then(
+    () => undefined,
+  );
+}
+
 export function unsubscribeClient<Subscription extends ReturnableSubscription>(
   subscriptions: Map<string, Subscription>,
   id: string,
@@ -28,14 +50,7 @@ export function unsubscribeClient<Subscription extends ReturnableSubscription>(
   }
 
   subscriptions.delete(id);
-  try {
-    return Promise.resolve(subscription.return?.()).then(
-      () => undefined,
-      () => undefined,
-    );
-  } catch {
-    return Promise.resolve();
-  }
+  return returnSubscription(subscription);
 }
 
 export function deleteClientSubscriptionIfCurrent<Subscription>(

From bf59b41849844c97c07e8024e8efe158a3eaa9b3 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Tue, 21 Jul 2026 00:58:01 +0800
Subject: [PATCH 04/11] perf(pack): accelerate large-graph HMR

---
 crates/pack-core/src/client/context.rs        |    1 +
 .../hmr/dynamic_chunk_lists/assert.js         |   43 +
 .../hmr/dynamic_chunk_lists/config.json       |   19 +
 .../hmr/dynamic_chunk_lists/input/index.js    |    3 +
 .../hmr/dynamic_chunk_lists/input/lazy.js     |    1 +
 .../output/input_index_3f44269c.js            |   13 +
 .../output/input_index_83022b3b.js            |    5 +
 .../output/input_lazy_5395e95a.js             |   11 +
 .../output/input_lazy_7d0cc84b.js             |    5 +
 .../output/input_lazy_91bce909.js             |   13 +
 .../hmr/dynamic_chunk_lists/output/main.js    | 2377 +++++++++++++++++
 next.js                                       |    2 +-
 packages/pack-shared/src/config.ts            |    6 +
 packages/pack/config_schema.json              |    9 +-
 packages/pack/src/__test__/env.test.ts        |  110 +
 packages/pack/src/__test__/hmr.test.ts        |  349 +++
 packages/pack/src/__test__/serveStats.test.ts |    6 +
 packages/pack/src/commands/build.ts           |    5 +-
 packages/pack/src/core/hmr.ts                 |  165 +-
 packages/pack/src/core/hmrClientState.ts      |  153 ++
 packages/pack/src/core/types.ts               |    3 +-
 packages/pack/src/utils/env.ts                |   57 +-
 22 files changed, 3280 insertions(+), 76 deletions(-)
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
 create mode 100644 packages/pack/src/__test__/env.test.ts

diff --git a/crates/pack-core/src/client/context.rs b/crates/pack-core/src/client/context.rs
index 1f92f5c12..c0afa9356 100644
--- a/crates/pack-core/src/client/context.rs
+++ b/crates/pack-core/src/client/context.rs
@@ -686,6 +686,7 @@ pub async fn get_client_chunking_context(
     if mode.is_development() {
         builder = builder
             .hot_module_replacement()
+            .dynamic_hmr_chunk_lists()
             .source_map_source_type(SourceMapSourceType::AbsoluteFileUri)
             .dynamic_chunk_content_loading(true);
     } else {
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
new file mode 100644
index 000000000..462704e3f
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
@@ -0,0 +1,43 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const outputDir = path.join(__dirname, "output");
+const registrations = fs
+  .readdirSync(outputDir)
+  .filter((file) => file.endsWith(".js"))
+  .map((file) => fs.readFileSync(path.join(outputDir, file), "utf8"))
+  .filter((content) => content.includes("_CHUNK_LISTS"));
+
+const entryRegistrations = registrations.filter((content) =>
+  /source:\s*["']entry["']/.test(content),
+);
+const dynamicRegistrations = registrations.filter((content) =>
+  /source:\s*["']dynamic["']/.test(content),
+);
+
+assert.equal(
+  entryRegistrations.length,
+  1,
+  "the runtime entry should have one HMR chunk list",
+);
+assert.equal(
+  dynamicRegistrations.length,
+  1,
+  "a loaded dynamic chunk group should have its own HMR chunk list",
+);
+
+function readChunks(registration) {
+  const match = registration.match(/chunks:\s*(\[[^\n]*\])/);
+  assert.ok(match, "the HMR registration should contain a chunks array");
+  return JSON.parse(match[1]);
+}
+
+const entryChunks = new Set(readChunks(entryRegistrations[0]));
+const dynamicChunks = readChunks(dynamicRegistrations[0]);
+
+assert.ok(dynamicChunks.length > 0, "the dynamic HMR list should not be empty");
+assert.ok(
+  dynamicChunks.every((chunk) => !entryChunks.has(chunk)),
+  "dynamic payload chunks should not be duplicated in the entry HMR list",
+);
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
new file mode 100644
index 000000000..831f7def7
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
@@ -0,0 +1,19 @@
+{
+  "config": {
+    "entry": [
+      {
+        "import": "input/index.js",
+        "name": "main"
+      }
+    ],
+    "mode": "development",
+    "sourceMaps": false,
+    "optimization": {
+      "minify": false
+    },
+    "output": {
+      "path": "output"
+    }
+  },
+  "runtimeType": "Development"
+}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js
new file mode 100644
index 000000000..cf953ba51
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js
@@ -0,0 +1,3 @@
+export async function loadLazy() {
+  return import('./lazy')
+}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js
new file mode 100644
index 000000000..6a722af50
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js
@@ -0,0 +1 @@
+export const value = 'lazy'
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js
new file mode 100644
index 000000000..b9434c796
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js
@@ -0,0 +1,13 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "loadLazy",
+    ()=>loadLazy
+]);
+async function loadLazy() {
+    return __turbopack_context__.A("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript, async loader)");
+}
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
new file mode 100644
index 000000000..9cc7d78e4
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
@@ -0,0 +1,5 @@
+(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
+    script: typeof document === "object" ? document.currentScript : undefined,
+    chunks: ["input_lazy_91bce909.js","input_index_3f44269c.js"],
+    source: "entry"
+});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
new file mode 100644
index 000000000..db0b12372
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
@@ -0,0 +1,11 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "value",
+    ()=>value
+]);
+const value = 'lazy';
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js
new file mode 100644
index 000000000..46c3090d2
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js
@@ -0,0 +1,5 @@
+(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
+    script: typeof document === "object" ? document.currentScript : undefined,
+    chunks: ["input_lazy_5395e95a.js"],
+    source: "dynamic"
+});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js
new file mode 100644
index 000000000..d47ce8825
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js
@@ -0,0 +1,13 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript, async loader)", ((__turbopack_context__) => {
+
+__turbopack_context__.v((parentImport) => {
+    return Promise.all([
+  "input_lazy_5395e95a.js",
+  "input_lazy_7d0cc84b.js"
+].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
+        return parentImport("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript)");
+    });
+});
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
new file mode 100644
index 000000000..fb3eadd93
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
@@ -0,0 +1,2377 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
+    typeof document === "object" ? document.currentScript : undefined,
+    {"otherChunks":["input_lazy_91bce909.js","input_index_3f44269c.js"],"runtimeModuleIds":["[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)"]}
+]);
+(() => {
+if (!Array.isArray(globalThis["TURBOPACK"])) {
+    return;
+}
+
+var CHUNK_BASE_PATH = "/";
+var WORKER_BASE_PATH = null;
+var RELATIVE_ROOT_PATH = "/ROOT";
+var RUNTIME_PUBLIC_PATH = "/";
+var ASSET_SUFFIX = "";
+var CROSS_ORIGIN = null;
+var CHUNK_LOAD_RETRY_MAX_ATTEMPTS = 1;
+var CHUNK_LOAD_RETRY_BASE_DELAY_MS = 200;
+var CHUNK_LOAD_RETRY_MAX_JITTER_MS = 400;
+var WORKER_FORWARDED_GLOBALS = [];
+/**
+ * This file contains runtime types and functions that are shared between all
+ * TurboPack ECMAScript runtimes.
+ *
+ * It will be prepended to the runtime code of each runtime.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
+/// <reference path="./async-module.ts" />
+/**
+ * Describes why a module was instantiated.
+ * Shared between browser and Node.js runtimes.
+ */ var SourceType = function(SourceType) {
+    /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
+    /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */ SourceType[SourceType["Parent"] = 1] = "Parent";
+    /**
+   * The module was instantiated because it was included in a chunk's hot module
+   * update.
+   * SourceData is an array of ModuleIds or undefined.
+   */ SourceType[SourceType["Update"] = 2] = "Update";
+    return SourceType;
+}(SourceType || {});
+/**
+ * Flag indicating which module object type to create when a module is merged. Set to `true`
+ * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,
+ * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it
+ * uses plain Module objects.
+ */ let createModuleWithDirectionFlag = false;
+const REEXPORTED_OBJECTS = new WeakMap();
+/**
+ * Constructs the `__turbopack_context__` object for a module.
+ */ function Context(module, exports) {
+    this.m = module;
+    // We need to store this here instead of accessing it from the module object to:
+    // 1. Make it available to factories directly, since we rewrite `this` to
+    //    `__turbopack_context__.e` in CJS modules.
+    // 2. Support async modules which rewrite `module.exports` to a promise, so we
+    //    can still access the original exports object from functions like
+    //    `esmExport`
+    // Ideally we could find a new approach for async modules and drop this property altogether.
+    this.e = exports;
+}
+const contextPrototype = Context.prototype;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+function defineProp(obj, name, options) {
+    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
+}
+function getOverwrittenModule(moduleCache, id) {
+    let module = moduleCache[id];
+    if (!module) {
+        if (createModuleWithDirectionFlag) {
+            // set in development modes for hmr support
+            module = createModuleWithDirection(id);
+        } else {
+            module = createModuleObject(id);
+        }
+        moduleCache[id] = module;
+    }
+    return module;
+}
+/**
+ * Creates the module object. Only done here to ensure all module objects have the same shape.
+ */ function createModuleObject(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined
+    };
+}
+function createModuleWithDirection(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined,
+        parents: [],
+        children: []
+    };
+}
+const BindingTag_Value = 0;
+/**
+ * Adds the getters to the exports object.
+ */ function esm(exports, bindings) {
+    defineProp(exports, '__esModule', {
+        value: true
+    });
+    if (toStringTag) defineProp(exports, toStringTag, {
+        value: 'Module'
+    });
+    let i = 0;
+    while(i < bindings.length){
+        const propName = bindings[i++];
+        const tagOrFunction = bindings[i++];
+        if (typeof tagOrFunction === 'number') {
+            if (tagOrFunction === BindingTag_Value) {
+                defineProp(exports, propName, {
+                    value: bindings[i++],
+                    enumerable: true,
+                    writable: false
+                });
+            } else {
+                throw new Error(`unexpected tag: ${tagOrFunction}`);
+            }
+        } else {
+            const getterFn = tagOrFunction;
+            if (typeof bindings[i] === 'function') {
+                const setterFn = bindings[i++];
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    set: setterFn,
+                    enumerable: true
+                });
+            } else {
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    enumerable: true
+                });
+            }
+        }
+    }
+    Object.seal(exports);
+}
+/**
+ * Makes the module an ESM with exports
+ */ function esmExport(bindings, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    module.namespaceObject = exports;
+    esm(exports, bindings);
+}
+contextPrototype.s = esmExport;
+function ensureDynamicExports(module, exports) {
+    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
+    if (!reexportedObjects) {
+        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
+        module.exports = module.namespaceObject = new Proxy(exports, {
+            get (target, prop) {
+                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
+                    return Reflect.get(target, prop);
+                }
+                for (const obj of reexportedObjects){
+                    const value = Reflect.get(obj, prop);
+                    if (value !== undefined) return value;
+                }
+                return undefined;
+            },
+            ownKeys (target) {
+                const keys = Reflect.ownKeys(target);
+                for (const obj of reexportedObjects){
+                    for (const key of Reflect.ownKeys(obj)){
+                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
+                    }
+                }
+                return keys;
+            }
+        });
+    }
+    return reexportedObjects;
+}
+/**
+ * Dynamically exports properties from an object
+ */ function dynamicExport(object, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    const reexportedObjects = ensureDynamicExports(module, exports);
+    if (typeof object === 'object' && object !== null) {
+        reexportedObjects.push(object);
+    }
+}
+contextPrototype.j = dynamicExport;
+function exportValue(value, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = value;
+}
+contextPrototype.v = exportValue;
+function exportNamespace(namespace, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = module.namespaceObject = namespace;
+}
+contextPrototype.n = exportNamespace;
+function createGetter(obj, key) {
+    return ()=>obj[key];
+}
+/**
+ * @returns prototype of the object
+ */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
+    null,
+    getProto({}),
+    getProto([]),
+    getProto(getProto)
+];
+/**
+ * @param raw
+ * @param ns
+ * @param allowExportDefault
+ *   * `false`: will have the raw module as default export
+ *   * `true`: will have the default property as default export
+ */ function interopEsm(raw, ns, allowExportDefault) {
+    const bindings = [];
+    let defaultLocation = -1;
+    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
+        for (const key of Object.getOwnPropertyNames(current)){
+            bindings.push(key, createGetter(raw, key));
+            if (defaultLocation === -1 && key === 'default') {
+                defaultLocation = bindings.length - 1;
+            }
+        }
+    }
+    // this is not really correct
+    // we should set the `default` getter if the imported module is a `.cjs file`
+    if (!(allowExportDefault && defaultLocation >= 0)) {
+        // Replace the binding with one for the namespace itself in order to preserve iteration order.
+        if (defaultLocation >= 0) {
+            // Replace the getter with the value
+            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
+        } else {
+            bindings.push('default', BindingTag_Value, raw);
+        }
+    }
+    esm(ns, bindings);
+    return ns;
+}
+function createNS(raw) {
+    if (typeof raw === 'function') {
+        return function(...args) {
+            return raw.apply(this, args);
+        };
+    } else {
+        return Object.create(null);
+    }
+}
+function esmImport(id) {
+    const module = getOrInstantiateModuleFromParent(id, this.m);
+    // any ES module has to have `module.namespaceObject` defined.
+    if (module.namespaceObject) return module.namespaceObject;
+    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
+    const raw = module.exports;
+    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
+}
+contextPrototype.i = esmImport;
+function asyncLoader(moduleId) {
+    const loader = this.r(moduleId);
+    return loader(esmImport.bind(this));
+}
+contextPrototype.A = asyncLoader;
+// Add a simple runtime require so that environments without one can still pass
+// `typeof require` CommonJS checks so that exports are correctly registered.
+const runtimeRequire = // @ts-ignore
+typeof require === 'function' ? require : function require1() {
+    throw new Error('Unexpected use of runtime require');
+};
+contextPrototype.t = runtimeRequire;
+function commonJsRequire(id) {
+    return getOrInstantiateModuleFromParent(id, this.m).exports;
+}
+contextPrototype.r = commonJsRequire;
+/**
+ * Remove fragments and query parameters since they are never part of the context map keys
+ *
+ * This matches how we parse patterns at resolving time.  Arguably we should only do this for
+ * strings passed to `import` but the resolve does it for `import` and `require` and so we do
+ * here as well.
+ */ function parseRequest(request) {
+    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    const hashIndex = request.indexOf('#');
+    if (hashIndex !== -1) {
+        request = request.substring(0, hashIndex);
+    }
+    const queryIndex = request.indexOf('?');
+    if (queryIndex !== -1) {
+        request = request.substring(0, queryIndex);
+    }
+    return request;
+}
+/**
+ * `require.context` and require/import expression runtime.
+ */ function moduleContext(map) {
+    function moduleContext(id) {
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].module();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    }
+    moduleContext.keys = ()=>{
+        return Object.keys(map);
+    };
+    moduleContext.resolve = (id)=>{
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].id();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    };
+    moduleContext.import = async (id)=>{
+        return await moduleContext(id);
+    };
+    return moduleContext;
+}
+contextPrototype.f = moduleContext;
+/**
+ * Returns the path of a chunk defined by its data.
+ */ function getChunkPath(chunkData) {
+    return typeof chunkData === 'string' ? chunkData : chunkData.path;
+}
+// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
+// The CompressedModuleFactories format is
+// - 1 or more module ids
+// - a module factory function
+// So walking this is a little complex but the flat structure is also fast to
+// traverse, we can use `typeof` operators to distinguish the two cases.
+function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
+    let i = offset;
+    while(i < chunkModules.length){
+        let end = i + 1;
+        // Find our factory function
+        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
+            end++;
+        }
+        if (end === chunkModules.length) {
+            throw new Error('malformed chunk format, expected a factory function');
+        }
+        // Install the factory for each module ID that doesn't already have one.
+        // When some IDs in this group already have a factory, reuse that existing
+        // group factory for the missing IDs to keep all IDs in the group consistent.
+        // Otherwise, install the factory from this chunk.
+        const moduleFactoryFn = chunkModules[end];
+        let existingGroupFactory = undefined;
+        for(let j = i; j < end; j++){
+            const id = chunkModules[j];
+            const existingFactory = moduleFactories.get(id);
+            if (existingFactory) {
+                existingGroupFactory = existingFactory;
+                break;
+            }
+        }
+        const factoryToInstall = existingGroupFactory ?? moduleFactoryFn;
+        let didInstallFactory = false;
+        for(let j = i; j < end; j++){
+            const id = chunkModules[j];
+            if (!moduleFactories.has(id)) {
+                if (!didInstallFactory) {
+                    if (factoryToInstall === moduleFactoryFn) {
+                        applyModuleFactoryName(moduleFactoryFn);
+                    }
+                    didInstallFactory = true;
+                }
+                moduleFactories.set(id, factoryToInstall);
+                newModuleId?.(id);
+            }
+        }
+        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
+    }
+}
+/**
+ * A pseudo "fake" URL object to resolve to its relative path.
+ *
+ * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
+ * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
+ * hydration mismatch.
+ *
+ * This is based on webpack's existing implementation:
+ * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
+ */ const relativeURL = function relativeURL(inputUrl) {
+    const realUrl = new URL(inputUrl, 'x:/');
+    const values = {};
+    for(const key in realUrl)values[key] = realUrl[key];
+    values.href = inputUrl;
+    values.pathname = inputUrl.replace(/[?#].*/, '');
+    values.origin = values.protocol = '';
+    values.toString = values.toJSON = (..._args)=>inputUrl;
+    for(const key in values)Object.defineProperty(this, key, {
+        enumerable: true,
+        configurable: true,
+        value: values[key]
+    });
+};
+relativeURL.prototype = URL.prototype;
+contextPrototype.U = relativeURL;
+/**
+ * Utility function to ensure all variants of an enum are handled.
+ */ function invariant(never, computeMessage) {
+    throw new Error(`Invariant: ${computeMessage(never)}`);
+}
+/**
+ * Constructs an error message for when a module factory is not available.
+ */ function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
+    let instantiationReason;
+    switch(sourceType){
+        case 0:
+            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
+            break;
+        case 1:
+            instantiationReason = `because it was required from module ${sourceData}`;
+            break;
+        case 2:
+            instantiationReason = 'because of an HMR update';
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
+}
+/**
+ * A stub function to make `require` available but non-functional in ESM.
+ */ function requireStub(_moduleId) {
+    throw new Error('dynamic usage of require is not supported');
+}
+contextPrototype.z = requireStub;
+// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
+contextPrototype.g = globalThis;
+let cachedAutomaticPublicPath;
+function getAutomaticPublicPath() {
+    if (cachedAutomaticPublicPath !== undefined) {
+        return cachedAutomaticPublicPath;
+    }
+    let scriptUrl;
+    if (typeof document === 'object') {
+        const currentScript = document.currentScript;
+        scriptUrl = currentScript?.src;
+        if (!scriptUrl) {
+            const scripts = document.getElementsByTagName('script');
+            const script = scripts[scripts.length - 1];
+            scriptUrl = script?.src;
+        }
+    }
+    if (!scriptUrl && typeof globalThis.importScripts === 'function' && globalThis.location) {
+        scriptUrl = String(globalThis.location);
+    }
+    cachedAutomaticPublicPath = scriptUrl ? scriptUrl.replace(/^blob:/, '').replace(/#.*$/, '').replace(/\?.*$/, '').replace(/\/[^/]*$/, '/') : '';
+    return cachedAutomaticPublicPath;
+}
+/**
+ * Gets the public path for runtime assets.
+ * Checks globalThis.publicPath and falls back to "/".
+ */ function getPublicPath(mode) {
+    if (mode === 'auto') {
+        return getAutomaticPublicPath();
+    }
+    if (typeof globalThis !== 'undefined' && typeof globalThis.publicPath === 'string') {
+        const publicPath = globalThis.publicPath;
+        return publicPath.endsWith('/') ? publicPath : `${publicPath}/`;
+    }
+    return '/';
+}
+contextPrototype.p = getPublicPath;
+function applyModuleFactoryName(factory) {
+    // Give the module factory a nice name to improve stack traces.
+    Object.defineProperty(factory, 'name', {
+        value: 'module evaluation'
+    });
+}
+/// <reference path="./runtime-types.d.ts" />
+/// <reference path="./runtime-utils.ts" />
+/**
+ * Top-level-await / async-module machinery. This is only included in the runtime
+ * when the module graph actually contains an async module (a module with
+ * top-level await, or one that transitively depends on one). When no async
+ * module is present, the chunk items never reference `__turbopack_context__.a`,
+ * so this whole file can be omitted.
+ *
+ * everything below is adapted from webpack
+ * https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
+ */ const turbopackQueues = Symbol('turbopack queues');
+const turbopackExports = Symbol('turbopack exports');
+const turbopackError = Symbol('turbopack error');
+function isPromise(maybePromise) {
+    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
+}
+function isAsyncModuleExt(obj) {
+    return turbopackQueues in obj;
+}
+function createPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        reject = rej;
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+function resolveQueue(queue) {
+    if (queue && queue.status !== 1) {
+        queue.status = 1;
+        queue.forEach((fn)=>fn.queueCount--);
+        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
+    }
+}
+function wrapDeps(deps) {
+    return deps.map((dep)=>{
+        if (dep !== null && typeof dep === 'object') {
+            if (isAsyncModuleExt(dep)) return dep;
+            if (isPromise(dep)) {
+                const queue = Object.assign([], {
+                    status: 0
+                });
+                const obj = {
+                    [turbopackExports]: {},
+                    [turbopackQueues]: (fn)=>fn(queue)
+                };
+                dep.then((res)=>{
+                    obj[turbopackExports] = res;
+                    resolveQueue(queue);
+                }, (err)=>{
+                    obj[turbopackError] = err;
+                    resolveQueue(queue);
+                });
+                return obj;
+            }
+        }
+        return {
+            [turbopackExports]: dep,
+            [turbopackQueues]: ()=>{}
+        };
+    });
+}
+function asyncModule(body, hasAwait) {
+    const module = this.m;
+    const queue = hasAwait ? Object.assign([], {
+        status: -1
+    }) : undefined;
+    const depQueues = new Set();
+    const { resolve, reject, promise: rawPromise } = createPromise();
+    const promise = Object.assign(rawPromise, {
+        [turbopackExports]: module.exports,
+        [turbopackQueues]: (fn)=>{
+            queue && fn(queue);
+            depQueues.forEach(fn);
+            promise['catch'](()=>{});
+        }
+    });
+    const attributes = {
+        get () {
+            return promise;
+        },
+        set (v) {
+            // Calling `esmExport` leads to this.
+            if (v !== promise) {
+                promise[turbopackExports] = v;
+            }
+        }
+    };
+    Object.defineProperty(module, 'exports', attributes);
+    Object.defineProperty(module, 'namespaceObject', attributes);
+    function handleAsyncDependencies(deps) {
+        const currentDeps = wrapDeps(deps);
+        const getResult = ()=>currentDeps.map((d)=>{
+                if (d[turbopackError]) throw d[turbopackError];
+                return d[turbopackExports];
+            });
+        const { promise, resolve } = createPromise();
+        const fn = Object.assign(()=>resolve(getResult), {
+            queueCount: 0
+        });
+        function fnQueue(q) {
+            if (q !== queue && !depQueues.has(q)) {
+                depQueues.add(q);
+                if (q && q.status === 0) {
+                    fn.queueCount++;
+                    q.push(fn);
+                }
+            }
+        }
+        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
+        return fn.queueCount ? promise : getResult();
+    }
+    function asyncResult(err) {
+        if (err) {
+            reject(promise[turbopackError] = err);
+        } else {
+            resolve(promise[turbopackExports]);
+        }
+        resolveQueue(queue);
+    }
+    body(handleAsyncDependencies, asyncResult);
+    if (queue && queue.status === -1) {
+        queue.status = 0;
+    }
+}
+contextPrototype.a = asyncModule;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *browser* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
+/// <reference path="../../../shared/runtime/runtime-utils.ts" />
+// Used in WebWorkers to tell the runtime about the chunk suffix
+// Support runtime public path modes.
+function getRuntimeChunkBasePath(basePath = CHUNK_BASE_PATH) {
+    if (basePath === '__RUNTIME_PUBLIC_PATH__') {
+        return contextPrototype.p();
+    }
+    if (basePath === '__AUTO_PUBLIC_PATH__') {
+        return contextPrototype.p('auto');
+    }
+    return basePath;
+}
+const browserContextPrototype = Context.prototype;
+const moduleFactories = new Map();
+contextPrototype.M = moduleFactories;
+const availableModules = new Map();
+const availableModuleChunks = new Map();
+function loadChunk(chunkData) {
+    return loadChunkInternal(SourceType.Parent, this.m.id, chunkData);
+}
+browserContextPrototype.l = loadChunk;
+function loadInitialChunk(chunkPath, chunkData) {
+    return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
+}
+async function loadChunkInternal(sourceType, sourceData, chunkData) {
+    if (typeof chunkData === 'string') {
+        return loadChunkPath(sourceType, sourceData, chunkData);
+    }
+    const includedList = chunkData.included || [];
+    const modulesPromises = includedList.map((included)=>{
+        if (moduleFactories.has(included)) return true;
+        return availableModules.get(included);
+    });
+    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
+        // When all included items are already loaded or loading, we can skip loading ourselves
+        await Promise.all(modulesPromises);
+        return;
+    }
+    const includedModuleChunksList = chunkData.moduleChunks || [];
+    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
+        // TODO(alexkirsz) Do we need this check?
+        // if (moduleFactories[included]) return true;
+        return availableModuleChunks.get(included);
+    }).filter((p)=>p);
+    let promise;
+    if (moduleChunksPromises.length > 0) {
+        // Some module chunks are already loaded or loading.
+        if (moduleChunksPromises.length === includedModuleChunksList.length) {
+            // When all included module chunks are already loaded or loading, we can skip loading ourselves
+            await Promise.all(moduleChunksPromises);
+            return;
+        }
+        const moduleChunksToLoad = new Set();
+        for (const moduleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(moduleChunk)) {
+                moduleChunksToLoad.add(moduleChunk);
+            }
+        }
+        for (const moduleChunkToLoad of moduleChunksToLoad){
+            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
+            availableModuleChunks.set(moduleChunkToLoad, promise);
+            moduleChunksPromises.push(promise);
+        }
+        promise = Promise.all(moduleChunksPromises);
+    } else {
+        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
+        // Mark all included module chunks as loading if they are not already loaded or loading.
+        for (const includedModuleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(includedModuleChunk)) {
+                availableModuleChunks.set(includedModuleChunk, promise);
+            }
+        }
+    }
+    for (const included of includedList){
+        if (!availableModules.has(included)) {
+            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
+            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
+            availableModules.set(included, promise);
+        }
+    }
+    await promise;
+}
+const loadedChunk = Promise.resolve(undefined);
+const instrumentedBackendLoadChunks = new WeakMap();
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrl(chunkUrl) {
+    return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl);
+}
+browserContextPrototype.L = loadChunkByUrl;
+const loadedScripts = new Map();
+/**
+ * Load an external script by creating a <script> tag.
+ * This is used for script externals that need to be loaded from CDN or other external sources.
+ */ function loadScript(scriptUrl) {
+    // Return cached promise if script is already loading or loaded
+    let promise = loadedScripts.get(scriptUrl);
+    if (promise) {
+        return promise;
+    }
+    promise = new Promise((resolve, reject)=>{
+        const script = document.createElement('script');
+        script.crossOrigin = CROSS_ORIGIN;
+        script.src = scriptUrl;
+        script.onload = ()=>resolve();
+        script.onerror = ()=>reject(new Error(`Failed to load script: ${scriptUrl}`));
+        document.head.appendChild(script);
+    });
+    loadedScripts.set(scriptUrl, promise);
+    return promise;
+}
+browserContextPrototype.S = loadScript;
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
+    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
+    let entry = instrumentedBackendLoadChunks.get(thenable);
+    if (entry === undefined) {
+        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
+        entry = thenable.then(resolve).catch((cause)=>{
+            let loadReason;
+            switch(sourceType){
+                case SourceType.Runtime:
+                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
+                    break;
+                case SourceType.Parent:
+                    loadReason = `from module ${sourceData}`;
+                    break;
+                case SourceType.Update:
+                    loadReason = 'from an HMR update';
+                    break;
+                default:
+                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+            }
+            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
+                cause
+            } : undefined);
+            error.name = 'ChunkLoadError';
+            throw error;
+        });
+        instrumentedBackendLoadChunks.set(thenable, entry);
+    }
+    return entry;
+}
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkPath(sourceType, sourceData, chunkPath) {
+    const url = getChunkRelativeUrl(chunkPath);
+    return loadChunkByUrlInternal(sourceType, sourceData, url);
+}
+/**
+ * Returns an absolute url to an asset.
+ */ function resolvePathFromModule(moduleId) {
+    const exported = this.r(moduleId);
+    return exported?.default ?? exported;
+}
+browserContextPrototype.R = resolvePathFromModule;
+/**
+ * no-op for browser
+ * @param modulePath
+ */ function resolveAbsolutePath(modulePath) {
+    return `/ROOT/${modulePath ?? ''}`;
+}
+browserContextPrototype.P = resolveAbsolutePath;
+/**
+ * Returns a placeholder `file://` URL for the given module path. The browser
+ * runtime intentionally does not expose the real filesystem path. Path
+ * segments are percent-encoded so the result is always a valid file URI.
+ */ function resolveFileUrl(modulePath) {
+    if (!modulePath) return 'file:///ROOT/';
+    return `file:///ROOT/${modulePath.split('/').map(encodeURIComponent).join('/')}`;
+}
+browserContextPrototype.F = resolveFileUrl;
+/**
+ * Exports a URL with the static suffix appended.
+ */ function exportUrl(url, id) {
+    exportValue.call(this, `${url}${ASSET_SUFFIX}`, id);
+}
+browserContextPrototype.q = exportUrl;
+/**
+ * Instantiates a runtime module.
+ */ function instantiateRuntimeModule(moduleId, chunkPath) {
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Returns the URL relative to the origin where a chunk can be fetched from.
+ */ function getChunkRelativeUrl(chunkPath, basePath = CHUNK_BASE_PATH) {
+    return `${getRuntimeChunkBasePath(basePath)}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${ASSET_SUFFIX}`;
+}
+// Shared runtime primitives consumed by the bundled `createWorker` helper,
+// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.
+browserContextPrototype.b = CHUNK_BASE_PATH;
+browserContextPrototype.X = ASSET_SUFFIX;
+// Shared runtime primitive: build a chunk's URL. Used by the bundled worker
+// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.
+browserContextPrototype.h = getChunkRelativeUrl;
+function getPathFromScript(chunkScript) {
+    if (typeof chunkScript === 'string') {
+        return chunkScript;
+    }
+    const chunkUrl = chunkScript.src;
+    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
+    const runtimeBasePath = getRuntimeChunkBasePath();
+    let path = src.startsWith(runtimeBasePath) ? src.slice(runtimeBasePath.length) : src;
+    if (path.startsWith('/')) {
+        path = path.slice(1);
+    }
+    return path;
+}
+/**
+ * Return the ChunkUrl from a ChunkScript.
+ */ function getUrlFromScript(chunk) {
+    if (typeof chunk === 'string') {
+        return getChunkRelativeUrl(chunk);
+    } else {
+        // This is already exactly what we want
+        return chunk.src;
+    }
+}
+/**
+ * Determine the chunk to register. Note that this function has side-effects!
+ */ function getChunkFromRegistration(chunk) {
+    if (typeof chunk === 'string') {
+        return chunk;
+    } else if (!chunk) {
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        } else {
+            throw new Error('chunk path empty but not in a worker');
+        }
+    } else {
+        return {
+            src: chunk.getAttribute('src')
+        };
+    }
+}
+/**
+ * Checks if a given path/URL ends with the given extension,
+ * optionally followed by ?query or #fragment.
+ */ function endsWithExtension(chunkUrlOrPath, ext) {
+    // Find where the path ends (before query or fragment)
+    const q = chunkUrlOrPath.indexOf('?');
+    let end;
+    if (q !== -1) {
+        end = q;
+    } else {
+        const h = chunkUrlOrPath.indexOf('#');
+        end = h !== -1 ? h : chunkUrlOrPath.length;
+    }
+    // Check if the path portion ends with the extension
+    return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length);
+}
+function isJs(chunkUrlOrPath) {
+    return endsWithExtension(chunkUrlOrPath, '.js');
+}
+function isCss(chunkUrl) {
+    return endsWithExtension(chunkUrl, '.css');
+}
+/// <reference path="./runtime-utils.ts" />
+/// <reference path="./runtime-types.d.ts" />
+/// <reference path="./dev-extensions.ts" />
+/// <reference path="./dev-protocol.d.ts" />
+/**
+ * Shared HMR (Hot Module Replacement) implementation.
+ *
+ * This file contains the complete HMR implementation that's shared between
+ * browser and Node.js runtimes. It manages module hot state, dependency
+ * tracking, the module.hot API, and the full HMR update flow.
+ */ /**
+ * The development module cache shared across the runtime.
+ * Browser runtime declares this directly.
+ * Node.js runtime assigns globalThis.__turbopack_module_cache__ to this.
+ */ let devModuleCache;
+/**
+ * Module IDs that are instantiated as part of the runtime of a chunk.
+ */ let runtimeModules;
+/**
+ * Maps module IDs to persisted data between executions of their hot module
+ * implementation (`hot.data`).
+ */ const moduleHotData = new Map();
+/**
+ * Maps module instances to their hot module state.
+ * Uses WeakMap so it works with both HotModule and ModuleWithDirection.
+ */ const moduleHotState = new WeakMap();
+/**
+ * Modules that call `module.hot.invalidate()` (while being updated).
+ */ const queuedInvalidatedModules = new Set();
+class UpdateApplyError extends Error {
+    name = 'UpdateApplyError';
+    constructor(message, dependencyChain){
+        super(message);
+        this.dependencyChain = dependencyChain;
+    }
+}
+/**
+ * Records parent-child relationship when a module imports another.
+ * Should be called during module instantiation.
+ */ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+function trackModuleImport(parentModule, childModuleId, childModule) {
+    // Record that parent imports child
+    if (parentModule.children.indexOf(childModuleId) === -1) {
+        parentModule.children.push(childModuleId);
+    }
+    // Record that child is imported by parent
+    if (childModule && childModule.parents.indexOf(parentModule.id) === -1) {
+        childModule.parents.push(parentModule.id);
+    }
+}
+function formatDependencyChain(dependencyChain) {
+    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
+}
+/**
+ * Walks the dependency tree to find all modules affected by a change.
+ * Returns information about whether the update can be accepted and which
+ * modules need to be invalidated.
+ *
+ * @param moduleId - The module that changed
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().
+ *                           This is used for server-side HMR where pages auto-accept at the top level.
+ */ function getAffectedModuleEffects(moduleId, autoAcceptRootModules) {
+    const outdatedModules = new Set();
+    const outdatedDependencies = new Map();
+    const queue = [
+        {
+            moduleId,
+            dependencyChain: []
+        }
+    ];
+    let nextItem;
+    while(nextItem = queue.shift()){
+        const { moduleId, dependencyChain } = nextItem;
+        if (moduleId != null) {
+            if (outdatedModules.has(moduleId)) {
+                continue;
+            }
+            outdatedModules.add(moduleId);
+        }
+        // We've arrived at the runtime of the chunk, which means that nothing
+        // else above can accept this update.
+        if (moduleId === undefined) {
+            if (autoAcceptRootModules) {
+                return {
+                    type: 'accepted',
+                    moduleId,
+                    outdatedModules,
+                    outdatedDependencies
+                };
+            }
+            return {
+                type: 'unaccepted',
+                dependencyChain
+            };
+        }
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (// The module is not in the cache. Since this is a "modified" update,
+        // it means that the module was never instantiated before.
+        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
+            continue;
+        }
+        if (hotState.selfDeclined) {
+            return {
+                type: 'self-declined',
+                dependencyChain,
+                moduleId
+            };
+        }
+        if (runtimeModules.has(moduleId)) {
+            if (autoAcceptRootModules) {
+                continue;
+            }
+            queue.push({
+                moduleId: undefined,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+            continue;
+        }
+        for (const parentId of module.parents){
+            const parent = devModuleCache[parentId];
+            if (!parent) {
+                continue;
+            }
+            const parentHotState = moduleHotState.get(parent);
+            // Check if parent declined this dependency
+            if (parentHotState?.declinedDependencies[moduleId]) {
+                return {
+                    type: 'declined',
+                    dependencyChain: [
+                        ...dependencyChain,
+                        moduleId
+                    ],
+                    moduleId,
+                    parentId
+                };
+            }
+            // Skip if parent is already outdated
+            if (outdatedModules.has(parentId)) {
+                continue;
+            }
+            // Check if parent accepts this dependency
+            if (parentHotState?.acceptedDependencies[moduleId]) {
+                if (!outdatedDependencies.has(parentId)) {
+                    outdatedDependencies.set(parentId, new Set());
+                }
+                outdatedDependencies.get(parentId).add(moduleId);
+                continue;
+            }
+            // Neither accepted nor declined — propagate to parent
+            queue.push({
+                moduleId: parentId,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+        }
+        // If no parents and we're at a root module, auto-accept if configured
+        if (module.parents.length === 0 && autoAcceptRootModules) {
+            continue;
+        }
+    }
+    return {
+        type: 'accepted',
+        moduleId,
+        outdatedModules,
+        outdatedDependencies
+    };
+}
+/**
+ * Merges source dependency map into target dependency map.
+ */ function mergeDependencies(target, source) {
+    for (const [parentId, deps] of source){
+        const existing = target.get(parentId);
+        if (existing) {
+            for (const dep of deps){
+                existing.add(dep);
+            }
+        } else {
+            target.set(parentId, new Set(deps));
+        }
+    }
+}
+/**
+ * Computes all modules that need to be invalidated based on which modules changed.
+ *
+ * @param invalidated - The modules that have been invalidated
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function computedInvalidatedModules(invalidated, autoAcceptRootModules) {
+    const outdatedModules = new Set();
+    const outdatedDependencies = new Map();
+    for (const moduleId of invalidated){
+        const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules);
+        switch(effect.type){
+            case 'unaccepted':
+                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'self-declined':
+                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'declined':
+                throw new UpdateApplyError(`cannot apply update: declined dependency. ${formatDependencyChain(effect.dependencyChain)}. Declined by ${effect.parentId}.`, effect.dependencyChain);
+            case 'accepted':
+                for (const outdatedModuleId of effect.outdatedModules){
+                    outdatedModules.add(outdatedModuleId);
+                }
+                mergeDependencies(outdatedDependencies, effect.outdatedDependencies);
+                break;
+            default:
+                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
+        }
+    }
+    return {
+        outdatedModules,
+        outdatedDependencies
+    };
+}
+/**
+ * Creates the module.hot API object and its internal state.
+ * This provides the HMR API that user code calls (module.hot.accept(), etc.)
+ */ function createModuleHot(moduleId, hotData) {
+    const hotState = {
+        selfAccepted: false,
+        selfDeclined: false,
+        selfInvalidated: false,
+        disposeHandlers: [],
+        acceptedDependencies: {},
+        acceptedErrorHandlers: {},
+        declinedDependencies: {}
+    };
+    const hot = {
+        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
+        // decide whether to warn whenever an HMR-disposed module required other
+        // modules. We might want to remove it.
+        active: true,
+        data: hotData ?? {},
+        accept: (modules, callback, errorHandler)=>{
+            if (modules === undefined) {
+                hotState.selfAccepted = true;
+            } else if (typeof modules === 'function') {
+                hotState.selfAccepted = modules;
+            } else if (typeof modules === 'object' && modules !== null) {
+                for(let i = 0; i < modules.length; i++){
+                    hotState.acceptedDependencies[modules[i]] = callback || function() {};
+                    hotState.acceptedErrorHandlers[modules[i]] = errorHandler;
+                }
+            } else {
+                hotState.acceptedDependencies[modules] = callback || function() {};
+                hotState.acceptedErrorHandlers[modules] = errorHandler;
+            }
+        },
+        decline: (dep)=>{
+            if (dep === undefined) {
+                hotState.selfDeclined = true;
+            } else if (typeof dep === 'object' && dep !== null) {
+                for(let i = 0; i < dep.length; i++){
+                    hotState.declinedDependencies[dep[i]] = true;
+                }
+            } else {
+                hotState.declinedDependencies[dep] = true;
+            }
+        },
+        dispose: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        addDisposeHandler: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        removeDisposeHandler: (callback)=>{
+            const idx = hotState.disposeHandlers.indexOf(callback);
+            if (idx >= 0) {
+                hotState.disposeHandlers.splice(idx, 1);
+            }
+        },
+        invalidate: ()=>{
+            hotState.selfInvalidated = true;
+            queuedInvalidatedModules.add(moduleId);
+        },
+        // NOTE(alexkirsz) This is part of the management API, which we don't
+        // implement, but the Next.js React Refresh runtime uses this to decide
+        // whether to schedule an update.
+        status: ()=>'idle',
+        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
+        addStatusHandler: (_handler)=>{},
+        removeStatusHandler: (_handler)=>{},
+        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
+        // want the webpack code paths to ever update (the turbopack paths handle
+        // this already).
+        check: ()=>Promise.resolve(null)
+    };
+    return {
+        hot,
+        hotState
+    };
+}
+/**
+ * Processes queued invalidated modules and adds them to the outdated modules set.
+ * Modules that call module.hot.invalidate() are queued and processed here.
+ *
+ * @param outdatedModules - The current set of outdated modules
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules) {
+    if (queuedInvalidatedModules.size > 0) {
+        const result = computedInvalidatedModules(queuedInvalidatedModules, autoAcceptRootModules);
+        for (const moduleId of result.outdatedModules){
+            outdatedModules.add(moduleId);
+        }
+        mergeDependencies(outdatedDependencies, result.outdatedDependencies);
+        queuedInvalidatedModules.clear();
+    }
+    return {
+        outdatedModules,
+        outdatedDependencies
+    };
+}
+/**
+ * Computes which outdated modules have self-accepted and can be hot reloaded.
+ */ function computeOutdatedSelfAcceptedModules(outdatedModules) {
+    const outdatedSelfAcceptedModules = [];
+    for (const moduleId of outdatedModules){
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (module && hotState?.selfAccepted && !hotState.selfInvalidated) {
+            outdatedSelfAcceptedModules.push({
+                moduleId,
+                errorHandler: hotState.selfAccepted
+            });
+        }
+    }
+    return outdatedSelfAcceptedModules;
+}
+/**
+ * Disposes of an instance of a module.
+ * Runs hot.dispose handlers and manages persistent hot data.
+ *
+ * NOTE: mode = "replace" will not remove modules from devModuleCache.
+ * This must be done in a separate step afterwards.
+ */ function disposeModule(moduleId, mode) {
+    const module = devModuleCache[moduleId];
+    if (!module) {
+        return;
+    }
+    const hotState = moduleHotState.get(module);
+    if (!hotState) {
+        return;
+    }
+    const data = {};
+    // Run the `hot.dispose` handler, if any, passing in the persistent
+    // `hot.data` object.
+    for (const disposeHandler of hotState.disposeHandlers){
+        disposeHandler(data);
+    }
+    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
+    // module is still importing other modules.
+    if (module.hot) {
+        module.hot.active = false;
+    }
+    moduleHotState.delete(module);
+    // Remove the disposed module from its children's parent list.
+    // It will be added back once the module re-instantiates and imports its
+    // children again.
+    for (const childId of module.children){
+        const child = devModuleCache[childId];
+        if (!child) {
+            continue;
+        }
+        const idx = child.parents.indexOf(module.id);
+        if (idx >= 0) {
+            child.parents.splice(idx, 1);
+        }
+    }
+    switch(mode){
+        case 'clear':
+            delete devModuleCache[module.id];
+            moduleHotData.delete(module.id);
+            break;
+        case 'replace':
+            moduleHotData.set(module.id, data);
+            break;
+        default:
+            invariant(mode, (mode)=>`invalid mode: ${mode}`);
+    }
+}
+/**
+ * Dispose phase: runs dispose handlers and cleans up outdated/disposed modules.
+ * Returns the parent modules of outdated modules for use in the apply phase.
+ */ function disposePhase(outdatedModules, disposedModules, outdatedDependencies) {
+    for (const moduleId of outdatedModules){
+        disposeModule(moduleId, 'replace');
+    }
+    for (const moduleId of disposedModules){
+        disposeModule(moduleId, 'clear');
+    }
+    // Removing modules from the module cache is a separate step.
+    // We also want to keep track of previous parents of the outdated modules.
+    const outdatedModuleParents = new Map();
+    for (const moduleId of outdatedModules){
+        const oldModule = devModuleCache[moduleId];
+        outdatedModuleParents.set(moduleId, oldModule?.parents);
+        delete devModuleCache[moduleId];
+    }
+    // Remove outdated dependencies from parent module's children list.
+    // When a parent accepts a child's update, the child is re-instantiated
+    // but the parent stays alive. We remove the old child reference so it
+    // gets re-added when the child re-imports.
+    for (const [parentId, deps] of outdatedDependencies){
+        const module = devModuleCache[parentId];
+        if (module) {
+            for (const dep of deps){
+                const idx = module.children.indexOf(dep);
+                if (idx >= 0) {
+                    module.children.splice(idx, 1);
+                }
+            }
+        }
+    }
+    return {
+        outdatedModuleParents
+    };
+}
+/* eslint-disable @typescript-eslint/no-unused-vars */ /**
+ * Shared module instantiation logic.
+ * This handles the full module instantiation flow for both browser and Node.js.
+ * Only React Refresh hooks differ between platforms (passed as callback).
+ */ function instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContextFn, runModuleExecutionHooksFn) {
+    // 1. Factory validation (same in both browser and Node.js)
+    const id = moduleId;
+    const moduleFactory = moduleFactories.get(id);
+    if (typeof moduleFactory !== 'function') {
+        throw new Error(factoryNotAvailableMessage(moduleId, sourceType, sourceData) + `\nThis is often caused by a stale browser cache, misconfigured Cache-Control headers, or a service worker serving outdated responses.` + `\nTo fix this, make sure your Cache-Control headers allow revalidation of chunks and review your service worker configuration. ` + `As an immediate workaround, try hard-reloading the page, clearing the browser cache, or unregistering any service workers.`);
+    }
+    // 2. Hot API setup (same in both - works for browser, included for Node.js)
+    const hotData = moduleHotData.get(id);
+    const { hot, hotState } = createModuleHot(id, hotData);
+    // 3. Parent assignment logic (same in both)
+    let parents;
+    switch(sourceType){
+        case SourceType.Runtime:
+            runtimeModules.add(id);
+            parents = [];
+            break;
+        case SourceType.Parent:
+            parents = [
+                sourceData
+            ];
+            break;
+        case SourceType.Update:
+            parents = sourceData || [];
+            break;
+        default:
+            throw new Error(`Unknown source type: ${sourceType}`);
+    }
+    // 4. Module creation (platform creates base module object)
+    const module = createModuleObjectFn(id);
+    const exports = module.exports;
+    module.parents = parents;
+    module.children = [];
+    module.hot = hot;
+    devModuleCache[id] = module;
+    moduleHotState.set(module, hotState);
+    // 5. Module execution (React Refresh hooks are platform-specific)
+    try {
+        runModuleExecutionHooksFn(module, (refresh)=>{
+            const context = createContextFn(module, exports, refresh);
+            moduleFactory.call(exports, context, module, exports);
+        });
+    } catch (error) {
+        module.error = error;
+        throw error;
+    }
+    // 6. ESM interop (same in both)
+    if (module.namespaceObject && module.exports !== module.namespaceObject) {
+        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+        interopEsm(module.exports, module.namespaceObject);
+    }
+    return module;
+}
+/**
+ * Analyzes update entries and chunks to determine which modules were added, modified, or deleted.
+ * This is pure logic that doesn't depend on the runtime environment.
+ */ function computeChangedModules(entries, updates, chunkModulesMap) {
+    const chunksAdded = new Map();
+    const chunksDeleted = new Map();
+    const added = new Map();
+    const modified = new Map();
+    const deleted = new Set();
+    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
+        switch(mergedChunkUpdate.type){
+            case 'added':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.modules);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    break;
+                }
+            case 'deleted':
+                {
+                    const updateDeleted = chunkModulesMap ? new Set(chunkModulesMap.get(chunkPath)) : new Set();
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            case 'partial':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.added);
+                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            default:
+                throw new Error('Unknown merged chunk update type');
+        }
+    }
+    // If a module was added from one chunk and deleted from another in the same update,
+    // consider it to be modified, as it means the module was moved from one chunk to another
+    // AND has new code in a single update.
+    for (const moduleId of added.keys()){
+        if (deleted.has(moduleId)) {
+            added.delete(moduleId);
+            deleted.delete(moduleId);
+        }
+    }
+    for (const [moduleId, entry] of Object.entries(entries)){
+        // Modules that haven't been added to any chunk but have new code are considered
+        // to be modified.
+        // This needs to be under the previous loop, as we need it to get rid of modules
+        // that were added and deleted in the same update.
+        if (!added.has(moduleId)) {
+            modified.set(moduleId, entry);
+        }
+    }
+    return {
+        added,
+        deleted,
+        modified,
+        chunksAdded,
+        chunksDeleted
+    };
+}
+/**
+ * Compiles new module code and walks the dependency tree to find all outdated modules.
+ * Uses the evalModuleEntry function to compile code (platform-specific).
+ *
+ * @param added - Map of added modules
+ * @param modified - Map of modified modules
+ * @param evalModuleEntry - Function to compile module code
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules) {
+    const newModuleFactories = new Map();
+    // Compile added modules
+    for (const [moduleId, entry] of added){
+        if (entry != null) {
+            newModuleFactories.set(moduleId, evalModuleEntry(entry));
+        }
+    }
+    // Walk dependency tree to find all modules affected by modifications
+    const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(modified.keys(), autoAcceptRootModules);
+    // Compile modified modules
+    for (const [moduleId, entry] of modified){
+        newModuleFactories.set(moduleId, evalModuleEntry(entry));
+    }
+    return {
+        outdatedModules,
+        outdatedDependencies,
+        newModuleFactories
+    };
+}
+/**
+ * Updates module factories and re-instantiates self-accepted modules.
+ * Uses the instantiateModule function (platform-specific via callback).
+ */ function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError) {
+    // Update module factories
+    for (const [moduleId, factory] of newModuleFactories.entries()){
+        applyModuleFactoryNameFn(factory);
+        moduleFactories.set(moduleId, factory);
+    }
+    // TODO(alexkirsz) Run new runtime entries here.
+    // Call accept handlers for outdated dependencies.
+    // This runs BEFORE re-instantiating self-accepted modules, matching
+    // webpack's behavior.
+    for (const [parentId, deps] of outdatedDependencies){
+        const module = devModuleCache[parentId];
+        if (!module) continue;
+        const hotState = moduleHotState.get(module);
+        if (!hotState) continue;
+        // Group deps by callback, deduplicating callbacks that handle multiple deps.
+        // Each callback receives only the deps it was registered for.
+        const callbackDeps = new Map();
+        const callbackErrorHandlers = new Map();
+        for (const dep of deps){
+            const acceptCallback = hotState.acceptedDependencies[dep];
+            if (acceptCallback) {
+                let depList = callbackDeps.get(acceptCallback);
+                if (!depList) {
+                    depList = [];
+                    callbackDeps.set(acceptCallback, depList);
+                    callbackErrorHandlers.set(acceptCallback, hotState.acceptedErrorHandlers[dep]);
+                }
+                depList.push(dep);
+            }
+        }
+        for (const [callback, cbDeps] of callbackDeps){
+            try {
+                callback.call(null, cbDeps);
+            } catch (err) {
+                const errorHandler = callbackErrorHandlers.get(callback);
+                if (typeof errorHandler === 'function') {
+                    try {
+                        errorHandler(err, {
+                            moduleId: parentId,
+                            dependencyId: cbDeps[0]
+                        });
+                    } catch (err2) {
+                        reportError(err2);
+                        reportError(err);
+                    }
+                } else {
+                    reportError(err);
+                }
+            }
+        }
+    }
+    // Re-instantiate all outdated self-accepted modules
+    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
+        try {
+            instantiateModuleFn(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
+        } catch (err) {
+            if (typeof errorHandler === 'function') {
+                try {
+                    errorHandler(err, {
+                        moduleId,
+                        module: devModuleCache[moduleId]
+                    });
+                } catch (err2) {
+                    reportError(err2);
+                    reportError(err);
+                }
+            } else {
+                reportError(err);
+            }
+        }
+    }
+}
+/**
+ * Internal implementation that orchestrates the full HMR update flow:
+ * invalidation, disposal, and application of new modules.
+ *
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules) {
+    ;
+    ({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules));
+    // Find self-accepted modules to re-instantiate
+    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
+    // Run dispose handlers, save hot.data, clear caches
+    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules, outdatedDependencies);
+    let error;
+    function reportError(err) {
+        if (!error) error = err; // Keep first error
+    }
+    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError);
+    if (error) {
+        throw error;
+    }
+    // Recursively apply any queued invalidations from new module execution
+    if (queuedInvalidatedModules.size > 0) {
+        applyInternal(new Set(), new Map(), [], new Map(), moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules);
+    }
+}
+/**
+ * Main entry point for applying an ECMAScript merged update.
+ * This is called by both browser and Node.js runtimes with platform-specific callbacks.
+ *
+ * @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit
+ *                                   module.hot.accept(). Used for server-side HMR where pages
+ *                                   auto-accept at the top level.
+ */ function applyEcmascriptMergedUpdateShared(options) {
+    const { added, modified, disposedModules, evalModuleEntry, instantiateModule, applyModuleFactoryName, moduleFactories, devModuleCache, autoAcceptRootModules } = options;
+    const { outdatedModules, outdatedDependencies, newModuleFactories } = computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules);
+    applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModule, applyModuleFactoryName, autoAcceptRootModules);
+}
+/// <reference path="../../../shared/runtime/dev-globals.d.ts" />
+/// <reference path="../../../shared/runtime/dev-protocol.d.ts" />
+const devContextPrototype = Context.prototype;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *development* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ // Assign browser's module cache and runtime modules to shared HMR state
+devModuleCache = Object.create(null);
+devContextPrototype.c = devModuleCache;
+runtimeModules = new Set();
+// Set flag to indicate we use ModuleWithDirection
+createModuleWithDirectionFlag = true;
+function getRefreshBoundaryExports(exports) {
+    if (typeof isAsyncModuleExt === 'function' && exports != null && typeof exports === 'object' && isAsyncModuleExt(exports)) {
+        return exports[turbopackExports];
+    }
+    return exports;
+}
+/**
+ * Map from module ID to the chunks that contain this module.
+ *
+ * In HMR, we need to keep track of which modules are contained in which so
+ * chunks. This is so we don't eagerly dispose of a module when it is removed
+ * from chunk A, but still exists in chunk B.
+ */ const moduleChunksMap = new Map();
+/**
+ * Map from a chunk path to all modules it contains.
+ */ const chunkModulesMap = new Map();
+/**
+ * Chunk lists that contain a runtime. When these chunk lists receive an update
+ * that can't be reconciled with the current state of the page, we need to
+ * reload the runtime entirely.
+ */ const runtimeChunkLists = new Set();
+/**
+ * Map from a chunk list to the chunk paths it contains.
+ */ const chunkListChunksMap = new Map();
+/**
+ * Map from a chunk path to the chunk lists it belongs to.
+ */ const chunkChunkListsMap = new Map();
+/**
+ * Gets or instantiates a runtime module.
+ */ // @ts-ignore
+function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
+    const module = devModuleCache[moduleId];
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        return module;
+    }
+    // @ts-ignore
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */ // @ts-ignore Defined in `runtime-utils.ts`
+const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
+    if (!sourceModule.hot.active) {
+        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
+    }
+    const module = devModuleCache[id];
+    if (sourceModule.children.indexOf(id) === -1) {
+        sourceModule.children.push(id);
+    }
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        if (module.parents.indexOf(sourceModule.id) === -1) {
+            module.parents.push(sourceModule.id);
+        }
+        return module;
+    }
+    return instantiateModule(id, SourceType.Parent, sourceModule.id);
+};
+function DevContext(module, exports, refresh) {
+    Context.call(this, module, exports);
+    this.k = refresh;
+}
+DevContext.prototype = Context.prototype;
+function instantiateModule(moduleId, sourceType, sourceData) {
+    // Browser: creates base HotModule object (hot API added by shared code)
+    const createModuleObjectFn = (id)=>{
+        return createModuleObject(id);
+    };
+    // Browser: creates DevContext with refresh
+    const createContext = (module, exports, refresh)=>{
+        return new DevContext(module, exports, refresh);
+    };
+    // Use shared instantiation logic (includes hot API setup)
+    return instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContext, runModuleExecutionHooks);
+}
+const DUMMY_REFRESH_CONTEXT = {
+    register: (_type, _id)=>{},
+    signature: ()=>(_type)=>{},
+    registerExports: (_module, _helpers)=>{}
+};
+/**
+ * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
+ * Next.js' React Refresh runtime hooks into to add module context to the
+ * refresh registry.
+ */ function runModuleExecutionHooks(module, executeModule) {
+    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
+        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
+        try {
+            executeModule({
+                register: globalThis.$RefreshReg$,
+                signature: globalThis.$RefreshSig$,
+                registerExports: registerExportsAndSetupBoundaryForReactRefresh
+            });
+        } finally{
+            // Always cleanup the intercept, even if module execution failed.
+            cleanupReactRefreshIntercept();
+        }
+    } else {
+        // If the react refresh hooks are not installed we need to bind dummy functions.
+        // This is expected when running in a Web Worker.  It is also common in some of
+        // our test environments.
+        executeModule(DUMMY_REFRESH_CONTEXT);
+    }
+}
+/**
+ * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+ */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
+    const currentExports = getRefreshBoundaryExports(module.exports);
+    const prevExports = module.hot.data.prevExports ?? null;
+    helpers.registerExportsForReactRefresh(currentExports, module.id);
+    // A module can be accepted automatically based on its exports, e.g. when
+    // it is a Refresh Boundary.
+    if (helpers.isReactRefreshBoundary(currentExports)) {
+        // Save the previous exports on update, so we can compare the boundary
+        // signatures.
+        module.hot.dispose((data)=>{
+            data.prevExports = currentExports;
+        });
+        // Unconditionally accept an update to this module, we'll check if it's
+        // still a Refresh Boundary later.
+        module.hot.accept();
+        // This field is set when the previous version of this module was a
+        // Refresh Boundary, letting us know we need to check for invalidation or
+        // enqueue an update.
+        if (prevExports !== null) {
+            // A boundary can become ineligible if its exports are incompatible
+            // with the previous exports.
+            //
+            // For example, if you add/remove/change exports, we'll want to
+            // re-execute the importing modules, and force those components to
+            // re-render. Similarly, if you convert a class component to a
+            // function, we want to invalidate the boundary.
+            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
+                module.hot.invalidate();
+            } else {
+                helpers.scheduleUpdate();
+            }
+        }
+    } else {
+        // Since we just executed the code for the module, it's possible that the
+        // new exports made it ineligible for being a boundary.
+        // We only care about the case when we were _previously_ a boundary,
+        // because we already accepted this update (accidental side effect).
+        const isNoLongerABoundary = prevExports !== null;
+        if (isNoLongerABoundary) {
+            module.hot.invalidate();
+        }
+    }
+}
+/**
+ * Adds, deletes, and moves modules between chunks. This must happen before the
+ * dispose phase as it needs to know which modules were removed from all chunks,
+ * which we can only compute *after* taking care of added and moved modules.
+ */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
+    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
+        for (const moduleId of addedModuleIds){
+            addModuleToChunk(moduleId, chunkPath);
+        }
+    }
+    const disposedModules = new Set();
+    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
+        for (const moduleId of addedModuleIds){
+            if (removeModuleFromChunk(moduleId, chunkPath)) {
+                disposedModules.add(moduleId);
+            }
+        }
+    }
+    return {
+        disposedModules
+    };
+}
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+    }
+}
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+        }
+    }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+            }
+        }
+    }
+}
+function applyEcmascriptMergedUpdate(update) {
+    // Browser-specific chunk management phase
+    const { entries = {}, chunks = {} } = update;
+    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks, chunkModulesMap);
+    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
+    // Use shared HMR update implementation
+    applyEcmascriptMergedUpdateShared({
+        added,
+        modified,
+        disposedModules,
+        evalModuleEntry: _eval,
+        instantiateModule,
+        applyModuleFactoryName,
+        moduleFactories,
+        devModuleCache,
+        autoAcceptRootModules: false
+    });
+}
+function handleApply(chunkListPath, update) {
+    switch(update.type){
+        case 'partial':
+            {
+                // This indicates that the update is can be applied to the current state of the application.
+                applyUpdate(update.instruction);
+                break;
+            }
+        case 'restart':
+            {
+                // This indicates that there is no way to apply the update to the
+                // current state of the application, and that the application must be
+                // restarted.
+                DEV_BACKEND.restart();
+                break;
+            }
+        case 'notFound':
+            {
+                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
+                // or the page itself was deleted.
+                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
+                // If it is a runtime chunk list, we restart the application.
+                if (runtimeChunkLists.has(chunkListPath)) {
+                    DEV_BACKEND.restart();
+                } else {
+                    disposeChunkList(chunkListPath);
+                }
+                break;
+            }
+        default:
+            throw new Error(`Unknown update type: ${update.type}`);
+    }
+}
+/**
+ * Removes a module from a chunk.
+ * Returns `true` if there are no remaining chunks including this module.
+ */ function removeModuleFromChunk(moduleId, chunkPath) {
+    const moduleChunks = moduleChunksMap.get(moduleId);
+    moduleChunks.delete(chunkPath);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    chunkModules.delete(moduleId);
+    const noRemainingModules = chunkModules.size === 0;
+    if (noRemainingModules) {
+        chunkModulesMap.delete(chunkPath);
+    }
+    const noRemainingChunks = moduleChunks.size === 0;
+    if (noRemainingChunks) {
+        moduleChunksMap.delete(moduleId);
+    }
+    return noRemainingChunks;
+}
+/**
+ * Disposes of a chunk list and its corresponding exclusive chunks.
+ */ function disposeChunkList(chunkListPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (chunkPaths == null) {
+        return false;
+    }
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
+            disposeChunk(chunkPath);
+        }
+    }
+    // We must also dispose of the chunk list's chunk itself to ensure it may
+    // be reloaded properly in the future.
+    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
+    DEV_BACKEND.unloadChunk?.(chunkListUrl);
+    return true;
+}
+/**
+ * Disposes of a chunk and its corresponding exclusive modules.
+ *
+ * @returns Whether the chunk was disposed of.
+ */ function disposeChunk(chunkPath) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    // This should happen whether the chunk has any modules in it or not.
+    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
+    DEV_BACKEND.unloadChunk?.(chunkUrl);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    if (chunkModules == null) {
+        return false;
+    }
+    chunkModules.delete(chunkPath);
+    for (const moduleId of chunkModules){
+        const moduleChunks = moduleChunksMap.get(moduleId);
+        moduleChunks.delete(chunkPath);
+        const noRemainingChunks = moduleChunks.size === 0;
+        if (noRemainingChunks) {
+            moduleChunksMap.delete(moduleId);
+            disposeModule(moduleId, 'clear');
+            availableModules.delete(moduleId);
+        }
+    }
+    return true;
+}
+/**
+ * Adds a module to a chunk.
+ */ function addModuleToChunk(moduleId, chunkPath) {
+    let moduleChunks = moduleChunksMap.get(moduleId);
+    if (!moduleChunks) {
+        moduleChunks = new Set([
+            chunkPath
+        ]);
+        moduleChunksMap.set(moduleId, moduleChunks);
+    } else {
+        moduleChunks.add(chunkPath);
+    }
+    let chunkModules = chunkModulesMap.get(chunkPath);
+    if (!chunkModules) {
+        chunkModules = new Set([
+            moduleId
+        ]);
+        chunkModulesMap.set(chunkPath, chunkModules);
+    } else {
+        chunkModules.add(moduleId);
+    }
+}
+/**
+ * Marks a chunk list as a runtime chunk list. There can be more than one
+ * runtime chunk list. For instance, integration tests can have multiple chunk
+ * groups loaded at runtime, each with its own chunk list.
+ */ function markChunkListAsRuntime(chunkListPath) {
+    runtimeChunkLists.add(chunkListPath);
+}
+function registerChunk(registration) {
+    const chunk = getChunkFromRegistration(registration[0]);
+    let runtimeParams;
+    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
+    if (registration.length === 2) {
+        runtimeParams = registration[1];
+    } else {
+        let chunkPath = getPathFromScript(chunk);
+        runtimeParams = undefined;
+        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
+    }
+    return BACKEND.registerChunk(chunk, runtimeParams);
+}
+/**
+ * Subscribes to chunk list updates from the update server and applies them.
+ */ function registerChunkList(chunkList) {
+    const chunkListScript = getChunkFromRegistration(chunkList.script);
+    const chunkListPath = getPathFromScript(chunkListScript);
+    // The "chunk" is also registered to finish the loading in the backend
+    BACKEND.registerChunk(chunkListPath);
+    globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath)
+    ]);
+    // Adding chunks to chunk lists and vice versa.
+    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
+    if (chunkList.source === 'entry') {
+        markChunkListAsRuntime(chunkListPath);
+    }
+}
+globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
+/**
+ * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
+ *
+ * It will be appended to the base runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
+/// <reference path="../../../shared/runtime/runtime-types.d.ts" />
+function getAssetSuffixFromScriptSrc() {
+    // TURBOPACK_ASSET_SUFFIX is set in web workers
+    if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX;
+    const src = document?.currentScript?.getAttribute?.('src') ?? '';
+    const qi = src.indexOf('?');
+    return qi >= 0 ? src.slice(qi) : '';
+}
+let BACKEND;
+/**
+ * Maps chunk paths to the corresponding resolver.
+ */ const chunkResolvers = new Map();
+(()=>{
+    BACKEND = {
+        async registerChunk (chunk, params) {
+            let chunkPath = getPathFromScript(chunk);
+            let chunkUrl = getUrlFromScript(chunkPath);
+            const resolver = getOrCreateResolver(chunkUrl);
+            resolver.resolve();
+            if (params == null) {
+                return;
+            }
+            for (const otherChunkData of params.otherChunks){
+                const otherChunkPath = getChunkPath(otherChunkData);
+                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
+                // Chunk might have started loading, so we want to avoid triggering another load.
+                getOrCreateResolver(otherChunkUrl);
+            }
+            // This waits for chunks to be loaded, but also marks included items as available.
+            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
+            if (params.runtimeModuleIds.length > 0) {
+                for (const moduleId of params.runtimeModuleIds){
+                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
+                }
+            }
+        },
+        /**
+     * Loads the given chunk, and returns a promise that resolves once the chunk
+     * has been loaded.
+     */ loadChunkCached (sourceType, chunkUrl) {
+            return doLoadChunk(sourceType, chunkUrl);
+        }
+    };
+    function getOrCreateResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                retryAttempts: 0,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        return resolver;
+    }
+    /**
+   * Rejects a chunk resolver and drops it from the cache.
+   * We don't want to cache failed chunk loads: a later
+   * request for the same chunk should try again.
+   */ function rejectChunkResolver(chunkUrl, resolver, error) {
+        if (chunkResolvers.get(chunkUrl) === resolver) {
+            chunkResolvers.delete(chunkUrl);
+        }
+        resolver.reject(error);
+    }
+    function getChunkLoadRetryDelayMs() {
+        const jitter = Math.floor(Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1));
+        return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter;
+    }
+    function isRetryableChunkLoadError(error) {
+        return error == null || error instanceof DOMException && error.name === 'NetworkError';
+    }
+    /**
+   * Handles a failed chunk load: retries the load once after a short delay.
+   */ function onChunkLoadError(sourceType, chunkUrl, resolver, error, reload) {
+        if (!isRetryableChunkLoadError(error) || resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS || chunkResolvers.get(chunkUrl) !== resolver) {
+            rejectChunkResolver(chunkUrl, resolver, error);
+            return;
+        }
+        resolver.retryAttempts++;
+        setTimeout(()=>{
+            // if this chunk is being fetched multiple times, and one of those
+            // attempts succeeds. or, if this chunk has another resolver
+            // mapped to it - it's safe to skip retrying.
+            if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {
+                return;
+            }
+            if (reload) {
+                reload();
+            } else {
+                resolver.loadingStarted = false;
+                doLoadChunk(sourceType, chunkUrl);
+            }
+        }, getChunkLoadRetryDelayMs());
+    }
+    /**
+   * Loads the given chunk, and returns a promise that resolves once the chunk
+   * has been loaded.
+   */ function doLoadChunk(sourceType, chunkUrl) {
+        const resolver = getOrCreateResolver(chunkUrl);
+        if (resolver.loadingStarted) {
+            return resolver.promise;
+        }
+        if (sourceType === SourceType.Runtime) {
+            // CSS chunks do not register themselves, and as such must be marked as
+            // loaded instantly.
+            resolver.loadingStarted = true;
+            if (isCss(chunkUrl)) {
+                if (typeof importScripts !== 'function') {
+                    const decodedChunkUrl = decodeURI(chunkUrl);
+                    const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                    if (previousLinks.length === 0) {
+                        const link = document.createElement('link');
+                        link.rel = 'stylesheet';
+                        link.crossOrigin = CROSS_ORIGIN;
+                        link.href = chunkUrl;
+                        link.onerror = ()=>{
+                            resolver.reject();
+                        };
+                        link.onload = ()=>{
+                            resolver.resolve();
+                        };
+                        document.head.appendChild(link);
+                        return resolver.promise;
+                    }
+                }
+                resolver.resolve();
+                return resolver.promise;
+            }
+            // Runtime JS chunks are expected to be present in the DOM already.
+            // Load it first
+            if (typeof importScripts !== 'function') {
+                const decodedChunkUrl = decodeURI(chunkUrl);
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            resolver.reject();
+                        });
+                    }
+                    return resolver.promise;
+                }
+            }
+        // If it wasn't present in the DOM, fallback to loading logic.
+        }
+        if (typeof importScripts === 'function') {
+            // We're in a web worker
+            if (isCss(chunkUrl)) {
+            // ignore
+            } else if (isJs(chunkUrl)) {
+                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
+                try {
+                    importScripts(chunkUrl);
+                } catch (error) {
+                    onChunkLoadError(sourceType, chunkUrl, resolver, error);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
+            }
+        } else {
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length > 0) {
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolver.resolve();
+                } else {
+                    const createLink = ()=>{
+                        const link = document.createElement('link');
+                        link.rel = 'stylesheet';
+                        link.crossOrigin = CROSS_ORIGIN;
+                        link.href = chunkUrl;
+                        link.onerror = ()=>{
+                            // Re-insert a fresh tag at the same position on retry to preserve
+                            // cascade order.
+                            const anchor = document.createComment('');
+                            link.replaceWith(anchor);
+                            onChunkLoadError(sourceType, chunkUrl, resolver, undefined, ()=>anchor.replaceWith(createLink()));
+                        };
+                        link.onload = ()=>{
+                            // CSS chunks do not register themselves, and as such must be marked as
+                            // loaded instantly.
+                            resolver.resolve();
+                        };
+                        return link;
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(createLink());
+                }
+            } else if (isJs(chunkUrl)) {
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            // Drop the failed tag so a retry can re-add it cleanly.
+                            script.remove();
+                            onChunkLoadError(sourceType, chunkUrl, resolver);
+                        }, {
+                            once: true
+                        });
+                    }
+                } else {
+                    const script = document.createElement('script');
+                    script.crossOrigin = CROSS_ORIGIN;
+                    script.src = chunkUrl;
+                    // We'll only mark the chunk as loaded once the script has been executed,
+                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
+                    // this branch.
+                    script.onerror = ()=>{
+                        // Drop the failed tag so a retry can re-add it cleanly.
+                        script.remove();
+                        onChunkLoadError(sourceType, chunkUrl, resolver);
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(script);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        }
+        resolver.loadingStarted = true;
+        return resolver.promise;
+    }
+})();
+/**
+ * This file contains the runtime code specific to the Turbopack development
+ * ECMAScript DOM runtime.
+ *
+ * It will be appended to the base development runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
+/// <reference path="../base/dev-base.ts" />
+/// <reference path="./runtime-backend-dom.ts" />
+/// <reference path="../../../shared/require-type.d.ts" />
+let DEV_BACKEND;
+(()=>{
+    DEV_BACKEND = {
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // Strip query string so we match links regardless of cache-busting
+            // params (e.g. ?ts=) that may differ between HMR updates.
+            const baseChunkUrl = chunkUrl.split('?')[0];
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
+                }
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        },
+        reloadChunk (chunkUrl) {
+            return new Promise((resolve, reject)=>{
+                if (!isCss(chunkUrl)) {
+                    reject(new Error('The DOM backend can only reload CSS chunks'));
+                    return;
+                }
+                // Strip query string so we match links regardless of cache-busting
+                // params (e.g. ?ts=) that may differ between HMR updates.
+                const baseChunkUrl = chunkUrl.split('?')[0];
+                const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
+                if (previousLinks.length === 0) {
+                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
+                    return;
+                }
+                const link = document.createElement('link');
+                link.rel = 'stylesheet';
+                link.crossOrigin = CROSS_ORIGIN;
+                if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
+                    // Firefox won't reload CSS files that were previously loaded on the
+                    // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
+                    //
+                    // Safari serves cached CSS when a <link rel=preload> exists for the
+                    // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726
+                    //
+                    // Replace or add a fresh `ts` cache-busting param without
+                    // discarding other query parameters that may already be present.
+                    const url = new URL(chunkUrl, location.origin);
+                    // Reduced timer precision in some browers could lead to an update getting dropped
+                    // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).
+                    // So trust that the server is only updating us when it is important and use a
+                    // random number to bust the cache.
+                    url.searchParams.set('ts', `${Date.now()}.${Math.random()}`);
+                    link.href = url.pathname + url.search;
+                } else {
+                    link.href = chunkUrl;
+                }
+                link.onerror = ()=>{
+                    reject();
+                };
+                link.onload = ()=>{
+                    // First load the new CSS, then remove the old ones. This prevents visible
+                    // flickering that would happen in-between removing the previous CSS and
+                    // loading the new one.
+                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolve();
+                };
+                // Make sure to insert the new CSS right after the previous one, so that
+                // its precedence is higher.
+                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
+            });
+        },
+        restart: ()=>self.location.reload()
+    };
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
+    }
+})();
+function _eval({ code, url, map }) {
+    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX)}`;
+    if (map) {
+        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
+        // See https://stackoverflow.com/a/26603875
+        unescape(encodeURIComponent(map)))}`;
+    }
+    // eslint-disable-next-line no-eval
+    return eval(code);
+}
+var chunksToRegister = globalThis["TURBOPACK"];
+globalThis["TURBOPACK"] = { push: registerChunk };
+chunksToRegister.forEach(registerChunk);
+var chunkListsToRegister = globalThis["TURBOPACK_CHUNK_LISTS"] || [];
+globalThis["TURBOPACK_CHUNK_LISTS"] = { push: registerChunkList };
+chunkListsToRegister.forEach(registerChunkList);
+})();
\ No newline at end of file
diff --git a/next.js b/next.js
index 617586347..93353e10d 160000
--- a/next.js
+++ b/next.js
@@ -1 +1 @@
-Subproject commit 61758634754c1d6af7ad8fa1725c7af1b4d633c8
+Subproject commit 93353e10d56dd1f49ecb63da1a6ffd26495e6b51
diff --git a/packages/pack-shared/src/config.ts b/packages/pack-shared/src/config.ts
index 5d9fef49c..d5710c227 100644
--- a/packages/pack-shared/src/config.ts
+++ b/packages/pack-shared/src/config.ts
@@ -344,6 +344,12 @@ export interface ConfigComplete {
   pluginRuntimeStrategy?: "workerThreads" | "childProcesses";
   persistentCaching?: boolean;
   turbopackMemoryEviction?: boolean | "full";
+  /**
+   * Persist Turbopack's development cache periodically in the background.
+   * Disable this for very large graphs where snapshot work can contend with HMR.
+   * @default true
+   */
+  turbopackBackgroundPersistence?: boolean;
   nodePolyfill?: boolean;
   mdx?: MdxOptions;
   devServer?: DevServerConfig;
diff --git a/packages/pack/config_schema.json b/packages/pack/config_schema.json
index 870e5473c..453f4e360 100644
--- a/packages/pack/config_schema.json
+++ b/packages/pack/config_schema.json
@@ -233,6 +233,13 @@
           "type": "null"
         }
       ]
+    },
+    "turbopackBackgroundPersistence": {
+      "description": "Persist Turbopack's development cache periodically in the background. Disable this for very large graphs where snapshot work can contend with HMR.",
+      "type": [
+        "boolean",
+        "null"
+      ]
     }
   },
   "definitions": {
@@ -1901,4 +1908,4 @@
       ]
     }
   }
-}
\ No newline at end of file
+}
diff --git a/packages/pack/src/__test__/env.test.ts b/packages/pack/src/__test__/env.test.ts
new file mode 100644
index 000000000..21d9e3fb7
--- /dev/null
+++ b/packages/pack/src/__test__/env.test.ts
@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import {
+  normalizeBuildTurbopackMemoryEviction,
+  normalizeDevTurbopackMemoryEviction,
+  shouldShutdownDevTurbopackProject,
+  shouldUseDevTurbopackBackgroundPersistence,
+} from "../utils/env";
+
+describe("normalizeDevTurbopackMemoryEviction", () => {
+  it.each([undefined, "1", "true"])(
+    "keeps the existing full default when config is unset and env is %s",
+    (rawEnv) => {
+      expect(normalizeDevTurbopackMemoryEviction(undefined, rawEnv)).toBe(
+        "full",
+      );
+    },
+  );
+
+  it.each(["0", "false"])(
+    "allows env=%s to explicitly disable eviction",
+    (rawEnv) => {
+      expect(normalizeDevTurbopackMemoryEviction(undefined, rawEnv)).toBe(
+        "off",
+      );
+    },
+  );
+
+  it.each([true, "full"] as const)(
+    "allows config=%s to explicitly enable full eviction",
+    (value) => {
+      expect(normalizeDevTurbopackMemoryEviction(value, "0")).toBe("full");
+    },
+  );
+
+  it("keeps an explicit false config authoritative over env", () => {
+    expect(normalizeDevTurbopackMemoryEviction(false, "1")).toBe("off");
+  });
+});
+
+describe("normalizeBuildTurbopackMemoryEviction", () => {
+  it.each([undefined, "1", "true"])(
+    "keeps the existing full default when config is unset and env is %s",
+    (rawEnv) => {
+      expect(normalizeBuildTurbopackMemoryEviction(undefined, rawEnv)).toBe(
+        "full",
+      );
+    },
+  );
+
+  it.each(["0", "false"])("keeps env=%s as an explicit opt-out", (rawEnv) => {
+    expect(normalizeBuildTurbopackMemoryEviction(undefined, rawEnv)).toBe(
+      "off",
+    );
+  });
+
+  it("keeps an explicit false config authoritative over env", () => {
+    expect(normalizeBuildTurbopackMemoryEviction(false, "1")).toBe("off");
+  });
+});
+
+describe("shouldUseDevTurbopackBackgroundPersistence", () => {
+  it.each([undefined, "1", "true"])(
+    "keeps periodic background snapshots by default when env is %s",
+    (rawEnv) => {
+      expect(
+        shouldUseDevTurbopackBackgroundPersistence(undefined, rawEnv),
+      ).toBe(true);
+    },
+  );
+
+  it.each(["0", "false"])(
+    "allows env=%s to opt into shutdown-only persistence",
+    (rawEnv) => {
+      expect(
+        shouldUseDevTurbopackBackgroundPersistence(undefined, rawEnv),
+      ).toBe(false);
+    },
+  );
+
+  it("keeps an explicit false config authoritative over env", () => {
+    expect(shouldUseDevTurbopackBackgroundPersistence(false, "1")).toBe(false);
+  });
+
+  it("keeps an explicit true config authoritative over env", () => {
+    expect(shouldUseDevTurbopackBackgroundPersistence(true, "0")).toBe(true);
+  });
+
+  it("treats schema null as an unset optional value", () => {
+    expect(shouldUseDevTurbopackBackgroundPersistence(null, undefined)).toBe(
+      true,
+    );
+    expect(shouldUseDevTurbopackBackgroundPersistence(null, "0")).toBe(false);
+  });
+});
+
+describe("shouldShutdownDevTurbopackProject", () => {
+  it.each([
+    [undefined, true, true, false],
+    [true, true, true, true],
+    [undefined, true, false, true],
+    [false, false, false, false],
+  ] as const)(
+    "uses configured=%s normalized=%s background=%s => %s",
+    (configured, normalized, background, expected) => {
+      expect(
+        shouldShutdownDevTurbopackProject(configured, normalized, background),
+      ).toBe(expected);
+    },
+  );
+});
diff --git a/packages/pack/src/__test__/hmr.test.ts b/packages/pack/src/__test__/hmr.test.ts
index 9f3e95623..99feeca3c 100644
--- a/packages/pack/src/__test__/hmr.test.ts
+++ b/packages/pack/src/__test__/hmr.test.ts
@@ -1,5 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
 import {
+  consumeHmrSubscription,
+  createHmrTimingReporter,
+  createSharedHmrSubscriptionRegistry,
   deleteClientSubscriptionIfCurrent,
   enqueueTurbopackUpdateForClient,
   isCurrentClientSubscription,
@@ -7,6 +10,119 @@ import {
   unsubscribeClient,
 } from "../core/hmrClientState";
 
+describe("HMR timing reporter", () => {
+  it("does not attribute the initial project batch to the first HMR update", () => {
+    let now = 0;
+    const reporter = createHmrTimingReporter(() => now);
+
+    reporter.start();
+    now = 60_000;
+
+    expect(reporter.markHmrUpdate()).toBeUndefined();
+  });
+
+  it("reports time to the first HMR payload after the initial batch", () => {
+    let now = 0;
+    const reporter = createHmrTimingReporter(() => now);
+
+    reporter.start();
+    reporter.end();
+    now = 100;
+    reporter.start();
+    now = 425;
+
+    expect(reporter.markHmrUpdate()).toBe(325);
+    expect(reporter.markHmrUpdate()).toBeUndefined();
+  });
+
+  it("does not report an update outside an active project batch", () => {
+    const reporter = createHmrTimingReporter(() => 100);
+
+    expect(reporter.markHmrUpdate()).toBeUndefined();
+    reporter.start();
+    reporter.end();
+    expect(reporter.markHmrUpdate()).toBeUndefined();
+  });
+
+  it("keeps timing a payload that is sent just after its batch ends", () => {
+    let now = 0;
+    const reporter = createHmrTimingReporter(() => now);
+
+    reporter.start();
+    reporter.end();
+    now = 100;
+    reporter.start();
+    now = 425;
+    reporter.end();
+    now = 450;
+
+    expect(reporter.markHmrUpdate()).toBe(350);
+  });
+
+  it("uses the latest batch when a newer one starts before a payload", () => {
+    let now = 0;
+    const reporter = createHmrTimingReporter(() => now);
+
+    reporter.start();
+    reporter.end();
+    now = 100;
+    reporter.start();
+    reporter.end();
+    now = 300;
+    reporter.start();
+    now = 350;
+
+    expect(reporter.markHmrUpdate()).toBe(50);
+  });
+});
+
+async function* hmrEvents(...events: any[]) {
+  yield* events;
+}
+
+function createControlledHmrEvents<Result>() {
+  let settled = false;
+  let pending:
+    | {
+        resolve: (result: IteratorResult<Result>) => void;
+        reject: (error: unknown) => void;
+      }
+    | undefined;
+
+  const iterator: AsyncIterableIterator<Result> & {
+    emit(result: Result): void;
+    fail(error: unknown): void;
+  } = {
+    next: vi.fn(() => {
+      if (settled) return Promise.resolve({ done: true, value: undefined });
+      return new Promise((resolve, reject) => {
+        pending = { resolve, reject };
+      });
+    }),
+    return: vi.fn(() => {
+      settled = true;
+      pending?.resolve({ done: true, value: undefined });
+      pending = undefined;
+      return Promise.resolve({ done: true, value: undefined });
+    }),
+    emit(result) {
+      const current = pending;
+      pending = undefined;
+      current?.resolve({ done: false, value: result });
+    },
+    fail(error) {
+      const current = pending;
+      pending = undefined;
+      current?.reject(error);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+
+  return iterator;
+}
+
 function createClientState() {
   return {
     hmrPayloads: new Map(),
@@ -64,6 +180,239 @@ describe("HMR client delivery", () => {
 });
 
 describe("HMR subscription lifecycle", () => {
+  it("shares one underlying iterator for subscribers to the same id", async () => {
+    const baseline = { type: "issues", issues: [] };
+    const update = { type: "partial", issues: [], instruction: {} };
+    const createSubscription = vi.fn(() => hmrEvents(baseline, update));
+    const registry = createSharedHmrSubscriptionRegistry(createSubscription);
+    const clientA = { onIssues: vi.fn(), onUpdate: vi.fn() };
+    const clientB = { onIssues: vi.fn(), onUpdate: vi.fn() };
+
+    registry.subscribe("route", clientA);
+    registry.subscribe("route", clientB);
+    await vi.waitFor(() => {
+      expect(clientA.onUpdate).toHaveBeenCalledWith(update);
+      expect(clientB.onUpdate).toHaveBeenCalledWith(update);
+    });
+
+    expect(createSubscription).toHaveBeenCalledExactlyOnceWith("route");
+    expect(clientA.onIssues).toHaveBeenCalledWith([]);
+    expect(clientB.onIssues).toHaveBeenCalledWith([]);
+  });
+
+  it("returns the shared iterator only after its last subscriber leaves", async () => {
+    const iterator = createControlledHmrEvents<any>();
+    const registry = createSharedHmrSubscriptionRegistry(() => iterator);
+    const subscriptionA = registry.subscribe("route", {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+    });
+    const subscriptionB = registry.subscribe("route", {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+    });
+
+    await subscriptionA.return?.();
+    expect(iterator.return).not.toHaveBeenCalled();
+
+    await subscriptionB.return?.();
+    expect(iterator.return).toHaveBeenCalledOnce();
+  });
+
+  it("seeds a joining subscriber with latest issues without replaying a partial", async () => {
+    const iterator = createControlledHmrEvents<any>();
+    const registry = createSharedHmrSubscriptionRegistry(() => iterator);
+    const clientA = { onIssues: vi.fn(), onUpdate: vi.fn() };
+    const clientB = { onIssues: vi.fn(), onUpdate: vi.fn() };
+
+    registry.subscribe("route", clientA);
+    iterator.emit({
+      type: "partial",
+      issues: [{ severity: "warning", message: "latest" }],
+      instruction: {},
+    });
+    await vi.waitFor(() => expect(clientA.onUpdate).toHaveBeenCalledOnce());
+
+    registry.subscribe("route", clientB);
+
+    expect(clientB.onIssues).toHaveBeenCalledExactlyOnceWith([
+      { severity: "warning", message: "latest" },
+    ]);
+    expect(clientB.onUpdate).not.toHaveBeenCalled();
+  });
+
+  it("isolates issue snapshots between subscribers", async () => {
+    const iterator = createControlledHmrEvents<any>();
+    const registry = createSharedHmrSubscriptionRegistry(() => iterator);
+    const clientA = {
+      onIssues: vi.fn((issues: any[]) => issues.push({ severity: "fatal" })),
+      onUpdate: vi.fn(),
+    };
+    const clientB = { onIssues: vi.fn(), onUpdate: vi.fn() };
+
+    registry.subscribe("route", clientA);
+    registry.subscribe("route", clientB);
+    iterator.emit({ type: "issues", issues: [{ severity: "warning" }] });
+    await vi.waitFor(() => expect(clientB.onIssues).toHaveBeenCalledOnce());
+
+    expect(clientB.onIssues).toHaveBeenCalledWith([{ severity: "warning" }]);
+  });
+
+  it("keeps one subscriber callback failure from stopping other clients", async () => {
+    const iterator = createControlledHmrEvents<any>();
+    const registry = createSharedHmrSubscriptionRegistry(() => iterator);
+    const clientA = {
+      onIssues: vi.fn(() => {
+        throw new Error("client state failed");
+      }),
+      onUpdate: vi.fn(),
+      onError: vi.fn(),
+    };
+    const clientB = { onIssues: vi.fn(), onUpdate: vi.fn(), onError: vi.fn() };
+    const update = { type: "partial", issues: [], instruction: {} };
+
+    registry.subscribe("route", clientA);
+    registry.subscribe("route", clientB);
+    iterator.emit(update);
+    await vi.waitFor(() => expect(clientB.onUpdate).toHaveBeenCalledOnce());
+
+    expect(clientA.onError).toHaveBeenCalledOnce();
+    expect(clientB.onError).not.toHaveBeenCalled();
+    expect(clientB.onUpdate).toHaveBeenCalledWith(update);
+  });
+
+  it("does not let an old iterator error tear down its replacement", async () => {
+    const oldIterator = createControlledHmrEvents<any>();
+    oldIterator.return = vi.fn(() =>
+      Promise.resolve({ done: true, value: undefined }),
+    );
+    const replacementIterator = createControlledHmrEvents<any>();
+    const createSubscription = vi
+      .fn()
+      .mockReturnValueOnce(oldIterator)
+      .mockReturnValueOnce(replacementIterator);
+    const registry = createSharedHmrSubscriptionRegistry(createSubscription);
+    const oldClient = { onIssues: vi.fn(), onUpdate: vi.fn() };
+    const replacementClient = {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+      onError: vi.fn(),
+    };
+
+    const oldSubscription = registry.subscribe("route", oldClient);
+    await oldSubscription.return?.();
+    registry.subscribe("route", replacementClient);
+    oldIterator.fail(new Error("stale iterator failed"));
+    replacementIterator.emit({
+      type: "partial",
+      issues: [],
+      instruction: { type: "replacement" },
+    });
+    await vi.waitFor(() =>
+      expect(replacementClient.onUpdate).toHaveBeenCalledOnce(),
+    );
+
+    expect(createSubscription).toHaveBeenCalledTimes(2);
+    expect(replacementClient.onError).not.toHaveBeenCalled();
+  });
+
+  it("reports a shared iterator error to every current subscriber", async () => {
+    const iterator = createControlledHmrEvents<any>();
+    const registry = createSharedHmrSubscriptionRegistry(() => iterator);
+    const clientA = {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+      onError: vi.fn(),
+      onComplete: vi.fn(),
+    };
+    const clientB = {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+      onError: vi.fn(),
+      onComplete: vi.fn(),
+    };
+    const error = new Error("subscription failed");
+
+    registry.subscribe("route", clientA);
+    registry.subscribe("route", clientB);
+    iterator.fail(error);
+    await vi.waitFor(() => {
+      expect(clientA.onComplete).toHaveBeenCalledOnce();
+      expect(clientB.onComplete).toHaveBeenCalledOnce();
+    });
+
+    expect(clientA.onError).toHaveBeenCalledExactlyOnceWith(error);
+    expect(clientB.onError).toHaveBeenCalledExactlyOnceWith(error);
+  });
+
+  it("absorbs shared iterator cleanup failures and permits replacement", async () => {
+    const failingIterator = createControlledHmrEvents<any>();
+    const finish = failingIterator.return!.bind(failingIterator);
+    failingIterator.return = vi.fn(async () => {
+      await finish();
+      throw new Error("cleanup failed");
+    });
+    const replacementIterator = createControlledHmrEvents<any>();
+    const createSubscription = vi
+      .fn()
+      .mockReturnValueOnce(failingIterator)
+      .mockReturnValueOnce(replacementIterator);
+    const registry = createSharedHmrSubscriptionRegistry(createSubscription);
+    const subscription = registry.subscribe("route", {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+    });
+
+    await expect(subscription.return?.()).resolves.toBeUndefined();
+    registry.subscribe("route", {
+      onIssues: vi.fn(),
+      onUpdate: vi.fn(),
+    });
+
+    expect(createSubscription).toHaveBeenCalledTimes(2);
+  });
+
+  it("processes an initial issues baseline without forwarding an update", async () => {
+    const onResult = vi.fn();
+    const onUpdate = vi.fn();
+
+    await consumeHmrSubscription(
+      hmrEvents({ type: "issues", issues: [] }),
+      onResult,
+      onUpdate,
+    );
+
+    expect(onResult).toHaveBeenCalledOnce();
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+
+  it("forwards a real partial update in the first subscription result", async () => {
+    const update = { type: "partial", issues: [], instruction: {} };
+    const onResult = vi.fn();
+    const onUpdate = vi.fn();
+
+    await consumeHmrSubscription(hmrEvents(update), onResult, onUpdate);
+
+    expect(onResult).toHaveBeenCalledWith(update);
+    expect(onUpdate).toHaveBeenCalledExactlyOnceWith(update);
+  });
+
+  it("does not drop a buffered update immediately after the baseline", async () => {
+    const baseline = { type: "issues", issues: [] };
+    const restart = { type: "restart", issues: [] };
+    const onResult = vi.fn();
+    const onUpdate = vi.fn();
+
+    await consumeHmrSubscription(
+      hmrEvents(baseline, restart),
+      onResult,
+      onUpdate,
+    );
+
+    expect(onResult.mock.calls).toEqual([[baseline], [restart]]);
+    expect(onUpdate).toHaveBeenCalledExactlyOnceWith(restart);
+  });
+
   it("safely cleans every subscription when a client disconnects", async () => {
     const remainingSizes: number[] = [];
     const subscriptions = new Map([
diff --git a/packages/pack/src/__test__/serveStats.test.ts b/packages/pack/src/__test__/serveStats.test.ts
index 026f26cbd..ea3e53cdc 100644
--- a/packages/pack/src/__test__/serveStats.test.ts
+++ b/packages/pack/src/__test__/serveStats.test.ts
@@ -105,6 +105,10 @@ describe("serve stats", () => {
             "name": "src_lazy_<hash>.js",
             "type": "asset",
           },
+          {
+            "name": "src_lazy_<hash>.js",
+            "type": "asset",
+          },
           {
             "name": "src_lazy_<hash>.js.map",
             "type": "asset",
@@ -121,12 +125,14 @@ describe("serve stats", () => {
               "main.js",
               "src_index_<hash>.js",
               "src_lazy_<hash>.js",
+              "src_lazy_<hash>.js",
             ],
             "chunks": [
               "_root-of-the-server___<hash>.js",
               "main.js",
               "src_index_<hash>.js",
               "src_lazy_<hash>.js",
+              "src_lazy_<hash>.js",
             ],
           },
         },
diff --git a/packages/pack/src/commands/build.ts b/packages/pack/src/commands/build.ts
index 44b71afe1..62404c89f 100644
--- a/packages/pack/src/commands/build.ts
+++ b/packages/pack/src/commands/build.ts
@@ -12,7 +12,7 @@ import { blockStdout, getPackPath } from "../utils/common";
 import {
   isPersistentCachingEnabled,
   isTruthyEnv,
-  normalizeTurbopackMemoryEviction,
+  normalizeBuildTurbopackMemoryEviction,
 } from "../utils/env";
 import { findRootDir } from "../utils/findRoot";
 import { getInitialAssetsFromEndpointPaths } from "../utils/getInitialAssets";
@@ -55,8 +55,9 @@ async function buildInternal(
   const persistentCaching = isPersistentCachingEnabled(
     bundleOptions.config.persistentCaching,
   );
-  const turbopackMemoryEviction = normalizeTurbopackMemoryEviction(
+  const turbopackMemoryEviction = normalizeBuildTurbopackMemoryEviction(
     bundleOptions.config.turbopackMemoryEviction,
+    process.env.TURBO_ENGINE_EVICT_AFTER_SNAPSHOT,
   ) as MemoryEvictionMode;
   const smallPreallocation = isTruthyEnv(
     process.env.UTOO_TURBOPACK_SMALL_PREALLOCATION,
diff --git a/packages/pack/src/core/hmr.ts b/packages/pack/src/core/hmr.ts
index c7b8c623d..4c322e702 100644
--- a/packages/pack/src/core/hmr.ts
+++ b/packages/pack/src/core/hmr.ts
@@ -22,7 +22,9 @@ import { debounce, getPackPath, processIssues } from "../utils/common";
 import {
   isPersistentCachingEnabled,
   isTruthyEnv,
-  normalizeTurbopackMemoryEviction,
+  normalizeDevTurbopackMemoryEviction,
+  shouldShutdownDevTurbopackProject,
+  shouldUseDevTurbopackBackgroundPersistence,
 } from "../utils/env";
 import { getInitialAssetsFromEndpointPaths } from "../utils/getInitialAssets";
 import { processHtmlEntry } from "../utils/htmlEntry";
@@ -31,9 +33,11 @@ import { normalizePath } from "../utils/normalizePath";
 import { useWorkerThreads } from "../utils/runtimePluginStratety";
 import { validateEntryPaths } from "../utils/validateEntry";
 import {
+  createHmrTimingReporter,
+  createSharedHmrSubscriptionRegistry,
   deleteClientSubscriptionIfCurrent,
   enqueueTurbopackUpdateForClient,
-  isCurrentClientSubscription,
+  type ReturnableSubscription,
   unsubscribeAllClientSubscriptions,
   unsubscribeClient,
 } from "./hmrClientState";
@@ -112,7 +116,7 @@ export type StartBuilding = (id: string, forceRebuild: boolean) => () => void;
 export type ClientState = {
   hmrPayloads: Map<string, HMR_ACTION_TYPES>;
   turbopackUpdates: TurbopackUpdate[];
-  subscriptions: Map<string, AsyncIterator<any>>;
+  subscriptions: Map<string, ReturnableSubscription>;
   clientIssues: EntryIssuesMap;
 };
 
@@ -180,12 +184,21 @@ export async function createHotReloader(
   const persistentCaching = isPersistentCachingEnabled(
     bundleOptions.config.persistentCaching,
   );
-  const turbopackMemoryEviction = normalizeTurbopackMemoryEviction(
+  const turbopackMemoryEviction = normalizeDevTurbopackMemoryEviction(
     bundleOptions.config.turbopackMemoryEviction,
+    process.env.TURBO_ENGINE_EVICT_AFTER_SNAPSHOT,
   ) as MemoryEvictionMode;
   const smallPreallocation = isTruthyEnv(
     process.env.UTOO_TURBOPACK_SMALL_PREALLOCATION,
   );
+  const backgroundPersistence = shouldUseDevTurbopackBackgroundPersistence(
+    (
+      bundleOptions.config as typeof bundleOptions.config & {
+        turbopackBackgroundPersistence?: boolean;
+      }
+    ).turbopackBackgroundPersistence,
+    process.env.UTOO_TURBOPACK_BACKGROUND_PERSISTENCE,
+  );
   const persistentCacheLock = await acquirePersistentCacheLock(
     resolvedProjectPath,
     "utoo pack dev",
@@ -239,6 +252,10 @@ export async function createHotReloader(
         persistentCaching,
         turbopackMemoryEviction,
         smallPreallocation,
+        // A large single-page graph can spend tens of seconds serializing a
+        // background snapshot and starve HMR. Keep reading the persistent cache,
+        // but defer writes until shutdown unless explicitly opted back in.
+        isShortSession: persistentCaching && !backgroundPersistence,
       },
     );
   } catch (error) {
@@ -253,11 +270,14 @@ export async function createHotReloader(
     (resolve) => (currentEntriesHandlingResolve = resolve),
   );
 
-  let hmrEventHappened = false;
   let hmrHash = 0;
+  const hmrTimingReporter = createHmrTimingReporter();
 
   const clients = new Set<WSLike>();
   const clientStates = new WeakMap<WSLike, ClientState>();
+  const hmrSubscriptions = createSharedHmrSubscriptionRegistry<
+    TurbopackResult<TurbopackUpdate>
+  >((id) => project.hmrEvents(id));
   const currentEntryIssues: EntryIssuesMap = new Map();
   const backgroundWatchSubscriptions = new Set<
     AsyncIterableIterator<TurbopackResult>
@@ -280,6 +300,7 @@ export async function createHotReloader(
       return;
     }
 
+    let sentTurbopackUpdate = false;
     for (const client of clients) {
       const state = clientStates.get(client);
       if (!state) {
@@ -287,7 +308,7 @@ export async function createHotReloader(
       }
 
       if (hasBlockingIssues(state.clientIssues)) {
-        return;
+        continue;
       }
 
       for (const payload of state.hmrPayloads.values()) {
@@ -301,6 +322,18 @@ export async function createHotReloader(
           data: state.turbopackUpdates,
         });
         state.turbopackUpdates.length = 0;
+        sentTurbopackUpdate = true;
+      }
+    }
+
+    if (sentTurbopackUpdate) {
+      const duration = hmrTimingReporter.markHmrUpdate();
+      if (duration !== undefined) {
+        const timeMessage =
+          duration > 2000
+            ? `${Math.round(duration / 100) / 10}s`
+            : `${duration}ms`;
+        console.log(`HMR payload sent in ${timeMessage}`);
       }
     }
   }
@@ -308,8 +341,6 @@ export async function createHotReloader(
 
   function sendTurbopackMessage(client: WSLike, payload: TurbopackUpdate) {
     enqueueTurbopackUpdateForClient(clientStates, client, payload);
-
-    hmrEventHappened = true;
     sendEnqueuedMessagesDebounce();
   }
 
@@ -403,7 +434,6 @@ export async function createHotReloader(
         }
 
         await writeOutputToDisk(entrypoint);
-        hmrEventHappened = true;
       })
       .finally(() => {
         if (shouldCreateWebpackStats) {
@@ -462,7 +492,6 @@ export async function createHotReloader(
               processIssues(currentEntryIssues, issueKey, data, false, true);
 
               if (hasBlockingResultIssues(data)) {
-                hmrEventHappened = true;
                 sendEnqueuedMessagesDebounce();
                 continue;
               }
@@ -493,58 +522,53 @@ export async function createHotReloader(
     );
   }
 
-  async function subscribeToHmrEvents(client: WSLike, id: string) {
+  function subscribeToHmrEvents(client: WSLike, id: string) {
     const state = clientStates.get(client);
     if (!state || state.subscriptions.has(id)) {
       return;
     }
 
-    const subscription = project!.hmrEvents(id);
-    state.subscriptions.set(id, subscription);
     const issueKey = getClientIssueKey(id);
-
-    // The subscription will always emit once, which is the initial
-    // computation. This is not a change, so swallow it.
-    try {
-      await subscription.next();
-
-      for await (const data of subscription) {
-        processIssues(state.clientIssues, issueKey, data, false, true);
-        if (data.type !== "issues") {
-          sendTurbopackMessage(client, data);
+    let subscription: ReturnableSubscription;
+    subscription = hmrSubscriptions.subscribe(id, {
+      onIssues(issues) {
+        if (clientStates.get(client) !== state) return;
+        processIssues(state.clientIssues, issueKey, { issues }, false, true);
+      },
+      onUpdate(data) {
+        if (clientStates.get(client) !== state) return;
+        sendTurbopackMessage(client, data);
+      },
+      onError(error) {
+        if (
+          clientStates.get(client) !== state ||
+          state.subscriptions.get(id) !== subscription
+        ) {
+          return;
         }
-      }
-    } catch (e) {
-      if (
-        !isCurrentClientSubscription(
-          clientStates,
-          client,
-          state,
-          id,
-          subscription,
-        )
-      ) {
-        return;
-      }
 
-      // The client might be using an HMR session from a previous server, tell them
-      // to fully reload the page to resolve the issue. We can't use
-      // `hotReloader.send` since that would force every connected client to
-      // reload, only this client is out of date.
-      const reloadAction: ReloadAction = {
-        action: HMR_ACTIONS_SENT_TO_BROWSER.RELOAD,
-        data: `error in HMR event subscription for ${id}: ${e}`,
-      };
-      sendToClient(client, reloadAction);
-      client.close();
-      return;
-    } finally {
-      if (
-        deleteClientSubscriptionIfCurrent(state.subscriptions, id, subscription)
-      ) {
-        state.clientIssues.delete(issueKey);
-      }
-    }
+        // The client might be using an HMR session from a previous server, tell
+        // only subscribers of this resource to reload.
+        const reloadAction: ReloadAction = {
+          action: HMR_ACTIONS_SENT_TO_BROWSER.RELOAD,
+          data: `error in HMR event subscription for ${id}: ${error}`,
+        };
+        sendToClient(client, reloadAction);
+        client.close();
+      },
+      onComplete() {
+        if (
+          deleteClientSubscriptionIfCurrent(
+            state.subscriptions,
+            id,
+            subscription,
+          )
+        ) {
+          state.clientIssues.delete(issueKey);
+        }
+      },
+    });
+    state.subscriptions.set(id, subscription);
   }
 
   function unsubscribeFromHmrEvents(client: WSLike, id: string) {
@@ -606,7 +630,7 @@ export async function createHotReloader(
     onHMR(req, socket: Socket, head, onUpgrade) {
       wsServer.handleUpgrade(req, socket, head, (client) => {
         onUpgrade?.(client);
-        const subscriptions: Map<string, AsyncIterator<any>> = new Map();
+        const subscriptions: Map<string, ReturnableSubscription> = new Map();
 
         clients.add(client);
         clientStates.set(client, {
@@ -697,7 +721,7 @@ export async function createHotReloader(
     },
 
     registerClient(ws) {
-      const subscriptions: Map<string, AsyncIterator<any>> = new Map();
+      const subscriptions: Map<string, ReturnableSubscription> = new Map();
       clients.add(ws);
       clientStates.set(ws, {
         hmrPayloads: new Map(),
@@ -805,8 +829,20 @@ export async function createHotReloader(
     async close() {
       closed = true;
       const disposePromise = disposeBackgroundWatchSubscriptions();
+      const clientSubscriptionCleanup = [...clients].map((client) => {
+        const state = clientStates.get(client);
+        return state
+          ? unsubscribeAllClientSubscriptions(state.subscriptions)
+          : Promise.resolve();
+      });
       closePromise ??= (
-        persistentCaching ? project.shutdown() : project.onExit()
+        shouldShutdownDevTurbopackProject(
+          bundleOptions.config.persistentCaching,
+          persistentCaching,
+          backgroundPersistence,
+        )
+          ? project.shutdown()
+          : project.onExit()
       )
         .catch((err) => {
           console.error(err);
@@ -820,7 +856,11 @@ export async function createHotReloader(
       }
       clients.clear();
 
-      await Promise.all([disposePromise, closePromise]);
+      await Promise.all([
+        disposePromise,
+        closePromise,
+        ...clientSubscriptionCleanup,
+      ]);
     },
   };
 
@@ -836,6 +876,7 @@ export async function createHotReloader(
     for await (const updateMessage of project.updateInfoSubscribe(30)) {
       switch (updateMessage.updateType) {
         case "start": {
+          hmrTimingReporter.start();
           hotReloader.send({ action: HMR_ACTIONS_SENT_TO_BROWSER.BUILDING });
           console.log("Compiling...");
           break;
@@ -863,13 +904,7 @@ export async function createHotReloader(
             });
           }
 
-          if (hmrEventHappened) {
-            const time = updateMessage.value!.duration;
-            const timeMessage =
-              time > 2000 ? `${Math.round(time / 100) / 10}s` : `${time}ms`;
-            console.log(`Compiled in ${timeMessage}`);
-            hmrEventHappened = false;
-          }
+          hmrTimingReporter.end();
           break;
         }
         default:
diff --git a/packages/pack/src/core/hmrClientState.ts b/packages/pack/src/core/hmrClientState.ts
index 3336afe23..9f7c5a7d1 100644
--- a/packages/pack/src/core/hmrClientState.ts
+++ b/packages/pack/src/core/hmrClientState.ts
@@ -2,6 +2,159 @@ export interface TurbopackUpdateQueue<Update> {
   turbopackUpdates: Update[];
 }
 
+export function createHmrTimingReporter(now: () => number = Date.now) {
+  let initialBatchFinished = false;
+  let batchStartedAt: number | undefined;
+  let reportedCurrentBatch = false;
+
+  return {
+    start() {
+      batchStartedAt = now();
+      reportedCurrentBatch = false;
+    },
+    end() {
+      if (!initialBatchFinished) {
+        initialBatchFinished = true;
+        batchStartedAt = undefined;
+        reportedCurrentBatch = false;
+      }
+    },
+    markHmrUpdate() {
+      if (
+        !initialBatchFinished ||
+        batchStartedAt === undefined ||
+        reportedCurrentBatch
+      ) {
+        return undefined;
+      }
+      reportedCurrentBatch = true;
+      return Math.max(0, now() - batchStartedAt);
+    },
+  };
+}
+
+export async function consumeHmrSubscription<Result extends { type: string }>(
+  subscription: AsyncIterable<Result>,
+  onResult: (result: Result) => void,
+  onUpdate: (result: Result) => void,
+) {
+  for await (const result of subscription) {
+    onResult(result);
+    if (result.type !== "issues") {
+      onUpdate(result);
+    }
+  }
+}
+
+export interface SharedHmrSubscriber<Result extends { issues: unknown[] }> {
+  onIssues: (issues: Result["issues"]) => void;
+  onUpdate: (result: Result) => void;
+  onError?: (error: unknown) => void;
+  onComplete?: () => void;
+}
+
+export function createSharedHmrSubscriptionRegistry<
+  Result extends { type: string; issues: unknown[] },
+>(createSubscription: (id: string) => AsyncIterableIterator<Result>) {
+  type Subscriber = SharedHmrSubscriber<Result>;
+  type Member = { active: boolean; subscriber: Subscriber };
+  type Entry = {
+    latestIssues?: Result["issues"];
+    subscription: AsyncIterableIterator<Result>;
+    subscribers: Set<Member>;
+  };
+
+  const entries = new Map<string, Entry>();
+
+  const reportSubscriberError = (member: Member, error: unknown) => {
+    if (!member.active) return;
+    try {
+      member.subscriber.onError?.(error);
+    } catch {
+      // A client callback must not terminate the shared project iterator.
+    }
+  };
+
+  const consume = async (id: string, entry: Entry) => {
+    try {
+      for await (const result of entry.subscription) {
+        entry.latestIssues = [...result.issues] as Result["issues"];
+        for (const member of [...entry.subscribers]) {
+          if (!member.active) continue;
+          const { subscriber } = member;
+          try {
+            subscriber.onIssues([...entry.latestIssues] as Result["issues"]);
+            if (member.active && result.type !== "issues") {
+              subscriber.onUpdate(result);
+            }
+          } catch (error) {
+            reportSubscriberError(member, error);
+          }
+        }
+      }
+    } catch (error) {
+      [...entry.subscribers].forEach((member) =>
+        reportSubscriberError(member, error),
+      );
+    } finally {
+      if (entries.get(id) === entry) {
+        entries.delete(id);
+      }
+      entry.subscribers.forEach((member) => {
+        member.active = false;
+        try {
+          member.subscriber.onComplete?.();
+        } catch {
+          // Completion cleanup is isolated per client.
+        }
+      });
+      entry.subscribers.clear();
+    }
+  };
+
+  return {
+    subscribe(id: string, subscriber: Subscriber) {
+      let entry = entries.get(id);
+      let start = false;
+      if (!entry) {
+        entry = {
+          subscription: createSubscription(id),
+          subscribers: new Set(),
+        };
+        entries.set(id, entry);
+        start = true;
+      }
+      const member: Member = { active: true, subscriber };
+      entry.subscribers.add(member);
+      if (entry.latestIssues) {
+        try {
+          subscriber.onIssues([...entry.latestIssues] as Result["issues"]);
+        } catch (error) {
+          reportSubscriberError(member, error);
+        }
+      }
+      if (start) {
+        void consume(id, entry);
+      }
+
+      return {
+        return() {
+          if (!member.active) return;
+
+          member.active = false;
+          entry.subscribers.delete(member);
+          if (entry.subscribers.size > 0) return;
+
+          if (entries.get(id) === entry) {
+            entries.delete(id);
+          }
+          return returnSubscription(entry.subscription);
+        },
+      };
+    },
+  };
+}
+
 export function enqueueTurbopackUpdateForClient<
   Client extends object,
   Update extends { issues: unknown[] },
diff --git a/packages/pack/src/core/types.ts b/packages/pack/src/core/types.ts
index 487aee936..9f766159f 100644
--- a/packages/pack/src/core/types.ts
+++ b/packages/pack/src/core/types.ts
@@ -1,3 +1,4 @@
+import type { RestartUpdate } from "@utoo/pack-shared";
 import {
   HmrIdentifiers,
   NapiIssue,
@@ -42,7 +43,7 @@ export interface PartialUpdate extends BaseUpdate {
   };
 }
 
-export type Update = IssuesUpdate | PartialUpdate;
+export type Update = IssuesUpdate | PartialUpdate | RestartUpdate;
 
 export interface ProjectOptions extends BundleOptions {
   /**
diff --git a/packages/pack/src/utils/env.ts b/packages/pack/src/utils/env.ts
index 4d1af070d..7ea19f423 100644
--- a/packages/pack/src/utils/env.ts
+++ b/packages/pack/src/utils/env.ts
@@ -3,7 +3,7 @@ export function isTruthyEnv(value: string | undefined): boolean {
 }
 
 export function isPersistentCachingEnabled(
-  configuredValue: boolean | undefined,
+  configuredValue: boolean | null | undefined,
 ): boolean {
   return (
     !isTruthyEnv(process.env.DISABLE_PERSISTENT_CACHE?.toLowerCase()) &&
@@ -11,9 +11,38 @@ export function isPersistentCachingEnabled(
   );
 }
 
-export function normalizeTurbopackMemoryEviction(
-  value: boolean | "full" | undefined,
-): "off" | "full" {
+export function shouldUseDevTurbopackBackgroundPersistence(
+  value: boolean | null | undefined,
+  rawEnv: string | undefined,
+): boolean {
+  if (value != null) {
+    return value;
+  }
+  if (rawEnv === undefined) {
+    return true;
+  }
+  return isTruthyEnv(rawEnv);
+}
+
+export function shouldShutdownDevTurbopackProject(
+  configuredPersistentCaching: boolean | null | undefined,
+  persistentCaching: boolean,
+  backgroundPersistence: boolean,
+): boolean {
+  return (
+    persistentCaching &&
+    (configuredPersistentCaching === true || !backgroundPersistence)
+  );
+}
+
+type TurbopackMemoryEvictionConfig = boolean | "full" | undefined;
+type TurbopackMemoryEvictionMode = "off" | "full";
+
+function normalizeTurbopackMemoryEviction(
+  value: TurbopackMemoryEvictionConfig,
+  rawEnv: string | undefined,
+  defaultMode: TurbopackMemoryEvictionMode,
+): TurbopackMemoryEvictionMode {
   if (value === false) {
     return "off";
   }
@@ -21,6 +50,22 @@ export function normalizeTurbopackMemoryEviction(
     return "full";
   }
 
-  const rawEnv = process.env.TURBO_ENGINE_EVICT_AFTER_SNAPSHOT;
-  return rawEnv == null || rawEnv === "1" || rawEnv === "true" ? "full" : "off";
+  if (rawEnv === undefined) {
+    return defaultMode;
+  }
+  return isTruthyEnv(rawEnv) ? "full" : "off";
+}
+
+export function normalizeDevTurbopackMemoryEviction(
+  value: TurbopackMemoryEvictionConfig,
+  rawEnv: string | undefined,
+): TurbopackMemoryEvictionMode {
+  return normalizeTurbopackMemoryEviction(value, rawEnv, "full");
+}
+
+export function normalizeBuildTurbopackMemoryEviction(
+  value: TurbopackMemoryEvictionConfig,
+  rawEnv: string | undefined,
+): TurbopackMemoryEvictionMode {
+  return normalizeTurbopackMemoryEviction(value, rawEnv, "full");
 }

From 60adbef7d9ffd35589317e3204f32772c59c9468 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Tue, 21 Jul 2026 01:23:15 +0800
Subject: [PATCH 05/11] test(pack): update dynamic HMR snapshot

---
 .../output/chunks/input_index_83022b3b.dev.js                | 2 +-
 .../output/chunks/input_message_6ccb1ced.dev.js              | 3 ++-
 .../output/chunks/input_message_807614c3.dev.js              | 5 +++++
 3 files changed, 8 insertions(+), 2 deletions(-)
 create mode 100644 crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js

diff --git a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js
index af632e75f..65d1cff1d 100644
--- a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js
+++ b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js
@@ -1,5 +1,5 @@
 (globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
     script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["chunks/input_message_7d12845b.dev.js","chunks/input_message_6ccb1ced.dev.js","chunks/input_index_c388c1fc.dev.js"],
+    chunks: ["chunks/input_message_6ccb1ced.dev.js","chunks/input_index_c388c1fc.dev.js"],
     source: "entry"
 });
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js
index b06701997..a9f16d6a2 100644
--- a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js
+++ b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js
@@ -3,7 +3,8 @@
 
 __turbopack_context__.v((parentImport) => {
     return Promise.all([
-  "chunks/input_message_7d12845b.dev.js"
+  "chunks/input_message_7d12845b.dev.js",
+  "chunks/input_message_807614c3.dev.js"
 ].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
         return parentImport("[project]/basic/js_filename_dev/input/message.js [client] (ecmascript)");
     });
diff --git a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js
new file mode 100644
index 000000000..68a701eda
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js
@@ -0,0 +1,5 @@
+(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
+    script: typeof document === "object" ? document.currentScript : undefined,
+    chunks: ["chunks/input_message_7d12845b.dev.js"],
+    source: "dynamic"
+});
\ No newline at end of file

From 008c2167eab8893fbf779545ffba0bac06c52430 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Tue, 21 Jul 2026 20:05:04 +0800
Subject: [PATCH 06/11] fix(pack): harden scoped HMR delivery

---
 .github/workflows/pack-ci.yml                 |   30 +-
 crates/pack-api/src/project.rs                |   26 +-
 crates/pack-core/js/src/hmr/websocket.ts      |  133 +-
 crates/pack-core/src/client/context.rs        |   18 +-
 crates/pack-napi/src/pack_api/project.rs      |   45 +-
 .../hmr/dynamic_chunk_lists/assert.js         |   52 +-
 .../hmr/dynamic_chunk_lists/config.json       |    6 +-
 .../output/_root-of-the-server___7c304173.js  | 1332 +++++++
 .../output/input_index_3f44269c.js            |   13 -
 .../output/input_index_83022b3b.js            |    6 +-
 ...azy_7d0cc84b.js => input_lazy_0468b002.js} |    4 +-
 .../output/input_lazy_5395e95a.js             |    3 +
 ...azy_91bce909.js => input_lazy_b90c1087.js} |    3 +-
 .../hmr/dynamic_chunk_lists/output/main.js    |  950 ++++-
 .../assert.js                                 |   33 +
 .../config.json                               |   23 +
 .../input/index.js                            |    3 +
 .../input/lazy.js                             |    1 +
 .../output/_root-of-the-server___2651c4ea.js  |  453 +++
 .../output/input_lazy_b65347b5.js             |   12 +
 .../output/input_lazy_c5880b16.js             |   14 +
 .../output/main.js                            | 3147 +++++++++++++++++
 crates/utoo-wasm/src/pack.rs                  |   61 +-
 crates/utoo-wasm/src/project.rs               |    5 +-
 e2e/pack-hmr/.gitignore                       |    1 +
 e2e/pack-hmr/index.html                       |   13 +
 e2e/pack-hmr/pack-hmr.spec.ts                 |  628 ++++
 e2e/pack-hmr/playwright.config.ts             |   24 +
 e2e/pack-hmr/server.cjs                       |   38 +
 e2e/pack-hmr/src/a.js                         |    8 +
 e2e/pack-hmr/src/b.js                         |    8 +
 e2e/pack-hmr/src/index.js                     |   16 +
 e2e/pack-hmr/src/shared.css                   |    4 +
 e2e/pack-hmr/src/shared.js                    |    4 +
 package.json                                  |    1 +
 packages/pack-shared/src/hmr.ts               |    3 +
 packages/pack/src/__test__/hmr.test.ts        |   56 +-
 .../pack/src/__test__/hmrWebSocket.test.ts    |  147 +
 packages/pack/src/binding.d.ts                |    2 +-
 packages/pack/src/core/hmr.ts                 |  101 +-
 packages/pack/src/core/hmrClientState.ts      |   27 +-
 packages/pack/src/core/project.ts             |    9 +-
 packages/pack/src/core/types.ts               |   13 +-
 packages/utoo-web/src/hmr/HmrServer.ts        |   37 +-
 .../utoo-web/src/project/ForkedProject.ts     |   18 +-
 .../utoo-web/src/project/InternalProject.ts   |   49 +-
 packages/utoo-web/src/project/Project.ts      |   42 +-
 packages/utoo-web/src/types.ts                |   10 +
 packages/utoo-web/src/utoo/index.d.ts         |    2 +-
 49 files changed, 7409 insertions(+), 225 deletions(-)
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js
 rename crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/{input_lazy_7d0cc84b.js => input_lazy_0468b002.js} (65%)
 rename crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/{input_lazy_91bce909.js => input_lazy_b90c1087.js} (90%)
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js
 create mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
 create mode 100644 e2e/pack-hmr/.gitignore
 create mode 100644 e2e/pack-hmr/index.html
 create mode 100644 e2e/pack-hmr/pack-hmr.spec.ts
 create mode 100644 e2e/pack-hmr/playwright.config.ts
 create mode 100644 e2e/pack-hmr/server.cjs
 create mode 100644 e2e/pack-hmr/src/a.js
 create mode 100644 e2e/pack-hmr/src/b.js
 create mode 100644 e2e/pack-hmr/src/index.js
 create mode 100644 e2e/pack-hmr/src/shared.css
 create mode 100644 e2e/pack-hmr/src/shared.js
 create mode 100644 packages/pack/src/__test__/hmrWebSocket.test.ts

diff --git a/.github/workflows/pack-ci.yml b/.github/workflows/pack-ci.yml
index 55ff8216a..eadf214bf 100644
--- a/.github/workflows/pack-ci.yml
+++ b/.github/workflows/pack-ci.yml
@@ -165,16 +165,44 @@ jobs:
         if: ${{ !matrix.settings.docker }}
         shell: bash
 
+  hmr_e2e:
+    name: utoopack-ci-hmr-e2e
+    if: (github.event_name == 'push' && contains(github.event.head_commit.message, '(pack)')) || (github.event_name == 'pull_request' && contains(github.event.pull_request.title, '(pack)'))
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Init git submodules
+        run: git submodule update --init --recursive --depth 1
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22.14.0
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: nightly-2026-05-15
+      - name: Setup Utoo
+        uses: utooland/setup-utoo@v1
+      - name: Install dependencies
+        run: utoo install
+      - name: Build @utoo/pack
+        run: npm run build:local --workspace @utoo/pack
+      - name: Install Playwright browser
+        run: npx playwright install --with-deps chromium
+      - name: Run HMR browser regression tests
+        run: npm run test:e2e:pack-hmr
+
   success:
     name: utoopack-ci-success
     runs-on: ubuntu-latest
     if: always()
     needs:
       - test
+      - hmr_e2e
     steps:
       - name: Check success
         run: |
-          if [ "${{ needs.test.result }}" == "failure" ] || [ "${{ needs.test.result }}" == "cancelled" ]; then
+          if [ "${{ needs.test.result }}" == "failure" ] || [ "${{ needs.test.result }}" == "cancelled" ] || [ "${{ needs.hmr_e2e.result }}" == "failure" ] || [ "${{ needs.hmr_e2e.result }}" == "cancelled" ]; then
             echo "Tests failed or were cancelled"
             exit 1
           else
diff --git a/crates/pack-api/src/project.rs b/crates/pack-api/src/project.rs
index 2b3cdf1b9..be71cdf5a 100644
--- a/crates/pack-api/src/project.rs
+++ b/crates/pack-api/src/project.rs
@@ -1167,11 +1167,15 @@ impl Project {
 
     #[turbo_tasks::function]
     pub(super) async fn client_compile_time_info(&self) -> Result<Vc<CompileTimeInfo>> {
+        let watch = self.watch.enable;
+        let hot = self.config.dev_server().await?.hot.unwrap_or_default();
         Ok(get_client_compile_time_info(
             (*self.config.target().await?).clone(),
             client_define_env(*self.config, self.process_env).await?,
             self.config.mode(),
             self.config.provider_config(),
+            Vc::cell(watch),
+            Vc::cell(hot),
         ))
     }
 
@@ -1190,12 +1194,18 @@ impl Project {
     pub(super) async fn compile_time_info_for_platform(&self) -> Result<Vc<CompileTimeInfo>> {
         let target = (*self.config.target().await?).clone();
         match &*self.config.platform().await? {
-            Platform::Web => Ok(get_client_compile_time_info(
-                target,
-                client_define_env(*self.config, self.process_env).await?,
-                self.config.mode(),
-                self.config.provider_config(),
-            )),
+            Platform::Web => {
+                let watch = self.watch.enable;
+                let hot = self.config.dev_server().await?.hot.unwrap_or_default();
+                Ok(get_client_compile_time_info(
+                    target,
+                    client_define_env(*self.config, self.process_env).await?,
+                    self.config.mode(),
+                    self.config.provider_config(),
+                    Vc::cell(watch),
+                    Vc::cell(hot),
+                ))
+            }
             Platform::Node => Ok(get_server_compile_time_info(
                 target,
                 self.config.define_env(),
@@ -1209,6 +1219,8 @@ impl Project {
     pub async fn client_chunking_context(self: Vc<Self>) -> Result<Vc<Box<dyn ChunkingContext>>> {
         let mode = self.mode();
         let config = self.config();
+        let watch = self.await?.watch.enable;
+        let hot = config.dev_server().await?.hot.unwrap_or_default();
         let source_maps = if *config.source_maps().await? {
             SourceMapsType::Full
         } else {
@@ -1216,6 +1228,8 @@ impl Project {
         };
         Ok(get_client_chunking_context(ClientChunkingContextOptions {
             mode,
+            watch: Vc::cell(watch),
+            hot: Vc::cell(hot),
             root_path: self.project_path().owned().await?,
             client_root: self.client_root().owned().await?,
             client_root_to_root_path: rcstr!("/ROOT"),
diff --git a/crates/pack-core/js/src/hmr/websocket.ts b/crates/pack-core/js/src/hmr/websocket.ts
index 04a40df85..e14cdcdc7 100644
--- a/crates/pack-core/js/src/hmr/websocket.ts
+++ b/crates/pack-core/js/src/hmr/websocket.ts
@@ -12,6 +12,9 @@ type WebSocketMessage =
 let source: WebSocket | null = null;
 let eventCallbacks: Array<(event: WebSocketMessage) => void> = [];
 
+const INITIAL_RECONNECT_DELAY_MS = 500;
+const MAX_RECONNECT_DELAY_MS = 5_000;
+
 // Helper function to dispatch messages to all event callbacks
 function dispatchMessage(message: WebSocketMessage) {
   for (const eventCallback of eventCallbacks) {
@@ -72,21 +75,89 @@ let serverSessionId: number | null = null;
 
 // This is not used by Next.js, but it is used by the standalone turbopack-cli
 export function connectHMR(options: HMROptions) {
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  let reconnectAttempts = 0;
+  let pageIsUnloading = false;
+
+  function clearReconnectTimer() {
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+  }
+
+  function closeSocket(socket: WebSocket) {
+    socket.onopen = null;
+    socket.onerror = null;
+    socket.onclose = null;
+    socket.onmessage = null;
+
+    if (source === socket) {
+      source = null;
+    }
+
+    if (
+      socket.readyState === WebSocket.CONNECTING ||
+      socket.readyState === WebSocket.OPEN
+    ) {
+      socket.close();
+    }
+  }
+
+  function scheduleReconnect() {
+    if (reconnectTimer !== null || pageIsUnloading || reloading) {
+      return;
+    }
+
+    const delay = Math.min(
+      INITIAL_RECONNECT_DELAY_MS * 2 ** reconnectAttempts,
+      MAX_RECONNECT_DELAY_MS,
+    );
+    reconnectAttempts += 1;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      init();
+    }, delay);
+  }
+
   function init() {
-    if (source) source.close();
+    if (pageIsUnloading || reloading) {
+      return;
+    }
+
+    if (source) {
+      closeSocket(source);
+    }
 
     console.log("[HMR] connecting...");
 
+    let socket: WebSocket;
+    try {
+      socket = new WebSocket(`${getSocketUrl()}${options.path}`);
+    } catch (error) {
+      console.error("[HMR] Failed to create WebSocket:", error);
+      scheduleReconnect();
+      return;
+    }
+
+    source = socket;
+
     function handleOnline() {
-      window.console.log("[HMR] connected");
+      if (source !== socket || pageIsUnloading || reloading) {
+        closeSocket(socket);
+        return;
+      }
 
-      // Send the turbopack-connected message to trigger handleSocketConnected
-      const connected: WebSocketMessage = { type: "turbopack-connected" };
-      dispatchMessage(connected);
+      reconnectAttempts = 0;
+      window.console.log("[HMR] connected");
+      // Direct turbopack-dev-server does not send a separate connected frame.
+      // Utoo does, but the socket-open notification is sufficient to restore
+      // subscriptions in both cases.
+      dispatchMessage({ type: "turbopack-connected" });
     }
 
     function handleMessage(event: MessageEvent<string>) {
-      if (reloading) {
+      if (source !== socket || reloading) {
         return;
       }
 
@@ -99,22 +170,21 @@ export function connectHMR(options: HMROptions) {
             serverSessionId !== null &&
             serverSessionId !== msg.data.sessionId
           ) {
-            window.location.reload();
             reloading = true;
+            window.location.reload();
             return;
           }
 
           serverSessionId = msg.data.sessionId;
 
-          // Convert to turbopack format and trigger handleSocketConnected
-          const connected: WebSocketMessage = { type: "turbopack-connected" };
-          dispatchMessage(connected);
+          // Socket open already restored subscriptions. This frame only carries
+          // the Utoo server session id used to detect server restarts.
           return;
         }
 
         if (msg.action === "reload") {
-          window.location.reload();
           reloading = true;
+          window.location.reload();
           return;
         }
 
@@ -146,27 +216,40 @@ export function connectHMR(options: HMROptions) {
       }
     }
 
-    function handleDisconnect(event?: Event) {
-      if (event && event.target !== source) {
+    function handleDisconnect(event: Event) {
+      if (event.target !== socket || source !== socket) {
         return;
       }
 
-      if (source) {
-        source.onerror = null;
-        source.onclose = null;
-        source.close();
-        source = null;
-      }
-
+      closeSocket(socket);
       window.console.warn("[HMR] disconnected");
+      scheduleReconnect();
     }
 
-    source = new WebSocket(`${getSocketUrl()}${options.path}`);
-    source.onopen = handleOnline;
-    source.onerror = handleDisconnect;
-    source.onclose = handleDisconnect;
-    source.onmessage = handleMessage;
+    socket.onopen = handleOnline;
+    socket.onerror = handleDisconnect;
+    socket.onclose = handleDisconnect;
+    socket.onmessage = handleMessage;
   }
 
+  // `pagehide` is not fired when a beforeunload prompt is cancelled, so it is
+  // safe to use as the point where reconnects should stop.
+  window.addEventListener("pagehide", () => {
+    pageIsUnloading = true;
+    clearReconnectTimer();
+    if (source) {
+      closeSocket(source);
+    }
+  });
+
+  // A page restored from the back-forward cache needs a fresh HMR transport.
+  window.addEventListener("pageshow", (event) => {
+    if (event.persisted) {
+      pageIsUnloading = false;
+      reconnectAttempts = 0;
+      init();
+    }
+  });
+
   init();
 }
diff --git a/crates/pack-core/src/client/context.rs b/crates/pack-core/src/client/context.rs
index c0afa9356..83de6ed3a 100644
--- a/crates/pack-core/src/client/context.rs
+++ b/crates/pack-core/src/client/context.rs
@@ -93,13 +93,14 @@ pub async fn get_client_compile_time_info(
     define_env: Vc<EnvMap>,
     mode: Vc<Mode>,
     provider_config: Vc<ProviderConfig>,
+    watch: Vc<bool>,
+    hot: Vc<bool>,
 ) -> Result<Vc<CompileTimeInfo>> {
+    let mode_ref = mode.await?;
     let mut define_env = (*define_env.await?).clone();
     define_env.extend([(
         "process.env.NODE_ENV".into(),
-        serde_json::to_string(mode.await?.node_env())
-            .unwrap()
-            .into(),
+        serde_json::to_string(mode_ref.node_env()).unwrap().into(),
     )]);
     let define_env = Vc::cell(define_env);
     let environment = BrowserEnvironment {
@@ -117,6 +118,7 @@ pub async fn get_client_compile_time_info(
     )
     .defines(defines(define_env).to_resolved().await?)
     .free_var_references(free_vars(define_env, provider_config).to_resolved().await?)
+    .hot_module_replacement_enabled(mode_ref.is_development() && *watch.await? && *hot.await?)
     .cell()
     .await
 }
@@ -555,6 +557,8 @@ pub async fn get_client_resolve_options_context(
 #[derive(Clone, Debug, PartialEq, Eq, Hash, TraceRawVcs, Encode, Decode)]
 pub struct ClientChunkingContextOptions {
     pub mode: Vc<Mode>,
+    pub watch: Vc<bool>,
+    pub hot: Vc<bool>,
     pub root_path: FileSystemPath,
     pub client_root: FileSystemPath,
     pub client_root_to_root_path: RcStr,
@@ -580,6 +584,8 @@ pub async fn get_client_chunking_context(
 ) -> Result<Vc<Box<dyn ChunkingContext>>> {
     let ClientChunkingContextOptions {
         mode,
+        watch,
+        hot,
         root_path,
         client_root,
         client_root_to_root_path,
@@ -685,10 +691,12 @@ pub async fn get_client_chunking_context(
 
     if mode.is_development() {
         builder = builder
-            .hot_module_replacement()
-            .dynamic_hmr_chunk_lists()
             .source_map_source_type(SourceMapSourceType::AbsoluteFileUri)
             .dynamic_chunk_content_loading(true);
+
+        if *watch.await? && *hot.await? {
+            builder = builder.hot_module_replacement().dynamic_hmr_chunk_lists();
+        }
     } else {
         let split_chunks = &config.optimization().await?.split_chunks;
         let style_groups_algorithm = config.css_chunking_algorithm().owned().await?;
diff --git a/crates/pack-napi/src/pack_api/project.rs b/crates/pack-napi/src/pack_api/project.rs
index 32f6c4208..a49fc5848 100644
--- a/crates/pack-napi/src/pack_api/project.rs
+++ b/crates/pack-napi/src/pack_api/project.rs
@@ -2,7 +2,10 @@ use std::{
     borrow::Cow,
     io::Write,
     path::PathBuf,
-    sync::LazyLock,
+    sync::{
+        Arc, LazyLock,
+        atomic::{AtomicBool, Ordering},
+    },
     thread::{self, JoinHandle},
     time::{Duration, Instant},
 };
@@ -53,7 +56,7 @@ use turbo_unix_path::get_relative_path_to;
 use turbopack_core::{
     PROJECT_FILESYSTEM_NAME, SOURCE_URL_PROTOCOL,
     source_map::{SourceMap, Token},
-    version::{PartialUpdate, TotalUpdate, Update},
+    version::{PartialUpdate, TotalUpdate, Update, Version},
 };
 use turbopack_ecmascript_hmr_protocol::{ClientUpdateInstruction, ResourceIdentifier};
 use turbopack_trace_utils::{
@@ -711,25 +714,41 @@ pub fn project_hmr_events(
     #[napi(ts_arg_type = "{ __napiType: \"Project\" }")] project: External<ProjectInstance>,
     identifier: RcStr,
     func: JsFunction,
+    expected_version: Option<RcStr>,
 ) -> napi::Result<External<RootTask>> {
     let turbopack_ctx = project.turbopack_ctx.clone();
     let project = project.container;
     let session = TransientInstance::new(());
+    let check_expected_version = Arc::new(AtomicBool::new(expected_version.is_some()));
+    let check_expected_version_after_emit = check_expected_version.clone();
     subscribe(
         turbopack_ctx,
         func,
         {
             let outer_identifier = identifier.clone();
             let session = session.clone();
+            let expected_version = expected_version.clone();
+            let check_expected_version = check_expected_version.clone();
             move || {
                 let identifier: RcStr = outer_identifier.clone();
                 let session = session.clone();
+                let expected_version = expected_version.clone();
+                let check_expected_version = check_expected_version.clone();
                 async move {
                     let project = project.project().to_resolved().await?;
                     let state = project
                         .hmr_version_state(identifier.clone(), session)
                         .to_resolved()
                         .await?;
+                    let should_check_expected_version =
+                        check_expected_version.load(Ordering::Acquire);
+                    let version_mismatch = if should_check_expected_version
+                        && let Some(expected_version) = expected_version
+                    {
+                        state.get().id().owned().await? != expected_version
+                    } else {
+                        false
+                    };
 
                     let update_op =
                         hmr_update_with_issues_operation(project, identifier.clone(), state);
@@ -750,12 +769,17 @@ pub fn project_hmr_events(
                             state.set(to.clone()).await?;
                         }
                     }
-                    Ok((Some(update.clone()), issues.clone()))
+                    Ok((
+                        Some(update.clone()),
+                        issues.clone(),
+                        version_mismatch,
+                        should_check_expected_version,
+                    ))
                 }
             }
         },
         move |ctx| {
-            let (update, issues) = ctx.value;
+            let (update, issues, version_mismatch, should_check_expected_version) = ctx.value;
 
             let napi_issues = issues
                 .iter()
@@ -771,7 +795,11 @@ pub fn project_hmr_events(
                 headers: None,
             };
             let update = match update.as_deref() {
-                None | Some(Update::Missing) | Some(Update::Total(_)) => {
+                Some(Update::Missing) => ClientUpdateInstruction::not_found(&identifier),
+                _ if version_mismatch => {
+                    ClientUpdateInstruction::restart(&identifier, &update_issues)
+                }
+                None | Some(Update::Total(_)) => {
                     ClientUpdateInstruction::restart(&identifier, &update_issues)
                 }
                 Some(Update::Partial(update)) => ClientUpdateInstruction::partial(
@@ -782,8 +810,13 @@ pub fn project_hmr_events(
                 Some(Update::None) => ClientUpdateInstruction::issues(&identifier, &update_issues),
             };
 
+            let result = ctx.env.to_js_value(&update)?;
+            if should_check_expected_version {
+                check_expected_version_after_emit.store(false, Ordering::Release);
+            }
+
             Ok(vec![TurbopackResult {
-                result: ctx.env.to_js_value(&update)?,
+                result,
                 issues: napi_issues,
             }])
         },
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
index 462704e3f..7abf594f9 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
@@ -3,16 +3,21 @@ const fs = require("node:fs");
 const path = require("node:path");
 
 const outputDir = path.join(__dirname, "output");
-const registrations = fs
+const javascriptAssets = fs
   .readdirSync(outputDir)
   .filter((file) => file.endsWith(".js"))
-  .map((file) => fs.readFileSync(path.join(outputDir, file), "utf8"))
-  .filter((content) => content.includes("_CHUNK_LISTS"));
+  .map((file) => ({
+    file,
+    content: fs.readFileSync(path.join(outputDir, file), "utf8"),
+  }));
+const registrations = javascriptAssets.filter(({ content }) =>
+  content.includes("_CHUNK_LISTS"),
+);
 
-const entryRegistrations = registrations.filter((content) =>
+const entryRegistrations = registrations.filter(({ content }) =>
   /source:\s*["']entry["']/.test(content),
 );
-const dynamicRegistrations = registrations.filter((content) =>
+const dynamicRegistrations = registrations.filter(({ content }) =>
   /source:\s*["']dynamic["']/.test(content),
 );
 
@@ -33,11 +38,44 @@ function readChunks(registration) {
   return JSON.parse(match[1]);
 }
 
-const entryChunks = new Set(readChunks(entryRegistrations[0]));
-const dynamicChunks = readChunks(dynamicRegistrations[0]);
+function readChunkVersions(registration) {
+  const match = registration.match(/chunkVersions:\s*(\{[^\n]*\})/);
+  assert.ok(match, "the HMR registration should contain chunk versions");
+  return JSON.parse(match[1]);
+}
+
+const entryChunks = new Set(readChunks(entryRegistrations[0].content));
+const dynamicChunks = readChunks(dynamicRegistrations[0].content);
+const dynamicChunkVersions = readChunkVersions(dynamicRegistrations[0].content);
 
 assert.ok(dynamicChunks.length > 0, "the dynamic HMR list should not be empty");
 assert.ok(
   dynamicChunks.every((chunk) => !entryChunks.has(chunk)),
   "dynamic payload chunks should not be duplicated in the entry HMR list",
 );
+assert.deepEqual(
+  Object.keys(dynamicChunkVersions).sort(),
+  [...dynamicChunks].sort(),
+  "every dynamic member must carry the content version used for its URL",
+);
+assert.ok(
+  Object.values(dynamicChunkVersions).every(
+    (version) => typeof version === "string" && version.length > 0,
+  ),
+  "dynamic member content versions must be non-empty strings",
+);
+
+const asyncLoader = javascriptAssets.find(({ content }) =>
+  content.includes("return parentImport("),
+);
+assert.ok(asyncLoader, "the fixture should emit an async loader");
+const loaderMatch = asyncLoader.content.match(
+  /return Promise\.all\((\[[\s\S]*?\])\.map/,
+);
+assert.ok(loaderMatch, "the async loader should contain a chunk array");
+const loaderChunks = JSON.parse(loaderMatch[1]);
+assert.deepEqual(
+  loaderChunks,
+  [dynamicRegistrations[0].file],
+  "the async loader must fetch only the HMR-list bootstrap before content",
+);
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
index 831f7def7..5141b968f 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
@@ -7,6 +7,9 @@
       }
     ],
     "mode": "development",
+    "devServer": {
+      "hot": true
+    },
     "sourceMaps": false,
     "optimization": {
       "minify": false
@@ -15,5 +18,6 @@
       "path": "output"
     }
   },
-  "runtimeType": "Development"
+  "runtimeType": "Development",
+  "watch": true
 }
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
new file mode 100644
index 000000000..2f7535bae
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
@@ -0,0 +1,1332 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[@utoo/pack-runtime]/hmr/bootstrap.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([]);
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/hmr/client.ts [client] (ecmascript)");
+;
+(0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["initHMR"])();
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/hmr/client.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "initHMR",
+    ()=>initHMR
+]);
+// @ts-ignore
+var __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[turbopack]/browser/dev/hmr-client/hmr-client.ts [client] (ecmascript)");
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/hmr/websocket.ts [client] (ecmascript)");
+;
+;
+function initHMR() {
+    (0, __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["connect"])({
+        addMessageListener: __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["addMessageListener"],
+        sendMessage: __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["sendMessage"],
+        onUpdateError: console.error,
+        chunkUpdateListenersGlobal: __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL"]
+    });
+    (0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["connectHMR"])({
+        path: "/turbopack-hmr"
+    });
+}
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/hmr/websocket.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+// Adapted from https://github.com/vercel/next.js/blob/canary/packages/next/src/client/dev/error-overlay/websocket.ts
+__turbopack_context__.s([
+    "addMessageListener",
+    ()=>addMessageListener,
+    "connectHMR",
+    ()=>connectHMR,
+    "sendMessage",
+    ()=>sendMessage
+]);
+let source = null;
+let eventCallbacks = [];
+const INITIAL_RECONNECT_DELAY_MS = 500;
+const MAX_RECONNECT_DELAY_MS = 5_000;
+// Helper function to dispatch messages to all event callbacks
+function dispatchMessage(message) {
+    for (const eventCallback of eventCallbacks){
+        eventCallback(message);
+    }
+}
+function addMessageListener(callback) {
+    eventCallbacks.push(callback);
+}
+function sendMessage(data) {
+    if (source && source.readyState === source.OPEN) {
+        const message = typeof data === "string" ? data : JSON.stringify(data);
+        source.send(message);
+    }
+}
+function getSocketProtocol() {
+    return typeof location !== "undefined" && location.protocol === "https:" ? "wss" : "ws";
+}
+function getSocketUrl() {
+    const socketServer = ("TURBOPACK compile-time value", undefined);
+    if (socketServer) {
+        try {
+            const parsed = new URL(socketServer);
+            const protocol = parsed.protocol === "https:" ? "wss:" : parsed.protocol === "http:" ? "ws:" : parsed.protocol;
+            if (protocol === "ws:" || protocol === "wss:") {
+                const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+                return `${protocol}//${parsed.host}${pathname}`;
+            }
+        } catch  {}
+    }
+    const { hostname, port } = location;
+    const protocol = getSocketProtocol();
+    return `${protocol}://${hostname}${port ? `:${port}` : ""}`;
+}
+let reloading = false;
+let serverSessionId = null;
+function connectHMR(options) {
+    let reconnectTimer = null;
+    let reconnectAttempts = 0;
+    let pageIsUnloading = false;
+    function clearReconnectTimer() {
+        if (reconnectTimer !== null) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+    }
+    function closeSocket(socket) {
+        socket.onopen = null;
+        socket.onerror = null;
+        socket.onclose = null;
+        socket.onmessage = null;
+        if (source === socket) {
+            source = null;
+        }
+        if (socket.readyState === WebSocket.CONNECTING || socket.readyState === WebSocket.OPEN) {
+            socket.close();
+        }
+    }
+    function scheduleReconnect() {
+        if (reconnectTimer !== null || pageIsUnloading || reloading) {
+            return;
+        }
+        const delay = Math.min(INITIAL_RECONNECT_DELAY_MS * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY_MS);
+        reconnectAttempts += 1;
+        reconnectTimer = setTimeout(()=>{
+            reconnectTimer = null;
+            init();
+        }, delay);
+    }
+    function init() {
+        if (pageIsUnloading || reloading) {
+            return;
+        }
+        if (source) {
+            closeSocket(source);
+        }
+        console.log("[HMR] connecting...");
+        let socket;
+        try {
+            socket = new WebSocket(`${getSocketUrl()}${options.path}`);
+        } catch (error) {
+            console.error("[HMR] Failed to create WebSocket:", error);
+            scheduleReconnect();
+            return;
+        }
+        source = socket;
+        function handleOnline() {
+            if (source !== socket || pageIsUnloading || reloading) {
+                closeSocket(socket);
+                return;
+            }
+            reconnectAttempts = 0;
+            window.console.log("[HMR] connected");
+            // Direct turbopack-dev-server does not send a separate connected frame.
+            // Utoo does, but the socket-open notification is sufficient to restore
+            // subscriptions in both cases.
+            dispatchMessage({
+                type: "turbopack-connected"
+            });
+        }
+        function handleMessage(event) {
+            if (source !== socket || reloading) {
+                return;
+            }
+            try {
+                const msg = JSON.parse(event.data);
+                // Handle the different message formats from different servers
+                if (msg.action === "turbopack-connected") {
+                    if (serverSessionId !== null && serverSessionId !== msg.data.sessionId) {
+                        reloading = true;
+                        window.location.reload();
+                        return;
+                    }
+                    serverSessionId = msg.data.sessionId;
+                    // Socket open already restored subscriptions. This frame only carries
+                    // the Utoo server session id used to detect server restarts.
+                    return;
+                }
+                if (msg.action === "reload") {
+                    reloading = true;
+                    window.location.reload();
+                    return;
+                }
+                if (msg.action === "turbopack-message") {
+                    const turbopackMessage = {
+                        type: "turbopack-message",
+                        data: msg.data
+                    };
+                    dispatchMessage(turbopackMessage);
+                    return;
+                }
+                // Handle direct turbopack-dev-server messages
+                if (msg.type && [
+                    "partial",
+                    "restart",
+                    "notFound",
+                    "issues"
+                ].includes(msg.type)) {
+                    const turbopackMessage = {
+                        type: "turbopack-message",
+                        data: msg
+                    };
+                    dispatchMessage(turbopackMessage);
+                    return;
+                }
+            // TODO: handle rest msg.actions
+            } catch (e) {
+                console.error("[HMR] Failed to parse message:", e);
+            }
+        }
+        function handleDisconnect(event) {
+            if (event.target !== socket || source !== socket) {
+                return;
+            }
+            closeSocket(socket);
+            window.console.warn("[HMR] disconnected");
+            scheduleReconnect();
+        }
+        socket.onopen = handleOnline;
+        socket.onerror = handleDisconnect;
+        socket.onclose = handleDisconnect;
+        socket.onmessage = handleMessage;
+    }
+    // `pagehide` is not fired when a beforeunload prompt is cancelled, so it is
+    // safe to use as the point where reconnects should stop.
+    window.addEventListener("pagehide", ()=>{
+        pageIsUnloading = true;
+        clearReconnectTimer();
+        if (source) {
+            closeSocket(source);
+        }
+    });
+    // A page restored from the back-forward cache needs a fresh HMR transport.
+    window.addEventListener("pageshow", (event)=>{
+        if (event.persisted) {
+            pageIsUnloading = false;
+            reconnectAttempts = 0;
+            init();
+        }
+    });
+    init();
+}
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "default",
+    ()=>__TURBOPACK__default__export__
+]);
+/**
+ * MIT License
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */ // This file is copied from the Metro JavaScript bundler, with minor tweaks for
+// webpack 4 compatibility.
+//
+// https://github.com/facebook/metro/blob/d6b9685c730d0d63577db40f41369157f28dfa3a/packages/metro/src/lib/polyfills/require.js
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
+;
+const { m: turbopackModule } = __turbopack_context__;
+function isSafeExport(key) {
+    return key === "__esModule" || key === "__N_SSG" || key === "__N_SSP" || // TODO: remove this key from page config instead of allow listing it
+    key === "config";
+}
+function registerExportsForReactRefresh(moduleExports, moduleID) {
+    __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(moduleExports, moduleID + " %exports%");
+    if (moduleExports == null || typeof moduleExports !== "object") {
+        // Exit if we can't iterate over exports.
+        // (This is important for legacy environments.)
+        return;
+    }
+    for(var key in moduleExports){
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        } catch  {
+            continue;
+        }
+        var typeID = moduleID + " %exports% " + key;
+        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(exportValue, typeID);
+    }
+}
+function getRefreshBoundarySignature(moduleExports) {
+    var signature = [];
+    signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(moduleExports));
+    if (moduleExports == null || typeof moduleExports !== "object") {
+        // Exit if we can't iterate over exports.
+        // (This is important for legacy environments.)
+        return signature;
+    }
+    for(var key in moduleExports){
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        } catch  {
+            continue;
+        }
+        signature.push(key);
+        signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(exportValue));
+    }
+    return signature;
+}
+function isReactRefreshBoundary(moduleExports) {
+    if (__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(moduleExports)) {
+        return true;
+    }
+    if (moduleExports == null || typeof moduleExports !== "object") {
+        // Exit if we can't iterate over exports.
+        return false;
+    }
+    var hasExports = false;
+    var areAllExportsComponents = true;
+    for(var key in moduleExports){
+        hasExports = true;
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        } catch  {
+            // This might fail due to circular dependencies
+            return false;
+        }
+        if (!__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(exportValue)) {
+            areAllExportsComponents = false;
+        }
+    }
+    return hasExports && areAllExportsComponents;
+}
+function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) {
+    if (prevSignature.length !== nextSignature.length) {
+        return true;
+    }
+    for(var i = 0; i < nextSignature.length; i++){
+        if (prevSignature[i] !== nextSignature[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+var isUpdateScheduled = false;
+// This function aggregates updates from multiple modules into a single React Refresh call.
+function scheduleUpdate() {
+    if (isUpdateScheduled) {
+        return;
+    }
+    isUpdateScheduled = true;
+    function canApplyUpdate(status) {
+        return status === "idle";
+    }
+    function applyUpdate() {
+        isUpdateScheduled = false;
+        try {
+            __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].performReactRefresh();
+        } catch (err) {
+            console.warn("Warning: Failed to re-render. We will retry on the next Fast Refresh event.\n" + err);
+        }
+    }
+    if (canApplyUpdate(turbopackModule.hot.status())) {
+        // Apply update on the next tick.
+        Promise.resolve().then(()=>{
+            applyUpdate();
+        });
+        return;
+    }
+    const statusHandler = (status)=>{
+        if (canApplyUpdate(status)) {
+            turbopackModule.hot.removeStatusHandler(statusHandler);
+            applyUpdate();
+        }
+    };
+    // Apply update once the HMR runtime's status is idle.
+    turbopackModule.hot.addStatusHandler(statusHandler);
+}
+var __TURBOPACK__default__export__ = {
+    registerExportsForReactRefresh: registerExportsForReactRefresh,
+    isReactRefreshBoundary: isReactRefreshBoundary,
+    shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary,
+    getRefreshBoundarySignature: getRefreshBoundarySignature,
+    scheduleUpdate: scheduleUpdate
+};
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)", ((__turbopack_context__, module, exports) => {
+"use strict";
+
+// react@0.18.0: https://unpkg.com/react-refresh@0.18.0/cjs/react-refresh-runtime.development.js
+/**
+ * @license React
+ * react-refresh-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "production" !== ("TURBOPACK compile-time value", "development") && function() {
+    function computeFullKey(signature) {
+        if (null !== signature.fullKey) return signature.fullKey;
+        var fullKey = signature.ownKey;
+        try {
+            var hooks = signature.getCustomHooks();
+        } catch (err) {
+            return signature.forceReset = !0, signature.fullKey = fullKey;
+        }
+        for(var i = 0; i < hooks.length; i++){
+            var hook = hooks[i];
+            if ("function" !== typeof hook) return signature.forceReset = !0, signature.fullKey = fullKey;
+            hook = allSignaturesByType.get(hook);
+            if (void 0 !== hook) {
+                var nestedHookKey = computeFullKey(hook);
+                hook.forceReset && (signature.forceReset = !0);
+                fullKey += "\n---\n" + nestedHookKey;
+            }
+        }
+        return signature.fullKey = fullKey;
+    }
+    function resolveFamily(type) {
+        return updatedFamiliesByType.get(type);
+    }
+    function cloneMap(map) {
+        var clone = new Map();
+        map.forEach(function(value, key) {
+            clone.set(key, value);
+        });
+        return clone;
+    }
+    function cloneSet(set) {
+        var clone = new Set();
+        set.forEach(function(value) {
+            clone.add(value);
+        });
+        return clone;
+    }
+    function getProperty(object, property) {
+        try {
+            return object[property];
+        } catch (err) {}
+    }
+    function register(type, id) {
+        if (!(null === type || "function" !== typeof type && "object" !== typeof type || allFamiliesByType.has(type))) {
+            var family = allFamiliesByID.get(id);
+            void 0 === family ? (family = {
+                current: type
+            }, allFamiliesByID.set(id, family)) : pendingUpdates.push([
+                family,
+                type
+            ]);
+            allFamiliesByType.set(type, family);
+            if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
+                case REACT_FORWARD_REF_TYPE:
+                    register(type.render, id + "$render");
+                    break;
+                case REACT_MEMO_TYPE:
+                    register(type.type, id + "$type");
+            }
+        }
+    }
+    function setSignature(type, key) {
+        var forceReset = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1, getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
+        allSignaturesByType.has(type) || allSignaturesByType.set(type, {
+            forceReset: forceReset,
+            ownKey: key,
+            fullKey: null,
+            getCustomHooks: getCustomHooks || function() {
+                return [];
+            }
+        });
+        if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
+            case REACT_FORWARD_REF_TYPE:
+                setSignature(type.render, key, forceReset, getCustomHooks);
+                break;
+            case REACT_MEMO_TYPE:
+                setSignature(type.type, key, forceReset, getCustomHooks);
+        }
+    }
+    function collectCustomHooksForSignature(type) {
+        type = allSignaturesByType.get(type);
+        void 0 !== type && computeFullKey(type);
+    }
+    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_MEMO_TYPE = Symbol.for("react.memo"), PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map, allFamiliesByID = new Map(), allFamiliesByType = new PossiblyWeakMap(), allSignaturesByType = new PossiblyWeakMap(), updatedFamiliesByType = new PossiblyWeakMap(), pendingUpdates = [], helpersByRendererID = new Map(), helpersByRoot = new Map(), mountedRoots = new Set(), failedRoots = new Set(), rootElements = "function" === typeof WeakMap ? new WeakMap() : null, isPerformingRefresh = !1;
+    exports._getMountedRootCount = function() {
+        return mountedRoots.size;
+    };
+    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
+    exports.createSignatureFunctionForTransform = function() {
+        var savedType, hasCustomHooks, didCollectHooks = !1;
+        return function(type, key, forceReset, getCustomHooks) {
+            if ("string" === typeof key) return savedType || (savedType = type, hasCustomHooks = "function" === typeof getCustomHooks), null == type || "function" !== typeof type && "object" !== typeof type || setSignature(type, key, forceReset, getCustomHooks), type;
+            !didCollectHooks && hasCustomHooks && (didCollectHooks = !0, collectCustomHooksForSignature(savedType));
+        };
+    };
+    exports.getFamilyByID = function(id) {
+        return allFamiliesByID.get(id);
+    };
+    exports.getFamilyByType = function(type) {
+        return allFamiliesByType.get(type);
+    };
+    exports.hasUnrecoverableErrors = function() {
+        return !1;
+    };
+    exports.injectIntoGlobalHook = function(globalObject) {
+        var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+        if (void 0 === hook) {
+            var nextID = 0;
+            globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+                renderers: new Map(),
+                supportsFiber: !0,
+                inject: function() {
+                    return nextID++;
+                },
+                onScheduleFiberRoot: function() {},
+                onCommitFiberRoot: function() {},
+                onCommitFiberUnmount: function() {}
+            };
+        }
+        if (hook.isDisabled) console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
+        else {
+            var oldInject = hook.inject;
+            hook.inject = function(injected) {
+                var id = oldInject.apply(this, arguments);
+                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
+                return id;
+            };
+            hook.renderers.forEach(function(injected, id) {
+                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
+            });
+            var oldOnCommitFiberRoot = hook.onCommitFiberRoot, oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {};
+            hook.onScheduleFiberRoot = function(id, root, children) {
+                isPerformingRefresh || (failedRoots.delete(root), null !== rootElements && rootElements.set(root, children));
+                return oldOnScheduleFiberRoot.apply(this, arguments);
+            };
+            hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
+                var helpers = helpersByRendererID.get(id);
+                if (void 0 !== helpers) {
+                    helpersByRoot.set(root, helpers);
+                    helpers = root.current;
+                    var alternate = helpers.alternate;
+                    null !== alternate ? (alternate = null != alternate.memoizedState && null != alternate.memoizedState.element && mountedRoots.has(root), helpers = null != helpers.memoizedState && null != helpers.memoizedState.element, !alternate && helpers ? (mountedRoots.add(root), failedRoots.delete(root)) : alternate && helpers || (alternate && !helpers ? (mountedRoots.delete(root), didError ? failedRoots.add(root) : helpersByRoot.delete(root)) : alternate || helpers || didError && failedRoots.add(root))) : mountedRoots.add(root);
+                }
+                return oldOnCommitFiberRoot.apply(this, arguments);
+            };
+        }
+    };
+    exports.isLikelyComponentType = function(type) {
+        switch(typeof type){
+            case "function":
+                if (null != type.prototype) {
+                    if (type.prototype.isReactComponent) return !0;
+                    var ownNames = Object.getOwnPropertyNames(type.prototype);
+                    if (1 < ownNames.length || "constructor" !== ownNames[0] || type.prototype.__proto__ !== Object.prototype) return !1;
+                }
+                type = type.name || type.displayName;
+                return "string" === typeof type && /^[A-Z]/.test(type);
+            case "object":
+                if (null != type) switch(getProperty(type, "$$typeof")){
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_MEMO_TYPE:
+                        return !0;
+                }
+                return !1;
+            default:
+                return !1;
+        }
+    };
+    exports.performReactRefresh = function() {
+        if (0 === pendingUpdates.length || isPerformingRefresh) return null;
+        isPerformingRefresh = !0;
+        try {
+            var staleFamilies = new Set(), updatedFamilies = new Set(), updates = pendingUpdates;
+            pendingUpdates = [];
+            updates.forEach(function(_ref) {
+                var family = _ref[0];
+                _ref = _ref[1];
+                var prevType = family.current;
+                updatedFamiliesByType.set(prevType, family);
+                updatedFamiliesByType.set(_ref, family);
+                family.current = _ref;
+                prevType.prototype && prevType.prototype.isReactComponent || _ref.prototype && _ref.prototype.isReactComponent ? _ref = !1 : (prevType = allSignaturesByType.get(prevType), _ref = allSignaturesByType.get(_ref), _ref = void 0 === prevType && void 0 === _ref || void 0 !== prevType && void 0 !== _ref && computeFullKey(prevType) === computeFullKey(_ref) && !_ref.forceReset ? !0 : !1);
+                _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
+            });
+            var update = {
+                updatedFamilies: updatedFamilies,
+                staleFamilies: staleFamilies
+            };
+            helpersByRendererID.forEach(function(helpers) {
+                helpers.setRefreshHandler(resolveFamily);
+            });
+            var didError = !1, firstError = null, failedRootsSnapshot = cloneSet(failedRoots), mountedRootsSnapshot = cloneSet(mountedRoots), helpersByRootSnapshot = cloneMap(helpersByRoot);
+            failedRootsSnapshot.forEach(function(root) {
+                var helpers = helpersByRootSnapshot.get(root);
+                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
+                failedRoots.has(root);
+                if (null !== rootElements && rootElements.has(root)) {
+                    var element = rootElements.get(root);
+                    try {
+                        helpers.scheduleRoot(root, element);
+                    } catch (err) {
+                        didError || (didError = !0, firstError = err);
+                    }
+                }
+            });
+            mountedRootsSnapshot.forEach(function(root) {
+                var helpers = helpersByRootSnapshot.get(root);
+                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
+                mountedRoots.has(root);
+                try {
+                    helpers.scheduleRefresh(root, update);
+                } catch (err) {
+                    didError || (didError = !0, firstError = err);
+                }
+            });
+            if (didError) throw firstError;
+            return update;
+        } finally{
+            isPerformingRefresh = !1;
+        }
+    };
+    exports.register = register;
+    exports.setSignature = setSignature;
+}();
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([]);
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)");
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
+;
+;
+// Hook into ReactDOM initialization
+__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].injectIntoGlobalHook(self);
+// Register global helpers
+self.$RefreshHelpers$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["default"];
+// Register a helper for module execution interception
+self.$RefreshInterceptModuleExecution$ = function(webpackModuleId) {
+    var prevRefreshReg = self.$RefreshReg$;
+    var prevRefreshSig = self.$RefreshSig$;
+    self.$RefreshReg$ = function(type, id) {
+        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(type, webpackModuleId + " " + id);
+    };
+    self.$RefreshSig$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].createSignatureFunctionForTransform;
+    // Modeled after `useEffect` cleanup pattern:
+    // https://react.dev/learn/synchronizing-with-effects#step-3-add-cleanup-if-needed
+    return function() {
+        self.$RefreshReg$ = prevRefreshReg;
+        self.$RefreshSig$ = prevRefreshSig;
+    };
+};
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "loadLazy",
+    ()=>loadLazy
+]);
+async function loadLazy() {
+    return __turbopack_context__.A("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript, async loader)");
+}
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[turbopack]/browser/dev/hmr-client/hmr-client.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+/// <reference path="../../../shared/runtime/runtime-types.d.ts" />
+/// <reference path="../../../shared/runtime/dev-globals.d.ts" />
+/// <reference path="../../../shared/runtime/dev-protocol.d.ts" />
+/// <reference path="../../../shared/runtime/dev-extensions.ts" />
+__turbopack_context__.s([
+    "TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL",
+    ()=>TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL,
+    "connect",
+    ()=>connect,
+    "setHooks",
+    ()=>setHooks,
+    "subscribeToUpdate",
+    ()=>subscribeToUpdate
+]);
+const TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL = 'TURBOPACK_CHUNK_UPDATE_LISTENERS';
+function connect({ addMessageListener, sendMessage, onUpdateError = console.error, chunkUpdateListenersGlobal }) {
+    const reportUpdateError = (e)=>{
+        console.warn('[Fast Refresh] performing full reload\n\n' + "Fast Refresh will perform a full reload when you edit a file that's imported by modules outside of the React rendering tree.\n" + 'You might have a file which exports a React component but also exports a value that is imported by a non-React component file.\n' + 'Consider migrating the non-React component export to a separate file and importing it into both files.\n\n' + 'It is also possible the parent component of the component you edited is a class component, which disables Fast Refresh.\n' + 'Fast Refresh requires at least one parent function component in your React tree.');
+        onUpdateError(e);
+        location.reload();
+    };
+    addMessageListener((msg)=>{
+        try {
+            switch(msg.type){
+                case 'turbopack-connected':
+                    handleSocketConnected(sendMessage);
+                    break;
+                default:
+                    {
+                        const completions = [];
+                        if (Array.isArray(msg.data)) {
+                            for(let i = 0; i < msg.data.length; i++){
+                                completions.push(handleSocketMessage(msg.data[i]));
+                            }
+                        } else {
+                            completions.push(handleSocketMessage(msg.data));
+                        }
+                        completions.push(applyAggregatedUpdates());
+                        void Promise.all(completions).catch(reportUpdateError);
+                        break;
+                    }
+            }
+        } catch (e) {
+            reportUpdateError(e);
+        }
+    });
+    const global = globalThis;
+    const queued = global[chunkUpdateListenersGlobal];
+    if (queued != null && !Array.isArray(queued)) {
+        throw new Error('A separate HMR handler was already registered');
+    }
+    global[chunkUpdateListenersGlobal] = {
+        push: ([chunkPath, callback, options])=>{
+            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.batch, options?.onSubscribed, options?.expectedVersion);
+        }
+    };
+    if (Array.isArray(queued)) {
+        for (const [chunkPath, callback, options] of queued){
+            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.batch, options?.onSubscribed, options?.expectedVersion);
+        }
+    }
+}
+const updateCallbackSets = new Map();
+function sendJSON(sendMessage, message) {
+    sendMessage(JSON.stringify(message));
+}
+function resourceKey(resource) {
+    return JSON.stringify({
+        path: resource.path,
+        headers: resource.headers || null
+    });
+}
+function subscribeToUpdates(sendMessage, resource, expectedVersion, validation) {
+    sendJSON(sendMessage, {
+        type: 'turbopack-subscribe',
+        ...resource,
+        version: expectedVersion,
+        validation
+    });
+    return ()=>{
+        sendJSON(sendMessage, {
+            type: 'turbopack-unsubscribe',
+            ...resource
+        });
+    };
+}
+function handleSocketConnected(sendMessage) {
+    for (const [key, callbackSet] of updateCallbackSets){
+        callbackSet.subscribed = false;
+        callbackSet.unsubscribe = subscribeToUpdates(sendMessage, JSON.parse(key), callbackSet.expectedVersion, callbackSet.validationToken);
+    }
+}
+// we aggregate all pending updates until the issues are resolved
+const chunkListsWithPendingUpdates = new Map();
+function aggregateUpdates(msg) {
+    const key = resourceKey(msg.resource);
+    let aggregated = chunkListsWithPendingUpdates.get(key);
+    if (aggregated) {
+        aggregated.instruction = mergeChunkListUpdates(aggregated.instruction, msg.instruction);
+    } else {
+        chunkListsWithPendingUpdates.set(key, msg);
+    }
+}
+function applyAggregatedUpdates() {
+    if (chunkListsWithPendingUpdates.size === 0) return Promise.resolve();
+    hooks.beforeRefresh();
+    const updates = [
+        ...chunkListsWithPendingUpdates.values()
+    ];
+    chunkListsWithPendingUpdates.clear();
+    const { handledCallbacks, completions } = triggerUpdateBatch(updates);
+    for (const msg of updates){
+        completions.push(...triggerUpdate(msg, handledCallbacks.get(msg.resource.path)));
+    }
+    return Promise.all(completions).then(()=>finalizeUpdate());
+}
+function triggerUpdateBatch(updates) {
+    const callbacks = new Map();
+    for (const update of updates){
+        const callbackSet = updateCallbackSets.get(resourceKey(update.resource));
+        if (callbackSet) {
+            for (const [callback, updateCallbacks] of callbackSet.batchCallbacks){
+                let registeredCallbacks = callbacks.get(callback);
+                if (!registeredCallbacks) {
+                    registeredCallbacks = new Set();
+                    callbacks.set(callback, registeredCallbacks);
+                }
+                for (const updateCallback of updateCallbacks){
+                    registeredCallbacks.add(updateCallback);
+                }
+            }
+        }
+    }
+    const handledCallbacks = new Map();
+    const completions = [];
+    for (const [callback, updateCallbacks] of callbacks){
+        const result = callback(updates);
+        if (result.completion) {
+            completions.push(result.completion);
+        }
+        for (const path of result.handledPaths){
+            let callbacksForPath = handledCallbacks.get(path);
+            if (!callbacksForPath) {
+                callbacksForPath = new Set();
+                handledCallbacks.set(path, callbacksForPath);
+            }
+            for (const updateCallback of updateCallbacks){
+                callbacksForPath.add(updateCallback);
+            }
+        }
+    }
+    return {
+        handledCallbacks,
+        completions
+    };
+}
+function mergeChunkListUpdates(updateA, updateB) {
+    let chunks;
+    if (updateA.chunks != null) {
+        if (updateB.chunks == null) {
+            chunks = updateA.chunks;
+        } else {
+            chunks = mergeChunkListChunks(updateA.chunks, updateB.chunks);
+        }
+    } else if (updateB.chunks != null) {
+        chunks = updateB.chunks;
+    }
+    let merged;
+    if (updateA.merged != null) {
+        if (updateB.merged == null) {
+            merged = updateA.merged;
+        } else {
+            // Since `merged` is an array of updates, we need to merge them all into
+            // one, consistent update.
+            // Since there can only be `EcmascriptMergeUpdates` in the array, there is
+            // no need to key on the `type` field.
+            let update = updateA.merged[0];
+            for(let i = 1; i < updateA.merged.length; i++){
+                update = mergeChunkListEcmascriptMergedUpdates(update, updateA.merged[i]);
+            }
+            for(let i = 0; i < updateB.merged.length; i++){
+                update = mergeChunkListEcmascriptMergedUpdates(update, updateB.merged[i]);
+            }
+            merged = [
+                update
+            ];
+        }
+    } else if (updateB.merged != null) {
+        merged = updateB.merged;
+    }
+    return {
+        type: 'ChunkListUpdate',
+        chunks,
+        merged
+    };
+}
+function mergeChunkListChunks(chunksA, chunksB) {
+    const chunks = {};
+    for (const [chunkPath, chunkUpdateA] of Object.entries(chunksA)){
+        const chunkUpdateB = chunksB[chunkPath];
+        if (chunkUpdateB != null) {
+            const mergedUpdate = mergeChunkUpdates(chunkUpdateA, chunkUpdateB);
+            if (mergedUpdate != null) {
+                chunks[chunkPath] = mergedUpdate;
+            }
+        } else {
+            chunks[chunkPath] = chunkUpdateA;
+        }
+    }
+    for (const [chunkPath, chunkUpdateB] of Object.entries(chunksB)){
+        if (chunks[chunkPath] == null) {
+            chunks[chunkPath] = chunkUpdateB;
+        }
+    }
+    return chunks;
+}
+function mergeChunkUpdates(updateA, updateB) {
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        return undefined;
+    }
+    if (updateB.type === 'total') {
+        // A total update replaces the entire chunk, so it supersedes any prior update.
+        return updateB;
+    }
+    if (updateA.type === 'partial') {
+        invariant(updateA.instruction, 'Partial updates are unsupported');
+    }
+    if (updateB.type === 'partial') {
+        invariant(updateB.instruction, 'Partial updates are unsupported');
+    }
+    return undefined;
+}
+function mergeChunkListEcmascriptMergedUpdates(mergedA, mergedB) {
+    const entries = mergeEcmascriptChunkEntries(mergedA.entries, mergedB.entries);
+    const chunks = mergeEcmascriptChunksUpdates(mergedA.chunks, mergedB.chunks);
+    return {
+        type: 'EcmascriptMergedUpdate',
+        entries,
+        chunks
+    };
+}
+function mergeEcmascriptChunkEntries(entriesA, entriesB) {
+    return {
+        ...entriesA,
+        ...entriesB
+    };
+}
+function mergeEcmascriptChunksUpdates(chunksA, chunksB) {
+    if (chunksA == null) {
+        return chunksB;
+    }
+    if (chunksB == null) {
+        return chunksA;
+    }
+    const chunks = {};
+    for (const [chunkPath, chunkUpdateA] of Object.entries(chunksA)){
+        const chunkUpdateB = chunksB[chunkPath];
+        if (chunkUpdateB != null) {
+            const mergedUpdate = mergeEcmascriptChunkUpdates(chunkUpdateA, chunkUpdateB);
+            if (mergedUpdate != null) {
+                chunks[chunkPath] = mergedUpdate;
+            }
+        } else {
+            chunks[chunkPath] = chunkUpdateA;
+        }
+    }
+    for (const [chunkPath, chunkUpdateB] of Object.entries(chunksB)){
+        if (chunks[chunkPath] == null) {
+            chunks[chunkPath] = chunkUpdateB;
+        }
+    }
+    if (Object.keys(chunks).length === 0) {
+        return undefined;
+    }
+    return chunks;
+}
+function mergeEcmascriptChunkUpdates(updateA, updateB) {
+    if (updateA.type === 'added' && updateB.type === 'deleted') {
+        // These two completely cancel each other out.
+        return undefined;
+    }
+    if (updateA.type === 'deleted' && updateB.type === 'added') {
+        const added = [];
+        const deleted = [];
+        const deletedModules = new Set(updateA.modules ?? []);
+        const addedModules = new Set(updateB.modules ?? []);
+        for (const moduleId of addedModules){
+            if (!deletedModules.has(moduleId)) {
+                added.push(moduleId);
+            }
+        }
+        for (const moduleId of deletedModules){
+            if (!addedModules.has(moduleId)) {
+                deleted.push(moduleId);
+            }
+        }
+        if (added.length === 0 && deleted.length === 0) {
+            return undefined;
+        }
+        return {
+            type: 'partial',
+            added,
+            deleted
+        };
+    }
+    if (updateA.type === 'partial' && updateB.type === 'partial') {
+        const added = new Set([
+            ...updateA.added ?? [],
+            ...updateB.added ?? []
+        ]);
+        const deleted = new Set([
+            ...updateA.deleted ?? [],
+            ...updateB.deleted ?? []
+        ]);
+        if (updateB.added != null) {
+            for (const moduleId of updateB.added){
+                deleted.delete(moduleId);
+            }
+        }
+        if (updateB.deleted != null) {
+            for (const moduleId of updateB.deleted){
+                added.delete(moduleId);
+            }
+        }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
+    }
+    if (updateA.type === 'added' && updateB.type === 'partial') {
+        const modules = new Set([
+            ...updateA.modules ?? [],
+            ...updateB.added ?? []
+        ]);
+        for (const moduleId of updateB.deleted ?? []){
+            modules.delete(moduleId);
+        }
+        return {
+            type: 'added',
+            modules: [
+                ...modules
+            ]
+        };
+    }
+    if (updateA.type === 'partial' && updateB.type === 'deleted') {
+        // We could eagerly return `updateB` here, but this would potentially be
+        // incorrect if `updateA` has added modules.
+        const modules = new Set(updateB.modules ?? []);
+        if (updateA.added != null) {
+            for (const moduleId of updateA.added){
+                modules.delete(moduleId);
+            }
+        }
+        return {
+            type: 'deleted',
+            modules: [
+                ...modules
+            ]
+        };
+    }
+    // Any other update combination is invalid.
+    return undefined;
+}
+function invariant(_, message) {
+    throw new Error(`Invariant: ${message}`);
+}
+const CRITICAL = [
+    'bug',
+    'error',
+    'fatal'
+];
+function compareByList(list, a, b) {
+    const aI = list.indexOf(a) + 1 || list.length;
+    const bI = list.indexOf(b) + 1 || list.length;
+    return aI - bI;
+}
+const chunksWithIssues = new Map();
+function emitIssues() {
+    const issues = [];
+    const deduplicationSet = new Set();
+    for (const [_, chunkIssues] of chunksWithIssues){
+        for (const chunkIssue of chunkIssues){
+            if (deduplicationSet.has(chunkIssue.formatted)) continue;
+            issues.push(chunkIssue);
+            deduplicationSet.add(chunkIssue.formatted);
+        }
+    }
+    sortIssues(issues);
+    hooks.issues(issues);
+}
+function handleIssues(msg) {
+    const key = resourceKey(msg.resource);
+    let hasCriticalIssues = false;
+    for (const issue of msg.issues){
+        if (CRITICAL.includes(issue.severity)) {
+            hasCriticalIssues = true;
+        }
+    }
+    if (msg.issues.length > 0) {
+        chunksWithIssues.set(key, msg.issues);
+    } else if (chunksWithIssues.has(key)) {
+        chunksWithIssues.delete(key);
+    }
+    emitIssues();
+    return hasCriticalIssues;
+}
+const SEVERITY_ORDER = [
+    'bug',
+    'fatal',
+    'error',
+    'warning',
+    'info',
+    'log'
+];
+const CATEGORY_ORDER = [
+    'parse',
+    'resolve',
+    'code generation',
+    'rendering',
+    'typescript',
+    'other'
+];
+function sortIssues(issues) {
+    issues.sort((a, b)=>{
+        const first = compareByList(SEVERITY_ORDER, a.severity, b.severity);
+        if (first !== 0) return first;
+        return compareByList(CATEGORY_ORDER, a.category, b.category);
+    });
+}
+const hooks = {
+    beforeRefresh: ()=>{},
+    refresh: ()=>{},
+    buildOk: ()=>{},
+    issues: (_issues)=>{}
+};
+function setHooks(newHooks) {
+    Object.assign(hooks, newHooks);
+}
+function handleSocketMessage(msg) {
+    const callbackSet = updateCallbackSets.get(resourceKey(msg.resource));
+    if (!callbackSet || callbackSet.validationToken !== msg.validation) {
+        // An unsubscribe cannot retract frames which were already queued on the
+        // transport. Ignore frames from an older subscription generation.
+        return Promise.resolve();
+    }
+    sortIssues(msg.issues);
+    const hasCriticalIssues = handleIssues(msg);
+    // A real issues message is the server's baseline acknowledgement. Updates
+    // received before that acknowledgement cannot safely be applied to dynamic
+    // chunks which may still be loading from HTTP.
+    if (!hasCriticalIssues && msg.type === 'issues') {
+        markUpdateSubscriptionReady(msg.resource);
+    } else if (msg.type !== 'issues') {
+        rejectUpdateSubscriptionValidation(msg.resource, new Error(`Received ${msg.type} before the HMR subscription baseline was validated.`));
+    }
+    switch(msg.type){
+        case 'issues':
+            // issues are already handled
+            return Promise.resolve();
+        case 'partial':
+            // aggregate updates
+            aggregateUpdates(msg);
+            return Promise.resolve();
+        default:
+            // run single update
+            const runHooks = chunkListsWithPendingUpdates.size === 0;
+            if (runHooks) hooks.beforeRefresh();
+            return Promise.all(triggerUpdate(msg)).then(()=>{
+                if (runHooks) finalizeUpdate();
+            });
+    }
+}
+function markUpdateSubscriptionReady(resource) {
+    const callbackSet = updateCallbackSets.get(resourceKey(resource));
+    if (!callbackSet || callbackSet.subscribed) {
+        return;
+    }
+    callbackSet.subscribed = true;
+    callbackSet.validation?.resolve();
+    callbackSet.validation = undefined;
+    for (const callback of callbackSet.onSubscribedCallbacks){
+        callback(callbackSet.revalidate);
+    }
+    callbackSet.onSubscribedCallbacks.clear();
+}
+function rejectUpdateSubscriptionValidation(resource, error) {
+    const callbackSet = updateCallbackSets.get(resourceKey(resource));
+    if (!callbackSet || callbackSet.subscribed) return;
+    callbackSet.validation?.reject(error);
+    callbackSet.validation = undefined;
+}
+function finalizeUpdate() {
+    hooks.refresh();
+    hooks.buildOk();
+    // This is used by the Next.js integration test suite to notify it when HMR
+    // updates have been completed.
+    // TODO: Only run this in test environments (gate by `process.env.__NEXT_TEST_MODE`)
+    if (globalThis.__NEXT_HMR_CB) {
+        globalThis.__NEXT_HMR_CB();
+        globalThis.__NEXT_HMR_CB = null;
+    }
+}
+function subscribeToChunkUpdate(chunkListPath, sendMessage, callback, batchCallback, onSubscribed, expectedVersion) {
+    return subscribeToUpdate({
+        path: chunkListPath
+    }, sendMessage, callback, batchCallback, onSubscribed, expectedVersion);
+}
+function subscribeToUpdate(resource, sendMessage, callback, batchCallback, onSubscribed, expectedVersion) {
+    const key = resourceKey(resource);
+    let callbackSet;
+    const existingCallbackSet = updateCallbackSets.get(key);
+    if (!existingCallbackSet) {
+        let callbackSetRef;
+        const revalidate = ()=>{
+            if (callbackSetRef.validation) {
+                return callbackSetRef.validation.promise;
+            }
+            if (updateCallbackSets.get(key) !== callbackSetRef) {
+                return Promise.reject(new Error(`Cannot validate an inactive HMR subscription for ${resource.path}.`));
+            }
+            callbackSetRef.unsubscribe();
+            callbackSetRef.subscribed = false;
+            callbackSetRef.validationToken = `${Date.now()}:${Math.random()}`;
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            callbackSetRef.validation = {
+                promise,
+                resolve,
+                reject
+            };
+            callbackSetRef.unsubscribe = subscribeToUpdates(sendMessage, resource, expectedVersion, callbackSetRef.validationToken);
+            return promise;
+        };
+        callbackSet = {
+            callbacks: new Set([
+                callback
+            ]),
+            batchCallbacks: new Map(batchCallback ? [
+                [
+                    batchCallback,
+                    new Set([
+                        callback
+                    ])
+                ]
+            ] : []),
+            onSubscribedCallbacks: new Set(onSubscribed ? [
+                onSubscribed
+            ] : []),
+            subscribed: false,
+            expectedVersion,
+            revalidate,
+            unsubscribe: subscribeToUpdates(sendMessage, resource, expectedVersion)
+        };
+        callbackSetRef = callbackSet;
+        updateCallbackSets.set(key, callbackSet);
+    } else {
+        if (existingCallbackSet.expectedVersion !== expectedVersion) {
+            // Two manifests for the same stable chunk-list path cannot safely share
+            // a version baseline. Reload rather than acknowledging stale content.
+            location.reload();
+        }
+        existingCallbackSet.callbacks.add(callback);
+        if (batchCallback) {
+            let callbacks = existingCallbackSet.batchCallbacks.get(batchCallback);
+            if (!callbacks) {
+                callbacks = new Set();
+                existingCallbackSet.batchCallbacks.set(batchCallback, callbacks);
+            }
+            callbacks.add(callback);
+        }
+        if (onSubscribed) {
+            if (existingCallbackSet.subscribed) {
+                onSubscribed(existingCallbackSet.revalidate);
+            } else {
+                existingCallbackSet.onSubscribedCallbacks.add(onSubscribed);
+            }
+        }
+        callbackSet = existingCallbackSet;
+    }
+    return ()=>{
+        callbackSet.callbacks.delete(callback);
+        if (batchCallback) {
+            const callbacks = callbackSet.batchCallbacks.get(batchCallback);
+            callbacks?.delete(callback);
+            if (callbacks?.size === 0) {
+                callbackSet.batchCallbacks.delete(batchCallback);
+            }
+        }
+        if (onSubscribed) {
+            callbackSet.onSubscribedCallbacks.delete(onSubscribed);
+        }
+        if (callbackSet.callbacks.size === 0) {
+            callbackSet.unsubscribe();
+            updateCallbackSets.delete(key);
+            callbackSet.validationToken = undefined;
+            callbackSet.validation?.reject(new Error(`HMR subscription for ${resource.path} was removed.`));
+            callbackSet.validation = undefined;
+        }
+    };
+}
+function triggerUpdate(msg, skippedCallbacks) {
+    const key = resourceKey(msg.resource);
+    const callbackSet = updateCallbackSets.get(key);
+    if (!callbackSet) {
+        return [];
+    }
+    const completions = [];
+    for (const callback of callbackSet.callbacks){
+        if (!skippedCallbacks?.has(callback)) {
+            const completion = callback(msg);
+            if (completion) {
+                completions.push(completion);
+            }
+        }
+    }
+    if (msg.type === 'notFound') {
+        // This indicates that the resource which we subscribed to either does not exist or
+        // has been deleted. In either case, we should clear all update callbacks, so if a
+        // new subscription is created for the same resource, it will send a new "subscribe"
+        // message to the server.
+        // No need to send an "unsubscribe" message to the server, it will have already
+        // dropped the update stream before sending the "notFound" message.
+        updateCallbackSets.delete(key);
+    }
+    return completions;
+}
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js
deleted file mode 100644
index b9434c796..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_3f44269c.js
+++ /dev/null
@@ -1,13 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "loadLazy",
-    ()=>loadLazy
-]);
-async function loadLazy() {
-    return __turbopack_context__.A("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript, async loader)");
-}
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
index 9cc7d78e4..eccaf0234 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
@@ -1,5 +1,7 @@
 (globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
     script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["input_lazy_91bce909.js","input_index_3f44269c.js"],
-    source: "entry"
+    chunks: ["input_lazy_b90c1087.js","_root-of-the-server___7c304173.js"],
+    chunkVersions: {},
+    source: "entry",
+    version: "VstQW4OIbsE"
 });
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
similarity index 65%
rename from crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js
rename to crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
index 46c3090d2..04aaa0617 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_7d0cc84b.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
@@ -1,5 +1,7 @@
 (globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
     script: typeof document === "object" ? document.currentScript : undefined,
     chunks: ["input_lazy_5395e95a.js"],
-    source: "dynamic"
+    chunkVersions: {"input_lazy_5395e95a.js":"kLSvJuOI5c4"},
+    source: "dynamic",
+    version: "ajrJuYAhFyU"
 });
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
index db0b12372..3ff5fe527 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
@@ -7,5 +7,8 @@ __turbopack_context__.s([
     ()=>value
 ]);
 const value = 'lazy';
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
 }),
 ]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js
similarity index 90%
rename from crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js
rename to crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js
index d47ce8825..4f973a332 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_91bce909.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js
@@ -3,8 +3,7 @@
 
 __turbopack_context__.v((parentImport) => {
     return Promise.all([
-  "input_lazy_5395e95a.js",
-  "input_lazy_7d0cc84b.js"
+  "input_lazy_0468b002.js"
 ].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
         return parentImport("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript)");
     });
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
index fb3eadd93..4f6357a05 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
@@ -1,6 +1,6 @@
 (globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
     typeof document === "object" ? document.currentScript : undefined,
-    {"otherChunks":["input_lazy_91bce909.js","input_index_3f44269c.js"],"runtimeModuleIds":["[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)"]}
+    {"otherChunks":["input_lazy_b90c1087.js","_root-of-the-server___7c304173.js"],"runtimeModuleIds":["[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)","[@utoo/pack-runtime]/hmr/bootstrap.ts [client] (ecmascript)","[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)"]}
 ]);
 (() => {
 if (!Array.isArray(globalThis["TURBOPACK"])) {
@@ -11,6 +11,10 @@ var CHUNK_BASE_PATH = "/";
 var WORKER_BASE_PATH = null;
 var RELATIVE_ROOT_PATH = "/ROOT";
 var RUNTIME_PUBLIC_PATH = "/";
+globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"] ||= [];
+var CHUNK_UPDATE_LISTENERS = {
+    push: (registration) => globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"].push(registration),
+};
 var ASSET_SUFFIX = "";
 var CROSS_ORIGIN = null;
 var CHUNK_LOAD_RETRY_MAX_ATTEMPTS = 1;
@@ -669,6 +673,19 @@ browserContextPrototype.l = loadChunk;
 function loadInitialChunk(chunkPath, chunkData) {
     return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
 }
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+/**
+ * Dynamic chunk-list manifests have already done their own availability
+ * calculation. Load the exact member URL for this manifest generation so an
+ * older in-flight request cannot be reused by a replacement generation.
+ */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
+    const memberChunkPath = getChunkPath(chunkData);
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
+}
 async function loadChunkInternal(sourceType, sourceData, chunkData) {
     if (typeof chunkData === 'string') {
         return loadChunkPath(sourceType, sourceData, chunkData);
@@ -865,6 +882,21 @@ function getPathFromScript(chunkScript) {
  * Determine the chunk to register. Note that this function has side-effects!
  */ function getChunkFromRegistration(chunk) {
     if (typeof chunk === 'string') {
+        if (typeof document !== 'undefined') {
+            const src = document.currentScript?.getAttribute('src');
+            if (src && getPathFromScript({
+                src
+            }) === chunk) {
+                return {
+                    src
+                };
+            }
+        }
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        }
         return chunk;
     } else if (!chunk) {
         if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
@@ -1637,6 +1669,13 @@ function getRefreshBoundaryExports(exports) {
 /**
  * Map from a chunk path to the chunk lists it belongs to.
  */ const chunkChunkListsMap = new Map();
+const dynamicChunkListLoadStates = new Map();
+const pendingHmrTasks = [];
+const chunkListGenerations = new Map();
+let nextChunkListGeneration = 1;
+let activeHmrTask;
+const discardedChunkRegistrations = new Set();
+const dynamicMemberChunkUrlOwners = new Map();
 /**
  * Gets or instantiates a runtime module.
  */ // @ts-ignore
@@ -1786,48 +1825,259 @@ const DUMMY_REFRESH_CONTEXT = {
         disposedModules
     };
 }
-function applyUpdate(update) {
-    switch(update.type){
-        case 'ChunkListUpdate':
-            applyChunkListUpdate(update);
-            break;
-        default:
-            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+const PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict');
+function mergeParallelChunkUpdate(updateA, updateB) {
+    if (updateA.type === updateB.type) {
+        return updateA;
     }
+    if (updateA.type === 'total' || updateB.type === 'total') {
+        return {
+            type: 'total'
+        };
+    }
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        return null;
+    }
+    return PARALLEL_UPDATE_CONFLICT;
 }
-function applyChunkListUpdate(update) {
-    if (update.merged != null) {
-        for (const merged of update.merged){
-            switch(merged.type){
-                case 'EcmascriptMergedUpdate':
-                    applyEcmascriptMergedUpdate(merged);
-                    break;
-                default:
-                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+function mergeParallelEcmascriptChunkUpdate(updateA, updateB) {
+    if (updateA.type === 'added' && updateB.type === 'added') {
+        return {
+            type: 'added',
+            modules: [
+                ...new Set([
+                    ...updateA.modules ?? [],
+                    ...updateB.modules ?? []
+                ])
+            ]
+        };
+    }
+    if (updateA.type === 'deleted' && updateB.type === 'deleted') {
+        return {
+            type: 'deleted',
+            modules: [
+                ...new Set([
+                    ...updateA.modules ?? [],
+                    ...updateB.modules ?? []
+                ])
+            ]
+        };
+    }
+    if (updateA.type === 'partial' && updateB.type === 'partial') {
+        const added = new Set([
+            ...updateA.added ?? [],
+            ...updateB.added ?? []
+        ]);
+        const deleted = new Set([
+            ...updateA.deleted ?? [],
+            ...updateB.deleted ?? []
+        ]);
+        for (const moduleId of added){
+            if (deleted.has(moduleId)) {
+                added.delete(moduleId);
+                deleted.delete(moduleId);
+            }
+        }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
+    }
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        const addedUpdate = updateA.type === 'added' ? updateA : updateB;
+        const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB;
+        const added = new Set(addedUpdate.modules ?? []);
+        const deleted = new Set(deletedUpdate.modules ?? []);
+        for (const moduleId of added){
+            if (deleted.has(moduleId)) {
+                added.delete(moduleId);
+                deleted.delete(moduleId);
             }
         }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
     }
-    if (update.chunks != null) {
-        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-            const chunkUrl = getChunkRelativeUrl(chunkPath);
-            switch(chunkUpdate.type){
-                case 'added':
-                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
-                    break;
-                case 'total':
-                    DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    break;
-                case 'deleted':
-                    DEV_BACKEND.unloadChunk?.(chunkUrl);
-                    break;
-                case 'partial':
-                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                    break;
-                default:
-                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+    if (updateA.type === 'partial') {
+        if ((updateA.added?.length ?? 0) === 0 && (updateA.deleted?.length ?? 0) === 0) {
+            return updateB;
+        }
+        return PARALLEL_UPDATE_CONFLICT;
+    }
+    if (updateB.type === 'partial') {
+        if ((updateB.added?.length ?? 0) === 0 && (updateB.deleted?.length ?? 0) === 0) {
+            return updateA;
+        }
+        return PARALLEL_UPDATE_CONFLICT;
+    }
+    return PARALLEL_UPDATE_CONFLICT;
+}
+function moduleEntriesEqual(entryA, entryB) {
+    // The same module can be emitted into multiple chunks. Its source URL is
+    // chunk-relative, so it is allowed to differ even when the executable entry
+    // is identical. Treat only code and source map differences as conflicts.
+    return entryA.code === entryB.code && entryA.map === entryB.map;
+}
+function applyChunkListUpdates(updates) {
+    const resourceOperations = [];
+    const ownershipTransitions = new Map();
+    const chunks = new Map();
+    const ecmascriptChunks = new Map();
+    const entries = {};
+    const explicitlyModifiedModules = new Set();
+    let hasConflict = false;
+    for (const { chunkListPath, update } of updates){
+        if (update.chunks) {
+            for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+                if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, chunkUpdate.type, ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                }
+                if (!chunks.has(chunkPath)) {
+                    chunks.set(chunkPath, chunkUpdate);
+                } else {
+                    const previous = chunks.get(chunkPath);
+                    if (previous === null) {
+                        chunks.set(chunkPath, chunkUpdate);
+                    } else {
+                        const merged = mergeParallelChunkUpdate(previous, chunkUpdate);
+                        if (merged === PARALLEL_UPDATE_CONFLICT) {
+                            hasConflict = true;
+                        } else {
+                            chunks.set(chunkPath, merged);
+                        }
+                    }
+                }
+            }
+        }
+        for (const merged of update.merged ?? []){
+            if (merged.type !== 'EcmascriptMergedUpdate') {
+                invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+            const addedInThisUpdate = new Set();
+            for (const [chunkPath, chunkUpdate] of Object.entries(merged.chunks ?? {})){
+                if (chunkUpdate.type === 'added') {
+                    for (const moduleId of chunkUpdate.modules ?? []){
+                        addedInThisUpdate.add(moduleId);
+                    }
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'added', ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                } else if (chunkUpdate.type === 'deleted') {
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'deleted', ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                } else {
+                    for (const moduleId of chunkUpdate.added ?? []){
+                        addedInThisUpdate.add(moduleId);
+                    }
+                }
+                const previous = ecmascriptChunks.get(chunkPath);
+                if (!previous) {
+                    ecmascriptChunks.set(chunkPath, chunkUpdate);
+                } else {
+                    const combined = mergeParallelEcmascriptChunkUpdate(previous, chunkUpdate);
+                    if (combined === PARALLEL_UPDATE_CONFLICT) {
+                        hasConflict = true;
+                    } else {
+                        ecmascriptChunks.set(chunkPath, combined);
+                    }
+                }
+            }
+            for (const [moduleId, entry] of Object.entries(merged.entries ?? {})){
+                const previous = entries[moduleId];
+                if (previous) {
+                    if (!moduleEntriesEqual(previous, entry)) {
+                        hasConflict = true;
+                    }
+                } else {
+                    entries[moduleId] = entry;
+                }
+                if (!addedInThisUpdate.has(moduleId)) {
+                    explicitlyModifiedModules.add(moduleId);
+                }
             }
         }
     }
+    if (hasConflict) {
+        DEV_BACKEND.restart();
+        return resourceOperations;
+    }
+    const filteredEcmascriptChunks = {};
+    for (const [chunkPath, chunkUpdate] of ecmascriptChunks){
+        const transition = ownershipTransitions.get(chunkPath);
+        if (chunkUpdate.type === 'added' && transition && transition.before > 0) {
+            for (const moduleId of chunkUpdate.modules ?? []){
+                if (!explicitlyModifiedModules.has(moduleId)) {
+                    delete entries[moduleId];
+                }
+            }
+            continue;
+        }
+        if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {
+            continue;
+        }
+        filteredEcmascriptChunks[chunkPath] = chunkUpdate;
+    }
+    if (Object.keys(entries).length > 0 || Object.keys(filteredEcmascriptChunks).length > 0) {
+        applyEcmascriptMergedUpdate({
+            type: 'EcmascriptMergedUpdate',
+            entries,
+            chunks: filteredEcmascriptChunks
+        });
+    }
+    for (const [chunkPath, chunkUpdate] of chunks){
+        if (chunkUpdate === null) {
+            continue;
+        }
+        const transition = ownershipTransitions.get(chunkPath);
+        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+        const chunkUrl = getChunkRelativeUrl(chunkPath);
+        switch(chunkUpdate.type){
+            case 'added':
+                if (!transition || transition.before === 0 && transition.after > 0) {
+                    resourceOperations.push({
+                        chunkPath,
+                        promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl)
+                    });
+                }
+                break;
+            case 'total':
+                if (ownerCount > 0) {
+                    const promise = DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    if (promise) {
+                        resourceOperations.push({
+                            chunkPath,
+                            promise
+                        });
+                    }
+                }
+                break;
+            case 'deleted':
+                if (!transition || transition.before > 0 && transition.after === 0) {
+                    disposeChunk(chunkPath);
+                }
+                break;
+            case 'partial':
+                invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                break;
+            default:
+                invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+        }
+    }
+    return resourceOperations;
 }
 function applyEcmascriptMergedUpdate(update) {
     // Browser-specific chunk management phase
@@ -1847,13 +2097,196 @@ function applyEcmascriptMergedUpdate(update) {
         autoAcceptRootModules: false
     });
 }
+function getCurrentTaskPaths(task) {
+    return task.chunkLists.filter(({ path, generation })=>chunkListGenerations.get(path) === generation).map(({ path })=>path);
+}
+function isHmrTaskBlocked(task) {
+    return task.chunkLists.some(({ path, generation })=>{
+        if (chunkListGenerations.get(path) !== generation) return false;
+        const state = dynamicChunkListLoadStates.get(path);
+        return state?.generation === generation && state.loading;
+    });
+}
+function runHmrTask(task) {
+    activeHmrTask = task;
+    void (async ()=>{
+        let resourceOperations = [];
+        try {
+            const currentPaths = new Set(getCurrentTaskPaths(task));
+            if (currentPaths.size > 0) {
+                resourceOperations = task.apply(currentPaths);
+                const results = await Promise.allSettled(resourceOperations.map(({ promise })=>promise));
+                const failedIndex = results.findIndex((result, index)=>result.status === 'rejected' && chunkChunkListsMap.has(resourceOperations[index].chunkPath));
+                if (failedIndex !== -1) {
+                    throw results[failedIndex].reason;
+                }
+            }
+            task.resolve();
+        } catch (cause) {
+            // A terminal update invalidates the generation immediately. Any member
+            // request it cancelled belongs to that old generation and must not turn
+            // a valid replacement subscription into a page reload.
+            if (getCurrentTaskPaths(task).length === 0) {
+                task.resolve();
+            } else {
+                task.reject(cause);
+            }
+        } finally{
+            for (const { chunkPath } of resourceOperations){
+                if (!chunkChunkListsMap.has(chunkPath)) {
+                    disposeChunk(chunkPath);
+                }
+            }
+            if (activeHmrTask === task) {
+                activeHmrTask = undefined;
+            }
+            flushPendingHmrTasks();
+        }
+    })();
+}
+function scheduleHmrTask(chunkListPaths, apply) {
+    const chunkLists = [
+        ...new Set(chunkListPaths)
+    ].flatMap((path)=>{
+        const generation = chunkListGenerations.get(path);
+        return generation === undefined ? [] : [
+            {
+                path,
+                generation
+            }
+        ];
+    });
+    if (chunkLists.length === 0) {
+        return Promise.resolve();
+    }
+    let resolve;
+    let reject;
+    const completion = new Promise((innerResolve, innerReject)=>{
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    const task = {
+        chunkLists,
+        apply,
+        resolve,
+        reject
+    };
+    for (const { path, generation } of chunkLists){
+        const state = dynamicChunkListLoadStates.get(path);
+        if (state?.generation === generation && state.bootstrapping && !state.terminated) {
+            state.pendingTasks.add(completion);
+            void completion.then(()=>state.pendingTasks.delete(completion), ()=>state.pendingTasks.delete(completion));
+        }
+    }
+    if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {
+        pendingHmrTasks.push(task);
+        flushPendingHmrTasks();
+    } else {
+        runHmrTask(task);
+    }
+    return completion;
+}
+function flushPendingHmrTasks() {
+    if (activeHmrTask) return;
+    while(pendingHmrTasks.length > 0){
+        const task = pendingHmrTasks[0];
+        if (getCurrentTaskPaths(task).length === 0) {
+            pendingHmrTasks.shift();
+            task.resolve();
+            continue;
+        }
+        if (isHmrTaskBlocked(task)) {
+            return;
+        }
+        pendingHmrTasks.shift();
+        runHmrTask(task);
+        return;
+    }
+}
+function handleApplyBatch(updates) {
+    const relevantUpdates = updates.map((update)=>({
+            chunkListPath: update.resource.path,
+            update: update.instruction
+        })).filter(({ chunkListPath })=>chunkListChunksMap.has(chunkListPath));
+    const chunkListPaths = [
+        ...new Set(relevantUpdates.map(({ chunkListPath })=>chunkListPath))
+    ];
+    if (chunkListPaths.length === 0) {
+        return {
+            handledPaths: []
+        };
+    }
+    const bootstrappingPaths = chunkListPaths.filter((chunkListPath)=>{
+        const state = dynamicChunkListLoadStates.get(chunkListPath);
+        return state?.bootstrapping && !state.terminated;
+    });
+    if (bootstrappingPaths.length > 0) {
+        for (const chunkListPath of bootstrappingPaths){
+            const state = dynamicChunkListLoadStates.get(chunkListPath);
+            terminateDynamicChunkListLoad(chunkListPath, state, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
+        }
+        DEV_BACKEND.restart();
+        flushPendingHmrTasks();
+        return {
+            handledPaths: chunkListPaths
+        };
+    }
+    const completion = scheduleHmrTask(chunkListPaths, (currentPaths)=>{
+        const chunkListUpdates = relevantUpdates.filter(({ chunkListPath })=>currentPaths.has(chunkListPath)).map(({ chunkListPath, update })=>{
+            if (update.type !== 'ChunkListUpdate') {
+                invariant(update, (update)=>`Unknown update type: ${update.type}`);
+            }
+            return {
+                chunkListPath,
+                update
+            };
+        });
+        return chunkListUpdates.length > 0 ? applyChunkListUpdates(chunkListUpdates) : [];
+    });
+    return {
+        handledPaths: chunkListPaths,
+        completion
+    };
+}
 function handleApply(chunkListPath, update) {
+    const loadState = dynamicChunkListLoadStates.get(chunkListPath);
+    if (update.type === 'partial' && loadState?.bootstrapping && !loadState.terminated) {
+        terminateDynamicChunkListLoad(chunkListPath, loadState, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
+        DEV_BACKEND.restart();
+        flushPendingHmrTasks();
+        return Promise.resolve();
+    }
+    if (update.type === 'notFound' || update.type === 'restart') {
+        if (loadState && !loadState.terminated) {
+            const error = new Error(update.type === 'notFound' ? `Dynamic chunk list ${chunkListPath} disappeared while loading.` : `Dynamic chunk list ${chunkListPath} must restart while loading.`);
+            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+        }
+        if (update.type === 'restart') {
+            chunkListGenerations.delete(chunkListPath);
+            dynamicChunkListLoadStates.delete(chunkListPath);
+        }
+        handleApplyImmediately(chunkListPath, update);
+        flushPendingHmrTasks();
+        return Promise.resolve();
+    }
+    return scheduleHmrTask([
+        chunkListPath
+    ], (currentPaths)=>currentPaths.has(chunkListPath) ? handleApplyImmediately(chunkListPath, update) : []);
+}
+function handleApplyImmediately(chunkListPath, update) {
     switch(update.type){
         case 'partial':
             {
                 // This indicates that the update is can be applied to the current state of the application.
-                applyUpdate(update.instruction);
-                break;
+                if (update.instruction.type !== 'ChunkListUpdate') {
+                    invariant(update.instruction, (instruction)=>`Unknown update type: ${instruction.type}`);
+                }
+                return applyChunkListUpdates([
+                    {
+                        chunkListPath,
+                        update: update.instruction
+                    }
+                ]);
             }
         case 'restart':
             {
@@ -1861,7 +2294,7 @@ function handleApply(chunkListPath, update) {
                 // current state of the application, and that the application must be
                 // restarted.
                 DEV_BACKEND.restart();
-                break;
+                return [];
             }
         case 'notFound':
             {
@@ -1874,12 +2307,73 @@ function handleApply(chunkListPath, update) {
                 } else {
                     disposeChunkList(chunkListPath);
                 }
-                break;
+                return [];
             }
         default:
             throw new Error(`Unknown update type: ${update.type}`);
     }
 }
+function applyChunkListMembershipDelta(chunkListPath, chunkPath, type, transitions) {
+    let transition = transitions.get(chunkPath);
+    if (!transition) {
+        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+        transition = {
+            before: ownerCount,
+            after: ownerCount
+        };
+        transitions.set(chunkPath, transition);
+    }
+    const changed = type === 'added' ? addChunkToChunkList(chunkListPath, chunkPath) : removeChunkFromChunkList(chunkListPath, chunkPath);
+    transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+    return changed;
+}
+function addChunkToChunkList(chunkListPath, chunkPath) {
+    let chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (!chunkPaths) {
+        chunkPaths = new Set();
+        chunkListChunksMap.set(chunkListPath, chunkPaths);
+    }
+    if (chunkPaths.has(chunkPath)) {
+        return false;
+    }
+    chunkPaths.add(chunkPath);
+    let chunkLists = chunkChunkListsMap.get(chunkPath);
+    if (!chunkLists) {
+        chunkLists = new Set();
+        chunkChunkListsMap.set(chunkPath, chunkLists);
+    }
+    chunkLists.add(chunkListPath);
+    return true;
+}
+function removeChunkFromChunkList(chunkListPath, chunkPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    const chunkLists = chunkChunkListsMap.get(chunkPath);
+    if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {
+        return false;
+    }
+    chunkPaths.delete(chunkPath);
+    chunkLists.delete(chunkListPath);
+    if (chunkLists.size === 0) {
+        chunkChunkListsMap.delete(chunkPath);
+    }
+    return true;
+}
+function setChunkListChunks(chunkListPath, nextChunkPaths) {
+    const previousChunkPaths = new Set(chunkListChunksMap.get(chunkListPath) ?? []);
+    if (!chunkListChunksMap.has(chunkListPath)) {
+        chunkListChunksMap.set(chunkListPath, new Set());
+    }
+    for (const chunkPath of previousChunkPaths){
+        if (!nextChunkPaths.has(chunkPath) && removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+            disposeChunk(chunkPath);
+        }
+    }
+    for (const chunkPath of nextChunkPaths){
+        if (!previousChunkPaths.has(chunkPath)) {
+            addChunkToChunkList(chunkListPath, chunkPath);
+        }
+    }
+}
 /**
  * Removes a module from a chunk.
  * Returns `true` if there are no remaining chunks including this module.
@@ -1898,6 +2392,70 @@ function handleApply(chunkListPath, update) {
     }
     return noRemainingChunks;
 }
+function terminateDynamicChunkListLoad(chunkListPath, state, error) {
+    if (state.terminated) return;
+    state.loading = false;
+    state.bootstrapping = false;
+    state.terminated = true;
+    state.rejectSubscribed?.(error);
+    BACKEND.rejectChunk?.(chunkListPath, error);
+    for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
+        releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
+    }
+}
+function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
+    // Reusing the same content-version URL is safe: a tombstone for an older
+    // generation represents identical content and must not discard this load.
+    discardedChunkRegistrations.delete(chunkUrl);
+    let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (!owners) {
+        owners = new Map();
+        dynamicMemberChunkUrlOwners.set(chunkUrl, owners);
+    }
+    owners.set(chunkListPath, generation);
+}
+function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath, chunkUrl) {
+    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (owners?.get(chunkListPath) !== generation) return;
+    owners.delete(chunkListPath);
+    if (owners.size > 0) return;
+    dynamicMemberChunkUrlOwners.delete(chunkUrl);
+    if (isJs(chunkUrl)) {
+        // Executed factories are already tracked by logical chunk ownership. The
+        // exact URL still needs a tombstone so a cancelled in-flight script cannot
+        // register stale factories after this generation has been discarded.
+        discardedChunkRegistrations.add(chunkUrl);
+        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+    } else {
+        const hasOtherChunkListOwner = [
+            ...chunkChunkListsMap.get(chunkPath) ?? []
+        ].some((owner)=>owner !== chunkListPath);
+        if (hasOtherChunkListOwner) return;
+        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+    }
+    if (!chunkChunkListsMap.has(chunkPath)) {
+        disposeChunk(chunkPath);
+    }
+}
+function completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
+    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (owners?.get(chunkListPath) !== generation) return;
+    owners.delete(chunkListPath);
+    if (owners.size === 0) {
+        dynamicMemberChunkUrlOwners.delete(chunkUrl);
+    }
+}
+function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken) {
+    const chunkPath = getChunkPath(chunkData);
+    const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken);
+    if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {
+        // A previous owner may have loaded an older content-version URL for the
+        // same stylesheet. Swap it only after the new CSS has loaded so dynamic
+        // lists never accumulate duplicate cascade entries.
+        return DEV_BACKEND.loadChunkReplacing(chunkUrl);
+    }
+    return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
+}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -1905,15 +2463,17 @@ function handleApply(chunkListPath, update) {
     if (chunkPaths == null) {
         return false;
     }
-    chunkListChunksMap.delete(chunkListPath);
-    for (const chunkPath of chunkPaths){
-        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        chunkChunkLists.delete(chunkListPath);
-        if (chunkChunkLists.size === 0) {
-            chunkChunkListsMap.delete(chunkPath);
+    for (const chunkPath of [
+        ...chunkPaths
+    ]){
+        if (removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
             disposeChunk(chunkPath);
         }
     }
+    chunkListChunksMap.delete(chunkListPath);
+    chunkListGenerations.delete(chunkListPath);
+    dynamicChunkListLoadStates.delete(chunkListPath);
+    runtimeChunkLists.delete(chunkListPath);
     // We must also dispose of the chunk list's chunk itself to ensure it may
     // be reloaded properly in the future.
     const chunkListUrl = getChunkRelativeUrl(chunkListPath);
@@ -1933,7 +2493,7 @@ function handleApply(chunkListPath, update) {
     if (chunkModules == null) {
         return false;
     }
-    chunkModules.delete(chunkPath);
+    chunkModulesMap.delete(chunkPath);
     for (const moduleId of chunkModules){
         const moduleChunks = moduleChunksMap.get(moduleId);
         moduleChunks.delete(chunkPath);
@@ -1983,7 +2543,13 @@ function registerChunk(registration) {
         runtimeParams = registration[1];
     } else {
         let chunkPath = getPathFromScript(chunk);
+        const chunkUrl = getUrlFromScript(chunk);
         runtimeParams = undefined;
+        if (discardedChunkRegistrations.delete(chunkUrl)) {
+            const result = BACKEND.registerChunk(chunk, runtimeParams);
+            DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+            return result;
+        }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
     return BACKEND.registerChunk(chunk, runtimeParams);
@@ -1993,31 +2559,135 @@ function registerChunk(registration) {
  */ function registerChunkList(chunkList) {
     const chunkListScript = getChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
-    // The "chunk" is also registered to finish the loading in the backend
-    BACKEND.registerChunk(chunkListPath);
-    globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS.push([
-        chunkListPath,
-        handleApply.bind(null, chunkListPath)
-    ]);
-    // Adding chunks to chunk lists and vice versa.
+    const generation = nextChunkListGeneration++;
+    chunkListGenerations.set(chunkListPath, generation);
     const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    chunkListChunksMap.set(chunkListPath, chunkPaths);
-    for (const chunkPath of chunkPaths){
-        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        if (!chunkChunkLists) {
-            chunkChunkLists = new Set([
-                chunkListPath
-            ]);
-            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
-        } else {
-            chunkChunkLists.add(chunkListPath);
-        }
-    }
+    setChunkListChunks(chunkListPath, chunkPaths);
     if (chunkList.source === 'entry') {
+        // Entry chunks have already loaded their member chunks while bootstrapping.
+        // The "chunk" registration completes the backend's initial load.
+        BACKEND.registerChunk(chunkListPath);
         markChunkListAsRuntime(chunkListPath);
+        CHUNK_UPDATE_LISTENERS.push([
+            chunkListPath,
+            handleApply.bind(null, chunkListPath),
+            {
+                batch: handleApplyBatch,
+                expectedVersion: chunkList.version
+            }
+        ]);
+        return;
     }
+    if (typeof document === 'undefined') {
+        // Workers currently have no HMR transport/provider. Keep the dynamic
+        // chunk-list as a lightweight bootstrap, but load its members directly
+        // instead of waiting forever for an onSubscribed acknowledgement.
+        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
+            const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
+            BACKEND.rejectChunk?.(chunkListPath, error);
+        });
+        return;
+    }
+    // A dynamic chunk list is the bootstrap for its group. Establish the server
+    // baseline before fetching content, then hold updates while content loads.
+    // This closes the HTTP/WebSocket race where stale content could otherwise be
+    // fetched immediately before a newer subscription baseline was created.
+    const loadState = {
+        generation,
+        loading: true,
+        bootstrapping: true,
+        terminated: false,
+        pendingTasks: new Set(),
+        memberChunkUrls: new Map()
+    };
+    for (const chunkData of chunkList.chunks){
+        const chunkPath = getChunkPath(chunkData);
+        const chunkVersion = chunkList.chunkVersions[chunkPath];
+        if (chunkVersion === undefined) {
+            throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
+        }
+        const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion);
+        loadState.memberChunkUrls.set(chunkPath, chunkUrl);
+        addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
+    }
+    dynamicChunkListLoadStates.set(chunkListPath, loadState);
+    let resolveSubscribed;
+    let revalidateSubscription;
+    const subscribed = new Promise((resolve, reject)=>{
+        resolveSubscribed = resolve;
+        loadState.rejectSubscribed = reject;
+    });
+    CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath),
+        {
+            batch: handleApplyBatch,
+            onSubscribed: (revalidate)=>{
+                revalidateSubscription = revalidate;
+                resolveSubscribed();
+            },
+            expectedVersion: chunkList.version
+        }
+    ]);
+    void (async ()=>{
+        try {
+            await subscribed;
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            const memberResults = await Promise.allSettled(chunkList.chunks.map((chunkData)=>loadVersionedDynamicMemberChunk(chunkListPath, chunkData, chunkList.chunkVersions[getChunkPath(chunkData)])));
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                for (const chunkPath of chunkPaths){
+                    if (!chunkChunkListsMap.has(chunkPath)) {
+                        disposeChunk(chunkPath);
+                    }
+                }
+                return;
+            }
+            const failedMember = memberResults.find((result)=>result.status === 'rejected');
+            if (failedMember) {
+                throw failedMember.reason;
+            }
+            // The member URLs are served from the live output directory rather than
+            // a historical snapshot. Validate the manifest version again after all
+            // HTTP responses have completed, closing the subscription/HTTP race.
+            await revalidateSubscription();
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            for (const chunkUrl of loadState.memberChunkUrls.values()){
+                completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
+            }
+            loadState.loading = false;
+            flushPendingHmrTasks();
+            while(loadState.pendingTasks.size > 0){
+                await Promise.all([
+                    ...loadState.pendingTasks
+                ]);
+            }
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                for (const chunkPath of chunkPaths){
+                    if (!chunkChunkListsMap.has(chunkPath)) {
+                        disposeChunk(chunkPath);
+                    }
+                }
+                return;
+            }
+            // Resolving the bootstrap schedules the import continuation as a
+            // microtask. Every queued update and resource load has completed first,
+            // so user code cannot observe factories from an older manifest.
+            loadState.bootstrapping = false;
+            BACKEND.registerChunk(chunkListPath);
+        } catch (cause) {
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            const error = cause instanceof Error ? cause : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`);
+            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+            DEV_BACKEND.restart();
+        }
+    })();
 }
-globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
 /**
  * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
  *
@@ -2039,7 +2709,7 @@ let BACKEND;
     BACKEND = {
         async registerChunk (chunk, params) {
             let chunkPath = getPathFromScript(chunk);
-            let chunkUrl = getUrlFromScript(chunkPath);
+            let chunkUrl = getUrlFromScript(chunk);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
             if (params == null) {
@@ -2064,6 +2734,13 @@ let BACKEND;
      * has been loaded.
      */ loadChunkCached (sourceType, chunkUrl) {
             return doLoadChunk(sourceType, chunkUrl);
+        },
+        rejectChunk (chunkPath, error) {
+            const chunkUrl = getUrlFromScript(chunkPath);
+            const resolver = chunkResolvers.get(chunkUrl);
+            if (resolver) {
+                rejectChunkResolver(chunkUrl, resolver, error);
+            }
         }
     };
     function getOrCreateResolver(chunkUrl) {
@@ -2272,31 +2949,41 @@ let BACKEND;
 /// <reference path="../../../shared/require-type.d.ts" />
 let DEV_BACKEND;
 (()=>{
+    const pendingChunkReloads = new Map();
+    const replacingCssLoads = new Map();
     DEV_BACKEND = {
-        unloadChunk (chunkUrl) {
-            deleteResolver(chunkUrl);
-            // Strip query string so we match links regardless of cache-busting
-            // params (e.g. ?ts=) that may differ between HMR updates.
+        loadChunkReplacing (chunkUrl) {
+            if (!isCss(chunkUrl)) {
+                return Promise.reject(new Error(`Only CSS chunks can be replaced while loading: ${chunkUrl}`));
+            }
+            const existingLoad = replacingCssLoads.get(chunkUrl);
+            if (existingLoad) return existingLoad;
             const baseChunkUrl = chunkUrl.split('?')[0];
-            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
             const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            if (isCss(chunkUrl)) {
-                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
-                for (const link of Array.from(links)){
-                    link.remove();
+            const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?';
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
+            const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
+            const load = exactLinks.length > 0 || baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>BACKEND.registerChunk({
+                    src: chunkUrl
+                }));
+            replacingCssLoads.set(chunkUrl, load);
+            void load.then(()=>{
+                if (replacingCssLoads.get(chunkUrl) === load) {
+                    replacingCssLoads.delete(chunkUrl);
                 }
-            } else if (isJs(chunkUrl)) {
-                // Unloading a JS chunk would have no effect, as it lives in the JS
-                // runtime once evaluated.
-                // However, we still want to remove the script tag from the DOM to keep
-                // the HTML somewhat consistent from the user's perspective.
-                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
-                for (const script of Array.from(scripts)){
-                    script.remove();
+            }, ()=>{
+                if (replacingCssLoads.get(chunkUrl) === load) {
+                    replacingCssLoads.delete(chunkUrl);
                 }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-            }
+            });
+            return load;
+        },
+        unloadChunk (chunkUrl) {
+            unloadChunk(chunkUrl, false);
+        },
+        unloadChunkExact (chunkUrl) {
+            unloadChunk(chunkUrl, true);
         },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
@@ -2313,9 +3000,43 @@ let DEV_BACKEND;
                     reject(new Error(`No link element found for chunk ${chunkUrl}`));
                     return;
                 }
+                const currentReloads = pendingChunkReloads.get(baseChunkUrl);
+                if (currentReloads) {
+                    const suffix = chunkUrl.includes('?') ? '&' : '?';
+                    for (const reload of [
+                        ...currentReloads
+                    ]){
+                        const href = reload.link.getAttribute('href');
+                        if (href !== chunkUrl && !href?.startsWith(`${chunkUrl}${suffix}`)) {
+                            reload.reject(new Error(`CSS chunk ${chunkUrl} superseded an in-flight reload.`));
+                        }
+                    }
+                }
                 const link = document.createElement('link');
                 link.rel = 'stylesheet';
                 link.crossOrigin = CROSS_ORIGIN;
+                let pendingReloads = pendingChunkReloads.get(baseChunkUrl);
+                if (!pendingReloads) {
+                    pendingReloads = new Set();
+                    pendingChunkReloads.set(baseChunkUrl, pendingReloads);
+                }
+                const cleanup = ()=>{
+                    pendingReloads.delete(pendingReload);
+                    if (pendingReloads.size === 0) {
+                        pendingChunkReloads.delete(baseChunkUrl);
+                    }
+                };
+                const pendingReload = {
+                    link,
+                    reject: (error)=>{
+                        cleanup();
+                        link.onload = null;
+                        link.onerror = null;
+                        link.remove();
+                        reject(error);
+                    }
+                };
+                pendingReloads.add(pendingReload);
                 if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
                     // Firefox won't reload CSS files that were previously loaded on the
                     // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
@@ -2336,9 +3057,10 @@ let DEV_BACKEND;
                     link.href = chunkUrl;
                 }
                 link.onerror = ()=>{
-                    reject();
+                    pendingReload.reject(new Error(`Failed to reload CSS chunk ${chunkUrl}`));
                 };
                 link.onload = ()=>{
+                    cleanup();
                     // First load the new CSS, then remove the old ones. This prevents visible
                     // flickering that would happen in-between removing the previous CSS and
                     // loading the new one.
@@ -2354,8 +3076,56 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
-    function deleteResolver(chunkUrl) {
-        chunkResolvers.delete(chunkUrl);
+    function unloadChunk(chunkUrl, exact) {
+        deleteResolvers(chunkUrl, exact);
+        const baseChunkUrl = chunkUrl.split('?')[0];
+        const reloads = pendingChunkReloads.get(baseChunkUrl);
+        if (reloads) {
+            for (const reload of [
+                ...reloads
+            ]){
+                const href = reload.link.getAttribute('href');
+                const suffix = chunkUrl.includes('?') ? '&' : '?';
+                if (!exact || href === chunkUrl || href?.startsWith(`${chunkUrl}${suffix}`)) {
+                    reload.reject(new Error(`Chunk ${chunkUrl} was unloaded while reloading.`));
+                }
+            }
+        }
+        // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+        const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl);
+        const path = exact ? chunkUrl : baseChunkUrl;
+        const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
+        if (isCss(chunkUrl)) {
+            const links = document.querySelectorAll(exact ? `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]` : `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
+            for (const link of Array.from(links)){
+                link.remove();
+            }
+        } else if (isJs(chunkUrl)) {
+            // Unloading a JS chunk would have no effect once it has executed, but
+            // removing the exact stale registration keeps the DOM and resolver cache
+            // bounded without touching a newer generation of the same chunk path.
+            const scripts = document.querySelectorAll(exact ? `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]` : `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
+            for (const script of Array.from(scripts)){
+                script.remove();
+            }
+        } else {
+            throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+        }
+    }
+    function deleteResolvers(chunkUrl, exact) {
+        const baseChunkUrl = chunkUrl.split('?')[0];
+        for (const [resolverUrl, resolver] of [
+            ...chunkResolvers
+        ]){
+            if (exact ? resolverUrl !== chunkUrl : resolverUrl.split('?')[0] !== baseChunkUrl) {
+                continue;
+            }
+            if (resolver.resolved) {
+                chunkResolvers.delete(resolverUrl);
+            } else {
+                rejectChunkResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
+            }
+        }
     }
 })();
 function _eval({ code, url, map }) {
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js
new file mode 100644
index 000000000..bc784065f
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js
@@ -0,0 +1,33 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const outputDir = path.join(__dirname, "output");
+const javascriptAssets = fs
+  .readdirSync(outputDir)
+  .filter((file) => file.endsWith(".js"))
+  .map((file) => ({
+    file,
+    content: fs.readFileSync(path.join(outputDir, file), "utf8"),
+  }));
+
+assert.equal(
+  javascriptAssets.filter(({ content }) =>
+    /source:\s*["'](?:entry|dynamic)["']/.test(content),
+  ).length,
+  0,
+  "hot=false must not emit chunk-list bootstraps that wait for an HMR client",
+);
+
+const asyncLoader = javascriptAssets.find(({ content }) =>
+  content.includes("return parentImport("),
+);
+assert.ok(asyncLoader, "the fixture should emit an async loader");
+const loaderMatch = asyncLoader.content.match(
+  /return Promise\.all\((\[[\s\S]*?\])\.map/,
+);
+assert.ok(loaderMatch, "the async loader should contain a chunk array");
+assert.ok(
+  JSON.parse(loaderMatch[1]).length > 0,
+  "hot=false must load dynamic content chunks directly",
+);
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json
new file mode 100644
index 000000000..b09219d5f
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json
@@ -0,0 +1,23 @@
+{
+  "config": {
+    "entry": [
+      {
+        "import": "input/index.js",
+        "name": "main"
+      }
+    ],
+    "mode": "development",
+    "devServer": {
+      "hot": false
+    },
+    "sourceMaps": false,
+    "optimization": {
+      "minify": false
+    },
+    "output": {
+      "path": "output"
+    }
+  },
+  "runtimeType": "Development",
+  "watch": true
+}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js
new file mode 100644
index 000000000..0af5803a0
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js
@@ -0,0 +1,3 @@
+export async function loadLazy() {
+  return import("./lazy");
+}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js
new file mode 100644
index 000000000..24e545669
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js
@@ -0,0 +1 @@
+export const value = "lazy";
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js
new file mode 100644
index 000000000..5883f8f7c
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js
@@ -0,0 +1,453 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "default",
+    ()=>__TURBOPACK__default__export__
+]);
+/**
+ * MIT License
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */ // This file is copied from the Metro JavaScript bundler, with minor tweaks for
+// webpack 4 compatibility.
+//
+// https://github.com/facebook/metro/blob/d6b9685c730d0d63577db40f41369157f28dfa3a/packages/metro/src/lib/polyfills/require.js
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
+;
+const { m: turbopackModule } = __turbopack_context__;
+function isSafeExport(key) {
+    return key === "__esModule" || key === "__N_SSG" || key === "__N_SSP" || // TODO: remove this key from page config instead of allow listing it
+    key === "config";
+}
+function registerExportsForReactRefresh(moduleExports, moduleID) {
+    __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(moduleExports, moduleID + " %exports%");
+    if (moduleExports == null || typeof moduleExports !== "object") {
+        // Exit if we can't iterate over exports.
+        // (This is important for legacy environments.)
+        return;
+    }
+    for(var key in moduleExports){
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        } catch  {
+            continue;
+        }
+        var typeID = moduleID + " %exports% " + key;
+        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(exportValue, typeID);
+    }
+}
+function getRefreshBoundarySignature(moduleExports) {
+    var signature = [];
+    signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(moduleExports));
+    if (moduleExports == null || typeof moduleExports !== "object") {
+        // Exit if we can't iterate over exports.
+        // (This is important for legacy environments.)
+        return signature;
+    }
+    for(var key in moduleExports){
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        } catch  {
+            continue;
+        }
+        signature.push(key);
+        signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(exportValue));
+    }
+    return signature;
+}
+function isReactRefreshBoundary(moduleExports) {
+    if (__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(moduleExports)) {
+        return true;
+    }
+    if (moduleExports == null || typeof moduleExports !== "object") {
+        // Exit if we can't iterate over exports.
+        return false;
+    }
+    var hasExports = false;
+    var areAllExportsComponents = true;
+    for(var key in moduleExports){
+        hasExports = true;
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        } catch  {
+            // This might fail due to circular dependencies
+            return false;
+        }
+        if (!__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(exportValue)) {
+            areAllExportsComponents = false;
+        }
+    }
+    return hasExports && areAllExportsComponents;
+}
+function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) {
+    if (prevSignature.length !== nextSignature.length) {
+        return true;
+    }
+    for(var i = 0; i < nextSignature.length; i++){
+        if (prevSignature[i] !== nextSignature[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+var isUpdateScheduled = false;
+// This function aggregates updates from multiple modules into a single React Refresh call.
+function scheduleUpdate() {
+    if (isUpdateScheduled) {
+        return;
+    }
+    isUpdateScheduled = true;
+    function canApplyUpdate(status) {
+        return status === "idle";
+    }
+    function applyUpdate() {
+        isUpdateScheduled = false;
+        try {
+            __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].performReactRefresh();
+        } catch (err) {
+            console.warn("Warning: Failed to re-render. We will retry on the next Fast Refresh event.\n" + err);
+        }
+    }
+    if (canApplyUpdate(turbopackModule.hot.status())) {
+        // Apply update on the next tick.
+        Promise.resolve().then(()=>{
+            applyUpdate();
+        });
+        return;
+    }
+    const statusHandler = (status)=>{
+        if (canApplyUpdate(status)) {
+            turbopackModule.hot.removeStatusHandler(statusHandler);
+            applyUpdate();
+        }
+    };
+    // Apply update once the HMR runtime's status is idle.
+    turbopackModule.hot.addStatusHandler(statusHandler);
+}
+var __TURBOPACK__default__export__ = {
+    registerExportsForReactRefresh: registerExportsForReactRefresh,
+    isReactRefreshBoundary: isReactRefreshBoundary,
+    shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary,
+    getRefreshBoundarySignature: getRefreshBoundarySignature,
+    scheduleUpdate: scheduleUpdate
+};
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)", ((__turbopack_context__, module, exports) => {
+"use strict";
+
+// react@0.18.0: https://unpkg.com/react-refresh@0.18.0/cjs/react-refresh-runtime.development.js
+/**
+ * @license React
+ * react-refresh-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "production" !== ("TURBOPACK compile-time value", "development") && function() {
+    function computeFullKey(signature) {
+        if (null !== signature.fullKey) return signature.fullKey;
+        var fullKey = signature.ownKey;
+        try {
+            var hooks = signature.getCustomHooks();
+        } catch (err) {
+            return signature.forceReset = !0, signature.fullKey = fullKey;
+        }
+        for(var i = 0; i < hooks.length; i++){
+            var hook = hooks[i];
+            if ("function" !== typeof hook) return signature.forceReset = !0, signature.fullKey = fullKey;
+            hook = allSignaturesByType.get(hook);
+            if (void 0 !== hook) {
+                var nestedHookKey = computeFullKey(hook);
+                hook.forceReset && (signature.forceReset = !0);
+                fullKey += "\n---\n" + nestedHookKey;
+            }
+        }
+        return signature.fullKey = fullKey;
+    }
+    function resolveFamily(type) {
+        return updatedFamiliesByType.get(type);
+    }
+    function cloneMap(map) {
+        var clone = new Map();
+        map.forEach(function(value, key) {
+            clone.set(key, value);
+        });
+        return clone;
+    }
+    function cloneSet(set) {
+        var clone = new Set();
+        set.forEach(function(value) {
+            clone.add(value);
+        });
+        return clone;
+    }
+    function getProperty(object, property) {
+        try {
+            return object[property];
+        } catch (err) {}
+    }
+    function register(type, id) {
+        if (!(null === type || "function" !== typeof type && "object" !== typeof type || allFamiliesByType.has(type))) {
+            var family = allFamiliesByID.get(id);
+            void 0 === family ? (family = {
+                current: type
+            }, allFamiliesByID.set(id, family)) : pendingUpdates.push([
+                family,
+                type
+            ]);
+            allFamiliesByType.set(type, family);
+            if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
+                case REACT_FORWARD_REF_TYPE:
+                    register(type.render, id + "$render");
+                    break;
+                case REACT_MEMO_TYPE:
+                    register(type.type, id + "$type");
+            }
+        }
+    }
+    function setSignature(type, key) {
+        var forceReset = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1, getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
+        allSignaturesByType.has(type) || allSignaturesByType.set(type, {
+            forceReset: forceReset,
+            ownKey: key,
+            fullKey: null,
+            getCustomHooks: getCustomHooks || function() {
+                return [];
+            }
+        });
+        if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
+            case REACT_FORWARD_REF_TYPE:
+                setSignature(type.render, key, forceReset, getCustomHooks);
+                break;
+            case REACT_MEMO_TYPE:
+                setSignature(type.type, key, forceReset, getCustomHooks);
+        }
+    }
+    function collectCustomHooksForSignature(type) {
+        type = allSignaturesByType.get(type);
+        void 0 !== type && computeFullKey(type);
+    }
+    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_MEMO_TYPE = Symbol.for("react.memo"), PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map, allFamiliesByID = new Map(), allFamiliesByType = new PossiblyWeakMap(), allSignaturesByType = new PossiblyWeakMap(), updatedFamiliesByType = new PossiblyWeakMap(), pendingUpdates = [], helpersByRendererID = new Map(), helpersByRoot = new Map(), mountedRoots = new Set(), failedRoots = new Set(), rootElements = "function" === typeof WeakMap ? new WeakMap() : null, isPerformingRefresh = !1;
+    exports._getMountedRootCount = function() {
+        return mountedRoots.size;
+    };
+    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
+    exports.createSignatureFunctionForTransform = function() {
+        var savedType, hasCustomHooks, didCollectHooks = !1;
+        return function(type, key, forceReset, getCustomHooks) {
+            if ("string" === typeof key) return savedType || (savedType = type, hasCustomHooks = "function" === typeof getCustomHooks), null == type || "function" !== typeof type && "object" !== typeof type || setSignature(type, key, forceReset, getCustomHooks), type;
+            !didCollectHooks && hasCustomHooks && (didCollectHooks = !0, collectCustomHooksForSignature(savedType));
+        };
+    };
+    exports.getFamilyByID = function(id) {
+        return allFamiliesByID.get(id);
+    };
+    exports.getFamilyByType = function(type) {
+        return allFamiliesByType.get(type);
+    };
+    exports.hasUnrecoverableErrors = function() {
+        return !1;
+    };
+    exports.injectIntoGlobalHook = function(globalObject) {
+        var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+        if (void 0 === hook) {
+            var nextID = 0;
+            globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+                renderers: new Map(),
+                supportsFiber: !0,
+                inject: function() {
+                    return nextID++;
+                },
+                onScheduleFiberRoot: function() {},
+                onCommitFiberRoot: function() {},
+                onCommitFiberUnmount: function() {}
+            };
+        }
+        if (hook.isDisabled) console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
+        else {
+            var oldInject = hook.inject;
+            hook.inject = function(injected) {
+                var id = oldInject.apply(this, arguments);
+                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
+                return id;
+            };
+            hook.renderers.forEach(function(injected, id) {
+                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
+            });
+            var oldOnCommitFiberRoot = hook.onCommitFiberRoot, oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {};
+            hook.onScheduleFiberRoot = function(id, root, children) {
+                isPerformingRefresh || (failedRoots.delete(root), null !== rootElements && rootElements.set(root, children));
+                return oldOnScheduleFiberRoot.apply(this, arguments);
+            };
+            hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
+                var helpers = helpersByRendererID.get(id);
+                if (void 0 !== helpers) {
+                    helpersByRoot.set(root, helpers);
+                    helpers = root.current;
+                    var alternate = helpers.alternate;
+                    null !== alternate ? (alternate = null != alternate.memoizedState && null != alternate.memoizedState.element && mountedRoots.has(root), helpers = null != helpers.memoizedState && null != helpers.memoizedState.element, !alternate && helpers ? (mountedRoots.add(root), failedRoots.delete(root)) : alternate && helpers || (alternate && !helpers ? (mountedRoots.delete(root), didError ? failedRoots.add(root) : helpersByRoot.delete(root)) : alternate || helpers || didError && failedRoots.add(root))) : mountedRoots.add(root);
+                }
+                return oldOnCommitFiberRoot.apply(this, arguments);
+            };
+        }
+    };
+    exports.isLikelyComponentType = function(type) {
+        switch(typeof type){
+            case "function":
+                if (null != type.prototype) {
+                    if (type.prototype.isReactComponent) return !0;
+                    var ownNames = Object.getOwnPropertyNames(type.prototype);
+                    if (1 < ownNames.length || "constructor" !== ownNames[0] || type.prototype.__proto__ !== Object.prototype) return !1;
+                }
+                type = type.name || type.displayName;
+                return "string" === typeof type && /^[A-Z]/.test(type);
+            case "object":
+                if (null != type) switch(getProperty(type, "$$typeof")){
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_MEMO_TYPE:
+                        return !0;
+                }
+                return !1;
+            default:
+                return !1;
+        }
+    };
+    exports.performReactRefresh = function() {
+        if (0 === pendingUpdates.length || isPerformingRefresh) return null;
+        isPerformingRefresh = !0;
+        try {
+            var staleFamilies = new Set(), updatedFamilies = new Set(), updates = pendingUpdates;
+            pendingUpdates = [];
+            updates.forEach(function(_ref) {
+                var family = _ref[0];
+                _ref = _ref[1];
+                var prevType = family.current;
+                updatedFamiliesByType.set(prevType, family);
+                updatedFamiliesByType.set(_ref, family);
+                family.current = _ref;
+                prevType.prototype && prevType.prototype.isReactComponent || _ref.prototype && _ref.prototype.isReactComponent ? _ref = !1 : (prevType = allSignaturesByType.get(prevType), _ref = allSignaturesByType.get(_ref), _ref = void 0 === prevType && void 0 === _ref || void 0 !== prevType && void 0 !== _ref && computeFullKey(prevType) === computeFullKey(_ref) && !_ref.forceReset ? !0 : !1);
+                _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
+            });
+            var update = {
+                updatedFamilies: updatedFamilies,
+                staleFamilies: staleFamilies
+            };
+            helpersByRendererID.forEach(function(helpers) {
+                helpers.setRefreshHandler(resolveFamily);
+            });
+            var didError = !1, firstError = null, failedRootsSnapshot = cloneSet(failedRoots), mountedRootsSnapshot = cloneSet(mountedRoots), helpersByRootSnapshot = cloneMap(helpersByRoot);
+            failedRootsSnapshot.forEach(function(root) {
+                var helpers = helpersByRootSnapshot.get(root);
+                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
+                failedRoots.has(root);
+                if (null !== rootElements && rootElements.has(root)) {
+                    var element = rootElements.get(root);
+                    try {
+                        helpers.scheduleRoot(root, element);
+                    } catch (err) {
+                        didError || (didError = !0, firstError = err);
+                    }
+                }
+            });
+            mountedRootsSnapshot.forEach(function(root) {
+                var helpers = helpersByRootSnapshot.get(root);
+                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
+                mountedRoots.has(root);
+                try {
+                    helpers.scheduleRefresh(root, update);
+                } catch (err) {
+                    didError || (didError = !0, firstError = err);
+                }
+            });
+            if (didError) throw firstError;
+            return update;
+        } finally{
+            isPerformingRefresh = !1;
+        }
+    };
+    exports.register = register;
+    exports.setSignature = setSignature;
+}();
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([]);
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)");
+var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
+;
+;
+// Hook into ReactDOM initialization
+__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].injectIntoGlobalHook(self);
+// Register global helpers
+self.$RefreshHelpers$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["default"];
+// Register a helper for module execution interception
+self.$RefreshInterceptModuleExecution$ = function(webpackModuleId) {
+    var prevRefreshReg = self.$RefreshReg$;
+    var prevRefreshSig = self.$RefreshSig$;
+    self.$RefreshReg$ = function(type, id) {
+        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(type, webpackModuleId + " " + id);
+    };
+    self.$RefreshSig$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].createSignatureFunctionForTransform;
+    // Modeled after `useEffect` cleanup pattern:
+    // https://react.dev/learn/synchronizing-with-effects#step-3-add-cleanup-if-needed
+    return function() {
+        self.$RefreshReg$ = prevRefreshReg;
+        self.$RefreshSig$ = prevRefreshSig;
+    };
+};
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+"[project]/hmr/dynamic_chunk_lists_hot_disabled/input/index.js [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "loadLazy",
+    ()=>loadLazy
+]);
+async function loadLazy() {
+    return __turbopack_context__.A("[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript, async loader)");
+}
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js
new file mode 100644
index 000000000..2c44130bc
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js
@@ -0,0 +1,12 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript, async loader)", ((__turbopack_context__) => {
+
+__turbopack_context__.v((parentImport) => {
+    return Promise.all([
+  "input_lazy_c5880b16.js"
+].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
+        return parentImport("[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript)");
+    });
+});
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js
new file mode 100644
index 000000000..6669c1054
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js
@@ -0,0 +1,14 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
+"[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript)", ((__turbopack_context__) => {
+"use strict";
+
+__turbopack_context__.s([
+    "value",
+    ()=>value
+]);
+const value = "lazy";
+if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
+    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
+}
+}),
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
new file mode 100644
index 000000000..9dcab2660
--- /dev/null
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
@@ -0,0 +1,3147 @@
+(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
+    typeof document === "object" ? document.currentScript : undefined,
+    {"otherChunks":["input_lazy_b65347b5.js","_root-of-the-server___2651c4ea.js"],"runtimeModuleIds":["[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)","[project]/hmr/dynamic_chunk_lists_hot_disabled/input/index.js [client] (ecmascript)"]}
+]);
+(() => {
+if (!Array.isArray(globalThis["TURBOPACK"])) {
+    return;
+}
+
+var CHUNK_BASE_PATH = "/";
+var WORKER_BASE_PATH = null;
+var RELATIVE_ROOT_PATH = "/ROOT";
+var RUNTIME_PUBLIC_PATH = "/";
+globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"] ||= [];
+var CHUNK_UPDATE_LISTENERS = {
+    push: (registration) => globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"].push(registration),
+};
+var ASSET_SUFFIX = "";
+var CROSS_ORIGIN = null;
+var CHUNK_LOAD_RETRY_MAX_ATTEMPTS = 1;
+var CHUNK_LOAD_RETRY_BASE_DELAY_MS = 200;
+var CHUNK_LOAD_RETRY_MAX_JITTER_MS = 400;
+var WORKER_FORWARDED_GLOBALS = [];
+/**
+ * This file contains runtime types and functions that are shared between all
+ * TurboPack ECMAScript runtimes.
+ *
+ * It will be prepended to the runtime code of each runtime.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
+/// <reference path="./async-module.ts" />
+/**
+ * Describes why a module was instantiated.
+ * Shared between browser and Node.js runtimes.
+ */ var SourceType = function(SourceType) {
+    /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
+    /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */ SourceType[SourceType["Parent"] = 1] = "Parent";
+    /**
+   * The module was instantiated because it was included in a chunk's hot module
+   * update.
+   * SourceData is an array of ModuleIds or undefined.
+   */ SourceType[SourceType["Update"] = 2] = "Update";
+    return SourceType;
+}(SourceType || {});
+/**
+ * Flag indicating which module object type to create when a module is merged. Set to `true`
+ * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,
+ * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it
+ * uses plain Module objects.
+ */ let createModuleWithDirectionFlag = false;
+const REEXPORTED_OBJECTS = new WeakMap();
+/**
+ * Constructs the `__turbopack_context__` object for a module.
+ */ function Context(module, exports) {
+    this.m = module;
+    // We need to store this here instead of accessing it from the module object to:
+    // 1. Make it available to factories directly, since we rewrite `this` to
+    //    `__turbopack_context__.e` in CJS modules.
+    // 2. Support async modules which rewrite `module.exports` to a promise, so we
+    //    can still access the original exports object from functions like
+    //    `esmExport`
+    // Ideally we could find a new approach for async modules and drop this property altogether.
+    this.e = exports;
+}
+const contextPrototype = Context.prototype;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+function defineProp(obj, name, options) {
+    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
+}
+function getOverwrittenModule(moduleCache, id) {
+    let module = moduleCache[id];
+    if (!module) {
+        if (createModuleWithDirectionFlag) {
+            // set in development modes for hmr support
+            module = createModuleWithDirection(id);
+        } else {
+            module = createModuleObject(id);
+        }
+        moduleCache[id] = module;
+    }
+    return module;
+}
+/**
+ * Creates the module object. Only done here to ensure all module objects have the same shape.
+ */ function createModuleObject(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined
+    };
+}
+function createModuleWithDirection(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined,
+        parents: [],
+        children: []
+    };
+}
+const BindingTag_Value = 0;
+/**
+ * Adds the getters to the exports object.
+ */ function esm(exports, bindings) {
+    defineProp(exports, '__esModule', {
+        value: true
+    });
+    if (toStringTag) defineProp(exports, toStringTag, {
+        value: 'Module'
+    });
+    let i = 0;
+    while(i < bindings.length){
+        const propName = bindings[i++];
+        const tagOrFunction = bindings[i++];
+        if (typeof tagOrFunction === 'number') {
+            if (tagOrFunction === BindingTag_Value) {
+                defineProp(exports, propName, {
+                    value: bindings[i++],
+                    enumerable: true,
+                    writable: false
+                });
+            } else {
+                throw new Error(`unexpected tag: ${tagOrFunction}`);
+            }
+        } else {
+            const getterFn = tagOrFunction;
+            if (typeof bindings[i] === 'function') {
+                const setterFn = bindings[i++];
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    set: setterFn,
+                    enumerable: true
+                });
+            } else {
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    enumerable: true
+                });
+            }
+        }
+    }
+    Object.seal(exports);
+}
+/**
+ * Makes the module an ESM with exports
+ */ function esmExport(bindings, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    module.namespaceObject = exports;
+    esm(exports, bindings);
+}
+contextPrototype.s = esmExport;
+function ensureDynamicExports(module, exports) {
+    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
+    if (!reexportedObjects) {
+        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
+        module.exports = module.namespaceObject = new Proxy(exports, {
+            get (target, prop) {
+                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
+                    return Reflect.get(target, prop);
+                }
+                for (const obj of reexportedObjects){
+                    const value = Reflect.get(obj, prop);
+                    if (value !== undefined) return value;
+                }
+                return undefined;
+            },
+            ownKeys (target) {
+                const keys = Reflect.ownKeys(target);
+                for (const obj of reexportedObjects){
+                    for (const key of Reflect.ownKeys(obj)){
+                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
+                    }
+                }
+                return keys;
+            }
+        });
+    }
+    return reexportedObjects;
+}
+/**
+ * Dynamically exports properties from an object
+ */ function dynamicExport(object, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    const reexportedObjects = ensureDynamicExports(module, exports);
+    if (typeof object === 'object' && object !== null) {
+        reexportedObjects.push(object);
+    }
+}
+contextPrototype.j = dynamicExport;
+function exportValue(value, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = value;
+}
+contextPrototype.v = exportValue;
+function exportNamespace(namespace, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = module.namespaceObject = namespace;
+}
+contextPrototype.n = exportNamespace;
+function createGetter(obj, key) {
+    return ()=>obj[key];
+}
+/**
+ * @returns prototype of the object
+ */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
+    null,
+    getProto({}),
+    getProto([]),
+    getProto(getProto)
+];
+/**
+ * @param raw
+ * @param ns
+ * @param allowExportDefault
+ *   * `false`: will have the raw module as default export
+ *   * `true`: will have the default property as default export
+ */ function interopEsm(raw, ns, allowExportDefault) {
+    const bindings = [];
+    let defaultLocation = -1;
+    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
+        for (const key of Object.getOwnPropertyNames(current)){
+            bindings.push(key, createGetter(raw, key));
+            if (defaultLocation === -1 && key === 'default') {
+                defaultLocation = bindings.length - 1;
+            }
+        }
+    }
+    // this is not really correct
+    // we should set the `default` getter if the imported module is a `.cjs file`
+    if (!(allowExportDefault && defaultLocation >= 0)) {
+        // Replace the binding with one for the namespace itself in order to preserve iteration order.
+        if (defaultLocation >= 0) {
+            // Replace the getter with the value
+            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
+        } else {
+            bindings.push('default', BindingTag_Value, raw);
+        }
+    }
+    esm(ns, bindings);
+    return ns;
+}
+function createNS(raw) {
+    if (typeof raw === 'function') {
+        return function(...args) {
+            return raw.apply(this, args);
+        };
+    } else {
+        return Object.create(null);
+    }
+}
+function esmImport(id) {
+    const module = getOrInstantiateModuleFromParent(id, this.m);
+    // any ES module has to have `module.namespaceObject` defined.
+    if (module.namespaceObject) return module.namespaceObject;
+    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
+    const raw = module.exports;
+    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
+}
+contextPrototype.i = esmImport;
+function asyncLoader(moduleId) {
+    const loader = this.r(moduleId);
+    return loader(esmImport.bind(this));
+}
+contextPrototype.A = asyncLoader;
+// Add a simple runtime require so that environments without one can still pass
+// `typeof require` CommonJS checks so that exports are correctly registered.
+const runtimeRequire = // @ts-ignore
+typeof require === 'function' ? require : function require1() {
+    throw new Error('Unexpected use of runtime require');
+};
+contextPrototype.t = runtimeRequire;
+function commonJsRequire(id) {
+    return getOrInstantiateModuleFromParent(id, this.m).exports;
+}
+contextPrototype.r = commonJsRequire;
+/**
+ * Remove fragments and query parameters since they are never part of the context map keys
+ *
+ * This matches how we parse patterns at resolving time.  Arguably we should only do this for
+ * strings passed to `import` but the resolve does it for `import` and `require` and so we do
+ * here as well.
+ */ function parseRequest(request) {
+    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    const hashIndex = request.indexOf('#');
+    if (hashIndex !== -1) {
+        request = request.substring(0, hashIndex);
+    }
+    const queryIndex = request.indexOf('?');
+    if (queryIndex !== -1) {
+        request = request.substring(0, queryIndex);
+    }
+    return request;
+}
+/**
+ * `require.context` and require/import expression runtime.
+ */ function moduleContext(map) {
+    function moduleContext(id) {
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].module();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    }
+    moduleContext.keys = ()=>{
+        return Object.keys(map);
+    };
+    moduleContext.resolve = (id)=>{
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].id();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    };
+    moduleContext.import = async (id)=>{
+        return await moduleContext(id);
+    };
+    return moduleContext;
+}
+contextPrototype.f = moduleContext;
+/**
+ * Returns the path of a chunk defined by its data.
+ */ function getChunkPath(chunkData) {
+    return typeof chunkData === 'string' ? chunkData : chunkData.path;
+}
+// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
+// The CompressedModuleFactories format is
+// - 1 or more module ids
+// - a module factory function
+// So walking this is a little complex but the flat structure is also fast to
+// traverse, we can use `typeof` operators to distinguish the two cases.
+function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
+    let i = offset;
+    while(i < chunkModules.length){
+        let end = i + 1;
+        // Find our factory function
+        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
+            end++;
+        }
+        if (end === chunkModules.length) {
+            throw new Error('malformed chunk format, expected a factory function');
+        }
+        // Install the factory for each module ID that doesn't already have one.
+        // When some IDs in this group already have a factory, reuse that existing
+        // group factory for the missing IDs to keep all IDs in the group consistent.
+        // Otherwise, install the factory from this chunk.
+        const moduleFactoryFn = chunkModules[end];
+        let existingGroupFactory = undefined;
+        for(let j = i; j < end; j++){
+            const id = chunkModules[j];
+            const existingFactory = moduleFactories.get(id);
+            if (existingFactory) {
+                existingGroupFactory = existingFactory;
+                break;
+            }
+        }
+        const factoryToInstall = existingGroupFactory ?? moduleFactoryFn;
+        let didInstallFactory = false;
+        for(let j = i; j < end; j++){
+            const id = chunkModules[j];
+            if (!moduleFactories.has(id)) {
+                if (!didInstallFactory) {
+                    if (factoryToInstall === moduleFactoryFn) {
+                        applyModuleFactoryName(moduleFactoryFn);
+                    }
+                    didInstallFactory = true;
+                }
+                moduleFactories.set(id, factoryToInstall);
+                newModuleId?.(id);
+            }
+        }
+        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
+    }
+}
+/**
+ * A pseudo "fake" URL object to resolve to its relative path.
+ *
+ * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
+ * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
+ * hydration mismatch.
+ *
+ * This is based on webpack's existing implementation:
+ * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
+ */ const relativeURL = function relativeURL(inputUrl) {
+    const realUrl = new URL(inputUrl, 'x:/');
+    const values = {};
+    for(const key in realUrl)values[key] = realUrl[key];
+    values.href = inputUrl;
+    values.pathname = inputUrl.replace(/[?#].*/, '');
+    values.origin = values.protocol = '';
+    values.toString = values.toJSON = (..._args)=>inputUrl;
+    for(const key in values)Object.defineProperty(this, key, {
+        enumerable: true,
+        configurable: true,
+        value: values[key]
+    });
+};
+relativeURL.prototype = URL.prototype;
+contextPrototype.U = relativeURL;
+/**
+ * Utility function to ensure all variants of an enum are handled.
+ */ function invariant(never, computeMessage) {
+    throw new Error(`Invariant: ${computeMessage(never)}`);
+}
+/**
+ * Constructs an error message for when a module factory is not available.
+ */ function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
+    let instantiationReason;
+    switch(sourceType){
+        case 0:
+            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
+            break;
+        case 1:
+            instantiationReason = `because it was required from module ${sourceData}`;
+            break;
+        case 2:
+            instantiationReason = 'because of an HMR update';
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
+}
+/**
+ * A stub function to make `require` available but non-functional in ESM.
+ */ function requireStub(_moduleId) {
+    throw new Error('dynamic usage of require is not supported');
+}
+contextPrototype.z = requireStub;
+// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
+contextPrototype.g = globalThis;
+let cachedAutomaticPublicPath;
+function getAutomaticPublicPath() {
+    if (cachedAutomaticPublicPath !== undefined) {
+        return cachedAutomaticPublicPath;
+    }
+    let scriptUrl;
+    if (typeof document === 'object') {
+        const currentScript = document.currentScript;
+        scriptUrl = currentScript?.src;
+        if (!scriptUrl) {
+            const scripts = document.getElementsByTagName('script');
+            const script = scripts[scripts.length - 1];
+            scriptUrl = script?.src;
+        }
+    }
+    if (!scriptUrl && typeof globalThis.importScripts === 'function' && globalThis.location) {
+        scriptUrl = String(globalThis.location);
+    }
+    cachedAutomaticPublicPath = scriptUrl ? scriptUrl.replace(/^blob:/, '').replace(/#.*$/, '').replace(/\?.*$/, '').replace(/\/[^/]*$/, '/') : '';
+    return cachedAutomaticPublicPath;
+}
+/**
+ * Gets the public path for runtime assets.
+ * Checks globalThis.publicPath and falls back to "/".
+ */ function getPublicPath(mode) {
+    if (mode === 'auto') {
+        return getAutomaticPublicPath();
+    }
+    if (typeof globalThis !== 'undefined' && typeof globalThis.publicPath === 'string') {
+        const publicPath = globalThis.publicPath;
+        return publicPath.endsWith('/') ? publicPath : `${publicPath}/`;
+    }
+    return '/';
+}
+contextPrototype.p = getPublicPath;
+function applyModuleFactoryName(factory) {
+    // Give the module factory a nice name to improve stack traces.
+    Object.defineProperty(factory, 'name', {
+        value: 'module evaluation'
+    });
+}
+/// <reference path="./runtime-types.d.ts" />
+/// <reference path="./runtime-utils.ts" />
+/**
+ * Top-level-await / async-module machinery. This is only included in the runtime
+ * when the module graph actually contains an async module (a module with
+ * top-level await, or one that transitively depends on one). When no async
+ * module is present, the chunk items never reference `__turbopack_context__.a`,
+ * so this whole file can be omitted.
+ *
+ * everything below is adapted from webpack
+ * https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
+ */ const turbopackQueues = Symbol('turbopack queues');
+const turbopackExports = Symbol('turbopack exports');
+const turbopackError = Symbol('turbopack error');
+function isPromise(maybePromise) {
+    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
+}
+function isAsyncModuleExt(obj) {
+    return turbopackQueues in obj;
+}
+function createPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        reject = rej;
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+function resolveQueue(queue) {
+    if (queue && queue.status !== 1) {
+        queue.status = 1;
+        queue.forEach((fn)=>fn.queueCount--);
+        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
+    }
+}
+function wrapDeps(deps) {
+    return deps.map((dep)=>{
+        if (dep !== null && typeof dep === 'object') {
+            if (isAsyncModuleExt(dep)) return dep;
+            if (isPromise(dep)) {
+                const queue = Object.assign([], {
+                    status: 0
+                });
+                const obj = {
+                    [turbopackExports]: {},
+                    [turbopackQueues]: (fn)=>fn(queue)
+                };
+                dep.then((res)=>{
+                    obj[turbopackExports] = res;
+                    resolveQueue(queue);
+                }, (err)=>{
+                    obj[turbopackError] = err;
+                    resolveQueue(queue);
+                });
+                return obj;
+            }
+        }
+        return {
+            [turbopackExports]: dep,
+            [turbopackQueues]: ()=>{}
+        };
+    });
+}
+function asyncModule(body, hasAwait) {
+    const module = this.m;
+    const queue = hasAwait ? Object.assign([], {
+        status: -1
+    }) : undefined;
+    const depQueues = new Set();
+    const { resolve, reject, promise: rawPromise } = createPromise();
+    const promise = Object.assign(rawPromise, {
+        [turbopackExports]: module.exports,
+        [turbopackQueues]: (fn)=>{
+            queue && fn(queue);
+            depQueues.forEach(fn);
+            promise['catch'](()=>{});
+        }
+    });
+    const attributes = {
+        get () {
+            return promise;
+        },
+        set (v) {
+            // Calling `esmExport` leads to this.
+            if (v !== promise) {
+                promise[turbopackExports] = v;
+            }
+        }
+    };
+    Object.defineProperty(module, 'exports', attributes);
+    Object.defineProperty(module, 'namespaceObject', attributes);
+    function handleAsyncDependencies(deps) {
+        const currentDeps = wrapDeps(deps);
+        const getResult = ()=>currentDeps.map((d)=>{
+                if (d[turbopackError]) throw d[turbopackError];
+                return d[turbopackExports];
+            });
+        const { promise, resolve } = createPromise();
+        const fn = Object.assign(()=>resolve(getResult), {
+            queueCount: 0
+        });
+        function fnQueue(q) {
+            if (q !== queue && !depQueues.has(q)) {
+                depQueues.add(q);
+                if (q && q.status === 0) {
+                    fn.queueCount++;
+                    q.push(fn);
+                }
+            }
+        }
+        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
+        return fn.queueCount ? promise : getResult();
+    }
+    function asyncResult(err) {
+        if (err) {
+            reject(promise[turbopackError] = err);
+        } else {
+            resolve(promise[turbopackExports]);
+        }
+        resolveQueue(queue);
+    }
+    body(handleAsyncDependencies, asyncResult);
+    if (queue && queue.status === -1) {
+        queue.status = 0;
+    }
+}
+contextPrototype.a = asyncModule;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *browser* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
+/// <reference path="../../../shared/runtime/runtime-utils.ts" />
+// Used in WebWorkers to tell the runtime about the chunk suffix
+// Support runtime public path modes.
+function getRuntimeChunkBasePath(basePath = CHUNK_BASE_PATH) {
+    if (basePath === '__RUNTIME_PUBLIC_PATH__') {
+        return contextPrototype.p();
+    }
+    if (basePath === '__AUTO_PUBLIC_PATH__') {
+        return contextPrototype.p('auto');
+    }
+    return basePath;
+}
+const browserContextPrototype = Context.prototype;
+const moduleFactories = new Map();
+contextPrototype.M = moduleFactories;
+const availableModules = new Map();
+const availableModuleChunks = new Map();
+function loadChunk(chunkData) {
+    return loadChunkInternal(SourceType.Parent, this.m.id, chunkData);
+}
+browserContextPrototype.l = loadChunk;
+function loadInitialChunk(chunkPath, chunkData) {
+    return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
+}
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+/**
+ * Dynamic chunk-list manifests have already done their own availability
+ * calculation. Load the exact member URL for this manifest generation so an
+ * older in-flight request cannot be reused by a replacement generation.
+ */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
+    const memberChunkPath = getChunkPath(chunkData);
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
+}
+async function loadChunkInternal(sourceType, sourceData, chunkData) {
+    if (typeof chunkData === 'string') {
+        return loadChunkPath(sourceType, sourceData, chunkData);
+    }
+    const includedList = chunkData.included || [];
+    const modulesPromises = includedList.map((included)=>{
+        if (moduleFactories.has(included)) return true;
+        return availableModules.get(included);
+    });
+    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
+        // When all included items are already loaded or loading, we can skip loading ourselves
+        await Promise.all(modulesPromises);
+        return;
+    }
+    const includedModuleChunksList = chunkData.moduleChunks || [];
+    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
+        // TODO(alexkirsz) Do we need this check?
+        // if (moduleFactories[included]) return true;
+        return availableModuleChunks.get(included);
+    }).filter((p)=>p);
+    let promise;
+    if (moduleChunksPromises.length > 0) {
+        // Some module chunks are already loaded or loading.
+        if (moduleChunksPromises.length === includedModuleChunksList.length) {
+            // When all included module chunks are already loaded or loading, we can skip loading ourselves
+            await Promise.all(moduleChunksPromises);
+            return;
+        }
+        const moduleChunksToLoad = new Set();
+        for (const moduleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(moduleChunk)) {
+                moduleChunksToLoad.add(moduleChunk);
+            }
+        }
+        for (const moduleChunkToLoad of moduleChunksToLoad){
+            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
+            availableModuleChunks.set(moduleChunkToLoad, promise);
+            moduleChunksPromises.push(promise);
+        }
+        promise = Promise.all(moduleChunksPromises);
+    } else {
+        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
+        // Mark all included module chunks as loading if they are not already loaded or loading.
+        for (const includedModuleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(includedModuleChunk)) {
+                availableModuleChunks.set(includedModuleChunk, promise);
+            }
+        }
+    }
+    for (const included of includedList){
+        if (!availableModules.has(included)) {
+            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
+            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
+            availableModules.set(included, promise);
+        }
+    }
+    await promise;
+}
+const loadedChunk = Promise.resolve(undefined);
+const instrumentedBackendLoadChunks = new WeakMap();
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrl(chunkUrl) {
+    return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl);
+}
+browserContextPrototype.L = loadChunkByUrl;
+const loadedScripts = new Map();
+/**
+ * Load an external script by creating a <script> tag.
+ * This is used for script externals that need to be loaded from CDN or other external sources.
+ */ function loadScript(scriptUrl) {
+    // Return cached promise if script is already loading or loaded
+    let promise = loadedScripts.get(scriptUrl);
+    if (promise) {
+        return promise;
+    }
+    promise = new Promise((resolve, reject)=>{
+        const script = document.createElement('script');
+        script.crossOrigin = CROSS_ORIGIN;
+        script.src = scriptUrl;
+        script.onload = ()=>resolve();
+        script.onerror = ()=>reject(new Error(`Failed to load script: ${scriptUrl}`));
+        document.head.appendChild(script);
+    });
+    loadedScripts.set(scriptUrl, promise);
+    return promise;
+}
+browserContextPrototype.S = loadScript;
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
+    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
+    let entry = instrumentedBackendLoadChunks.get(thenable);
+    if (entry === undefined) {
+        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
+        entry = thenable.then(resolve).catch((cause)=>{
+            let loadReason;
+            switch(sourceType){
+                case SourceType.Runtime:
+                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
+                    break;
+                case SourceType.Parent:
+                    loadReason = `from module ${sourceData}`;
+                    break;
+                case SourceType.Update:
+                    loadReason = 'from an HMR update';
+                    break;
+                default:
+                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+            }
+            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
+                cause
+            } : undefined);
+            error.name = 'ChunkLoadError';
+            throw error;
+        });
+        instrumentedBackendLoadChunks.set(thenable, entry);
+    }
+    return entry;
+}
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkPath(sourceType, sourceData, chunkPath) {
+    const url = getChunkRelativeUrl(chunkPath);
+    return loadChunkByUrlInternal(sourceType, sourceData, url);
+}
+/**
+ * Returns an absolute url to an asset.
+ */ function resolvePathFromModule(moduleId) {
+    const exported = this.r(moduleId);
+    return exported?.default ?? exported;
+}
+browserContextPrototype.R = resolvePathFromModule;
+/**
+ * no-op for browser
+ * @param modulePath
+ */ function resolveAbsolutePath(modulePath) {
+    return `/ROOT/${modulePath ?? ''}`;
+}
+browserContextPrototype.P = resolveAbsolutePath;
+/**
+ * Returns a placeholder `file://` URL for the given module path. The browser
+ * runtime intentionally does not expose the real filesystem path. Path
+ * segments are percent-encoded so the result is always a valid file URI.
+ */ function resolveFileUrl(modulePath) {
+    if (!modulePath) return 'file:///ROOT/';
+    return `file:///ROOT/${modulePath.split('/').map(encodeURIComponent).join('/')}`;
+}
+browserContextPrototype.F = resolveFileUrl;
+/**
+ * Exports a URL with the static suffix appended.
+ */ function exportUrl(url, id) {
+    exportValue.call(this, `${url}${ASSET_SUFFIX}`, id);
+}
+browserContextPrototype.q = exportUrl;
+/**
+ * Instantiates a runtime module.
+ */ function instantiateRuntimeModule(moduleId, chunkPath) {
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Returns the URL relative to the origin where a chunk can be fetched from.
+ */ function getChunkRelativeUrl(chunkPath, basePath = CHUNK_BASE_PATH) {
+    return `${getRuntimeChunkBasePath(basePath)}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${ASSET_SUFFIX}`;
+}
+// Shared runtime primitives consumed by the bundled `createWorker` helper,
+// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.
+browserContextPrototype.b = CHUNK_BASE_PATH;
+browserContextPrototype.X = ASSET_SUFFIX;
+// Shared runtime primitive: build a chunk's URL. Used by the bundled worker
+// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.
+browserContextPrototype.h = getChunkRelativeUrl;
+function getPathFromScript(chunkScript) {
+    if (typeof chunkScript === 'string') {
+        return chunkScript;
+    }
+    const chunkUrl = chunkScript.src;
+    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
+    const runtimeBasePath = getRuntimeChunkBasePath();
+    let path = src.startsWith(runtimeBasePath) ? src.slice(runtimeBasePath.length) : src;
+    if (path.startsWith('/')) {
+        path = path.slice(1);
+    }
+    return path;
+}
+/**
+ * Return the ChunkUrl from a ChunkScript.
+ */ function getUrlFromScript(chunk) {
+    if (typeof chunk === 'string') {
+        return getChunkRelativeUrl(chunk);
+    } else {
+        // This is already exactly what we want
+        return chunk.src;
+    }
+}
+/**
+ * Determine the chunk to register. Note that this function has side-effects!
+ */ function getChunkFromRegistration(chunk) {
+    if (typeof chunk === 'string') {
+        if (typeof document !== 'undefined') {
+            const src = document.currentScript?.getAttribute('src');
+            if (src && getPathFromScript({
+                src
+            }) === chunk) {
+                return {
+                    src
+                };
+            }
+        }
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        }
+        return chunk;
+    } else if (!chunk) {
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        } else {
+            throw new Error('chunk path empty but not in a worker');
+        }
+    } else {
+        return {
+            src: chunk.getAttribute('src')
+        };
+    }
+}
+/**
+ * Checks if a given path/URL ends with the given extension,
+ * optionally followed by ?query or #fragment.
+ */ function endsWithExtension(chunkUrlOrPath, ext) {
+    // Find where the path ends (before query or fragment)
+    const q = chunkUrlOrPath.indexOf('?');
+    let end;
+    if (q !== -1) {
+        end = q;
+    } else {
+        const h = chunkUrlOrPath.indexOf('#');
+        end = h !== -1 ? h : chunkUrlOrPath.length;
+    }
+    // Check if the path portion ends with the extension
+    return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length);
+}
+function isJs(chunkUrlOrPath) {
+    return endsWithExtension(chunkUrlOrPath, '.js');
+}
+function isCss(chunkUrl) {
+    return endsWithExtension(chunkUrl, '.css');
+}
+/// <reference path="./runtime-utils.ts" />
+/// <reference path="./runtime-types.d.ts" />
+/// <reference path="./dev-extensions.ts" />
+/// <reference path="./dev-protocol.d.ts" />
+/**
+ * Shared HMR (Hot Module Replacement) implementation.
+ *
+ * This file contains the complete HMR implementation that's shared between
+ * browser and Node.js runtimes. It manages module hot state, dependency
+ * tracking, the module.hot API, and the full HMR update flow.
+ */ /**
+ * The development module cache shared across the runtime.
+ * Browser runtime declares this directly.
+ * Node.js runtime assigns globalThis.__turbopack_module_cache__ to this.
+ */ let devModuleCache;
+/**
+ * Module IDs that are instantiated as part of the runtime of a chunk.
+ */ let runtimeModules;
+/**
+ * Maps module IDs to persisted data between executions of their hot module
+ * implementation (`hot.data`).
+ */ const moduleHotData = new Map();
+/**
+ * Maps module instances to their hot module state.
+ * Uses WeakMap so it works with both HotModule and ModuleWithDirection.
+ */ const moduleHotState = new WeakMap();
+/**
+ * Modules that call `module.hot.invalidate()` (while being updated).
+ */ const queuedInvalidatedModules = new Set();
+class UpdateApplyError extends Error {
+    name = 'UpdateApplyError';
+    constructor(message, dependencyChain){
+        super(message);
+        this.dependencyChain = dependencyChain;
+    }
+}
+/**
+ * Records parent-child relationship when a module imports another.
+ * Should be called during module instantiation.
+ */ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+function trackModuleImport(parentModule, childModuleId, childModule) {
+    // Record that parent imports child
+    if (parentModule.children.indexOf(childModuleId) === -1) {
+        parentModule.children.push(childModuleId);
+    }
+    // Record that child is imported by parent
+    if (childModule && childModule.parents.indexOf(parentModule.id) === -1) {
+        childModule.parents.push(parentModule.id);
+    }
+}
+function formatDependencyChain(dependencyChain) {
+    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
+}
+/**
+ * Walks the dependency tree to find all modules affected by a change.
+ * Returns information about whether the update can be accepted and which
+ * modules need to be invalidated.
+ *
+ * @param moduleId - The module that changed
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().
+ *                           This is used for server-side HMR where pages auto-accept at the top level.
+ */ function getAffectedModuleEffects(moduleId, autoAcceptRootModules) {
+    const outdatedModules = new Set();
+    const outdatedDependencies = new Map();
+    const queue = [
+        {
+            moduleId,
+            dependencyChain: []
+        }
+    ];
+    let nextItem;
+    while(nextItem = queue.shift()){
+        const { moduleId, dependencyChain } = nextItem;
+        if (moduleId != null) {
+            if (outdatedModules.has(moduleId)) {
+                continue;
+            }
+            outdatedModules.add(moduleId);
+        }
+        // We've arrived at the runtime of the chunk, which means that nothing
+        // else above can accept this update.
+        if (moduleId === undefined) {
+            if (autoAcceptRootModules) {
+                return {
+                    type: 'accepted',
+                    moduleId,
+                    outdatedModules,
+                    outdatedDependencies
+                };
+            }
+            return {
+                type: 'unaccepted',
+                dependencyChain
+            };
+        }
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (// The module is not in the cache. Since this is a "modified" update,
+        // it means that the module was never instantiated before.
+        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
+            continue;
+        }
+        if (hotState.selfDeclined) {
+            return {
+                type: 'self-declined',
+                dependencyChain,
+                moduleId
+            };
+        }
+        if (runtimeModules.has(moduleId)) {
+            if (autoAcceptRootModules) {
+                continue;
+            }
+            queue.push({
+                moduleId: undefined,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+            continue;
+        }
+        for (const parentId of module.parents){
+            const parent = devModuleCache[parentId];
+            if (!parent) {
+                continue;
+            }
+            const parentHotState = moduleHotState.get(parent);
+            // Check if parent declined this dependency
+            if (parentHotState?.declinedDependencies[moduleId]) {
+                return {
+                    type: 'declined',
+                    dependencyChain: [
+                        ...dependencyChain,
+                        moduleId
+                    ],
+                    moduleId,
+                    parentId
+                };
+            }
+            // Skip if parent is already outdated
+            if (outdatedModules.has(parentId)) {
+                continue;
+            }
+            // Check if parent accepts this dependency
+            if (parentHotState?.acceptedDependencies[moduleId]) {
+                if (!outdatedDependencies.has(parentId)) {
+                    outdatedDependencies.set(parentId, new Set());
+                }
+                outdatedDependencies.get(parentId).add(moduleId);
+                continue;
+            }
+            // Neither accepted nor declined — propagate to parent
+            queue.push({
+                moduleId: parentId,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+        }
+        // If no parents and we're at a root module, auto-accept if configured
+        if (module.parents.length === 0 && autoAcceptRootModules) {
+            continue;
+        }
+    }
+    return {
+        type: 'accepted',
+        moduleId,
+        outdatedModules,
+        outdatedDependencies
+    };
+}
+/**
+ * Merges source dependency map into target dependency map.
+ */ function mergeDependencies(target, source) {
+    for (const [parentId, deps] of source){
+        const existing = target.get(parentId);
+        if (existing) {
+            for (const dep of deps){
+                existing.add(dep);
+            }
+        } else {
+            target.set(parentId, new Set(deps));
+        }
+    }
+}
+/**
+ * Computes all modules that need to be invalidated based on which modules changed.
+ *
+ * @param invalidated - The modules that have been invalidated
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function computedInvalidatedModules(invalidated, autoAcceptRootModules) {
+    const outdatedModules = new Set();
+    const outdatedDependencies = new Map();
+    for (const moduleId of invalidated){
+        const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules);
+        switch(effect.type){
+            case 'unaccepted':
+                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'self-declined':
+                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'declined':
+                throw new UpdateApplyError(`cannot apply update: declined dependency. ${formatDependencyChain(effect.dependencyChain)}. Declined by ${effect.parentId}.`, effect.dependencyChain);
+            case 'accepted':
+                for (const outdatedModuleId of effect.outdatedModules){
+                    outdatedModules.add(outdatedModuleId);
+                }
+                mergeDependencies(outdatedDependencies, effect.outdatedDependencies);
+                break;
+            default:
+                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
+        }
+    }
+    return {
+        outdatedModules,
+        outdatedDependencies
+    };
+}
+/**
+ * Creates the module.hot API object and its internal state.
+ * This provides the HMR API that user code calls (module.hot.accept(), etc.)
+ */ function createModuleHot(moduleId, hotData) {
+    const hotState = {
+        selfAccepted: false,
+        selfDeclined: false,
+        selfInvalidated: false,
+        disposeHandlers: [],
+        acceptedDependencies: {},
+        acceptedErrorHandlers: {},
+        declinedDependencies: {}
+    };
+    const hot = {
+        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
+        // decide whether to warn whenever an HMR-disposed module required other
+        // modules. We might want to remove it.
+        active: true,
+        data: hotData ?? {},
+        accept: (modules, callback, errorHandler)=>{
+            if (modules === undefined) {
+                hotState.selfAccepted = true;
+            } else if (typeof modules === 'function') {
+                hotState.selfAccepted = modules;
+            } else if (typeof modules === 'object' && modules !== null) {
+                for(let i = 0; i < modules.length; i++){
+                    hotState.acceptedDependencies[modules[i]] = callback || function() {};
+                    hotState.acceptedErrorHandlers[modules[i]] = errorHandler;
+                }
+            } else {
+                hotState.acceptedDependencies[modules] = callback || function() {};
+                hotState.acceptedErrorHandlers[modules] = errorHandler;
+            }
+        },
+        decline: (dep)=>{
+            if (dep === undefined) {
+                hotState.selfDeclined = true;
+            } else if (typeof dep === 'object' && dep !== null) {
+                for(let i = 0; i < dep.length; i++){
+                    hotState.declinedDependencies[dep[i]] = true;
+                }
+            } else {
+                hotState.declinedDependencies[dep] = true;
+            }
+        },
+        dispose: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        addDisposeHandler: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        removeDisposeHandler: (callback)=>{
+            const idx = hotState.disposeHandlers.indexOf(callback);
+            if (idx >= 0) {
+                hotState.disposeHandlers.splice(idx, 1);
+            }
+        },
+        invalidate: ()=>{
+            hotState.selfInvalidated = true;
+            queuedInvalidatedModules.add(moduleId);
+        },
+        // NOTE(alexkirsz) This is part of the management API, which we don't
+        // implement, but the Next.js React Refresh runtime uses this to decide
+        // whether to schedule an update.
+        status: ()=>'idle',
+        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
+        addStatusHandler: (_handler)=>{},
+        removeStatusHandler: (_handler)=>{},
+        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
+        // want the webpack code paths to ever update (the turbopack paths handle
+        // this already).
+        check: ()=>Promise.resolve(null)
+    };
+    return {
+        hot,
+        hotState
+    };
+}
+/**
+ * Processes queued invalidated modules and adds them to the outdated modules set.
+ * Modules that call module.hot.invalidate() are queued and processed here.
+ *
+ * @param outdatedModules - The current set of outdated modules
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules) {
+    if (queuedInvalidatedModules.size > 0) {
+        const result = computedInvalidatedModules(queuedInvalidatedModules, autoAcceptRootModules);
+        for (const moduleId of result.outdatedModules){
+            outdatedModules.add(moduleId);
+        }
+        mergeDependencies(outdatedDependencies, result.outdatedDependencies);
+        queuedInvalidatedModules.clear();
+    }
+    return {
+        outdatedModules,
+        outdatedDependencies
+    };
+}
+/**
+ * Computes which outdated modules have self-accepted and can be hot reloaded.
+ */ function computeOutdatedSelfAcceptedModules(outdatedModules) {
+    const outdatedSelfAcceptedModules = [];
+    for (const moduleId of outdatedModules){
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (module && hotState?.selfAccepted && !hotState.selfInvalidated) {
+            outdatedSelfAcceptedModules.push({
+                moduleId,
+                errorHandler: hotState.selfAccepted
+            });
+        }
+    }
+    return outdatedSelfAcceptedModules;
+}
+/**
+ * Disposes of an instance of a module.
+ * Runs hot.dispose handlers and manages persistent hot data.
+ *
+ * NOTE: mode = "replace" will not remove modules from devModuleCache.
+ * This must be done in a separate step afterwards.
+ */ function disposeModule(moduleId, mode) {
+    const module = devModuleCache[moduleId];
+    if (!module) {
+        return;
+    }
+    const hotState = moduleHotState.get(module);
+    if (!hotState) {
+        return;
+    }
+    const data = {};
+    // Run the `hot.dispose` handler, if any, passing in the persistent
+    // `hot.data` object.
+    for (const disposeHandler of hotState.disposeHandlers){
+        disposeHandler(data);
+    }
+    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
+    // module is still importing other modules.
+    if (module.hot) {
+        module.hot.active = false;
+    }
+    moduleHotState.delete(module);
+    // Remove the disposed module from its children's parent list.
+    // It will be added back once the module re-instantiates and imports its
+    // children again.
+    for (const childId of module.children){
+        const child = devModuleCache[childId];
+        if (!child) {
+            continue;
+        }
+        const idx = child.parents.indexOf(module.id);
+        if (idx >= 0) {
+            child.parents.splice(idx, 1);
+        }
+    }
+    switch(mode){
+        case 'clear':
+            delete devModuleCache[module.id];
+            moduleHotData.delete(module.id);
+            break;
+        case 'replace':
+            moduleHotData.set(module.id, data);
+            break;
+        default:
+            invariant(mode, (mode)=>`invalid mode: ${mode}`);
+    }
+}
+/**
+ * Dispose phase: runs dispose handlers and cleans up outdated/disposed modules.
+ * Returns the parent modules of outdated modules for use in the apply phase.
+ */ function disposePhase(outdatedModules, disposedModules, outdatedDependencies) {
+    for (const moduleId of outdatedModules){
+        disposeModule(moduleId, 'replace');
+    }
+    for (const moduleId of disposedModules){
+        disposeModule(moduleId, 'clear');
+    }
+    // Removing modules from the module cache is a separate step.
+    // We also want to keep track of previous parents of the outdated modules.
+    const outdatedModuleParents = new Map();
+    for (const moduleId of outdatedModules){
+        const oldModule = devModuleCache[moduleId];
+        outdatedModuleParents.set(moduleId, oldModule?.parents);
+        delete devModuleCache[moduleId];
+    }
+    // Remove outdated dependencies from parent module's children list.
+    // When a parent accepts a child's update, the child is re-instantiated
+    // but the parent stays alive. We remove the old child reference so it
+    // gets re-added when the child re-imports.
+    for (const [parentId, deps] of outdatedDependencies){
+        const module = devModuleCache[parentId];
+        if (module) {
+            for (const dep of deps){
+                const idx = module.children.indexOf(dep);
+                if (idx >= 0) {
+                    module.children.splice(idx, 1);
+                }
+            }
+        }
+    }
+    return {
+        outdatedModuleParents
+    };
+}
+/* eslint-disable @typescript-eslint/no-unused-vars */ /**
+ * Shared module instantiation logic.
+ * This handles the full module instantiation flow for both browser and Node.js.
+ * Only React Refresh hooks differ between platforms (passed as callback).
+ */ function instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContextFn, runModuleExecutionHooksFn) {
+    // 1. Factory validation (same in both browser and Node.js)
+    const id = moduleId;
+    const moduleFactory = moduleFactories.get(id);
+    if (typeof moduleFactory !== 'function') {
+        throw new Error(factoryNotAvailableMessage(moduleId, sourceType, sourceData) + `\nThis is often caused by a stale browser cache, misconfigured Cache-Control headers, or a service worker serving outdated responses.` + `\nTo fix this, make sure your Cache-Control headers allow revalidation of chunks and review your service worker configuration. ` + `As an immediate workaround, try hard-reloading the page, clearing the browser cache, or unregistering any service workers.`);
+    }
+    // 2. Hot API setup (same in both - works for browser, included for Node.js)
+    const hotData = moduleHotData.get(id);
+    const { hot, hotState } = createModuleHot(id, hotData);
+    // 3. Parent assignment logic (same in both)
+    let parents;
+    switch(sourceType){
+        case SourceType.Runtime:
+            runtimeModules.add(id);
+            parents = [];
+            break;
+        case SourceType.Parent:
+            parents = [
+                sourceData
+            ];
+            break;
+        case SourceType.Update:
+            parents = sourceData || [];
+            break;
+        default:
+            throw new Error(`Unknown source type: ${sourceType}`);
+    }
+    // 4. Module creation (platform creates base module object)
+    const module = createModuleObjectFn(id);
+    const exports = module.exports;
+    module.parents = parents;
+    module.children = [];
+    module.hot = hot;
+    devModuleCache[id] = module;
+    moduleHotState.set(module, hotState);
+    // 5. Module execution (React Refresh hooks are platform-specific)
+    try {
+        runModuleExecutionHooksFn(module, (refresh)=>{
+            const context = createContextFn(module, exports, refresh);
+            moduleFactory.call(exports, context, module, exports);
+        });
+    } catch (error) {
+        module.error = error;
+        throw error;
+    }
+    // 6. ESM interop (same in both)
+    if (module.namespaceObject && module.exports !== module.namespaceObject) {
+        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+        interopEsm(module.exports, module.namespaceObject);
+    }
+    return module;
+}
+/**
+ * Analyzes update entries and chunks to determine which modules were added, modified, or deleted.
+ * This is pure logic that doesn't depend on the runtime environment.
+ */ function computeChangedModules(entries, updates, chunkModulesMap) {
+    const chunksAdded = new Map();
+    const chunksDeleted = new Map();
+    const added = new Map();
+    const modified = new Map();
+    const deleted = new Set();
+    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
+        switch(mergedChunkUpdate.type){
+            case 'added':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.modules);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    break;
+                }
+            case 'deleted':
+                {
+                    const updateDeleted = chunkModulesMap ? new Set(chunkModulesMap.get(chunkPath)) : new Set();
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            case 'partial':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.added);
+                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            default:
+                throw new Error('Unknown merged chunk update type');
+        }
+    }
+    // If a module was added from one chunk and deleted from another in the same update,
+    // consider it to be modified, as it means the module was moved from one chunk to another
+    // AND has new code in a single update.
+    for (const moduleId of added.keys()){
+        if (deleted.has(moduleId)) {
+            added.delete(moduleId);
+            deleted.delete(moduleId);
+        }
+    }
+    for (const [moduleId, entry] of Object.entries(entries)){
+        // Modules that haven't been added to any chunk but have new code are considered
+        // to be modified.
+        // This needs to be under the previous loop, as we need it to get rid of modules
+        // that were added and deleted in the same update.
+        if (!added.has(moduleId)) {
+            modified.set(moduleId, entry);
+        }
+    }
+    return {
+        added,
+        deleted,
+        modified,
+        chunksAdded,
+        chunksDeleted
+    };
+}
+/**
+ * Compiles new module code and walks the dependency tree to find all outdated modules.
+ * Uses the evalModuleEntry function to compile code (platform-specific).
+ *
+ * @param added - Map of added modules
+ * @param modified - Map of modified modules
+ * @param evalModuleEntry - Function to compile module code
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules) {
+    const newModuleFactories = new Map();
+    // Compile added modules
+    for (const [moduleId, entry] of added){
+        if (entry != null) {
+            newModuleFactories.set(moduleId, evalModuleEntry(entry));
+        }
+    }
+    // Walk dependency tree to find all modules affected by modifications
+    const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(modified.keys(), autoAcceptRootModules);
+    // Compile modified modules
+    for (const [moduleId, entry] of modified){
+        newModuleFactories.set(moduleId, evalModuleEntry(entry));
+    }
+    return {
+        outdatedModules,
+        outdatedDependencies,
+        newModuleFactories
+    };
+}
+/**
+ * Updates module factories and re-instantiates self-accepted modules.
+ * Uses the instantiateModule function (platform-specific via callback).
+ */ function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError) {
+    // Update module factories
+    for (const [moduleId, factory] of newModuleFactories.entries()){
+        applyModuleFactoryNameFn(factory);
+        moduleFactories.set(moduleId, factory);
+    }
+    // TODO(alexkirsz) Run new runtime entries here.
+    // Call accept handlers for outdated dependencies.
+    // This runs BEFORE re-instantiating self-accepted modules, matching
+    // webpack's behavior.
+    for (const [parentId, deps] of outdatedDependencies){
+        const module = devModuleCache[parentId];
+        if (!module) continue;
+        const hotState = moduleHotState.get(module);
+        if (!hotState) continue;
+        // Group deps by callback, deduplicating callbacks that handle multiple deps.
+        // Each callback receives only the deps it was registered for.
+        const callbackDeps = new Map();
+        const callbackErrorHandlers = new Map();
+        for (const dep of deps){
+            const acceptCallback = hotState.acceptedDependencies[dep];
+            if (acceptCallback) {
+                let depList = callbackDeps.get(acceptCallback);
+                if (!depList) {
+                    depList = [];
+                    callbackDeps.set(acceptCallback, depList);
+                    callbackErrorHandlers.set(acceptCallback, hotState.acceptedErrorHandlers[dep]);
+                }
+                depList.push(dep);
+            }
+        }
+        for (const [callback, cbDeps] of callbackDeps){
+            try {
+                callback.call(null, cbDeps);
+            } catch (err) {
+                const errorHandler = callbackErrorHandlers.get(callback);
+                if (typeof errorHandler === 'function') {
+                    try {
+                        errorHandler(err, {
+                            moduleId: parentId,
+                            dependencyId: cbDeps[0]
+                        });
+                    } catch (err2) {
+                        reportError(err2);
+                        reportError(err);
+                    }
+                } else {
+                    reportError(err);
+                }
+            }
+        }
+    }
+    // Re-instantiate all outdated self-accepted modules
+    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
+        try {
+            instantiateModuleFn(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
+        } catch (err) {
+            if (typeof errorHandler === 'function') {
+                try {
+                    errorHandler(err, {
+                        moduleId,
+                        module: devModuleCache[moduleId]
+                    });
+                } catch (err2) {
+                    reportError(err2);
+                    reportError(err);
+                }
+            } else {
+                reportError(err);
+            }
+        }
+    }
+}
+/**
+ * Internal implementation that orchestrates the full HMR update flow:
+ * invalidation, disposal, and application of new modules.
+ *
+ * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
+ */ function applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules) {
+    ;
+    ({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules));
+    // Find self-accepted modules to re-instantiate
+    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
+    // Run dispose handlers, save hot.data, clear caches
+    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules, outdatedDependencies);
+    let error;
+    function reportError(err) {
+        if (!error) error = err; // Keep first error
+    }
+    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError);
+    if (error) {
+        throw error;
+    }
+    // Recursively apply any queued invalidations from new module execution
+    if (queuedInvalidatedModules.size > 0) {
+        applyInternal(new Set(), new Map(), [], new Map(), moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules);
+    }
+}
+/**
+ * Main entry point for applying an ECMAScript merged update.
+ * This is called by both browser and Node.js runtimes with platform-specific callbacks.
+ *
+ * @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit
+ *                                   module.hot.accept(). Used for server-side HMR where pages
+ *                                   auto-accept at the top level.
+ */ function applyEcmascriptMergedUpdateShared(options) {
+    const { added, modified, disposedModules, evalModuleEntry, instantiateModule, applyModuleFactoryName, moduleFactories, devModuleCache, autoAcceptRootModules } = options;
+    const { outdatedModules, outdatedDependencies, newModuleFactories } = computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules);
+    applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModule, applyModuleFactoryName, autoAcceptRootModules);
+}
+/// <reference path="../../../shared/runtime/dev-globals.d.ts" />
+/// <reference path="../../../shared/runtime/dev-protocol.d.ts" />
+const devContextPrototype = Context.prototype;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *development* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ // Assign browser's module cache and runtime modules to shared HMR state
+devModuleCache = Object.create(null);
+devContextPrototype.c = devModuleCache;
+runtimeModules = new Set();
+// Set flag to indicate we use ModuleWithDirection
+createModuleWithDirectionFlag = true;
+function getRefreshBoundaryExports(exports) {
+    if (typeof isAsyncModuleExt === 'function' && exports != null && typeof exports === 'object' && isAsyncModuleExt(exports)) {
+        return exports[turbopackExports];
+    }
+    return exports;
+}
+/**
+ * Map from module ID to the chunks that contain this module.
+ *
+ * In HMR, we need to keep track of which modules are contained in which so
+ * chunks. This is so we don't eagerly dispose of a module when it is removed
+ * from chunk A, but still exists in chunk B.
+ */ const moduleChunksMap = new Map();
+/**
+ * Map from a chunk path to all modules it contains.
+ */ const chunkModulesMap = new Map();
+/**
+ * Chunk lists that contain a runtime. When these chunk lists receive an update
+ * that can't be reconciled with the current state of the page, we need to
+ * reload the runtime entirely.
+ */ const runtimeChunkLists = new Set();
+/**
+ * Map from a chunk list to the chunk paths it contains.
+ */ const chunkListChunksMap = new Map();
+/**
+ * Map from a chunk path to the chunk lists it belongs to.
+ */ const chunkChunkListsMap = new Map();
+const dynamicChunkListLoadStates = new Map();
+const pendingHmrTasks = [];
+const chunkListGenerations = new Map();
+let nextChunkListGeneration = 1;
+let activeHmrTask;
+const discardedChunkRegistrations = new Set();
+const dynamicMemberChunkUrlOwners = new Map();
+/**
+ * Gets or instantiates a runtime module.
+ */ // @ts-ignore
+function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
+    const module = devModuleCache[moduleId];
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        return module;
+    }
+    // @ts-ignore
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */ // @ts-ignore Defined in `runtime-utils.ts`
+const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
+    if (!sourceModule.hot.active) {
+        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
+    }
+    const module = devModuleCache[id];
+    if (sourceModule.children.indexOf(id) === -1) {
+        sourceModule.children.push(id);
+    }
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        if (module.parents.indexOf(sourceModule.id) === -1) {
+            module.parents.push(sourceModule.id);
+        }
+        return module;
+    }
+    return instantiateModule(id, SourceType.Parent, sourceModule.id);
+};
+function DevContext(module, exports, refresh) {
+    Context.call(this, module, exports);
+    this.k = refresh;
+}
+DevContext.prototype = Context.prototype;
+function instantiateModule(moduleId, sourceType, sourceData) {
+    // Browser: creates base HotModule object (hot API added by shared code)
+    const createModuleObjectFn = (id)=>{
+        return createModuleObject(id);
+    };
+    // Browser: creates DevContext with refresh
+    const createContext = (module, exports, refresh)=>{
+        return new DevContext(module, exports, refresh);
+    };
+    // Use shared instantiation logic (includes hot API setup)
+    return instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContext, runModuleExecutionHooks);
+}
+const DUMMY_REFRESH_CONTEXT = {
+    register: (_type, _id)=>{},
+    signature: ()=>(_type)=>{},
+    registerExports: (_module, _helpers)=>{}
+};
+/**
+ * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
+ * Next.js' React Refresh runtime hooks into to add module context to the
+ * refresh registry.
+ */ function runModuleExecutionHooks(module, executeModule) {
+    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
+        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
+        try {
+            executeModule({
+                register: globalThis.$RefreshReg$,
+                signature: globalThis.$RefreshSig$,
+                registerExports: registerExportsAndSetupBoundaryForReactRefresh
+            });
+        } finally{
+            // Always cleanup the intercept, even if module execution failed.
+            cleanupReactRefreshIntercept();
+        }
+    } else {
+        // If the react refresh hooks are not installed we need to bind dummy functions.
+        // This is expected when running in a Web Worker.  It is also common in some of
+        // our test environments.
+        executeModule(DUMMY_REFRESH_CONTEXT);
+    }
+}
+/**
+ * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+ */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
+    const currentExports = getRefreshBoundaryExports(module.exports);
+    const prevExports = module.hot.data.prevExports ?? null;
+    helpers.registerExportsForReactRefresh(currentExports, module.id);
+    // A module can be accepted automatically based on its exports, e.g. when
+    // it is a Refresh Boundary.
+    if (helpers.isReactRefreshBoundary(currentExports)) {
+        // Save the previous exports on update, so we can compare the boundary
+        // signatures.
+        module.hot.dispose((data)=>{
+            data.prevExports = currentExports;
+        });
+        // Unconditionally accept an update to this module, we'll check if it's
+        // still a Refresh Boundary later.
+        module.hot.accept();
+        // This field is set when the previous version of this module was a
+        // Refresh Boundary, letting us know we need to check for invalidation or
+        // enqueue an update.
+        if (prevExports !== null) {
+            // A boundary can become ineligible if its exports are incompatible
+            // with the previous exports.
+            //
+            // For example, if you add/remove/change exports, we'll want to
+            // re-execute the importing modules, and force those components to
+            // re-render. Similarly, if you convert a class component to a
+            // function, we want to invalidate the boundary.
+            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
+                module.hot.invalidate();
+            } else {
+                helpers.scheduleUpdate();
+            }
+        }
+    } else {
+        // Since we just executed the code for the module, it's possible that the
+        // new exports made it ineligible for being a boundary.
+        // We only care about the case when we were _previously_ a boundary,
+        // because we already accepted this update (accidental side effect).
+        const isNoLongerABoundary = prevExports !== null;
+        if (isNoLongerABoundary) {
+            module.hot.invalidate();
+        }
+    }
+}
+/**
+ * Adds, deletes, and moves modules between chunks. This must happen before the
+ * dispose phase as it needs to know which modules were removed from all chunks,
+ * which we can only compute *after* taking care of added and moved modules.
+ */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
+    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
+        for (const moduleId of addedModuleIds){
+            addModuleToChunk(moduleId, chunkPath);
+        }
+    }
+    const disposedModules = new Set();
+    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
+        for (const moduleId of addedModuleIds){
+            if (removeModuleFromChunk(moduleId, chunkPath)) {
+                disposedModules.add(moduleId);
+            }
+        }
+    }
+    return {
+        disposedModules
+    };
+}
+const PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict');
+function mergeParallelChunkUpdate(updateA, updateB) {
+    if (updateA.type === updateB.type) {
+        return updateA;
+    }
+    if (updateA.type === 'total' || updateB.type === 'total') {
+        return {
+            type: 'total'
+        };
+    }
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        return null;
+    }
+    return PARALLEL_UPDATE_CONFLICT;
+}
+function mergeParallelEcmascriptChunkUpdate(updateA, updateB) {
+    if (updateA.type === 'added' && updateB.type === 'added') {
+        return {
+            type: 'added',
+            modules: [
+                ...new Set([
+                    ...updateA.modules ?? [],
+                    ...updateB.modules ?? []
+                ])
+            ]
+        };
+    }
+    if (updateA.type === 'deleted' && updateB.type === 'deleted') {
+        return {
+            type: 'deleted',
+            modules: [
+                ...new Set([
+                    ...updateA.modules ?? [],
+                    ...updateB.modules ?? []
+                ])
+            ]
+        };
+    }
+    if (updateA.type === 'partial' && updateB.type === 'partial') {
+        const added = new Set([
+            ...updateA.added ?? [],
+            ...updateB.added ?? []
+        ]);
+        const deleted = new Set([
+            ...updateA.deleted ?? [],
+            ...updateB.deleted ?? []
+        ]);
+        for (const moduleId of added){
+            if (deleted.has(moduleId)) {
+                added.delete(moduleId);
+                deleted.delete(moduleId);
+            }
+        }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
+    }
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        const addedUpdate = updateA.type === 'added' ? updateA : updateB;
+        const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB;
+        const added = new Set(addedUpdate.modules ?? []);
+        const deleted = new Set(deletedUpdate.modules ?? []);
+        for (const moduleId of added){
+            if (deleted.has(moduleId)) {
+                added.delete(moduleId);
+                deleted.delete(moduleId);
+            }
+        }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
+    }
+    if (updateA.type === 'partial') {
+        if ((updateA.added?.length ?? 0) === 0 && (updateA.deleted?.length ?? 0) === 0) {
+            return updateB;
+        }
+        return PARALLEL_UPDATE_CONFLICT;
+    }
+    if (updateB.type === 'partial') {
+        if ((updateB.added?.length ?? 0) === 0 && (updateB.deleted?.length ?? 0) === 0) {
+            return updateA;
+        }
+        return PARALLEL_UPDATE_CONFLICT;
+    }
+    return PARALLEL_UPDATE_CONFLICT;
+}
+function moduleEntriesEqual(entryA, entryB) {
+    // The same module can be emitted into multiple chunks. Its source URL is
+    // chunk-relative, so it is allowed to differ even when the executable entry
+    // is identical. Treat only code and source map differences as conflicts.
+    return entryA.code === entryB.code && entryA.map === entryB.map;
+}
+function applyChunkListUpdates(updates) {
+    const resourceOperations = [];
+    const ownershipTransitions = new Map();
+    const chunks = new Map();
+    const ecmascriptChunks = new Map();
+    const entries = {};
+    const explicitlyModifiedModules = new Set();
+    let hasConflict = false;
+    for (const { chunkListPath, update } of updates){
+        if (update.chunks) {
+            for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+                if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, chunkUpdate.type, ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                }
+                if (!chunks.has(chunkPath)) {
+                    chunks.set(chunkPath, chunkUpdate);
+                } else {
+                    const previous = chunks.get(chunkPath);
+                    if (previous === null) {
+                        chunks.set(chunkPath, chunkUpdate);
+                    } else {
+                        const merged = mergeParallelChunkUpdate(previous, chunkUpdate);
+                        if (merged === PARALLEL_UPDATE_CONFLICT) {
+                            hasConflict = true;
+                        } else {
+                            chunks.set(chunkPath, merged);
+                        }
+                    }
+                }
+            }
+        }
+        for (const merged of update.merged ?? []){
+            if (merged.type !== 'EcmascriptMergedUpdate') {
+                invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+            const addedInThisUpdate = new Set();
+            for (const [chunkPath, chunkUpdate] of Object.entries(merged.chunks ?? {})){
+                if (chunkUpdate.type === 'added') {
+                    for (const moduleId of chunkUpdate.modules ?? []){
+                        addedInThisUpdate.add(moduleId);
+                    }
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'added', ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                } else if (chunkUpdate.type === 'deleted') {
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'deleted', ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                } else {
+                    for (const moduleId of chunkUpdate.added ?? []){
+                        addedInThisUpdate.add(moduleId);
+                    }
+                }
+                const previous = ecmascriptChunks.get(chunkPath);
+                if (!previous) {
+                    ecmascriptChunks.set(chunkPath, chunkUpdate);
+                } else {
+                    const combined = mergeParallelEcmascriptChunkUpdate(previous, chunkUpdate);
+                    if (combined === PARALLEL_UPDATE_CONFLICT) {
+                        hasConflict = true;
+                    } else {
+                        ecmascriptChunks.set(chunkPath, combined);
+                    }
+                }
+            }
+            for (const [moduleId, entry] of Object.entries(merged.entries ?? {})){
+                const previous = entries[moduleId];
+                if (previous) {
+                    if (!moduleEntriesEqual(previous, entry)) {
+                        hasConflict = true;
+                    }
+                } else {
+                    entries[moduleId] = entry;
+                }
+                if (!addedInThisUpdate.has(moduleId)) {
+                    explicitlyModifiedModules.add(moduleId);
+                }
+            }
+        }
+    }
+    if (hasConflict) {
+        DEV_BACKEND.restart();
+        return resourceOperations;
+    }
+    const filteredEcmascriptChunks = {};
+    for (const [chunkPath, chunkUpdate] of ecmascriptChunks){
+        const transition = ownershipTransitions.get(chunkPath);
+        if (chunkUpdate.type === 'added' && transition && transition.before > 0) {
+            for (const moduleId of chunkUpdate.modules ?? []){
+                if (!explicitlyModifiedModules.has(moduleId)) {
+                    delete entries[moduleId];
+                }
+            }
+            continue;
+        }
+        if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {
+            continue;
+        }
+        filteredEcmascriptChunks[chunkPath] = chunkUpdate;
+    }
+    if (Object.keys(entries).length > 0 || Object.keys(filteredEcmascriptChunks).length > 0) {
+        applyEcmascriptMergedUpdate({
+            type: 'EcmascriptMergedUpdate',
+            entries,
+            chunks: filteredEcmascriptChunks
+        });
+    }
+    for (const [chunkPath, chunkUpdate] of chunks){
+        if (chunkUpdate === null) {
+            continue;
+        }
+        const transition = ownershipTransitions.get(chunkPath);
+        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+        const chunkUrl = getChunkRelativeUrl(chunkPath);
+        switch(chunkUpdate.type){
+            case 'added':
+                if (!transition || transition.before === 0 && transition.after > 0) {
+                    resourceOperations.push({
+                        chunkPath,
+                        promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl)
+                    });
+                }
+                break;
+            case 'total':
+                if (ownerCount > 0) {
+                    const promise = DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    if (promise) {
+                        resourceOperations.push({
+                            chunkPath,
+                            promise
+                        });
+                    }
+                }
+                break;
+            case 'deleted':
+                if (!transition || transition.before > 0 && transition.after === 0) {
+                    disposeChunk(chunkPath);
+                }
+                break;
+            case 'partial':
+                invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                break;
+            default:
+                invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+        }
+    }
+    return resourceOperations;
+}
+function applyEcmascriptMergedUpdate(update) {
+    // Browser-specific chunk management phase
+    const { entries = {}, chunks = {} } = update;
+    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks, chunkModulesMap);
+    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
+    // Use shared HMR update implementation
+    applyEcmascriptMergedUpdateShared({
+        added,
+        modified,
+        disposedModules,
+        evalModuleEntry: _eval,
+        instantiateModule,
+        applyModuleFactoryName,
+        moduleFactories,
+        devModuleCache,
+        autoAcceptRootModules: false
+    });
+}
+function getCurrentTaskPaths(task) {
+    return task.chunkLists.filter(({ path, generation })=>chunkListGenerations.get(path) === generation).map(({ path })=>path);
+}
+function isHmrTaskBlocked(task) {
+    return task.chunkLists.some(({ path, generation })=>{
+        if (chunkListGenerations.get(path) !== generation) return false;
+        const state = dynamicChunkListLoadStates.get(path);
+        return state?.generation === generation && state.loading;
+    });
+}
+function runHmrTask(task) {
+    activeHmrTask = task;
+    void (async ()=>{
+        let resourceOperations = [];
+        try {
+            const currentPaths = new Set(getCurrentTaskPaths(task));
+            if (currentPaths.size > 0) {
+                resourceOperations = task.apply(currentPaths);
+                const results = await Promise.allSettled(resourceOperations.map(({ promise })=>promise));
+                const failedIndex = results.findIndex((result, index)=>result.status === 'rejected' && chunkChunkListsMap.has(resourceOperations[index].chunkPath));
+                if (failedIndex !== -1) {
+                    throw results[failedIndex].reason;
+                }
+            }
+            task.resolve();
+        } catch (cause) {
+            // A terminal update invalidates the generation immediately. Any member
+            // request it cancelled belongs to that old generation and must not turn
+            // a valid replacement subscription into a page reload.
+            if (getCurrentTaskPaths(task).length === 0) {
+                task.resolve();
+            } else {
+                task.reject(cause);
+            }
+        } finally{
+            for (const { chunkPath } of resourceOperations){
+                if (!chunkChunkListsMap.has(chunkPath)) {
+                    disposeChunk(chunkPath);
+                }
+            }
+            if (activeHmrTask === task) {
+                activeHmrTask = undefined;
+            }
+            flushPendingHmrTasks();
+        }
+    })();
+}
+function scheduleHmrTask(chunkListPaths, apply) {
+    const chunkLists = [
+        ...new Set(chunkListPaths)
+    ].flatMap((path)=>{
+        const generation = chunkListGenerations.get(path);
+        return generation === undefined ? [] : [
+            {
+                path,
+                generation
+            }
+        ];
+    });
+    if (chunkLists.length === 0) {
+        return Promise.resolve();
+    }
+    let resolve;
+    let reject;
+    const completion = new Promise((innerResolve, innerReject)=>{
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    const task = {
+        chunkLists,
+        apply,
+        resolve,
+        reject
+    };
+    for (const { path, generation } of chunkLists){
+        const state = dynamicChunkListLoadStates.get(path);
+        if (state?.generation === generation && state.bootstrapping && !state.terminated) {
+            state.pendingTasks.add(completion);
+            void completion.then(()=>state.pendingTasks.delete(completion), ()=>state.pendingTasks.delete(completion));
+        }
+    }
+    if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {
+        pendingHmrTasks.push(task);
+        flushPendingHmrTasks();
+    } else {
+        runHmrTask(task);
+    }
+    return completion;
+}
+function flushPendingHmrTasks() {
+    if (activeHmrTask) return;
+    while(pendingHmrTasks.length > 0){
+        const task = pendingHmrTasks[0];
+        if (getCurrentTaskPaths(task).length === 0) {
+            pendingHmrTasks.shift();
+            task.resolve();
+            continue;
+        }
+        if (isHmrTaskBlocked(task)) {
+            return;
+        }
+        pendingHmrTasks.shift();
+        runHmrTask(task);
+        return;
+    }
+}
+function handleApplyBatch(updates) {
+    const relevantUpdates = updates.map((update)=>({
+            chunkListPath: update.resource.path,
+            update: update.instruction
+        })).filter(({ chunkListPath })=>chunkListChunksMap.has(chunkListPath));
+    const chunkListPaths = [
+        ...new Set(relevantUpdates.map(({ chunkListPath })=>chunkListPath))
+    ];
+    if (chunkListPaths.length === 0) {
+        return {
+            handledPaths: []
+        };
+    }
+    const bootstrappingPaths = chunkListPaths.filter((chunkListPath)=>{
+        const state = dynamicChunkListLoadStates.get(chunkListPath);
+        return state?.bootstrapping && !state.terminated;
+    });
+    if (bootstrappingPaths.length > 0) {
+        for (const chunkListPath of bootstrappingPaths){
+            const state = dynamicChunkListLoadStates.get(chunkListPath);
+            terminateDynamicChunkListLoad(chunkListPath, state, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
+        }
+        DEV_BACKEND.restart();
+        flushPendingHmrTasks();
+        return {
+            handledPaths: chunkListPaths
+        };
+    }
+    const completion = scheduleHmrTask(chunkListPaths, (currentPaths)=>{
+        const chunkListUpdates = relevantUpdates.filter(({ chunkListPath })=>currentPaths.has(chunkListPath)).map(({ chunkListPath, update })=>{
+            if (update.type !== 'ChunkListUpdate') {
+                invariant(update, (update)=>`Unknown update type: ${update.type}`);
+            }
+            return {
+                chunkListPath,
+                update
+            };
+        });
+        return chunkListUpdates.length > 0 ? applyChunkListUpdates(chunkListUpdates) : [];
+    });
+    return {
+        handledPaths: chunkListPaths,
+        completion
+    };
+}
+function handleApply(chunkListPath, update) {
+    const loadState = dynamicChunkListLoadStates.get(chunkListPath);
+    if (update.type === 'partial' && loadState?.bootstrapping && !loadState.terminated) {
+        terminateDynamicChunkListLoad(chunkListPath, loadState, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
+        DEV_BACKEND.restart();
+        flushPendingHmrTasks();
+        return Promise.resolve();
+    }
+    if (update.type === 'notFound' || update.type === 'restart') {
+        if (loadState && !loadState.terminated) {
+            const error = new Error(update.type === 'notFound' ? `Dynamic chunk list ${chunkListPath} disappeared while loading.` : `Dynamic chunk list ${chunkListPath} must restart while loading.`);
+            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+        }
+        if (update.type === 'restart') {
+            chunkListGenerations.delete(chunkListPath);
+            dynamicChunkListLoadStates.delete(chunkListPath);
+        }
+        handleApplyImmediately(chunkListPath, update);
+        flushPendingHmrTasks();
+        return Promise.resolve();
+    }
+    return scheduleHmrTask([
+        chunkListPath
+    ], (currentPaths)=>currentPaths.has(chunkListPath) ? handleApplyImmediately(chunkListPath, update) : []);
+}
+function handleApplyImmediately(chunkListPath, update) {
+    switch(update.type){
+        case 'partial':
+            {
+                // This indicates that the update is can be applied to the current state of the application.
+                if (update.instruction.type !== 'ChunkListUpdate') {
+                    invariant(update.instruction, (instruction)=>`Unknown update type: ${instruction.type}`);
+                }
+                return applyChunkListUpdates([
+                    {
+                        chunkListPath,
+                        update: update.instruction
+                    }
+                ]);
+            }
+        case 'restart':
+            {
+                // This indicates that there is no way to apply the update to the
+                // current state of the application, and that the application must be
+                // restarted.
+                DEV_BACKEND.restart();
+                return [];
+            }
+        case 'notFound':
+            {
+                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
+                // or the page itself was deleted.
+                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
+                // If it is a runtime chunk list, we restart the application.
+                if (runtimeChunkLists.has(chunkListPath)) {
+                    DEV_BACKEND.restart();
+                } else {
+                    disposeChunkList(chunkListPath);
+                }
+                return [];
+            }
+        default:
+            throw new Error(`Unknown update type: ${update.type}`);
+    }
+}
+function applyChunkListMembershipDelta(chunkListPath, chunkPath, type, transitions) {
+    let transition = transitions.get(chunkPath);
+    if (!transition) {
+        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+        transition = {
+            before: ownerCount,
+            after: ownerCount
+        };
+        transitions.set(chunkPath, transition);
+    }
+    const changed = type === 'added' ? addChunkToChunkList(chunkListPath, chunkPath) : removeChunkFromChunkList(chunkListPath, chunkPath);
+    transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+    return changed;
+}
+function addChunkToChunkList(chunkListPath, chunkPath) {
+    let chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (!chunkPaths) {
+        chunkPaths = new Set();
+        chunkListChunksMap.set(chunkListPath, chunkPaths);
+    }
+    if (chunkPaths.has(chunkPath)) {
+        return false;
+    }
+    chunkPaths.add(chunkPath);
+    let chunkLists = chunkChunkListsMap.get(chunkPath);
+    if (!chunkLists) {
+        chunkLists = new Set();
+        chunkChunkListsMap.set(chunkPath, chunkLists);
+    }
+    chunkLists.add(chunkListPath);
+    return true;
+}
+function removeChunkFromChunkList(chunkListPath, chunkPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    const chunkLists = chunkChunkListsMap.get(chunkPath);
+    if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {
+        return false;
+    }
+    chunkPaths.delete(chunkPath);
+    chunkLists.delete(chunkListPath);
+    if (chunkLists.size === 0) {
+        chunkChunkListsMap.delete(chunkPath);
+    }
+    return true;
+}
+function setChunkListChunks(chunkListPath, nextChunkPaths) {
+    const previousChunkPaths = new Set(chunkListChunksMap.get(chunkListPath) ?? []);
+    if (!chunkListChunksMap.has(chunkListPath)) {
+        chunkListChunksMap.set(chunkListPath, new Set());
+    }
+    for (const chunkPath of previousChunkPaths){
+        if (!nextChunkPaths.has(chunkPath) && removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+            disposeChunk(chunkPath);
+        }
+    }
+    for (const chunkPath of nextChunkPaths){
+        if (!previousChunkPaths.has(chunkPath)) {
+            addChunkToChunkList(chunkListPath, chunkPath);
+        }
+    }
+}
+/**
+ * Removes a module from a chunk.
+ * Returns `true` if there are no remaining chunks including this module.
+ */ function removeModuleFromChunk(moduleId, chunkPath) {
+    const moduleChunks = moduleChunksMap.get(moduleId);
+    moduleChunks.delete(chunkPath);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    chunkModules.delete(moduleId);
+    const noRemainingModules = chunkModules.size === 0;
+    if (noRemainingModules) {
+        chunkModulesMap.delete(chunkPath);
+    }
+    const noRemainingChunks = moduleChunks.size === 0;
+    if (noRemainingChunks) {
+        moduleChunksMap.delete(moduleId);
+    }
+    return noRemainingChunks;
+}
+function terminateDynamicChunkListLoad(chunkListPath, state, error) {
+    if (state.terminated) return;
+    state.loading = false;
+    state.bootstrapping = false;
+    state.terminated = true;
+    state.rejectSubscribed?.(error);
+    BACKEND.rejectChunk?.(chunkListPath, error);
+    for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
+        releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
+    }
+}
+function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
+    // Reusing the same content-version URL is safe: a tombstone for an older
+    // generation represents identical content and must not discard this load.
+    discardedChunkRegistrations.delete(chunkUrl);
+    let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (!owners) {
+        owners = new Map();
+        dynamicMemberChunkUrlOwners.set(chunkUrl, owners);
+    }
+    owners.set(chunkListPath, generation);
+}
+function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath, chunkUrl) {
+    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (owners?.get(chunkListPath) !== generation) return;
+    owners.delete(chunkListPath);
+    if (owners.size > 0) return;
+    dynamicMemberChunkUrlOwners.delete(chunkUrl);
+    if (isJs(chunkUrl)) {
+        // Executed factories are already tracked by logical chunk ownership. The
+        // exact URL still needs a tombstone so a cancelled in-flight script cannot
+        // register stale factories after this generation has been discarded.
+        discardedChunkRegistrations.add(chunkUrl);
+        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+    } else {
+        const hasOtherChunkListOwner = [
+            ...chunkChunkListsMap.get(chunkPath) ?? []
+        ].some((owner)=>owner !== chunkListPath);
+        if (hasOtherChunkListOwner) return;
+        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+    }
+    if (!chunkChunkListsMap.has(chunkPath)) {
+        disposeChunk(chunkPath);
+    }
+}
+function completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
+    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (owners?.get(chunkListPath) !== generation) return;
+    owners.delete(chunkListPath);
+    if (owners.size === 0) {
+        dynamicMemberChunkUrlOwners.delete(chunkUrl);
+    }
+}
+function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken) {
+    const chunkPath = getChunkPath(chunkData);
+    const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken);
+    if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {
+        // A previous owner may have loaded an older content-version URL for the
+        // same stylesheet. Swap it only after the new CSS has loaded so dynamic
+        // lists never accumulate duplicate cascade entries.
+        return DEV_BACKEND.loadChunkReplacing(chunkUrl);
+    }
+    return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
+}
+/**
+ * Disposes of a chunk list and its corresponding exclusive chunks.
+ */ function disposeChunkList(chunkListPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (chunkPaths == null) {
+        return false;
+    }
+    for (const chunkPath of [
+        ...chunkPaths
+    ]){
+        if (removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+            disposeChunk(chunkPath);
+        }
+    }
+    chunkListChunksMap.delete(chunkListPath);
+    chunkListGenerations.delete(chunkListPath);
+    dynamicChunkListLoadStates.delete(chunkListPath);
+    runtimeChunkLists.delete(chunkListPath);
+    // We must also dispose of the chunk list's chunk itself to ensure it may
+    // be reloaded properly in the future.
+    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
+    DEV_BACKEND.unloadChunk?.(chunkListUrl);
+    return true;
+}
+/**
+ * Disposes of a chunk and its corresponding exclusive modules.
+ *
+ * @returns Whether the chunk was disposed of.
+ */ function disposeChunk(chunkPath) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    // This should happen whether the chunk has any modules in it or not.
+    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
+    DEV_BACKEND.unloadChunk?.(chunkUrl);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    if (chunkModules == null) {
+        return false;
+    }
+    chunkModulesMap.delete(chunkPath);
+    for (const moduleId of chunkModules){
+        const moduleChunks = moduleChunksMap.get(moduleId);
+        moduleChunks.delete(chunkPath);
+        const noRemainingChunks = moduleChunks.size === 0;
+        if (noRemainingChunks) {
+            moduleChunksMap.delete(moduleId);
+            disposeModule(moduleId, 'clear');
+            availableModules.delete(moduleId);
+        }
+    }
+    return true;
+}
+/**
+ * Adds a module to a chunk.
+ */ function addModuleToChunk(moduleId, chunkPath) {
+    let moduleChunks = moduleChunksMap.get(moduleId);
+    if (!moduleChunks) {
+        moduleChunks = new Set([
+            chunkPath
+        ]);
+        moduleChunksMap.set(moduleId, moduleChunks);
+    } else {
+        moduleChunks.add(chunkPath);
+    }
+    let chunkModules = chunkModulesMap.get(chunkPath);
+    if (!chunkModules) {
+        chunkModules = new Set([
+            moduleId
+        ]);
+        chunkModulesMap.set(chunkPath, chunkModules);
+    } else {
+        chunkModules.add(moduleId);
+    }
+}
+/**
+ * Marks a chunk list as a runtime chunk list. There can be more than one
+ * runtime chunk list. For instance, integration tests can have multiple chunk
+ * groups loaded at runtime, each with its own chunk list.
+ */ function markChunkListAsRuntime(chunkListPath) {
+    runtimeChunkLists.add(chunkListPath);
+}
+function registerChunk(registration) {
+    const chunk = getChunkFromRegistration(registration[0]);
+    let runtimeParams;
+    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
+    if (registration.length === 2) {
+        runtimeParams = registration[1];
+    } else {
+        let chunkPath = getPathFromScript(chunk);
+        const chunkUrl = getUrlFromScript(chunk);
+        runtimeParams = undefined;
+        if (discardedChunkRegistrations.delete(chunkUrl)) {
+            const result = BACKEND.registerChunk(chunk, runtimeParams);
+            DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+            return result;
+        }
+        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
+    }
+    return BACKEND.registerChunk(chunk, runtimeParams);
+}
+/**
+ * Subscribes to chunk list updates from the update server and applies them.
+ */ function registerChunkList(chunkList) {
+    const chunkListScript = getChunkFromRegistration(chunkList.script);
+    const chunkListPath = getPathFromScript(chunkListScript);
+    const generation = nextChunkListGeneration++;
+    chunkListGenerations.set(chunkListPath, generation);
+    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
+    setChunkListChunks(chunkListPath, chunkPaths);
+    if (chunkList.source === 'entry') {
+        // Entry chunks have already loaded their member chunks while bootstrapping.
+        // The "chunk" registration completes the backend's initial load.
+        BACKEND.registerChunk(chunkListPath);
+        markChunkListAsRuntime(chunkListPath);
+        CHUNK_UPDATE_LISTENERS.push([
+            chunkListPath,
+            handleApply.bind(null, chunkListPath),
+            {
+                batch: handleApplyBatch,
+                expectedVersion: chunkList.version
+            }
+        ]);
+        return;
+    }
+    if (typeof document === 'undefined') {
+        // Workers currently have no HMR transport/provider. Keep the dynamic
+        // chunk-list as a lightweight bootstrap, but load its members directly
+        // instead of waiting forever for an onSubscribed acknowledgement.
+        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
+            const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
+            BACKEND.rejectChunk?.(chunkListPath, error);
+        });
+        return;
+    }
+    // A dynamic chunk list is the bootstrap for its group. Establish the server
+    // baseline before fetching content, then hold updates while content loads.
+    // This closes the HTTP/WebSocket race where stale content could otherwise be
+    // fetched immediately before a newer subscription baseline was created.
+    const loadState = {
+        generation,
+        loading: true,
+        bootstrapping: true,
+        terminated: false,
+        pendingTasks: new Set(),
+        memberChunkUrls: new Map()
+    };
+    for (const chunkData of chunkList.chunks){
+        const chunkPath = getChunkPath(chunkData);
+        const chunkVersion = chunkList.chunkVersions[chunkPath];
+        if (chunkVersion === undefined) {
+            throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
+        }
+        const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion);
+        loadState.memberChunkUrls.set(chunkPath, chunkUrl);
+        addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
+    }
+    dynamicChunkListLoadStates.set(chunkListPath, loadState);
+    let resolveSubscribed;
+    let revalidateSubscription;
+    const subscribed = new Promise((resolve, reject)=>{
+        resolveSubscribed = resolve;
+        loadState.rejectSubscribed = reject;
+    });
+    CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath),
+        {
+            batch: handleApplyBatch,
+            onSubscribed: (revalidate)=>{
+                revalidateSubscription = revalidate;
+                resolveSubscribed();
+            },
+            expectedVersion: chunkList.version
+        }
+    ]);
+    void (async ()=>{
+        try {
+            await subscribed;
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            const memberResults = await Promise.allSettled(chunkList.chunks.map((chunkData)=>loadVersionedDynamicMemberChunk(chunkListPath, chunkData, chunkList.chunkVersions[getChunkPath(chunkData)])));
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                for (const chunkPath of chunkPaths){
+                    if (!chunkChunkListsMap.has(chunkPath)) {
+                        disposeChunk(chunkPath);
+                    }
+                }
+                return;
+            }
+            const failedMember = memberResults.find((result)=>result.status === 'rejected');
+            if (failedMember) {
+                throw failedMember.reason;
+            }
+            // The member URLs are served from the live output directory rather than
+            // a historical snapshot. Validate the manifest version again after all
+            // HTTP responses have completed, closing the subscription/HTTP race.
+            await revalidateSubscription();
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            for (const chunkUrl of loadState.memberChunkUrls.values()){
+                completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
+            }
+            loadState.loading = false;
+            flushPendingHmrTasks();
+            while(loadState.pendingTasks.size > 0){
+                await Promise.all([
+                    ...loadState.pendingTasks
+                ]);
+            }
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                for (const chunkPath of chunkPaths){
+                    if (!chunkChunkListsMap.has(chunkPath)) {
+                        disposeChunk(chunkPath);
+                    }
+                }
+                return;
+            }
+            // Resolving the bootstrap schedules the import continuation as a
+            // microtask. Every queued update and resource load has completed first,
+            // so user code cannot observe factories from an older manifest.
+            loadState.bootstrapping = false;
+            BACKEND.registerChunk(chunkListPath);
+        } catch (cause) {
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            const error = cause instanceof Error ? cause : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`);
+            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+            DEV_BACKEND.restart();
+        }
+    })();
+}
+/**
+ * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
+ *
+ * It will be appended to the base runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
+/// <reference path="../../../shared/runtime/runtime-types.d.ts" />
+function getAssetSuffixFromScriptSrc() {
+    // TURBOPACK_ASSET_SUFFIX is set in web workers
+    if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX;
+    const src = document?.currentScript?.getAttribute?.('src') ?? '';
+    const qi = src.indexOf('?');
+    return qi >= 0 ? src.slice(qi) : '';
+}
+let BACKEND;
+/**
+ * Maps chunk paths to the corresponding resolver.
+ */ const chunkResolvers = new Map();
+(()=>{
+    BACKEND = {
+        async registerChunk (chunk, params) {
+            let chunkPath = getPathFromScript(chunk);
+            let chunkUrl = getUrlFromScript(chunk);
+            const resolver = getOrCreateResolver(chunkUrl);
+            resolver.resolve();
+            if (params == null) {
+                return;
+            }
+            for (const otherChunkData of params.otherChunks){
+                const otherChunkPath = getChunkPath(otherChunkData);
+                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
+                // Chunk might have started loading, so we want to avoid triggering another load.
+                getOrCreateResolver(otherChunkUrl);
+            }
+            // This waits for chunks to be loaded, but also marks included items as available.
+            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
+            if (params.runtimeModuleIds.length > 0) {
+                for (const moduleId of params.runtimeModuleIds){
+                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
+                }
+            }
+        },
+        /**
+     * Loads the given chunk, and returns a promise that resolves once the chunk
+     * has been loaded.
+     */ loadChunkCached (sourceType, chunkUrl) {
+            return doLoadChunk(sourceType, chunkUrl);
+        },
+        rejectChunk (chunkPath, error) {
+            const chunkUrl = getUrlFromScript(chunkPath);
+            const resolver = chunkResolvers.get(chunkUrl);
+            if (resolver) {
+                rejectChunkResolver(chunkUrl, resolver, error);
+            }
+        }
+    };
+    function getOrCreateResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                retryAttempts: 0,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        return resolver;
+    }
+    /**
+   * Rejects a chunk resolver and drops it from the cache.
+   * We don't want to cache failed chunk loads: a later
+   * request for the same chunk should try again.
+   */ function rejectChunkResolver(chunkUrl, resolver, error) {
+        if (chunkResolvers.get(chunkUrl) === resolver) {
+            chunkResolvers.delete(chunkUrl);
+        }
+        resolver.reject(error);
+    }
+    function getChunkLoadRetryDelayMs() {
+        const jitter = Math.floor(Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1));
+        return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter;
+    }
+    function isRetryableChunkLoadError(error) {
+        return error == null || error instanceof DOMException && error.name === 'NetworkError';
+    }
+    /**
+   * Handles a failed chunk load: retries the load once after a short delay.
+   */ function onChunkLoadError(sourceType, chunkUrl, resolver, error, reload) {
+        if (!isRetryableChunkLoadError(error) || resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS || chunkResolvers.get(chunkUrl) !== resolver) {
+            rejectChunkResolver(chunkUrl, resolver, error);
+            return;
+        }
+        resolver.retryAttempts++;
+        setTimeout(()=>{
+            // if this chunk is being fetched multiple times, and one of those
+            // attempts succeeds. or, if this chunk has another resolver
+            // mapped to it - it's safe to skip retrying.
+            if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {
+                return;
+            }
+            if (reload) {
+                reload();
+            } else {
+                resolver.loadingStarted = false;
+                doLoadChunk(sourceType, chunkUrl);
+            }
+        }, getChunkLoadRetryDelayMs());
+    }
+    /**
+   * Loads the given chunk, and returns a promise that resolves once the chunk
+   * has been loaded.
+   */ function doLoadChunk(sourceType, chunkUrl) {
+        const resolver = getOrCreateResolver(chunkUrl);
+        if (resolver.loadingStarted) {
+            return resolver.promise;
+        }
+        if (sourceType === SourceType.Runtime) {
+            // CSS chunks do not register themselves, and as such must be marked as
+            // loaded instantly.
+            resolver.loadingStarted = true;
+            if (isCss(chunkUrl)) {
+                if (typeof importScripts !== 'function') {
+                    const decodedChunkUrl = decodeURI(chunkUrl);
+                    const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                    if (previousLinks.length === 0) {
+                        const link = document.createElement('link');
+                        link.rel = 'stylesheet';
+                        link.crossOrigin = CROSS_ORIGIN;
+                        link.href = chunkUrl;
+                        link.onerror = ()=>{
+                            resolver.reject();
+                        };
+                        link.onload = ()=>{
+                            resolver.resolve();
+                        };
+                        document.head.appendChild(link);
+                        return resolver.promise;
+                    }
+                }
+                resolver.resolve();
+                return resolver.promise;
+            }
+            // Runtime JS chunks are expected to be present in the DOM already.
+            // Load it first
+            if (typeof importScripts !== 'function') {
+                const decodedChunkUrl = decodeURI(chunkUrl);
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            resolver.reject();
+                        });
+                    }
+                    return resolver.promise;
+                }
+            }
+        // If it wasn't present in the DOM, fallback to loading logic.
+        }
+        if (typeof importScripts === 'function') {
+            // We're in a web worker
+            if (isCss(chunkUrl)) {
+            // ignore
+            } else if (isJs(chunkUrl)) {
+                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
+                try {
+                    importScripts(chunkUrl);
+                } catch (error) {
+                    onChunkLoadError(sourceType, chunkUrl, resolver, error);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
+            }
+        } else {
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length > 0) {
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolver.resolve();
+                } else {
+                    const createLink = ()=>{
+                        const link = document.createElement('link');
+                        link.rel = 'stylesheet';
+                        link.crossOrigin = CROSS_ORIGIN;
+                        link.href = chunkUrl;
+                        link.onerror = ()=>{
+                            // Re-insert a fresh tag at the same position on retry to preserve
+                            // cascade order.
+                            const anchor = document.createComment('');
+                            link.replaceWith(anchor);
+                            onChunkLoadError(sourceType, chunkUrl, resolver, undefined, ()=>anchor.replaceWith(createLink()));
+                        };
+                        link.onload = ()=>{
+                            // CSS chunks do not register themselves, and as such must be marked as
+                            // loaded instantly.
+                            resolver.resolve();
+                        };
+                        return link;
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(createLink());
+                }
+            } else if (isJs(chunkUrl)) {
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            // Drop the failed tag so a retry can re-add it cleanly.
+                            script.remove();
+                            onChunkLoadError(sourceType, chunkUrl, resolver);
+                        }, {
+                            once: true
+                        });
+                    }
+                } else {
+                    const script = document.createElement('script');
+                    script.crossOrigin = CROSS_ORIGIN;
+                    script.src = chunkUrl;
+                    // We'll only mark the chunk as loaded once the script has been executed,
+                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
+                    // this branch.
+                    script.onerror = ()=>{
+                        // Drop the failed tag so a retry can re-add it cleanly.
+                        script.remove();
+                        onChunkLoadError(sourceType, chunkUrl, resolver);
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(script);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        }
+        resolver.loadingStarted = true;
+        return resolver.promise;
+    }
+})();
+/**
+ * This file contains the runtime code specific to the Turbopack development
+ * ECMAScript DOM runtime.
+ *
+ * It will be appended to the base development runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
+/// <reference path="../base/dev-base.ts" />
+/// <reference path="./runtime-backend-dom.ts" />
+/// <reference path="../../../shared/require-type.d.ts" />
+let DEV_BACKEND;
+(()=>{
+    const pendingChunkReloads = new Map();
+    const replacingCssLoads = new Map();
+    DEV_BACKEND = {
+        loadChunkReplacing (chunkUrl) {
+            if (!isCss(chunkUrl)) {
+                return Promise.reject(new Error(`Only CSS chunks can be replaced while loading: ${chunkUrl}`));
+            }
+            const existingLoad = replacingCssLoads.get(chunkUrl);
+            if (existingLoad) return existingLoad;
+            const baseChunkUrl = chunkUrl.split('?')[0];
+            const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
+            const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?';
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
+            const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
+            const load = exactLinks.length > 0 || baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>BACKEND.registerChunk({
+                    src: chunkUrl
+                }));
+            replacingCssLoads.set(chunkUrl, load);
+            void load.then(()=>{
+                if (replacingCssLoads.get(chunkUrl) === load) {
+                    replacingCssLoads.delete(chunkUrl);
+                }
+            }, ()=>{
+                if (replacingCssLoads.get(chunkUrl) === load) {
+                    replacingCssLoads.delete(chunkUrl);
+                }
+            });
+            return load;
+        },
+        unloadChunk (chunkUrl) {
+            unloadChunk(chunkUrl, false);
+        },
+        unloadChunkExact (chunkUrl) {
+            unloadChunk(chunkUrl, true);
+        },
+        reloadChunk (chunkUrl) {
+            return new Promise((resolve, reject)=>{
+                if (!isCss(chunkUrl)) {
+                    reject(new Error('The DOM backend can only reload CSS chunks'));
+                    return;
+                }
+                // Strip query string so we match links regardless of cache-busting
+                // params (e.g. ?ts=) that may differ between HMR updates.
+                const baseChunkUrl = chunkUrl.split('?')[0];
+                const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
+                if (previousLinks.length === 0) {
+                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
+                    return;
+                }
+                const currentReloads = pendingChunkReloads.get(baseChunkUrl);
+                if (currentReloads) {
+                    const suffix = chunkUrl.includes('?') ? '&' : '?';
+                    for (const reload of [
+                        ...currentReloads
+                    ]){
+                        const href = reload.link.getAttribute('href');
+                        if (href !== chunkUrl && !href?.startsWith(`${chunkUrl}${suffix}`)) {
+                            reload.reject(new Error(`CSS chunk ${chunkUrl} superseded an in-flight reload.`));
+                        }
+                    }
+                }
+                const link = document.createElement('link');
+                link.rel = 'stylesheet';
+                link.crossOrigin = CROSS_ORIGIN;
+                let pendingReloads = pendingChunkReloads.get(baseChunkUrl);
+                if (!pendingReloads) {
+                    pendingReloads = new Set();
+                    pendingChunkReloads.set(baseChunkUrl, pendingReloads);
+                }
+                const cleanup = ()=>{
+                    pendingReloads.delete(pendingReload);
+                    if (pendingReloads.size === 0) {
+                        pendingChunkReloads.delete(baseChunkUrl);
+                    }
+                };
+                const pendingReload = {
+                    link,
+                    reject: (error)=>{
+                        cleanup();
+                        link.onload = null;
+                        link.onerror = null;
+                        link.remove();
+                        reject(error);
+                    }
+                };
+                pendingReloads.add(pendingReload);
+                if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
+                    // Firefox won't reload CSS files that were previously loaded on the
+                    // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
+                    //
+                    // Safari serves cached CSS when a <link rel=preload> exists for the
+                    // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726
+                    //
+                    // Replace or add a fresh `ts` cache-busting param without
+                    // discarding other query parameters that may already be present.
+                    const url = new URL(chunkUrl, location.origin);
+                    // Reduced timer precision in some browers could lead to an update getting dropped
+                    // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).
+                    // So trust that the server is only updating us when it is important and use a
+                    // random number to bust the cache.
+                    url.searchParams.set('ts', `${Date.now()}.${Math.random()}`);
+                    link.href = url.pathname + url.search;
+                } else {
+                    link.href = chunkUrl;
+                }
+                link.onerror = ()=>{
+                    pendingReload.reject(new Error(`Failed to reload CSS chunk ${chunkUrl}`));
+                };
+                link.onload = ()=>{
+                    cleanup();
+                    // First load the new CSS, then remove the old ones. This prevents visible
+                    // flickering that would happen in-between removing the previous CSS and
+                    // loading the new one.
+                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolve();
+                };
+                // Make sure to insert the new CSS right after the previous one, so that
+                // its precedence is higher.
+                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
+            });
+        },
+        restart: ()=>self.location.reload()
+    };
+    function unloadChunk(chunkUrl, exact) {
+        deleteResolvers(chunkUrl, exact);
+        const baseChunkUrl = chunkUrl.split('?')[0];
+        const reloads = pendingChunkReloads.get(baseChunkUrl);
+        if (reloads) {
+            for (const reload of [
+                ...reloads
+            ]){
+                const href = reload.link.getAttribute('href');
+                const suffix = chunkUrl.includes('?') ? '&' : '?';
+                if (!exact || href === chunkUrl || href?.startsWith(`${chunkUrl}${suffix}`)) {
+                    reload.reject(new Error(`Chunk ${chunkUrl} was unloaded while reloading.`));
+                }
+            }
+        }
+        // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+        const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl);
+        const path = exact ? chunkUrl : baseChunkUrl;
+        const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
+        if (isCss(chunkUrl)) {
+            const links = document.querySelectorAll(exact ? `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]` : `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
+            for (const link of Array.from(links)){
+                link.remove();
+            }
+        } else if (isJs(chunkUrl)) {
+            // Unloading a JS chunk would have no effect once it has executed, but
+            // removing the exact stale registration keeps the DOM and resolver cache
+            // bounded without touching a newer generation of the same chunk path.
+            const scripts = document.querySelectorAll(exact ? `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]` : `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
+            for (const script of Array.from(scripts)){
+                script.remove();
+            }
+        } else {
+            throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+        }
+    }
+    function deleteResolvers(chunkUrl, exact) {
+        const baseChunkUrl = chunkUrl.split('?')[0];
+        for (const [resolverUrl, resolver] of [
+            ...chunkResolvers
+        ]){
+            if (exact ? resolverUrl !== chunkUrl : resolverUrl.split('?')[0] !== baseChunkUrl) {
+                continue;
+            }
+            if (resolver.resolved) {
+                chunkResolvers.delete(resolverUrl);
+            } else {
+                rejectChunkResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
+            }
+        }
+    }
+})();
+function _eval({ code, url, map }) {
+    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX)}`;
+    if (map) {
+        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
+        // See https://stackoverflow.com/a/26603875
+        unescape(encodeURIComponent(map)))}`;
+    }
+    // eslint-disable-next-line no-eval
+    return eval(code);
+}
+var chunksToRegister = globalThis["TURBOPACK"];
+globalThis["TURBOPACK"] = { push: registerChunk };
+chunksToRegister.forEach(registerChunk);
+var chunkListsToRegister = globalThis["TURBOPACK_CHUNK_LISTS"] || [];
+globalThis["TURBOPACK_CHUNK_LISTS"] = { push: registerChunkList };
+chunkListsToRegister.forEach(registerChunkList);
+})();
\ No newline at end of file
diff --git a/crates/utoo-wasm/src/pack.rs b/crates/utoo-wasm/src/pack.rs
index 083701761..658726d5c 100644
--- a/crates/utoo-wasm/src/pack.rs
+++ b/crates/utoo-wasm/src/pack.rs
@@ -2,33 +2,42 @@ use anyhow::{Context, Result};
 use pack_api::{
     endpoint::Endpoint,
     entrypoint::{
-        get_all_written_entrypoints_with_issues_operation, get_entrypoints_with_issues_operation,
-        EntrypointsWithIssues,
+        EntrypointsWithIssues, get_all_written_entrypoints_with_issues_operation,
+        get_entrypoints_with_issues_operation,
     },
-    hmr::{hmr_update_with_issues_operation, HmrUpdateWithIssues},
+    hmr::{HmrUpdateWithIssues, hmr_update_with_issues_operation},
     project::{ProjectContainer, ProjectOptions, WatchOptions},
     turbo_tasks::UtooTurboTasks,
     utils::StyledStringSerialize,
 };
 use parking_lot::RwLock;
 use serde::{Deserialize, Deserializer, Serialize};
-use serde_json::{json, Value};
-use std::{ops::Deref, path::PathBuf, str::FromStr, sync::Arc, time::Duration};
+use serde_json::{Value, json};
+use std::{
+    ops::Deref,
+    path::PathBuf,
+    str::FromStr,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
 use tokio::{sync::mpsc::unbounded_channel, time::Instant};
-use turbo_rcstr::{rcstr, RcStr};
+use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::TaskId;
 use turbo_tasks::{
-    read_strongly_consistent_and_apply_effects, Completion, OperationVc, PrettyPrintError,
-    ReadConsistency, ResolvedVc, TransientInstance, TurboTasks, Vc,
+    Completion, OperationVc, PrettyPrintError, ReadConsistency, ResolvedVc, TransientInstance,
+    TurboTasks, Vc, read_strongly_consistent_and_apply_effects,
 };
-use turbo_tasks_backend::{noop_backing_storage, BackendOptions, TurboTasksBackend};
+use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};
 use turbo_tasks_fs::FileContent;
 use turbopack_core::{
     issue::{PlainIssue, PlainIssueSource, PlainSource},
     source_pos::SourcePos as SourcePosInner,
-    version::{PartialUpdate, TotalUpdate, Update, VersionState},
+    version::{PartialUpdate, TotalUpdate, Update, Version, VersionState},
 };
-use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+use wasm_bindgen::{JsValue, prelude::wasm_bindgen};
 
 use crate::fs::Fs;
 use crate::tokio_runtime::runtime;
@@ -54,7 +63,7 @@ pub struct RootTask {
 impl Drop for RootTask {
     fn drop(&mut self) {
         tracing::debug!("RootTask dropped, subscription will be stopped");
-        // TODO: dispose the root task
+        self.turbo_tasks.dispose_root_task(self.task_id);
     }
 }
 
@@ -570,10 +579,13 @@ pub fn project_write_all_to_disk(callback: js_sys::Function) {
 pub async fn project_hmr_events(
     identifier: String,
     callback: js_sys::Function,
+    expected_version: Option<String>,
 ) -> Result<RootTask, wasm_bindgen::JsError> {
     use wasm_bindgen::JsError;
 
     let identifier: RcStr = identifier.into();
+    let expected_version = expected_version.map(RcStr::from);
+    let check_expected_version = Arc::new(AtomicBool::new(expected_version.is_some()));
 
     let pack_project = GLOBAL_PACK_PROJECT
         .read()
@@ -594,11 +606,15 @@ pub async fn project_hmr_events(
         .spawn({
             let identifier = identifier.clone();
             let session = session.clone();
+            let expected_version = expected_version.clone();
+            let check_expected_version = check_expected_version.clone();
             async move {
                 turbo_tasks_clone.spawn_root_task(move || {
                     let identifier = identifier.clone();
                     let session = session.clone();
                     let tx = tx.clone();
+                    let expected_version = expected_version.clone();
+                    let check_expected_version = check_expected_version.clone();
                     async move {
                         tracing::debug!("hmrSubscribe root task executing for {}", identifier);
 
@@ -607,6 +623,17 @@ pub async fn project_hmr_events(
                             .hmr_version_state(identifier.clone(), session)
                             .to_resolved()
                             .await?;
+                        let should_check_expected_version =
+                            check_expected_version.load(Ordering::Acquire);
+                        let version_mismatch = if should_check_expected_version {
+                            if let Some(expected_version) = expected_version {
+                                state.get().id().owned().await? != expected_version
+                            } else {
+                                false
+                            }
+                        } else {
+                            false
+                        };
 
                         let update_op =
                             hmr_update_with_issues_operation(project, identifier.clone(), state);
@@ -640,6 +667,11 @@ pub async fn project_hmr_events(
                                 "resource": { "path": identifier.to_string() },
                                 "issues": []
                             }),
+                            _ if version_mismatch => serde_json::json!({
+                                "type": "restart",
+                                "resource": { "path": identifier.to_string() },
+                                "issues": issues_json
+                            }),
                             Update::None => serde_json::json!({
                                 "type": "issues",
                                 "resource": { "path": identifier.to_string() },
@@ -661,8 +693,9 @@ pub async fn project_hmr_events(
                         };
 
                         tracing::debug!("hmrSubscribe sending update for {}", identifier);
-                        if let Ok(json_str) = serde_json::to_string(&result_json) {
-                            let _ = tx.send(json_str);
+                        let json_str = serde_json::to_string(&result_json)?;
+                        if tx.send(json_str).is_ok() && should_check_expected_version {
+                            check_expected_version.store(false, Ordering::Release);
                         }
 
                         Ok(Completion::new())
diff --git a/crates/utoo-wasm/src/project.rs b/crates/utoo-wasm/src/project.rs
index 383076d74..ab4bf50fb 100644
--- a/crates/utoo-wasm/src/project.rs
+++ b/crates/utoo-wasm/src/project.rs
@@ -9,7 +9,7 @@ use parking_lot::RwLock;
 use wasm_bindgen::prelude::*;
 
 use crate::errors::to_js_error;
-use crate::pm::{self, with_project, OPFS_PROJECT};
+use crate::pm::{self, OPFS_PROJECT, with_project};
 use crate::tokio_runtime::init_tokio_runtime;
 
 #[cfg(feature = "utoopack")]
@@ -126,8 +126,9 @@ impl Project {
     pub async fn hmr_events(
         identifier: String,
         callback: js_sys::Function,
+        expected_version: Option<String>,
     ) -> Result<RootTask, JsError> {
-        pack::project_hmr_events(identifier, callback).await
+        pack::project_hmr_events(identifier, callback, expected_version).await
     }
 
     /// Subscribe to compilation lifecycle events.
diff --git a/e2e/pack-hmr/.gitignore b/e2e/pack-hmr/.gitignore
new file mode 100644
index 000000000..1521c8b76
--- /dev/null
+++ b/e2e/pack-hmr/.gitignore
@@ -0,0 +1 @@
+dist
diff --git a/e2e/pack-hmr/index.html b/e2e/pack-hmr/index.html
new file mode 100644
index 000000000..cb66f9d64
--- /dev/null
+++ b/e2e/pack-hmr/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>Pack HMR safety fixture</title>
+  </head>
+  <body>
+    <button id="load">Load dynamic groups</button>
+    <div id="a">pending</div>
+    <div id="b">pending</div>
+    <div id="error"></div>
+  </body>
+</html>
diff --git a/e2e/pack-hmr/pack-hmr.spec.ts b/e2e/pack-hmr/pack-hmr.spec.ts
new file mode 100644
index 000000000..53f40ee5f
--- /dev/null
+++ b/e2e/pack-hmr/pack-hmr.spec.ts
@@ -0,0 +1,628 @@
+import { expect, test, type Page } from "@playwright/test";
+import fs from "node:fs";
+import path from "node:path";
+
+const sharedPath = path.join(__dirname, "src/shared.js");
+const sharedCssPath = path.join(__dirname, "src/shared.css");
+const indexPath = path.join(__dirname, "src/index.js");
+const baseline = fs.readFileSync(sharedPath, "utf8");
+const cssBaseline = fs.readFileSync(sharedCssPath, "utf8");
+const indexBaseline = fs.readFileSync(indexPath, "utf8");
+const pageFrames = new WeakMap<Page, string[]>();
+const pageReadySockets = new WeakMap<Page, Set<object>>();
+let restoreGeneration = 0;
+
+test.beforeEach(async ({ page }) => {
+  const frames: string[] = [];
+  const readySockets = new Set<object>();
+  pageFrames.set(page, frames);
+  pageReadySockets.set(page, readySockets);
+  page.on("websocket", (socket) => {
+    socket.on("framereceived", ({ payload }) => {
+      const frame = String(payload);
+      frames.push(frame);
+      if (frameAction(frame) === "turbopack-connected") {
+        readySockets.add(socket);
+      }
+    });
+    socket.on("close", () => readySockets.delete(socket));
+  });
+});
+
+function writeShared(version: string) {
+  fs.writeFileSync(sharedPath, baseline.replace("shared-v1", version));
+}
+
+function writeSharedCss(version: string) {
+  fs.writeFileSync(
+    sharedCssPath,
+    cssBaseline.replace("shared-css-v1", version),
+  );
+}
+
+async function readRuntimeState(page: Page) {
+  return page.evaluate(() => ({
+    evaluations: (globalThis as any).__packHmrSharedEvaluations,
+    entryEvaluations: (globalThis as any).__packHmrEntryEvaluations,
+    hmrApiAvailable: (globalThis as any).__packHmrApiAvailable,
+    pageToken: (globalThis as any).__packHmrPageToken,
+    timeOrigin: performance.timeOrigin,
+  }));
+}
+
+function frameAction(frame: string) {
+  try {
+    return JSON.parse(frame).action as string | undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function mutateAndWaitForBuild(page: Page, mutate: () => void) {
+  const frames = pageFrames.get(page) ?? [];
+  await expect
+    .poll(() => pageReadySockets.get(page)?.size ?? 0)
+    .toBeGreaterThan(0);
+  const frameStart = frames.length;
+  mutate();
+  await expect
+    .poll(() => {
+      let building = false;
+      for (const frame of frames.slice(frameStart)) {
+        const action = frameAction(frame);
+        if (action === "building") building = true;
+        if (building && action === "built") return true;
+      }
+      return false;
+    })
+    .toBe(true);
+}
+
+test.afterEach(async () => {
+  const marker = `// e2e-restore-${++restoreGeneration}`;
+  fs.writeFileSync(sharedPath, baseline);
+  fs.writeFileSync(sharedCssPath, cssBaseline);
+  fs.writeFileSync(indexPath, `${indexBaseline}\n${marker}\n`);
+
+  // A race test may deliberately reload or disconnect the page, so raw socket
+  // frames are not a reliable cleanup signal. The emitted entry itself proves
+  // the watcher rebuilt the complete baseline graph.
+  await expect
+    .poll(() => {
+      const outputDir = path.join(__dirname, "dist");
+      if (!fs.existsSync(outputDir)) return false;
+      return fs
+        .readdirSync(outputDir)
+        .filter((file) => file.endsWith(".js"))
+        .some((file) =>
+          fs.readFileSync(path.join(outputDir, file), "utf8").includes(marker),
+        );
+    })
+    .toBe(true);
+});
+
+test.afterAll(() => {
+  fs.writeFileSync(sharedPath, baseline);
+  fs.writeFileSync(sharedCssPath, cssBaseline);
+  fs.writeFileSync(indexPath, indexBaseline);
+});
+
+function getTurbopackUpdates(frames: string[]) {
+  return getTurbopackEnvelopes(frames).flat();
+}
+
+function getTurbopackEnvelopes(frames: string[]) {
+  return frames.flatMap((frame) => {
+    try {
+      const message = JSON.parse(frame);
+      if (message.action !== "turbopack-message") return [];
+      return [Array.isArray(message.data) ? message.data : [message.data]];
+    } catch {
+      return [];
+    }
+  });
+}
+
+test("closes the first dynamic-load subscription race", async ({ page }) => {
+  await page.addInitScript(() => {
+    const originalSend = WebSocket.prototype.send;
+    const delayedFrames: Array<{ socket: WebSocket; data: any }> = [];
+    (globalThis as any).__delayedDynamicSubscriptions = [];
+    (globalThis as any).__hmrSubscriptionPaths = [];
+    (globalThis as any).__hmrSubscriptionVersions = [];
+    (globalThis as any).__flushDynamicSubscriptions = () => {
+      sessionStorage.setItem("pack-hmr-disable-subscription-delay", "1");
+      for (const { socket, data } of delayedFrames.splice(0)) {
+        originalSend.call(socket, data);
+      }
+    };
+    WebSocket.prototype.send = function (data) {
+      let message;
+      try {
+        message = JSON.parse(String(data));
+      } catch {}
+      if (message?.type === "turbopack-subscribe") {
+        (globalThis as any).__hmrSubscriptionPaths.push(message.path);
+        (globalThis as any).__hmrSubscriptionVersions.push(message.version);
+      }
+      if (
+        sessionStorage.getItem("pack-hmr-disable-subscription-delay") !== "1" &&
+        message?.type === "turbopack-subscribe" &&
+        /(?:^|\/)src_[ab]_[^/]+\.js$/.test(message.path)
+      ) {
+        const paths = (globalThis as any).__delayedDynamicSubscriptions;
+        if (!paths.includes(message.path)) paths.push(message.path);
+        delayedFrames.push({ socket: this, data });
+        return;
+      }
+      originalSend.call(this, data);
+    };
+  });
+
+  await page.goto("/");
+  const initial = await readRuntimeState(page);
+  await page.locator("#load").click();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () => (globalThis as any).__delayedDynamicSubscriptions.length,
+      ),
+    )
+    .toBe(2);
+
+  await expect
+    .poll(() =>
+      page.evaluate(() =>
+        (globalThis as any).__hmrSubscriptionVersions.every(
+          (version: unknown) => typeof version === "string",
+        ),
+      ),
+    )
+    .toBe(true);
+  await mutateAndWaitForBuild(page, () => writeShared("shared-race-v2"));
+  await page.evaluate(() => (globalThis as any).__flushDynamicSubscriptions());
+
+  // The server baseline is newer than the manifest that initiated the load.
+  // Reject that manifest and reload instead of evaluating stale factories.
+  await expect
+    .poll(() => readRuntimeState(page).then((state) => state.pageToken))
+    .not.toBe(initial.pageToken);
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-race-v2");
+  await expect(page.locator("#b")).toHaveText("b:shared-race-v2");
+  await expect(page.locator("#error")).toBeEmpty();
+  const updated = await readRuntimeState(page);
+  const subscriptionPaths = await page.evaluate(
+    () => (globalThis as any).__hmrSubscriptionPaths,
+  );
+  const subscriptionCounts = new Map<string, number>();
+  for (const path of subscriptionPaths) {
+    subscriptionCounts.set(path, (subscriptionCounts.get(path) ?? 0) + 1);
+  }
+  expect([...subscriptionCounts.values()].sort()).toEqual([1, 2, 2]);
+  expect(updated.evaluations).toBe(1);
+  expect(updated.hmrApiAvailable).toBe(true);
+  expect(updated.pageToken).not.toBe(initial.pageToken);
+  expect(updated.timeOrigin).not.toBe(initial.timeOrigin);
+});
+
+test("revalidates after HTTP members load before exposing a dynamic import", async ({
+  page,
+}) => {
+  let releaseMembers!: () => void;
+  const membersReleased = new Promise<void>((resolve) => {
+    releaseMembers = resolve;
+  });
+  let capturedMembers = 0;
+
+  await page.route(/\.js\?hmr=/, async (route) => {
+    // Hold the V1 URL until after the build, then fetch it from the live output
+    // directory. The response is V2 even though the URL contains V1's token.
+    // Post-load subscription validation must detect that race.
+    capturedMembers += 1;
+    await membersReleased;
+    const response = await route.fetch();
+    const body = await response.body();
+    await route.fulfill({ response, body });
+  });
+
+  try {
+    await page.goto("/");
+    const initial = await readRuntimeState(page);
+    await page.locator("#load").click();
+    await expect.poll(() => capturedMembers).toBeGreaterThanOrEqual(2);
+
+    await mutateAndWaitForBuild(page, () => writeShared("shared-queued-v2"));
+    releaseMembers();
+
+    await expect
+      .poll(() => readRuntimeState(page).then((state) => state.pageToken))
+      .not.toBe(initial.pageToken);
+    await page.locator("#load").click();
+    await expect(page.locator("#a")).toHaveText("a:shared-queued-v2");
+    await expect(page.locator("#b")).toHaveText("b:shared-queued-v2");
+    await expect(page.locator("#error")).toBeEmpty();
+    const updated = await readRuntimeState(page);
+    expect(updated.evaluations).toBe(1);
+    expect(updated.pageToken).not.toBe(initial.pageToken);
+    expect(updated.timeOrigin).not.toBe(initial.timeOrigin);
+  } finally {
+    releaseMembers();
+  }
+});
+
+test("resubscribes dynamic imports after the HMR socket reconnects", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    const NativeWebSocket = WebSocket;
+    const sockets: WebSocket[] = [];
+    (globalThis as any).__packHmrSockets = sockets;
+    (globalThis as any).WebSocket = new Proxy(NativeWebSocket, {
+      construct(Target, args) {
+        const socket = new Target(...(args as [string, string | string[]]));
+        sockets.push(socket);
+        return socket;
+      },
+    });
+  });
+
+  await page.goto("/");
+  await expect
+    .poll(() => pageReadySockets.get(page)?.size ?? 0)
+    .toBeGreaterThan(0);
+  await page.evaluate(() => {
+    const sockets = (globalThis as any).__packHmrSockets as WebSocket[];
+    sockets.at(-1)?.close();
+  });
+  await expect.poll(() => pageReadySockets.get(page)?.size ?? 0).toBe(0);
+
+  // These subscriptions are created while sendMessage has no open socket.
+  // Reconnect must cause the HMR client to replay them.
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  await expect(page.locator("#error")).toBeEmpty();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () => ((globalThis as any).__packHmrSockets as WebSocket[]).length,
+      ),
+    )
+    .toBeGreaterThanOrEqual(2);
+});
+
+test("applies a shared update once across two dynamic lists", async ({
+  page,
+}) => {
+  const frames = pageFrames.get(page)!;
+
+  await page.goto("/");
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  const initial = await readRuntimeState(page);
+  expect(initial.evaluations).toBe(1);
+  expect(initial.hmrApiAvailable).toBe(true);
+  const versionedStylesheets = await page
+    .locator('link[rel="stylesheet"][href*="hmr="]')
+    .evaluateAll((links) => links.map((link) => new URL(link.href).pathname));
+  expect(versionedStylesheets.length).toBeGreaterThan(0);
+  expect(new Set(versionedStylesheets).size).toBe(versionedStylesheets.length);
+  const frameStart = frames.length;
+
+  await mutateAndWaitForBuild(page, () => writeShared("shared-dedupe-v2"));
+
+  await expect(page.locator("#a")).toHaveText("a:shared-dedupe-v2");
+  await expect(page.locator("#b")).toHaveText("b:shared-dedupe-v2");
+  const updated = await readRuntimeState(page);
+  expect(updated.evaluations).toBe(2);
+  expect(updated.pageToken).toBe(initial.pageToken);
+  expect(updated.timeOrigin).toBe(initial.timeOrigin);
+
+  const resourcePaths = new Set<string>();
+  for (const update of getTurbopackUpdates(frames.slice(frameStart))) {
+    if (update.type === "partial") resourcePaths.add(update.resource.path);
+  }
+  expect(resourcePaths.size).toBeGreaterThanOrEqual(2);
+  expect(
+    getTurbopackEnvelopes(frames.slice(frameStart)).some((updates) => {
+      const paths = new Set(
+        updates
+          .filter((update) => update.type === "partial")
+          .map((update) => update.resource.path),
+      );
+      return paths.size >= 2;
+    }),
+  ).toBe(true);
+});
+
+test("swaps an older shared stylesheet when a new dynamic list joins", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  const initial = await readRuntimeState(page);
+
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(
+      indexPath,
+      indexBaseline.replace(
+        '[import("./a.js"), import("./b.js")]',
+        '[Promise.resolve(), import("./b.js")]',
+      ),
+    ),
+  );
+  await mutateAndWaitForBuild(page, () => writeSharedCss("shared-css-swap-v2"));
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(indexPath, indexBaseline),
+  );
+  await expect
+    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
+    .toBeGreaterThanOrEqual(3);
+
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#error")).toBeEmpty();
+  await expect
+    .poll(() =>
+      page
+        .locator('link[rel="stylesheet"]')
+        .evaluateAll(
+          (links) =>
+            links.filter((link) =>
+              new URL((link as HTMLLinkElement).href).pathname.endsWith(".css"),
+            ).length,
+        ),
+    )
+    .toBe(1);
+
+  const updated = await readRuntimeState(page);
+  expect(updated.pageToken).toBe(initial.pageToken);
+  expect(updated.timeOrigin).toBe(initial.timeOrigin);
+});
+
+test("cancels an obsolete CSS reload without stalling later HMR", async ({
+  page,
+}) => {
+  const frames = pageFrames.get(page)!;
+  await page.goto("/");
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+
+  let releaseCss!: () => void;
+  const cssReleased = new Promise<void>((resolve) => {
+    releaseCss = resolve;
+  });
+  let capturedCssReloads = 0;
+  await page.route(/\.css(?:\?.*)?$/, async (route) => {
+    if (capturedCssReloads > 0) {
+      await route.continue();
+      return;
+    }
+    capturedCssReloads += 1;
+    await cssReleased;
+    await route.continue();
+  });
+
+  try {
+    await mutateAndWaitForBuild(page, () =>
+      writeSharedCss("shared-css-reload-v2"),
+    );
+    await expect.poll(() => capturedCssReloads).toBe(1);
+
+    const frameStart = frames.length;
+    await mutateAndWaitForBuild(page, () =>
+      fs.writeFileSync(
+        indexPath,
+        indexBaseline.replace(
+          '[import("./a.js"), import("./b.js")]',
+          "[Promise.resolve(), Promise.resolve()]",
+        ),
+      ),
+    );
+    await expect
+      .poll(
+        () =>
+          getTurbopackUpdates(frames.slice(frameStart)).filter(
+            (update) => update.type === "notFound",
+          ).length,
+      )
+      .toBeGreaterThanOrEqual(2);
+
+    releaseCss();
+    await mutateAndWaitForBuild(page, () =>
+      fs.writeFileSync(indexPath, indexBaseline),
+    );
+    await expect
+      .poll(() =>
+        readRuntimeState(page).then((state) => state.entryEvaluations),
+      )
+      .toBeGreaterThanOrEqual(3);
+
+    await page.locator("#a").evaluate((element) => {
+      element.textContent = "pending";
+    });
+    await page.locator("#b").evaluate((element) => {
+      element.textContent = "pending";
+    });
+    await page.locator("#load").click();
+    await expect(page.locator("#a")).toHaveText("a:shared-v1");
+    await expect(page.locator("#b")).toHaveText("b:shared-v1");
+    await expect(page.locator("#error")).toBeEmpty();
+  } finally {
+    releaseCss();
+  }
+});
+
+test("disposes and restores missing dynamic lists without reloading", async ({
+  page,
+}) => {
+  const receivedFrames = pageFrames.get(page)!;
+  const sentFrames: string[] = [];
+  page.on("websocket", (socket) => {
+    socket.on("framesent", ({ payload }) => sentFrames.push(String(payload)));
+  });
+
+  await page.goto("/");
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  const initial = await readRuntimeState(page);
+
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(
+      indexPath,
+      indexBaseline.replace(
+        '[import("./a.js"), import("./b.js")]',
+        '[Promise.resolve(), import("./b.js")]',
+      ),
+    ),
+  );
+
+  await expect
+    .poll(() =>
+      getTurbopackUpdates(receivedFrames).find(
+        (update) =>
+          update.type === "notFound" &&
+          /(?:^|\/)src_a_[^/]+\.js$/.test(update.resource.path),
+      ),
+    )
+    .toBeTruthy();
+  await expect
+    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
+    .toBe(2);
+
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(indexPath, indexBaseline),
+  );
+  await expect
+    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
+    .toBe(3);
+
+  await page.locator("#a").evaluate((element) => {
+    element.textContent = "disposed";
+  });
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  await expect(page.locator("#error")).toBeEmpty();
+
+  const restored = await readRuntimeState(page);
+  // Both old dynamic lists disappeared during re-chunking, so the shared
+  // module is released only after its final owner is gone and runs once more
+  // when the restored lists load.
+  expect(restored.evaluations).toBe(2);
+  expect(restored.pageToken).toBe(initial.pageToken);
+  expect(restored.timeOrigin).toBe(initial.timeOrigin);
+
+  const aSubscriptions = sentFrames
+    .map((frame) => {
+      try {
+        return JSON.parse(frame);
+      } catch {
+        return null;
+      }
+    })
+    .filter(
+      (message) =>
+        message?.type === "turbopack-subscribe" &&
+        /(?:^|\/)src_a_[^/]+\.js$/.test(message.path),
+    );
+  expect(aSubscriptions).toHaveLength(4);
+  expect(
+    aSubscriptions.filter((message) => message.validation === undefined),
+  ).toHaveLength(2);
+  expect(
+    new Set(
+      aSubscriptions
+        .map((message) => message.validation)
+        .filter((validation) => validation !== undefined),
+    ).size,
+  ).toBe(2);
+});
+
+test("rejects a dynamic bootstrap that disappears before its baseline", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    const originalSend = WebSocket.prototype.send;
+    const delayedFrames: Array<{ socket: WebSocket; data: any }> = [];
+    let delaySubscriptions = true;
+    (globalThis as any).__delayedDynamicSubscriptions = [];
+    (globalThis as any).__flushDynamicSubscriptions = () => {
+      delaySubscriptions = false;
+      for (const { socket, data } of delayedFrames.splice(0)) {
+        originalSend.call(socket, data);
+      }
+    };
+    WebSocket.prototype.send = function (data) {
+      let message;
+      try {
+        message = JSON.parse(String(data));
+      } catch {}
+      if (
+        delaySubscriptions &&
+        message?.type === "turbopack-subscribe" &&
+        /(?:^|\/)src_[ab]_[^/]+\.js$/.test(message.path)
+      ) {
+        const paths = (globalThis as any).__delayedDynamicSubscriptions;
+        if (!paths.includes(message.path)) paths.push(message.path);
+        delayedFrames.push({ socket: this, data });
+        return;
+      }
+      originalSend.call(this, data);
+    };
+  });
+
+  await page.goto("/");
+  const initial = await readRuntimeState(page);
+  await page.locator("#load").click();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () => (globalThis as any).__delayedDynamicSubscriptions.length,
+      ),
+    )
+    .toBe(2);
+
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(
+      indexPath,
+      indexBaseline.replace(
+        '[import("./a.js"), import("./b.js")]',
+        "[Promise.resolve(), Promise.resolve()]",
+      ),
+    ),
+  );
+  await page.evaluate(() => (globalThis as any).__flushDynamicSubscriptions());
+
+  await expect(page.locator("#error")).toContainText(
+    "disappeared while loading",
+  );
+  await expect(page.locator("#a")).toHaveText("pending");
+  await expect(page.locator("#b")).toHaveText("pending");
+  expect((await readRuntimeState(page)).evaluations).toBeUndefined();
+
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(indexPath, indexBaseline),
+  );
+  await expect
+    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
+    .toBeGreaterThanOrEqual(3);
+  await page.locator("#error").evaluate((element) => {
+    element.textContent = "";
+  });
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  await expect(page.locator("#error")).toBeEmpty();
+
+  const restored = await readRuntimeState(page);
+  expect(restored.evaluations).toBe(1);
+  expect(restored.pageToken).toBe(initial.pageToken);
+  expect(restored.timeOrigin).toBe(initial.timeOrigin);
+});
diff --git a/e2e/pack-hmr/playwright.config.ts b/e2e/pack-hmr/playwright.config.ts
new file mode 100644
index 000000000..dd043fa78
--- /dev/null
+++ b/e2e/pack-hmr/playwright.config.ts
@@ -0,0 +1,24 @@
+import { defineConfig } from "@playwright/test";
+
+const port = 4199;
+
+export default defineConfig({
+  testDir: ".",
+  timeout: 2 * 60 * 1000,
+  expect: { timeout: 30 * 1000 },
+  fullyParallel: false,
+  workers: 1,
+  retries: 0,
+  reporter: "list",
+  use: {
+    baseURL: `http://127.0.0.1:${port}`,
+    browserName: "chromium",
+    trace: "retain-on-failure",
+  },
+  webServer: {
+    command: `node server.cjs ${port}`,
+    url: `http://127.0.0.1:${port}`,
+    reuseExistingServer: false,
+    timeout: 2 * 60 * 1000,
+  },
+});
diff --git a/e2e/pack-hmr/server.cjs b/e2e/pack-hmr/server.cjs
new file mode 100644
index 000000000..455452e19
--- /dev/null
+++ b/e2e/pack-hmr/server.cjs
@@ -0,0 +1,38 @@
+const path = require("node:path");
+const { serve } = require("../../packages/pack/cjs");
+
+const port = Number(process.argv[2] || 4199);
+const projectPath = __dirname;
+
+void serve(
+  {
+    config: {
+      entry: [
+        {
+          import: "./src/index.js",
+          name: "main",
+          html: { template: "./index.html" },
+        },
+      ],
+      output: { path: "./dist", clean: true },
+      optimization: {
+        minify: false,
+        splitChunks: {
+          js: {
+            minChunkSize: 1,
+            maxChunkCountPerGroup: 10,
+            maxMergeChunkSize: 1,
+          },
+        },
+      },
+      persistentCaching: false,
+    },
+  },
+  projectPath,
+  projectPath,
+  {
+    hostname: "127.0.0.1",
+    logServerInfo: false,
+    port,
+  },
+);
diff --git a/e2e/pack-hmr/src/a.js b/e2e/pack-hmr/src/a.js
new file mode 100644
index 000000000..c9caf53dd
--- /dev/null
+++ b/e2e/pack-hmr/src/a.js
@@ -0,0 +1,8 @@
+import { sharedValue } from "./shared.js";
+import "./shared.css";
+
+document.querySelector("#a").textContent = `a:${sharedValue}`;
+
+if (import.meta.turbopackHot) {
+  import.meta.turbopackHot.accept();
+}
diff --git a/e2e/pack-hmr/src/b.js b/e2e/pack-hmr/src/b.js
new file mode 100644
index 000000000..a73fb7270
--- /dev/null
+++ b/e2e/pack-hmr/src/b.js
@@ -0,0 +1,8 @@
+import { sharedValue } from "./shared.js";
+import "./shared.css";
+
+document.querySelector("#b").textContent = `b:${sharedValue}`;
+
+if (import.meta.turbopackHot) {
+  import.meta.turbopackHot.accept();
+}
diff --git a/e2e/pack-hmr/src/index.js b/e2e/pack-hmr/src/index.js
new file mode 100644
index 000000000..c60d04fd0
--- /dev/null
+++ b/e2e/pack-hmr/src/index.js
@@ -0,0 +1,16 @@
+globalThis.__packHmrPageToken ||= crypto.randomUUID();
+globalThis.__packHmrApiAvailable = Boolean(import.meta.turbopackHot);
+globalThis.__packHmrEntryEvaluations =
+  (globalThis.__packHmrEntryEvaluations || 0) + 1;
+
+document.querySelector("#load").onclick = async () => {
+  try {
+    await Promise.all([import("./a.js"), import("./b.js")]);
+  } catch (error) {
+    document.querySelector("#error").textContent = String(error);
+  }
+};
+
+if (import.meta.turbopackHot) {
+  import.meta.turbopackHot.accept();
+}
diff --git a/e2e/pack-hmr/src/shared.css b/e2e/pack-hmr/src/shared.css
new file mode 100644
index 000000000..bcdb85af6
--- /dev/null
+++ b/e2e/pack-hmr/src/shared.css
@@ -0,0 +1,4 @@
+#a,
+#b {
+  --pack-hmr-shared: "shared-css-v1";
+}
diff --git a/e2e/pack-hmr/src/shared.js b/e2e/pack-hmr/src/shared.js
new file mode 100644
index 000000000..1d528ffba
--- /dev/null
+++ b/e2e/pack-hmr/src/shared.js
@@ -0,0 +1,4 @@
+globalThis.__packHmrSharedEvaluations =
+  (globalThis.__packHmrSharedEvaluations || 0) + 1;
+
+export const sharedValue = "shared-v1";
diff --git a/package.json b/package.json
index f32dcc645..62d4ddec0 100644
--- a/package.json
+++ b/package.json
@@ -8,6 +8,7 @@
     "build": "turbo run build",
     "test": "turbo run test",
     "test:e2e:utooweb": "playwright test -c e2e/utoo-web/playwright.config.ts",
+    "test:e2e:pack-hmr": "playwright test -c e2e/pack-hmr/playwright.config.ts",
     "vitest:all": "turbo run test --filter=@utoo/pack --filter=@utoo/pack-shared",
     "lint": "turbo run lint",
     "dev": "turbo run dev",
diff --git a/packages/pack-shared/src/hmr.ts b/packages/pack-shared/src/hmr.ts
index 33b243bde..54786e54b 100644
--- a/packages/pack-shared/src/hmr.ts
+++ b/packages/pack-shared/src/hmr.ts
@@ -48,6 +48,7 @@ export interface EcmascriptMergedUpdate {
 export interface BaseUpdate {
   resource: ResourceIdentifier;
   issues: HmrIssue[];
+  validation?: string;
 }
 
 export interface IssuesUpdate extends BaseUpdate {
@@ -155,6 +156,8 @@ export type HMR_ACTION_TYPES =
 export interface TurbopackSubscribeMessage {
   type: "turbopack-subscribe";
   path: string;
+  version?: string;
+  validation?: string;
 }
 
 export interface TurbopackUnsubscribeMessage {
diff --git a/packages/pack/src/__test__/hmr.test.ts b/packages/pack/src/__test__/hmr.test.ts
index 99feeca3c..0c61a8f47 100644
--- a/packages/pack/src/__test__/hmr.test.ts
+++ b/packages/pack/src/__test__/hmr.test.ts
@@ -196,8 +196,8 @@ describe("HMR subscription lifecycle", () => {
     });
 
     expect(createSubscription).toHaveBeenCalledExactlyOnceWith("route");
-    expect(clientA.onIssues).toHaveBeenCalledWith([]);
-    expect(clientB.onIssues).toHaveBeenCalledWith([]);
+    expect(clientA.onIssues).toHaveBeenCalledWith([], "issues");
+    expect(clientB.onIssues).toHaveBeenCalledWith([], "issues");
   });
 
   it("returns the shared iterator only after its last subscriber leaves", async () => {
@@ -219,25 +219,56 @@ describe("HMR subscription lifecycle", () => {
     expect(iterator.return).toHaveBeenCalledOnce();
   });
 
-  it("seeds a joining subscriber with latest issues without replaying a partial", async () => {
+  it("seeds a joining subscriber from a stable issues baseline", async () => {
     const iterator = createControlledHmrEvents<any>();
-    const registry = createSharedHmrSubscriptionRegistry(() => iterator);
+    const createSubscription = vi.fn(() => iterator);
+    const registry = createSharedHmrSubscriptionRegistry(createSubscription);
     const clientA = { onIssues: vi.fn(), onUpdate: vi.fn() };
     const clientB = { onIssues: vi.fn(), onUpdate: vi.fn() };
 
     registry.subscribe("route", clientA);
     iterator.emit({
-      type: "partial",
+      type: "issues",
       issues: [{ severity: "warning", message: "latest" }],
-      instruction: {},
     });
-    await vi.waitFor(() => expect(clientA.onUpdate).toHaveBeenCalledOnce());
+    await vi.waitFor(() => expect(clientA.onIssues).toHaveBeenCalledOnce());
 
     registry.subscribe("route", clientB);
 
-    expect(clientB.onIssues).toHaveBeenCalledExactlyOnceWith([
-      { severity: "warning", message: "latest" },
-    ]);
+    expect(createSubscription).toHaveBeenCalledOnce();
+    expect(clientB.onIssues).toHaveBeenCalledExactlyOnceWith(
+      [{ severity: "warning", message: "latest" }],
+      "issues",
+    );
+    expect(clientB.onUpdate).not.toHaveBeenCalled();
+  });
+
+  it("creates a fresh baseline for a subscriber joining after an update", async () => {
+    const iteratorA = createControlledHmrEvents<any>();
+    const iteratorB = createControlledHmrEvents<any>();
+    const createSubscription = vi
+      .fn()
+      .mockReturnValueOnce(iteratorA)
+      .mockReturnValueOnce(iteratorB);
+    const registry = createSharedHmrSubscriptionRegistry(createSubscription);
+    const clientA = { onIssues: vi.fn(), onUpdate: vi.fn() };
+    const clientB = { onIssues: vi.fn(), onUpdate: vi.fn() };
+
+    registry.subscribe("route", clientA);
+    const update = { type: "partial", issues: [], instruction: {} };
+    iteratorA.emit(update);
+    await vi.waitFor(() =>
+      expect(clientA.onUpdate).toHaveBeenCalledWith(update),
+    );
+
+    registry.subscribe("route", clientB);
+    expect(createSubscription).toHaveBeenCalledTimes(2);
+    expect(clientB.onIssues).not.toHaveBeenCalled();
+
+    iteratorB.emit({ type: "issues", issues: [] });
+    await vi.waitFor(() =>
+      expect(clientB.onIssues).toHaveBeenCalledWith([], "issues"),
+    );
     expect(clientB.onUpdate).not.toHaveBeenCalled();
   });
 
@@ -255,7 +286,10 @@ describe("HMR subscription lifecycle", () => {
     iterator.emit({ type: "issues", issues: [{ severity: "warning" }] });
     await vi.waitFor(() => expect(clientB.onIssues).toHaveBeenCalledOnce());
 
-    expect(clientB.onIssues).toHaveBeenCalledWith([{ severity: "warning" }]);
+    expect(clientB.onIssues).toHaveBeenCalledWith(
+      [{ severity: "warning" }],
+      "issues",
+    );
   });
 
   it("keeps one subscriber callback failure from stopping other clients", async () => {
diff --git a/packages/pack/src/__test__/hmrWebSocket.test.ts b/packages/pack/src/__test__/hmrWebSocket.test.ts
new file mode 100644
index 000000000..6be3c416f
--- /dev/null
+++ b/packages/pack/src/__test__/hmrWebSocket.test.ts
@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+class FakeWebSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  static readonly instances: FakeWebSocket[] = [];
+
+  readonly CONNECTING = FakeWebSocket.CONNECTING;
+  readonly OPEN = FakeWebSocket.OPEN;
+  readonly CLOSING = FakeWebSocket.CLOSING;
+  readonly CLOSED = FakeWebSocket.CLOSED;
+  readonly sent: string[] = [];
+  readonly url: string;
+  closeCalls = 0;
+  readyState = FakeWebSocket.CONNECTING;
+  onopen: ((event: Event) => void) | null = null;
+  onerror: ((event: Event) => void) | null = null;
+  onclose: ((event: Event) => void) | null = null;
+  onmessage: ((event: MessageEvent<string>) => void) | null = null;
+
+  constructor(url: string | URL) {
+    this.url = String(url);
+    FakeWebSocket.instances.push(this);
+  }
+
+  open() {
+    this.readyState = FakeWebSocket.OPEN;
+    this.onopen?.({ target: this } as unknown as Event);
+  }
+
+  fail() {
+    this.onerror?.({ target: this } as unknown as Event);
+  }
+
+  send(message: string) {
+    this.sent.push(message);
+  }
+
+  close() {
+    this.closeCalls += 1;
+    this.readyState = FakeWebSocket.CLOSED;
+  }
+}
+
+function createWindow() {
+  const listeners = new Map<string, Set<(event: any) => void>>();
+  const location = {
+    hostname: "localhost",
+    port: "3000",
+    protocol: "http:",
+    reload: vi.fn(),
+  };
+
+  return {
+    location,
+    window: {
+      console: {
+        log: vi.fn(),
+        warn: vi.fn(),
+      },
+      location,
+      addEventListener(type: string, callback: (event: any) => void) {
+        let callbacks = listeners.get(type);
+        if (!callbacks) {
+          callbacks = new Set();
+          listeners.set(type, callbacks);
+        }
+        callbacks.add(callback);
+      },
+    },
+    dispatch(type: string, event: any = {}) {
+      for (const callback of listeners.get(type) ?? []) {
+        callback(event);
+      }
+    },
+  };
+}
+
+describe("HMR WebSocket", () => {
+  const originalSocketServer = process.env.SOCKET_SERVER;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.resetModules();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    FakeWebSocket.instances.length = 0;
+    delete process.env.SOCKET_SERVER;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+    if (originalSocketServer === undefined) {
+      delete process.env.SOCKET_SERVER;
+    } else {
+      process.env.SOCKET_SERVER = originalSocketServer;
+    }
+  });
+
+  it("reconnects and emits connected so active subscriptions can be restored", async () => {
+    const browser = createWindow();
+    vi.stubGlobal("window", browser.window);
+    vi.stubGlobal("location", browser.location);
+    vi.stubGlobal("WebSocket", FakeWebSocket);
+
+    const { addMessageListener, connectHMR } = await import(
+      "../../../../crates/pack-core/js/src/hmr/websocket"
+    );
+    const messages: Array<{ type: string }> = [];
+    addMessageListener((message) => messages.push(message));
+
+    connectHMR({ path: "/turbopack-hmr" });
+    expect(FakeWebSocket.instances).toHaveLength(1);
+
+    FakeWebSocket.instances[0].fail();
+    await vi.advanceTimersByTimeAsync(499);
+    expect(FakeWebSocket.instances).toHaveLength(1);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(FakeWebSocket.instances).toHaveLength(2);
+    FakeWebSocket.instances[1].open();
+
+    expect(messages).toEqual([{ type: "turbopack-connected" }]);
+  });
+
+  it("cancels reconnects while the page is unloading", async () => {
+    const browser = createWindow();
+    vi.stubGlobal("window", browser.window);
+    vi.stubGlobal("location", browser.location);
+    vi.stubGlobal("WebSocket", FakeWebSocket);
+
+    const { connectHMR } = await import(
+      "../../../../crates/pack-core/js/src/hmr/websocket"
+    );
+
+    connectHMR({ path: "/turbopack-hmr" });
+    FakeWebSocket.instances[0].fail();
+    browser.dispatch("pagehide");
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    expect(FakeWebSocket.instances).toHaveLength(1);
+  });
+});
diff --git a/packages/pack/src/binding.d.ts b/packages/pack/src/binding.d.ts
index 04de61e96..8c6cbf1fa 100644
--- a/packages/pack/src/binding.d.ts
+++ b/packages/pack/src/binding.d.ts
@@ -171,7 +171,7 @@ export interface NapiEntrypoints {
 }
 export declare function projectWriteAllEntrypointsToDisk(project: { __napiType: "Project" }): Promise<TurbopackResult>
 export declare function projectEntrypointsSubscribe(project: { __napiType: "Project" }, func: (...args: any[]) => any): { __napiType: "RootTask" }
-export declare function projectHmrEvents(project: { __napiType: "Project" }, identifier: RcStr, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export declare function projectHmrEvents(project: { __napiType: "Project" }, identifier: RcStr, func: (...args: any[]) => any, expectedVersion?: RcStr | undefined | null): { __napiType: "RootTask" }
 export interface HmrIdentifiers {
   identifiers: Array<string>
 }
diff --git a/packages/pack/src/core/hmr.ts b/packages/pack/src/core/hmr.ts
index 4c322e702..352a5a016 100644
--- a/packages/pack/src/core/hmr.ts
+++ b/packages/pack/src/core/hmr.ts
@@ -136,6 +136,12 @@ function hasBlockingIssues(issues: EntryIssuesMap) {
   return false;
 }
 
+function hasCriticalHmrIssues(issues: TurbopackUpdate["issues"]) {
+  return issues.some((issue) =>
+    ["bug", "error", "fatal"].includes(issue.severity),
+  );
+}
+
 function hasBlockingResultIssues(result: TurbopackResult) {
   return result.issues.some(
     (issue) => issue.severity === "error" || issue.severity === "fatal",
@@ -277,7 +283,14 @@ export async function createHotReloader(
   const clientStates = new WeakMap<WSLike, ClientState>();
   const hmrSubscriptions = createSharedHmrSubscriptionRegistry<
     TurbopackResult<TurbopackUpdate>
-  >((id) => project.hmrEvents(id));
+  >((subscriptionKey) => {
+    const [id, expectedVersion] = JSON.parse(subscriptionKey) as [
+      string,
+      string | null,
+      string | null,
+    ];
+    return project.hmrEvents(id, expectedVersion ?? undefined);
+  });
   const currentEntryIssues: EntryIssuesMap = new Map();
   const backgroundWatchSubscriptions = new Set<
     AsyncIterableIterator<TurbopackResult>
@@ -286,6 +299,7 @@ export async function createHotReloader(
   let currentWatchedEntrypoints: Endpoint[] = [];
   let backgroundWatchersStarted = false;
   let backgroundWatchGeneration = 0;
+  let hmrBuildInProgress = false;
   const backgroundEndpointWriteTasks = new Map<Endpoint, Promise<void>>();
   let backgroundProjectWriteTask: Promise<void> | undefined;
   let closed = false;
@@ -337,9 +351,19 @@ export async function createHotReloader(
       }
     }
   }
-  const sendEnqueuedMessagesDebounce = debounce(sendEnqueuedMessages, 2);
+  const sendEnqueuedMessagesDebounce = debounce(() => {
+    // Every chunk-list subscription computes its own update, but all updates
+    // from one project build must reach the browser as one transaction. A
+    // timer firing mid-build would otherwise make shared modules apply twice.
+    if (!hmrBuildInProgress) {
+      sendEnqueuedMessages();
+    }
+  }, 2);
 
-  function sendTurbopackMessage(client: WSLike, payload: TurbopackUpdate) {
+  function sendTurbopackMessage(
+    client: WSLike,
+    payload: TurbopackUpdate & { validation?: string },
+  ) {
     enqueueTurbopackUpdateForClient(clientStates, client, payload);
     sendEnqueuedMessagesDebounce();
   }
@@ -522,22 +546,61 @@ export async function createHotReloader(
     );
   }
 
-  function subscribeToHmrEvents(client: WSLike, id: string) {
+  function subscribeToHmrEvents(
+    client: WSLike,
+    id: string,
+    expectedVersion?: string,
+    validation?: string,
+  ) {
     const state = clientStates.get(client);
     if (!state || state.subscriptions.has(id)) {
       return;
     }
 
     const issueKey = getClientIssueKey(id);
+    let subscriptionReady = false;
     let subscription: ReturnableSubscription;
-    subscription = hmrSubscriptions.subscribe(id, {
-      onIssues(issues) {
+    const subscriptionKey = JSON.stringify([
+      id,
+      expectedVersion ?? null,
+      validation ?? null,
+    ]);
+    subscription = hmrSubscriptions.subscribe(subscriptionKey, {
+      onIssues(issues, resultType) {
         if (clientStates.get(client) !== state) return;
         processIssues(state.clientIssues, issueKey, { issues }, false, true);
+
+        if (
+          !subscriptionReady &&
+          !hasCriticalHmrIssues(issues) &&
+          resultType === "issues"
+        ) {
+          subscriptionReady = true;
+          // A normal first result (or a cached baseline for a shared native
+          // subscription) proves that VersionState is ready. Terminal results
+          // must reach the client directly and reject the dynamic bootstrap.
+          const readyUpdate: TurbopackUpdate & { validation?: string } = {
+            type: "issues",
+            resource: { path: id, headers: undefined },
+            issues,
+            validation,
+          };
+          sendToClient(client, {
+            action: HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE,
+            data: readyUpdate,
+          });
+        }
       },
       onUpdate(data) {
         if (clientStates.get(client) !== state) return;
-        sendTurbopackMessage(client, data);
+        if (data.type === "partial" && !hasCriticalHmrIssues(data.issues)) {
+          subscriptionReady = true;
+        }
+        sendTurbopackMessage(client, { ...data, validation });
+        if (data.type === "notFound") {
+          void unsubscribeClient(state.subscriptions, id);
+          state.clientIssues.delete(issueKey);
+        }
       },
       onError(error) {
         if (
@@ -685,7 +748,16 @@ export async function createHotReloader(
           // Turbopack messages
           switch (parsedData.type) {
             case "turbopack-subscribe":
-              subscribeToHmrEvents(client, parsedData.path);
+              subscribeToHmrEvents(
+                client,
+                parsedData.path,
+                typeof parsedData.version === "string"
+                  ? parsedData.version
+                  : undefined,
+                typeof parsedData.validation === "string"
+                  ? parsedData.validation
+                  : undefined,
+              );
               break;
 
             case "turbopack-unsubscribe":
@@ -788,7 +860,16 @@ export async function createHotReloader(
 
       switch (parsedData.type) {
         case "turbopack-subscribe":
-          subscribeToHmrEvents(ws, parsedData.path);
+          subscribeToHmrEvents(
+            ws,
+            parsedData.path,
+            typeof parsedData.version === "string"
+              ? parsedData.version
+              : undefined,
+            typeof parsedData.validation === "string"
+              ? parsedData.validation
+              : undefined,
+          );
           break;
         case "turbopack-unsubscribe":
           unsubscribeFromHmrEvents(ws, parsedData.path);
@@ -876,12 +957,14 @@ export async function createHotReloader(
     for await (const updateMessage of project.updateInfoSubscribe(30)) {
       switch (updateMessage.updateType) {
         case "start": {
+          hmrBuildInProgress = true;
           hmrTimingReporter.start();
           hotReloader.send({ action: HMR_ACTIONS_SENT_TO_BROWSER.BUILDING });
           console.log("Compiling...");
           break;
         }
         case "end": {
+          hmrBuildInProgress = false;
           sendEnqueuedMessages();
 
           const errors = new Map<string, CompilationError>();
diff --git a/packages/pack/src/core/hmrClientState.ts b/packages/pack/src/core/hmrClientState.ts
index 9f7c5a7d1..8955b6cbb 100644
--- a/packages/pack/src/core/hmrClientState.ts
+++ b/packages/pack/src/core/hmrClientState.ts
@@ -46,8 +46,10 @@ export async function consumeHmrSubscription<Result extends { type: string }>(
   }
 }
 
-export interface SharedHmrSubscriber<Result extends { issues: unknown[] }> {
-  onIssues: (issues: Result["issues"]) => void;
+export interface SharedHmrSubscriber<
+  Result extends { type: string; issues: unknown[] },
+> {
+  onIssues: (issues: Result["issues"], resultType: Result["type"]) => void;
   onUpdate: (result: Result) => void;
   onError?: (error: unknown) => void;
   onComplete?: () => void;
@@ -60,6 +62,7 @@ export function createSharedHmrSubscriptionRegistry<
   type Member = { active: boolean; subscriber: Subscriber };
   type Entry = {
     latestIssues?: Result["issues"];
+    latestResultType?: Result["type"];
     subscription: AsyncIterableIterator<Result>;
     subscribers: Set<Member>;
   };
@@ -79,11 +82,22 @@ export function createSharedHmrSubscriptionRegistry<
     try {
       for await (const result of entry.subscription) {
         entry.latestIssues = [...result.issues] as Result["issues"];
+        entry.latestResultType = result.type;
+        if (result.type !== "issues" && entries.get(id) === entry) {
+          // A late subscriber cannot reuse a stream after its version state has
+          // advanced: it would receive the latest issues but miss the update
+          // which advanced that state. Keep serving existing subscribers, but
+          // force future ones to establish and validate a fresh baseline.
+          entries.delete(id);
+        }
         for (const member of [...entry.subscribers]) {
           if (!member.active) continue;
           const { subscriber } = member;
           try {
-            subscriber.onIssues([...entry.latestIssues] as Result["issues"]);
+            subscriber.onIssues(
+              [...entry.latestIssues] as Result["issues"],
+              result.type,
+            );
             if (member.active && result.type !== "issues") {
               subscriber.onUpdate(result);
             }
@@ -126,9 +140,12 @@ export function createSharedHmrSubscriptionRegistry<
       }
       const member: Member = { active: true, subscriber };
       entry.subscribers.add(member);
-      if (entry.latestIssues) {
+      if (entry.latestIssues && entry.latestResultType) {
         try {
-          subscriber.onIssues([...entry.latestIssues] as Result["issues"]);
+          subscriber.onIssues(
+            [...entry.latestIssues] as Result["issues"],
+            entry.latestResultType,
+          );
         } catch (error) {
           reportSubscriberError(member, error);
         }
diff --git a/packages/pack/src/core/project.ts b/packages/pack/src/core/project.ts
index 6d6ed196e..4f4db7649 100644
--- a/packages/pack/src/core/project.ts
+++ b/packages/pack/src/core/project.ts
@@ -553,9 +553,14 @@ export function projectFactory() {
       })();
     }
 
-    hmrEvents(identifier: string) {
+    hmrEvents(identifier: string, expectedVersion?: string) {
       return subscribe<TurbopackResult<Update>>(true, async (callback) =>
-        binding.projectHmrEvents(this._nativeProject, identifier, callback),
+        binding.projectHmrEvents(
+          this._nativeProject,
+          identifier,
+          callback,
+          expectedVersion,
+        ),
       );
     }
 
diff --git a/packages/pack/src/core/types.ts b/packages/pack/src/core/types.ts
index 9f766159f..31b10d2e1 100644
--- a/packages/pack/src/core/types.ts
+++ b/packages/pack/src/core/types.ts
@@ -1,4 +1,4 @@
-import type { RestartUpdate } from "@utoo/pack-shared";
+import type { NotFoundUpdate, RestartUpdate } from "@utoo/pack-shared";
 import {
   HmrIdentifiers,
   NapiIssue,
@@ -43,7 +43,11 @@ export interface PartialUpdate extends BaseUpdate {
   };
 }
 
-export type Update = IssuesUpdate | PartialUpdate | RestartUpdate;
+export type Update =
+  | IssuesUpdate
+  | PartialUpdate
+  | RestartUpdate
+  | NotFoundUpdate;
 
 export interface ProjectOptions extends BundleOptions {
   /**
@@ -67,7 +71,10 @@ export interface Project {
     TurbopackResult<RawEntrypoints>
   >;
 
-  hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
+  hmrEvents(
+    identifier: string,
+    expectedVersion?: string,
+  ): AsyncIterableIterator<TurbopackResult<Update>>;
 
   hmrIdentifiersSubscribe(): AsyncIterableIterator<
     TurbopackResult<HmrIdentifiers>
diff --git a/packages/utoo-web/src/hmr/HmrServer.ts b/packages/utoo-web/src/hmr/HmrServer.ts
index fb0a356d7..9f6331b8f 100644
--- a/packages/utoo-web/src/hmr/HmrServer.ts
+++ b/packages/utoo-web/src/hmr/HmrServer.ts
@@ -19,7 +19,12 @@ export interface HmrServerOptions {
   /** Session ID for this HMR server instance */
   sessionId?: number;
   /** Callback when a client subscribes to an HMR path */
-  onSubscribe?: (path: string, client: HmrClient) => void;
+  onSubscribe?: (
+    path: string,
+    client: HmrClient,
+    expectedVersion?: string,
+    validation?: string,
+  ) => void | Promise<void>;
   /** Callback when a client unsubscribes from an HMR path */
   onUnsubscribe?: (path: string, client: HmrClient) => void;
 }
@@ -132,12 +137,25 @@ export class HmrServer {
 
       if ("type" in message) {
         switch (message.type) {
-          case "turbopack-subscribe":
-            this.subscribe(client, (message as { path: string }).path);
+          case "turbopack-subscribe": {
+            const subscribeMessage = message as {
+              path: string;
+              version?: string;
+              validation?: string;
+            };
+            this.subscribe(
+              client,
+              subscribeMessage.path,
+              subscribeMessage.version,
+              subscribeMessage.validation,
+            );
             break;
-          case "turbopack-unsubscribe":
-            this.unsubscribe(client, (message as { path: string }).path);
+          }
+          case "turbopack-unsubscribe": {
+            const unsubscribeMessage = message as { path: string };
+            this.unsubscribe(client, unsubscribeMessage.path);
             break;
+          }
         }
       }
 
@@ -170,14 +188,19 @@ export class HmrServer {
     }
   }
 
-  private subscribe(client: HmrClient, path: string) {
+  private subscribe(
+    client: HmrClient,
+    path: string,
+    expectedVersion?: string,
+    validation?: string,
+  ) {
     let clients = this.subscriptions.get(path);
     if (!clients) {
       clients = new Set();
       this.subscriptions.set(path, clients);
     }
     clients.add(client);
-    this.options.onSubscribe?.(path, client);
+    void this.options.onSubscribe?.(path, client, expectedVersion, validation);
   }
 
   private unsubscribe(client: HmrClient, path: string) {
diff --git a/packages/utoo-web/src/project/ForkedProject.ts b/packages/utoo-web/src/project/ForkedProject.ts
index c9597d21f..e7324ac1b 100644
--- a/packages/utoo-web/src/project/ForkedProject.ts
+++ b/packages/utoo-web/src/project/ForkedProject.ts
@@ -2,6 +2,7 @@ import { type ConfigComplete } from "@utoo/pack-shared";
 import * as comlink from "comlink";
 import {
   DepsOptions,
+  HmrSubscribeOptions,
   InstallOptions,
   PackFile,
   ProjectEndpoint,
@@ -10,8 +11,12 @@ import {
   UpdateMessage,
 } from "../types";
 
+type RemoteProjectEndpoint = ProjectEndpoint & {
+  hmrUnsubscribe: NonNullable<ProjectEndpoint["hmrUnsubscribe"]>;
+};
+
 export class ForkedProject implements ProjectEndpoint {
-  private endpoint: comlink.Remote<ProjectEndpoint>;
+  private endpoint: comlink.Remote<RemoteProjectEndpoint>;
 
   constructor(port: MessagePort) {
     this.endpoint ??= comlink.wrap(port);
@@ -44,8 +49,17 @@ export class ForkedProject implements ProjectEndpoint {
   public async hmrSubscribe(
     identifier: string,
     callback: (update: unknown) => void,
+    options?: HmrSubscribeOptions,
   ): Promise<void> {
-    await this.endpoint.hmrSubscribe(identifier, comlink.proxy(callback));
+    await this.endpoint.hmrSubscribe(
+      identifier,
+      comlink.proxy(callback),
+      options,
+    );
+  }
+
+  public async hmrUnsubscribe(subscriptionId: string): Promise<void> {
+    await this.endpoint.hmrUnsubscribe(subscriptionId);
   }
 
   public updateInfoSubscribe(
diff --git a/packages/utoo-web/src/project/InternalProject.ts b/packages/utoo-web/src/project/InternalProject.ts
index 931478eaf..cb20ce548 100644
--- a/packages/utoo-web/src/project/InternalProject.ts
+++ b/packages/utoo-web/src/project/InternalProject.ts
@@ -1,6 +1,7 @@
 import { type ConfigComplete, type UpdateMessage } from "@utoo/pack-shared";
 import {
   DepsOptions,
+  HmrSubscribeOptions,
   InstallOptions,
   PackFile,
   ProjectEndpoint,
@@ -28,6 +29,9 @@ class InternalEndpoint implements ProjectEndpoint {
   private rootTask?: RootTask;
   // Keep HMR root tasks alive (keyed by identifier)
   private hmrRootTasks: Map<string, RootTask> = new Map();
+  // Monotonic generations prevent a slow, cancelled subscription from replacing
+  // a newer subscription that uses the same client/path key.
+  private hmrSubscriptionGenerations: Map<string, number> = new Map();
 
   // This should be called only once
   async mount(opt: Omit<ProjectOptions, "workerUrl" | "serviceWorker">) {
@@ -200,9 +204,48 @@ class InternalEndpoint implements ProjectEndpoint {
     return await ProjectInternal.sigMd5(content);
   }
 
-  async hmrSubscribe(identifier: string, callback: (update: unknown) => void) {
-    const rootTask = await ProjectInternal.hmrEvents(identifier, callback);
-    this.hmrRootTasks.set(identifier, rootTask);
+  async hmrSubscribe(
+    identifier: string,
+    callback: (update: unknown) => void,
+    options?: HmrSubscribeOptions,
+  ) {
+    const subscriptionId = options?.subscriptionId ?? identifier;
+    const generation =
+      (this.hmrSubscriptionGenerations.get(subscriptionId) ?? 0) + 1;
+    this.hmrSubscriptionGenerations.set(subscriptionId, generation);
+
+    this.hmrRootTasks.get(subscriptionId)?.free();
+    this.hmrRootTasks.delete(subscriptionId);
+
+    const rootTask = await ProjectInternal.hmrEvents(
+      identifier,
+      (update: unknown) => {
+        if (
+          this.hmrSubscriptionGenerations.get(subscriptionId) === generation
+        ) {
+          callback(
+            options?.validation === undefined
+              ? update
+              : { ...(update as object), validation: options.validation },
+          );
+        }
+      },
+      options?.expectedVersion,
+    );
+
+    if (this.hmrSubscriptionGenerations.get(subscriptionId) !== generation) {
+      rootTask.free();
+      return;
+    }
+    this.hmrRootTasks.set(subscriptionId, rootTask);
+  }
+
+  hmrUnsubscribe(subscriptionId: string) {
+    const generation =
+      (this.hmrSubscriptionGenerations.get(subscriptionId) ?? 0) + 1;
+    this.hmrSubscriptionGenerations.set(subscriptionId, generation);
+    this.hmrRootTasks.get(subscriptionId)?.free();
+    this.hmrRootTasks.delete(subscriptionId);
   }
 
   updateInfoSubscribe(
diff --git a/packages/utoo-web/src/project/Project.ts b/packages/utoo-web/src/project/Project.ts
index e73c4a286..cea51ca59 100644
--- a/packages/utoo-web/src/project/Project.ts
+++ b/packages/utoo-web/src/project/Project.ts
@@ -1,6 +1,8 @@
 import {
   type ConfigComplete,
+  HMR_ACTIONS_SENT_TO_BROWSER,
   handleIssues,
+  type TurbopackUpdate,
   type UpdateMessage,
 } from "@utoo/pack-shared";
 import * as comlink from "comlink";
@@ -11,6 +13,7 @@ import {
   BuildOutput,
   DepsOptions,
   Dirent,
+  HmrSubscribeOptions,
   InstallOptions,
   PackFile,
   ProjectEndpoint,
@@ -28,6 +31,10 @@ let ProjectWorker: Worker;
 
 const ConnectedPorts = new Set<MessagePort>();
 
+type RemoteProjectEndpoint = ProjectEndpoint & {
+  hmrUnsubscribe: NonNullable<ProjectEndpoint["hmrUnsubscribe"]>;
+};
+
 export class Project implements ProjectEndpoint {
   #mount: Promise<void>;
 
@@ -39,7 +46,7 @@ export class Project implements ProjectEndpoint {
   private hmrServer?: HmrServer;
 
   private remote: comlink.Remote<
-    ProjectEndpoint & {
+    RemoteProjectEndpoint & {
       mount: (
         opt: Omit<ProjectOptions, "workerUrl" | "serviceWorker">,
       ) => Promise<void>;
@@ -139,10 +146,24 @@ export class Project implements ProjectEndpoint {
     // Create HmrServer lazily on first dev() call
     if (!this.hmrServer) {
       this.hmrServer = new HmrServer({
-        onSubscribe: async (path, client) => {
-          await this.hmrSubscribe(path, (update) => {
-            this.hmrServer!.sendUpdate(path, update as any);
-          });
+        onSubscribe: async (path, client, expectedVersion, validation) => {
+          await this.hmrSubscribe(
+            path,
+            (update) => {
+              client.send({
+                action: HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE,
+                data: update as TurbopackUpdate,
+              });
+            },
+            {
+              expectedVersion,
+              subscriptionId: `${client.id}:${path}`,
+              validation,
+            },
+          );
+        },
+        onUnsubscribe: (path, client) => {
+          void this.hmrUnsubscribe(`${client.id}:${path}`);
         },
       });
     }
@@ -162,8 +183,17 @@ export class Project implements ProjectEndpoint {
   public async hmrSubscribe(
     identifier: string,
     callback: (update: unknown) => void,
+    options?: HmrSubscribeOptions,
   ): Promise<void> {
-    await this.remote.hmrSubscribe(identifier, comlink.proxy(callback));
+    await this.remote.hmrSubscribe(
+      identifier,
+      comlink.proxy(callback),
+      options,
+    );
+  }
+
+  public async hmrUnsubscribe(subscriptionId: string): Promise<void> {
+    await this.remote.hmrUnsubscribe(subscriptionId);
   }
 
   public updateInfoSubscribe(
diff --git a/packages/utoo-web/src/types.ts b/packages/utoo-web/src/types.ts
index 03b8fa75a..c3b614e93 100644
--- a/packages/utoo-web/src/types.ts
+++ b/packages/utoo-web/src/types.ts
@@ -117,6 +117,13 @@ export interface InstallOptions {
   omit?: OmitType[];
 }
 
+export interface HmrSubscribeOptions {
+  expectedVersion?: string;
+  subscriptionId?: string;
+  /** Opaque generation token echoed on every update for this subscription. */
+  validation?: string;
+}
+
 export interface ProjectEndpoint {
   deps: (options?: DepsOptions) => Promise<string>;
   install: (packageLock: string, options?: InstallOptions) => Promise<void>;
@@ -138,7 +145,10 @@ export interface ProjectEndpoint {
   hmrSubscribe: (
     identifier: string,
     callback: (update: unknown) => void,
+    options?: HmrSubscribeOptions,
   ) => void | Promise<void>;
+  /** Cancel an HMR subscription previously created with the same subscription ID. */
+  hmrUnsubscribe?: (subscriptionId: string) => void | Promise<void>;
   /** Subscribe to compilation lifecycle events (start/end). */
   updateInfoSubscribe: (
     aggregationMs: number,
diff --git a/packages/utoo-web/src/utoo/index.d.ts b/packages/utoo-web/src/utoo/index.d.ts
index 397133b48..cf79bb024 100644
--- a/packages/utoo-web/src/utoo/index.d.ts
+++ b/packages/utoo-web/src/utoo/index.d.ts
@@ -120,7 +120,7 @@ export class Project {
      * Subscribe to HMR events for a specific identifier.
      * Returns a RootTask that must be held by JS to keep the subscription active.
      */
-    static hmrEvents(identifier: string, callback: Function): Promise<RootTask>;
+    static hmrEvents(identifier: string, callback: Function, expected_version?: string | null): Promise<RootTask>;
     static init(thread_url: string): void;
     /**
      * Install dependencies - downloads tgz files only, extracts on-demand when files are read

From a66bb32676d2b64185cbc6784c5b79afecc3c0a5 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Tue, 21 Jul 2026 20:19:13 +0800
Subject: [PATCH 07/11] chore(pack): align rust formatting

---
 crates/utoo-wasm/src/pack.rs    | 20 ++++++++++----------
 crates/utoo-wasm/src/project.rs |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/crates/utoo-wasm/src/pack.rs b/crates/utoo-wasm/src/pack.rs
index 658726d5c..4f5664ea6 100644
--- a/crates/utoo-wasm/src/pack.rs
+++ b/crates/utoo-wasm/src/pack.rs
@@ -2,42 +2,42 @@ use anyhow::{Context, Result};
 use pack_api::{
     endpoint::Endpoint,
     entrypoint::{
-        EntrypointsWithIssues, get_all_written_entrypoints_with_issues_operation,
-        get_entrypoints_with_issues_operation,
+        get_all_written_entrypoints_with_issues_operation, get_entrypoints_with_issues_operation,
+        EntrypointsWithIssues,
     },
-    hmr::{HmrUpdateWithIssues, hmr_update_with_issues_operation},
+    hmr::{hmr_update_with_issues_operation, HmrUpdateWithIssues},
     project::{ProjectContainer, ProjectOptions, WatchOptions},
     turbo_tasks::UtooTurboTasks,
     utils::StyledStringSerialize,
 };
 use parking_lot::RwLock;
 use serde::{Deserialize, Deserializer, Serialize};
-use serde_json::{Value, json};
+use serde_json::{json, Value};
 use std::{
     ops::Deref,
     path::PathBuf,
     str::FromStr,
     sync::{
-        Arc,
         atomic::{AtomicBool, Ordering},
+        Arc,
     },
     time::Duration,
 };
 use tokio::{sync::mpsc::unbounded_channel, time::Instant};
-use turbo_rcstr::{RcStr, rcstr};
+use turbo_rcstr::{rcstr, RcStr};
 use turbo_tasks::TaskId;
 use turbo_tasks::{
-    Completion, OperationVc, PrettyPrintError, ReadConsistency, ResolvedVc, TransientInstance,
-    TurboTasks, Vc, read_strongly_consistent_and_apply_effects,
+    read_strongly_consistent_and_apply_effects, Completion, OperationVc, PrettyPrintError,
+    ReadConsistency, ResolvedVc, TransientInstance, TurboTasks, Vc,
 };
-use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};
+use turbo_tasks_backend::{noop_backing_storage, BackendOptions, TurboTasksBackend};
 use turbo_tasks_fs::FileContent;
 use turbopack_core::{
     issue::{PlainIssue, PlainIssueSource, PlainSource},
     source_pos::SourcePos as SourcePosInner,
     version::{PartialUpdate, TotalUpdate, Update, Version, VersionState},
 };
-use wasm_bindgen::{JsValue, prelude::wasm_bindgen};
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
 use crate::fs::Fs;
 use crate::tokio_runtime::runtime;
diff --git a/crates/utoo-wasm/src/project.rs b/crates/utoo-wasm/src/project.rs
index ab4bf50fb..4a653b3d3 100644
--- a/crates/utoo-wasm/src/project.rs
+++ b/crates/utoo-wasm/src/project.rs
@@ -9,7 +9,7 @@ use parking_lot::RwLock;
 use wasm_bindgen::prelude::*;
 
 use crate::errors::to_js_error;
-use crate::pm::{self, OPFS_PROJECT, with_project};
+use crate::pm::{self, with_project, OPFS_PROJECT};
 use crate::tokio_runtime::init_tokio_runtime;
 
 #[cfg(feature = "utoopack")]

From 8f309979cda8f146e3c0ceab152e7f5d619c8100 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Wed, 22 Jul 2026 11:36:26 +0800
Subject: [PATCH 08/11] fix(pack): stabilize HMR CI coverage

---
 .../output/input_index_83022b3b.js            |   5 -
 .../output/chunks/input_index_83022b3b.dev.js |   5 -
 .../chunks/input_message_6ccb1ced.dev.js      |   5 +-
 .../chunks/input_message_807614c3.dev.js      |   5 -
 .../output/_root-of-the-server___7c304173.js  |   8 +-
 .../output/input_index_83022b3b.js            |   4 +-
 .../hmr/dynamic_chunk_lists/output/main.js    | 165 +--
 .../output/main.js                            | 165 +--
 .../runtime/app_dev_runtime/output/main.js    | 996 ++++++++++++++++--
 .../app_dev_runtime/output/main.js.map        |   6 +-
 .../output/input_index_83022b3b.js            |   5 -
 .../output/input_index_tsx_83022b3b.js        |   5 -
 e2e/pack-hmr/pack-hmr.spec.ts                 |  40 +-
 13 files changed, 1157 insertions(+), 257 deletions(-)
 delete mode 100644 crates/pack-tests/tests/snapshot/basic/asset_module_filename_dev/output/input_index_83022b3b.js
 delete mode 100644 crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js
 delete mode 100644 crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js
 delete mode 100644 crates/pack-tests/tests/snapshot/style/css_filename_dev/output/input_index_83022b3b.js
 delete mode 100644 crates/pack-tests/tests/snapshot/style/emotion_dev/output/input_index_tsx_83022b3b.js

diff --git a/crates/pack-tests/tests/snapshot/basic/asset_module_filename_dev/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/basic/asset_module_filename_dev/output/input_index_83022b3b.js
deleted file mode 100644
index 89de5ef6f..000000000
--- a/crates/pack-tests/tests/snapshot/basic/asset_module_filename_dev/output/input_index_83022b3b.js
+++ /dev/null
@@ -1,5 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["input_0e1f1939.js"],
-    source: "entry"
-});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js
deleted file mode 100644
index 65d1cff1d..000000000
--- a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_index_83022b3b.dev.js
+++ /dev/null
@@ -1,5 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["chunks/input_message_6ccb1ced.dev.js","chunks/input_index_c388c1fc.dev.js"],
-    source: "entry"
-});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js
index a9f16d6a2..698492c3c 100644
--- a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js
+++ b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_6ccb1ced.dev.js
@@ -3,11 +3,10 @@
 
 __turbopack_context__.v((parentImport) => {
     return Promise.all([
-  "chunks/input_message_7d12845b.dev.js",
-  "chunks/input_message_807614c3.dev.js"
+  "chunks/input_message_7d12845b.dev.js"
 ].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
         return parentImport("[project]/basic/js_filename_dev/input/message.js [client] (ecmascript)");
     });
 });
 }),
-]);
\ No newline at end of file
+]);
diff --git a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js b/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js
deleted file mode 100644
index 68a701eda..000000000
--- a/crates/pack-tests/tests/snapshot/basic/js_filename_dev/output/chunks/input_message_807614c3.dev.js
+++ /dev/null
@@ -1,5 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["chunks/input_message_7d12845b.dev.js"],
-    source: "dynamic"
-});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
index 2f7535bae..83dc4c3af 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
@@ -5,7 +5,7 @@
 __turbopack_context__.s([]);
 var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/hmr/client.ts [client] (ecmascript)");
 ;
-(0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["initHMR"])();
+(0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["initHMR"])("TURBOPACK_CHUNK_UPDATE_LISTENERS");
 if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
     __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
 }
@@ -22,12 +22,12 @@ var __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$c
 var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/hmr/websocket.ts [client] (ecmascript)");
 ;
 ;
-function initHMR() {
+function initHMR(chunkUpdateListenersGlobal = "TURBOPACK_CHUNK_UPDATE_LISTENERS") {
     (0, __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["connect"])({
         addMessageListener: __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["addMessageListener"],
         sendMessage: __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["sendMessage"],
         onUpdateError: console.error,
-        chunkUpdateListenersGlobal: __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL"]
+        chunkUpdateListenersGlobal
     });
     (0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["connectHMR"])({
         path: "/turbopack-hmr"
@@ -1329,4 +1329,4 @@ function triggerUpdate(msg, skippedCallbacks) {
     return completions;
 }
 }),
-]);
\ No newline at end of file
+]);
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
index eccaf0234..a5ebcc405 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
@@ -3,5 +3,5 @@
     chunks: ["input_lazy_b90c1087.js","_root-of-the-server___7c304173.js"],
     chunkVersions: {},
     source: "entry",
-    version: "VstQW4OIbsE"
-});
\ No newline at end of file
+    version: "eYoNAFE8+JU"
+});
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
index 4f6357a05..5df61b091 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
@@ -673,19 +673,6 @@ browserContextPrototype.l = loadChunk;
 function loadInitialChunk(chunkPath, chunkData) {
     return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
 }
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-/**
- * Dynamic chunk-list manifests have already done their own availability
- * calculation. Load the exact member URL for this manifest generation so an
- * older in-flight request cannot be reused by a replacement generation.
- */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
-    const memberChunkPath = getChunkPath(chunkData);
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
-}
 async function loadChunkInternal(sourceType, sourceData, chunkData) {
     if (typeof chunkData === 'string') {
         return loadChunkPath(sourceType, sourceData, chunkData);
@@ -882,21 +869,6 @@ function getPathFromScript(chunkScript) {
  * Determine the chunk to register. Note that this function has side-effects!
  */ function getChunkFromRegistration(chunk) {
     if (typeof chunk === 'string') {
-        if (typeof document !== 'undefined') {
-            const src = document.currentScript?.getAttribute('src');
-            if (src && getPathFromScript({
-                src
-            }) === chunk) {
-                return {
-                    src
-                };
-            }
-        }
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        }
         return chunk;
     } else if (!chunk) {
         if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
@@ -1674,7 +1646,6 @@ const pendingHmrTasks = [];
 const chunkListGenerations = new Map();
 let nextChunkListGeneration = 1;
 let activeHmrTask;
-const discardedChunkRegistrations = new Set();
 const dynamicMemberChunkUrlOwners = new Map();
 /**
  * Gets or instantiates a runtime module.
@@ -2398,15 +2369,12 @@ function terminateDynamicChunkListLoad(chunkListPath, state, error) {
     state.bootstrapping = false;
     state.terminated = true;
     state.rejectSubscribed?.(error);
-    BACKEND.rejectChunk?.(chunkListPath, error);
+    DEV_BACKEND.rejectChunk?.(chunkListPath, error);
     for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
         releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
     }
 }
 function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    // Reusing the same content-version URL is safe: a tombstone for an older
-    // generation represents identical content and must not discard this load.
-    discardedChunkRegistrations.delete(chunkUrl);
     let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
     if (!owners) {
         owners = new Map();
@@ -2422,9 +2390,8 @@ function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath,
     dynamicMemberChunkUrlOwners.delete(chunkUrl);
     if (isJs(chunkUrl)) {
         // Executed factories are already tracked by logical chunk ownership. The
-        // exact URL still needs a tombstone so a cancelled in-flight script cannot
-        // register stale factories after this generation has been discarded.
-        discardedChunkRegistrations.add(chunkUrl);
+        // exact URL is removed so a cancelled in-flight script cannot satisfy a
+        // later request for the same logical chunk.
         DEV_BACKEND.unloadChunkExact?.(chunkUrl);
     } else {
         const hasOtherChunkListOwner = [
@@ -2456,6 +2423,22 @@ function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken)
     }
     return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
 }
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+function isVersionedDynamicMemberChunkUrl(chunkUrl) {
+    return /(?:[?&])hmr=/.test(chunkUrl);
+}
+/**
+ * Dynamic chunk-list manifests have already done their own availability
+ * calculation. Load the exact member URL for this manifest generation so an
+ * older in-flight request cannot be reused by a replacement generation.
+ */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
+    const memberChunkPath = getChunkPath(chunkData);
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
+}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -2535,29 +2518,63 @@ function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken)
  */ function markChunkListAsRuntime(chunkListPath) {
     runtimeChunkLists.add(chunkListPath);
 }
+function getDevChunkFromRegistration(chunk) {
+    if (typeof chunk === 'string') {
+        if (typeof document !== 'undefined') {
+            const src = document.currentScript?.getAttribute('src');
+            if (src && getPathFromScript({
+                src
+            }) === chunk) {
+                return {
+                    src
+                };
+            }
+        }
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        }
+    }
+    return getChunkFromRegistration(chunk);
+}
 function registerChunk(registration) {
-    const chunk = getChunkFromRegistration(registration[0]);
+    const chunk = getDevChunkFromRegistration(registration[0]);
+    const chunkPath = getPathFromScript(chunk);
+    const chunkUrl = getUrlFromScript(chunk);
+    const canonicalChunkUrl = getChunkRelativeUrl(chunkPath);
     let runtimeParams;
     // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
     if (registration.length === 2) {
         runtimeParams = registration[1];
     } else {
-        let chunkPath = getPathFromScript(chunk);
-        const chunkUrl = getUrlFromScript(chunk);
         runtimeParams = undefined;
-        if (discardedChunkRegistrations.delete(chunkUrl)) {
-            const result = BACKEND.registerChunk(chunk, runtimeParams);
+        if (chunkUrl !== canonicalChunkUrl && isVersionedDynamicMemberChunkUrl(chunkUrl) && !dynamicMemberChunkUrlOwners.has(chunkUrl)) {
+            // Registration can race with cancellation even after its script element
+            // was removed. Only a live owner may install this content-versioned
+            // chunk; a later owner of the same URL is safe because its content is
+            // identical.
             DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-            return result;
+            return;
         }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
-    return BACKEND.registerChunk(chunk, runtimeParams);
+    if (runtimeParams === undefined && chunkUrl !== canonicalChunkUrl && DEV_BACKEND.resolveChunk) {
+        // Versioned development chunks have their own resolver. Resolving the
+        // canonical path here could let an older generation wake a newer load.
+        DEV_BACKEND.resolveChunk(chunkUrl);
+        return;
+    }
+    const result = BACKEND.registerChunk(chunk, runtimeParams);
+    if (chunkUrl !== canonicalChunkUrl) {
+        DEV_BACKEND.resolveChunk?.(chunkUrl);
+    }
+    return result;
 }
 /**
  * Subscribes to chunk list updates from the update server and applies them.
  */ function registerChunkList(chunkList) {
-    const chunkListScript = getChunkFromRegistration(chunkList.script);
+    const chunkListScript = getDevChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
     const generation = nextChunkListGeneration++;
     chunkListGenerations.set(chunkListPath, generation);
@@ -2584,7 +2601,7 @@ function registerChunk(registration) {
         // instead of waiting forever for an onSubscribed acknowledgement.
         void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
             const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
-            BACKEND.rejectChunk?.(chunkListPath, error);
+            DEV_BACKEND.rejectChunk?.(chunkListPath, error);
         });
         return;
     }
@@ -2709,7 +2726,7 @@ let BACKEND;
     BACKEND = {
         async registerChunk (chunk, params) {
             let chunkPath = getPathFromScript(chunk);
-            let chunkUrl = getUrlFromScript(chunk);
+            let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
             if (params == null) {
@@ -2734,13 +2751,6 @@ let BACKEND;
      * has been loaded.
      */ loadChunkCached (sourceType, chunkUrl) {
             return doLoadChunk(sourceType, chunkUrl);
-        },
-        rejectChunk (chunkPath, error) {
-            const chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = chunkResolvers.get(chunkUrl);
-            if (resolver) {
-                rejectChunkResolver(chunkUrl, resolver, error);
-            }
         }
     };
     function getOrCreateResolver(chunkUrl) {
@@ -2964,9 +2974,7 @@ let DEV_BACKEND;
             const decodedChunkUrl = decodeURI(chunkUrl);
             const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
             const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-            const load = exactLinks.length > 0 || baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>BACKEND.registerChunk({
-                    src: chunkUrl
-                }));
+            const load = exactLinks.length > 0 ? resolveChunkResolver(chunkUrl) : baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>resolveChunkResolver(chunkUrl));
             replacingCssLoads.set(chunkUrl, load);
             void load.then(()=>{
                 if (replacingCssLoads.get(chunkUrl) === load) {
@@ -2985,6 +2993,14 @@ let DEV_BACKEND;
         unloadChunkExact (chunkUrl) {
             unloadChunk(chunkUrl, true);
         },
+        rejectChunk (chunkPath, error) {
+            const chunkUrl = getUrlFromScript(chunkPath);
+            const resolver = chunkResolvers.get(chunkUrl);
+            if (resolver) rejectResolver(chunkUrl, resolver, error);
+        },
+        resolveChunk (chunkUrl) {
+            resolveChunkResolver(chunkUrl);
+        },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
                 if (!isCss(chunkUrl)) {
@@ -3076,6 +3092,37 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
+    function rejectResolver(chunkUrl, resolver, error) {
+        if (chunkResolvers.get(chunkUrl) === resolver) {
+            chunkResolvers.delete(chunkUrl);
+        }
+        resolver.reject(error);
+    }
+    function resolveChunkResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                retryAttempts: 0,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        resolver.resolve();
+        return resolver.promise;
+    }
     function unloadChunk(chunkUrl, exact) {
         deleteResolvers(chunkUrl, exact);
         const baseChunkUrl = chunkUrl.split('?')[0];
@@ -3096,7 +3143,7 @@ let DEV_BACKEND;
         const path = exact ? chunkUrl : baseChunkUrl;
         const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
         if (isCss(chunkUrl)) {
-            const links = document.querySelectorAll(exact ? `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]` : `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
+            const links = document.querySelectorAll(`link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
             for (const link of Array.from(links)){
                 link.remove();
             }
@@ -3104,7 +3151,7 @@ let DEV_BACKEND;
             // Unloading a JS chunk would have no effect once it has executed, but
             // removing the exact stale registration keeps the DOM and resolver cache
             // bounded without touching a newer generation of the same chunk path.
-            const scripts = document.querySelectorAll(exact ? `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]` : `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
+            const scripts = document.querySelectorAll(`script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
             for (const script of Array.from(scripts)){
                 script.remove();
             }
@@ -3123,7 +3170,7 @@ let DEV_BACKEND;
             if (resolver.resolved) {
                 chunkResolvers.delete(resolverUrl);
             } else {
-                rejectChunkResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
+                rejectResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
             }
         }
     }
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
index 9dcab2660..c1bc0b043 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
@@ -673,19 +673,6 @@ browserContextPrototype.l = loadChunk;
 function loadInitialChunk(chunkPath, chunkData) {
     return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
 }
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-/**
- * Dynamic chunk-list manifests have already done their own availability
- * calculation. Load the exact member URL for this manifest generation so an
- * older in-flight request cannot be reused by a replacement generation.
- */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
-    const memberChunkPath = getChunkPath(chunkData);
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
-}
 async function loadChunkInternal(sourceType, sourceData, chunkData) {
     if (typeof chunkData === 'string') {
         return loadChunkPath(sourceType, sourceData, chunkData);
@@ -882,21 +869,6 @@ function getPathFromScript(chunkScript) {
  * Determine the chunk to register. Note that this function has side-effects!
  */ function getChunkFromRegistration(chunk) {
     if (typeof chunk === 'string') {
-        if (typeof document !== 'undefined') {
-            const src = document.currentScript?.getAttribute('src');
-            if (src && getPathFromScript({
-                src
-            }) === chunk) {
-                return {
-                    src
-                };
-            }
-        }
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        }
         return chunk;
     } else if (!chunk) {
         if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
@@ -1674,7 +1646,6 @@ const pendingHmrTasks = [];
 const chunkListGenerations = new Map();
 let nextChunkListGeneration = 1;
 let activeHmrTask;
-const discardedChunkRegistrations = new Set();
 const dynamicMemberChunkUrlOwners = new Map();
 /**
  * Gets or instantiates a runtime module.
@@ -2398,15 +2369,12 @@ function terminateDynamicChunkListLoad(chunkListPath, state, error) {
     state.bootstrapping = false;
     state.terminated = true;
     state.rejectSubscribed?.(error);
-    BACKEND.rejectChunk?.(chunkListPath, error);
+    DEV_BACKEND.rejectChunk?.(chunkListPath, error);
     for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
         releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
     }
 }
 function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    // Reusing the same content-version URL is safe: a tombstone for an older
-    // generation represents identical content and must not discard this load.
-    discardedChunkRegistrations.delete(chunkUrl);
     let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
     if (!owners) {
         owners = new Map();
@@ -2422,9 +2390,8 @@ function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath,
     dynamicMemberChunkUrlOwners.delete(chunkUrl);
     if (isJs(chunkUrl)) {
         // Executed factories are already tracked by logical chunk ownership. The
-        // exact URL still needs a tombstone so a cancelled in-flight script cannot
-        // register stale factories after this generation has been discarded.
-        discardedChunkRegistrations.add(chunkUrl);
+        // exact URL is removed so a cancelled in-flight script cannot satisfy a
+        // later request for the same logical chunk.
         DEV_BACKEND.unloadChunkExact?.(chunkUrl);
     } else {
         const hasOtherChunkListOwner = [
@@ -2456,6 +2423,22 @@ function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken)
     }
     return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
 }
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+function isVersionedDynamicMemberChunkUrl(chunkUrl) {
+    return /(?:[?&])hmr=/.test(chunkUrl);
+}
+/**
+ * Dynamic chunk-list manifests have already done their own availability
+ * calculation. Load the exact member URL for this manifest generation so an
+ * older in-flight request cannot be reused by a replacement generation.
+ */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
+    const memberChunkPath = getChunkPath(chunkData);
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
+}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -2535,29 +2518,63 @@ function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken)
  */ function markChunkListAsRuntime(chunkListPath) {
     runtimeChunkLists.add(chunkListPath);
 }
+function getDevChunkFromRegistration(chunk) {
+    if (typeof chunk === 'string') {
+        if (typeof document !== 'undefined') {
+            const src = document.currentScript?.getAttribute('src');
+            if (src && getPathFromScript({
+                src
+            }) === chunk) {
+                return {
+                    src
+                };
+            }
+        }
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        }
+    }
+    return getChunkFromRegistration(chunk);
+}
 function registerChunk(registration) {
-    const chunk = getChunkFromRegistration(registration[0]);
+    const chunk = getDevChunkFromRegistration(registration[0]);
+    const chunkPath = getPathFromScript(chunk);
+    const chunkUrl = getUrlFromScript(chunk);
+    const canonicalChunkUrl = getChunkRelativeUrl(chunkPath);
     let runtimeParams;
     // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
     if (registration.length === 2) {
         runtimeParams = registration[1];
     } else {
-        let chunkPath = getPathFromScript(chunk);
-        const chunkUrl = getUrlFromScript(chunk);
         runtimeParams = undefined;
-        if (discardedChunkRegistrations.delete(chunkUrl)) {
-            const result = BACKEND.registerChunk(chunk, runtimeParams);
+        if (chunkUrl !== canonicalChunkUrl && isVersionedDynamicMemberChunkUrl(chunkUrl) && !dynamicMemberChunkUrlOwners.has(chunkUrl)) {
+            // Registration can race with cancellation even after its script element
+            // was removed. Only a live owner may install this content-versioned
+            // chunk; a later owner of the same URL is safe because its content is
+            // identical.
             DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-            return result;
+            return;
         }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
-    return BACKEND.registerChunk(chunk, runtimeParams);
+    if (runtimeParams === undefined && chunkUrl !== canonicalChunkUrl && DEV_BACKEND.resolveChunk) {
+        // Versioned development chunks have their own resolver. Resolving the
+        // canonical path here could let an older generation wake a newer load.
+        DEV_BACKEND.resolveChunk(chunkUrl);
+        return;
+    }
+    const result = BACKEND.registerChunk(chunk, runtimeParams);
+    if (chunkUrl !== canonicalChunkUrl) {
+        DEV_BACKEND.resolveChunk?.(chunkUrl);
+    }
+    return result;
 }
 /**
  * Subscribes to chunk list updates from the update server and applies them.
  */ function registerChunkList(chunkList) {
-    const chunkListScript = getChunkFromRegistration(chunkList.script);
+    const chunkListScript = getDevChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
     const generation = nextChunkListGeneration++;
     chunkListGenerations.set(chunkListPath, generation);
@@ -2584,7 +2601,7 @@ function registerChunk(registration) {
         // instead of waiting forever for an onSubscribed acknowledgement.
         void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
             const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
-            BACKEND.rejectChunk?.(chunkListPath, error);
+            DEV_BACKEND.rejectChunk?.(chunkListPath, error);
         });
         return;
     }
@@ -2709,7 +2726,7 @@ let BACKEND;
     BACKEND = {
         async registerChunk (chunk, params) {
             let chunkPath = getPathFromScript(chunk);
-            let chunkUrl = getUrlFromScript(chunk);
+            let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
             if (params == null) {
@@ -2734,13 +2751,6 @@ let BACKEND;
      * has been loaded.
      */ loadChunkCached (sourceType, chunkUrl) {
             return doLoadChunk(sourceType, chunkUrl);
-        },
-        rejectChunk (chunkPath, error) {
-            const chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = chunkResolvers.get(chunkUrl);
-            if (resolver) {
-                rejectChunkResolver(chunkUrl, resolver, error);
-            }
         }
     };
     function getOrCreateResolver(chunkUrl) {
@@ -2964,9 +2974,7 @@ let DEV_BACKEND;
             const decodedChunkUrl = decodeURI(chunkUrl);
             const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
             const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-            const load = exactLinks.length > 0 || baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>BACKEND.registerChunk({
-                    src: chunkUrl
-                }));
+            const load = exactLinks.length > 0 ? resolveChunkResolver(chunkUrl) : baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>resolveChunkResolver(chunkUrl));
             replacingCssLoads.set(chunkUrl, load);
             void load.then(()=>{
                 if (replacingCssLoads.get(chunkUrl) === load) {
@@ -2985,6 +2993,14 @@ let DEV_BACKEND;
         unloadChunkExact (chunkUrl) {
             unloadChunk(chunkUrl, true);
         },
+        rejectChunk (chunkPath, error) {
+            const chunkUrl = getUrlFromScript(chunkPath);
+            const resolver = chunkResolvers.get(chunkUrl);
+            if (resolver) rejectResolver(chunkUrl, resolver, error);
+        },
+        resolveChunk (chunkUrl) {
+            resolveChunkResolver(chunkUrl);
+        },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
                 if (!isCss(chunkUrl)) {
@@ -3076,6 +3092,37 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
+    function rejectResolver(chunkUrl, resolver, error) {
+        if (chunkResolvers.get(chunkUrl) === resolver) {
+            chunkResolvers.delete(chunkUrl);
+        }
+        resolver.reject(error);
+    }
+    function resolveChunkResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                retryAttempts: 0,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        resolver.resolve();
+        return resolver.promise;
+    }
     function unloadChunk(chunkUrl, exact) {
         deleteResolvers(chunkUrl, exact);
         const baseChunkUrl = chunkUrl.split('?')[0];
@@ -3096,7 +3143,7 @@ let DEV_BACKEND;
         const path = exact ? chunkUrl : baseChunkUrl;
         const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
         if (isCss(chunkUrl)) {
-            const links = document.querySelectorAll(exact ? `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]` : `link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
+            const links = document.querySelectorAll(`link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
             for (const link of Array.from(links)){
                 link.remove();
             }
@@ -3104,7 +3151,7 @@ let DEV_BACKEND;
             // Unloading a JS chunk would have no effect once it has executed, but
             // removing the exact stale registration keeps the DOM and resolver cache
             // bounded without touching a newer generation of the same chunk path.
-            const scripts = document.querySelectorAll(exact ? `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]` : `script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
+            const scripts = document.querySelectorAll(`script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
             for (const script of Array.from(scripts)){
                 script.remove();
             }
@@ -3123,7 +3170,7 @@ let DEV_BACKEND;
             if (resolver.resolved) {
                 chunkResolvers.delete(resolverUrl);
             } else {
-                rejectChunkResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
+                rejectResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
             }
         }
     }
diff --git a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js
index 10a712bf1..6b13b9e4a 100644
--- a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js
+++ b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js
@@ -1641,6 +1641,12 @@ function getRefreshBoundaryExports(exports) {
 /**
  * Map from a chunk path to the chunk lists it belongs to.
  */ const chunkChunkListsMap = new Map();
+const dynamicChunkListLoadStates = new Map();
+const pendingHmrTasks = [];
+const chunkListGenerations = new Map();
+let nextChunkListGeneration = 1;
+let activeHmrTask;
+const dynamicMemberChunkUrlOwners = new Map();
 /**
  * Gets or instantiates a runtime module.
  */ // @ts-ignore
@@ -1790,48 +1796,259 @@ const DUMMY_REFRESH_CONTEXT = {
         disposedModules
     };
 }
-function applyUpdate(update) {
-    switch(update.type){
-        case 'ChunkListUpdate':
-            applyChunkListUpdate(update);
-            break;
-        default:
-            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+const PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict');
+function mergeParallelChunkUpdate(updateA, updateB) {
+    if (updateA.type === updateB.type) {
+        return updateA;
+    }
+    if (updateA.type === 'total' || updateB.type === 'total') {
+        return {
+            type: 'total'
+        };
+    }
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        return null;
     }
+    return PARALLEL_UPDATE_CONFLICT;
 }
-function applyChunkListUpdate(update) {
-    if (update.merged != null) {
-        for (const merged of update.merged){
-            switch(merged.type){
-                case 'EcmascriptMergedUpdate':
-                    applyEcmascriptMergedUpdate(merged);
-                    break;
-                default:
-                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+function mergeParallelEcmascriptChunkUpdate(updateA, updateB) {
+    if (updateA.type === 'added' && updateB.type === 'added') {
+        return {
+            type: 'added',
+            modules: [
+                ...new Set([
+                    ...updateA.modules ?? [],
+                    ...updateB.modules ?? []
+                ])
+            ]
+        };
+    }
+    if (updateA.type === 'deleted' && updateB.type === 'deleted') {
+        return {
+            type: 'deleted',
+            modules: [
+                ...new Set([
+                    ...updateA.modules ?? [],
+                    ...updateB.modules ?? []
+                ])
+            ]
+        };
+    }
+    if (updateA.type === 'partial' && updateB.type === 'partial') {
+        const added = new Set([
+            ...updateA.added ?? [],
+            ...updateB.added ?? []
+        ]);
+        const deleted = new Set([
+            ...updateA.deleted ?? [],
+            ...updateB.deleted ?? []
+        ]);
+        for (const moduleId of added){
+            if (deleted.has(moduleId)) {
+                added.delete(moduleId);
+                deleted.delete(moduleId);
             }
         }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
     }
-    if (update.chunks != null) {
-        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-            const chunkUrl = getChunkRelativeUrl(chunkPath);
-            switch(chunkUpdate.type){
-                case 'added':
-                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
-                    break;
-                case 'total':
-                    DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    break;
-                case 'deleted':
-                    DEV_BACKEND.unloadChunk?.(chunkUrl);
-                    break;
-                case 'partial':
-                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                    break;
-                default:
-                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
+        const addedUpdate = updateA.type === 'added' ? updateA : updateB;
+        const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB;
+        const added = new Set(addedUpdate.modules ?? []);
+        const deleted = new Set(deletedUpdate.modules ?? []);
+        for (const moduleId of added){
+            if (deleted.has(moduleId)) {
+                added.delete(moduleId);
+                deleted.delete(moduleId);
+            }
+        }
+        return {
+            type: 'partial',
+            added: [
+                ...added
+            ],
+            deleted: [
+                ...deleted
+            ]
+        };
+    }
+    if (updateA.type === 'partial') {
+        if ((updateA.added?.length ?? 0) === 0 && (updateA.deleted?.length ?? 0) === 0) {
+            return updateB;
+        }
+        return PARALLEL_UPDATE_CONFLICT;
+    }
+    if (updateB.type === 'partial') {
+        if ((updateB.added?.length ?? 0) === 0 && (updateB.deleted?.length ?? 0) === 0) {
+            return updateA;
+        }
+        return PARALLEL_UPDATE_CONFLICT;
+    }
+    return PARALLEL_UPDATE_CONFLICT;
+}
+function moduleEntriesEqual(entryA, entryB) {
+    // The same module can be emitted into multiple chunks. Its source URL is
+    // chunk-relative, so it is allowed to differ even when the executable entry
+    // is identical. Treat only code and source map differences as conflicts.
+    return entryA.code === entryB.code && entryA.map === entryB.map;
+}
+function applyChunkListUpdates(updates) {
+    const resourceOperations = [];
+    const ownershipTransitions = new Map();
+    const chunks = new Map();
+    const ecmascriptChunks = new Map();
+    const entries = {};
+    const explicitlyModifiedModules = new Set();
+    let hasConflict = false;
+    for (const { chunkListPath, update } of updates){
+        if (update.chunks) {
+            for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+                if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, chunkUpdate.type, ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                }
+                if (!chunks.has(chunkPath)) {
+                    chunks.set(chunkPath, chunkUpdate);
+                } else {
+                    const previous = chunks.get(chunkPath);
+                    if (previous === null) {
+                        chunks.set(chunkPath, chunkUpdate);
+                    } else {
+                        const merged = mergeParallelChunkUpdate(previous, chunkUpdate);
+                        if (merged === PARALLEL_UPDATE_CONFLICT) {
+                            hasConflict = true;
+                        } else {
+                            chunks.set(chunkPath, merged);
+                        }
+                    }
+                }
+            }
+        }
+        for (const merged of update.merged ?? []){
+            if (merged.type !== 'EcmascriptMergedUpdate') {
+                invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
             }
+            const addedInThisUpdate = new Set();
+            for (const [chunkPath, chunkUpdate] of Object.entries(merged.chunks ?? {})){
+                if (chunkUpdate.type === 'added') {
+                    for (const moduleId of chunkUpdate.modules ?? []){
+                        addedInThisUpdate.add(moduleId);
+                    }
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'added', ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                } else if (chunkUpdate.type === 'deleted') {
+                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'deleted', ownershipTransitions)) {
+                        hasConflict = true;
+                    }
+                } else {
+                    for (const moduleId of chunkUpdate.added ?? []){
+                        addedInThisUpdate.add(moduleId);
+                    }
+                }
+                const previous = ecmascriptChunks.get(chunkPath);
+                if (!previous) {
+                    ecmascriptChunks.set(chunkPath, chunkUpdate);
+                } else {
+                    const combined = mergeParallelEcmascriptChunkUpdate(previous, chunkUpdate);
+                    if (combined === PARALLEL_UPDATE_CONFLICT) {
+                        hasConflict = true;
+                    } else {
+                        ecmascriptChunks.set(chunkPath, combined);
+                    }
+                }
+            }
+            for (const [moduleId, entry] of Object.entries(merged.entries ?? {})){
+                const previous = entries[moduleId];
+                if (previous) {
+                    if (!moduleEntriesEqual(previous, entry)) {
+                        hasConflict = true;
+                    }
+                } else {
+                    entries[moduleId] = entry;
+                }
+                if (!addedInThisUpdate.has(moduleId)) {
+                    explicitlyModifiedModules.add(moduleId);
+                }
+            }
+        }
+    }
+    if (hasConflict) {
+        DEV_BACKEND.restart();
+        return resourceOperations;
+    }
+    const filteredEcmascriptChunks = {};
+    for (const [chunkPath, chunkUpdate] of ecmascriptChunks){
+        const transition = ownershipTransitions.get(chunkPath);
+        if (chunkUpdate.type === 'added' && transition && transition.before > 0) {
+            for (const moduleId of chunkUpdate.modules ?? []){
+                if (!explicitlyModifiedModules.has(moduleId)) {
+                    delete entries[moduleId];
+                }
+            }
+            continue;
+        }
+        if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {
+            continue;
+        }
+        filteredEcmascriptChunks[chunkPath] = chunkUpdate;
+    }
+    if (Object.keys(entries).length > 0 || Object.keys(filteredEcmascriptChunks).length > 0) {
+        applyEcmascriptMergedUpdate({
+            type: 'EcmascriptMergedUpdate',
+            entries,
+            chunks: filteredEcmascriptChunks
+        });
+    }
+    for (const [chunkPath, chunkUpdate] of chunks){
+        if (chunkUpdate === null) {
+            continue;
+        }
+        const transition = ownershipTransitions.get(chunkPath);
+        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+        const chunkUrl = getChunkRelativeUrl(chunkPath);
+        switch(chunkUpdate.type){
+            case 'added':
+                if (!transition || transition.before === 0 && transition.after > 0) {
+                    resourceOperations.push({
+                        chunkPath,
+                        promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl)
+                    });
+                }
+                break;
+            case 'total':
+                if (ownerCount > 0) {
+                    const promise = DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    if (promise) {
+                        resourceOperations.push({
+                            chunkPath,
+                            promise
+                        });
+                    }
+                }
+                break;
+            case 'deleted':
+                if (!transition || transition.before > 0 && transition.after === 0) {
+                    disposeChunk(chunkPath);
+                }
+                break;
+            case 'partial':
+                invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                break;
+            default:
+                invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
         }
     }
+    return resourceOperations;
 }
 function applyEcmascriptMergedUpdate(update) {
     // Browser-specific chunk management phase
@@ -1851,13 +2068,196 @@ function applyEcmascriptMergedUpdate(update) {
         autoAcceptRootModules: false
     });
 }
+function getCurrentTaskPaths(task) {
+    return task.chunkLists.filter(({ path, generation })=>chunkListGenerations.get(path) === generation).map(({ path })=>path);
+}
+function isHmrTaskBlocked(task) {
+    return task.chunkLists.some(({ path, generation })=>{
+        if (chunkListGenerations.get(path) !== generation) return false;
+        const state = dynamicChunkListLoadStates.get(path);
+        return state?.generation === generation && state.loading;
+    });
+}
+function runHmrTask(task) {
+    activeHmrTask = task;
+    void (async ()=>{
+        let resourceOperations = [];
+        try {
+            const currentPaths = new Set(getCurrentTaskPaths(task));
+            if (currentPaths.size > 0) {
+                resourceOperations = task.apply(currentPaths);
+                const results = await Promise.allSettled(resourceOperations.map(({ promise })=>promise));
+                const failedIndex = results.findIndex((result, index)=>result.status === 'rejected' && chunkChunkListsMap.has(resourceOperations[index].chunkPath));
+                if (failedIndex !== -1) {
+                    throw results[failedIndex].reason;
+                }
+            }
+            task.resolve();
+        } catch (cause) {
+            // A terminal update invalidates the generation immediately. Any member
+            // request it cancelled belongs to that old generation and must not turn
+            // a valid replacement subscription into a page reload.
+            if (getCurrentTaskPaths(task).length === 0) {
+                task.resolve();
+            } else {
+                task.reject(cause);
+            }
+        } finally{
+            for (const { chunkPath } of resourceOperations){
+                if (!chunkChunkListsMap.has(chunkPath)) {
+                    disposeChunk(chunkPath);
+                }
+            }
+            if (activeHmrTask === task) {
+                activeHmrTask = undefined;
+            }
+            flushPendingHmrTasks();
+        }
+    })();
+}
+function scheduleHmrTask(chunkListPaths, apply) {
+    const chunkLists = [
+        ...new Set(chunkListPaths)
+    ].flatMap((path)=>{
+        const generation = chunkListGenerations.get(path);
+        return generation === undefined ? [] : [
+            {
+                path,
+                generation
+            }
+        ];
+    });
+    if (chunkLists.length === 0) {
+        return Promise.resolve();
+    }
+    let resolve;
+    let reject;
+    const completion = new Promise((innerResolve, innerReject)=>{
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    const task = {
+        chunkLists,
+        apply,
+        resolve,
+        reject
+    };
+    for (const { path, generation } of chunkLists){
+        const state = dynamicChunkListLoadStates.get(path);
+        if (state?.generation === generation && state.bootstrapping && !state.terminated) {
+            state.pendingTasks.add(completion);
+            void completion.then(()=>state.pendingTasks.delete(completion), ()=>state.pendingTasks.delete(completion));
+        }
+    }
+    if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {
+        pendingHmrTasks.push(task);
+        flushPendingHmrTasks();
+    } else {
+        runHmrTask(task);
+    }
+    return completion;
+}
+function flushPendingHmrTasks() {
+    if (activeHmrTask) return;
+    while(pendingHmrTasks.length > 0){
+        const task = pendingHmrTasks[0];
+        if (getCurrentTaskPaths(task).length === 0) {
+            pendingHmrTasks.shift();
+            task.resolve();
+            continue;
+        }
+        if (isHmrTaskBlocked(task)) {
+            return;
+        }
+        pendingHmrTasks.shift();
+        runHmrTask(task);
+        return;
+    }
+}
+function handleApplyBatch(updates) {
+    const relevantUpdates = updates.map((update)=>({
+            chunkListPath: update.resource.path,
+            update: update.instruction
+        })).filter(({ chunkListPath })=>chunkListChunksMap.has(chunkListPath));
+    const chunkListPaths = [
+        ...new Set(relevantUpdates.map(({ chunkListPath })=>chunkListPath))
+    ];
+    if (chunkListPaths.length === 0) {
+        return {
+            handledPaths: []
+        };
+    }
+    const bootstrappingPaths = chunkListPaths.filter((chunkListPath)=>{
+        const state = dynamicChunkListLoadStates.get(chunkListPath);
+        return state?.bootstrapping && !state.terminated;
+    });
+    if (bootstrappingPaths.length > 0) {
+        for (const chunkListPath of bootstrappingPaths){
+            const state = dynamicChunkListLoadStates.get(chunkListPath);
+            terminateDynamicChunkListLoad(chunkListPath, state, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
+        }
+        DEV_BACKEND.restart();
+        flushPendingHmrTasks();
+        return {
+            handledPaths: chunkListPaths
+        };
+    }
+    const completion = scheduleHmrTask(chunkListPaths, (currentPaths)=>{
+        const chunkListUpdates = relevantUpdates.filter(({ chunkListPath })=>currentPaths.has(chunkListPath)).map(({ chunkListPath, update })=>{
+            if (update.type !== 'ChunkListUpdate') {
+                invariant(update, (update)=>`Unknown update type: ${update.type}`);
+            }
+            return {
+                chunkListPath,
+                update
+            };
+        });
+        return chunkListUpdates.length > 0 ? applyChunkListUpdates(chunkListUpdates) : [];
+    });
+    return {
+        handledPaths: chunkListPaths,
+        completion
+    };
+}
 function handleApply(chunkListPath, update) {
+    const loadState = dynamicChunkListLoadStates.get(chunkListPath);
+    if (update.type === 'partial' && loadState?.bootstrapping && !loadState.terminated) {
+        terminateDynamicChunkListLoad(chunkListPath, loadState, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
+        DEV_BACKEND.restart();
+        flushPendingHmrTasks();
+        return Promise.resolve();
+    }
+    if (update.type === 'notFound' || update.type === 'restart') {
+        if (loadState && !loadState.terminated) {
+            const error = new Error(update.type === 'notFound' ? `Dynamic chunk list ${chunkListPath} disappeared while loading.` : `Dynamic chunk list ${chunkListPath} must restart while loading.`);
+            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+        }
+        if (update.type === 'restart') {
+            chunkListGenerations.delete(chunkListPath);
+            dynamicChunkListLoadStates.delete(chunkListPath);
+        }
+        handleApplyImmediately(chunkListPath, update);
+        flushPendingHmrTasks();
+        return Promise.resolve();
+    }
+    return scheduleHmrTask([
+        chunkListPath
+    ], (currentPaths)=>currentPaths.has(chunkListPath) ? handleApplyImmediately(chunkListPath, update) : []);
+}
+function handleApplyImmediately(chunkListPath, update) {
     switch(update.type){
         case 'partial':
             {
                 // This indicates that the update is can be applied to the current state of the application.
-                applyUpdate(update.instruction);
-                break;
+                if (update.instruction.type !== 'ChunkListUpdate') {
+                    invariant(update.instruction, (instruction)=>`Unknown update type: ${instruction.type}`);
+                }
+                return applyChunkListUpdates([
+                    {
+                        chunkListPath,
+                        update: update.instruction
+                    }
+                ]);
             }
         case 'restart':
             {
@@ -1865,7 +2265,7 @@ function handleApply(chunkListPath, update) {
                 // current state of the application, and that the application must be
                 // restarted.
                 DEV_BACKEND.restart();
-                break;
+                return [];
             }
         case 'notFound':
             {
@@ -1878,12 +2278,73 @@ function handleApply(chunkListPath, update) {
                 } else {
                     disposeChunkList(chunkListPath);
                 }
-                break;
+                return [];
             }
         default:
             throw new Error(`Unknown update type: ${update.type}`);
     }
 }
+function applyChunkListMembershipDelta(chunkListPath, chunkPath, type, transitions) {
+    let transition = transitions.get(chunkPath);
+    if (!transition) {
+        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+        transition = {
+            before: ownerCount,
+            after: ownerCount
+        };
+        transitions.set(chunkPath, transition);
+    }
+    const changed = type === 'added' ? addChunkToChunkList(chunkListPath, chunkPath) : removeChunkFromChunkList(chunkListPath, chunkPath);
+    transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
+    return changed;
+}
+function addChunkToChunkList(chunkListPath, chunkPath) {
+    let chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (!chunkPaths) {
+        chunkPaths = new Set();
+        chunkListChunksMap.set(chunkListPath, chunkPaths);
+    }
+    if (chunkPaths.has(chunkPath)) {
+        return false;
+    }
+    chunkPaths.add(chunkPath);
+    let chunkLists = chunkChunkListsMap.get(chunkPath);
+    if (!chunkLists) {
+        chunkLists = new Set();
+        chunkChunkListsMap.set(chunkPath, chunkLists);
+    }
+    chunkLists.add(chunkListPath);
+    return true;
+}
+function removeChunkFromChunkList(chunkListPath, chunkPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    const chunkLists = chunkChunkListsMap.get(chunkPath);
+    if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {
+        return false;
+    }
+    chunkPaths.delete(chunkPath);
+    chunkLists.delete(chunkListPath);
+    if (chunkLists.size === 0) {
+        chunkChunkListsMap.delete(chunkPath);
+    }
+    return true;
+}
+function setChunkListChunks(chunkListPath, nextChunkPaths) {
+    const previousChunkPaths = new Set(chunkListChunksMap.get(chunkListPath) ?? []);
+    if (!chunkListChunksMap.has(chunkListPath)) {
+        chunkListChunksMap.set(chunkListPath, new Set());
+    }
+    for (const chunkPath of previousChunkPaths){
+        if (!nextChunkPaths.has(chunkPath) && removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+            disposeChunk(chunkPath);
+        }
+    }
+    for (const chunkPath of nextChunkPaths){
+        if (!previousChunkPaths.has(chunkPath)) {
+            addChunkToChunkList(chunkListPath, chunkPath);
+        }
+    }
+}
 /**
  * Removes a module from a chunk.
  * Returns `true` if there are no remaining chunks including this module.
@@ -1902,6 +2363,82 @@ function handleApply(chunkListPath, update) {
     }
     return noRemainingChunks;
 }
+function terminateDynamicChunkListLoad(chunkListPath, state, error) {
+    if (state.terminated) return;
+    state.loading = false;
+    state.bootstrapping = false;
+    state.terminated = true;
+    state.rejectSubscribed?.(error);
+    DEV_BACKEND.rejectChunk?.(chunkListPath, error);
+    for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
+        releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
+    }
+}
+function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
+    let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (!owners) {
+        owners = new Map();
+        dynamicMemberChunkUrlOwners.set(chunkUrl, owners);
+    }
+    owners.set(chunkListPath, generation);
+}
+function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath, chunkUrl) {
+    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (owners?.get(chunkListPath) !== generation) return;
+    owners.delete(chunkListPath);
+    if (owners.size > 0) return;
+    dynamicMemberChunkUrlOwners.delete(chunkUrl);
+    if (isJs(chunkUrl)) {
+        // Executed factories are already tracked by logical chunk ownership. The
+        // exact URL is removed so a cancelled in-flight script cannot satisfy a
+        // later request for the same logical chunk.
+        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+    } else {
+        const hasOtherChunkListOwner = [
+            ...chunkChunkListsMap.get(chunkPath) ?? []
+        ].some((owner)=>owner !== chunkListPath);
+        if (hasOtherChunkListOwner) return;
+        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+    }
+    if (!chunkChunkListsMap.has(chunkPath)) {
+        disposeChunk(chunkPath);
+    }
+}
+function completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
+    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
+    if (owners?.get(chunkListPath) !== generation) return;
+    owners.delete(chunkListPath);
+    if (owners.size === 0) {
+        dynamicMemberChunkUrlOwners.delete(chunkUrl);
+    }
+}
+function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken) {
+    const chunkPath = getChunkPath(chunkData);
+    const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken);
+    if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {
+        // A previous owner may have loaded an older content-version URL for the
+        // same stylesheet. Swap it only after the new CSS has loaded so dynamic
+        // lists never accumulate duplicate cascade entries.
+        return DEV_BACKEND.loadChunkReplacing(chunkUrl);
+    }
+    return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
+}
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+function isVersionedDynamicMemberChunkUrl(chunkUrl) {
+    return /(?:[?&])hmr=/.test(chunkUrl);
+}
+/**
+ * Dynamic chunk-list manifests have already done their own availability
+ * calculation. Load the exact member URL for this manifest generation so an
+ * older in-flight request cannot be reused by a replacement generation.
+ */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
+    const memberChunkPath = getChunkPath(chunkData);
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
+}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -1909,15 +2446,17 @@ function handleApply(chunkListPath, update) {
     if (chunkPaths == null) {
         return false;
     }
-    chunkListChunksMap.delete(chunkListPath);
-    for (const chunkPath of chunkPaths){
-        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        chunkChunkLists.delete(chunkListPath);
-        if (chunkChunkLists.size === 0) {
-            chunkChunkListsMap.delete(chunkPath);
+    for (const chunkPath of [
+        ...chunkPaths
+    ]){
+        if (removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
             disposeChunk(chunkPath);
         }
     }
+    chunkListChunksMap.delete(chunkListPath);
+    chunkListGenerations.delete(chunkListPath);
+    dynamicChunkListLoadStates.delete(chunkListPath);
+    runtimeChunkLists.delete(chunkListPath);
     // We must also dispose of the chunk list's chunk itself to ensure it may
     // be reloaded properly in the future.
     const chunkListUrl = getChunkRelativeUrl(chunkListPath);
@@ -1937,7 +2476,7 @@ function handleApply(chunkListPath, update) {
     if (chunkModules == null) {
         return false;
     }
-    chunkModules.delete(chunkPath);
+    chunkModulesMap.delete(chunkPath);
     for (const moduleId of chunkModules){
         const moduleChunks = moduleChunksMap.get(moduleId);
         moduleChunks.delete(chunkPath);
@@ -1979,47 +2518,192 @@ function handleApply(chunkListPath, update) {
  */ function markChunkListAsRuntime(chunkListPath) {
     runtimeChunkLists.add(chunkListPath);
 }
+function getDevChunkFromRegistration(chunk) {
+    if (typeof chunk === 'string') {
+        if (typeof document !== 'undefined') {
+            const src = document.currentScript?.getAttribute('src');
+            if (src && getPathFromScript({
+                src
+            }) === chunk) {
+                return {
+                    src
+                };
+            }
+        }
+        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+            return {
+                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
+            };
+        }
+    }
+    return getChunkFromRegistration(chunk);
+}
 function registerChunk(registration) {
-    const chunk = getChunkFromRegistration(registration[0]);
+    const chunk = getDevChunkFromRegistration(registration[0]);
+    const chunkPath = getPathFromScript(chunk);
+    const chunkUrl = getUrlFromScript(chunk);
+    const canonicalChunkUrl = getChunkRelativeUrl(chunkPath);
     let runtimeParams;
     // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
     if (registration.length === 2) {
         runtimeParams = registration[1];
     } else {
-        let chunkPath = getPathFromScript(chunk);
         runtimeParams = undefined;
+        if (chunkUrl !== canonicalChunkUrl && isVersionedDynamicMemberChunkUrl(chunkUrl) && !dynamicMemberChunkUrlOwners.has(chunkUrl)) {
+            // Registration can race with cancellation even after its script element
+            // was removed. Only a live owner may install this content-versioned
+            // chunk; a later owner of the same URL is safe because its content is
+            // identical.
+            DEV_BACKEND.unloadChunkExact?.(chunkUrl);
+            return;
+        }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
-    return BACKEND.registerChunk(chunk, runtimeParams);
+    if (runtimeParams === undefined && chunkUrl !== canonicalChunkUrl && DEV_BACKEND.resolveChunk) {
+        // Versioned development chunks have their own resolver. Resolving the
+        // canonical path here could let an older generation wake a newer load.
+        DEV_BACKEND.resolveChunk(chunkUrl);
+        return;
+    }
+    const result = BACKEND.registerChunk(chunk, runtimeParams);
+    if (chunkUrl !== canonicalChunkUrl) {
+        DEV_BACKEND.resolveChunk?.(chunkUrl);
+    }
+    return result;
 }
 /**
  * Subscribes to chunk list updates from the update server and applies them.
  */ function registerChunkList(chunkList) {
-    const chunkListScript = getChunkFromRegistration(chunkList.script);
+    const chunkListScript = getDevChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
-    // The "chunk" is also registered to finish the loading in the backend
-    BACKEND.registerChunk(chunkListPath);
-    CHUNK_UPDATE_LISTENERS.push([
-        chunkListPath,
-        handleApply.bind(null, chunkListPath)
-    ]);
-    // Adding chunks to chunk lists and vice versa.
+    const generation = nextChunkListGeneration++;
+    chunkListGenerations.set(chunkListPath, generation);
     const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    chunkListChunksMap.set(chunkListPath, chunkPaths);
-    for (const chunkPath of chunkPaths){
-        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        if (!chunkChunkLists) {
-            chunkChunkLists = new Set([
-                chunkListPath
-            ]);
-            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
-        } else {
-            chunkChunkLists.add(chunkListPath);
-        }
-    }
+    setChunkListChunks(chunkListPath, chunkPaths);
     if (chunkList.source === 'entry') {
+        // Entry chunks have already loaded their member chunks while bootstrapping.
+        // The "chunk" registration completes the backend's initial load.
+        BACKEND.registerChunk(chunkListPath);
         markChunkListAsRuntime(chunkListPath);
+        CHUNK_UPDATE_LISTENERS.push([
+            chunkListPath,
+            handleApply.bind(null, chunkListPath),
+            {
+                batch: handleApplyBatch,
+                expectedVersion: chunkList.version
+            }
+        ]);
+        return;
+    }
+    if (typeof document === 'undefined') {
+        // Workers currently have no HMR transport/provider. Keep the dynamic
+        // chunk-list as a lightweight bootstrap, but load its members directly
+        // instead of waiting forever for an onSubscribed acknowledgement.
+        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
+            const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
+            DEV_BACKEND.rejectChunk?.(chunkListPath, error);
+        });
+        return;
     }
+    // A dynamic chunk list is the bootstrap for its group. Establish the server
+    // baseline before fetching content, then hold updates while content loads.
+    // This closes the HTTP/WebSocket race where stale content could otherwise be
+    // fetched immediately before a newer subscription baseline was created.
+    const loadState = {
+        generation,
+        loading: true,
+        bootstrapping: true,
+        terminated: false,
+        pendingTasks: new Set(),
+        memberChunkUrls: new Map()
+    };
+    for (const chunkData of chunkList.chunks){
+        const chunkPath = getChunkPath(chunkData);
+        const chunkVersion = chunkList.chunkVersions[chunkPath];
+        if (chunkVersion === undefined) {
+            throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
+        }
+        const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion);
+        loadState.memberChunkUrls.set(chunkPath, chunkUrl);
+        addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
+    }
+    dynamicChunkListLoadStates.set(chunkListPath, loadState);
+    let resolveSubscribed;
+    let revalidateSubscription;
+    const subscribed = new Promise((resolve, reject)=>{
+        resolveSubscribed = resolve;
+        loadState.rejectSubscribed = reject;
+    });
+    CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath),
+        {
+            batch: handleApplyBatch,
+            onSubscribed: (revalidate)=>{
+                revalidateSubscription = revalidate;
+                resolveSubscribed();
+            },
+            expectedVersion: chunkList.version
+        }
+    ]);
+    void (async ()=>{
+        try {
+            await subscribed;
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            const memberResults = await Promise.allSettled(chunkList.chunks.map((chunkData)=>loadVersionedDynamicMemberChunk(chunkListPath, chunkData, chunkList.chunkVersions[getChunkPath(chunkData)])));
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                for (const chunkPath of chunkPaths){
+                    if (!chunkChunkListsMap.has(chunkPath)) {
+                        disposeChunk(chunkPath);
+                    }
+                }
+                return;
+            }
+            const failedMember = memberResults.find((result)=>result.status === 'rejected');
+            if (failedMember) {
+                throw failedMember.reason;
+            }
+            // The member URLs are served from the live output directory rather than
+            // a historical snapshot. Validate the manifest version again after all
+            // HTTP responses have completed, closing the subscription/HTTP race.
+            await revalidateSubscription();
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            for (const chunkUrl of loadState.memberChunkUrls.values()){
+                completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
+            }
+            loadState.loading = false;
+            flushPendingHmrTasks();
+            while(loadState.pendingTasks.size > 0){
+                await Promise.all([
+                    ...loadState.pendingTasks
+                ]);
+            }
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                for (const chunkPath of chunkPaths){
+                    if (!chunkChunkListsMap.has(chunkPath)) {
+                        disposeChunk(chunkPath);
+                    }
+                }
+                return;
+            }
+            // Resolving the bootstrap schedules the import continuation as a
+            // microtask. Every queued update and resource load has completed first,
+            // so user code cannot observe factories from an older manifest.
+            loadState.bootstrapping = false;
+            BACKEND.registerChunk(chunkListPath);
+        } catch (cause) {
+            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
+                return;
+            }
+            const error = cause instanceof Error ? cause : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`);
+            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+            DEV_BACKEND.restart();
+        }
+    })();
 }
 /**
  * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
@@ -2275,31 +2959,47 @@ let BACKEND;
 /// <reference path="../../../shared/require-type.d.ts" />
 let DEV_BACKEND;
 (()=>{
+    const pendingChunkReloads = new Map();
+    const replacingCssLoads = new Map();
     DEV_BACKEND = {
-        unloadChunk (chunkUrl) {
-            deleteResolver(chunkUrl);
-            // Strip query string so we match links regardless of cache-busting
-            // params (e.g. ?ts=) that may differ between HMR updates.
+        loadChunkReplacing (chunkUrl) {
+            if (!isCss(chunkUrl)) {
+                return Promise.reject(new Error(`Only CSS chunks can be replaced while loading: ${chunkUrl}`));
+            }
+            const existingLoad = replacingCssLoads.get(chunkUrl);
+            if (existingLoad) return existingLoad;
             const baseChunkUrl = chunkUrl.split('?')[0];
-            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
             const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            if (isCss(chunkUrl)) {
-                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
-                for (const link of Array.from(links)){
-                    link.remove();
+            const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?';
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
+            const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
+            const load = exactLinks.length > 0 ? resolveChunkResolver(chunkUrl) : baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>resolveChunkResolver(chunkUrl));
+            replacingCssLoads.set(chunkUrl, load);
+            void load.then(()=>{
+                if (replacingCssLoads.get(chunkUrl) === load) {
+                    replacingCssLoads.delete(chunkUrl);
                 }
-            } else if (isJs(chunkUrl)) {
-                // Unloading a JS chunk would have no effect, as it lives in the JS
-                // runtime once evaluated.
-                // However, we still want to remove the script tag from the DOM to keep
-                // the HTML somewhat consistent from the user's perspective.
-                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
-                for (const script of Array.from(scripts)){
-                    script.remove();
+            }, ()=>{
+                if (replacingCssLoads.get(chunkUrl) === load) {
+                    replacingCssLoads.delete(chunkUrl);
                 }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-            }
+            });
+            return load;
+        },
+        unloadChunk (chunkUrl) {
+            unloadChunk(chunkUrl, false);
+        },
+        unloadChunkExact (chunkUrl) {
+            unloadChunk(chunkUrl, true);
+        },
+        rejectChunk (chunkPath, error) {
+            const chunkUrl = getUrlFromScript(chunkPath);
+            const resolver = chunkResolvers.get(chunkUrl);
+            if (resolver) rejectResolver(chunkUrl, resolver, error);
+        },
+        resolveChunk (chunkUrl) {
+            resolveChunkResolver(chunkUrl);
         },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
@@ -2316,9 +3016,43 @@ let DEV_BACKEND;
                     reject(new Error(`No link element found for chunk ${chunkUrl}`));
                     return;
                 }
+                const currentReloads = pendingChunkReloads.get(baseChunkUrl);
+                if (currentReloads) {
+                    const suffix = chunkUrl.includes('?') ? '&' : '?';
+                    for (const reload of [
+                        ...currentReloads
+                    ]){
+                        const href = reload.link.getAttribute('href');
+                        if (href !== chunkUrl && !href?.startsWith(`${chunkUrl}${suffix}`)) {
+                            reload.reject(new Error(`CSS chunk ${chunkUrl} superseded an in-flight reload.`));
+                        }
+                    }
+                }
                 const link = document.createElement('link');
                 link.rel = 'stylesheet';
                 link.crossOrigin = CROSS_ORIGIN;
+                let pendingReloads = pendingChunkReloads.get(baseChunkUrl);
+                if (!pendingReloads) {
+                    pendingReloads = new Set();
+                    pendingChunkReloads.set(baseChunkUrl, pendingReloads);
+                }
+                const cleanup = ()=>{
+                    pendingReloads.delete(pendingReload);
+                    if (pendingReloads.size === 0) {
+                        pendingChunkReloads.delete(baseChunkUrl);
+                    }
+                };
+                const pendingReload = {
+                    link,
+                    reject: (error)=>{
+                        cleanup();
+                        link.onload = null;
+                        link.onerror = null;
+                        link.remove();
+                        reject(error);
+                    }
+                };
+                pendingReloads.add(pendingReload);
                 if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
                     // Firefox won't reload CSS files that were previously loaded on the
                     // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
@@ -2339,9 +3073,10 @@ let DEV_BACKEND;
                     link.href = chunkUrl;
                 }
                 link.onerror = ()=>{
-                    reject();
+                    pendingReload.reject(new Error(`Failed to reload CSS chunk ${chunkUrl}`));
                 };
                 link.onload = ()=>{
+                    cleanup();
                     // First load the new CSS, then remove the old ones. This prevents visible
                     // flickering that would happen in-between removing the previous CSS and
                     // loading the new one.
@@ -2357,8 +3092,87 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
-    function deleteResolver(chunkUrl) {
-        chunkResolvers.delete(chunkUrl);
+    function rejectResolver(chunkUrl, resolver, error) {
+        if (chunkResolvers.get(chunkUrl) === resolver) {
+            chunkResolvers.delete(chunkUrl);
+        }
+        resolver.reject(error);
+    }
+    function resolveChunkResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                retryAttempts: 0,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        resolver.resolve();
+        return resolver.promise;
+    }
+    function unloadChunk(chunkUrl, exact) {
+        deleteResolvers(chunkUrl, exact);
+        const baseChunkUrl = chunkUrl.split('?')[0];
+        const reloads = pendingChunkReloads.get(baseChunkUrl);
+        if (reloads) {
+            for (const reload of [
+                ...reloads
+            ]){
+                const href = reload.link.getAttribute('href');
+                const suffix = chunkUrl.includes('?') ? '&' : '?';
+                if (!exact || href === chunkUrl || href?.startsWith(`${chunkUrl}${suffix}`)) {
+                    reload.reject(new Error(`Chunk ${chunkUrl} was unloaded while reloading.`));
+                }
+            }
+        }
+        // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+        const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl);
+        const path = exact ? chunkUrl : baseChunkUrl;
+        const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
+        if (isCss(chunkUrl)) {
+            const links = document.querySelectorAll(`link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
+            for (const link of Array.from(links)){
+                link.remove();
+            }
+        } else if (isJs(chunkUrl)) {
+            // Unloading a JS chunk would have no effect once it has executed, but
+            // removing the exact stale registration keeps the DOM and resolver cache
+            // bounded without touching a newer generation of the same chunk path.
+            const scripts = document.querySelectorAll(`script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
+            for (const script of Array.from(scripts)){
+                script.remove();
+            }
+        } else {
+            throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+        }
+    }
+    function deleteResolvers(chunkUrl, exact) {
+        const baseChunkUrl = chunkUrl.split('?')[0];
+        for (const [resolverUrl, resolver] of [
+            ...chunkResolvers
+        ]){
+            if (exact ? resolverUrl !== chunkUrl : resolverUrl.split('?')[0] !== baseChunkUrl) {
+                continue;
+            }
+            if (resolver.resolved) {
+                chunkResolvers.delete(resolverUrl);
+            } else {
+                rejectResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
+            }
+        }
     }
 })();
 function _eval({ code, url, map }) {
diff --git a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map
index 175e88514..e3743b692 100644
--- a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map
@@ -6,7 +6,7 @@
     {"offset": {"line": 512, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/async-module.ts"],"sourcesContent":["/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./runtime-utils.ts\" />\n\n/**\n * Top-level-await / async-module machinery. This is only included in the runtime\n * when the module graph actually contains an async module (a module with\n * top-level await, or one that transitively depends on one). When no async\n * module is present, the chunk items never reference `__turbopack_context__.a`,\n * so this whole file can be omitted.\n *\n * everything below is adapted from webpack\n * https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n */\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n"],"names":["turbopackQueues","Symbol","turbopackExports","turbopackError","isPromise","maybePromise","then","isAsyncModuleExt","obj","createPromise","resolve","reject","promise","Promise","res","rej","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","map","dep","Object","assign","err","asyncModule","body","hasAwait","module","m","undefined","depQueues","Set","rawPromise","exports","attributes","get","set","v","defineProperty","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","has","add","push","asyncResult","contextPrototype","a"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 644, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 908, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/hmr-runtime.ts"],"sourcesContent":["/// <reference path=\"./runtime-utils.ts\" />\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n\ntype HotModuleFactoryFunction = ModuleFactoryFunction<\n  HotModule,\n  TurbopackBaseContext<HotModule>\n>\n\n/**\n * Shared HMR (Hot Module Replacement) implementation.\n *\n * This file contains the complete HMR implementation that's shared between\n * browser and Node.js runtimes. It manages module hot state, dependency\n * tracking, the module.hot API, and the full HMR update flow.\n */\n\n/**\n * The development module cache shared across the runtime.\n * Browser runtime declares this directly.\n * Node.js runtime assigns globalThis.__turbopack_module_cache__ to this.\n */\nlet devModuleCache: Record<ModuleId, any>\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nlet runtimeModules: Set<ModuleId>\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n\n/**\n * Maps module instances to their hot module state.\n * Uses WeakMap so it works with both HotModule and ModuleWithDirection.\n */\nconst moduleHotState: WeakMap<any, HotState> = new WeakMap()\n\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n      parentId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n      outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n    }\n\n/**\n * Records parent-child relationship when a module imports another.\n * Should be called during module instantiation.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction trackModuleImport(\n  parentModule: ModuleWithDirection,\n  childModuleId: ModuleId,\n  childModule: ModuleWithDirection | undefined\n): void {\n  // Record that parent imports child\n  if (parentModule.children.indexOf(childModuleId) === -1) {\n    parentModule.children.push(childModuleId)\n  }\n\n  // Record that child is imported by parent\n  if (childModule && childModule.parents.indexOf(parentModule.id) === -1) {\n    childModule.parents.push(parentModule.id)\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\n/**\n * Walks the dependency tree to find all modules affected by a change.\n * Returns information about whether the update can be accepted and which\n * modules need to be invalidated.\n *\n * @param moduleId - The module that changed\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().\n *                           This is used for server-side HMR where pages auto-accept at the top level.\n */\nfunction getAffectedModuleEffects(\n  moduleId: ModuleId,\n  autoAcceptRootModules: boolean\n): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n  const outdatedDependencies: Map<ModuleId, Set<ModuleId>> = new Map()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      if (autoAcceptRootModules) {\n        return {\n          type: 'accepted',\n          moduleId,\n          outdatedModules,\n          outdatedDependencies,\n        }\n      }\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      if (autoAcceptRootModules) {\n        continue\n      }\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        continue\n      }\n\n      const parentHotState = moduleHotState.get(parent)\n\n      // Check if parent declined this dependency\n      if (parentHotState?.declinedDependencies[moduleId]) {\n        return {\n          type: 'declined',\n          dependencyChain: [...dependencyChain, moduleId],\n          moduleId,\n          parentId,\n        }\n      }\n\n      // Skip if parent is already outdated\n      if (outdatedModules.has(parentId)) {\n        continue\n      }\n\n      // Check if parent accepts this dependency\n      if (parentHotState?.acceptedDependencies[moduleId]) {\n        if (!outdatedDependencies.has(parentId)) {\n          outdatedDependencies.set(parentId, new Set())\n        }\n        outdatedDependencies.get(parentId)!.add(moduleId)\n        continue\n      }\n\n      // Neither accepted nor declined — propagate to parent\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n\n    // If no parents and we're at a root module, auto-accept if configured\n    if (module.parents.length === 0 && autoAcceptRootModules) {\n      continue\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n    outdatedDependencies,\n  }\n}\n\n/**\n * Merges source dependency map into target dependency map.\n */\nfunction mergeDependencies(\n  target: Map<ModuleId, Set<ModuleId>>,\n  source: Map<ModuleId, Set<ModuleId>>\n): void {\n  for (const [parentId, deps] of source) {\n    const existing = target.get(parentId)\n    if (existing) {\n      for (const dep of deps) {\n        existing.add(dep)\n      }\n    } else {\n      target.set(parentId, new Set(deps))\n    }\n  }\n}\n\n/**\n * Computes all modules that need to be invalidated based on which modules changed.\n *\n * @param invalidated - The modules that have been invalidated\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>,\n  autoAcceptRootModules: boolean\n): {\n  outdatedModules: Set<ModuleId>\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n} {\n  const outdatedModules = new Set<ModuleId>()\n  const outdatedDependencies = new Map<ModuleId, Set<ModuleId>>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'declined':\n        throw new UpdateApplyError(\n          `cannot apply update: declined dependency. ${formatDependencyChain(\n            effect.dependencyChain\n          )}. Declined by ${effect.parentId}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        mergeDependencies(outdatedDependencies, effect.outdatedDependencies)\n        break\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return { outdatedModules, outdatedDependencies }\n}\n\n/**\n * Creates the module.hot API object and its internal state.\n * This provides the HMR API that user code calls (module.hot.accept(), etc.)\n */\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n    acceptedDependencies: {},\n    acceptedErrorHandlers: {},\n    declinedDependencies: {},\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      callback?: AcceptCallback,\n      errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else if (typeof modules === 'object' && modules !== null) {\n        for (let i = 0; i < modules.length; i++) {\n          hotState.acceptedDependencies[modules[i]] = callback || function () {}\n          hotState.acceptedErrorHandlers[modules[i]] = errorHandler\n        }\n      } else {\n        hotState.acceptedDependencies[modules] = callback || function () {}\n        hotState.acceptedErrorHandlers[modules] = errorHandler\n      }\n    },\n\n    decline: (dep?: string | string[]) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else if (typeof dep === 'object' && dep !== null) {\n        for (let i = 0; i < dep.length; i++) {\n          hotState.declinedDependencies[dep[i]] = true\n        }\n      } else {\n        hotState.declinedDependencies[dep] = true\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Processes queued invalidated modules and adds them to the outdated modules set.\n * Modules that call module.hot.invalidate() are queued and processed here.\n *\n * @param outdatedModules - The current set of outdated modules\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction applyInvalidatedModules(\n  outdatedModules: Set<ModuleId>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>,\n  autoAcceptRootModules: boolean\n): {\n  outdatedModules: Set<ModuleId>\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n} {\n  if (queuedInvalidatedModules.size > 0) {\n    const result = computedInvalidatedModules(\n      queuedInvalidatedModules,\n      autoAcceptRootModules\n    )\n    for (const moduleId of result.outdatedModules) {\n      outdatedModules.add(moduleId)\n    }\n    mergeDependencies(outdatedDependencies, result.outdatedDependencies)\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return { outdatedModules, outdatedDependencies }\n}\n\n/**\n * Computes which outdated modules have self-accepted and can be hot reloaded.\n */\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)\n    if (module && hotState?.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Disposes of an instance of a module.\n * Runs hot.dispose handlers and manages persistent hot data.\n *\n * NOTE: mode = \"replace\" will not remove modules from devModuleCache.\n * This must be done in a separate step afterwards.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)\n  if (!hotState) {\n    return\n  }\n\n  const data: HotData = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  if (module.hot) {\n    module.hot.active = false\n  }\n\n  moduleHotState.delete(module)\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\n/**\n * Dispose phase: runs dispose handlers and cleans up outdated/disposed modules.\n * Returns the parent modules of outdated modules for use in the apply phase.\n */\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map<ModuleId, Array<ModuleId>>()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // Remove outdated dependencies from parent module's children list.\n  // When a parent accepts a child's update, the child is re-instantiated\n  // but the parent stays alive. We remove the old child reference so it\n  // gets re-added when the child re-imports.\n  for (const [parentId, deps] of outdatedDependencies) {\n    const module = devModuleCache[parentId]\n    if (module) {\n      for (const dep of deps) {\n        const idx = module.children.indexOf(dep)\n        if (idx >= 0) {\n          module.children.splice(idx, 1)\n        }\n      }\n    }\n  }\n\n  return { outdatedModuleParents }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/**\n * Shared module instantiation logic.\n * This handles the full module instantiation flow for both browser and Node.js.\n * Only React Refresh hooks differ between platforms (passed as callback).\n */\nfunction instantiateModuleShared(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData,\n  moduleFactories: ModuleFactories,\n  devModuleCache: ModuleCache<HotModule>,\n  runtimeModules: Set<ModuleId>,\n  createModuleObjectFn: (id: ModuleId) => HotModule,\n  createContextFn: (module: HotModule, exports: Exports, refresh?: any) => any,\n  runModuleExecutionHooksFn: (\n    module: HotModule,\n    exec: (refresh: any) => void\n  ) => void\n): HotModule {\n  // 1. Factory validation (same in both browser and Node.js)\n  const id = moduleId\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    throw new Error(\n      factoryNotAvailableMessage(moduleId, sourceType, sourceData) +\n        `\\nThis is often caused by a stale browser cache, misconfigured Cache-Control headers, or a service worker serving outdated responses.` +\n        `\\nTo fix this, make sure your Cache-Control headers allow revalidation of chunks and review your service worker configuration. ` +\n        `As an immediate workaround, try hard-reloading the page, clearing the browser cache, or unregistering any service workers.`\n    )\n  }\n\n  // 2. Hot API setup (same in both - works for browser, included for Node.js)\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  // 3. Parent assignment logic (same in both)\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      throw new Error(`Unknown source type: ${sourceType}`)\n  }\n\n  // 4. Module creation (platform creates base module object)\n  const module = createModuleObjectFn(id)\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // 5. Module execution (React Refresh hooks are platform-specific)\n  try {\n    runModuleExecutionHooksFn(module, (refresh) => {\n      const context = createContextFn(module, exports, refresh)\n      moduleFactory.call(exports, context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  // 6. ESM interop (same in both)\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n/**\n * Analyzes update entries and chunks to determine which modules were added, modified, or deleted.\n * This is pure logic that doesn't depend on the runtime environment.\n */\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>,\n  chunkModulesMap?: Map<ChunkPath, Set<ModuleId>>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        const updateDeleted = chunkModulesMap\n          ? new Set(chunkModulesMap.get(chunkPath))\n          : new Set<ModuleId>()\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        throw new Error('Unknown merged chunk update type')\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\n/**\n * Compiles new module code and walks the dependency tree to find all outdated modules.\n * Uses the evalModuleEntry function to compile code (platform-specific).\n *\n * @param added - Map of added modules\n * @param modified - Map of modified modules\n * @param evalModuleEntry - Function to compile module code\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>,\n  evalModuleEntry: (entry: EcmascriptModuleEntry) => HotModuleFactoryFunction,\n  autoAcceptRootModules: boolean\n): {\n  outdatedModules: Set<ModuleId>\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n  newModuleFactories: Map<ModuleId, HotModuleFactoryFunction>\n} {\n  const newModuleFactories = new Map<ModuleId, HotModuleFactoryFunction>()\n\n  // Compile added modules\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, evalModuleEntry(entry))\n    }\n  }\n\n  // Walk dependency tree to find all modules affected by modifications\n  const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(\n    modified.keys(),\n    autoAcceptRootModules\n  )\n\n  // Compile modified modules\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, evalModuleEntry(entry))\n  }\n\n  return { outdatedModules, outdatedDependencies, newModuleFactories }\n}\n\n/**\n * Updates module factories and re-instantiates self-accepted modules.\n * Uses the instantiateModule function (platform-specific via callback).\n */\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, HotModuleFactoryFunction>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>,\n  moduleFactories: ModuleFactories,\n  devModuleCache: ModuleCache<HotModule>,\n  instantiateModuleFn: (\n    moduleId: ModuleId,\n    sourceType: SourceType,\n    sourceData: SourceData\n  ) => HotModule,\n  applyModuleFactoryNameFn: (factory: HotModuleFactoryFunction) => void,\n  reportError: (err: any) => void\n) {\n  // Update module factories\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryNameFn(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // Call accept handlers for outdated dependencies.\n  // This runs BEFORE re-instantiating self-accepted modules, matching\n  // webpack's behavior.\n  for (const [parentId, deps] of outdatedDependencies) {\n    const module = devModuleCache[parentId]\n    if (!module) continue\n\n    const hotState = moduleHotState.get(module)\n    if (!hotState) continue\n\n    // Group deps by callback, deduplicating callbacks that handle multiple deps.\n    // Each callback receives only the deps it was registered for.\n    const callbackDeps = new Map<AcceptCallback | (() => void), ModuleId[]>()\n    const callbackErrorHandlers = new Map<\n      AcceptCallback | (() => void),\n      AcceptErrorHandler | undefined\n    >()\n\n    for (const dep of deps) {\n      const acceptCallback = hotState.acceptedDependencies[dep]\n      if (acceptCallback) {\n        let depList = callbackDeps.get(acceptCallback)\n        if (!depList) {\n          depList = []\n          callbackDeps.set(acceptCallback, depList)\n          callbackErrorHandlers.set(\n            acceptCallback,\n            hotState.acceptedErrorHandlers[dep]\n          )\n        }\n        depList.push(dep)\n      }\n    }\n\n    for (const [callback, cbDeps] of callbackDeps) {\n      try {\n        callback.call(null, cbDeps)\n      } catch (err: any) {\n        const errorHandler = callbackErrorHandlers.get(callback)\n        if (typeof errorHandler === 'function') {\n          try {\n            errorHandler(err, {\n              moduleId: parentId,\n              dependencyId: cbDeps[0],\n            })\n          } catch (err2) {\n            reportError(err2)\n            reportError(err)\n          }\n        } else {\n          reportError(err)\n        }\n      }\n    }\n  }\n\n  // Re-instantiate all outdated self-accepted modules\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModuleFn(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\n/**\n * Internal implementation that orchestrates the full HMR update flow:\n * invalidation, disposal, and application of new modules.\n *\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, HotModuleFactoryFunction>,\n  moduleFactories: ModuleFactories,\n  devModuleCache: ModuleCache<HotModule>,\n  instantiateModuleFn: (\n    moduleId: ModuleId,\n    sourceType: SourceType,\n    sourceData: SourceData\n  ) => HotModule,\n  applyModuleFactoryNameFn: (factory: HotModuleFactoryFunction) => void,\n  autoAcceptRootModules: boolean\n) {\n  ;({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(\n    outdatedModules,\n    outdatedDependencies,\n    autoAcceptRootModules\n  ))\n\n  // Find self-accepted modules to re-instantiate\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  // Run dispose handlers, save hot.data, clear caches\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules,\n    outdatedDependencies\n  )\n\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err // Keep first error\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    outdatedDependencies,\n    moduleFactories,\n    devModuleCache,\n    instantiateModuleFn,\n    applyModuleFactoryNameFn,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  // Recursively apply any queued invalidations from new module execution\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(\n      new Set(),\n      new Map(),\n      [],\n      new Map(),\n      moduleFactories,\n      devModuleCache,\n      instantiateModuleFn,\n      applyModuleFactoryNameFn,\n      autoAcceptRootModules\n    )\n  }\n}\n\n/**\n * Main entry point for applying an ECMAScript merged update.\n * This is called by both browser and Node.js runtimes with platform-specific callbacks.\n *\n * @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit\n *                                   module.hot.accept(). Used for server-side HMR where pages\n *                                   auto-accept at the top level.\n */\nfunction applyEcmascriptMergedUpdateShared(options: {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  disposedModules: Iterable<ModuleId>\n  evalModuleEntry: (entry: EcmascriptModuleEntry) => HotModuleFactoryFunction\n  instantiateModule: (\n    moduleId: ModuleId,\n    sourceType: SourceType,\n    sourceData: SourceData\n  ) => HotModule\n  applyModuleFactoryName: (factory: HotModuleFactoryFunction) => void\n  moduleFactories: ModuleFactories\n  devModuleCache: ModuleCache<HotModule>\n  autoAcceptRootModules: boolean\n}) {\n  const {\n    added,\n    modified,\n    disposedModules,\n    evalModuleEntry,\n    instantiateModule,\n    applyModuleFactoryName,\n    moduleFactories,\n    devModuleCache,\n    autoAcceptRootModules,\n  } = options\n\n  const { outdatedModules, outdatedDependencies, newModuleFactories } =\n    computeOutdatedModules(\n      added,\n      modified,\n      evalModuleEntry,\n      autoAcceptRootModules\n    )\n\n  applyInternal(\n    outdatedModules,\n    outdatedDependencies,\n    disposedModules,\n    newModuleFactories,\n    moduleFactories,\n    devModuleCache,\n    instantiateModule,\n    applyModuleFactoryName,\n    autoAcceptRootModules\n  )\n}\n"],"names":["devModuleCache","runtimeModules","moduleHotData","Map","moduleHotState","WeakMap","queuedInvalidatedModules","Set","UpdateApplyError","Error","name","message","dependencyChain","trackModuleImport","parentModule","childModuleId","childModule","children","indexOf","push","parents","id","formatDependencyChain","join","getAffectedModuleEffects","moduleId","autoAcceptRootModules","outdatedModules","outdatedDependencies","queue","nextItem","shift","has","add","undefined","type","module","hotState","get","selfAccepted","selfInvalidated","selfDeclined","parentId","parent","parentHotState","declinedDependencies","acceptedDependencies","set","length","mergeDependencies","target","source","deps","existing","dep","computedInvalidatedModules","invalidated","effect","outdatedModuleId","invariant","createModuleHot","hotData","disposeHandlers","acceptedErrorHandlers","hot","active","data","accept","modules","callback","errorHandler","i","decline","dispose","addDisposeHandler","removeDisposeHandler","idx","splice","invalidate","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","applyInvalidatedModules","size","result","clear","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","disposeModule","mode","disposeHandler","delete","childId","child","disposePhase","disposedModules","outdatedModuleParents","oldModule","instantiateModuleShared","sourceType","sourceData","moduleFactories","createModuleObjectFn","createContextFn","runModuleExecutionHooksFn","moduleFactory","factoryNotAvailableMessage","SourceType","Runtime","Parent","Update","exports","refresh","context","call","error","namespaceObject","interopEsm","computeChangedModules","entries","updates","chunkModulesMap","chunksAdded","chunksDeleted","added","modified","deleted","chunkPath","mergedChunkUpdate","Object","updateAdded","updateDeleted","keys","entry","computeOutdatedModules","evalModuleEntry","newModuleFactories","applyPhase","instantiateModuleFn","applyModuleFactoryNameFn","reportError","factory","callbackDeps","callbackErrorHandlers","acceptCallback","depList","cbDeps","err","dependencyId","err2","applyInternal","applyEcmascriptMergedUpdateShared","options","instantiateModule","applyModuleFactoryName"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"../../../shared/runtime/dev-globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/dev-protocol.d.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// Assign browser's module cache and runtime modules to shared HMR state\ndevModuleCache = Object.create(null)\ndevContextPrototype.c = devModuleCache\nruntimeModules = new Set()\n\n// Set flag to indicate we use ModuleWithDirection\ncreateModuleWithDirectionFlag = true\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\nfunction getRefreshBoundaryExports<T>(exports: T): T {\n  if (\n    typeof isAsyncModuleExt === 'function' &&\n    exports != null &&\n    typeof exports === 'object' &&\n    isAsyncModuleExt(exports)\n  ) {\n    return exports[turbopackExports] as T\n  }\n  return exports\n}\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // Browser: creates base HotModule object (hot API added by shared code)\n  const createModuleObjectFn = (id: ModuleId) => {\n    return createModuleObject(id) as HotModule\n  }\n\n  // Browser: creates DevContext with refresh\n  const createContext = (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ) => {\n    return new (DevContext as any as DevContextConstructor)(\n      module,\n      exports,\n      refresh\n    )\n  }\n\n  // Use shared instantiation logic (includes hot API setup)\n  return instantiateModuleShared(\n    moduleId,\n    sourceType,\n    sourceData,\n    moduleFactories,\n    devModuleCache,\n    runtimeModules,\n    createModuleObjectFn,\n    createContext,\n    runModuleExecutionHooks\n  )\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = getRefreshBoundaryExports(module.exports)\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  // Browser-specific chunk management phase\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks,\n    chunkModulesMap\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  // Use shared HMR update implementation\n  applyEcmascriptMergedUpdateShared({\n    added,\n    modified,\n    disposedModules,\n    evalModuleEntry: _eval, // browser's eval with source maps\n    instantiateModule, // now wraps shared logic\n    applyModuleFactoryName,\n    moduleFactories,\n    devModuleCache,\n    autoAcceptRootModules: false,\n  })\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkPath\n    | ChunkScript\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    let chunkPath = getPathFromScript(chunk)\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = getChunkFromRegistration(chunkList.script) as\n    | ChunkListPath\n    | ChunkListScript\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  CHUNK_UPDATE_LISTENERS.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","runtimeModules","Set","createModuleWithDirectionFlag","getRefreshBoundaryExports","exports","isAsyncModuleExt","turbopackExports","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","refresh","call","k","sourceType","sourceData","createModuleObjectFn","createModuleObject","createContext","instantiateModuleShared","moduleFactories","runModuleExecutionHooks","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","add","applyUpdate","update","type","applyChunkListUpdate","invariant","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","entries","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","Update","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","added","modified","chunksAdded","chunksDeleted","computeChangedModules","applyEcmascriptMergedUpdateShared","evalModuleEntry","_eval","applyModuleFactoryName","autoAcceptRootModules","handleApply","chunkListPath","restart","has","disposeChunkList","Error","moduleChunks","get","delete","chunkModules","noRemainingModules","size","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","disposeModule","availableModules","set","markChunkListAsRuntime","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","getPathFromScript","undefined","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 2023, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 2266, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // Strip query string so we match links regardless of cache-busting\n      // params (e.g. ?ts=) that may differ between HMR updates.\n      const baseChunkUrl = chunkUrl.split('?')[0]\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${baseChunkUrl}\"],link[href^=\"${baseChunkUrl}?\"],link[href=\"${decodedBaseChunkUrl}\"],link[href^=\"${decodedBaseChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${baseChunkUrl}\"],script[src^=\"${baseChunkUrl}?\"],script[src=\"${decodedBaseChunkUrl}\"],script[src^=\"${decodedBaseChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        // Strip query string so we match links regardless of cache-busting\n        // params (e.g. ?ts=) that may differ between HMR updates.\n        const baseChunkUrl = chunkUrl.split('?')[0]\n        const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${baseChunkUrl}\"],link[rel=stylesheet][href^=\"${baseChunkUrl}?\"],link[rel=stylesheet][href=\"${decodedBaseChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedBaseChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n        link.crossOrigin = CROSS_ORIGIN\n\n        if (\n          navigator.userAgent.includes('Firefox') ||\n          (navigator.userAgent.includes('Safari') &&\n            !navigator.userAgent.includes('Chrome') &&\n            !navigator.userAgent.includes('Chromium'))\n        ) {\n          // Firefox won't reload CSS files that were previously loaded on the\n          // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari serves cached CSS when a <link rel=preload> exists for the\n          // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726\n          //\n          // Replace or add a fresh `ts` cache-busting param without\n          // discarding other query parameters that may already be present.\n          const url = new URL(chunkUrl, location.origin)\n          // Reduced timer precision in some browers could lead to an update getting dropped\n          // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).\n          // So trust that the server is only updating us when it is important and use a\n          // random number to bust the cache.\n          url.searchParams.set('ts', `${Date.now()}.${Math.random()}`)\n          link.href = url.pathname + url.search\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","baseChunkUrl","split","decodedBaseChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","crossOrigin","CROSS_ORIGIN","navigator","userAgent","includes","url","URL","location","origin","searchParams","set","Date","now","Math","random","href","pathname","search","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","reload","chunkResolvers","delete","_eval","code","map","encodeURI","CHUNK_BASE_PATH","ASSET_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"../../../shared/runtime/dev-globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/dev-protocol.d.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// Assign browser's module cache and runtime modules to shared HMR state\ndevModuleCache = Object.create(null)\ndevContextPrototype.c = devModuleCache\nruntimeModules = new Set()\n\n// Set flag to indicate we use ModuleWithDirection\ncreateModuleWithDirectionFlag = true\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\nfunction getRefreshBoundaryExports<T>(exports: T): T {\n  if (\n    typeof isAsyncModuleExt === 'function' &&\n    exports != null &&\n    typeof exports === 'object' &&\n    isAsyncModuleExt(exports)\n  ) {\n    return exports[turbopackExports] as T\n  }\n  return exports\n}\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  loadChunkReplacing?: (chunkUrl: ChunkUrl) => Promise<void>\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  rejectChunk?: (chunkPath: ChunkPath, error: Error) => void\n  resolveChunk?: (chunkUrl: ChunkUrl) => void\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  unloadChunkExact?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\ntype DevChunkList = ChunkList & {\n  chunkVersions: Record<ChunkPath, string>\n  version: string\n}\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\ntype DynamicChunkListLoadState = {\n  generation: number\n  loading: boolean\n  bootstrapping: boolean\n  terminated: boolean\n  pendingTasks: Set<Promise<void>>\n  memberChunkUrls: Map<ChunkPath, ChunkUrl>\n  rejectSubscribed?: (error: Error) => void\n}\n\ntype PendingHmrTask = {\n  chunkLists: Array<{ path: ChunkListPath; generation: number }>\n  apply: (currentPaths: ReadonlySet<ChunkListPath>) => HmrResourceOperation[]\n  resolve: () => void\n  reject: (error: unknown) => void\n}\n\ntype HmrResourceOperation = {\n  chunkPath: ChunkPath\n  promise: Promise<void>\n}\n\nconst dynamicChunkListLoadStates: Map<\n  ChunkListPath,\n  DynamicChunkListLoadState\n> = new Map()\nconst pendingHmrTasks: PendingHmrTask[] = []\nconst chunkListGenerations: Map<ChunkListPath, number> = new Map()\nlet nextChunkListGeneration = 1\nlet activeHmrTask: PendingHmrTask | undefined\nconst dynamicMemberChunkUrlOwners: Map<\n  ChunkUrl,\n  Map<ChunkListPath, number>\n> = new Map()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // Browser: creates base HotModule object (hot API added by shared code)\n  const createModuleObjectFn = (id: ModuleId) => {\n    return createModuleObject(id) as HotModule\n  }\n\n  // Browser: creates DevContext with refresh\n  const createContext = (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ) => {\n    return new (DevContext as any as DevContextConstructor)(\n      module,\n      exports,\n      refresh\n    )\n  }\n\n  // Use shared instantiation logic (includes hot API setup)\n  return instantiateModuleShared(\n    moduleId,\n    sourceType,\n    sourceData,\n    moduleFactories,\n    devModuleCache,\n    runtimeModules,\n    createModuleObjectFn,\n    createContext,\n    runModuleExecutionHooks\n  )\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = getRefreshBoundaryExports(module.exports)\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\ntype ChunkOwnershipTransition = {\n  before: number\n  after: number\n}\n\nconst PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict')\n\nfunction mergeParallelChunkUpdate(\n  updateA: ChunkUpdate,\n  updateB: ChunkUpdate\n): ChunkUpdate | null | typeof PARALLEL_UPDATE_CONFLICT {\n  if (updateA.type === updateB.type) {\n    return updateA\n  }\n  if (updateA.type === 'total' || updateB.type === 'total') {\n    return { type: 'total' }\n  }\n  if (\n    (updateA.type === 'added' && updateB.type === 'deleted') ||\n    (updateA.type === 'deleted' && updateB.type === 'added')\n  ) {\n    return null\n  }\n  return PARALLEL_UPDATE_CONFLICT\n}\n\nfunction mergeParallelEcmascriptChunkUpdate(\n  updateA: EcmascriptMergedChunkUpdate,\n  updateB: EcmascriptMergedChunkUpdate\n): EcmascriptMergedChunkUpdate | typeof PARALLEL_UPDATE_CONFLICT {\n  if (updateA.type === 'added' && updateB.type === 'added') {\n    return {\n      type: 'added',\n      modules: [\n        ...new Set([...(updateA.modules ?? []), ...(updateB.modules ?? [])]),\n      ],\n    }\n  }\n  if (updateA.type === 'deleted' && updateB.type === 'deleted') {\n    return {\n      type: 'deleted',\n      modules: [\n        ...new Set([...(updateA.modules ?? []), ...(updateB.modules ?? [])]),\n      ],\n    }\n  }\n  if (updateA.type === 'partial' && updateB.type === 'partial') {\n    const added = new Set([...(updateA.added ?? []), ...(updateB.added ?? [])])\n    const deleted = new Set([\n      ...(updateA.deleted ?? []),\n      ...(updateB.deleted ?? []),\n    ])\n    for (const moduleId of added) {\n      if (deleted.has(moduleId)) {\n        added.delete(moduleId)\n        deleted.delete(moduleId)\n      }\n    }\n    return { type: 'partial', added: [...added], deleted: [...deleted] }\n  }\n  if (\n    (updateA.type === 'added' && updateB.type === 'deleted') ||\n    (updateA.type === 'deleted' && updateB.type === 'added')\n  ) {\n    const addedUpdate = updateA.type === 'added' ? updateA : updateB\n    const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB\n    const added = new Set(addedUpdate.modules ?? [])\n    const deleted = new Set(deletedUpdate.modules ?? [])\n    for (const moduleId of added) {\n      if (deleted.has(moduleId)) {\n        added.delete(moduleId)\n        deleted.delete(moduleId)\n      }\n    }\n    return { type: 'partial', added: [...added], deleted: [...deleted] }\n  }\n\n  if (updateA.type === 'partial') {\n    if (\n      (updateA.added?.length ?? 0) === 0 &&\n      (updateA.deleted?.length ?? 0) === 0\n    ) {\n      return updateB\n    }\n    return PARALLEL_UPDATE_CONFLICT\n  }\n  if (updateB.type === 'partial') {\n    if (\n      (updateB.added?.length ?? 0) === 0 &&\n      (updateB.deleted?.length ?? 0) === 0\n    ) {\n      return updateA\n    }\n    return PARALLEL_UPDATE_CONFLICT\n  }\n  return PARALLEL_UPDATE_CONFLICT\n}\n\nfunction moduleEntriesEqual(\n  entryA: EcmascriptModuleEntry,\n  entryB: EcmascriptModuleEntry\n) {\n  // The same module can be emitted into multiple chunks. Its source URL is\n  // chunk-relative, so it is allowed to differ even when the executable entry\n  // is identical. Treat only code and source map differences as conflicts.\n  return entryA.code === entryB.code && entryA.map === entryB.map\n}\n\nfunction applyChunkListUpdates(\n  updates: Array<{\n    chunkListPath: ChunkListPath\n    update: ChunkListUpdate\n  }>\n): HmrResourceOperation[] {\n  const resourceOperations: HmrResourceOperation[] = []\n  const ownershipTransitions = new Map<ChunkPath, ChunkOwnershipTransition>()\n  const chunks = new Map<ChunkPath, ChunkUpdate | null>()\n  const ecmascriptChunks = new Map<ChunkPath, EcmascriptMergedChunkUpdate>()\n  const entries: Record<ModuleId, EcmascriptModuleEntry> = {}\n  const explicitlyModifiedModules = new Set<ModuleId>()\n  let hasConflict = false\n\n  for (const { chunkListPath, update } of updates) {\n    if (update.chunks) {\n      for (const [chunkPath, chunkUpdate] of Object.entries(\n        update.chunks\n      ) as Array<[ChunkPath, ChunkUpdate]>) {\n        if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {\n          if (\n            !applyChunkListMembershipDelta(\n              chunkListPath,\n              chunkPath,\n              chunkUpdate.type,\n              ownershipTransitions\n            )\n          ) {\n            hasConflict = true\n          }\n        }\n\n        if (!chunks.has(chunkPath)) {\n          chunks.set(chunkPath, chunkUpdate)\n        } else {\n          const previous = chunks.get(chunkPath)\n          if (previous === null) {\n            chunks.set(chunkPath, chunkUpdate)\n          } else {\n            const merged = mergeParallelChunkUpdate(previous!, chunkUpdate)\n            if (merged === PARALLEL_UPDATE_CONFLICT) {\n              hasConflict = true\n            } else {\n              chunks.set(chunkPath, merged)\n            }\n          }\n        }\n      }\n    }\n\n    for (const merged of update.merged ?? []) {\n      if (merged.type !== 'EcmascriptMergedUpdate') {\n        invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n\n      const addedInThisUpdate = new Set<ModuleId>()\n      for (const [chunkPath, chunkUpdate] of Object.entries(\n        merged.chunks ?? {}\n      ) as Array<[ChunkPath, EcmascriptMergedChunkUpdate]>) {\n        if (chunkUpdate.type === 'added') {\n          for (const moduleId of chunkUpdate.modules ?? []) {\n            addedInThisUpdate.add(moduleId)\n          }\n          if (\n            !applyChunkListMembershipDelta(\n              chunkListPath,\n              chunkPath,\n              'added',\n              ownershipTransitions\n            )\n          ) {\n            hasConflict = true\n          }\n        } else if (chunkUpdate.type === 'deleted') {\n          if (\n            !applyChunkListMembershipDelta(\n              chunkListPath,\n              chunkPath,\n              'deleted',\n              ownershipTransitions\n            )\n          ) {\n            hasConflict = true\n          }\n        } else {\n          for (const moduleId of chunkUpdate.added ?? []) {\n            addedInThisUpdate.add(moduleId)\n          }\n        }\n\n        const previous = ecmascriptChunks.get(chunkPath)\n        if (!previous) {\n          ecmascriptChunks.set(chunkPath, chunkUpdate)\n        } else {\n          const combined = mergeParallelEcmascriptChunkUpdate(\n            previous,\n            chunkUpdate\n          )\n          if (combined === PARALLEL_UPDATE_CONFLICT) {\n            hasConflict = true\n          } else {\n            ecmascriptChunks.set(chunkPath, combined)\n          }\n        }\n      }\n\n      for (const [moduleId, entry] of Object.entries(merged.entries ?? {})) {\n        const previous = entries[moduleId]\n        if (previous) {\n          if (!moduleEntriesEqual(previous, entry)) {\n            hasConflict = true\n          }\n        } else {\n          entries[moduleId] = entry\n        }\n        if (!addedInThisUpdate.has(moduleId)) {\n          explicitlyModifiedModules.add(moduleId)\n        }\n      }\n    }\n  }\n\n  if (hasConflict) {\n    DEV_BACKEND.restart()\n    return resourceOperations\n  }\n\n  const filteredEcmascriptChunks: Record<\n    ChunkPath,\n    EcmascriptMergedChunkUpdate\n  > = {}\n  for (const [chunkPath, chunkUpdate] of ecmascriptChunks) {\n    const transition = ownershipTransitions.get(chunkPath)\n    if (chunkUpdate.type === 'added' && transition && transition.before > 0) {\n      for (const moduleId of chunkUpdate.modules ?? []) {\n        if (!explicitlyModifiedModules.has(moduleId)) {\n          delete entries[moduleId]\n        }\n      }\n      continue\n    }\n    if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {\n      continue\n    }\n    filteredEcmascriptChunks[chunkPath] = chunkUpdate\n  }\n\n  if (\n    Object.keys(entries).length > 0 ||\n    Object.keys(filteredEcmascriptChunks).length > 0\n  ) {\n    applyEcmascriptMergedUpdate({\n      type: 'EcmascriptMergedUpdate',\n      entries,\n      chunks: filteredEcmascriptChunks,\n    })\n  }\n\n  for (const [chunkPath, chunkUpdate] of chunks) {\n    if (chunkUpdate === null) {\n      continue\n    }\n    const transition = ownershipTransitions.get(chunkPath)\n    const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0\n    const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n    switch (chunkUpdate.type) {\n      case 'added':\n        if (!transition || (transition.before === 0 && transition.after > 0)) {\n          resourceOperations.push({\n            chunkPath,\n            promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl),\n          })\n        }\n        break\n      case 'total':\n        if (ownerCount > 0) {\n          const promise = DEV_BACKEND.reloadChunk?.(chunkUrl)\n          if (promise) {\n            resourceOperations.push({ chunkPath, promise })\n          }\n        }\n        break\n      case 'deleted':\n        if (!transition || (transition.before > 0 && transition.after === 0)) {\n          disposeChunk(chunkPath)\n        }\n        break\n      case 'partial':\n        invariant(\n          chunkUpdate.instruction,\n          (instruction) =>\n            `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n        )\n        break\n      default:\n        invariant(\n          chunkUpdate,\n          (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n        )\n    }\n  }\n\n  return resourceOperations\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  // Browser-specific chunk management phase\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks,\n    chunkModulesMap\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  // Use shared HMR update implementation\n  applyEcmascriptMergedUpdateShared({\n    added,\n    modified,\n    disposedModules,\n    evalModuleEntry: _eval, // browser's eval with source maps\n    instantiateModule, // now wraps shared logic\n    applyModuleFactoryName,\n    moduleFactories,\n    devModuleCache,\n    autoAcceptRootModules: false,\n  })\n}\n\nfunction getCurrentTaskPaths(task: PendingHmrTask): ChunkListPath[] {\n  return task.chunkLists\n    .filter(\n      ({ path, generation }) => chunkListGenerations.get(path) === generation\n    )\n    .map(({ path }) => path)\n}\n\nfunction isHmrTaskBlocked(task: PendingHmrTask): boolean {\n  return task.chunkLists.some(({ path, generation }) => {\n    if (chunkListGenerations.get(path) !== generation) return false\n    const state = dynamicChunkListLoadStates.get(path)\n    return state?.generation === generation && state.loading\n  })\n}\n\nfunction runHmrTask(task: PendingHmrTask) {\n  activeHmrTask = task\n  void (async () => {\n    let resourceOperations: HmrResourceOperation[] = []\n    try {\n      const currentPaths = new Set(getCurrentTaskPaths(task))\n      if (currentPaths.size > 0) {\n        resourceOperations = task.apply(currentPaths)\n        const results = await Promise.allSettled(\n          resourceOperations.map(({ promise }) => promise)\n        )\n        const failedIndex = results.findIndex(\n          (result, index) =>\n            result.status === 'rejected' &&\n            chunkChunkListsMap.has(resourceOperations[index].chunkPath)\n        )\n        if (failedIndex !== -1) {\n          throw (results[failedIndex] as PromiseRejectedResult).reason\n        }\n      }\n      task.resolve()\n    } catch (cause) {\n      // A terminal update invalidates the generation immediately. Any member\n      // request it cancelled belongs to that old generation and must not turn\n      // a valid replacement subscription into a page reload.\n      if (getCurrentTaskPaths(task).length === 0) {\n        task.resolve()\n      } else {\n        task.reject(cause)\n      }\n    } finally {\n      for (const { chunkPath } of resourceOperations) {\n        if (!chunkChunkListsMap.has(chunkPath)) {\n          disposeChunk(chunkPath)\n        }\n      }\n      if (activeHmrTask === task) {\n        activeHmrTask = undefined\n      }\n      flushPendingHmrTasks()\n    }\n  })()\n}\n\nfunction scheduleHmrTask(\n  chunkListPaths: ChunkListPath[],\n  apply: (currentPaths: ReadonlySet<ChunkListPath>) => HmrResourceOperation[]\n): Promise<void> {\n  const chunkLists = [...new Set(chunkListPaths)].flatMap((path) => {\n    const generation = chunkListGenerations.get(path)\n    return generation === undefined ? [] : [{ path, generation }]\n  })\n  if (chunkLists.length === 0) {\n    return Promise.resolve()\n  }\n\n  let resolve!: () => void\n  let reject!: (error: unknown) => void\n  const completion = new Promise<void>((innerResolve, innerReject) => {\n    resolve = innerResolve\n    reject = innerReject\n  })\n  const task: PendingHmrTask = { chunkLists, apply, resolve, reject }\n\n  for (const { path, generation } of chunkLists) {\n    const state = dynamicChunkListLoadStates.get(path)\n    if (\n      state?.generation === generation &&\n      state.bootstrapping &&\n      !state.terminated\n    ) {\n      state.pendingTasks.add(completion)\n      void completion.then(\n        () => state.pendingTasks.delete(completion),\n        () => state.pendingTasks.delete(completion)\n      )\n    }\n  }\n\n  if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {\n    pendingHmrTasks.push(task)\n    flushPendingHmrTasks()\n  } else {\n    runHmrTask(task)\n  }\n  return completion\n}\n\nfunction flushPendingHmrTasks() {\n  if (activeHmrTask) return\n\n  while (pendingHmrTasks.length > 0) {\n    const task = pendingHmrTasks[0]\n    if (getCurrentTaskPaths(task).length === 0) {\n      pendingHmrTasks.shift()\n      task.resolve()\n      continue\n    }\n    if (isHmrTaskBlocked(task)) {\n      return\n    }\n    pendingHmrTasks.shift()\n    runHmrTask(task)\n    return\n  }\n}\n\nfunction handleApplyBatch(updates: PartialServerMessage[]): UpdateBatchResult {\n  const relevantUpdates = updates\n    .map((update) => ({\n      chunkListPath: update.resource.path as ChunkListPath,\n      update: update.instruction,\n    }))\n    .filter(({ chunkListPath }) => chunkListChunksMap.has(chunkListPath))\n\n  const chunkListPaths = [\n    ...new Set(relevantUpdates.map(({ chunkListPath }) => chunkListPath)),\n  ]\n  if (chunkListPaths.length === 0) {\n    return { handledPaths: [] }\n  }\n\n  const bootstrappingPaths = chunkListPaths.filter((chunkListPath) => {\n    const state = dynamicChunkListLoadStates.get(chunkListPath)\n    return state?.bootstrapping && !state.terminated\n  })\n  if (bootstrappingPaths.length > 0) {\n    for (const chunkListPath of bootstrappingPaths) {\n      const state = dynamicChunkListLoadStates.get(chunkListPath)!\n      terminateDynamicChunkListLoad(\n        chunkListPath,\n        state,\n        new Error(\n          `Dynamic chunk list ${chunkListPath} changed while its members were loading.`\n        )\n      )\n    }\n    DEV_BACKEND.restart()\n    flushPendingHmrTasks()\n    return { handledPaths: chunkListPaths }\n  }\n\n  const completion = scheduleHmrTask(chunkListPaths, (currentPaths) => {\n    const chunkListUpdates = relevantUpdates\n      .filter(({ chunkListPath }) => currentPaths.has(chunkListPath))\n      .map(({ chunkListPath, update }) => {\n        if (update.type !== 'ChunkListUpdate') {\n          invariant(update, (update) => `Unknown update type: ${update.type}`)\n        }\n        return { chunkListPath, update }\n      })\n    return chunkListUpdates.length > 0\n      ? applyChunkListUpdates(chunkListUpdates)\n      : []\n  })\n  return { handledPaths: chunkListPaths, completion }\n}\n\nfunction handleApply(\n  chunkListPath: ChunkListPath,\n  update: ServerMessage\n): Promise<void> {\n  const loadState = dynamicChunkListLoadStates.get(chunkListPath)\n  if (\n    update.type === 'partial' &&\n    loadState?.bootstrapping &&\n    !loadState.terminated\n  ) {\n    terminateDynamicChunkListLoad(\n      chunkListPath,\n      loadState,\n      new Error(\n        `Dynamic chunk list ${chunkListPath} changed while its members were loading.`\n      )\n    )\n    DEV_BACKEND.restart()\n    flushPendingHmrTasks()\n    return Promise.resolve()\n  }\n  if (update.type === 'notFound' || update.type === 'restart') {\n    if (loadState && !loadState.terminated) {\n      const error = new Error(\n        update.type === 'notFound'\n          ? `Dynamic chunk list ${chunkListPath} disappeared while loading.`\n          : `Dynamic chunk list ${chunkListPath} must restart while loading.`\n      )\n      terminateDynamicChunkListLoad(chunkListPath, loadState, error)\n    }\n    if (update.type === 'restart') {\n      chunkListGenerations.delete(chunkListPath)\n      dynamicChunkListLoadStates.delete(chunkListPath)\n    }\n    handleApplyImmediately(chunkListPath, update)\n    flushPendingHmrTasks()\n    return Promise.resolve()\n  }\n\n  return scheduleHmrTask([chunkListPath], (currentPaths) =>\n    currentPaths.has(chunkListPath)\n      ? handleApplyImmediately(chunkListPath, update)\n      : []\n  )\n}\n\nfunction handleApplyImmediately(\n  chunkListPath: ChunkListPath,\n  update: ServerMessage\n): HmrResourceOperation[] {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      if (update.instruction.type !== 'ChunkListUpdate') {\n        invariant(\n          update.instruction,\n          (instruction) => `Unknown update type: ${instruction.type}`\n        )\n      }\n      return applyChunkListUpdates([\n        { chunkListPath, update: update.instruction },\n      ])\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      return []\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      return []\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListMembershipDelta(\n  chunkListPath: ChunkListPath,\n  chunkPath: ChunkPath,\n  type: 'added' | 'deleted',\n  transitions: Map<ChunkPath, ChunkOwnershipTransition>\n): boolean {\n  let transition = transitions.get(chunkPath)\n  if (!transition) {\n    const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0\n    transition = { before: ownerCount, after: ownerCount }\n    transitions.set(chunkPath, transition)\n  }\n\n  const changed =\n    type === 'added'\n      ? addChunkToChunkList(chunkListPath, chunkPath)\n      : removeChunkFromChunkList(chunkListPath, chunkPath)\n  transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0\n  return changed\n}\n\nfunction addChunkToChunkList(\n  chunkListPath: ChunkListPath,\n  chunkPath: ChunkPath\n): boolean {\n  let chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (!chunkPaths) {\n    chunkPaths = new Set()\n    chunkListChunksMap.set(chunkListPath, chunkPaths)\n  }\n  if (chunkPaths.has(chunkPath)) {\n    return false\n  }\n  chunkPaths.add(chunkPath)\n\n  let chunkLists = chunkChunkListsMap.get(chunkPath)\n  if (!chunkLists) {\n    chunkLists = new Set()\n    chunkChunkListsMap.set(chunkPath, chunkLists)\n  }\n  chunkLists.add(chunkListPath)\n  return true\n}\n\nfunction removeChunkFromChunkList(\n  chunkListPath: ChunkListPath,\n  chunkPath: ChunkPath\n): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  const chunkLists = chunkChunkListsMap.get(chunkPath)\n  if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {\n    return false\n  }\n\n  chunkPaths.delete(chunkPath)\n  chunkLists.delete(chunkListPath)\n  if (chunkLists.size === 0) {\n    chunkChunkListsMap.delete(chunkPath)\n  }\n  return true\n}\n\nfunction setChunkListChunks(\n  chunkListPath: ChunkListPath,\n  nextChunkPaths: Set<ChunkPath>\n) {\n  const previousChunkPaths = new Set(\n    chunkListChunksMap.get(chunkListPath) ?? []\n  )\n  if (!chunkListChunksMap.has(chunkListPath)) {\n    chunkListChunksMap.set(chunkListPath, new Set())\n  }\n\n  for (const chunkPath of previousChunkPaths) {\n    if (\n      !nextChunkPaths.has(chunkPath) &&\n      removeChunkFromChunkList(chunkListPath, chunkPath) &&\n      !chunkChunkListsMap.has(chunkPath)\n    ) {\n      disposeChunk(chunkPath)\n    }\n  }\n  for (const chunkPath of nextChunkPaths) {\n    if (!previousChunkPaths.has(chunkPath)) {\n      addChunkToChunkList(chunkListPath, chunkPath)\n    }\n  }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\nfunction terminateDynamicChunkListLoad(\n  chunkListPath: ChunkListPath,\n  state: DynamicChunkListLoadState,\n  error: Error\n) {\n  if (state.terminated) return\n\n  state.loading = false\n  state.bootstrapping = false\n  state.terminated = true\n  state.rejectSubscribed?.(error)\n  DEV_BACKEND.rejectChunk?.(chunkListPath as string as ChunkPath, error)\n\n  for (const [chunkPath, chunkUrl] of state.memberChunkUrls) {\n    releaseDynamicMemberChunkUrlOwner(\n      chunkListPath,\n      state.generation,\n      chunkPath,\n      chunkUrl\n    )\n  }\n}\n\nfunction addDynamicMemberChunkUrlOwner(\n  chunkListPath: ChunkListPath,\n  generation: number,\n  chunkUrl: ChunkUrl\n) {\n  let owners = dynamicMemberChunkUrlOwners.get(chunkUrl)\n  if (!owners) {\n    owners = new Map()\n    dynamicMemberChunkUrlOwners.set(chunkUrl, owners)\n  }\n  owners.set(chunkListPath, generation)\n}\n\nfunction releaseDynamicMemberChunkUrlOwner(\n  chunkListPath: ChunkListPath,\n  generation: number,\n  chunkPath: ChunkPath,\n  chunkUrl: ChunkUrl\n) {\n  const owners = dynamicMemberChunkUrlOwners.get(chunkUrl)\n  if (owners?.get(chunkListPath) !== generation) return\n\n  owners.delete(chunkListPath)\n  if (owners.size > 0) return\n\n  dynamicMemberChunkUrlOwners.delete(chunkUrl)\n  if (isJs(chunkUrl)) {\n    // Executed factories are already tracked by logical chunk ownership. The\n    // exact URL is removed so a cancelled in-flight script cannot satisfy a\n    // later request for the same logical chunk.\n    DEV_BACKEND.unloadChunkExact?.(chunkUrl)\n  } else {\n    const hasOtherChunkListOwner = [\n      ...(chunkChunkListsMap.get(chunkPath) ?? []),\n    ].some((owner) => owner !== chunkListPath)\n    if (hasOtherChunkListOwner) return\n    DEV_BACKEND.unloadChunkExact?.(chunkUrl)\n  }\n\n  if (!chunkChunkListsMap.has(chunkPath)) {\n    disposeChunk(chunkPath)\n  }\n}\n\nfunction completeDynamicMemberChunkUrlOwner(\n  chunkListPath: ChunkListPath,\n  generation: number,\n  chunkUrl: ChunkUrl\n) {\n  const owners = dynamicMemberChunkUrlOwners.get(chunkUrl)\n  if (owners?.get(chunkListPath) !== generation) return\n\n  owners.delete(chunkListPath)\n  if (owners.size === 0) {\n    dynamicMemberChunkUrlOwners.delete(chunkUrl)\n  }\n}\n\nfunction loadVersionedDynamicMemberChunk(\n  chunkListPath: ChunkPath,\n  chunkData: ChunkData,\n  versionToken: string\n) {\n  const chunkPath = getChunkPath(chunkData)\n  const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken)\n  if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {\n    // A previous owner may have loaded an older content-version URL for the\n    // same stylesheet. Swap it only after the new CSS has loaded so dynamic\n    // lists never accumulate duplicate cascade entries.\n    return DEV_BACKEND.loadChunkReplacing(chunkUrl)\n  }\n  return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken)\n}\n\nfunction getVersionedChunkUrl(\n  chunkPath: ChunkPath,\n  versionToken: string\n): ChunkUrl {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  const separator = chunkUrl.includes('?') ? '&' : '?'\n  return `${chunkUrl}${separator}hmr=${encodeURIComponent(\n    versionToken\n  )}` as ChunkUrl\n}\n\nfunction isVersionedDynamicMemberChunkUrl(chunkUrl: ChunkUrl): boolean {\n  return /(?:[?&])hmr=/.test(chunkUrl)\n}\n\n/**\n * Dynamic chunk-list manifests have already done their own availability\n * calculation. Load the exact member URL for this manifest generation so an\n * older in-flight request cannot be reused by a replacement generation.\n */\nfunction loadVersionedInitialChunk(\n  chunkPath: ChunkPath,\n  chunkData: ChunkData,\n  versionToken: string\n) {\n  const memberChunkPath = getChunkPath(chunkData)\n  return loadChunkByUrlInternal(\n    SourceType.Runtime,\n    chunkPath,\n    getVersionedChunkUrl(memberChunkPath, versionToken)\n  )\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  for (const chunkPath of [...chunkPaths]) {\n    if (\n      removeChunkFromChunkList(chunkListPath, chunkPath) &&\n      !chunkChunkListsMap.has(chunkPath)\n    ) {\n      disposeChunk(chunkPath)\n    }\n  }\n  chunkListChunksMap.delete(chunkListPath)\n  chunkListGenerations.delete(chunkListPath)\n  dynamicChunkListLoadStates.delete(chunkListPath)\n  runtimeChunkLists.delete(chunkListPath)\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModulesMap.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction getDevChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    if (typeof document !== 'undefined') {\n      const src = document.currentScript?.getAttribute('src')\n      if (\n        src &&\n        getPathFromScript({ src } as ChunkScript) === (chunk as ChunkPath)\n      ) {\n        return { src } as CurrentScript\n      }\n    }\n    if (\n      typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' &&\n      TURBOPACK_NEXT_CHUNK_URLS.length > 0\n    ) {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    }\n  }\n  return getChunkFromRegistration(chunk)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getDevChunkFromRegistration(registration[0]) as\n    | ChunkPath\n    | ChunkScript\n  const chunkPath = getPathFromScript(chunk)\n  const chunkUrl = getUrlFromScript(chunk)\n  const canonicalChunkUrl = getChunkRelativeUrl(chunkPath)\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    if (\n      chunkUrl !== canonicalChunkUrl &&\n      isVersionedDynamicMemberChunkUrl(chunkUrl) &&\n      !dynamicMemberChunkUrlOwners.has(chunkUrl)\n    ) {\n      // Registration can race with cancellation even after its script element\n      // was removed. Only a live owner may install this content-versioned\n      // chunk; a later owner of the same URL is safe because its content is\n      // identical.\n      DEV_BACKEND.unloadChunkExact?.(chunkUrl)\n      return\n    }\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n\n  if (\n    runtimeParams === undefined &&\n    chunkUrl !== canonicalChunkUrl &&\n    DEV_BACKEND.resolveChunk\n  ) {\n    // Versioned development chunks have their own resolver. Resolving the\n    // canonical path here could let an older generation wake a newer load.\n    DEV_BACKEND.resolveChunk(chunkUrl)\n    return\n  }\n\n  const result = BACKEND.registerChunk(chunk, runtimeParams)\n  if (chunkUrl !== canonicalChunkUrl) {\n    DEV_BACKEND.resolveChunk?.(chunkUrl)\n  }\n  return result\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: DevChunkList) {\n  const chunkListScript = getDevChunkFromRegistration(chunkList.script) as\n    | ChunkListPath\n    | ChunkListScript\n  const chunkListPath = getPathFromScript(chunkListScript)\n  const generation = nextChunkListGeneration++\n  chunkListGenerations.set(chunkListPath, generation)\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  setChunkListChunks(chunkListPath, chunkPaths)\n\n  if (chunkList.source === 'entry') {\n    // Entry chunks have already loaded their member chunks while bootstrapping.\n    // The \"chunk\" registration completes the backend's initial load.\n    BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n    markChunkListAsRuntime(chunkListPath)\n    CHUNK_UPDATE_LISTENERS.push([\n      chunkListPath,\n      handleApply.bind(null, chunkListPath),\n      { batch: handleApplyBatch, expectedVersion: chunkList.version },\n    ])\n    return\n  }\n\n  if (typeof document === 'undefined') {\n    // Workers currently have no HMR transport/provider. Keep the dynamic\n    // chunk-list as a lightweight bootstrap, but load its members directly\n    // instead of waiting forever for an onSubscribed acknowledgement.\n    void Promise.all(\n      chunkList.chunks.map((chunkData) =>\n        loadInitialChunk(chunkListPath as string as ChunkPath, chunkData)\n      )\n    ).then(\n      () => BACKEND.registerChunk(chunkListPath as string as ChunkPath),\n      (cause) => {\n        const error =\n          cause instanceof Error\n            ? cause\n            : new Error(\n                `Failed to load a worker dynamic chunk group: ${String(cause)}`\n              )\n        DEV_BACKEND.rejectChunk?.(chunkListPath as string as ChunkPath, error)\n      }\n    )\n    return\n  }\n\n  // A dynamic chunk list is the bootstrap for its group. Establish the server\n  // baseline before fetching content, then hold updates while content loads.\n  // This closes the HTTP/WebSocket race where stale content could otherwise be\n  // fetched immediately before a newer subscription baseline was created.\n  const loadState: DynamicChunkListLoadState = {\n    generation,\n    loading: true,\n    bootstrapping: true,\n    terminated: false,\n    pendingTasks: new Set(),\n    memberChunkUrls: new Map(),\n  }\n  for (const chunkData of chunkList.chunks) {\n    const chunkPath = getChunkPath(chunkData)\n    const chunkVersion = chunkList.chunkVersions[chunkPath]\n    if (chunkVersion === undefined) {\n      throw new Error(`Missing version for dynamic member chunk ${chunkPath}`)\n    }\n    const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion)\n    loadState.memberChunkUrls.set(chunkPath, chunkUrl)\n    addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl)\n  }\n  dynamicChunkListLoadStates.set(chunkListPath, loadState)\n\n  let resolveSubscribed!: () => void\n  let revalidateSubscription!: () => Promise<void>\n  const subscribed = new Promise<void>((resolve, reject) => {\n    resolveSubscribed = resolve\n    loadState.rejectSubscribed = reject\n  })\n  CHUNK_UPDATE_LISTENERS.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n    {\n      batch: handleApplyBatch,\n      onSubscribed: (revalidate) => {\n        revalidateSubscription = revalidate\n        resolveSubscribed()\n      },\n      expectedVersion: chunkList.version,\n    },\n  ])\n\n  void (async () => {\n    try {\n      await subscribed\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        return\n      }\n\n      const memberResults = await Promise.allSettled(\n        chunkList.chunks.map((chunkData) =>\n          loadVersionedDynamicMemberChunk(\n            chunkListPath as string as ChunkPath,\n            chunkData,\n            chunkList.chunkVersions[getChunkPath(chunkData)]\n          )\n        )\n      )\n\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        for (const chunkPath of chunkPaths) {\n          if (!chunkChunkListsMap.has(chunkPath)) {\n            disposeChunk(chunkPath)\n          }\n        }\n        return\n      }\n\n      const failedMember = memberResults.find(\n        (result): result is PromiseRejectedResult =>\n          result.status === 'rejected'\n      )\n      if (failedMember) {\n        throw failedMember.reason\n      }\n\n      // The member URLs are served from the live output directory rather than\n      // a historical snapshot. Validate the manifest version again after all\n      // HTTP responses have completed, closing the subscription/HTTP race.\n      await revalidateSubscription()\n\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        return\n      }\n\n      for (const chunkUrl of loadState.memberChunkUrls.values()) {\n        completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl)\n      }\n\n      loadState.loading = false\n      flushPendingHmrTasks()\n      while (loadState.pendingTasks.size > 0) {\n        await Promise.all([...loadState.pendingTasks])\n      }\n\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        for (const chunkPath of chunkPaths) {\n          if (!chunkChunkListsMap.has(chunkPath)) {\n            disposeChunk(chunkPath)\n          }\n        }\n        return\n      }\n\n      // Resolving the bootstrap schedules the import continuation as a\n      // microtask. Every queued update and resource load has completed first,\n      // so user code cannot observe factories from an older manifest.\n      loadState.bootstrapping = false\n      BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n    } catch (cause) {\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        return\n      }\n      const error =\n        cause instanceof Error\n          ? cause\n          : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`)\n      terminateDynamicChunkListLoad(chunkListPath, loadState, error)\n      DEV_BACKEND.restart()\n    }\n  })()\n}\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","runtimeModules","Set","createModuleWithDirectionFlag","getRefreshBoundaryExports","exports","isAsyncModuleExt","turbopackExports","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","dynamicChunkListLoadStates","pendingHmrTasks","chunkListGenerations","nextChunkListGeneration","activeHmrTask","dynamicMemberChunkUrlOwners","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","refresh","call","k","sourceType","sourceData","createModuleObjectFn","createModuleObject","createContext","instantiateModuleShared","moduleFactories","runModuleExecutionHooks","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","add","PARALLEL_UPDATE_CONFLICT","Symbol","mergeParallelChunkUpdate","updateA","updateB","type","mergeParallelEcmascriptChunkUpdate","modules","added","deleted","has","delete","addedUpdate","deletedUpdate","length","moduleEntriesEqual","entryA","entryB","code","map","applyChunkListUpdates","updates","resourceOperations","ownershipTransitions","chunks","ecmascriptChunks","entries","explicitlyModifiedModules","hasConflict","chunkListPath","update","chunkUpdate","applyChunkListMembershipDelta","set","previous","get","merged","invariant","addedInThisUpdate","combined","entry","DEV_BACKEND","restart","filteredEcmascriptChunks","transition","before","after","keys","applyEcmascriptMergedUpdate","ownerCount","size","chunkUrl","getChunkRelativeUrl","promise","BACKEND","loadChunkCached","Update","reloadChunk","disposeChunk","instruction","JSON","stringify","modified","chunksAdded","chunksDeleted","computeChangedModules","applyEcmascriptMergedUpdateShared","evalModuleEntry","_eval","applyModuleFactoryName","autoAcceptRootModules","getCurrentTaskPaths","task","chunkLists","filter","path","generation","isHmrTaskBlocked","some","state","loading","runHmrTask","currentPaths","apply","results","Promise","allSettled","failedIndex","findIndex","result","index","status","reason","resolve","cause","reject","undefined","flushPendingHmrTasks","scheduleHmrTask","chunkListPaths","flatMap","completion","innerResolve","innerReject","bootstrapping","terminated","pendingTasks","then","shift","handleApplyBatch","relevantUpdates","resource","handledPaths","bootstrappingPaths","terminateDynamicChunkListLoad","Error","chunkListUpdates","handleApply","loadState","handleApplyImmediately","disposeChunkList","transitions","changed","addChunkToChunkList","removeChunkFromChunkList","chunkPaths","setChunkListChunks","nextChunkPaths","previousChunkPaths","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","rejectSubscribed","rejectChunk","memberChunkUrls","releaseDynamicMemberChunkUrlOwner","addDynamicMemberChunkUrlOwner","owners","isJs","unloadChunkExact","hasOtherChunkListOwner","owner","completeDynamicMemberChunkUrlOwner","loadVersionedDynamicMemberChunk","chunkData","versionToken","getChunkPath","getVersionedChunkUrl","isCss","loadChunkReplacing","loadVersionedInitialChunk","separator","includes","encodeURIComponent","isVersionedDynamicMemberChunkUrl","test","memberChunkPath","loadChunkByUrlInternal","chunkListUrl","unloadChunk","disposeModule","availableModules","markChunkListAsRuntime","getDevChunkFromRegistration","chunk","document","src","currentScript","getAttribute","getPathFromScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getChunkFromRegistration","registerChunk","registration","getUrlFromScript","canonicalChunkUrl","runtimeParams","installCompressedModuleFactories","resolveChunk","registerChunkList","chunkList","chunkListScript","script","source","CHUNK_UPDATE_LISTENERS","bind","batch","expectedVersion","version","all","loadInitialChunk","String","chunkVersion","chunkVersions","resolveSubscribed","revalidateSubscription","subscribed","onSubscribed","revalidate","memberResults","failedMember","find","values"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 2707, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 2950, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  type PendingChunkReload = {\n    link: HTMLLinkElement\n    reject: (error: Error) => void\n  }\n  const pendingChunkReloads = new Map<string, Set<PendingChunkReload>>()\n  const replacingCssLoads = new Map<ChunkUrl, Promise<void>>()\n\n  DEV_BACKEND = {\n    loadChunkReplacing(chunkUrl) {\n      if (!isCss(chunkUrl)) {\n        return Promise.reject(\n          new Error(\n            `Only CSS chunks can be replaced while loading: ${chunkUrl}`\n          )\n        )\n      }\n\n      const existingLoad = replacingCssLoads.get(chunkUrl)\n      if (existingLoad) return existingLoad\n\n      const baseChunkUrl = chunkUrl.split('?')[0]\n      const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n      const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?'\n      const decodedChunkUrl = decodeURI(chunkUrl)\n      const exactLinks = document.querySelectorAll(\n        `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}${cacheBusterSeparator}\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}${cacheBusterSeparator}\"]`\n      )\n      const baseLinks = document.querySelectorAll(\n        `link[rel=stylesheet][href=\"${baseChunkUrl}\"],link[rel=stylesheet][href^=\"${baseChunkUrl}?\"],link[rel=stylesheet][href=\"${decodedBaseChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedBaseChunkUrl}?\"]`\n      )\n\n      const load =\n        exactLinks.length > 0\n          ? resolveChunkResolver(chunkUrl)\n          : baseLinks.length === 0\n            ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl)\n            : DEV_BACKEND.reloadChunk!(chunkUrl).then(() =>\n                resolveChunkResolver(chunkUrl)\n              )\n      replacingCssLoads.set(chunkUrl, load)\n      void load.then(\n        () => {\n          if (replacingCssLoads.get(chunkUrl) === load) {\n            replacingCssLoads.delete(chunkUrl)\n          }\n        },\n        () => {\n          if (replacingCssLoads.get(chunkUrl) === load) {\n            replacingCssLoads.delete(chunkUrl)\n          }\n        }\n      )\n      return load\n    },\n\n    unloadChunk(chunkUrl) {\n      unloadChunk(chunkUrl, false)\n    },\n\n    unloadChunkExact(chunkUrl) {\n      unloadChunk(chunkUrl, true)\n    },\n\n    rejectChunk(chunkPath, error) {\n      const chunkUrl = getUrlFromScript(chunkPath)\n      const resolver = chunkResolvers.get(chunkUrl)\n      if (resolver) rejectResolver(chunkUrl, resolver, error)\n    },\n\n    resolveChunk(chunkUrl) {\n      resolveChunkResolver(chunkUrl)\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        // Strip query string so we match links regardless of cache-busting\n        // params (e.g. ?ts=) that may differ between HMR updates.\n        const baseChunkUrl = chunkUrl.split('?')[0]\n        const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${baseChunkUrl}\"],link[rel=stylesheet][href^=\"${baseChunkUrl}?\"],link[rel=stylesheet][href=\"${decodedBaseChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedBaseChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const currentReloads = pendingChunkReloads.get(baseChunkUrl)\n        if (currentReloads) {\n          const suffix = chunkUrl.includes('?') ? '&' : '?'\n          for (const reload of [...currentReloads]) {\n            const href = reload.link.getAttribute('href')\n            if (\n              href !== chunkUrl &&\n              !href?.startsWith(`${chunkUrl}${suffix}`)\n            ) {\n              reload.reject(\n                new Error(\n                  `CSS chunk ${chunkUrl} superseded an in-flight reload.`\n                )\n              )\n            }\n          }\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n        link.crossOrigin = CROSS_ORIGIN\n        let pendingReloads = pendingChunkReloads.get(baseChunkUrl)\n        if (!pendingReloads) {\n          pendingReloads = new Set()\n          pendingChunkReloads.set(baseChunkUrl, pendingReloads)\n        }\n        const cleanup = () => {\n          pendingReloads!.delete(pendingReload)\n          if (pendingReloads!.size === 0) {\n            pendingChunkReloads.delete(baseChunkUrl)\n          }\n        }\n        const pendingReload: PendingChunkReload = {\n          link,\n          reject: (error) => {\n            cleanup()\n            link.onload = null\n            link.onerror = null\n            link.remove()\n            reject(error)\n          },\n        }\n        pendingReloads.add(pendingReload)\n\n        if (\n          navigator.userAgent.includes('Firefox') ||\n          (navigator.userAgent.includes('Safari') &&\n            !navigator.userAgent.includes('Chrome') &&\n            !navigator.userAgent.includes('Chromium'))\n        ) {\n          // Firefox won't reload CSS files that were previously loaded on the\n          // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari serves cached CSS when a <link rel=preload> exists for the\n          // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726\n          //\n          // Replace or add a fresh `ts` cache-busting param without\n          // discarding other query parameters that may already be present.\n          const url = new URL(chunkUrl, location.origin)\n          // Reduced timer precision in some browers could lead to an update getting dropped\n          // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).\n          // So trust that the server is only updating us when it is important and use a\n          // random number to bust the cache.\n          url.searchParams.set('ts', `${Date.now()}.${Math.random()}`)\n          link.href = url.pathname + url.search\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          pendingReload.reject(\n            new Error(`Failed to reload CSS chunk ${chunkUrl}`)\n          )\n        }\n        link.onload = () => {\n          cleanup()\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function rejectResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function resolveChunkResolver(chunkUrl: ChunkUrl): Promise<void> {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    resolver.resolve()\n    return resolver.promise\n  }\n\n  function unloadChunk(chunkUrl: ChunkUrl, exact: boolean) {\n    deleteResolvers(chunkUrl, exact)\n\n    const baseChunkUrl = chunkUrl.split('?')[0]\n    const reloads = pendingChunkReloads.get(baseChunkUrl)\n    if (reloads) {\n      for (const reload of [...reloads]) {\n        const href = reload.link.getAttribute('href')\n        const suffix = chunkUrl.includes('?') ? '&' : '?'\n        if (\n          !exact ||\n          href === chunkUrl ||\n          href?.startsWith(`${chunkUrl}${suffix}`)\n        ) {\n          reload.reject(\n            new Error(`Chunk ${chunkUrl} was unloaded while reloading.`)\n          )\n        }\n      }\n    }\n\n    // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n    const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl)\n    const path = exact ? chunkUrl : baseChunkUrl\n    const suffix = exact ? (path.includes('?') ? '&' : '?') : '?'\n\n    if (isCss(chunkUrl)) {\n      const links = document.querySelectorAll(\n        `link[href=\"${path}\"],link[href^=\"${path}${suffix}\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}${suffix}\"]`\n      )\n      for (const link of Array.from(links)) {\n        link.remove()\n      }\n    } else if (isJs(chunkUrl)) {\n      // Unloading a JS chunk would have no effect once it has executed, but\n      // removing the exact stale registration keeps the DOM and resolver cache\n      // bounded without touching a newer generation of the same chunk path.\n      const scripts = document.querySelectorAll(\n        `script[src=\"${path}\"],script[src^=\"${path}${suffix}\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}${suffix}\"]`\n      )\n      for (const script of Array.from(scripts)) {\n        script.remove()\n      }\n    } else {\n      throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n    }\n  }\n\n  function deleteResolvers(chunkUrl: ChunkUrl, exact: boolean) {\n    const baseChunkUrl = chunkUrl.split('?')[0]\n    for (const [resolverUrl, resolver] of [...chunkResolvers]) {\n      if (\n        exact\n          ? resolverUrl !== chunkUrl\n          : resolverUrl.split('?')[0] !== baseChunkUrl\n      ) {\n        continue\n      }\n      if (resolver.resolved) {\n        chunkResolvers.delete(resolverUrl)\n      } else {\n        rejectResolver(\n          resolverUrl,\n          resolver,\n          new Error(`Chunk ${resolverUrl} was unloaded while loading.`)\n        )\n      }\n    }\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","pendingChunkReloads","Map","replacingCssLoads","loadChunkReplacing","chunkUrl","isCss","Promise","reject","Error","existingLoad","get","baseChunkUrl","split","decodedBaseChunkUrl","decodeURI","cacheBusterSeparator","includes","decodedChunkUrl","exactLinks","document","querySelectorAll","baseLinks","load","length","resolveChunkResolver","BACKEND","loadChunkCached","SourceType","Runtime","reloadChunk","then","set","delete","unloadChunk","unloadChunkExact","rejectChunk","chunkPath","error","getUrlFromScript","resolver","chunkResolvers","rejectResolver","resolveChunk","resolve","previousLinks","currentReloads","suffix","reload","href","link","getAttribute","startsWith","createElement","rel","crossOrigin","CROSS_ORIGIN","pendingReloads","Set","cleanup","pendingReload","size","onload","onerror","remove","add","navigator","userAgent","url","URL","location","origin","searchParams","Date","now","Math","random","pathname","search","previousLink","Array","from","parentElement","insertBefore","nextSibling","restart","self","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","exact","deleteResolvers","reloads","path","links","isJs","scripts","script","resolverUrl","_eval","code","map","encodeURI","CHUNK_BASE_PATH","ASSET_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/style/css_filename_dev/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/style/css_filename_dev/output/input_index_83022b3b.js
deleted file mode 100644
index 560892407..000000000
--- a/crates/pack-tests/tests/snapshot/style/css_filename_dev/output/input_index_83022b3b.js
+++ /dev/null
@@ -1,5 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["styles/input_style_b6e2d8cb.dev.css","input_index_bdf2db6d.js"],
-    source: "entry"
-});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/style/emotion_dev/output/input_index_tsx_83022b3b.js b/crates/pack-tests/tests/snapshot/style/emotion_dev/output/input_index_tsx_83022b3b.js
deleted file mode 100644
index 2d791252e..000000000
--- a/crates/pack-tests/tests/snapshot/style/emotion_dev/output/input_index_tsx_83022b3b.js
+++ /dev/null
@@ -1,5 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["_project___e9ec4102.js"],
-    source: "entry"
-});
diff --git a/e2e/pack-hmr/pack-hmr.spec.ts b/e2e/pack-hmr/pack-hmr.spec.ts
index 53f40ee5f..81a347312 100644
--- a/e2e/pack-hmr/pack-hmr.spec.ts
+++ b/e2e/pack-hmr/pack-hmr.spec.ts
@@ -64,18 +64,36 @@ async function mutateAndWaitForBuild(page: Page, mutate: () => void) {
     .poll(() => pageReadySockets.get(page)?.size ?? 0)
     .toBeGreaterThan(0);
   const frameStart = frames.length;
+  let buildInProgress = false;
+  for (const frame of frames.slice(0, frameStart)) {
+    const action = frameAction(frame);
+    if (action === "building") buildInProgress = true;
+    if (action === "built") buildInProgress = false;
+  }
   mutate();
-  await expect
-    .poll(() => {
-      let building = false;
-      for (const frame of frames.slice(frameStart)) {
-        const action = frameAction(frame);
-        if (action === "building") building = true;
-        if (building && action === "built") return true;
-      }
-      return false;
-    })
-    .toBe(true);
+  try {
+    await expect
+      .poll(() => {
+        // A mutation can join compilation work that was already started by a
+        // lazy chunk load. In that case BUILDING legitimately precedes
+        // frameStart. Preserve that unmatched BUILDING state, but do not treat
+        // a subscription baseline message as mutation-triggered activity.
+        let activity = buildInProgress;
+        for (const frame of frames.slice(frameStart)) {
+          const action = frameAction(frame);
+          if (action === "building") activity = true;
+          if (activity && action === "built") return true;
+        }
+        return false;
+      })
+      .toBe(true);
+  } catch (error) {
+    console.error(
+      "HMR frames received after the test mutation:",
+      frames.slice(frameStart).map(frameAction),
+    );
+    throw error;
+  }
 }
 
 test.afterEach(async () => {

From 49ed722e7a8f64ecce56986a21300afb093595d9 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Fri, 24 Jul 2026 10:58:54 +0800
Subject: [PATCH 09/11] test(pack): align HMR coverage with rebased fork

---
 .../output/_root-of-the-server___7c304173.js  | 192 +---
 .../output/input_index_83022b3b.js            |   6 +-
 .../output/input_lazy_0468b002.js             |   4 +-
 .../hmr/dynamic_chunk_lists/output/main.js    | 996 +++---------------
 .../output/main.js                            | 996 +++---------------
 e2e/pack-hmr/pack-hmr.spec.ts                 | 329 +++---
 6 files changed, 508 insertions(+), 2015 deletions(-)

diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
index 83dc4c3af..36bb751ef 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
@@ -709,34 +709,27 @@ __turbopack_context__.s([
 ]);
 const TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL = 'TURBOPACK_CHUNK_UPDATE_LISTENERS';
 function connect({ addMessageListener, sendMessage, onUpdateError = console.error, chunkUpdateListenersGlobal }) {
-    const reportUpdateError = (e)=>{
-        console.warn('[Fast Refresh] performing full reload\n\n' + "Fast Refresh will perform a full reload when you edit a file that's imported by modules outside of the React rendering tree.\n" + 'You might have a file which exports a React component but also exports a value that is imported by a non-React component file.\n' + 'Consider migrating the non-React component export to a separate file and importing it into both files.\n\n' + 'It is also possible the parent component of the component you edited is a class component, which disables Fast Refresh.\n' + 'Fast Refresh requires at least one parent function component in your React tree.');
-        onUpdateError(e);
-        location.reload();
-    };
     addMessageListener((msg)=>{
-        try {
-            switch(msg.type){
-                case 'turbopack-connected':
-                    handleSocketConnected(sendMessage);
-                    break;
-                default:
-                    {
-                        const completions = [];
-                        if (Array.isArray(msg.data)) {
-                            for(let i = 0; i < msg.data.length; i++){
-                                completions.push(handleSocketMessage(msg.data[i]));
-                            }
-                        } else {
-                            completions.push(handleSocketMessage(msg.data));
+        switch(msg.type){
+            case 'turbopack-connected':
+                handleSocketConnected(sendMessage);
+                break;
+            default:
+                try {
+                    if (Array.isArray(msg.data)) {
+                        for(let i = 0; i < msg.data.length; i++){
+                            handleSocketMessage(msg.data[i]);
                         }
-                        completions.push(applyAggregatedUpdates());
-                        void Promise.all(completions).catch(reportUpdateError);
-                        break;
+                    } else {
+                        handleSocketMessage(msg.data);
                     }
-            }
-        } catch (e) {
-            reportUpdateError(e);
+                    applyAggregatedUpdates();
+                } catch (e) {
+                    console.warn('[Fast Refresh] performing full reload\n\n' + "Fast Refresh will perform a full reload when you edit a file that's imported by modules outside of the React rendering tree.\n" + 'You might have a file which exports a React component but also exports a value that is imported by a non-React component file.\n' + 'Consider migrating the non-React component export to a separate file and importing it into both files.\n\n' + 'It is also possible the parent component of the component you edited is a class component, which disables Fast Refresh.\n' + 'Fast Refresh requires at least one parent function component in your React tree.');
+                    onUpdateError(e);
+                    location.reload();
+                }
+                break;
         }
     });
     const global = globalThis;
@@ -746,12 +739,12 @@ function connect({ addMessageListener, sendMessage, onUpdateError = console.erro
     }
     global[chunkUpdateListenersGlobal] = {
         push: ([chunkPath, callback, options])=>{
-            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.batch, options?.onSubscribed, options?.expectedVersion);
+            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.conservative, options?.onSubscribed, options?.expectedVersion);
         }
     };
     if (Array.isArray(queued)) {
         for (const [chunkPath, callback, options] of queued){
-            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.batch, options?.onSubscribed, options?.expectedVersion);
+            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.conservative, options?.onSubscribed, options?.expectedVersion);
         }
     }
 }
@@ -765,6 +758,9 @@ function resourceKey(resource) {
         headers: resource.headers || null
     });
 }
+function createValidationToken() {
+    return `${Date.now()}:${Math.random()}`;
+}
 function subscribeToUpdates(sendMessage, resource, expectedVersion, validation) {
     sendJSON(sendMessage, {
         type: 'turbopack-subscribe',
@@ -782,6 +778,9 @@ function subscribeToUpdates(sendMessage, resource, expectedVersion, validation)
 function handleSocketConnected(sendMessage) {
     for (const [key, callbackSet] of updateCallbackSets){
         callbackSet.subscribed = false;
+        if (callbackSet.validationToken !== undefined) {
+            callbackSet.validationToken = createValidationToken();
+        }
         callbackSet.unsubscribe = subscribeToUpdates(sendMessage, JSON.parse(key), callbackSet.expectedVersion, callbackSet.validationToken);
     }
 }
@@ -797,57 +796,19 @@ function aggregateUpdates(msg) {
     }
 }
 function applyAggregatedUpdates() {
-    if (chunkListsWithPendingUpdates.size === 0) return Promise.resolve();
-    hooks.beforeRefresh();
+    if (chunkListsWithPendingUpdates.size === 0) return;
     const updates = [
         ...chunkListsWithPendingUpdates.values()
     ];
     chunkListsWithPendingUpdates.clear();
-    const { handledCallbacks, completions } = triggerUpdateBatch(updates);
-    for (const msg of updates){
-        completions.push(...triggerUpdate(msg, handledCallbacks.get(msg.resource.path)));
+    if (updates.length > 1 && updates.some((update)=>updateCallbackSets.get(resourceKey(update.resource))?.conservative)) {
+        throw new Error('Multiple dynamic HMR lists changed in one build; reloading conservatively.');
     }
-    return Promise.all(completions).then(()=>finalizeUpdate());
-}
-function triggerUpdateBatch(updates) {
-    const callbacks = new Map();
-    for (const update of updates){
-        const callbackSet = updateCallbackSets.get(resourceKey(update.resource));
-        if (callbackSet) {
-            for (const [callback, updateCallbacks] of callbackSet.batchCallbacks){
-                let registeredCallbacks = callbacks.get(callback);
-                if (!registeredCallbacks) {
-                    registeredCallbacks = new Set();
-                    callbacks.set(callback, registeredCallbacks);
-                }
-                for (const updateCallback of updateCallbacks){
-                    registeredCallbacks.add(updateCallback);
-                }
-            }
-        }
-    }
-    const handledCallbacks = new Map();
-    const completions = [];
-    for (const [callback, updateCallbacks] of callbacks){
-        const result = callback(updates);
-        if (result.completion) {
-            completions.push(result.completion);
-        }
-        for (const path of result.handledPaths){
-            let callbacksForPath = handledCallbacks.get(path);
-            if (!callbacksForPath) {
-                callbacksForPath = new Set();
-                handledCallbacks.set(path, callbacksForPath);
-            }
-            for (const updateCallback of updateCallbacks){
-                callbacksForPath.add(updateCallback);
-            }
-        }
+    hooks.beforeRefresh();
+    for (const msg of updates){
+        triggerUpdate(msg);
     }
-    return {
-        handledCallbacks,
-        completions
-    };
+    finalizeUpdate();
 }
 function mergeChunkListUpdates(updateA, updateB) {
     let chunks;
@@ -1139,15 +1100,12 @@ function setHooks(newHooks) {
 function handleSocketMessage(msg) {
     const callbackSet = updateCallbackSets.get(resourceKey(msg.resource));
     if (!callbackSet || callbackSet.validationToken !== msg.validation) {
-        // An unsubscribe cannot retract frames which were already queued on the
-        // transport. Ignore frames from an older subscription generation.
-        return Promise.resolve();
+        // Frames already queued by an old subscription can arrive after an
+        // unsubscribe. Only the active validation generation may update state.
+        return;
     }
     sortIssues(msg.issues);
     const hasCriticalIssues = handleIssues(msg);
-    // A real issues message is the server's baseline acknowledgement. Updates
-    // received before that acknowledgement cannot safely be applied to dynamic
-    // chunks which may still be loading from HTTP.
     if (!hasCriticalIssues && msg.type === 'issues') {
         markUpdateSubscriptionReady(msg.resource);
     } else if (msg.type !== 'issues') {
@@ -1155,26 +1113,23 @@ function handleSocketMessage(msg) {
     }
     switch(msg.type){
         case 'issues':
-            // issues are already handled
-            return Promise.resolve();
+            break;
         case 'partial':
             // aggregate updates
             aggregateUpdates(msg);
-            return Promise.resolve();
+            break;
         default:
             // run single update
             const runHooks = chunkListsWithPendingUpdates.size === 0;
             if (runHooks) hooks.beforeRefresh();
-            return Promise.all(triggerUpdate(msg)).then(()=>{
-                if (runHooks) finalizeUpdate();
-            });
+            triggerUpdate(msg);
+            if (runHooks) finalizeUpdate();
+            break;
     }
 }
 function markUpdateSubscriptionReady(resource) {
     const callbackSet = updateCallbackSets.get(resourceKey(resource));
-    if (!callbackSet || callbackSet.subscribed) {
-        return;
-    }
+    if (!callbackSet || callbackSet.subscribed) return;
     callbackSet.subscribed = true;
     callbackSet.validation?.resolve();
     callbackSet.validation = undefined;
@@ -1200,27 +1155,25 @@ function finalizeUpdate() {
         globalThis.__NEXT_HMR_CB = null;
     }
 }
-function subscribeToChunkUpdate(chunkListPath, sendMessage, callback, batchCallback, onSubscribed, expectedVersion) {
+function subscribeToChunkUpdate(chunkListPath, sendMessage, callback, conservative, onSubscribed, expectedVersion) {
     return subscribeToUpdate({
         path: chunkListPath
-    }, sendMessage, callback, batchCallback, onSubscribed, expectedVersion);
+    }, sendMessage, callback, conservative, onSubscribed, expectedVersion);
 }
-function subscribeToUpdate(resource, sendMessage, callback, batchCallback, onSubscribed, expectedVersion) {
+function subscribeToUpdate(resource, sendMessage, callback, conservative, onSubscribed, expectedVersion) {
     const key = resourceKey(resource);
     let callbackSet;
     const existingCallbackSet = updateCallbackSets.get(key);
     if (!existingCallbackSet) {
         let callbackSetRef;
         const revalidate = ()=>{
-            if (callbackSetRef.validation) {
-                return callbackSetRef.validation.promise;
-            }
+            if (callbackSetRef.validation) return callbackSetRef.validation.promise;
             if (updateCallbackSets.get(key) !== callbackSetRef) {
                 return Promise.reject(new Error(`Cannot validate an inactive HMR subscription for ${resource.path}.`));
             }
             callbackSetRef.unsubscribe();
             callbackSetRef.subscribed = false;
-            callbackSetRef.validationToken = `${Date.now()}:${Math.random()}`;
+            callbackSetRef.validationToken = createValidationToken();
             let resolve;
             let reject;
             const promise = new Promise((innerResolve, innerReject)=>{
@@ -1235,43 +1188,30 @@ function subscribeToUpdate(resource, sendMessage, callback, batchCallback, onSub
             callbackSetRef.unsubscribe = subscribeToUpdates(sendMessage, resource, expectedVersion, callbackSetRef.validationToken);
             return promise;
         };
+        const validationToken = onSubscribed ? createValidationToken() : undefined;
         callbackSet = {
             callbacks: new Set([
                 callback
             ]),
-            batchCallbacks: new Map(batchCallback ? [
-                [
-                    batchCallback,
-                    new Set([
-                        callback
-                    ])
-                ]
-            ] : []),
+            conservative: Boolean(conservative),
             onSubscribedCallbacks: new Set(onSubscribed ? [
                 onSubscribed
             ] : []),
             subscribed: false,
             expectedVersion,
+            validationToken,
             revalidate,
-            unsubscribe: subscribeToUpdates(sendMessage, resource, expectedVersion)
+            unsubscribe: subscribeToUpdates(sendMessage, resource, expectedVersion, validationToken)
         };
         callbackSetRef = callbackSet;
         updateCallbackSets.set(key, callbackSet);
     } else {
         if (existingCallbackSet.expectedVersion !== expectedVersion) {
-            // Two manifests for the same stable chunk-list path cannot safely share
-            // a version baseline. Reload rather than acknowledging stale content.
             location.reload();
+            return ()=>{};
         }
         existingCallbackSet.callbacks.add(callback);
-        if (batchCallback) {
-            let callbacks = existingCallbackSet.batchCallbacks.get(batchCallback);
-            if (!callbacks) {
-                callbacks = new Set();
-                existingCallbackSet.batchCallbacks.set(batchCallback, callbacks);
-            }
-            callbacks.add(callback);
-        }
+        existingCallbackSet.conservative ||= Boolean(conservative);
         if (onSubscribed) {
             if (existingCallbackSet.subscribed) {
                 onSubscribed(existingCallbackSet.revalidate);
@@ -1283,16 +1223,7 @@ function subscribeToUpdate(resource, sendMessage, callback, batchCallback, onSub
     }
     return ()=>{
         callbackSet.callbacks.delete(callback);
-        if (batchCallback) {
-            const callbacks = callbackSet.batchCallbacks.get(batchCallback);
-            callbacks?.delete(callback);
-            if (callbacks?.size === 0) {
-                callbackSet.batchCallbacks.delete(batchCallback);
-            }
-        }
-        if (onSubscribed) {
-            callbackSet.onSubscribedCallbacks.delete(onSubscribed);
-        }
+        if (onSubscribed) callbackSet.onSubscribedCallbacks.delete(onSubscribed);
         if (callbackSet.callbacks.size === 0) {
             callbackSet.unsubscribe();
             updateCallbackSets.delete(key);
@@ -1302,20 +1233,14 @@ function subscribeToUpdate(resource, sendMessage, callback, batchCallback, onSub
         }
     };
 }
-function triggerUpdate(msg, skippedCallbacks) {
+function triggerUpdate(msg) {
     const key = resourceKey(msg.resource);
     const callbackSet = updateCallbackSets.get(key);
     if (!callbackSet) {
-        return [];
+        return;
     }
-    const completions = [];
     for (const callback of callbackSet.callbacks){
-        if (!skippedCallbacks?.has(callback)) {
-            const completion = callback(msg);
-            if (completion) {
-                completions.push(completion);
-            }
-        }
+        callback(msg);
     }
     if (msg.type === 'notFound') {
         // This indicates that the resource which we subscribed to either does not exist or
@@ -1326,7 +1251,6 @@ function triggerUpdate(msg, skippedCallbacks) {
         // dropped the update stream before sending the "notFound" message.
         updateCallbackSets.delete(key);
     }
-    return completions;
 }
 }),
-]);
+]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
index a5ebcc405..d3aa94f2c 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
@@ -1,7 +1,5 @@
 (globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
     script: typeof document === "object" ? document.currentScript : undefined,
     chunks: ["input_lazy_b90c1087.js","_root-of-the-server___7c304173.js"],
-    chunkVersions: {},
-    source: "entry",
-    version: "eYoNAFE8+JU"
-});
+    source: "entry"
+});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
index 04aaa0617..026c44090 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
@@ -1,7 +1,7 @@
 (globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
     script: typeof document === "object" ? document.currentScript : undefined,
     chunks: ["input_lazy_5395e95a.js"],
-    chunkVersions: {"input_lazy_5395e95a.js":"kLSvJuOI5c4"},
     source: "dynamic",
-    version: "ajrJuYAhFyU"
+chunkVersions: {"input_lazy_5395e95a.js":"kLSvJuOI5c4"},
+version: "ajrJuYAhFyU"
 });
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
index 5df61b091..e88c7cf64 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
@@ -1641,12 +1641,8 @@ function getRefreshBoundaryExports(exports) {
 /**
  * Map from a chunk path to the chunk lists it belongs to.
  */ const chunkChunkListsMap = new Map();
-const dynamicChunkListLoadStates = new Map();
-const pendingHmrTasks = [];
-const chunkListGenerations = new Map();
-let nextChunkListGeneration = 1;
-let activeHmrTask;
-const dynamicMemberChunkUrlOwners = new Map();
+/** Dynamic lists use a stricter, reload-on-ambiguity update policy. */ const dynamicChunkLists = new Set();
+/** Dynamic manifests which have not finished their subscribe/load/revalidate handshake. */ const loadingDynamicChunkLists = new Set();
 /**
  * Gets or instantiates a runtime module.
  */ // @ts-ignore
@@ -1796,259 +1792,48 @@ const DUMMY_REFRESH_CONTEXT = {
         disposedModules
     };
 }
-const PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict');
-function mergeParallelChunkUpdate(updateA, updateB) {
-    if (updateA.type === updateB.type) {
-        return updateA;
-    }
-    if (updateA.type === 'total' || updateB.type === 'total') {
-        return {
-            type: 'total'
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        return null;
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
     }
-    return PARALLEL_UPDATE_CONFLICT;
 }
-function mergeParallelEcmascriptChunkUpdate(updateA, updateB) {
-    if (updateA.type === 'added' && updateB.type === 'added') {
-        return {
-            type: 'added',
-            modules: [
-                ...new Set([
-                    ...updateA.modules ?? [],
-                    ...updateB.modules ?? []
-                ])
-            ]
-        };
-    }
-    if (updateA.type === 'deleted' && updateB.type === 'deleted') {
-        return {
-            type: 'deleted',
-            modules: [
-                ...new Set([
-                    ...updateA.modules ?? [],
-                    ...updateB.modules ?? []
-                ])
-            ]
-        };
-    }
-    if (updateA.type === 'partial' && updateB.type === 'partial') {
-        const added = new Set([
-            ...updateA.added ?? [],
-            ...updateB.added ?? []
-        ]);
-        const deleted = new Set([
-            ...updateA.deleted ?? [],
-            ...updateB.deleted ?? []
-        ]);
-        for (const moduleId of added){
-            if (deleted.has(moduleId)) {
-                added.delete(moduleId);
-                deleted.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        const addedUpdate = updateA.type === 'added' ? updateA : updateB;
-        const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB;
-        const added = new Set(addedUpdate.modules ?? []);
-        const deleted = new Set(deletedUpdate.modules ?? []);
-        for (const moduleId of added){
-            if (deleted.has(moduleId)) {
-                added.delete(moduleId);
-                deleted.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'partial') {
-        if ((updateA.added?.length ?? 0) === 0 && (updateA.deleted?.length ?? 0) === 0) {
-            return updateB;
-        }
-        return PARALLEL_UPDATE_CONFLICT;
-    }
-    if (updateB.type === 'partial') {
-        if ((updateB.added?.length ?? 0) === 0 && (updateB.deleted?.length ?? 0) === 0) {
-            return updateA;
-        }
-        return PARALLEL_UPDATE_CONFLICT;
-    }
-    return PARALLEL_UPDATE_CONFLICT;
-}
-function moduleEntriesEqual(entryA, entryB) {
-    // The same module can be emitted into multiple chunks. Its source URL is
-    // chunk-relative, so it is allowed to differ even when the executable entry
-    // is identical. Treat only code and source map differences as conflicts.
-    return entryA.code === entryB.code && entryA.map === entryB.map;
-}
-function applyChunkListUpdates(updates) {
-    const resourceOperations = [];
-    const ownershipTransitions = new Map();
-    const chunks = new Map();
-    const ecmascriptChunks = new Map();
-    const entries = {};
-    const explicitlyModifiedModules = new Set();
-    let hasConflict = false;
-    for (const { chunkListPath, update } of updates){
-        if (update.chunks) {
-            for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-                if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, chunkUpdate.type, ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                }
-                if (!chunks.has(chunkPath)) {
-                    chunks.set(chunkPath, chunkUpdate);
-                } else {
-                    const previous = chunks.get(chunkPath);
-                    if (previous === null) {
-                        chunks.set(chunkPath, chunkUpdate);
-                    } else {
-                        const merged = mergeParallelChunkUpdate(previous, chunkUpdate);
-                        if (merged === PARALLEL_UPDATE_CONFLICT) {
-                            hasConflict = true;
-                        } else {
-                            chunks.set(chunkPath, merged);
-                        }
-                    }
-                }
-            }
-        }
-        for (const merged of update.merged ?? []){
-            if (merged.type !== 'EcmascriptMergedUpdate') {
-                invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
-            }
-            const addedInThisUpdate = new Set();
-            for (const [chunkPath, chunkUpdate] of Object.entries(merged.chunks ?? {})){
-                if (chunkUpdate.type === 'added') {
-                    for (const moduleId of chunkUpdate.modules ?? []){
-                        addedInThisUpdate.add(moduleId);
-                    }
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'added', ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                } else if (chunkUpdate.type === 'deleted') {
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'deleted', ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                } else {
-                    for (const moduleId of chunkUpdate.added ?? []){
-                        addedInThisUpdate.add(moduleId);
-                    }
-                }
-                const previous = ecmascriptChunks.get(chunkPath);
-                if (!previous) {
-                    ecmascriptChunks.set(chunkPath, chunkUpdate);
-                } else {
-                    const combined = mergeParallelEcmascriptChunkUpdate(previous, chunkUpdate);
-                    if (combined === PARALLEL_UPDATE_CONFLICT) {
-                        hasConflict = true;
-                    } else {
-                        ecmascriptChunks.set(chunkPath, combined);
-                    }
-                }
-            }
-            for (const [moduleId, entry] of Object.entries(merged.entries ?? {})){
-                const previous = entries[moduleId];
-                if (previous) {
-                    if (!moduleEntriesEqual(previous, entry)) {
-                        hasConflict = true;
-                    }
-                } else {
-                    entries[moduleId] = entry;
-                }
-                if (!addedInThisUpdate.has(moduleId)) {
-                    explicitlyModifiedModules.add(moduleId);
-                }
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
             }
         }
     }
-    if (hasConflict) {
-        DEV_BACKEND.restart();
-        return resourceOperations;
-    }
-    const filteredEcmascriptChunks = {};
-    for (const [chunkPath, chunkUpdate] of ecmascriptChunks){
-        const transition = ownershipTransitions.get(chunkPath);
-        if (chunkUpdate.type === 'added' && transition && transition.before > 0) {
-            for (const moduleId of chunkUpdate.modules ?? []){
-                if (!explicitlyModifiedModules.has(moduleId)) {
-                    delete entries[moduleId];
-                }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
             }
-            continue;
-        }
-        if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {
-            continue;
-        }
-        filteredEcmascriptChunks[chunkPath] = chunkUpdate;
-    }
-    if (Object.keys(entries).length > 0 || Object.keys(filteredEcmascriptChunks).length > 0) {
-        applyEcmascriptMergedUpdate({
-            type: 'EcmascriptMergedUpdate',
-            entries,
-            chunks: filteredEcmascriptChunks
-        });
-    }
-    for (const [chunkPath, chunkUpdate] of chunks){
-        if (chunkUpdate === null) {
-            continue;
-        }
-        const transition = ownershipTransitions.get(chunkPath);
-        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-        const chunkUrl = getChunkRelativeUrl(chunkPath);
-        switch(chunkUpdate.type){
-            case 'added':
-                if (!transition || transition.before === 0 && transition.after > 0) {
-                    resourceOperations.push({
-                        chunkPath,
-                        promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl)
-                    });
-                }
-                break;
-            case 'total':
-                if (ownerCount > 0) {
-                    const promise = DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    if (promise) {
-                        resourceOperations.push({
-                            chunkPath,
-                            promise
-                        });
-                    }
-                }
-                break;
-            case 'deleted':
-                if (!transition || transition.before > 0 && transition.after === 0) {
-                    disposeChunk(chunkPath);
-                }
-                break;
-            case 'partial':
-                invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                break;
-            default:
-                invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
         }
     }
-    return resourceOperations;
 }
 function applyEcmascriptMergedUpdate(update) {
     // Browser-specific chunk management phase
@@ -2068,196 +1853,27 @@ function applyEcmascriptMergedUpdate(update) {
         autoAcceptRootModules: false
     });
 }
-function getCurrentTaskPaths(task) {
-    return task.chunkLists.filter(({ path, generation })=>chunkListGenerations.get(path) === generation).map(({ path })=>path);
-}
-function isHmrTaskBlocked(task) {
-    return task.chunkLists.some(({ path, generation })=>{
-        if (chunkListGenerations.get(path) !== generation) return false;
-        const state = dynamicChunkListLoadStates.get(path);
-        return state?.generation === generation && state.loading;
-    });
-}
-function runHmrTask(task) {
-    activeHmrTask = task;
-    void (async ()=>{
-        let resourceOperations = [];
-        try {
-            const currentPaths = new Set(getCurrentTaskPaths(task));
-            if (currentPaths.size > 0) {
-                resourceOperations = task.apply(currentPaths);
-                const results = await Promise.allSettled(resourceOperations.map(({ promise })=>promise));
-                const failedIndex = results.findIndex((result, index)=>result.status === 'rejected' && chunkChunkListsMap.has(resourceOperations[index].chunkPath));
-                if (failedIndex !== -1) {
-                    throw results[failedIndex].reason;
-                }
-            }
-            task.resolve();
-        } catch (cause) {
-            // A terminal update invalidates the generation immediately. Any member
-            // request it cancelled belongs to that old generation and must not turn
-            // a valid replacement subscription into a page reload.
-            if (getCurrentTaskPaths(task).length === 0) {
-                task.resolve();
-            } else {
-                task.reject(cause);
-            }
-        } finally{
-            for (const { chunkPath } of resourceOperations){
-                if (!chunkChunkListsMap.has(chunkPath)) {
-                    disposeChunk(chunkPath);
-                }
-            }
-            if (activeHmrTask === task) {
-                activeHmrTask = undefined;
-            }
-            flushPendingHmrTasks();
-        }
-    })();
-}
-function scheduleHmrTask(chunkListPaths, apply) {
-    const chunkLists = [
-        ...new Set(chunkListPaths)
-    ].flatMap((path)=>{
-        const generation = chunkListGenerations.get(path);
-        return generation === undefined ? [] : [
-            {
-                path,
-                generation
-            }
-        ];
-    });
-    if (chunkLists.length === 0) {
-        return Promise.resolve();
-    }
-    let resolve;
-    let reject;
-    const completion = new Promise((innerResolve, innerReject)=>{
-        resolve = innerResolve;
-        reject = innerReject;
-    });
-    const task = {
-        chunkLists,
-        apply,
-        resolve,
-        reject
-    };
-    for (const { path, generation } of chunkLists){
-        const state = dynamicChunkListLoadStates.get(path);
-        if (state?.generation === generation && state.bootstrapping && !state.terminated) {
-            state.pendingTasks.add(completion);
-            void completion.then(()=>state.pendingTasks.delete(completion), ()=>state.pendingTasks.delete(completion));
-        }
-    }
-    if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {
-        pendingHmrTasks.push(task);
-        flushPendingHmrTasks();
-    } else {
-        runHmrTask(task);
-    }
-    return completion;
-}
-function flushPendingHmrTasks() {
-    if (activeHmrTask) return;
-    while(pendingHmrTasks.length > 0){
-        const task = pendingHmrTasks[0];
-        if (getCurrentTaskPaths(task).length === 0) {
-            pendingHmrTasks.shift();
-            task.resolve();
-            continue;
-        }
-        if (isHmrTaskBlocked(task)) {
-            return;
-        }
-        pendingHmrTasks.shift();
-        runHmrTask(task);
-        return;
-    }
-}
-function handleApplyBatch(updates) {
-    const relevantUpdates = updates.map((update)=>({
-            chunkListPath: update.resource.path,
-            update: update.instruction
-        })).filter(({ chunkListPath })=>chunkListChunksMap.has(chunkListPath));
-    const chunkListPaths = [
-        ...new Set(relevantUpdates.map(({ chunkListPath })=>chunkListPath))
-    ];
-    if (chunkListPaths.length === 0) {
-        return {
-            handledPaths: []
-        };
-    }
-    const bootstrappingPaths = chunkListPaths.filter((chunkListPath)=>{
-        const state = dynamicChunkListLoadStates.get(chunkListPath);
-        return state?.bootstrapping && !state.terminated;
-    });
-    if (bootstrappingPaths.length > 0) {
-        for (const chunkListPath of bootstrappingPaths){
-            const state = dynamicChunkListLoadStates.get(chunkListPath);
-            terminateDynamicChunkListLoad(chunkListPath, state, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
-        }
-        DEV_BACKEND.restart();
-        flushPendingHmrTasks();
-        return {
-            handledPaths: chunkListPaths
-        };
-    }
-    const completion = scheduleHmrTask(chunkListPaths, (currentPaths)=>{
-        const chunkListUpdates = relevantUpdates.filter(({ chunkListPath })=>currentPaths.has(chunkListPath)).map(({ chunkListPath, update })=>{
-            if (update.type !== 'ChunkListUpdate') {
-                invariant(update, (update)=>`Unknown update type: ${update.type}`);
-            }
-            return {
-                chunkListPath,
-                update
-            };
-        });
-        return chunkListUpdates.length > 0 ? applyChunkListUpdates(chunkListUpdates) : [];
-    });
-    return {
-        handledPaths: chunkListPaths,
-        completion
-    };
-}
 function handleApply(chunkListPath, update) {
-    const loadState = dynamicChunkListLoadStates.get(chunkListPath);
-    if (update.type === 'partial' && loadState?.bootstrapping && !loadState.terminated) {
-        terminateDynamicChunkListLoad(chunkListPath, loadState, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
-        DEV_BACKEND.restart();
-        flushPendingHmrTasks();
-        return Promise.resolve();
-    }
-    if (update.type === 'notFound' || update.type === 'restart') {
-        if (loadState && !loadState.terminated) {
-            const error = new Error(update.type === 'notFound' ? `Dynamic chunk list ${chunkListPath} disappeared while loading.` : `Dynamic chunk list ${chunkListPath} must restart while loading.`);
-            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
-        }
-        if (update.type === 'restart') {
-            chunkListGenerations.delete(chunkListPath);
-            dynamicChunkListLoadStates.delete(chunkListPath);
-        }
-        handleApplyImmediately(chunkListPath, update);
-        flushPendingHmrTasks();
-        return Promise.resolve();
-    }
-    return scheduleHmrTask([
-        chunkListPath
-    ], (currentPaths)=>currentPaths.has(chunkListPath) ? handleApplyImmediately(chunkListPath, update) : []);
-}
-function handleApplyImmediately(chunkListPath, update) {
     switch(update.type){
         case 'partial':
             {
                 // This indicates that the update is can be applied to the current state of the application.
-                if (update.instruction.type !== 'ChunkListUpdate') {
-                    invariant(update.instruction, (instruction)=>`Unknown update type: ${instruction.type}`);
-                }
-                return applyChunkListUpdates([
-                    {
-                        chunkListPath,
-                        update: update.instruction
+                if (dynamicChunkLists.has(chunkListPath)) {
+                    if (loadingDynamicChunkLists.has(chunkListPath)) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} changed while it was loading.`);
+                    }
+                    if (update.instruction.type === 'ChunkListUpdate' && update.instruction.chunks != null) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} changed structure.`);
+                    }
+                    const hasSharedChunk = [
+                        ...chunkListChunksMap.get(chunkListPath) ?? []
+                    ].some((chunkPath)=>(chunkChunkListsMap.get(chunkPath)?.size ?? 0) > 1);
+                    if (hasSharedChunk) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} shares chunks with another active list.`);
                     }
-                ]);
+                }
+                applyUpdate(update.instruction);
+                break;
             }
         case 'restart':
             {
@@ -2265,7 +1881,7 @@ function handleApplyImmediately(chunkListPath, update) {
                 // current state of the application, and that the application must be
                 // restarted.
                 DEV_BACKEND.restart();
-                return [];
+                break;
             }
         case 'notFound':
             {
@@ -2273,78 +1889,17 @@ function handleApplyImmediately(chunkListPath, update) {
                 // or the page itself was deleted.
                 // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
                 // If it is a runtime chunk list, we restart the application.
-                if (runtimeChunkLists.has(chunkListPath)) {
+                if (runtimeChunkLists.has(chunkListPath) || dynamicChunkLists.has(chunkListPath)) {
                     DEV_BACKEND.restart();
                 } else {
                     disposeChunkList(chunkListPath);
                 }
-                return [];
+                break;
             }
         default:
             throw new Error(`Unknown update type: ${update.type}`);
     }
 }
-function applyChunkListMembershipDelta(chunkListPath, chunkPath, type, transitions) {
-    let transition = transitions.get(chunkPath);
-    if (!transition) {
-        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-        transition = {
-            before: ownerCount,
-            after: ownerCount
-        };
-        transitions.set(chunkPath, transition);
-    }
-    const changed = type === 'added' ? addChunkToChunkList(chunkListPath, chunkPath) : removeChunkFromChunkList(chunkListPath, chunkPath);
-    transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-    return changed;
-}
-function addChunkToChunkList(chunkListPath, chunkPath) {
-    let chunkPaths = chunkListChunksMap.get(chunkListPath);
-    if (!chunkPaths) {
-        chunkPaths = new Set();
-        chunkListChunksMap.set(chunkListPath, chunkPaths);
-    }
-    if (chunkPaths.has(chunkPath)) {
-        return false;
-    }
-    chunkPaths.add(chunkPath);
-    let chunkLists = chunkChunkListsMap.get(chunkPath);
-    if (!chunkLists) {
-        chunkLists = new Set();
-        chunkChunkListsMap.set(chunkPath, chunkLists);
-    }
-    chunkLists.add(chunkListPath);
-    return true;
-}
-function removeChunkFromChunkList(chunkListPath, chunkPath) {
-    const chunkPaths = chunkListChunksMap.get(chunkListPath);
-    const chunkLists = chunkChunkListsMap.get(chunkPath);
-    if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {
-        return false;
-    }
-    chunkPaths.delete(chunkPath);
-    chunkLists.delete(chunkListPath);
-    if (chunkLists.size === 0) {
-        chunkChunkListsMap.delete(chunkPath);
-    }
-    return true;
-}
-function setChunkListChunks(chunkListPath, nextChunkPaths) {
-    const previousChunkPaths = new Set(chunkListChunksMap.get(chunkListPath) ?? []);
-    if (!chunkListChunksMap.has(chunkListPath)) {
-        chunkListChunksMap.set(chunkListPath, new Set());
-    }
-    for (const chunkPath of previousChunkPaths){
-        if (!nextChunkPaths.has(chunkPath) && removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
-            disposeChunk(chunkPath);
-        }
-    }
-    for (const chunkPath of nextChunkPaths){
-        if (!previousChunkPaths.has(chunkPath)) {
-            addChunkToChunkList(chunkListPath, chunkPath);
-        }
-    }
-}
 /**
  * Removes a module from a chunk.
  * Returns `true` if there are no remaining chunks including this module.
@@ -2363,82 +1918,6 @@ function setChunkListChunks(chunkListPath, nextChunkPaths) {
     }
     return noRemainingChunks;
 }
-function terminateDynamicChunkListLoad(chunkListPath, state, error) {
-    if (state.terminated) return;
-    state.loading = false;
-    state.bootstrapping = false;
-    state.terminated = true;
-    state.rejectSubscribed?.(error);
-    DEV_BACKEND.rejectChunk?.(chunkListPath, error);
-    for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
-        releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
-    }
-}
-function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (!owners) {
-        owners = new Map();
-        dynamicMemberChunkUrlOwners.set(chunkUrl, owners);
-    }
-    owners.set(chunkListPath, generation);
-}
-function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath, chunkUrl) {
-    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (owners?.get(chunkListPath) !== generation) return;
-    owners.delete(chunkListPath);
-    if (owners.size > 0) return;
-    dynamicMemberChunkUrlOwners.delete(chunkUrl);
-    if (isJs(chunkUrl)) {
-        // Executed factories are already tracked by logical chunk ownership. The
-        // exact URL is removed so a cancelled in-flight script cannot satisfy a
-        // later request for the same logical chunk.
-        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-    } else {
-        const hasOtherChunkListOwner = [
-            ...chunkChunkListsMap.get(chunkPath) ?? []
-        ].some((owner)=>owner !== chunkListPath);
-        if (hasOtherChunkListOwner) return;
-        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-    }
-    if (!chunkChunkListsMap.has(chunkPath)) {
-        disposeChunk(chunkPath);
-    }
-}
-function completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (owners?.get(chunkListPath) !== generation) return;
-    owners.delete(chunkListPath);
-    if (owners.size === 0) {
-        dynamicMemberChunkUrlOwners.delete(chunkUrl);
-    }
-}
-function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken) {
-    const chunkPath = getChunkPath(chunkData);
-    const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken);
-    if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {
-        // A previous owner may have loaded an older content-version URL for the
-        // same stylesheet. Swap it only after the new CSS has loaded so dynamic
-        // lists never accumulate duplicate cascade entries.
-        return DEV_BACKEND.loadChunkReplacing(chunkUrl);
-    }
-    return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
-}
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-function isVersionedDynamicMemberChunkUrl(chunkUrl) {
-    return /(?:[?&])hmr=/.test(chunkUrl);
-}
-/**
- * Dynamic chunk-list manifests have already done their own availability
- * calculation. Load the exact member URL for this manifest generation so an
- * older in-flight request cannot be reused by a replacement generation.
- */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
-    const memberChunkPath = getChunkPath(chunkData);
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
-}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -2446,17 +1925,15 @@ function isVersionedDynamicMemberChunkUrl(chunkUrl) {
     if (chunkPaths == null) {
         return false;
     }
-    for (const chunkPath of [
-        ...chunkPaths
-    ]){
-        if (removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
             disposeChunk(chunkPath);
         }
     }
-    chunkListChunksMap.delete(chunkListPath);
-    chunkListGenerations.delete(chunkListPath);
-    dynamicChunkListLoadStates.delete(chunkListPath);
-    runtimeChunkLists.delete(chunkListPath);
     // We must also dispose of the chunk list's chunk itself to ensure it may
     // be reloaded properly in the future.
     const chunkListUrl = getChunkRelativeUrl(chunkListPath);
@@ -2476,7 +1953,7 @@ function isVersionedDynamicMemberChunkUrl(chunkUrl) {
     if (chunkModules == null) {
         return false;
     }
-    chunkModulesMap.delete(chunkPath);
+    chunkModules.delete(chunkPath);
     for (const moduleId of chunkModules){
         const moduleChunks = moduleChunksMap.get(moduleId);
         moduleChunks.delete(chunkPath);
@@ -2522,7 +1999,7 @@ function getDevChunkFromRegistration(chunk) {
     if (typeof chunk === 'string') {
         if (typeof document !== 'undefined') {
             const src = document.currentScript?.getAttribute('src');
-            if (src && getPathFromScript({
+            if (src && /[?&]hmr=/.test(src) && getPathFromScript({
                 src
             }) === chunk) {
                 return {
@@ -2530,177 +2007,102 @@ function getDevChunkFromRegistration(chunk) {
                 };
             }
         }
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        }
     }
     return getChunkFromRegistration(chunk);
 }
 function registerChunk(registration) {
     const chunk = getDevChunkFromRegistration(registration[0]);
-    const chunkPath = getPathFromScript(chunk);
-    const chunkUrl = getUrlFromScript(chunk);
-    const canonicalChunkUrl = getChunkRelativeUrl(chunkPath);
     let runtimeParams;
     // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
     if (registration.length === 2) {
         runtimeParams = registration[1];
     } else {
+        let chunkPath = getPathFromScript(chunk);
         runtimeParams = undefined;
-        if (chunkUrl !== canonicalChunkUrl && isVersionedDynamicMemberChunkUrl(chunkUrl) && !dynamicMemberChunkUrlOwners.has(chunkUrl)) {
-            // Registration can race with cancellation even after its script element
-            // was removed. Only a live owner may install this content-versioned
-            // chunk; a later owner of the same URL is safe because its content is
-            // identical.
-            DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-            return;
-        }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
-    if (runtimeParams === undefined && chunkUrl !== canonicalChunkUrl && DEV_BACKEND.resolveChunk) {
-        // Versioned development chunks have their own resolver. Resolving the
-        // canonical path here could let an older generation wake a newer load.
-        DEV_BACKEND.resolveChunk(chunkUrl);
-        return;
-    }
-    const result = BACKEND.registerChunk(chunk, runtimeParams);
-    if (chunkUrl !== canonicalChunkUrl) {
-        DEV_BACKEND.resolveChunk?.(chunkUrl);
-    }
-    return result;
+    return BACKEND.registerChunk(chunk, runtimeParams);
+}
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+function loadVersionedInitialChunk(chunkListPath, chunkData, versionToken) {
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkListPath, getVersionedChunkUrl(getChunkPath(chunkData), versionToken));
 }
 /**
  * Subscribes to chunk list updates from the update server and applies them.
  */ function registerChunkList(chunkList) {
     const chunkListScript = getDevChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
-    const generation = nextChunkListGeneration++;
-    chunkListGenerations.set(chunkListPath, generation);
+    // Adding chunks to chunk lists and vice versa.
     const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    setChunkListChunks(chunkListPath, chunkPaths);
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
     if (chunkList.source === 'entry') {
-        // Entry chunks have already loaded their member chunks while bootstrapping.
-        // The "chunk" registration completes the backend's initial load.
+        // Entry lists keep the legacy loading and update behavior.
         BACKEND.registerChunk(chunkListPath);
-        markChunkListAsRuntime(chunkListPath);
         CHUNK_UPDATE_LISTENERS.push([
             chunkListPath,
-            handleApply.bind(null, chunkListPath),
-            {
-                batch: handleApplyBatch,
-                expectedVersion: chunkList.version
-            }
+            handleApply.bind(null, chunkListPath)
         ]);
+        markChunkListAsRuntime(chunkListPath);
         return;
     }
+    dynamicChunkLists.add(chunkListPath);
     if (typeof document === 'undefined') {
-        // Workers currently have no HMR transport/provider. Keep the dynamic
-        // chunk-list as a lightweight bootstrap, but load its members directly
-        // instead of waiting forever for an onSubscribed acknowledgement.
-        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
-            const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
-            DEV_BACKEND.rejectChunk?.(chunkListPath, error);
-        });
+        // Workers do not have the browser HMR transport. Load the manifest members
+        // directly so the dynamic import cannot wait for a subscription forever.
+        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), ()=>DEV_BACKEND.restart());
         return;
     }
-    // A dynamic chunk list is the bootstrap for its group. Establish the server
-    // baseline before fetching content, then hold updates while content loads.
-    // This closes the HTTP/WebSocket race where stale content could otherwise be
-    // fetched immediately before a newer subscription baseline was created.
-    const loadState = {
-        generation,
-        loading: true,
-        bootstrapping: true,
-        terminated: false,
-        pendingTasks: new Set(),
-        memberChunkUrls: new Map()
-    };
-    for (const chunkData of chunkList.chunks){
-        const chunkPath = getChunkPath(chunkData);
-        const chunkVersion = chunkList.chunkVersions[chunkPath];
-        if (chunkVersion === undefined) {
-            throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
-        }
-        const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion);
-        loadState.memberChunkUrls.set(chunkPath, chunkUrl);
-        addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
-    }
-    dynamicChunkListLoadStates.set(chunkListPath, loadState);
+    loadingDynamicChunkLists.add(chunkListPath);
     let resolveSubscribed;
     let revalidateSubscription;
-    const subscribed = new Promise((resolve, reject)=>{
+    const subscribed = new Promise((resolve)=>{
         resolveSubscribed = resolve;
-        loadState.rejectSubscribed = reject;
     });
     CHUNK_UPDATE_LISTENERS.push([
         chunkListPath,
         handleApply.bind(null, chunkListPath),
         {
-            batch: handleApplyBatch,
+            conservative: true,
+            expectedVersion: chunkList.version,
             onSubscribed: (revalidate)=>{
                 revalidateSubscription = revalidate;
                 resolveSubscribed();
-            },
-            expectedVersion: chunkList.version
+            }
         }
     ]);
     void (async ()=>{
         try {
             await subscribed;
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            const memberResults = await Promise.allSettled(chunkList.chunks.map((chunkData)=>loadVersionedDynamicMemberChunk(chunkListPath, chunkData, chunkList.chunkVersions[getChunkPath(chunkData)])));
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                for (const chunkPath of chunkPaths){
-                    if (!chunkChunkListsMap.has(chunkPath)) {
-                        disposeChunk(chunkPath);
-                    }
+            await Promise.all(chunkList.chunks.map((chunkData)=>{
+                const chunkPath = getChunkPath(chunkData);
+                const chunkVersion = chunkList.chunkVersions[chunkPath];
+                if (chunkVersion === undefined) {
+                    throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
                 }
-                return;
-            }
-            const failedMember = memberResults.find((result)=>result.status === 'rejected');
-            if (failedMember) {
-                throw failedMember.reason;
-            }
-            // The member URLs are served from the live output directory rather than
-            // a historical snapshot. Validate the manifest version again after all
-            // HTTP responses have completed, closing the subscription/HTTP race.
+                return loadVersionedInitialChunk(chunkListPath, chunkData, chunkVersion);
+            }));
+            // Member URLs are served from the live output directory. Verify that
+            // the manifest did not change while those HTTP responses were loading.
             await revalidateSubscription();
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            for (const chunkUrl of loadState.memberChunkUrls.values()){
-                completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
-            }
-            loadState.loading = false;
-            flushPendingHmrTasks();
-            while(loadState.pendingTasks.size > 0){
-                await Promise.all([
-                    ...loadState.pendingTasks
-                ]);
-            }
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                for (const chunkPath of chunkPaths){
-                    if (!chunkChunkListsMap.has(chunkPath)) {
-                        disposeChunk(chunkPath);
-                    }
-                }
-                return;
-            }
-            // Resolving the bootstrap schedules the import continuation as a
-            // microtask. Every queued update and resource load has completed first,
-            // so user code cannot observe factories from an older manifest.
-            loadState.bootstrapping = false;
+            loadingDynamicChunkLists.delete(chunkListPath);
             BACKEND.registerChunk(chunkListPath);
-        } catch (cause) {
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            const error = cause instanceof Error ? cause : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`);
-            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+        } catch  {
+            loadingDynamicChunkLists.delete(chunkListPath);
             DEV_BACKEND.restart();
         }
     })();
@@ -2729,6 +2131,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
@@ -2959,47 +2365,31 @@ let BACKEND;
 /// <reference path="../../../shared/require-type.d.ts" />
 let DEV_BACKEND;
 (()=>{
-    const pendingChunkReloads = new Map();
-    const replacingCssLoads = new Map();
     DEV_BACKEND = {
-        loadChunkReplacing (chunkUrl) {
-            if (!isCss(chunkUrl)) {
-                return Promise.reject(new Error(`Only CSS chunks can be replaced while loading: ${chunkUrl}`));
-            }
-            const existingLoad = replacingCssLoads.get(chunkUrl);
-            if (existingLoad) return existingLoad;
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // Strip query string so we match links regardless of cache-busting
+            // params (e.g. ?ts=) that may differ between HMR updates.
             const baseChunkUrl = chunkUrl.split('?')[0];
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
             const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?';
-            const decodedChunkUrl = decodeURI(chunkUrl);
-            const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
-            const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-            const load = exactLinks.length > 0 ? resolveChunkResolver(chunkUrl) : baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>resolveChunkResolver(chunkUrl));
-            replacingCssLoads.set(chunkUrl, load);
-            void load.then(()=>{
-                if (replacingCssLoads.get(chunkUrl) === load) {
-                    replacingCssLoads.delete(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
                 }
-            }, ()=>{
-                if (replacingCssLoads.get(chunkUrl) === load) {
-                    replacingCssLoads.delete(chunkUrl);
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
                 }
-            });
-            return load;
-        },
-        unloadChunk (chunkUrl) {
-            unloadChunk(chunkUrl, false);
-        },
-        unloadChunkExact (chunkUrl) {
-            unloadChunk(chunkUrl, true);
-        },
-        rejectChunk (chunkPath, error) {
-            const chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = chunkResolvers.get(chunkUrl);
-            if (resolver) rejectResolver(chunkUrl, resolver, error);
-        },
-        resolveChunk (chunkUrl) {
-            resolveChunkResolver(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
         },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
@@ -3016,43 +2406,9 @@ let DEV_BACKEND;
                     reject(new Error(`No link element found for chunk ${chunkUrl}`));
                     return;
                 }
-                const currentReloads = pendingChunkReloads.get(baseChunkUrl);
-                if (currentReloads) {
-                    const suffix = chunkUrl.includes('?') ? '&' : '?';
-                    for (const reload of [
-                        ...currentReloads
-                    ]){
-                        const href = reload.link.getAttribute('href');
-                        if (href !== chunkUrl && !href?.startsWith(`${chunkUrl}${suffix}`)) {
-                            reload.reject(new Error(`CSS chunk ${chunkUrl} superseded an in-flight reload.`));
-                        }
-                    }
-                }
                 const link = document.createElement('link');
                 link.rel = 'stylesheet';
                 link.crossOrigin = CROSS_ORIGIN;
-                let pendingReloads = pendingChunkReloads.get(baseChunkUrl);
-                if (!pendingReloads) {
-                    pendingReloads = new Set();
-                    pendingChunkReloads.set(baseChunkUrl, pendingReloads);
-                }
-                const cleanup = ()=>{
-                    pendingReloads.delete(pendingReload);
-                    if (pendingReloads.size === 0) {
-                        pendingChunkReloads.delete(baseChunkUrl);
-                    }
-                };
-                const pendingReload = {
-                    link,
-                    reject: (error)=>{
-                        cleanup();
-                        link.onload = null;
-                        link.onerror = null;
-                        link.remove();
-                        reject(error);
-                    }
-                };
-                pendingReloads.add(pendingReload);
                 if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
                     // Firefox won't reload CSS files that were previously loaded on the
                     // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
@@ -3073,10 +2429,9 @@ let DEV_BACKEND;
                     link.href = chunkUrl;
                 }
                 link.onerror = ()=>{
-                    pendingReload.reject(new Error(`Failed to reload CSS chunk ${chunkUrl}`));
+                    reject();
                 };
                 link.onload = ()=>{
-                    cleanup();
                     // First load the new CSS, then remove the old ones. This prevents visible
                     // flickering that would happen in-between removing the previous CSS and
                     // loading the new one.
@@ -3092,87 +2447,8 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
-    function rejectResolver(chunkUrl, resolver, error) {
-        if (chunkResolvers.get(chunkUrl) === resolver) {
-            chunkResolvers.delete(chunkUrl);
-        }
-        resolver.reject(error);
-    }
-    function resolveChunkResolver(chunkUrl) {
-        let resolver = chunkResolvers.get(chunkUrl);
-        if (!resolver) {
-            let resolve;
-            let reject;
-            const promise = new Promise((innerResolve, innerReject)=>{
-                resolve = innerResolve;
-                reject = innerReject;
-            });
-            resolver = {
-                resolved: false,
-                loadingStarted: false,
-                retryAttempts: 0,
-                promise,
-                resolve: ()=>{
-                    resolver.resolved = true;
-                    resolve();
-                },
-                reject: reject
-            };
-            chunkResolvers.set(chunkUrl, resolver);
-        }
-        resolver.resolve();
-        return resolver.promise;
-    }
-    function unloadChunk(chunkUrl, exact) {
-        deleteResolvers(chunkUrl, exact);
-        const baseChunkUrl = chunkUrl.split('?')[0];
-        const reloads = pendingChunkReloads.get(baseChunkUrl);
-        if (reloads) {
-            for (const reload of [
-                ...reloads
-            ]){
-                const href = reload.link.getAttribute('href');
-                const suffix = chunkUrl.includes('?') ? '&' : '?';
-                if (!exact || href === chunkUrl || href?.startsWith(`${chunkUrl}${suffix}`)) {
-                    reload.reject(new Error(`Chunk ${chunkUrl} was unloaded while reloading.`));
-                }
-            }
-        }
-        // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-        const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl);
-        const path = exact ? chunkUrl : baseChunkUrl;
-        const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
-        if (isCss(chunkUrl)) {
-            const links = document.querySelectorAll(`link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
-            for (const link of Array.from(links)){
-                link.remove();
-            }
-        } else if (isJs(chunkUrl)) {
-            // Unloading a JS chunk would have no effect once it has executed, but
-            // removing the exact stale registration keeps the DOM and resolver cache
-            // bounded without touching a newer generation of the same chunk path.
-            const scripts = document.querySelectorAll(`script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
-            for (const script of Array.from(scripts)){
-                script.remove();
-            }
-        } else {
-            throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-        }
-    }
-    function deleteResolvers(chunkUrl, exact) {
-        const baseChunkUrl = chunkUrl.split('?')[0];
-        for (const [resolverUrl, resolver] of [
-            ...chunkResolvers
-        ]){
-            if (exact ? resolverUrl !== chunkUrl : resolverUrl.split('?')[0] !== baseChunkUrl) {
-                continue;
-            }
-            if (resolver.resolved) {
-                chunkResolvers.delete(resolverUrl);
-            } else {
-                rejectResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
-            }
-        }
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
     }
 })();
 function _eval({ code, url, map }) {
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
index c1bc0b043..c375b1cb5 100644
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
+++ b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
@@ -1641,12 +1641,8 @@ function getRefreshBoundaryExports(exports) {
 /**
  * Map from a chunk path to the chunk lists it belongs to.
  */ const chunkChunkListsMap = new Map();
-const dynamicChunkListLoadStates = new Map();
-const pendingHmrTasks = [];
-const chunkListGenerations = new Map();
-let nextChunkListGeneration = 1;
-let activeHmrTask;
-const dynamicMemberChunkUrlOwners = new Map();
+/** Dynamic lists use a stricter, reload-on-ambiguity update policy. */ const dynamicChunkLists = new Set();
+/** Dynamic manifests which have not finished their subscribe/load/revalidate handshake. */ const loadingDynamicChunkLists = new Set();
 /**
  * Gets or instantiates a runtime module.
  */ // @ts-ignore
@@ -1796,259 +1792,48 @@ const DUMMY_REFRESH_CONTEXT = {
         disposedModules
     };
 }
-const PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict');
-function mergeParallelChunkUpdate(updateA, updateB) {
-    if (updateA.type === updateB.type) {
-        return updateA;
-    }
-    if (updateA.type === 'total' || updateB.type === 'total') {
-        return {
-            type: 'total'
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        return null;
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
     }
-    return PARALLEL_UPDATE_CONFLICT;
 }
-function mergeParallelEcmascriptChunkUpdate(updateA, updateB) {
-    if (updateA.type === 'added' && updateB.type === 'added') {
-        return {
-            type: 'added',
-            modules: [
-                ...new Set([
-                    ...updateA.modules ?? [],
-                    ...updateB.modules ?? []
-                ])
-            ]
-        };
-    }
-    if (updateA.type === 'deleted' && updateB.type === 'deleted') {
-        return {
-            type: 'deleted',
-            modules: [
-                ...new Set([
-                    ...updateA.modules ?? [],
-                    ...updateB.modules ?? []
-                ])
-            ]
-        };
-    }
-    if (updateA.type === 'partial' && updateB.type === 'partial') {
-        const added = new Set([
-            ...updateA.added ?? [],
-            ...updateB.added ?? []
-        ]);
-        const deleted = new Set([
-            ...updateA.deleted ?? [],
-            ...updateB.deleted ?? []
-        ]);
-        for (const moduleId of added){
-            if (deleted.has(moduleId)) {
-                added.delete(moduleId);
-                deleted.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        const addedUpdate = updateA.type === 'added' ? updateA : updateB;
-        const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB;
-        const added = new Set(addedUpdate.modules ?? []);
-        const deleted = new Set(deletedUpdate.modules ?? []);
-        for (const moduleId of added){
-            if (deleted.has(moduleId)) {
-                added.delete(moduleId);
-                deleted.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'partial') {
-        if ((updateA.added?.length ?? 0) === 0 && (updateA.deleted?.length ?? 0) === 0) {
-            return updateB;
-        }
-        return PARALLEL_UPDATE_CONFLICT;
-    }
-    if (updateB.type === 'partial') {
-        if ((updateB.added?.length ?? 0) === 0 && (updateB.deleted?.length ?? 0) === 0) {
-            return updateA;
-        }
-        return PARALLEL_UPDATE_CONFLICT;
-    }
-    return PARALLEL_UPDATE_CONFLICT;
-}
-function moduleEntriesEqual(entryA, entryB) {
-    // The same module can be emitted into multiple chunks. Its source URL is
-    // chunk-relative, so it is allowed to differ even when the executable entry
-    // is identical. Treat only code and source map differences as conflicts.
-    return entryA.code === entryB.code && entryA.map === entryB.map;
-}
-function applyChunkListUpdates(updates) {
-    const resourceOperations = [];
-    const ownershipTransitions = new Map();
-    const chunks = new Map();
-    const ecmascriptChunks = new Map();
-    const entries = {};
-    const explicitlyModifiedModules = new Set();
-    let hasConflict = false;
-    for (const { chunkListPath, update } of updates){
-        if (update.chunks) {
-            for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-                if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, chunkUpdate.type, ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                }
-                if (!chunks.has(chunkPath)) {
-                    chunks.set(chunkPath, chunkUpdate);
-                } else {
-                    const previous = chunks.get(chunkPath);
-                    if (previous === null) {
-                        chunks.set(chunkPath, chunkUpdate);
-                    } else {
-                        const merged = mergeParallelChunkUpdate(previous, chunkUpdate);
-                        if (merged === PARALLEL_UPDATE_CONFLICT) {
-                            hasConflict = true;
-                        } else {
-                            chunks.set(chunkPath, merged);
-                        }
-                    }
-                }
-            }
-        }
-        for (const merged of update.merged ?? []){
-            if (merged.type !== 'EcmascriptMergedUpdate') {
-                invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
-            }
-            const addedInThisUpdate = new Set();
-            for (const [chunkPath, chunkUpdate] of Object.entries(merged.chunks ?? {})){
-                if (chunkUpdate.type === 'added') {
-                    for (const moduleId of chunkUpdate.modules ?? []){
-                        addedInThisUpdate.add(moduleId);
-                    }
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'added', ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                } else if (chunkUpdate.type === 'deleted') {
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'deleted', ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                } else {
-                    for (const moduleId of chunkUpdate.added ?? []){
-                        addedInThisUpdate.add(moduleId);
-                    }
-                }
-                const previous = ecmascriptChunks.get(chunkPath);
-                if (!previous) {
-                    ecmascriptChunks.set(chunkPath, chunkUpdate);
-                } else {
-                    const combined = mergeParallelEcmascriptChunkUpdate(previous, chunkUpdate);
-                    if (combined === PARALLEL_UPDATE_CONFLICT) {
-                        hasConflict = true;
-                    } else {
-                        ecmascriptChunks.set(chunkPath, combined);
-                    }
-                }
-            }
-            for (const [moduleId, entry] of Object.entries(merged.entries ?? {})){
-                const previous = entries[moduleId];
-                if (previous) {
-                    if (!moduleEntriesEqual(previous, entry)) {
-                        hasConflict = true;
-                    }
-                } else {
-                    entries[moduleId] = entry;
-                }
-                if (!addedInThisUpdate.has(moduleId)) {
-                    explicitlyModifiedModules.add(moduleId);
-                }
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
             }
         }
     }
-    if (hasConflict) {
-        DEV_BACKEND.restart();
-        return resourceOperations;
-    }
-    const filteredEcmascriptChunks = {};
-    for (const [chunkPath, chunkUpdate] of ecmascriptChunks){
-        const transition = ownershipTransitions.get(chunkPath);
-        if (chunkUpdate.type === 'added' && transition && transition.before > 0) {
-            for (const moduleId of chunkUpdate.modules ?? []){
-                if (!explicitlyModifiedModules.has(moduleId)) {
-                    delete entries[moduleId];
-                }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
             }
-            continue;
-        }
-        if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {
-            continue;
-        }
-        filteredEcmascriptChunks[chunkPath] = chunkUpdate;
-    }
-    if (Object.keys(entries).length > 0 || Object.keys(filteredEcmascriptChunks).length > 0) {
-        applyEcmascriptMergedUpdate({
-            type: 'EcmascriptMergedUpdate',
-            entries,
-            chunks: filteredEcmascriptChunks
-        });
-    }
-    for (const [chunkPath, chunkUpdate] of chunks){
-        if (chunkUpdate === null) {
-            continue;
-        }
-        const transition = ownershipTransitions.get(chunkPath);
-        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-        const chunkUrl = getChunkRelativeUrl(chunkPath);
-        switch(chunkUpdate.type){
-            case 'added':
-                if (!transition || transition.before === 0 && transition.after > 0) {
-                    resourceOperations.push({
-                        chunkPath,
-                        promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl)
-                    });
-                }
-                break;
-            case 'total':
-                if (ownerCount > 0) {
-                    const promise = DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    if (promise) {
-                        resourceOperations.push({
-                            chunkPath,
-                            promise
-                        });
-                    }
-                }
-                break;
-            case 'deleted':
-                if (!transition || transition.before > 0 && transition.after === 0) {
-                    disposeChunk(chunkPath);
-                }
-                break;
-            case 'partial':
-                invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                break;
-            default:
-                invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
         }
     }
-    return resourceOperations;
 }
 function applyEcmascriptMergedUpdate(update) {
     // Browser-specific chunk management phase
@@ -2068,196 +1853,27 @@ function applyEcmascriptMergedUpdate(update) {
         autoAcceptRootModules: false
     });
 }
-function getCurrentTaskPaths(task) {
-    return task.chunkLists.filter(({ path, generation })=>chunkListGenerations.get(path) === generation).map(({ path })=>path);
-}
-function isHmrTaskBlocked(task) {
-    return task.chunkLists.some(({ path, generation })=>{
-        if (chunkListGenerations.get(path) !== generation) return false;
-        const state = dynamicChunkListLoadStates.get(path);
-        return state?.generation === generation && state.loading;
-    });
-}
-function runHmrTask(task) {
-    activeHmrTask = task;
-    void (async ()=>{
-        let resourceOperations = [];
-        try {
-            const currentPaths = new Set(getCurrentTaskPaths(task));
-            if (currentPaths.size > 0) {
-                resourceOperations = task.apply(currentPaths);
-                const results = await Promise.allSettled(resourceOperations.map(({ promise })=>promise));
-                const failedIndex = results.findIndex((result, index)=>result.status === 'rejected' && chunkChunkListsMap.has(resourceOperations[index].chunkPath));
-                if (failedIndex !== -1) {
-                    throw results[failedIndex].reason;
-                }
-            }
-            task.resolve();
-        } catch (cause) {
-            // A terminal update invalidates the generation immediately. Any member
-            // request it cancelled belongs to that old generation and must not turn
-            // a valid replacement subscription into a page reload.
-            if (getCurrentTaskPaths(task).length === 0) {
-                task.resolve();
-            } else {
-                task.reject(cause);
-            }
-        } finally{
-            for (const { chunkPath } of resourceOperations){
-                if (!chunkChunkListsMap.has(chunkPath)) {
-                    disposeChunk(chunkPath);
-                }
-            }
-            if (activeHmrTask === task) {
-                activeHmrTask = undefined;
-            }
-            flushPendingHmrTasks();
-        }
-    })();
-}
-function scheduleHmrTask(chunkListPaths, apply) {
-    const chunkLists = [
-        ...new Set(chunkListPaths)
-    ].flatMap((path)=>{
-        const generation = chunkListGenerations.get(path);
-        return generation === undefined ? [] : [
-            {
-                path,
-                generation
-            }
-        ];
-    });
-    if (chunkLists.length === 0) {
-        return Promise.resolve();
-    }
-    let resolve;
-    let reject;
-    const completion = new Promise((innerResolve, innerReject)=>{
-        resolve = innerResolve;
-        reject = innerReject;
-    });
-    const task = {
-        chunkLists,
-        apply,
-        resolve,
-        reject
-    };
-    for (const { path, generation } of chunkLists){
-        const state = dynamicChunkListLoadStates.get(path);
-        if (state?.generation === generation && state.bootstrapping && !state.terminated) {
-            state.pendingTasks.add(completion);
-            void completion.then(()=>state.pendingTasks.delete(completion), ()=>state.pendingTasks.delete(completion));
-        }
-    }
-    if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {
-        pendingHmrTasks.push(task);
-        flushPendingHmrTasks();
-    } else {
-        runHmrTask(task);
-    }
-    return completion;
-}
-function flushPendingHmrTasks() {
-    if (activeHmrTask) return;
-    while(pendingHmrTasks.length > 0){
-        const task = pendingHmrTasks[0];
-        if (getCurrentTaskPaths(task).length === 0) {
-            pendingHmrTasks.shift();
-            task.resolve();
-            continue;
-        }
-        if (isHmrTaskBlocked(task)) {
-            return;
-        }
-        pendingHmrTasks.shift();
-        runHmrTask(task);
-        return;
-    }
-}
-function handleApplyBatch(updates) {
-    const relevantUpdates = updates.map((update)=>({
-            chunkListPath: update.resource.path,
-            update: update.instruction
-        })).filter(({ chunkListPath })=>chunkListChunksMap.has(chunkListPath));
-    const chunkListPaths = [
-        ...new Set(relevantUpdates.map(({ chunkListPath })=>chunkListPath))
-    ];
-    if (chunkListPaths.length === 0) {
-        return {
-            handledPaths: []
-        };
-    }
-    const bootstrappingPaths = chunkListPaths.filter((chunkListPath)=>{
-        const state = dynamicChunkListLoadStates.get(chunkListPath);
-        return state?.bootstrapping && !state.terminated;
-    });
-    if (bootstrappingPaths.length > 0) {
-        for (const chunkListPath of bootstrappingPaths){
-            const state = dynamicChunkListLoadStates.get(chunkListPath);
-            terminateDynamicChunkListLoad(chunkListPath, state, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
-        }
-        DEV_BACKEND.restart();
-        flushPendingHmrTasks();
-        return {
-            handledPaths: chunkListPaths
-        };
-    }
-    const completion = scheduleHmrTask(chunkListPaths, (currentPaths)=>{
-        const chunkListUpdates = relevantUpdates.filter(({ chunkListPath })=>currentPaths.has(chunkListPath)).map(({ chunkListPath, update })=>{
-            if (update.type !== 'ChunkListUpdate') {
-                invariant(update, (update)=>`Unknown update type: ${update.type}`);
-            }
-            return {
-                chunkListPath,
-                update
-            };
-        });
-        return chunkListUpdates.length > 0 ? applyChunkListUpdates(chunkListUpdates) : [];
-    });
-    return {
-        handledPaths: chunkListPaths,
-        completion
-    };
-}
 function handleApply(chunkListPath, update) {
-    const loadState = dynamicChunkListLoadStates.get(chunkListPath);
-    if (update.type === 'partial' && loadState?.bootstrapping && !loadState.terminated) {
-        terminateDynamicChunkListLoad(chunkListPath, loadState, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
-        DEV_BACKEND.restart();
-        flushPendingHmrTasks();
-        return Promise.resolve();
-    }
-    if (update.type === 'notFound' || update.type === 'restart') {
-        if (loadState && !loadState.terminated) {
-            const error = new Error(update.type === 'notFound' ? `Dynamic chunk list ${chunkListPath} disappeared while loading.` : `Dynamic chunk list ${chunkListPath} must restart while loading.`);
-            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
-        }
-        if (update.type === 'restart') {
-            chunkListGenerations.delete(chunkListPath);
-            dynamicChunkListLoadStates.delete(chunkListPath);
-        }
-        handleApplyImmediately(chunkListPath, update);
-        flushPendingHmrTasks();
-        return Promise.resolve();
-    }
-    return scheduleHmrTask([
-        chunkListPath
-    ], (currentPaths)=>currentPaths.has(chunkListPath) ? handleApplyImmediately(chunkListPath, update) : []);
-}
-function handleApplyImmediately(chunkListPath, update) {
     switch(update.type){
         case 'partial':
             {
                 // This indicates that the update is can be applied to the current state of the application.
-                if (update.instruction.type !== 'ChunkListUpdate') {
-                    invariant(update.instruction, (instruction)=>`Unknown update type: ${instruction.type}`);
-                }
-                return applyChunkListUpdates([
-                    {
-                        chunkListPath,
-                        update: update.instruction
+                if (dynamicChunkLists.has(chunkListPath)) {
+                    if (loadingDynamicChunkLists.has(chunkListPath)) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} changed while it was loading.`);
+                    }
+                    if (update.instruction.type === 'ChunkListUpdate' && update.instruction.chunks != null) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} changed structure.`);
+                    }
+                    const hasSharedChunk = [
+                        ...chunkListChunksMap.get(chunkListPath) ?? []
+                    ].some((chunkPath)=>(chunkChunkListsMap.get(chunkPath)?.size ?? 0) > 1);
+                    if (hasSharedChunk) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} shares chunks with another active list.`);
                     }
-                ]);
+                }
+                applyUpdate(update.instruction);
+                break;
             }
         case 'restart':
             {
@@ -2265,7 +1881,7 @@ function handleApplyImmediately(chunkListPath, update) {
                 // current state of the application, and that the application must be
                 // restarted.
                 DEV_BACKEND.restart();
-                return [];
+                break;
             }
         case 'notFound':
             {
@@ -2273,78 +1889,17 @@ function handleApplyImmediately(chunkListPath, update) {
                 // or the page itself was deleted.
                 // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
                 // If it is a runtime chunk list, we restart the application.
-                if (runtimeChunkLists.has(chunkListPath)) {
+                if (runtimeChunkLists.has(chunkListPath) || dynamicChunkLists.has(chunkListPath)) {
                     DEV_BACKEND.restart();
                 } else {
                     disposeChunkList(chunkListPath);
                 }
-                return [];
+                break;
             }
         default:
             throw new Error(`Unknown update type: ${update.type}`);
     }
 }
-function applyChunkListMembershipDelta(chunkListPath, chunkPath, type, transitions) {
-    let transition = transitions.get(chunkPath);
-    if (!transition) {
-        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-        transition = {
-            before: ownerCount,
-            after: ownerCount
-        };
-        transitions.set(chunkPath, transition);
-    }
-    const changed = type === 'added' ? addChunkToChunkList(chunkListPath, chunkPath) : removeChunkFromChunkList(chunkListPath, chunkPath);
-    transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-    return changed;
-}
-function addChunkToChunkList(chunkListPath, chunkPath) {
-    let chunkPaths = chunkListChunksMap.get(chunkListPath);
-    if (!chunkPaths) {
-        chunkPaths = new Set();
-        chunkListChunksMap.set(chunkListPath, chunkPaths);
-    }
-    if (chunkPaths.has(chunkPath)) {
-        return false;
-    }
-    chunkPaths.add(chunkPath);
-    let chunkLists = chunkChunkListsMap.get(chunkPath);
-    if (!chunkLists) {
-        chunkLists = new Set();
-        chunkChunkListsMap.set(chunkPath, chunkLists);
-    }
-    chunkLists.add(chunkListPath);
-    return true;
-}
-function removeChunkFromChunkList(chunkListPath, chunkPath) {
-    const chunkPaths = chunkListChunksMap.get(chunkListPath);
-    const chunkLists = chunkChunkListsMap.get(chunkPath);
-    if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {
-        return false;
-    }
-    chunkPaths.delete(chunkPath);
-    chunkLists.delete(chunkListPath);
-    if (chunkLists.size === 0) {
-        chunkChunkListsMap.delete(chunkPath);
-    }
-    return true;
-}
-function setChunkListChunks(chunkListPath, nextChunkPaths) {
-    const previousChunkPaths = new Set(chunkListChunksMap.get(chunkListPath) ?? []);
-    if (!chunkListChunksMap.has(chunkListPath)) {
-        chunkListChunksMap.set(chunkListPath, new Set());
-    }
-    for (const chunkPath of previousChunkPaths){
-        if (!nextChunkPaths.has(chunkPath) && removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
-            disposeChunk(chunkPath);
-        }
-    }
-    for (const chunkPath of nextChunkPaths){
-        if (!previousChunkPaths.has(chunkPath)) {
-            addChunkToChunkList(chunkListPath, chunkPath);
-        }
-    }
-}
 /**
  * Removes a module from a chunk.
  * Returns `true` if there are no remaining chunks including this module.
@@ -2363,82 +1918,6 @@ function setChunkListChunks(chunkListPath, nextChunkPaths) {
     }
     return noRemainingChunks;
 }
-function terminateDynamicChunkListLoad(chunkListPath, state, error) {
-    if (state.terminated) return;
-    state.loading = false;
-    state.bootstrapping = false;
-    state.terminated = true;
-    state.rejectSubscribed?.(error);
-    DEV_BACKEND.rejectChunk?.(chunkListPath, error);
-    for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
-        releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
-    }
-}
-function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (!owners) {
-        owners = new Map();
-        dynamicMemberChunkUrlOwners.set(chunkUrl, owners);
-    }
-    owners.set(chunkListPath, generation);
-}
-function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath, chunkUrl) {
-    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (owners?.get(chunkListPath) !== generation) return;
-    owners.delete(chunkListPath);
-    if (owners.size > 0) return;
-    dynamicMemberChunkUrlOwners.delete(chunkUrl);
-    if (isJs(chunkUrl)) {
-        // Executed factories are already tracked by logical chunk ownership. The
-        // exact URL is removed so a cancelled in-flight script cannot satisfy a
-        // later request for the same logical chunk.
-        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-    } else {
-        const hasOtherChunkListOwner = [
-            ...chunkChunkListsMap.get(chunkPath) ?? []
-        ].some((owner)=>owner !== chunkListPath);
-        if (hasOtherChunkListOwner) return;
-        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-    }
-    if (!chunkChunkListsMap.has(chunkPath)) {
-        disposeChunk(chunkPath);
-    }
-}
-function completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (owners?.get(chunkListPath) !== generation) return;
-    owners.delete(chunkListPath);
-    if (owners.size === 0) {
-        dynamicMemberChunkUrlOwners.delete(chunkUrl);
-    }
-}
-function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken) {
-    const chunkPath = getChunkPath(chunkData);
-    const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken);
-    if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {
-        // A previous owner may have loaded an older content-version URL for the
-        // same stylesheet. Swap it only after the new CSS has loaded so dynamic
-        // lists never accumulate duplicate cascade entries.
-        return DEV_BACKEND.loadChunkReplacing(chunkUrl);
-    }
-    return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
-}
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-function isVersionedDynamicMemberChunkUrl(chunkUrl) {
-    return /(?:[?&])hmr=/.test(chunkUrl);
-}
-/**
- * Dynamic chunk-list manifests have already done their own availability
- * calculation. Load the exact member URL for this manifest generation so an
- * older in-flight request cannot be reused by a replacement generation.
- */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
-    const memberChunkPath = getChunkPath(chunkData);
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
-}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -2446,17 +1925,15 @@ function isVersionedDynamicMemberChunkUrl(chunkUrl) {
     if (chunkPaths == null) {
         return false;
     }
-    for (const chunkPath of [
-        ...chunkPaths
-    ]){
-        if (removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
             disposeChunk(chunkPath);
         }
     }
-    chunkListChunksMap.delete(chunkListPath);
-    chunkListGenerations.delete(chunkListPath);
-    dynamicChunkListLoadStates.delete(chunkListPath);
-    runtimeChunkLists.delete(chunkListPath);
     // We must also dispose of the chunk list's chunk itself to ensure it may
     // be reloaded properly in the future.
     const chunkListUrl = getChunkRelativeUrl(chunkListPath);
@@ -2476,7 +1953,7 @@ function isVersionedDynamicMemberChunkUrl(chunkUrl) {
     if (chunkModules == null) {
         return false;
     }
-    chunkModulesMap.delete(chunkPath);
+    chunkModules.delete(chunkPath);
     for (const moduleId of chunkModules){
         const moduleChunks = moduleChunksMap.get(moduleId);
         moduleChunks.delete(chunkPath);
@@ -2522,7 +1999,7 @@ function getDevChunkFromRegistration(chunk) {
     if (typeof chunk === 'string') {
         if (typeof document !== 'undefined') {
             const src = document.currentScript?.getAttribute('src');
-            if (src && getPathFromScript({
+            if (src && /[?&]hmr=/.test(src) && getPathFromScript({
                 src
             }) === chunk) {
                 return {
@@ -2530,177 +2007,102 @@ function getDevChunkFromRegistration(chunk) {
                 };
             }
         }
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        }
     }
     return getChunkFromRegistration(chunk);
 }
 function registerChunk(registration) {
     const chunk = getDevChunkFromRegistration(registration[0]);
-    const chunkPath = getPathFromScript(chunk);
-    const chunkUrl = getUrlFromScript(chunk);
-    const canonicalChunkUrl = getChunkRelativeUrl(chunkPath);
     let runtimeParams;
     // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
     if (registration.length === 2) {
         runtimeParams = registration[1];
     } else {
+        let chunkPath = getPathFromScript(chunk);
         runtimeParams = undefined;
-        if (chunkUrl !== canonicalChunkUrl && isVersionedDynamicMemberChunkUrl(chunkUrl) && !dynamicMemberChunkUrlOwners.has(chunkUrl)) {
-            // Registration can race with cancellation even after its script element
-            // was removed. Only a live owner may install this content-versioned
-            // chunk; a later owner of the same URL is safe because its content is
-            // identical.
-            DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-            return;
-        }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
-    if (runtimeParams === undefined && chunkUrl !== canonicalChunkUrl && DEV_BACKEND.resolveChunk) {
-        // Versioned development chunks have their own resolver. Resolving the
-        // canonical path here could let an older generation wake a newer load.
-        DEV_BACKEND.resolveChunk(chunkUrl);
-        return;
-    }
-    const result = BACKEND.registerChunk(chunk, runtimeParams);
-    if (chunkUrl !== canonicalChunkUrl) {
-        DEV_BACKEND.resolveChunk?.(chunkUrl);
-    }
-    return result;
+    return BACKEND.registerChunk(chunk, runtimeParams);
+}
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+function loadVersionedInitialChunk(chunkListPath, chunkData, versionToken) {
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkListPath, getVersionedChunkUrl(getChunkPath(chunkData), versionToken));
 }
 /**
  * Subscribes to chunk list updates from the update server and applies them.
  */ function registerChunkList(chunkList) {
     const chunkListScript = getDevChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
-    const generation = nextChunkListGeneration++;
-    chunkListGenerations.set(chunkListPath, generation);
+    // Adding chunks to chunk lists and vice versa.
     const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    setChunkListChunks(chunkListPath, chunkPaths);
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
     if (chunkList.source === 'entry') {
-        // Entry chunks have already loaded their member chunks while bootstrapping.
-        // The "chunk" registration completes the backend's initial load.
+        // Entry lists keep the legacy loading and update behavior.
         BACKEND.registerChunk(chunkListPath);
-        markChunkListAsRuntime(chunkListPath);
         CHUNK_UPDATE_LISTENERS.push([
             chunkListPath,
-            handleApply.bind(null, chunkListPath),
-            {
-                batch: handleApplyBatch,
-                expectedVersion: chunkList.version
-            }
+            handleApply.bind(null, chunkListPath)
         ]);
+        markChunkListAsRuntime(chunkListPath);
         return;
     }
+    dynamicChunkLists.add(chunkListPath);
     if (typeof document === 'undefined') {
-        // Workers currently have no HMR transport/provider. Keep the dynamic
-        // chunk-list as a lightweight bootstrap, but load its members directly
-        // instead of waiting forever for an onSubscribed acknowledgement.
-        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
-            const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
-            DEV_BACKEND.rejectChunk?.(chunkListPath, error);
-        });
+        // Workers do not have the browser HMR transport. Load the manifest members
+        // directly so the dynamic import cannot wait for a subscription forever.
+        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), ()=>DEV_BACKEND.restart());
         return;
     }
-    // A dynamic chunk list is the bootstrap for its group. Establish the server
-    // baseline before fetching content, then hold updates while content loads.
-    // This closes the HTTP/WebSocket race where stale content could otherwise be
-    // fetched immediately before a newer subscription baseline was created.
-    const loadState = {
-        generation,
-        loading: true,
-        bootstrapping: true,
-        terminated: false,
-        pendingTasks: new Set(),
-        memberChunkUrls: new Map()
-    };
-    for (const chunkData of chunkList.chunks){
-        const chunkPath = getChunkPath(chunkData);
-        const chunkVersion = chunkList.chunkVersions[chunkPath];
-        if (chunkVersion === undefined) {
-            throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
-        }
-        const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion);
-        loadState.memberChunkUrls.set(chunkPath, chunkUrl);
-        addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
-    }
-    dynamicChunkListLoadStates.set(chunkListPath, loadState);
+    loadingDynamicChunkLists.add(chunkListPath);
     let resolveSubscribed;
     let revalidateSubscription;
-    const subscribed = new Promise((resolve, reject)=>{
+    const subscribed = new Promise((resolve)=>{
         resolveSubscribed = resolve;
-        loadState.rejectSubscribed = reject;
     });
     CHUNK_UPDATE_LISTENERS.push([
         chunkListPath,
         handleApply.bind(null, chunkListPath),
         {
-            batch: handleApplyBatch,
+            conservative: true,
+            expectedVersion: chunkList.version,
             onSubscribed: (revalidate)=>{
                 revalidateSubscription = revalidate;
                 resolveSubscribed();
-            },
-            expectedVersion: chunkList.version
+            }
         }
     ]);
     void (async ()=>{
         try {
             await subscribed;
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            const memberResults = await Promise.allSettled(chunkList.chunks.map((chunkData)=>loadVersionedDynamicMemberChunk(chunkListPath, chunkData, chunkList.chunkVersions[getChunkPath(chunkData)])));
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                for (const chunkPath of chunkPaths){
-                    if (!chunkChunkListsMap.has(chunkPath)) {
-                        disposeChunk(chunkPath);
-                    }
+            await Promise.all(chunkList.chunks.map((chunkData)=>{
+                const chunkPath = getChunkPath(chunkData);
+                const chunkVersion = chunkList.chunkVersions[chunkPath];
+                if (chunkVersion === undefined) {
+                    throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
                 }
-                return;
-            }
-            const failedMember = memberResults.find((result)=>result.status === 'rejected');
-            if (failedMember) {
-                throw failedMember.reason;
-            }
-            // The member URLs are served from the live output directory rather than
-            // a historical snapshot. Validate the manifest version again after all
-            // HTTP responses have completed, closing the subscription/HTTP race.
+                return loadVersionedInitialChunk(chunkListPath, chunkData, chunkVersion);
+            }));
+            // Member URLs are served from the live output directory. Verify that
+            // the manifest did not change while those HTTP responses were loading.
             await revalidateSubscription();
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            for (const chunkUrl of loadState.memberChunkUrls.values()){
-                completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
-            }
-            loadState.loading = false;
-            flushPendingHmrTasks();
-            while(loadState.pendingTasks.size > 0){
-                await Promise.all([
-                    ...loadState.pendingTasks
-                ]);
-            }
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                for (const chunkPath of chunkPaths){
-                    if (!chunkChunkListsMap.has(chunkPath)) {
-                        disposeChunk(chunkPath);
-                    }
-                }
-                return;
-            }
-            // Resolving the bootstrap schedules the import continuation as a
-            // microtask. Every queued update and resource load has completed first,
-            // so user code cannot observe factories from an older manifest.
-            loadState.bootstrapping = false;
+            loadingDynamicChunkLists.delete(chunkListPath);
             BACKEND.registerChunk(chunkListPath);
-        } catch (cause) {
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            const error = cause instanceof Error ? cause : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`);
-            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+        } catch  {
+            loadingDynamicChunkLists.delete(chunkListPath);
             DEV_BACKEND.restart();
         }
     })();
@@ -2729,6 +2131,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
@@ -2959,47 +2365,31 @@ let BACKEND;
 /// <reference path="../../../shared/require-type.d.ts" />
 let DEV_BACKEND;
 (()=>{
-    const pendingChunkReloads = new Map();
-    const replacingCssLoads = new Map();
     DEV_BACKEND = {
-        loadChunkReplacing (chunkUrl) {
-            if (!isCss(chunkUrl)) {
-                return Promise.reject(new Error(`Only CSS chunks can be replaced while loading: ${chunkUrl}`));
-            }
-            const existingLoad = replacingCssLoads.get(chunkUrl);
-            if (existingLoad) return existingLoad;
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // Strip query string so we match links regardless of cache-busting
+            // params (e.g. ?ts=) that may differ between HMR updates.
             const baseChunkUrl = chunkUrl.split('?')[0];
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
             const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?';
-            const decodedChunkUrl = decodeURI(chunkUrl);
-            const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
-            const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-            const load = exactLinks.length > 0 ? resolveChunkResolver(chunkUrl) : baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>resolveChunkResolver(chunkUrl));
-            replacingCssLoads.set(chunkUrl, load);
-            void load.then(()=>{
-                if (replacingCssLoads.get(chunkUrl) === load) {
-                    replacingCssLoads.delete(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
                 }
-            }, ()=>{
-                if (replacingCssLoads.get(chunkUrl) === load) {
-                    replacingCssLoads.delete(chunkUrl);
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
                 }
-            });
-            return load;
-        },
-        unloadChunk (chunkUrl) {
-            unloadChunk(chunkUrl, false);
-        },
-        unloadChunkExact (chunkUrl) {
-            unloadChunk(chunkUrl, true);
-        },
-        rejectChunk (chunkPath, error) {
-            const chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = chunkResolvers.get(chunkUrl);
-            if (resolver) rejectResolver(chunkUrl, resolver, error);
-        },
-        resolveChunk (chunkUrl) {
-            resolveChunkResolver(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
         },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
@@ -3016,43 +2406,9 @@ let DEV_BACKEND;
                     reject(new Error(`No link element found for chunk ${chunkUrl}`));
                     return;
                 }
-                const currentReloads = pendingChunkReloads.get(baseChunkUrl);
-                if (currentReloads) {
-                    const suffix = chunkUrl.includes('?') ? '&' : '?';
-                    for (const reload of [
-                        ...currentReloads
-                    ]){
-                        const href = reload.link.getAttribute('href');
-                        if (href !== chunkUrl && !href?.startsWith(`${chunkUrl}${suffix}`)) {
-                            reload.reject(new Error(`CSS chunk ${chunkUrl} superseded an in-flight reload.`));
-                        }
-                    }
-                }
                 const link = document.createElement('link');
                 link.rel = 'stylesheet';
                 link.crossOrigin = CROSS_ORIGIN;
-                let pendingReloads = pendingChunkReloads.get(baseChunkUrl);
-                if (!pendingReloads) {
-                    pendingReloads = new Set();
-                    pendingChunkReloads.set(baseChunkUrl, pendingReloads);
-                }
-                const cleanup = ()=>{
-                    pendingReloads.delete(pendingReload);
-                    if (pendingReloads.size === 0) {
-                        pendingChunkReloads.delete(baseChunkUrl);
-                    }
-                };
-                const pendingReload = {
-                    link,
-                    reject: (error)=>{
-                        cleanup();
-                        link.onload = null;
-                        link.onerror = null;
-                        link.remove();
-                        reject(error);
-                    }
-                };
-                pendingReloads.add(pendingReload);
                 if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
                     // Firefox won't reload CSS files that were previously loaded on the
                     // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
@@ -3073,10 +2429,9 @@ let DEV_BACKEND;
                     link.href = chunkUrl;
                 }
                 link.onerror = ()=>{
-                    pendingReload.reject(new Error(`Failed to reload CSS chunk ${chunkUrl}`));
+                    reject();
                 };
                 link.onload = ()=>{
-                    cleanup();
                     // First load the new CSS, then remove the old ones. This prevents visible
                     // flickering that would happen in-between removing the previous CSS and
                     // loading the new one.
@@ -3092,87 +2447,8 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
-    function rejectResolver(chunkUrl, resolver, error) {
-        if (chunkResolvers.get(chunkUrl) === resolver) {
-            chunkResolvers.delete(chunkUrl);
-        }
-        resolver.reject(error);
-    }
-    function resolveChunkResolver(chunkUrl) {
-        let resolver = chunkResolvers.get(chunkUrl);
-        if (!resolver) {
-            let resolve;
-            let reject;
-            const promise = new Promise((innerResolve, innerReject)=>{
-                resolve = innerResolve;
-                reject = innerReject;
-            });
-            resolver = {
-                resolved: false,
-                loadingStarted: false,
-                retryAttempts: 0,
-                promise,
-                resolve: ()=>{
-                    resolver.resolved = true;
-                    resolve();
-                },
-                reject: reject
-            };
-            chunkResolvers.set(chunkUrl, resolver);
-        }
-        resolver.resolve();
-        return resolver.promise;
-    }
-    function unloadChunk(chunkUrl, exact) {
-        deleteResolvers(chunkUrl, exact);
-        const baseChunkUrl = chunkUrl.split('?')[0];
-        const reloads = pendingChunkReloads.get(baseChunkUrl);
-        if (reloads) {
-            for (const reload of [
-                ...reloads
-            ]){
-                const href = reload.link.getAttribute('href');
-                const suffix = chunkUrl.includes('?') ? '&' : '?';
-                if (!exact || href === chunkUrl || href?.startsWith(`${chunkUrl}${suffix}`)) {
-                    reload.reject(new Error(`Chunk ${chunkUrl} was unloaded while reloading.`));
-                }
-            }
-        }
-        // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-        const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl);
-        const path = exact ? chunkUrl : baseChunkUrl;
-        const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
-        if (isCss(chunkUrl)) {
-            const links = document.querySelectorAll(`link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
-            for (const link of Array.from(links)){
-                link.remove();
-            }
-        } else if (isJs(chunkUrl)) {
-            // Unloading a JS chunk would have no effect once it has executed, but
-            // removing the exact stale registration keeps the DOM and resolver cache
-            // bounded without touching a newer generation of the same chunk path.
-            const scripts = document.querySelectorAll(`script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
-            for (const script of Array.from(scripts)){
-                script.remove();
-            }
-        } else {
-            throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-        }
-    }
-    function deleteResolvers(chunkUrl, exact) {
-        const baseChunkUrl = chunkUrl.split('?')[0];
-        for (const [resolverUrl, resolver] of [
-            ...chunkResolvers
-        ]){
-            if (exact ? resolverUrl !== chunkUrl : resolverUrl.split('?')[0] !== baseChunkUrl) {
-                continue;
-            }
-            if (resolver.resolved) {
-                chunkResolvers.delete(resolverUrl);
-            } else {
-                rejectResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
-            }
-        }
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
     }
 })();
 function _eval({ code, url, map }) {
diff --git a/e2e/pack-hmr/pack-hmr.spec.ts b/e2e/pack-hmr/pack-hmr.spec.ts
index 81a347312..7028b420f 100644
--- a/e2e/pack-hmr/pack-hmr.spec.ts
+++ b/e2e/pack-hmr/pack-hmr.spec.ts
@@ -50,6 +50,24 @@ async function readRuntimeState(page: Page) {
   }));
 }
 
+async function waitForPageReload(
+  page: Page,
+  previous: Awaited<ReturnType<typeof readRuntimeState>>,
+) {
+  await expect
+    .poll(() =>
+      readRuntimeState(page).then(
+        (state) =>
+          typeof state.pageToken === "string" &&
+          state.pageToken !== previous.pageToken,
+      ),
+    )
+    .toBe(true);
+  const current = await readRuntimeState(page);
+  expect(current.timeOrigin).not.toBe(previous.timeOrigin);
+  return current;
+}
+
 function frameAction(frame: string) {
   try {
     return JSON.parse(frame).action as string | undefined;
@@ -190,11 +208,16 @@ test("closes the first dynamic-load subscription race", async ({ page }) => {
 
   await expect
     .poll(() =>
-      page.evaluate(() =>
-        (globalThis as any).__hmrSubscriptionVersions.every(
-          (version: unknown) => typeof version === "string",
-        ),
-      ),
+      page.evaluate(() => {
+        const paths = (globalThis as any).__hmrSubscriptionPaths as string[];
+        const versions = (globalThis as any)
+          .__hmrSubscriptionVersions as unknown[];
+        return paths.every(
+          (path, index) =>
+            !/(?:^|\/)src_[ab]_[^/]+\.js$/.test(path) ||
+            typeof versions[index] === "string",
+        );
+      }),
     )
     .toBe(true);
   await mutateAndWaitForBuild(page, () => writeShared("shared-race-v2"));
@@ -272,6 +295,10 @@ test("revalidates after HTTP members load before exposing a dynamic import", asy
 test("resubscribes dynamic imports after the HMR socket reconnects", async ({
   page,
 }) => {
+  const sentFrames: string[] = [];
+  page.on("websocket", (socket) => {
+    socket.on("framesent", ({ payload }) => sentFrames.push(String(payload)));
+  });
   await page.addInitScript(() => {
     const NativeWebSocket = WebSocket;
     const sockets: WebSocket[] = [];
@@ -286,6 +313,7 @@ test("resubscribes dynamic imports after the HMR socket reconnects", async ({
   });
 
   await page.goto("/");
+  const initial = await readRuntimeState(page);
   await expect
     .poll(() => pageReadySockets.get(page)?.size ?? 0)
     .toBeGreaterThan(0);
@@ -294,6 +322,7 @@ test("resubscribes dynamic imports after the HMR socket reconnects", async ({
     sockets.at(-1)?.close();
   });
   await expect.poll(() => pageReadySockets.get(page)?.size ?? 0).toBe(0);
+  const sentFrameStart = sentFrames.length;
 
   // These subscriptions are created while sendMessage has no open socket.
   // Reconnect must cause the HMR client to replay them.
@@ -308,9 +337,93 @@ test("resubscribes dynamic imports after the HMR socket reconnects", async ({
       ),
     )
     .toBeGreaterThanOrEqual(2);
+
+  const dynamicSubscriptions = sentFrames
+    .slice(sentFrameStart)
+    .flatMap((frame) => {
+      try {
+        return [JSON.parse(frame)];
+      } catch {
+        return [];
+      }
+    })
+    .filter(
+      (message) =>
+        message.type === "turbopack-subscribe" &&
+        /(?:^|\/)src_[ab]_[^/]+\.js$/.test(message.path),
+    );
+  expect(dynamicSubscriptions).toHaveLength(4);
+  expect(
+    dynamicSubscriptions.every(
+      (message) =>
+        typeof message.version === "string" &&
+        typeof message.validation === "string",
+    ),
+  ).toBe(true);
+  const updated = await readRuntimeState(page);
+  expect(updated.pageToken).toBe(initial.pageToken);
+  expect(updated.timeOrigin).toBe(initial.timeOrigin);
+});
+
+test("hot updates a single active dynamic list without reloading", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    const NativeWebSocket = WebSocket;
+    const sockets: WebSocket[] = [];
+    (globalThis as any).__packHmrSockets = sockets;
+    (globalThis as any).WebSocket = new Proxy(NativeWebSocket, {
+      construct(Target, args) {
+        const socket = new Target(...(args as [string, string | string[]]));
+        sockets.push(socket);
+        return socket;
+      },
+    });
+  });
+  await page.goto("/");
+  await mutateAndWaitForBuild(page, () =>
+    fs.writeFileSync(
+      indexPath,
+      indexBaseline.replace(
+        '[import("./a.js"), import("./b.js")]',
+        '[import("./a.js")]',
+      ),
+    ),
+  );
+  await expect
+    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
+    .toBeGreaterThanOrEqual(2);
+
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("pending");
+  const initial = await readRuntimeState(page);
+
+  await mutateAndWaitForBuild(page, () => writeShared("shared-single-v2"));
+
+  await expect(page.locator("#a")).toHaveText("a:shared-single-v2");
+  await expect(page.locator("#b")).toHaveText("pending");
+  await expect(page.locator("#error")).toBeEmpty();
+  const updated = await readRuntimeState(page);
+  expect(updated.evaluations).toBe(2);
+  expect(updated.pageToken).toBe(initial.pageToken);
+  expect(updated.timeOrigin).toBe(initial.timeOrigin);
+
+  // The manifest version intentionally stays fixed for this thin integration.
+  // A reconnect after an update validates against that original baseline and
+  // reloads safely instead of accepting a potentially incomplete replay.
+  await page.evaluate(() => {
+    const sockets = (globalThis as any).__packHmrSockets as WebSocket[];
+    sockets.at(-1)?.close();
+  });
+  await waitForPageReload(page, updated);
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-single-v2");
+  await expect(page.locator("#b")).toHaveText("pending");
+  await expect(page.locator("#error")).toBeEmpty();
 });
 
-test("applies a shared update once across two dynamic lists", async ({
+test("reloads safely for an update shared by two dynamic lists", async ({
   page,
 }) => {
   const frames = pageFrames.get(page)!;
@@ -331,31 +444,24 @@ test("applies a shared update once across two dynamic lists", async ({
 
   await mutateAndWaitForBuild(page, () => writeShared("shared-dedupe-v2"));
 
+  await waitForPageReload(page, initial);
+  await page.locator("#load").click();
   await expect(page.locator("#a")).toHaveText("a:shared-dedupe-v2");
   await expect(page.locator("#b")).toHaveText("b:shared-dedupe-v2");
+  await expect(page.locator("#error")).toBeEmpty();
   const updated = await readRuntimeState(page);
-  expect(updated.evaluations).toBe(2);
-  expect(updated.pageToken).toBe(initial.pageToken);
-  expect(updated.timeOrigin).toBe(initial.timeOrigin);
+  expect(updated.evaluations).toBe(1);
+  expect(updated.pageToken).not.toBe(initial.pageToken);
+  expect(updated.timeOrigin).not.toBe(initial.timeOrigin);
 
   const resourcePaths = new Set<string>();
   for (const update of getTurbopackUpdates(frames.slice(frameStart))) {
     if (update.type === "partial") resourcePaths.add(update.resource.path);
   }
   expect(resourcePaths.size).toBeGreaterThanOrEqual(2);
-  expect(
-    getTurbopackEnvelopes(frames.slice(frameStart)).some((updates) => {
-      const paths = new Set(
-        updates
-          .filter((update) => update.type === "partial")
-          .map((update) => update.resource.path),
-      );
-      return paths.size >= 2;
-    }),
-  ).toBe(true);
 });
 
-test("swaps an older shared stylesheet when a new dynamic list joins", async ({
+test("reloads safely when a stylesheet is shared by dynamic lists", async ({
   page,
 }) => {
   await page.goto("/");
@@ -364,25 +470,12 @@ test("swaps an older shared stylesheet when a new dynamic list joins", async ({
   await expect(page.locator("#b")).toHaveText("b:shared-v1");
   const initial = await readRuntimeState(page);
 
-  await mutateAndWaitForBuild(page, () =>
-    fs.writeFileSync(
-      indexPath,
-      indexBaseline.replace(
-        '[import("./a.js"), import("./b.js")]',
-        '[Promise.resolve(), import("./b.js")]',
-      ),
-    ),
-  );
   await mutateAndWaitForBuild(page, () => writeSharedCss("shared-css-swap-v2"));
-  await mutateAndWaitForBuild(page, () =>
-    fs.writeFileSync(indexPath, indexBaseline),
-  );
-  await expect
-    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
-    .toBeGreaterThanOrEqual(3);
 
+  await waitForPageReload(page, initial);
   await page.locator("#load").click();
   await expect(page.locator("#a")).toHaveText("a:shared-v1");
+  await expect(page.locator("#b")).toHaveText("b:shared-v1");
   await expect(page.locator("#error")).toBeEmpty();
   await expect
     .poll(() =>
@@ -396,94 +489,53 @@ test("swaps an older shared stylesheet when a new dynamic list joins", async ({
         ),
     )
     .toBe(1);
-
-  const updated = await readRuntimeState(page);
-  expect(updated.pageToken).toBe(initial.pageToken);
-  expect(updated.timeOrigin).toBe(initial.timeOrigin);
+  await expect
+    .poll(() =>
+      page
+        .locator("#a")
+        .evaluate((element) =>
+          getComputedStyle(element).getPropertyValue("--pack-hmr-shared"),
+        ),
+    )
+    .toContain("shared-css-swap-v2");
 });
 
-test("cancels an obsolete CSS reload without stalling later HMR", async ({
+test("continues updating after a conservative stylesheet reload", async ({
   page,
 }) => {
-  const frames = pageFrames.get(page)!;
   await page.goto("/");
   await page.locator("#load").click();
   await expect(page.locator("#a")).toHaveText("a:shared-v1");
   await expect(page.locator("#b")).toHaveText("b:shared-v1");
+  const initial = await readRuntimeState(page);
 
-  let releaseCss!: () => void;
-  const cssReleased = new Promise<void>((resolve) => {
-    releaseCss = resolve;
-  });
-  let capturedCssReloads = 0;
-  await page.route(/\.css(?:\?.*)?$/, async (route) => {
-    if (capturedCssReloads > 0) {
-      await route.continue();
-      return;
-    }
-    capturedCssReloads += 1;
-    await cssReleased;
-    await route.continue();
-  });
-
-  try {
-    await mutateAndWaitForBuild(page, () =>
-      writeSharedCss("shared-css-reload-v2"),
-    );
-    await expect.poll(() => capturedCssReloads).toBe(1);
-
-    const frameStart = frames.length;
-    await mutateAndWaitForBuild(page, () =>
-      fs.writeFileSync(
-        indexPath,
-        indexBaseline.replace(
-          '[import("./a.js"), import("./b.js")]',
-          "[Promise.resolve(), Promise.resolve()]",
+  await mutateAndWaitForBuild(page, () =>
+    writeSharedCss("shared-css-reload-v2"),
+  );
+  const afterCssReload = await waitForPageReload(page, initial);
+  await page.locator("#load").click();
+  await expect
+    .poll(() =>
+      page
+        .locator("#a")
+        .evaluate((element) =>
+          getComputedStyle(element).getPropertyValue("--pack-hmr-shared"),
         ),
-      ),
-    );
-    await expect
-      .poll(
-        () =>
-          getTurbopackUpdates(frames.slice(frameStart)).filter(
-            (update) => update.type === "notFound",
-          ).length,
-      )
-      .toBeGreaterThanOrEqual(2);
-
-    releaseCss();
-    await mutateAndWaitForBuild(page, () =>
-      fs.writeFileSync(indexPath, indexBaseline),
-    );
-    await expect
-      .poll(() =>
-        readRuntimeState(page).then((state) => state.entryEvaluations),
-      )
-      .toBeGreaterThanOrEqual(3);
+    )
+    .toContain("shared-css-reload-v2");
 
-    await page.locator("#a").evaluate((element) => {
-      element.textContent = "pending";
-    });
-    await page.locator("#b").evaluate((element) => {
-      element.textContent = "pending";
-    });
-    await page.locator("#load").click();
-    await expect(page.locator("#a")).toHaveText("a:shared-v1");
-    await expect(page.locator("#b")).toHaveText("b:shared-v1");
-    await expect(page.locator("#error")).toBeEmpty();
-  } finally {
-    releaseCss();
-  }
+  await mutateAndWaitForBuild(page, () => writeShared("shared-after-css-v2"));
+  await waitForPageReload(page, afterCssReload);
+  await page.locator("#load").click();
+  await expect(page.locator("#a")).toHaveText("a:shared-after-css-v2");
+  await expect(page.locator("#b")).toHaveText("b:shared-after-css-v2");
+  await expect(page.locator("#error")).toBeEmpty();
 });
 
-test("disposes and restores missing dynamic lists without reloading", async ({
+test("reloads when an active dynamic list disappears and restores it", async ({
   page,
 }) => {
   const receivedFrames = pageFrames.get(page)!;
-  const sentFrames: string[] = [];
-  page.on("websocket", (socket) => {
-    socket.on("framesent", ({ payload }) => sentFrames.push(String(payload)));
-  });
 
   await page.goto("/");
   await page.locator("#load").click();
@@ -510,57 +562,26 @@ test("disposes and restores missing dynamic lists without reloading", async ({
       ),
     )
     .toBeTruthy();
-  await expect
-    .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
-    .toBe(2);
+  const afterRemovalReload = await waitForPageReload(page, initial);
+  await expect(page.locator("#a")).toHaveText("pending");
+  await expect(page.locator("#b")).toHaveText("pending");
 
   await mutateAndWaitForBuild(page, () =>
     fs.writeFileSync(indexPath, indexBaseline),
   );
   await expect
     .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
-    .toBe(3);
+    .toBeGreaterThanOrEqual(2);
 
-  await page.locator("#a").evaluate((element) => {
-    element.textContent = "disposed";
-  });
   await page.locator("#load").click();
   await expect(page.locator("#a")).toHaveText("a:shared-v1");
   await expect(page.locator("#b")).toHaveText("b:shared-v1");
   await expect(page.locator("#error")).toBeEmpty();
 
   const restored = await readRuntimeState(page);
-  // Both old dynamic lists disappeared during re-chunking, so the shared
-  // module is released only after its final owner is gone and runs once more
-  // when the restored lists load.
-  expect(restored.evaluations).toBe(2);
-  expect(restored.pageToken).toBe(initial.pageToken);
-  expect(restored.timeOrigin).toBe(initial.timeOrigin);
-
-  const aSubscriptions = sentFrames
-    .map((frame) => {
-      try {
-        return JSON.parse(frame);
-      } catch {
-        return null;
-      }
-    })
-    .filter(
-      (message) =>
-        message?.type === "turbopack-subscribe" &&
-        /(?:^|\/)src_a_[^/]+\.js$/.test(message.path),
-    );
-  expect(aSubscriptions).toHaveLength(4);
-  expect(
-    aSubscriptions.filter((message) => message.validation === undefined),
-  ).toHaveLength(2);
-  expect(
-    new Set(
-      aSubscriptions
-        .map((message) => message.validation)
-        .filter((validation) => validation !== undefined),
-    ).size,
-  ).toBe(2);
+  expect(restored.evaluations).toBe(1);
+  expect(restored.pageToken).toBe(afterRemovalReload.pageToken);
+  expect(restored.timeOrigin).toBe(afterRemovalReload.timeOrigin);
 });
 
 test("rejects a dynamic bootstrap that disappears before its baseline", async ({
@@ -569,9 +590,11 @@ test("rejects a dynamic bootstrap that disappears before its baseline", async ({
   await page.addInitScript(() => {
     const originalSend = WebSocket.prototype.send;
     const delayedFrames: Array<{ socket: WebSocket; data: any }> = [];
-    let delaySubscriptions = true;
+    let delaySubscriptions =
+      sessionStorage.getItem("pack-hmr-disable-bootstrap-delay") !== "1";
     (globalThis as any).__delayedDynamicSubscriptions = [];
     (globalThis as any).__flushDynamicSubscriptions = () => {
+      sessionStorage.setItem("pack-hmr-disable-bootstrap-delay", "1");
       delaySubscriptions = false;
       for (const { socket, data } of delayedFrames.splice(0)) {
         originalSend.call(socket, data);
@@ -618,9 +641,8 @@ test("rejects a dynamic bootstrap that disappears before its baseline", async ({
   );
   await page.evaluate(() => (globalThis as any).__flushDynamicSubscriptions());
 
-  await expect(page.locator("#error")).toContainText(
-    "disappeared while loading",
-  );
+  const afterBootstrapReload = await waitForPageReload(page, initial);
+  await expect(page.locator("#error")).toBeEmpty();
   await expect(page.locator("#a")).toHaveText("pending");
   await expect(page.locator("#b")).toHaveText("pending");
   expect((await readRuntimeState(page)).evaluations).toBeUndefined();
@@ -630,10 +652,7 @@ test("rejects a dynamic bootstrap that disappears before its baseline", async ({
   );
   await expect
     .poll(() => readRuntimeState(page).then((state) => state.entryEvaluations))
-    .toBeGreaterThanOrEqual(3);
-  await page.locator("#error").evaluate((element) => {
-    element.textContent = "";
-  });
+    .toBeGreaterThanOrEqual(2);
   await page.locator("#load").click();
   await expect(page.locator("#a")).toHaveText("a:shared-v1");
   await expect(page.locator("#b")).toHaveText("b:shared-v1");
@@ -641,6 +660,6 @@ test("rejects a dynamic bootstrap that disappears before its baseline", async ({
 
   const restored = await readRuntimeState(page);
   expect(restored.evaluations).toBe(1);
-  expect(restored.pageToken).toBe(initial.pageToken);
-  expect(restored.timeOrigin).toBe(initial.timeOrigin);
+  expect(restored.pageToken).toBe(afterBootstrapReload.pageToken);
+  expect(restored.timeOrigin).toBe(afterBootstrapReload.timeOrigin);
 });

From 3428501000df6e100f2df17788c8a07682a89886 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Fri, 24 Jul 2026 11:25:09 +0800
Subject: [PATCH 10/11] test(pack): drop generated HMR snapshots

---
 .../hmr/dynamic_chunk_lists/assert.js         |   81 -
 .../hmr/dynamic_chunk_lists/config.json       |   23 -
 .../hmr/dynamic_chunk_lists/input/index.js    |    3 -
 .../hmr/dynamic_chunk_lists/input/lazy.js     |    1 -
 .../output/_root-of-the-server___7c304173.js  | 1256 ---------
 .../output/input_index_83022b3b.js            |    5 -
 .../output/input_lazy_0468b002.js             |    7 -
 .../output/input_lazy_5395e95a.js             |   14 -
 .../output/input_lazy_b90c1087.js             |   12 -
 .../hmr/dynamic_chunk_lists/output/main.js    | 2470 -----------------
 .../assert.js                                 |   33 -
 .../config.json                               |   23 -
 .../input/index.js                            |    3 -
 .../input/lazy.js                             |    1 -
 .../output/_root-of-the-server___2651c4ea.js  |  453 ---
 .../output/input_lazy_b65347b5.js             |   12 -
 .../output/input_lazy_c5880b16.js             |   14 -
 .../output/main.js                            | 2470 -----------------
 18 files changed, 6881 deletions(-)
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js
 delete mode 100644 crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js

diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
deleted file mode 100644
index 7abf594f9..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/assert.js
+++ /dev/null
@@ -1,81 +0,0 @@
-const assert = require("node:assert/strict");
-const fs = require("node:fs");
-const path = require("node:path");
-
-const outputDir = path.join(__dirname, "output");
-const javascriptAssets = fs
-  .readdirSync(outputDir)
-  .filter((file) => file.endsWith(".js"))
-  .map((file) => ({
-    file,
-    content: fs.readFileSync(path.join(outputDir, file), "utf8"),
-  }));
-const registrations = javascriptAssets.filter(({ content }) =>
-  content.includes("_CHUNK_LISTS"),
-);
-
-const entryRegistrations = registrations.filter(({ content }) =>
-  /source:\s*["']entry["']/.test(content),
-);
-const dynamicRegistrations = registrations.filter(({ content }) =>
-  /source:\s*["']dynamic["']/.test(content),
-);
-
-assert.equal(
-  entryRegistrations.length,
-  1,
-  "the runtime entry should have one HMR chunk list",
-);
-assert.equal(
-  dynamicRegistrations.length,
-  1,
-  "a loaded dynamic chunk group should have its own HMR chunk list",
-);
-
-function readChunks(registration) {
-  const match = registration.match(/chunks:\s*(\[[^\n]*\])/);
-  assert.ok(match, "the HMR registration should contain a chunks array");
-  return JSON.parse(match[1]);
-}
-
-function readChunkVersions(registration) {
-  const match = registration.match(/chunkVersions:\s*(\{[^\n]*\})/);
-  assert.ok(match, "the HMR registration should contain chunk versions");
-  return JSON.parse(match[1]);
-}
-
-const entryChunks = new Set(readChunks(entryRegistrations[0].content));
-const dynamicChunks = readChunks(dynamicRegistrations[0].content);
-const dynamicChunkVersions = readChunkVersions(dynamicRegistrations[0].content);
-
-assert.ok(dynamicChunks.length > 0, "the dynamic HMR list should not be empty");
-assert.ok(
-  dynamicChunks.every((chunk) => !entryChunks.has(chunk)),
-  "dynamic payload chunks should not be duplicated in the entry HMR list",
-);
-assert.deepEqual(
-  Object.keys(dynamicChunkVersions).sort(),
-  [...dynamicChunks].sort(),
-  "every dynamic member must carry the content version used for its URL",
-);
-assert.ok(
-  Object.values(dynamicChunkVersions).every(
-    (version) => typeof version === "string" && version.length > 0,
-  ),
-  "dynamic member content versions must be non-empty strings",
-);
-
-const asyncLoader = javascriptAssets.find(({ content }) =>
-  content.includes("return parentImport("),
-);
-assert.ok(asyncLoader, "the fixture should emit an async loader");
-const loaderMatch = asyncLoader.content.match(
-  /return Promise\.all\((\[[\s\S]*?\])\.map/,
-);
-assert.ok(loaderMatch, "the async loader should contain a chunk array");
-const loaderChunks = JSON.parse(loaderMatch[1]);
-assert.deepEqual(
-  loaderChunks,
-  [dynamicRegistrations[0].file],
-  "the async loader must fetch only the HMR-list bootstrap before content",
-);
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
deleted file mode 100644
index 5141b968f..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/config.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-  "config": {
-    "entry": [
-      {
-        "import": "input/index.js",
-        "name": "main"
-      }
-    ],
-    "mode": "development",
-    "devServer": {
-      "hot": true
-    },
-    "sourceMaps": false,
-    "optimization": {
-      "minify": false
-    },
-    "output": {
-      "path": "output"
-    }
-  },
-  "runtimeType": "Development",
-  "watch": true
-}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js
deleted file mode 100644
index cf953ba51..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/index.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export async function loadLazy() {
-  return import('./lazy')
-}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js
deleted file mode 100644
index 6a722af50..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/input/lazy.js
+++ /dev/null
@@ -1 +0,0 @@
-export const value = 'lazy'
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
deleted file mode 100644
index 36bb751ef..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/_root-of-the-server___7c304173.js
+++ /dev/null
@@ -1,1256 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[@utoo/pack-runtime]/hmr/bootstrap.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([]);
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/hmr/client.ts [client] (ecmascript)");
-;
-(0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["initHMR"])("TURBOPACK_CHUNK_UPDATE_LISTENERS");
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/hmr/client.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "initHMR",
-    ()=>initHMR
-]);
-// @ts-ignore
-var __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[turbopack]/browser/dev/hmr-client/hmr-client.ts [client] (ecmascript)");
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/hmr/websocket.ts [client] (ecmascript)");
-;
-;
-function initHMR(chunkUpdateListenersGlobal = "TURBOPACK_CHUNK_UPDATE_LISTENERS") {
-    (0, __TURBOPACK__imported__module__$5b$turbopack$5d2f$browser$2f$dev$2f$hmr$2d$client$2f$hmr$2d$client$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["connect"])({
-        addMessageListener: __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["addMessageListener"],
-        sendMessage: __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["sendMessage"],
-        onUpdateError: console.error,
-        chunkUpdateListenersGlobal
-    });
-    (0, __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$hmr$2f$websocket$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["connectHMR"])({
-        path: "/turbopack-hmr"
-    });
-}
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/hmr/websocket.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-// Adapted from https://github.com/vercel/next.js/blob/canary/packages/next/src/client/dev/error-overlay/websocket.ts
-__turbopack_context__.s([
-    "addMessageListener",
-    ()=>addMessageListener,
-    "connectHMR",
-    ()=>connectHMR,
-    "sendMessage",
-    ()=>sendMessage
-]);
-let source = null;
-let eventCallbacks = [];
-const INITIAL_RECONNECT_DELAY_MS = 500;
-const MAX_RECONNECT_DELAY_MS = 5_000;
-// Helper function to dispatch messages to all event callbacks
-function dispatchMessage(message) {
-    for (const eventCallback of eventCallbacks){
-        eventCallback(message);
-    }
-}
-function addMessageListener(callback) {
-    eventCallbacks.push(callback);
-}
-function sendMessage(data) {
-    if (source && source.readyState === source.OPEN) {
-        const message = typeof data === "string" ? data : JSON.stringify(data);
-        source.send(message);
-    }
-}
-function getSocketProtocol() {
-    return typeof location !== "undefined" && location.protocol === "https:" ? "wss" : "ws";
-}
-function getSocketUrl() {
-    const socketServer = ("TURBOPACK compile-time value", undefined);
-    if (socketServer) {
-        try {
-            const parsed = new URL(socketServer);
-            const protocol = parsed.protocol === "https:" ? "wss:" : parsed.protocol === "http:" ? "ws:" : parsed.protocol;
-            if (protocol === "ws:" || protocol === "wss:") {
-                const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
-                return `${protocol}//${parsed.host}${pathname}`;
-            }
-        } catch  {}
-    }
-    const { hostname, port } = location;
-    const protocol = getSocketProtocol();
-    return `${protocol}://${hostname}${port ? `:${port}` : ""}`;
-}
-let reloading = false;
-let serverSessionId = null;
-function connectHMR(options) {
-    let reconnectTimer = null;
-    let reconnectAttempts = 0;
-    let pageIsUnloading = false;
-    function clearReconnectTimer() {
-        if (reconnectTimer !== null) {
-            clearTimeout(reconnectTimer);
-            reconnectTimer = null;
-        }
-    }
-    function closeSocket(socket) {
-        socket.onopen = null;
-        socket.onerror = null;
-        socket.onclose = null;
-        socket.onmessage = null;
-        if (source === socket) {
-            source = null;
-        }
-        if (socket.readyState === WebSocket.CONNECTING || socket.readyState === WebSocket.OPEN) {
-            socket.close();
-        }
-    }
-    function scheduleReconnect() {
-        if (reconnectTimer !== null || pageIsUnloading || reloading) {
-            return;
-        }
-        const delay = Math.min(INITIAL_RECONNECT_DELAY_MS * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY_MS);
-        reconnectAttempts += 1;
-        reconnectTimer = setTimeout(()=>{
-            reconnectTimer = null;
-            init();
-        }, delay);
-    }
-    function init() {
-        if (pageIsUnloading || reloading) {
-            return;
-        }
-        if (source) {
-            closeSocket(source);
-        }
-        console.log("[HMR] connecting...");
-        let socket;
-        try {
-            socket = new WebSocket(`${getSocketUrl()}${options.path}`);
-        } catch (error) {
-            console.error("[HMR] Failed to create WebSocket:", error);
-            scheduleReconnect();
-            return;
-        }
-        source = socket;
-        function handleOnline() {
-            if (source !== socket || pageIsUnloading || reloading) {
-                closeSocket(socket);
-                return;
-            }
-            reconnectAttempts = 0;
-            window.console.log("[HMR] connected");
-            // Direct turbopack-dev-server does not send a separate connected frame.
-            // Utoo does, but the socket-open notification is sufficient to restore
-            // subscriptions in both cases.
-            dispatchMessage({
-                type: "turbopack-connected"
-            });
-        }
-        function handleMessage(event) {
-            if (source !== socket || reloading) {
-                return;
-            }
-            try {
-                const msg = JSON.parse(event.data);
-                // Handle the different message formats from different servers
-                if (msg.action === "turbopack-connected") {
-                    if (serverSessionId !== null && serverSessionId !== msg.data.sessionId) {
-                        reloading = true;
-                        window.location.reload();
-                        return;
-                    }
-                    serverSessionId = msg.data.sessionId;
-                    // Socket open already restored subscriptions. This frame only carries
-                    // the Utoo server session id used to detect server restarts.
-                    return;
-                }
-                if (msg.action === "reload") {
-                    reloading = true;
-                    window.location.reload();
-                    return;
-                }
-                if (msg.action === "turbopack-message") {
-                    const turbopackMessage = {
-                        type: "turbopack-message",
-                        data: msg.data
-                    };
-                    dispatchMessage(turbopackMessage);
-                    return;
-                }
-                // Handle direct turbopack-dev-server messages
-                if (msg.type && [
-                    "partial",
-                    "restart",
-                    "notFound",
-                    "issues"
-                ].includes(msg.type)) {
-                    const turbopackMessage = {
-                        type: "turbopack-message",
-                        data: msg
-                    };
-                    dispatchMessage(turbopackMessage);
-                    return;
-                }
-            // TODO: handle rest msg.actions
-            } catch (e) {
-                console.error("[HMR] Failed to parse message:", e);
-            }
-        }
-        function handleDisconnect(event) {
-            if (event.target !== socket || source !== socket) {
-                return;
-            }
-            closeSocket(socket);
-            window.console.warn("[HMR] disconnected");
-            scheduleReconnect();
-        }
-        socket.onopen = handleOnline;
-        socket.onerror = handleDisconnect;
-        socket.onclose = handleDisconnect;
-        socket.onmessage = handleMessage;
-    }
-    // `pagehide` is not fired when a beforeunload prompt is cancelled, so it is
-    // safe to use as the point where reconnects should stop.
-    window.addEventListener("pagehide", ()=>{
-        pageIsUnloading = true;
-        clearReconnectTimer();
-        if (source) {
-            closeSocket(source);
-        }
-    });
-    // A page restored from the back-forward cache needs a fresh HMR transport.
-    window.addEventListener("pageshow", (event)=>{
-        if (event.persisted) {
-            pageIsUnloading = false;
-            reconnectAttempts = 0;
-            init();
-        }
-    });
-    init();
-}
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "default",
-    ()=>__TURBOPACK__default__export__
-]);
-/**
- * MIT License
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */ // This file is copied from the Metro JavaScript bundler, with minor tweaks for
-// webpack 4 compatibility.
-//
-// https://github.com/facebook/metro/blob/d6b9685c730d0d63577db40f41369157f28dfa3a/packages/metro/src/lib/polyfills/require.js
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
-;
-const { m: turbopackModule } = __turbopack_context__;
-function isSafeExport(key) {
-    return key === "__esModule" || key === "__N_SSG" || key === "__N_SSP" || // TODO: remove this key from page config instead of allow listing it
-    key === "config";
-}
-function registerExportsForReactRefresh(moduleExports, moduleID) {
-    __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(moduleExports, moduleID + " %exports%");
-    if (moduleExports == null || typeof moduleExports !== "object") {
-        // Exit if we can't iterate over exports.
-        // (This is important for legacy environments.)
-        return;
-    }
-    for(var key in moduleExports){
-        if (isSafeExport(key)) {
-            continue;
-        }
-        try {
-            var exportValue = moduleExports[key];
-        } catch  {
-            continue;
-        }
-        var typeID = moduleID + " %exports% " + key;
-        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(exportValue, typeID);
-    }
-}
-function getRefreshBoundarySignature(moduleExports) {
-    var signature = [];
-    signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(moduleExports));
-    if (moduleExports == null || typeof moduleExports !== "object") {
-        // Exit if we can't iterate over exports.
-        // (This is important for legacy environments.)
-        return signature;
-    }
-    for(var key in moduleExports){
-        if (isSafeExport(key)) {
-            continue;
-        }
-        try {
-            var exportValue = moduleExports[key];
-        } catch  {
-            continue;
-        }
-        signature.push(key);
-        signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(exportValue));
-    }
-    return signature;
-}
-function isReactRefreshBoundary(moduleExports) {
-    if (__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(moduleExports)) {
-        return true;
-    }
-    if (moduleExports == null || typeof moduleExports !== "object") {
-        // Exit if we can't iterate over exports.
-        return false;
-    }
-    var hasExports = false;
-    var areAllExportsComponents = true;
-    for(var key in moduleExports){
-        hasExports = true;
-        if (isSafeExport(key)) {
-            continue;
-        }
-        try {
-            var exportValue = moduleExports[key];
-        } catch  {
-            // This might fail due to circular dependencies
-            return false;
-        }
-        if (!__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(exportValue)) {
-            areAllExportsComponents = false;
-        }
-    }
-    return hasExports && areAllExportsComponents;
-}
-function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) {
-    if (prevSignature.length !== nextSignature.length) {
-        return true;
-    }
-    for(var i = 0; i < nextSignature.length; i++){
-        if (prevSignature[i] !== nextSignature[i]) {
-            return true;
-        }
-    }
-    return false;
-}
-var isUpdateScheduled = false;
-// This function aggregates updates from multiple modules into a single React Refresh call.
-function scheduleUpdate() {
-    if (isUpdateScheduled) {
-        return;
-    }
-    isUpdateScheduled = true;
-    function canApplyUpdate(status) {
-        return status === "idle";
-    }
-    function applyUpdate() {
-        isUpdateScheduled = false;
-        try {
-            __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].performReactRefresh();
-        } catch (err) {
-            console.warn("Warning: Failed to re-render. We will retry on the next Fast Refresh event.\n" + err);
-        }
-    }
-    if (canApplyUpdate(turbopackModule.hot.status())) {
-        // Apply update on the next tick.
-        Promise.resolve().then(()=>{
-            applyUpdate();
-        });
-        return;
-    }
-    const statusHandler = (status)=>{
-        if (canApplyUpdate(status)) {
-            turbopackModule.hot.removeStatusHandler(statusHandler);
-            applyUpdate();
-        }
-    };
-    // Apply update once the HMR runtime's status is idle.
-    turbopackModule.hot.addStatusHandler(statusHandler);
-}
-var __TURBOPACK__default__export__ = {
-    registerExportsForReactRefresh: registerExportsForReactRefresh,
-    isReactRefreshBoundary: isReactRefreshBoundary,
-    shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary,
-    getRefreshBoundarySignature: getRefreshBoundarySignature,
-    scheduleUpdate: scheduleUpdate
-};
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)", ((__turbopack_context__, module, exports) => {
-"use strict";
-
-// react@0.18.0: https://unpkg.com/react-refresh@0.18.0/cjs/react-refresh-runtime.development.js
-/**
- * @license React
- * react-refresh-runtime.development.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */ "production" !== ("TURBOPACK compile-time value", "development") && function() {
-    function computeFullKey(signature) {
-        if (null !== signature.fullKey) return signature.fullKey;
-        var fullKey = signature.ownKey;
-        try {
-            var hooks = signature.getCustomHooks();
-        } catch (err) {
-            return signature.forceReset = !0, signature.fullKey = fullKey;
-        }
-        for(var i = 0; i < hooks.length; i++){
-            var hook = hooks[i];
-            if ("function" !== typeof hook) return signature.forceReset = !0, signature.fullKey = fullKey;
-            hook = allSignaturesByType.get(hook);
-            if (void 0 !== hook) {
-                var nestedHookKey = computeFullKey(hook);
-                hook.forceReset && (signature.forceReset = !0);
-                fullKey += "\n---\n" + nestedHookKey;
-            }
-        }
-        return signature.fullKey = fullKey;
-    }
-    function resolveFamily(type) {
-        return updatedFamiliesByType.get(type);
-    }
-    function cloneMap(map) {
-        var clone = new Map();
-        map.forEach(function(value, key) {
-            clone.set(key, value);
-        });
-        return clone;
-    }
-    function cloneSet(set) {
-        var clone = new Set();
-        set.forEach(function(value) {
-            clone.add(value);
-        });
-        return clone;
-    }
-    function getProperty(object, property) {
-        try {
-            return object[property];
-        } catch (err) {}
-    }
-    function register(type, id) {
-        if (!(null === type || "function" !== typeof type && "object" !== typeof type || allFamiliesByType.has(type))) {
-            var family = allFamiliesByID.get(id);
-            void 0 === family ? (family = {
-                current: type
-            }, allFamiliesByID.set(id, family)) : pendingUpdates.push([
-                family,
-                type
-            ]);
-            allFamiliesByType.set(type, family);
-            if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
-                case REACT_FORWARD_REF_TYPE:
-                    register(type.render, id + "$render");
-                    break;
-                case REACT_MEMO_TYPE:
-                    register(type.type, id + "$type");
-            }
-        }
-    }
-    function setSignature(type, key) {
-        var forceReset = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1, getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
-        allSignaturesByType.has(type) || allSignaturesByType.set(type, {
-            forceReset: forceReset,
-            ownKey: key,
-            fullKey: null,
-            getCustomHooks: getCustomHooks || function() {
-                return [];
-            }
-        });
-        if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
-            case REACT_FORWARD_REF_TYPE:
-                setSignature(type.render, key, forceReset, getCustomHooks);
-                break;
-            case REACT_MEMO_TYPE:
-                setSignature(type.type, key, forceReset, getCustomHooks);
-        }
-    }
-    function collectCustomHooksForSignature(type) {
-        type = allSignaturesByType.get(type);
-        void 0 !== type && computeFullKey(type);
-    }
-    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_MEMO_TYPE = Symbol.for("react.memo"), PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map, allFamiliesByID = new Map(), allFamiliesByType = new PossiblyWeakMap(), allSignaturesByType = new PossiblyWeakMap(), updatedFamiliesByType = new PossiblyWeakMap(), pendingUpdates = [], helpersByRendererID = new Map(), helpersByRoot = new Map(), mountedRoots = new Set(), failedRoots = new Set(), rootElements = "function" === typeof WeakMap ? new WeakMap() : null, isPerformingRefresh = !1;
-    exports._getMountedRootCount = function() {
-        return mountedRoots.size;
-    };
-    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
-    exports.createSignatureFunctionForTransform = function() {
-        var savedType, hasCustomHooks, didCollectHooks = !1;
-        return function(type, key, forceReset, getCustomHooks) {
-            if ("string" === typeof key) return savedType || (savedType = type, hasCustomHooks = "function" === typeof getCustomHooks), null == type || "function" !== typeof type && "object" !== typeof type || setSignature(type, key, forceReset, getCustomHooks), type;
-            !didCollectHooks && hasCustomHooks && (didCollectHooks = !0, collectCustomHooksForSignature(savedType));
-        };
-    };
-    exports.getFamilyByID = function(id) {
-        return allFamiliesByID.get(id);
-    };
-    exports.getFamilyByType = function(type) {
-        return allFamiliesByType.get(type);
-    };
-    exports.hasUnrecoverableErrors = function() {
-        return !1;
-    };
-    exports.injectIntoGlobalHook = function(globalObject) {
-        var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-        if (void 0 === hook) {
-            var nextID = 0;
-            globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
-                renderers: new Map(),
-                supportsFiber: !0,
-                inject: function() {
-                    return nextID++;
-                },
-                onScheduleFiberRoot: function() {},
-                onCommitFiberRoot: function() {},
-                onCommitFiberUnmount: function() {}
-            };
-        }
-        if (hook.isDisabled) console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
-        else {
-            var oldInject = hook.inject;
-            hook.inject = function(injected) {
-                var id = oldInject.apply(this, arguments);
-                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
-                return id;
-            };
-            hook.renderers.forEach(function(injected, id) {
-                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
-            });
-            var oldOnCommitFiberRoot = hook.onCommitFiberRoot, oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {};
-            hook.onScheduleFiberRoot = function(id, root, children) {
-                isPerformingRefresh || (failedRoots.delete(root), null !== rootElements && rootElements.set(root, children));
-                return oldOnScheduleFiberRoot.apply(this, arguments);
-            };
-            hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
-                var helpers = helpersByRendererID.get(id);
-                if (void 0 !== helpers) {
-                    helpersByRoot.set(root, helpers);
-                    helpers = root.current;
-                    var alternate = helpers.alternate;
-                    null !== alternate ? (alternate = null != alternate.memoizedState && null != alternate.memoizedState.element && mountedRoots.has(root), helpers = null != helpers.memoizedState && null != helpers.memoizedState.element, !alternate && helpers ? (mountedRoots.add(root), failedRoots.delete(root)) : alternate && helpers || (alternate && !helpers ? (mountedRoots.delete(root), didError ? failedRoots.add(root) : helpersByRoot.delete(root)) : alternate || helpers || didError && failedRoots.add(root))) : mountedRoots.add(root);
-                }
-                return oldOnCommitFiberRoot.apply(this, arguments);
-            };
-        }
-    };
-    exports.isLikelyComponentType = function(type) {
-        switch(typeof type){
-            case "function":
-                if (null != type.prototype) {
-                    if (type.prototype.isReactComponent) return !0;
-                    var ownNames = Object.getOwnPropertyNames(type.prototype);
-                    if (1 < ownNames.length || "constructor" !== ownNames[0] || type.prototype.__proto__ !== Object.prototype) return !1;
-                }
-                type = type.name || type.displayName;
-                return "string" === typeof type && /^[A-Z]/.test(type);
-            case "object":
-                if (null != type) switch(getProperty(type, "$$typeof")){
-                    case REACT_FORWARD_REF_TYPE:
-                    case REACT_MEMO_TYPE:
-                        return !0;
-                }
-                return !1;
-            default:
-                return !1;
-        }
-    };
-    exports.performReactRefresh = function() {
-        if (0 === pendingUpdates.length || isPerformingRefresh) return null;
-        isPerformingRefresh = !0;
-        try {
-            var staleFamilies = new Set(), updatedFamilies = new Set(), updates = pendingUpdates;
-            pendingUpdates = [];
-            updates.forEach(function(_ref) {
-                var family = _ref[0];
-                _ref = _ref[1];
-                var prevType = family.current;
-                updatedFamiliesByType.set(prevType, family);
-                updatedFamiliesByType.set(_ref, family);
-                family.current = _ref;
-                prevType.prototype && prevType.prototype.isReactComponent || _ref.prototype && _ref.prototype.isReactComponent ? _ref = !1 : (prevType = allSignaturesByType.get(prevType), _ref = allSignaturesByType.get(_ref), _ref = void 0 === prevType && void 0 === _ref || void 0 !== prevType && void 0 !== _ref && computeFullKey(prevType) === computeFullKey(_ref) && !_ref.forceReset ? !0 : !1);
-                _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
-            });
-            var update = {
-                updatedFamilies: updatedFamilies,
-                staleFamilies: staleFamilies
-            };
-            helpersByRendererID.forEach(function(helpers) {
-                helpers.setRefreshHandler(resolveFamily);
-            });
-            var didError = !1, firstError = null, failedRootsSnapshot = cloneSet(failedRoots), mountedRootsSnapshot = cloneSet(mountedRoots), helpersByRootSnapshot = cloneMap(helpersByRoot);
-            failedRootsSnapshot.forEach(function(root) {
-                var helpers = helpersByRootSnapshot.get(root);
-                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
-                failedRoots.has(root);
-                if (null !== rootElements && rootElements.has(root)) {
-                    var element = rootElements.get(root);
-                    try {
-                        helpers.scheduleRoot(root, element);
-                    } catch (err) {
-                        didError || (didError = !0, firstError = err);
-                    }
-                }
-            });
-            mountedRootsSnapshot.forEach(function(root) {
-                var helpers = helpersByRootSnapshot.get(root);
-                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
-                mountedRoots.has(root);
-                try {
-                    helpers.scheduleRefresh(root, update);
-                } catch (err) {
-                    didError || (didError = !0, firstError = err);
-                }
-            });
-            if (didError) throw firstError;
-            return update;
-        } finally{
-            isPerformingRefresh = !1;
-        }
-    };
-    exports.register = register;
-    exports.setSignature = setSignature;
-}();
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([]);
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)");
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
-;
-;
-// Hook into ReactDOM initialization
-__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].injectIntoGlobalHook(self);
-// Register global helpers
-self.$RefreshHelpers$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["default"];
-// Register a helper for module execution interception
-self.$RefreshInterceptModuleExecution$ = function(webpackModuleId) {
-    var prevRefreshReg = self.$RefreshReg$;
-    var prevRefreshSig = self.$RefreshSig$;
-    self.$RefreshReg$ = function(type, id) {
-        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(type, webpackModuleId + " " + id);
-    };
-    self.$RefreshSig$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].createSignatureFunctionForTransform;
-    // Modeled after `useEffect` cleanup pattern:
-    // https://react.dev/learn/synchronizing-with-effects#step-3-add-cleanup-if-needed
-    return function() {
-        self.$RefreshReg$ = prevRefreshReg;
-        self.$RefreshSig$ = prevRefreshSig;
-    };
-};
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "loadLazy",
-    ()=>loadLazy
-]);
-async function loadLazy() {
-    return __turbopack_context__.A("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript, async loader)");
-}
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[turbopack]/browser/dev/hmr-client/hmr-client.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-/// <reference path="../../../shared/runtime/runtime-types.d.ts" />
-/// <reference path="../../../shared/runtime/dev-globals.d.ts" />
-/// <reference path="../../../shared/runtime/dev-protocol.d.ts" />
-/// <reference path="../../../shared/runtime/dev-extensions.ts" />
-__turbopack_context__.s([
-    "TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL",
-    ()=>TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL,
-    "connect",
-    ()=>connect,
-    "setHooks",
-    ()=>setHooks,
-    "subscribeToUpdate",
-    ()=>subscribeToUpdate
-]);
-const TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL = 'TURBOPACK_CHUNK_UPDATE_LISTENERS';
-function connect({ addMessageListener, sendMessage, onUpdateError = console.error, chunkUpdateListenersGlobal }) {
-    addMessageListener((msg)=>{
-        switch(msg.type){
-            case 'turbopack-connected':
-                handleSocketConnected(sendMessage);
-                break;
-            default:
-                try {
-                    if (Array.isArray(msg.data)) {
-                        for(let i = 0; i < msg.data.length; i++){
-                            handleSocketMessage(msg.data[i]);
-                        }
-                    } else {
-                        handleSocketMessage(msg.data);
-                    }
-                    applyAggregatedUpdates();
-                } catch (e) {
-                    console.warn('[Fast Refresh] performing full reload\n\n' + "Fast Refresh will perform a full reload when you edit a file that's imported by modules outside of the React rendering tree.\n" + 'You might have a file which exports a React component but also exports a value that is imported by a non-React component file.\n' + 'Consider migrating the non-React component export to a separate file and importing it into both files.\n\n' + 'It is also possible the parent component of the component you edited is a class component, which disables Fast Refresh.\n' + 'Fast Refresh requires at least one parent function component in your React tree.');
-                    onUpdateError(e);
-                    location.reload();
-                }
-                break;
-        }
-    });
-    const global = globalThis;
-    const queued = global[chunkUpdateListenersGlobal];
-    if (queued != null && !Array.isArray(queued)) {
-        throw new Error('A separate HMR handler was already registered');
-    }
-    global[chunkUpdateListenersGlobal] = {
-        push: ([chunkPath, callback, options])=>{
-            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.conservative, options?.onSubscribed, options?.expectedVersion);
-        }
-    };
-    if (Array.isArray(queued)) {
-        for (const [chunkPath, callback, options] of queued){
-            subscribeToChunkUpdate(chunkPath, sendMessage, callback, options?.conservative, options?.onSubscribed, options?.expectedVersion);
-        }
-    }
-}
-const updateCallbackSets = new Map();
-function sendJSON(sendMessage, message) {
-    sendMessage(JSON.stringify(message));
-}
-function resourceKey(resource) {
-    return JSON.stringify({
-        path: resource.path,
-        headers: resource.headers || null
-    });
-}
-function createValidationToken() {
-    return `${Date.now()}:${Math.random()}`;
-}
-function subscribeToUpdates(sendMessage, resource, expectedVersion, validation) {
-    sendJSON(sendMessage, {
-        type: 'turbopack-subscribe',
-        ...resource,
-        version: expectedVersion,
-        validation
-    });
-    return ()=>{
-        sendJSON(sendMessage, {
-            type: 'turbopack-unsubscribe',
-            ...resource
-        });
-    };
-}
-function handleSocketConnected(sendMessage) {
-    for (const [key, callbackSet] of updateCallbackSets){
-        callbackSet.subscribed = false;
-        if (callbackSet.validationToken !== undefined) {
-            callbackSet.validationToken = createValidationToken();
-        }
-        callbackSet.unsubscribe = subscribeToUpdates(sendMessage, JSON.parse(key), callbackSet.expectedVersion, callbackSet.validationToken);
-    }
-}
-// we aggregate all pending updates until the issues are resolved
-const chunkListsWithPendingUpdates = new Map();
-function aggregateUpdates(msg) {
-    const key = resourceKey(msg.resource);
-    let aggregated = chunkListsWithPendingUpdates.get(key);
-    if (aggregated) {
-        aggregated.instruction = mergeChunkListUpdates(aggregated.instruction, msg.instruction);
-    } else {
-        chunkListsWithPendingUpdates.set(key, msg);
-    }
-}
-function applyAggregatedUpdates() {
-    if (chunkListsWithPendingUpdates.size === 0) return;
-    const updates = [
-        ...chunkListsWithPendingUpdates.values()
-    ];
-    chunkListsWithPendingUpdates.clear();
-    if (updates.length > 1 && updates.some((update)=>updateCallbackSets.get(resourceKey(update.resource))?.conservative)) {
-        throw new Error('Multiple dynamic HMR lists changed in one build; reloading conservatively.');
-    }
-    hooks.beforeRefresh();
-    for (const msg of updates){
-        triggerUpdate(msg);
-    }
-    finalizeUpdate();
-}
-function mergeChunkListUpdates(updateA, updateB) {
-    let chunks;
-    if (updateA.chunks != null) {
-        if (updateB.chunks == null) {
-            chunks = updateA.chunks;
-        } else {
-            chunks = mergeChunkListChunks(updateA.chunks, updateB.chunks);
-        }
-    } else if (updateB.chunks != null) {
-        chunks = updateB.chunks;
-    }
-    let merged;
-    if (updateA.merged != null) {
-        if (updateB.merged == null) {
-            merged = updateA.merged;
-        } else {
-            // Since `merged` is an array of updates, we need to merge them all into
-            // one, consistent update.
-            // Since there can only be `EcmascriptMergeUpdates` in the array, there is
-            // no need to key on the `type` field.
-            let update = updateA.merged[0];
-            for(let i = 1; i < updateA.merged.length; i++){
-                update = mergeChunkListEcmascriptMergedUpdates(update, updateA.merged[i]);
-            }
-            for(let i = 0; i < updateB.merged.length; i++){
-                update = mergeChunkListEcmascriptMergedUpdates(update, updateB.merged[i]);
-            }
-            merged = [
-                update
-            ];
-        }
-    } else if (updateB.merged != null) {
-        merged = updateB.merged;
-    }
-    return {
-        type: 'ChunkListUpdate',
-        chunks,
-        merged
-    };
-}
-function mergeChunkListChunks(chunksA, chunksB) {
-    const chunks = {};
-    for (const [chunkPath, chunkUpdateA] of Object.entries(chunksA)){
-        const chunkUpdateB = chunksB[chunkPath];
-        if (chunkUpdateB != null) {
-            const mergedUpdate = mergeChunkUpdates(chunkUpdateA, chunkUpdateB);
-            if (mergedUpdate != null) {
-                chunks[chunkPath] = mergedUpdate;
-            }
-        } else {
-            chunks[chunkPath] = chunkUpdateA;
-        }
-    }
-    for (const [chunkPath, chunkUpdateB] of Object.entries(chunksB)){
-        if (chunks[chunkPath] == null) {
-            chunks[chunkPath] = chunkUpdateB;
-        }
-    }
-    return chunks;
-}
-function mergeChunkUpdates(updateA, updateB) {
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        return undefined;
-    }
-    if (updateB.type === 'total') {
-        // A total update replaces the entire chunk, so it supersedes any prior update.
-        return updateB;
-    }
-    if (updateA.type === 'partial') {
-        invariant(updateA.instruction, 'Partial updates are unsupported');
-    }
-    if (updateB.type === 'partial') {
-        invariant(updateB.instruction, 'Partial updates are unsupported');
-    }
-    return undefined;
-}
-function mergeChunkListEcmascriptMergedUpdates(mergedA, mergedB) {
-    const entries = mergeEcmascriptChunkEntries(mergedA.entries, mergedB.entries);
-    const chunks = mergeEcmascriptChunksUpdates(mergedA.chunks, mergedB.chunks);
-    return {
-        type: 'EcmascriptMergedUpdate',
-        entries,
-        chunks
-    };
-}
-function mergeEcmascriptChunkEntries(entriesA, entriesB) {
-    return {
-        ...entriesA,
-        ...entriesB
-    };
-}
-function mergeEcmascriptChunksUpdates(chunksA, chunksB) {
-    if (chunksA == null) {
-        return chunksB;
-    }
-    if (chunksB == null) {
-        return chunksA;
-    }
-    const chunks = {};
-    for (const [chunkPath, chunkUpdateA] of Object.entries(chunksA)){
-        const chunkUpdateB = chunksB[chunkPath];
-        if (chunkUpdateB != null) {
-            const mergedUpdate = mergeEcmascriptChunkUpdates(chunkUpdateA, chunkUpdateB);
-            if (mergedUpdate != null) {
-                chunks[chunkPath] = mergedUpdate;
-            }
-        } else {
-            chunks[chunkPath] = chunkUpdateA;
-        }
-    }
-    for (const [chunkPath, chunkUpdateB] of Object.entries(chunksB)){
-        if (chunks[chunkPath] == null) {
-            chunks[chunkPath] = chunkUpdateB;
-        }
-    }
-    if (Object.keys(chunks).length === 0) {
-        return undefined;
-    }
-    return chunks;
-}
-function mergeEcmascriptChunkUpdates(updateA, updateB) {
-    if (updateA.type === 'added' && updateB.type === 'deleted') {
-        // These two completely cancel each other out.
-        return undefined;
-    }
-    if (updateA.type === 'deleted' && updateB.type === 'added') {
-        const added = [];
-        const deleted = [];
-        const deletedModules = new Set(updateA.modules ?? []);
-        const addedModules = new Set(updateB.modules ?? []);
-        for (const moduleId of addedModules){
-            if (!deletedModules.has(moduleId)) {
-                added.push(moduleId);
-            }
-        }
-        for (const moduleId of deletedModules){
-            if (!addedModules.has(moduleId)) {
-                deleted.push(moduleId);
-            }
-        }
-        if (added.length === 0 && deleted.length === 0) {
-            return undefined;
-        }
-        return {
-            type: 'partial',
-            added,
-            deleted
-        };
-    }
-    if (updateA.type === 'partial' && updateB.type === 'partial') {
-        const added = new Set([
-            ...updateA.added ?? [],
-            ...updateB.added ?? []
-        ]);
-        const deleted = new Set([
-            ...updateA.deleted ?? [],
-            ...updateB.deleted ?? []
-        ]);
-        if (updateB.added != null) {
-            for (const moduleId of updateB.added){
-                deleted.delete(moduleId);
-            }
-        }
-        if (updateB.deleted != null) {
-            for (const moduleId of updateB.deleted){
-                added.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'partial') {
-        const modules = new Set([
-            ...updateA.modules ?? [],
-            ...updateB.added ?? []
-        ]);
-        for (const moduleId of updateB.deleted ?? []){
-            modules.delete(moduleId);
-        }
-        return {
-            type: 'added',
-            modules: [
-                ...modules
-            ]
-        };
-    }
-    if (updateA.type === 'partial' && updateB.type === 'deleted') {
-        // We could eagerly return `updateB` here, but this would potentially be
-        // incorrect if `updateA` has added modules.
-        const modules = new Set(updateB.modules ?? []);
-        if (updateA.added != null) {
-            for (const moduleId of updateA.added){
-                modules.delete(moduleId);
-            }
-        }
-        return {
-            type: 'deleted',
-            modules: [
-                ...modules
-            ]
-        };
-    }
-    // Any other update combination is invalid.
-    return undefined;
-}
-function invariant(_, message) {
-    throw new Error(`Invariant: ${message}`);
-}
-const CRITICAL = [
-    'bug',
-    'error',
-    'fatal'
-];
-function compareByList(list, a, b) {
-    const aI = list.indexOf(a) + 1 || list.length;
-    const bI = list.indexOf(b) + 1 || list.length;
-    return aI - bI;
-}
-const chunksWithIssues = new Map();
-function emitIssues() {
-    const issues = [];
-    const deduplicationSet = new Set();
-    for (const [_, chunkIssues] of chunksWithIssues){
-        for (const chunkIssue of chunkIssues){
-            if (deduplicationSet.has(chunkIssue.formatted)) continue;
-            issues.push(chunkIssue);
-            deduplicationSet.add(chunkIssue.formatted);
-        }
-    }
-    sortIssues(issues);
-    hooks.issues(issues);
-}
-function handleIssues(msg) {
-    const key = resourceKey(msg.resource);
-    let hasCriticalIssues = false;
-    for (const issue of msg.issues){
-        if (CRITICAL.includes(issue.severity)) {
-            hasCriticalIssues = true;
-        }
-    }
-    if (msg.issues.length > 0) {
-        chunksWithIssues.set(key, msg.issues);
-    } else if (chunksWithIssues.has(key)) {
-        chunksWithIssues.delete(key);
-    }
-    emitIssues();
-    return hasCriticalIssues;
-}
-const SEVERITY_ORDER = [
-    'bug',
-    'fatal',
-    'error',
-    'warning',
-    'info',
-    'log'
-];
-const CATEGORY_ORDER = [
-    'parse',
-    'resolve',
-    'code generation',
-    'rendering',
-    'typescript',
-    'other'
-];
-function sortIssues(issues) {
-    issues.sort((a, b)=>{
-        const first = compareByList(SEVERITY_ORDER, a.severity, b.severity);
-        if (first !== 0) return first;
-        return compareByList(CATEGORY_ORDER, a.category, b.category);
-    });
-}
-const hooks = {
-    beforeRefresh: ()=>{},
-    refresh: ()=>{},
-    buildOk: ()=>{},
-    issues: (_issues)=>{}
-};
-function setHooks(newHooks) {
-    Object.assign(hooks, newHooks);
-}
-function handleSocketMessage(msg) {
-    const callbackSet = updateCallbackSets.get(resourceKey(msg.resource));
-    if (!callbackSet || callbackSet.validationToken !== msg.validation) {
-        // Frames already queued by an old subscription can arrive after an
-        // unsubscribe. Only the active validation generation may update state.
-        return;
-    }
-    sortIssues(msg.issues);
-    const hasCriticalIssues = handleIssues(msg);
-    if (!hasCriticalIssues && msg.type === 'issues') {
-        markUpdateSubscriptionReady(msg.resource);
-    } else if (msg.type !== 'issues') {
-        rejectUpdateSubscriptionValidation(msg.resource, new Error(`Received ${msg.type} before the HMR subscription baseline was validated.`));
-    }
-    switch(msg.type){
-        case 'issues':
-            break;
-        case 'partial':
-            // aggregate updates
-            aggregateUpdates(msg);
-            break;
-        default:
-            // run single update
-            const runHooks = chunkListsWithPendingUpdates.size === 0;
-            if (runHooks) hooks.beforeRefresh();
-            triggerUpdate(msg);
-            if (runHooks) finalizeUpdate();
-            break;
-    }
-}
-function markUpdateSubscriptionReady(resource) {
-    const callbackSet = updateCallbackSets.get(resourceKey(resource));
-    if (!callbackSet || callbackSet.subscribed) return;
-    callbackSet.subscribed = true;
-    callbackSet.validation?.resolve();
-    callbackSet.validation = undefined;
-    for (const callback of callbackSet.onSubscribedCallbacks){
-        callback(callbackSet.revalidate);
-    }
-    callbackSet.onSubscribedCallbacks.clear();
-}
-function rejectUpdateSubscriptionValidation(resource, error) {
-    const callbackSet = updateCallbackSets.get(resourceKey(resource));
-    if (!callbackSet || callbackSet.subscribed) return;
-    callbackSet.validation?.reject(error);
-    callbackSet.validation = undefined;
-}
-function finalizeUpdate() {
-    hooks.refresh();
-    hooks.buildOk();
-    // This is used by the Next.js integration test suite to notify it when HMR
-    // updates have been completed.
-    // TODO: Only run this in test environments (gate by `process.env.__NEXT_TEST_MODE`)
-    if (globalThis.__NEXT_HMR_CB) {
-        globalThis.__NEXT_HMR_CB();
-        globalThis.__NEXT_HMR_CB = null;
-    }
-}
-function subscribeToChunkUpdate(chunkListPath, sendMessage, callback, conservative, onSubscribed, expectedVersion) {
-    return subscribeToUpdate({
-        path: chunkListPath
-    }, sendMessage, callback, conservative, onSubscribed, expectedVersion);
-}
-function subscribeToUpdate(resource, sendMessage, callback, conservative, onSubscribed, expectedVersion) {
-    const key = resourceKey(resource);
-    let callbackSet;
-    const existingCallbackSet = updateCallbackSets.get(key);
-    if (!existingCallbackSet) {
-        let callbackSetRef;
-        const revalidate = ()=>{
-            if (callbackSetRef.validation) return callbackSetRef.validation.promise;
-            if (updateCallbackSets.get(key) !== callbackSetRef) {
-                return Promise.reject(new Error(`Cannot validate an inactive HMR subscription for ${resource.path}.`));
-            }
-            callbackSetRef.unsubscribe();
-            callbackSetRef.subscribed = false;
-            callbackSetRef.validationToken = createValidationToken();
-            let resolve;
-            let reject;
-            const promise = new Promise((innerResolve, innerReject)=>{
-                resolve = innerResolve;
-                reject = innerReject;
-            });
-            callbackSetRef.validation = {
-                promise,
-                resolve,
-                reject
-            };
-            callbackSetRef.unsubscribe = subscribeToUpdates(sendMessage, resource, expectedVersion, callbackSetRef.validationToken);
-            return promise;
-        };
-        const validationToken = onSubscribed ? createValidationToken() : undefined;
-        callbackSet = {
-            callbacks: new Set([
-                callback
-            ]),
-            conservative: Boolean(conservative),
-            onSubscribedCallbacks: new Set(onSubscribed ? [
-                onSubscribed
-            ] : []),
-            subscribed: false,
-            expectedVersion,
-            validationToken,
-            revalidate,
-            unsubscribe: subscribeToUpdates(sendMessage, resource, expectedVersion, validationToken)
-        };
-        callbackSetRef = callbackSet;
-        updateCallbackSets.set(key, callbackSet);
-    } else {
-        if (existingCallbackSet.expectedVersion !== expectedVersion) {
-            location.reload();
-            return ()=>{};
-        }
-        existingCallbackSet.callbacks.add(callback);
-        existingCallbackSet.conservative ||= Boolean(conservative);
-        if (onSubscribed) {
-            if (existingCallbackSet.subscribed) {
-                onSubscribed(existingCallbackSet.revalidate);
-            } else {
-                existingCallbackSet.onSubscribedCallbacks.add(onSubscribed);
-            }
-        }
-        callbackSet = existingCallbackSet;
-    }
-    return ()=>{
-        callbackSet.callbacks.delete(callback);
-        if (onSubscribed) callbackSet.onSubscribedCallbacks.delete(onSubscribed);
-        if (callbackSet.callbacks.size === 0) {
-            callbackSet.unsubscribe();
-            updateCallbackSets.delete(key);
-            callbackSet.validationToken = undefined;
-            callbackSet.validation?.reject(new Error(`HMR subscription for ${resource.path} was removed.`));
-            callbackSet.validation = undefined;
-        }
-    };
-}
-function triggerUpdate(msg) {
-    const key = resourceKey(msg.resource);
-    const callbackSet = updateCallbackSets.get(key);
-    if (!callbackSet) {
-        return;
-    }
-    for (const callback of callbackSet.callbacks){
-        callback(msg);
-    }
-    if (msg.type === 'notFound') {
-        // This indicates that the resource which we subscribed to either does not exist or
-        // has been deleted. In either case, we should clear all update callbacks, so if a
-        // new subscription is created for the same resource, it will send a new "subscribe"
-        // message to the server.
-        // No need to send an "unsubscribe" message to the server, it will have already
-        // dropped the update stream before sending the "notFound" message.
-        updateCallbackSets.delete(key);
-    }
-}
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
deleted file mode 100644
index d3aa94f2c..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_index_83022b3b.js
+++ /dev/null
@@ -1,5 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["input_lazy_b90c1087.js","_root-of-the-server___7c304173.js"],
-    source: "entry"
-});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
deleted file mode 100644
index 026c44090..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_0468b002.js
+++ /dev/null
@@ -1,7 +0,0 @@
-(globalThis["TURBOPACK_CHUNK_LISTS"] || (globalThis["TURBOPACK_CHUNK_LISTS"] = [])).push({
-    script: typeof document === "object" ? document.currentScript : undefined,
-    chunks: ["input_lazy_5395e95a.js"],
-    source: "dynamic",
-chunkVersions: {"input_lazy_5395e95a.js":"kLSvJuOI5c4"},
-version: "ajrJuYAhFyU"
-});
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
deleted file mode 100644
index 3ff5fe527..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_5395e95a.js
+++ /dev/null
@@ -1,14 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "value",
-    ()=>value
-]);
-const value = 'lazy';
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js
deleted file mode 100644
index 4f973a332..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/input_lazy_b90c1087.js
+++ /dev/null
@@ -1,12 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript, async loader)", ((__turbopack_context__) => {
-
-__turbopack_context__.v((parentImport) => {
-    return Promise.all([
-  "input_lazy_0468b002.js"
-].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
-        return parentImport("[project]/hmr/dynamic_chunk_lists/input/lazy.js [client] (ecmascript)");
-    });
-});
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
deleted file mode 100644
index e88c7cf64..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists/output/main.js
+++ /dev/null
@@ -1,2470 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
-    typeof document === "object" ? document.currentScript : undefined,
-    {"otherChunks":["input_lazy_b90c1087.js","_root-of-the-server___7c304173.js"],"runtimeModuleIds":["[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)","[@utoo/pack-runtime]/hmr/bootstrap.ts [client] (ecmascript)","[project]/hmr/dynamic_chunk_lists/input/index.js [client] (ecmascript)"]}
-]);
-(() => {
-if (!Array.isArray(globalThis["TURBOPACK"])) {
-    return;
-}
-
-var CHUNK_BASE_PATH = "/";
-var WORKER_BASE_PATH = null;
-var RELATIVE_ROOT_PATH = "/ROOT";
-var RUNTIME_PUBLIC_PATH = "/";
-globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"] ||= [];
-var CHUNK_UPDATE_LISTENERS = {
-    push: (registration) => globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"].push(registration),
-};
-var ASSET_SUFFIX = "";
-var CROSS_ORIGIN = null;
-var CHUNK_LOAD_RETRY_MAX_ATTEMPTS = 1;
-var CHUNK_LOAD_RETRY_BASE_DELAY_MS = 200;
-var CHUNK_LOAD_RETRY_MAX_JITTER_MS = 400;
-var WORKER_FORWARDED_GLOBALS = [];
-/**
- * This file contains runtime types and functions that are shared between all
- * TurboPack ECMAScript runtimes.
- *
- * It will be prepended to the runtime code of each runtime.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
-/// <reference path="./async-module.ts" />
-/**
- * Describes why a module was instantiated.
- * Shared between browser and Node.js runtimes.
- */ var SourceType = function(SourceType) {
-    /**
-   * The module was instantiated because it was included in an evaluated chunk's
-   * runtime.
-   * SourceData is a ChunkPath.
-   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
-    /**
-   * The module was instantiated because a parent module imported it.
-   * SourceData is a ModuleId.
-   */ SourceType[SourceType["Parent"] = 1] = "Parent";
-    /**
-   * The module was instantiated because it was included in a chunk's hot module
-   * update.
-   * SourceData is an array of ModuleIds or undefined.
-   */ SourceType[SourceType["Update"] = 2] = "Update";
-    return SourceType;
-}(SourceType || {});
-/**
- * Flag indicating which module object type to create when a module is merged. Set to `true`
- * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,
- * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it
- * uses plain Module objects.
- */ let createModuleWithDirectionFlag = false;
-const REEXPORTED_OBJECTS = new WeakMap();
-/**
- * Constructs the `__turbopack_context__` object for a module.
- */ function Context(module, exports) {
-    this.m = module;
-    // We need to store this here instead of accessing it from the module object to:
-    // 1. Make it available to factories directly, since we rewrite `this` to
-    //    `__turbopack_context__.e` in CJS modules.
-    // 2. Support async modules which rewrite `module.exports` to a promise, so we
-    //    can still access the original exports object from functions like
-    //    `esmExport`
-    // Ideally we could find a new approach for async modules and drop this property altogether.
-    this.e = exports;
-}
-const contextPrototype = Context.prototype;
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
-function defineProp(obj, name, options) {
-    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
-}
-function getOverwrittenModule(moduleCache, id) {
-    let module = moduleCache[id];
-    if (!module) {
-        if (createModuleWithDirectionFlag) {
-            // set in development modes for hmr support
-            module = createModuleWithDirection(id);
-        } else {
-            module = createModuleObject(id);
-        }
-        moduleCache[id] = module;
-    }
-    return module;
-}
-/**
- * Creates the module object. Only done here to ensure all module objects have the same shape.
- */ function createModuleObject(id) {
-    return {
-        exports: {},
-        error: undefined,
-        id,
-        namespaceObject: undefined
-    };
-}
-function createModuleWithDirection(id) {
-    return {
-        exports: {},
-        error: undefined,
-        id,
-        namespaceObject: undefined,
-        parents: [],
-        children: []
-    };
-}
-const BindingTag_Value = 0;
-/**
- * Adds the getters to the exports object.
- */ function esm(exports, bindings) {
-    defineProp(exports, '__esModule', {
-        value: true
-    });
-    if (toStringTag) defineProp(exports, toStringTag, {
-        value: 'Module'
-    });
-    let i = 0;
-    while(i < bindings.length){
-        const propName = bindings[i++];
-        const tagOrFunction = bindings[i++];
-        if (typeof tagOrFunction === 'number') {
-            if (tagOrFunction === BindingTag_Value) {
-                defineProp(exports, propName, {
-                    value: bindings[i++],
-                    enumerable: true,
-                    writable: false
-                });
-            } else {
-                throw new Error(`unexpected tag: ${tagOrFunction}`);
-            }
-        } else {
-            const getterFn = tagOrFunction;
-            if (typeof bindings[i] === 'function') {
-                const setterFn = bindings[i++];
-                defineProp(exports, propName, {
-                    get: getterFn,
-                    set: setterFn,
-                    enumerable: true
-                });
-            } else {
-                defineProp(exports, propName, {
-                    get: getterFn,
-                    enumerable: true
-                });
-            }
-        }
-    }
-    Object.seal(exports);
-}
-/**
- * Makes the module an ESM with exports
- */ function esmExport(bindings, id) {
-    let module;
-    let exports;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-        exports = module.exports;
-    } else {
-        module = this.m;
-        exports = this.e;
-    }
-    module.namespaceObject = exports;
-    esm(exports, bindings);
-}
-contextPrototype.s = esmExport;
-function ensureDynamicExports(module, exports) {
-    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
-    if (!reexportedObjects) {
-        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
-        module.exports = module.namespaceObject = new Proxy(exports, {
-            get (target, prop) {
-                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
-                    return Reflect.get(target, prop);
-                }
-                for (const obj of reexportedObjects){
-                    const value = Reflect.get(obj, prop);
-                    if (value !== undefined) return value;
-                }
-                return undefined;
-            },
-            ownKeys (target) {
-                const keys = Reflect.ownKeys(target);
-                for (const obj of reexportedObjects){
-                    for (const key of Reflect.ownKeys(obj)){
-                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
-                    }
-                }
-                return keys;
-            }
-        });
-    }
-    return reexportedObjects;
-}
-/**
- * Dynamically exports properties from an object
- */ function dynamicExport(object, id) {
-    let module;
-    let exports;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-        exports = module.exports;
-    } else {
-        module = this.m;
-        exports = this.e;
-    }
-    const reexportedObjects = ensureDynamicExports(module, exports);
-    if (typeof object === 'object' && object !== null) {
-        reexportedObjects.push(object);
-    }
-}
-contextPrototype.j = dynamicExport;
-function exportValue(value, id) {
-    let module;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-    } else {
-        module = this.m;
-    }
-    module.exports = value;
-}
-contextPrototype.v = exportValue;
-function exportNamespace(namespace, id) {
-    let module;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-    } else {
-        module = this.m;
-    }
-    module.exports = module.namespaceObject = namespace;
-}
-contextPrototype.n = exportNamespace;
-function createGetter(obj, key) {
-    return ()=>obj[key];
-}
-/**
- * @returns prototype of the object
- */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
-/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
-    null,
-    getProto({}),
-    getProto([]),
-    getProto(getProto)
-];
-/**
- * @param raw
- * @param ns
- * @param allowExportDefault
- *   * `false`: will have the raw module as default export
- *   * `true`: will have the default property as default export
- */ function interopEsm(raw, ns, allowExportDefault) {
-    const bindings = [];
-    let defaultLocation = -1;
-    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
-        for (const key of Object.getOwnPropertyNames(current)){
-            bindings.push(key, createGetter(raw, key));
-            if (defaultLocation === -1 && key === 'default') {
-                defaultLocation = bindings.length - 1;
-            }
-        }
-    }
-    // this is not really correct
-    // we should set the `default` getter if the imported module is a `.cjs file`
-    if (!(allowExportDefault && defaultLocation >= 0)) {
-        // Replace the binding with one for the namespace itself in order to preserve iteration order.
-        if (defaultLocation >= 0) {
-            // Replace the getter with the value
-            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
-        } else {
-            bindings.push('default', BindingTag_Value, raw);
-        }
-    }
-    esm(ns, bindings);
-    return ns;
-}
-function createNS(raw) {
-    if (typeof raw === 'function') {
-        return function(...args) {
-            return raw.apply(this, args);
-        };
-    } else {
-        return Object.create(null);
-    }
-}
-function esmImport(id) {
-    const module = getOrInstantiateModuleFromParent(id, this.m);
-    // any ES module has to have `module.namespaceObject` defined.
-    if (module.namespaceObject) return module.namespaceObject;
-    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
-    const raw = module.exports;
-    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
-}
-contextPrototype.i = esmImport;
-function asyncLoader(moduleId) {
-    const loader = this.r(moduleId);
-    return loader(esmImport.bind(this));
-}
-contextPrototype.A = asyncLoader;
-// Add a simple runtime require so that environments without one can still pass
-// `typeof require` CommonJS checks so that exports are correctly registered.
-const runtimeRequire = // @ts-ignore
-typeof require === 'function' ? require : function require1() {
-    throw new Error('Unexpected use of runtime require');
-};
-contextPrototype.t = runtimeRequire;
-function commonJsRequire(id) {
-    return getOrInstantiateModuleFromParent(id, this.m).exports;
-}
-contextPrototype.r = commonJsRequire;
-/**
- * Remove fragments and query parameters since they are never part of the context map keys
- *
- * This matches how we parse patterns at resolving time.  Arguably we should only do this for
- * strings passed to `import` but the resolve does it for `import` and `require` and so we do
- * here as well.
- */ function parseRequest(request) {
-    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
-    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
-    const hashIndex = request.indexOf('#');
-    if (hashIndex !== -1) {
-        request = request.substring(0, hashIndex);
-    }
-    const queryIndex = request.indexOf('?');
-    if (queryIndex !== -1) {
-        request = request.substring(0, queryIndex);
-    }
-    return request;
-}
-/**
- * `require.context` and require/import expression runtime.
- */ function moduleContext(map) {
-    function moduleContext(id) {
-        id = parseRequest(id);
-        if (hasOwnProperty.call(map, id)) {
-            return map[id].module();
-        }
-        const e = new Error(`Cannot find module '${id}'`);
-        e.code = 'MODULE_NOT_FOUND';
-        throw e;
-    }
-    moduleContext.keys = ()=>{
-        return Object.keys(map);
-    };
-    moduleContext.resolve = (id)=>{
-        id = parseRequest(id);
-        if (hasOwnProperty.call(map, id)) {
-            return map[id].id();
-        }
-        const e = new Error(`Cannot find module '${id}'`);
-        e.code = 'MODULE_NOT_FOUND';
-        throw e;
-    };
-    moduleContext.import = async (id)=>{
-        return await moduleContext(id);
-    };
-    return moduleContext;
-}
-contextPrototype.f = moduleContext;
-/**
- * Returns the path of a chunk defined by its data.
- */ function getChunkPath(chunkData) {
-    return typeof chunkData === 'string' ? chunkData : chunkData.path;
-}
-// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
-// The CompressedModuleFactories format is
-// - 1 or more module ids
-// - a module factory function
-// So walking this is a little complex but the flat structure is also fast to
-// traverse, we can use `typeof` operators to distinguish the two cases.
-function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
-    let i = offset;
-    while(i < chunkModules.length){
-        let end = i + 1;
-        // Find our factory function
-        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
-            end++;
-        }
-        if (end === chunkModules.length) {
-            throw new Error('malformed chunk format, expected a factory function');
-        }
-        // Install the factory for each module ID that doesn't already have one.
-        // When some IDs in this group already have a factory, reuse that existing
-        // group factory for the missing IDs to keep all IDs in the group consistent.
-        // Otherwise, install the factory from this chunk.
-        const moduleFactoryFn = chunkModules[end];
-        let existingGroupFactory = undefined;
-        for(let j = i; j < end; j++){
-            const id = chunkModules[j];
-            const existingFactory = moduleFactories.get(id);
-            if (existingFactory) {
-                existingGroupFactory = existingFactory;
-                break;
-            }
-        }
-        const factoryToInstall = existingGroupFactory ?? moduleFactoryFn;
-        let didInstallFactory = false;
-        for(let j = i; j < end; j++){
-            const id = chunkModules[j];
-            if (!moduleFactories.has(id)) {
-                if (!didInstallFactory) {
-                    if (factoryToInstall === moduleFactoryFn) {
-                        applyModuleFactoryName(moduleFactoryFn);
-                    }
-                    didInstallFactory = true;
-                }
-                moduleFactories.set(id, factoryToInstall);
-                newModuleId?.(id);
-            }
-        }
-        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
-    }
-}
-/**
- * A pseudo "fake" URL object to resolve to its relative path.
- *
- * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
- * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
- * hydration mismatch.
- *
- * This is based on webpack's existing implementation:
- * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
- */ const relativeURL = function relativeURL(inputUrl) {
-    const realUrl = new URL(inputUrl, 'x:/');
-    const values = {};
-    for(const key in realUrl)values[key] = realUrl[key];
-    values.href = inputUrl;
-    values.pathname = inputUrl.replace(/[?#].*/, '');
-    values.origin = values.protocol = '';
-    values.toString = values.toJSON = (..._args)=>inputUrl;
-    for(const key in values)Object.defineProperty(this, key, {
-        enumerable: true,
-        configurable: true,
-        value: values[key]
-    });
-};
-relativeURL.prototype = URL.prototype;
-contextPrototype.U = relativeURL;
-/**
- * Utility function to ensure all variants of an enum are handled.
- */ function invariant(never, computeMessage) {
-    throw new Error(`Invariant: ${computeMessage(never)}`);
-}
-/**
- * Constructs an error message for when a module factory is not available.
- */ function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
-    let instantiationReason;
-    switch(sourceType){
-        case 0:
-            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
-            break;
-        case 1:
-            instantiationReason = `because it was required from module ${sourceData}`;
-            break;
-        case 2:
-            instantiationReason = 'because of an HMR update';
-            break;
-        default:
-            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
-    }
-    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
-}
-/**
- * A stub function to make `require` available but non-functional in ESM.
- */ function requireStub(_moduleId) {
-    throw new Error('dynamic usage of require is not supported');
-}
-contextPrototype.z = requireStub;
-// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
-contextPrototype.g = globalThis;
-let cachedAutomaticPublicPath;
-function getAutomaticPublicPath() {
-    if (cachedAutomaticPublicPath !== undefined) {
-        return cachedAutomaticPublicPath;
-    }
-    let scriptUrl;
-    if (typeof document === 'object') {
-        const currentScript = document.currentScript;
-        scriptUrl = currentScript?.src;
-        if (!scriptUrl) {
-            const scripts = document.getElementsByTagName('script');
-            const script = scripts[scripts.length - 1];
-            scriptUrl = script?.src;
-        }
-    }
-    if (!scriptUrl && typeof globalThis.importScripts === 'function' && globalThis.location) {
-        scriptUrl = String(globalThis.location);
-    }
-    cachedAutomaticPublicPath = scriptUrl ? scriptUrl.replace(/^blob:/, '').replace(/#.*$/, '').replace(/\?.*$/, '').replace(/\/[^/]*$/, '/') : '';
-    return cachedAutomaticPublicPath;
-}
-/**
- * Gets the public path for runtime assets.
- * Checks globalThis.publicPath and falls back to "/".
- */ function getPublicPath(mode) {
-    if (mode === 'auto') {
-        return getAutomaticPublicPath();
-    }
-    if (typeof globalThis !== 'undefined' && typeof globalThis.publicPath === 'string') {
-        const publicPath = globalThis.publicPath;
-        return publicPath.endsWith('/') ? publicPath : `${publicPath}/`;
-    }
-    return '/';
-}
-contextPrototype.p = getPublicPath;
-function applyModuleFactoryName(factory) {
-    // Give the module factory a nice name to improve stack traces.
-    Object.defineProperty(factory, 'name', {
-        value: 'module evaluation'
-    });
-}
-/// <reference path="./runtime-types.d.ts" />
-/// <reference path="./runtime-utils.ts" />
-/**
- * Top-level-await / async-module machinery. This is only included in the runtime
- * when the module graph actually contains an async module (a module with
- * top-level await, or one that transitively depends on one). When no async
- * module is present, the chunk items never reference `__turbopack_context__.a`,
- * so this whole file can be omitted.
- *
- * everything below is adapted from webpack
- * https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
- */ const turbopackQueues = Symbol('turbopack queues');
-const turbopackExports = Symbol('turbopack exports');
-const turbopackError = Symbol('turbopack error');
-function isPromise(maybePromise) {
-    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
-}
-function isAsyncModuleExt(obj) {
-    return turbopackQueues in obj;
-}
-function createPromise() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        reject = rej;
-        resolve = res;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject
-    };
-}
-function resolveQueue(queue) {
-    if (queue && queue.status !== 1) {
-        queue.status = 1;
-        queue.forEach((fn)=>fn.queueCount--);
-        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
-    }
-}
-function wrapDeps(deps) {
-    return deps.map((dep)=>{
-        if (dep !== null && typeof dep === 'object') {
-            if (isAsyncModuleExt(dep)) return dep;
-            if (isPromise(dep)) {
-                const queue = Object.assign([], {
-                    status: 0
-                });
-                const obj = {
-                    [turbopackExports]: {},
-                    [turbopackQueues]: (fn)=>fn(queue)
-                };
-                dep.then((res)=>{
-                    obj[turbopackExports] = res;
-                    resolveQueue(queue);
-                }, (err)=>{
-                    obj[turbopackError] = err;
-                    resolveQueue(queue);
-                });
-                return obj;
-            }
-        }
-        return {
-            [turbopackExports]: dep,
-            [turbopackQueues]: ()=>{}
-        };
-    });
-}
-function asyncModule(body, hasAwait) {
-    const module = this.m;
-    const queue = hasAwait ? Object.assign([], {
-        status: -1
-    }) : undefined;
-    const depQueues = new Set();
-    const { resolve, reject, promise: rawPromise } = createPromise();
-    const promise = Object.assign(rawPromise, {
-        [turbopackExports]: module.exports,
-        [turbopackQueues]: (fn)=>{
-            queue && fn(queue);
-            depQueues.forEach(fn);
-            promise['catch'](()=>{});
-        }
-    });
-    const attributes = {
-        get () {
-            return promise;
-        },
-        set (v) {
-            // Calling `esmExport` leads to this.
-            if (v !== promise) {
-                promise[turbopackExports] = v;
-            }
-        }
-    };
-    Object.defineProperty(module, 'exports', attributes);
-    Object.defineProperty(module, 'namespaceObject', attributes);
-    function handleAsyncDependencies(deps) {
-        const currentDeps = wrapDeps(deps);
-        const getResult = ()=>currentDeps.map((d)=>{
-                if (d[turbopackError]) throw d[turbopackError];
-                return d[turbopackExports];
-            });
-        const { promise, resolve } = createPromise();
-        const fn = Object.assign(()=>resolve(getResult), {
-            queueCount: 0
-        });
-        function fnQueue(q) {
-            if (q !== queue && !depQueues.has(q)) {
-                depQueues.add(q);
-                if (q && q.status === 0) {
-                    fn.queueCount++;
-                    q.push(fn);
-                }
-            }
-        }
-        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
-        return fn.queueCount ? promise : getResult();
-    }
-    function asyncResult(err) {
-        if (err) {
-            reject(promise[turbopackError] = err);
-        } else {
-            resolve(promise[turbopackExports]);
-        }
-        resolveQueue(queue);
-    }
-    body(handleAsyncDependencies, asyncResult);
-    if (queue && queue.status === -1) {
-        queue.status = 0;
-    }
-}
-contextPrototype.a = asyncModule;
-/**
- * This file contains runtime types and functions that are shared between all
- * Turbopack *browser* ECMAScript runtimes.
- *
- * It will be appended to the runtime code of each runtime right after the
- * shared runtime utils.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
-/// <reference path="../../../shared/runtime/runtime-utils.ts" />
-// Used in WebWorkers to tell the runtime about the chunk suffix
-// Support runtime public path modes.
-function getRuntimeChunkBasePath(basePath = CHUNK_BASE_PATH) {
-    if (basePath === '__RUNTIME_PUBLIC_PATH__') {
-        return contextPrototype.p();
-    }
-    if (basePath === '__AUTO_PUBLIC_PATH__') {
-        return contextPrototype.p('auto');
-    }
-    return basePath;
-}
-const browserContextPrototype = Context.prototype;
-const moduleFactories = new Map();
-contextPrototype.M = moduleFactories;
-const availableModules = new Map();
-const availableModuleChunks = new Map();
-function loadChunk(chunkData) {
-    return loadChunkInternal(SourceType.Parent, this.m.id, chunkData);
-}
-browserContextPrototype.l = loadChunk;
-function loadInitialChunk(chunkPath, chunkData) {
-    return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
-}
-async function loadChunkInternal(sourceType, sourceData, chunkData) {
-    if (typeof chunkData === 'string') {
-        return loadChunkPath(sourceType, sourceData, chunkData);
-    }
-    const includedList = chunkData.included || [];
-    const modulesPromises = includedList.map((included)=>{
-        if (moduleFactories.has(included)) return true;
-        return availableModules.get(included);
-    });
-    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
-        // When all included items are already loaded or loading, we can skip loading ourselves
-        await Promise.all(modulesPromises);
-        return;
-    }
-    const includedModuleChunksList = chunkData.moduleChunks || [];
-    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
-        // TODO(alexkirsz) Do we need this check?
-        // if (moduleFactories[included]) return true;
-        return availableModuleChunks.get(included);
-    }).filter((p)=>p);
-    let promise;
-    if (moduleChunksPromises.length > 0) {
-        // Some module chunks are already loaded or loading.
-        if (moduleChunksPromises.length === includedModuleChunksList.length) {
-            // When all included module chunks are already loaded or loading, we can skip loading ourselves
-            await Promise.all(moduleChunksPromises);
-            return;
-        }
-        const moduleChunksToLoad = new Set();
-        for (const moduleChunk of includedModuleChunksList){
-            if (!availableModuleChunks.has(moduleChunk)) {
-                moduleChunksToLoad.add(moduleChunk);
-            }
-        }
-        for (const moduleChunkToLoad of moduleChunksToLoad){
-            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
-            availableModuleChunks.set(moduleChunkToLoad, promise);
-            moduleChunksPromises.push(promise);
-        }
-        promise = Promise.all(moduleChunksPromises);
-    } else {
-        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
-        // Mark all included module chunks as loading if they are not already loaded or loading.
-        for (const includedModuleChunk of includedModuleChunksList){
-            if (!availableModuleChunks.has(includedModuleChunk)) {
-                availableModuleChunks.set(includedModuleChunk, promise);
-            }
-        }
-    }
-    for (const included of includedList){
-        if (!availableModules.has(included)) {
-            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
-            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
-            availableModules.set(included, promise);
-        }
-    }
-    await promise;
-}
-const loadedChunk = Promise.resolve(undefined);
-const instrumentedBackendLoadChunks = new WeakMap();
-// Do not make this async. React relies on referential equality of the returned Promise.
-function loadChunkByUrl(chunkUrl) {
-    return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl);
-}
-browserContextPrototype.L = loadChunkByUrl;
-const loadedScripts = new Map();
-/**
- * Load an external script by creating a <script> tag.
- * This is used for script externals that need to be loaded from CDN or other external sources.
- */ function loadScript(scriptUrl) {
-    // Return cached promise if script is already loading or loaded
-    let promise = loadedScripts.get(scriptUrl);
-    if (promise) {
-        return promise;
-    }
-    promise = new Promise((resolve, reject)=>{
-        const script = document.createElement('script');
-        script.crossOrigin = CROSS_ORIGIN;
-        script.src = scriptUrl;
-        script.onload = ()=>resolve();
-        script.onerror = ()=>reject(new Error(`Failed to load script: ${scriptUrl}`));
-        document.head.appendChild(script);
-    });
-    loadedScripts.set(scriptUrl, promise);
-    return promise;
-}
-browserContextPrototype.S = loadScript;
-// Do not make this async. React relies on referential equality of the returned Promise.
-function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
-    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
-    let entry = instrumentedBackendLoadChunks.get(thenable);
-    if (entry === undefined) {
-        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
-        entry = thenable.then(resolve).catch((cause)=>{
-            let loadReason;
-            switch(sourceType){
-                case SourceType.Runtime:
-                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
-                    break;
-                case SourceType.Parent:
-                    loadReason = `from module ${sourceData}`;
-                    break;
-                case SourceType.Update:
-                    loadReason = 'from an HMR update';
-                    break;
-                default:
-                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
-            }
-            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
-                cause
-            } : undefined);
-            error.name = 'ChunkLoadError';
-            throw error;
-        });
-        instrumentedBackendLoadChunks.set(thenable, entry);
-    }
-    return entry;
-}
-// Do not make this async. React relies on referential equality of the returned Promise.
-function loadChunkPath(sourceType, sourceData, chunkPath) {
-    const url = getChunkRelativeUrl(chunkPath);
-    return loadChunkByUrlInternal(sourceType, sourceData, url);
-}
-/**
- * Returns an absolute url to an asset.
- */ function resolvePathFromModule(moduleId) {
-    const exported = this.r(moduleId);
-    return exported?.default ?? exported;
-}
-browserContextPrototype.R = resolvePathFromModule;
-/**
- * no-op for browser
- * @param modulePath
- */ function resolveAbsolutePath(modulePath) {
-    return `/ROOT/${modulePath ?? ''}`;
-}
-browserContextPrototype.P = resolveAbsolutePath;
-/**
- * Returns a placeholder `file://` URL for the given module path. The browser
- * runtime intentionally does not expose the real filesystem path. Path
- * segments are percent-encoded so the result is always a valid file URI.
- */ function resolveFileUrl(modulePath) {
-    if (!modulePath) return 'file:///ROOT/';
-    return `file:///ROOT/${modulePath.split('/').map(encodeURIComponent).join('/')}`;
-}
-browserContextPrototype.F = resolveFileUrl;
-/**
- * Exports a URL with the static suffix appended.
- */ function exportUrl(url, id) {
-    exportValue.call(this, `${url}${ASSET_SUFFIX}`, id);
-}
-browserContextPrototype.q = exportUrl;
-/**
- * Instantiates a runtime module.
- */ function instantiateRuntimeModule(moduleId, chunkPath) {
-    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
-}
-/**
- * Returns the URL relative to the origin where a chunk can be fetched from.
- */ function getChunkRelativeUrl(chunkPath, basePath = CHUNK_BASE_PATH) {
-    return `${getRuntimeChunkBasePath(basePath)}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${ASSET_SUFFIX}`;
-}
-// Shared runtime primitives consumed by the bundled `createWorker` helper,
-// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.
-browserContextPrototype.b = CHUNK_BASE_PATH;
-browserContextPrototype.X = ASSET_SUFFIX;
-// Shared runtime primitive: build a chunk's URL. Used by the bundled worker
-// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.
-browserContextPrototype.h = getChunkRelativeUrl;
-function getPathFromScript(chunkScript) {
-    if (typeof chunkScript === 'string') {
-        return chunkScript;
-    }
-    const chunkUrl = chunkScript.src;
-    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
-    const runtimeBasePath = getRuntimeChunkBasePath();
-    let path = src.startsWith(runtimeBasePath) ? src.slice(runtimeBasePath.length) : src;
-    if (path.startsWith('/')) {
-        path = path.slice(1);
-    }
-    return path;
-}
-/**
- * Return the ChunkUrl from a ChunkScript.
- */ function getUrlFromScript(chunk) {
-    if (typeof chunk === 'string') {
-        return getChunkRelativeUrl(chunk);
-    } else {
-        // This is already exactly what we want
-        return chunk.src;
-    }
-}
-/**
- * Determine the chunk to register. Note that this function has side-effects!
- */ function getChunkFromRegistration(chunk) {
-    if (typeof chunk === 'string') {
-        return chunk;
-    } else if (!chunk) {
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        } else {
-            throw new Error('chunk path empty but not in a worker');
-        }
-    } else {
-        return {
-            src: chunk.getAttribute('src')
-        };
-    }
-}
-/**
- * Checks if a given path/URL ends with the given extension,
- * optionally followed by ?query or #fragment.
- */ function endsWithExtension(chunkUrlOrPath, ext) {
-    // Find where the path ends (before query or fragment)
-    const q = chunkUrlOrPath.indexOf('?');
-    let end;
-    if (q !== -1) {
-        end = q;
-    } else {
-        const h = chunkUrlOrPath.indexOf('#');
-        end = h !== -1 ? h : chunkUrlOrPath.length;
-    }
-    // Check if the path portion ends with the extension
-    return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length);
-}
-function isJs(chunkUrlOrPath) {
-    return endsWithExtension(chunkUrlOrPath, '.js');
-}
-function isCss(chunkUrl) {
-    return endsWithExtension(chunkUrl, '.css');
-}
-/// <reference path="./runtime-utils.ts" />
-/// <reference path="./runtime-types.d.ts" />
-/// <reference path="./dev-extensions.ts" />
-/// <reference path="./dev-protocol.d.ts" />
-/**
- * Shared HMR (Hot Module Replacement) implementation.
- *
- * This file contains the complete HMR implementation that's shared between
- * browser and Node.js runtimes. It manages module hot state, dependency
- * tracking, the module.hot API, and the full HMR update flow.
- */ /**
- * The development module cache shared across the runtime.
- * Browser runtime declares this directly.
- * Node.js runtime assigns globalThis.__turbopack_module_cache__ to this.
- */ let devModuleCache;
-/**
- * Module IDs that are instantiated as part of the runtime of a chunk.
- */ let runtimeModules;
-/**
- * Maps module IDs to persisted data between executions of their hot module
- * implementation (`hot.data`).
- */ const moduleHotData = new Map();
-/**
- * Maps module instances to their hot module state.
- * Uses WeakMap so it works with both HotModule and ModuleWithDirection.
- */ const moduleHotState = new WeakMap();
-/**
- * Modules that call `module.hot.invalidate()` (while being updated).
- */ const queuedInvalidatedModules = new Set();
-class UpdateApplyError extends Error {
-    name = 'UpdateApplyError';
-    constructor(message, dependencyChain){
-        super(message);
-        this.dependencyChain = dependencyChain;
-    }
-}
-/**
- * Records parent-child relationship when a module imports another.
- * Should be called during module instantiation.
- */ // eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackModuleImport(parentModule, childModuleId, childModule) {
-    // Record that parent imports child
-    if (parentModule.children.indexOf(childModuleId) === -1) {
-        parentModule.children.push(childModuleId);
-    }
-    // Record that child is imported by parent
-    if (childModule && childModule.parents.indexOf(parentModule.id) === -1) {
-        childModule.parents.push(parentModule.id);
-    }
-}
-function formatDependencyChain(dependencyChain) {
-    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
-}
-/**
- * Walks the dependency tree to find all modules affected by a change.
- * Returns information about whether the update can be accepted and which
- * modules need to be invalidated.
- *
- * @param moduleId - The module that changed
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().
- *                           This is used for server-side HMR where pages auto-accept at the top level.
- */ function getAffectedModuleEffects(moduleId, autoAcceptRootModules) {
-    const outdatedModules = new Set();
-    const outdatedDependencies = new Map();
-    const queue = [
-        {
-            moduleId,
-            dependencyChain: []
-        }
-    ];
-    let nextItem;
-    while(nextItem = queue.shift()){
-        const { moduleId, dependencyChain } = nextItem;
-        if (moduleId != null) {
-            if (outdatedModules.has(moduleId)) {
-                continue;
-            }
-            outdatedModules.add(moduleId);
-        }
-        // We've arrived at the runtime of the chunk, which means that nothing
-        // else above can accept this update.
-        if (moduleId === undefined) {
-            if (autoAcceptRootModules) {
-                return {
-                    type: 'accepted',
-                    moduleId,
-                    outdatedModules,
-                    outdatedDependencies
-                };
-            }
-            return {
-                type: 'unaccepted',
-                dependencyChain
-            };
-        }
-        const module = devModuleCache[moduleId];
-        const hotState = moduleHotState.get(module);
-        if (// The module is not in the cache. Since this is a "modified" update,
-        // it means that the module was never instantiated before.
-        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
-            continue;
-        }
-        if (hotState.selfDeclined) {
-            return {
-                type: 'self-declined',
-                dependencyChain,
-                moduleId
-            };
-        }
-        if (runtimeModules.has(moduleId)) {
-            if (autoAcceptRootModules) {
-                continue;
-            }
-            queue.push({
-                moduleId: undefined,
-                dependencyChain: [
-                    ...dependencyChain,
-                    moduleId
-                ]
-            });
-            continue;
-        }
-        for (const parentId of module.parents){
-            const parent = devModuleCache[parentId];
-            if (!parent) {
-                continue;
-            }
-            const parentHotState = moduleHotState.get(parent);
-            // Check if parent declined this dependency
-            if (parentHotState?.declinedDependencies[moduleId]) {
-                return {
-                    type: 'declined',
-                    dependencyChain: [
-                        ...dependencyChain,
-                        moduleId
-                    ],
-                    moduleId,
-                    parentId
-                };
-            }
-            // Skip if parent is already outdated
-            if (outdatedModules.has(parentId)) {
-                continue;
-            }
-            // Check if parent accepts this dependency
-            if (parentHotState?.acceptedDependencies[moduleId]) {
-                if (!outdatedDependencies.has(parentId)) {
-                    outdatedDependencies.set(parentId, new Set());
-                }
-                outdatedDependencies.get(parentId).add(moduleId);
-                continue;
-            }
-            // Neither accepted nor declined — propagate to parent
-            queue.push({
-                moduleId: parentId,
-                dependencyChain: [
-                    ...dependencyChain,
-                    moduleId
-                ]
-            });
-        }
-        // If no parents and we're at a root module, auto-accept if configured
-        if (module.parents.length === 0 && autoAcceptRootModules) {
-            continue;
-        }
-    }
-    return {
-        type: 'accepted',
-        moduleId,
-        outdatedModules,
-        outdatedDependencies
-    };
-}
-/**
- * Merges source dependency map into target dependency map.
- */ function mergeDependencies(target, source) {
-    for (const [parentId, deps] of source){
-        const existing = target.get(parentId);
-        if (existing) {
-            for (const dep of deps){
-                existing.add(dep);
-            }
-        } else {
-            target.set(parentId, new Set(deps));
-        }
-    }
-}
-/**
- * Computes all modules that need to be invalidated based on which modules changed.
- *
- * @param invalidated - The modules that have been invalidated
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function computedInvalidatedModules(invalidated, autoAcceptRootModules) {
-    const outdatedModules = new Set();
-    const outdatedDependencies = new Map();
-    for (const moduleId of invalidated){
-        const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules);
-        switch(effect.type){
-            case 'unaccepted':
-                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
-            case 'self-declined':
-                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
-            case 'declined':
-                throw new UpdateApplyError(`cannot apply update: declined dependency. ${formatDependencyChain(effect.dependencyChain)}. Declined by ${effect.parentId}.`, effect.dependencyChain);
-            case 'accepted':
-                for (const outdatedModuleId of effect.outdatedModules){
-                    outdatedModules.add(outdatedModuleId);
-                }
-                mergeDependencies(outdatedDependencies, effect.outdatedDependencies);
-                break;
-            default:
-                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
-        }
-    }
-    return {
-        outdatedModules,
-        outdatedDependencies
-    };
-}
-/**
- * Creates the module.hot API object and its internal state.
- * This provides the HMR API that user code calls (module.hot.accept(), etc.)
- */ function createModuleHot(moduleId, hotData) {
-    const hotState = {
-        selfAccepted: false,
-        selfDeclined: false,
-        selfInvalidated: false,
-        disposeHandlers: [],
-        acceptedDependencies: {},
-        acceptedErrorHandlers: {},
-        declinedDependencies: {}
-    };
-    const hot = {
-        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
-        // decide whether to warn whenever an HMR-disposed module required other
-        // modules. We might want to remove it.
-        active: true,
-        data: hotData ?? {},
-        accept: (modules, callback, errorHandler)=>{
-            if (modules === undefined) {
-                hotState.selfAccepted = true;
-            } else if (typeof modules === 'function') {
-                hotState.selfAccepted = modules;
-            } else if (typeof modules === 'object' && modules !== null) {
-                for(let i = 0; i < modules.length; i++){
-                    hotState.acceptedDependencies[modules[i]] = callback || function() {};
-                    hotState.acceptedErrorHandlers[modules[i]] = errorHandler;
-                }
-            } else {
-                hotState.acceptedDependencies[modules] = callback || function() {};
-                hotState.acceptedErrorHandlers[modules] = errorHandler;
-            }
-        },
-        decline: (dep)=>{
-            if (dep === undefined) {
-                hotState.selfDeclined = true;
-            } else if (typeof dep === 'object' && dep !== null) {
-                for(let i = 0; i < dep.length; i++){
-                    hotState.declinedDependencies[dep[i]] = true;
-                }
-            } else {
-                hotState.declinedDependencies[dep] = true;
-            }
-        },
-        dispose: (callback)=>{
-            hotState.disposeHandlers.push(callback);
-        },
-        addDisposeHandler: (callback)=>{
-            hotState.disposeHandlers.push(callback);
-        },
-        removeDisposeHandler: (callback)=>{
-            const idx = hotState.disposeHandlers.indexOf(callback);
-            if (idx >= 0) {
-                hotState.disposeHandlers.splice(idx, 1);
-            }
-        },
-        invalidate: ()=>{
-            hotState.selfInvalidated = true;
-            queuedInvalidatedModules.add(moduleId);
-        },
-        // NOTE(alexkirsz) This is part of the management API, which we don't
-        // implement, but the Next.js React Refresh runtime uses this to decide
-        // whether to schedule an update.
-        status: ()=>'idle',
-        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
-        addStatusHandler: (_handler)=>{},
-        removeStatusHandler: (_handler)=>{},
-        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
-        // want the webpack code paths to ever update (the turbopack paths handle
-        // this already).
-        check: ()=>Promise.resolve(null)
-    };
-    return {
-        hot,
-        hotState
-    };
-}
-/**
- * Processes queued invalidated modules and adds them to the outdated modules set.
- * Modules that call module.hot.invalidate() are queued and processed here.
- *
- * @param outdatedModules - The current set of outdated modules
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules) {
-    if (queuedInvalidatedModules.size > 0) {
-        const result = computedInvalidatedModules(queuedInvalidatedModules, autoAcceptRootModules);
-        for (const moduleId of result.outdatedModules){
-            outdatedModules.add(moduleId);
-        }
-        mergeDependencies(outdatedDependencies, result.outdatedDependencies);
-        queuedInvalidatedModules.clear();
-    }
-    return {
-        outdatedModules,
-        outdatedDependencies
-    };
-}
-/**
- * Computes which outdated modules have self-accepted and can be hot reloaded.
- */ function computeOutdatedSelfAcceptedModules(outdatedModules) {
-    const outdatedSelfAcceptedModules = [];
-    for (const moduleId of outdatedModules){
-        const module = devModuleCache[moduleId];
-        const hotState = moduleHotState.get(module);
-        if (module && hotState?.selfAccepted && !hotState.selfInvalidated) {
-            outdatedSelfAcceptedModules.push({
-                moduleId,
-                errorHandler: hotState.selfAccepted
-            });
-        }
-    }
-    return outdatedSelfAcceptedModules;
-}
-/**
- * Disposes of an instance of a module.
- * Runs hot.dispose handlers and manages persistent hot data.
- *
- * NOTE: mode = "replace" will not remove modules from devModuleCache.
- * This must be done in a separate step afterwards.
- */ function disposeModule(moduleId, mode) {
-    const module = devModuleCache[moduleId];
-    if (!module) {
-        return;
-    }
-    const hotState = moduleHotState.get(module);
-    if (!hotState) {
-        return;
-    }
-    const data = {};
-    // Run the `hot.dispose` handler, if any, passing in the persistent
-    // `hot.data` object.
-    for (const disposeHandler of hotState.disposeHandlers){
-        disposeHandler(data);
-    }
-    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
-    // module is still importing other modules.
-    if (module.hot) {
-        module.hot.active = false;
-    }
-    moduleHotState.delete(module);
-    // Remove the disposed module from its children's parent list.
-    // It will be added back once the module re-instantiates and imports its
-    // children again.
-    for (const childId of module.children){
-        const child = devModuleCache[childId];
-        if (!child) {
-            continue;
-        }
-        const idx = child.parents.indexOf(module.id);
-        if (idx >= 0) {
-            child.parents.splice(idx, 1);
-        }
-    }
-    switch(mode){
-        case 'clear':
-            delete devModuleCache[module.id];
-            moduleHotData.delete(module.id);
-            break;
-        case 'replace':
-            moduleHotData.set(module.id, data);
-            break;
-        default:
-            invariant(mode, (mode)=>`invalid mode: ${mode}`);
-    }
-}
-/**
- * Dispose phase: runs dispose handlers and cleans up outdated/disposed modules.
- * Returns the parent modules of outdated modules for use in the apply phase.
- */ function disposePhase(outdatedModules, disposedModules, outdatedDependencies) {
-    for (const moduleId of outdatedModules){
-        disposeModule(moduleId, 'replace');
-    }
-    for (const moduleId of disposedModules){
-        disposeModule(moduleId, 'clear');
-    }
-    // Removing modules from the module cache is a separate step.
-    // We also want to keep track of previous parents of the outdated modules.
-    const outdatedModuleParents = new Map();
-    for (const moduleId of outdatedModules){
-        const oldModule = devModuleCache[moduleId];
-        outdatedModuleParents.set(moduleId, oldModule?.parents);
-        delete devModuleCache[moduleId];
-    }
-    // Remove outdated dependencies from parent module's children list.
-    // When a parent accepts a child's update, the child is re-instantiated
-    // but the parent stays alive. We remove the old child reference so it
-    // gets re-added when the child re-imports.
-    for (const [parentId, deps] of outdatedDependencies){
-        const module = devModuleCache[parentId];
-        if (module) {
-            for (const dep of deps){
-                const idx = module.children.indexOf(dep);
-                if (idx >= 0) {
-                    module.children.splice(idx, 1);
-                }
-            }
-        }
-    }
-    return {
-        outdatedModuleParents
-    };
-}
-/* eslint-disable @typescript-eslint/no-unused-vars */ /**
- * Shared module instantiation logic.
- * This handles the full module instantiation flow for both browser and Node.js.
- * Only React Refresh hooks differ between platforms (passed as callback).
- */ function instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContextFn, runModuleExecutionHooksFn) {
-    // 1. Factory validation (same in both browser and Node.js)
-    const id = moduleId;
-    const moduleFactory = moduleFactories.get(id);
-    if (typeof moduleFactory !== 'function') {
-        throw new Error(factoryNotAvailableMessage(moduleId, sourceType, sourceData) + `\nThis is often caused by a stale browser cache, misconfigured Cache-Control headers, or a service worker serving outdated responses.` + `\nTo fix this, make sure your Cache-Control headers allow revalidation of chunks and review your service worker configuration. ` + `As an immediate workaround, try hard-reloading the page, clearing the browser cache, or unregistering any service workers.`);
-    }
-    // 2. Hot API setup (same in both - works for browser, included for Node.js)
-    const hotData = moduleHotData.get(id);
-    const { hot, hotState } = createModuleHot(id, hotData);
-    // 3. Parent assignment logic (same in both)
-    let parents;
-    switch(sourceType){
-        case SourceType.Runtime:
-            runtimeModules.add(id);
-            parents = [];
-            break;
-        case SourceType.Parent:
-            parents = [
-                sourceData
-            ];
-            break;
-        case SourceType.Update:
-            parents = sourceData || [];
-            break;
-        default:
-            throw new Error(`Unknown source type: ${sourceType}`);
-    }
-    // 4. Module creation (platform creates base module object)
-    const module = createModuleObjectFn(id);
-    const exports = module.exports;
-    module.parents = parents;
-    module.children = [];
-    module.hot = hot;
-    devModuleCache[id] = module;
-    moduleHotState.set(module, hotState);
-    // 5. Module execution (React Refresh hooks are platform-specific)
-    try {
-        runModuleExecutionHooksFn(module, (refresh)=>{
-            const context = createContextFn(module, exports, refresh);
-            moduleFactory.call(exports, context, module, exports);
-        });
-    } catch (error) {
-        module.error = error;
-        throw error;
-    }
-    // 6. ESM interop (same in both)
-    if (module.namespaceObject && module.exports !== module.namespaceObject) {
-        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
-        interopEsm(module.exports, module.namespaceObject);
-    }
-    return module;
-}
-/**
- * Analyzes update entries and chunks to determine which modules were added, modified, or deleted.
- * This is pure logic that doesn't depend on the runtime environment.
- */ function computeChangedModules(entries, updates, chunkModulesMap) {
-    const chunksAdded = new Map();
-    const chunksDeleted = new Map();
-    const added = new Map();
-    const modified = new Map();
-    const deleted = new Set();
-    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
-        switch(mergedChunkUpdate.type){
-            case 'added':
-                {
-                    const updateAdded = new Set(mergedChunkUpdate.modules);
-                    for (const moduleId of updateAdded){
-                        added.set(moduleId, entries[moduleId]);
-                    }
-                    chunksAdded.set(chunkPath, updateAdded);
-                    break;
-                }
-            case 'deleted':
-                {
-                    const updateDeleted = chunkModulesMap ? new Set(chunkModulesMap.get(chunkPath)) : new Set();
-                    for (const moduleId of updateDeleted){
-                        deleted.add(moduleId);
-                    }
-                    chunksDeleted.set(chunkPath, updateDeleted);
-                    break;
-                }
-            case 'partial':
-                {
-                    const updateAdded = new Set(mergedChunkUpdate.added);
-                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
-                    for (const moduleId of updateAdded){
-                        added.set(moduleId, entries[moduleId]);
-                    }
-                    for (const moduleId of updateDeleted){
-                        deleted.add(moduleId);
-                    }
-                    chunksAdded.set(chunkPath, updateAdded);
-                    chunksDeleted.set(chunkPath, updateDeleted);
-                    break;
-                }
-            default:
-                throw new Error('Unknown merged chunk update type');
-        }
-    }
-    // If a module was added from one chunk and deleted from another in the same update,
-    // consider it to be modified, as it means the module was moved from one chunk to another
-    // AND has new code in a single update.
-    for (const moduleId of added.keys()){
-        if (deleted.has(moduleId)) {
-            added.delete(moduleId);
-            deleted.delete(moduleId);
-        }
-    }
-    for (const [moduleId, entry] of Object.entries(entries)){
-        // Modules that haven't been added to any chunk but have new code are considered
-        // to be modified.
-        // This needs to be under the previous loop, as we need it to get rid of modules
-        // that were added and deleted in the same update.
-        if (!added.has(moduleId)) {
-            modified.set(moduleId, entry);
-        }
-    }
-    return {
-        added,
-        deleted,
-        modified,
-        chunksAdded,
-        chunksDeleted
-    };
-}
-/**
- * Compiles new module code and walks the dependency tree to find all outdated modules.
- * Uses the evalModuleEntry function to compile code (platform-specific).
- *
- * @param added - Map of added modules
- * @param modified - Map of modified modules
- * @param evalModuleEntry - Function to compile module code
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules) {
-    const newModuleFactories = new Map();
-    // Compile added modules
-    for (const [moduleId, entry] of added){
-        if (entry != null) {
-            newModuleFactories.set(moduleId, evalModuleEntry(entry));
-        }
-    }
-    // Walk dependency tree to find all modules affected by modifications
-    const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(modified.keys(), autoAcceptRootModules);
-    // Compile modified modules
-    for (const [moduleId, entry] of modified){
-        newModuleFactories.set(moduleId, evalModuleEntry(entry));
-    }
-    return {
-        outdatedModules,
-        outdatedDependencies,
-        newModuleFactories
-    };
-}
-/**
- * Updates module factories and re-instantiates self-accepted modules.
- * Uses the instantiateModule function (platform-specific via callback).
- */ function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError) {
-    // Update module factories
-    for (const [moduleId, factory] of newModuleFactories.entries()){
-        applyModuleFactoryNameFn(factory);
-        moduleFactories.set(moduleId, factory);
-    }
-    // TODO(alexkirsz) Run new runtime entries here.
-    // Call accept handlers for outdated dependencies.
-    // This runs BEFORE re-instantiating self-accepted modules, matching
-    // webpack's behavior.
-    for (const [parentId, deps] of outdatedDependencies){
-        const module = devModuleCache[parentId];
-        if (!module) continue;
-        const hotState = moduleHotState.get(module);
-        if (!hotState) continue;
-        // Group deps by callback, deduplicating callbacks that handle multiple deps.
-        // Each callback receives only the deps it was registered for.
-        const callbackDeps = new Map();
-        const callbackErrorHandlers = new Map();
-        for (const dep of deps){
-            const acceptCallback = hotState.acceptedDependencies[dep];
-            if (acceptCallback) {
-                let depList = callbackDeps.get(acceptCallback);
-                if (!depList) {
-                    depList = [];
-                    callbackDeps.set(acceptCallback, depList);
-                    callbackErrorHandlers.set(acceptCallback, hotState.acceptedErrorHandlers[dep]);
-                }
-                depList.push(dep);
-            }
-        }
-        for (const [callback, cbDeps] of callbackDeps){
-            try {
-                callback.call(null, cbDeps);
-            } catch (err) {
-                const errorHandler = callbackErrorHandlers.get(callback);
-                if (typeof errorHandler === 'function') {
-                    try {
-                        errorHandler(err, {
-                            moduleId: parentId,
-                            dependencyId: cbDeps[0]
-                        });
-                    } catch (err2) {
-                        reportError(err2);
-                        reportError(err);
-                    }
-                } else {
-                    reportError(err);
-                }
-            }
-        }
-    }
-    // Re-instantiate all outdated self-accepted modules
-    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
-        try {
-            instantiateModuleFn(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
-        } catch (err) {
-            if (typeof errorHandler === 'function') {
-                try {
-                    errorHandler(err, {
-                        moduleId,
-                        module: devModuleCache[moduleId]
-                    });
-                } catch (err2) {
-                    reportError(err2);
-                    reportError(err);
-                }
-            } else {
-                reportError(err);
-            }
-        }
-    }
-}
-/**
- * Internal implementation that orchestrates the full HMR update flow:
- * invalidation, disposal, and application of new modules.
- *
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules) {
-    ;
-    ({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules));
-    // Find self-accepted modules to re-instantiate
-    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
-    // Run dispose handlers, save hot.data, clear caches
-    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules, outdatedDependencies);
-    let error;
-    function reportError(err) {
-        if (!error) error = err; // Keep first error
-    }
-    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError);
-    if (error) {
-        throw error;
-    }
-    // Recursively apply any queued invalidations from new module execution
-    if (queuedInvalidatedModules.size > 0) {
-        applyInternal(new Set(), new Map(), [], new Map(), moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules);
-    }
-}
-/**
- * Main entry point for applying an ECMAScript merged update.
- * This is called by both browser and Node.js runtimes with platform-specific callbacks.
- *
- * @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit
- *                                   module.hot.accept(). Used for server-side HMR where pages
- *                                   auto-accept at the top level.
- */ function applyEcmascriptMergedUpdateShared(options) {
-    const { added, modified, disposedModules, evalModuleEntry, instantiateModule, applyModuleFactoryName, moduleFactories, devModuleCache, autoAcceptRootModules } = options;
-    const { outdatedModules, outdatedDependencies, newModuleFactories } = computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules);
-    applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModule, applyModuleFactoryName, autoAcceptRootModules);
-}
-/// <reference path="../../../shared/runtime/dev-globals.d.ts" />
-/// <reference path="../../../shared/runtime/dev-protocol.d.ts" />
-const devContextPrototype = Context.prototype;
-/**
- * This file contains runtime types and functions that are shared between all
- * Turbopack *development* ECMAScript runtimes.
- *
- * It will be appended to the runtime code of each runtime right after the
- * shared runtime utils.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ // Assign browser's module cache and runtime modules to shared HMR state
-devModuleCache = Object.create(null);
-devContextPrototype.c = devModuleCache;
-runtimeModules = new Set();
-// Set flag to indicate we use ModuleWithDirection
-createModuleWithDirectionFlag = true;
-function getRefreshBoundaryExports(exports) {
-    if (typeof isAsyncModuleExt === 'function' && exports != null && typeof exports === 'object' && isAsyncModuleExt(exports)) {
-        return exports[turbopackExports];
-    }
-    return exports;
-}
-/**
- * Map from module ID to the chunks that contain this module.
- *
- * In HMR, we need to keep track of which modules are contained in which so
- * chunks. This is so we don't eagerly dispose of a module when it is removed
- * from chunk A, but still exists in chunk B.
- */ const moduleChunksMap = new Map();
-/**
- * Map from a chunk path to all modules it contains.
- */ const chunkModulesMap = new Map();
-/**
- * Chunk lists that contain a runtime. When these chunk lists receive an update
- * that can't be reconciled with the current state of the page, we need to
- * reload the runtime entirely.
- */ const runtimeChunkLists = new Set();
-/**
- * Map from a chunk list to the chunk paths it contains.
- */ const chunkListChunksMap = new Map();
-/**
- * Map from a chunk path to the chunk lists it belongs to.
- */ const chunkChunkListsMap = new Map();
-/** Dynamic lists use a stricter, reload-on-ambiguity update policy. */ const dynamicChunkLists = new Set();
-/** Dynamic manifests which have not finished their subscribe/load/revalidate handshake. */ const loadingDynamicChunkLists = new Set();
-/**
- * Gets or instantiates a runtime module.
- */ // @ts-ignore
-function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
-    const module = devModuleCache[moduleId];
-    if (module) {
-        if (module.error) {
-            throw module.error;
-        }
-        return module;
-    }
-    // @ts-ignore
-    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
-}
-/**
- * Retrieves a module from the cache, or instantiate it if it is not cached.
- */ // @ts-ignore Defined in `runtime-utils.ts`
-const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
-    if (!sourceModule.hot.active) {
-        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
-    }
-    const module = devModuleCache[id];
-    if (sourceModule.children.indexOf(id) === -1) {
-        sourceModule.children.push(id);
-    }
-    if (module) {
-        if (module.error) {
-            throw module.error;
-        }
-        if (module.parents.indexOf(sourceModule.id) === -1) {
-            module.parents.push(sourceModule.id);
-        }
-        return module;
-    }
-    return instantiateModule(id, SourceType.Parent, sourceModule.id);
-};
-function DevContext(module, exports, refresh) {
-    Context.call(this, module, exports);
-    this.k = refresh;
-}
-DevContext.prototype = Context.prototype;
-function instantiateModule(moduleId, sourceType, sourceData) {
-    // Browser: creates base HotModule object (hot API added by shared code)
-    const createModuleObjectFn = (id)=>{
-        return createModuleObject(id);
-    };
-    // Browser: creates DevContext with refresh
-    const createContext = (module, exports, refresh)=>{
-        return new DevContext(module, exports, refresh);
-    };
-    // Use shared instantiation logic (includes hot API setup)
-    return instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContext, runModuleExecutionHooks);
-}
-const DUMMY_REFRESH_CONTEXT = {
-    register: (_type, _id)=>{},
-    signature: ()=>(_type)=>{},
-    registerExports: (_module, _helpers)=>{}
-};
-/**
- * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
- * Next.js' React Refresh runtime hooks into to add module context to the
- * refresh registry.
- */ function runModuleExecutionHooks(module, executeModule) {
-    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
-        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
-        try {
-            executeModule({
-                register: globalThis.$RefreshReg$,
-                signature: globalThis.$RefreshSig$,
-                registerExports: registerExportsAndSetupBoundaryForReactRefresh
-            });
-        } finally{
-            // Always cleanup the intercept, even if module execution failed.
-            cleanupReactRefreshIntercept();
-        }
-    } else {
-        // If the react refresh hooks are not installed we need to bind dummy functions.
-        // This is expected when running in a Web Worker.  It is also common in some of
-        // our test environments.
-        executeModule(DUMMY_REFRESH_CONTEXT);
-    }
-}
-/**
- * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
- */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
-    const currentExports = getRefreshBoundaryExports(module.exports);
-    const prevExports = module.hot.data.prevExports ?? null;
-    helpers.registerExportsForReactRefresh(currentExports, module.id);
-    // A module can be accepted automatically based on its exports, e.g. when
-    // it is a Refresh Boundary.
-    if (helpers.isReactRefreshBoundary(currentExports)) {
-        // Save the previous exports on update, so we can compare the boundary
-        // signatures.
-        module.hot.dispose((data)=>{
-            data.prevExports = currentExports;
-        });
-        // Unconditionally accept an update to this module, we'll check if it's
-        // still a Refresh Boundary later.
-        module.hot.accept();
-        // This field is set when the previous version of this module was a
-        // Refresh Boundary, letting us know we need to check for invalidation or
-        // enqueue an update.
-        if (prevExports !== null) {
-            // A boundary can become ineligible if its exports are incompatible
-            // with the previous exports.
-            //
-            // For example, if you add/remove/change exports, we'll want to
-            // re-execute the importing modules, and force those components to
-            // re-render. Similarly, if you convert a class component to a
-            // function, we want to invalidate the boundary.
-            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
-                module.hot.invalidate();
-            } else {
-                helpers.scheduleUpdate();
-            }
-        }
-    } else {
-        // Since we just executed the code for the module, it's possible that the
-        // new exports made it ineligible for being a boundary.
-        // We only care about the case when we were _previously_ a boundary,
-        // because we already accepted this update (accidental side effect).
-        const isNoLongerABoundary = prevExports !== null;
-        if (isNoLongerABoundary) {
-            module.hot.invalidate();
-        }
-    }
-}
-/**
- * Adds, deletes, and moves modules between chunks. This must happen before the
- * dispose phase as it needs to know which modules were removed from all chunks,
- * which we can only compute *after* taking care of added and moved modules.
- */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
-    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
-        for (const moduleId of addedModuleIds){
-            addModuleToChunk(moduleId, chunkPath);
-        }
-    }
-    const disposedModules = new Set();
-    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
-        for (const moduleId of addedModuleIds){
-            if (removeModuleFromChunk(moduleId, chunkPath)) {
-                disposedModules.add(moduleId);
-            }
-        }
-    }
-    return {
-        disposedModules
-    };
-}
-function applyUpdate(update) {
-    switch(update.type){
-        case 'ChunkListUpdate':
-            applyChunkListUpdate(update);
-            break;
-        default:
-            invariant(update, (update)=>`Unknown update type: ${update.type}`);
-    }
-}
-function applyChunkListUpdate(update) {
-    if (update.merged != null) {
-        for (const merged of update.merged){
-            switch(merged.type){
-                case 'EcmascriptMergedUpdate':
-                    applyEcmascriptMergedUpdate(merged);
-                    break;
-                default:
-                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
-            }
-        }
-    }
-    if (update.chunks != null) {
-        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-            const chunkUrl = getChunkRelativeUrl(chunkPath);
-            switch(chunkUpdate.type){
-                case 'added':
-                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
-                    break;
-                case 'total':
-                    DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    break;
-                case 'deleted':
-                    DEV_BACKEND.unloadChunk?.(chunkUrl);
-                    break;
-                case 'partial':
-                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                    break;
-                default:
-                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
-            }
-        }
-    }
-}
-function applyEcmascriptMergedUpdate(update) {
-    // Browser-specific chunk management phase
-    const { entries = {}, chunks = {} } = update;
-    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks, chunkModulesMap);
-    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
-    // Use shared HMR update implementation
-    applyEcmascriptMergedUpdateShared({
-        added,
-        modified,
-        disposedModules,
-        evalModuleEntry: _eval,
-        instantiateModule,
-        applyModuleFactoryName,
-        moduleFactories,
-        devModuleCache,
-        autoAcceptRootModules: false
-    });
-}
-function handleApply(chunkListPath, update) {
-    switch(update.type){
-        case 'partial':
-            {
-                // This indicates that the update is can be applied to the current state of the application.
-                if (dynamicChunkLists.has(chunkListPath)) {
-                    if (loadingDynamicChunkLists.has(chunkListPath)) {
-                        throw new Error(`Dynamic chunk list ${chunkListPath} changed while it was loading.`);
-                    }
-                    if (update.instruction.type === 'ChunkListUpdate' && update.instruction.chunks != null) {
-                        throw new Error(`Dynamic chunk list ${chunkListPath} changed structure.`);
-                    }
-                    const hasSharedChunk = [
-                        ...chunkListChunksMap.get(chunkListPath) ?? []
-                    ].some((chunkPath)=>(chunkChunkListsMap.get(chunkPath)?.size ?? 0) > 1);
-                    if (hasSharedChunk) {
-                        throw new Error(`Dynamic chunk list ${chunkListPath} shares chunks with another active list.`);
-                    }
-                }
-                applyUpdate(update.instruction);
-                break;
-            }
-        case 'restart':
-            {
-                // This indicates that there is no way to apply the update to the
-                // current state of the application, and that the application must be
-                // restarted.
-                DEV_BACKEND.restart();
-                break;
-            }
-        case 'notFound':
-            {
-                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
-                // or the page itself was deleted.
-                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
-                // If it is a runtime chunk list, we restart the application.
-                if (runtimeChunkLists.has(chunkListPath) || dynamicChunkLists.has(chunkListPath)) {
-                    DEV_BACKEND.restart();
-                } else {
-                    disposeChunkList(chunkListPath);
-                }
-                break;
-            }
-        default:
-            throw new Error(`Unknown update type: ${update.type}`);
-    }
-}
-/**
- * Removes a module from a chunk.
- * Returns `true` if there are no remaining chunks including this module.
- */ function removeModuleFromChunk(moduleId, chunkPath) {
-    const moduleChunks = moduleChunksMap.get(moduleId);
-    moduleChunks.delete(chunkPath);
-    const chunkModules = chunkModulesMap.get(chunkPath);
-    chunkModules.delete(moduleId);
-    const noRemainingModules = chunkModules.size === 0;
-    if (noRemainingModules) {
-        chunkModulesMap.delete(chunkPath);
-    }
-    const noRemainingChunks = moduleChunks.size === 0;
-    if (noRemainingChunks) {
-        moduleChunksMap.delete(moduleId);
-    }
-    return noRemainingChunks;
-}
-/**
- * Disposes of a chunk list and its corresponding exclusive chunks.
- */ function disposeChunkList(chunkListPath) {
-    const chunkPaths = chunkListChunksMap.get(chunkListPath);
-    if (chunkPaths == null) {
-        return false;
-    }
-    chunkListChunksMap.delete(chunkListPath);
-    for (const chunkPath of chunkPaths){
-        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        chunkChunkLists.delete(chunkListPath);
-        if (chunkChunkLists.size === 0) {
-            chunkChunkListsMap.delete(chunkPath);
-            disposeChunk(chunkPath);
-        }
-    }
-    // We must also dispose of the chunk list's chunk itself to ensure it may
-    // be reloaded properly in the future.
-    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
-    DEV_BACKEND.unloadChunk?.(chunkListUrl);
-    return true;
-}
-/**
- * Disposes of a chunk and its corresponding exclusive modules.
- *
- * @returns Whether the chunk was disposed of.
- */ function disposeChunk(chunkPath) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    // This should happen whether the chunk has any modules in it or not.
-    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
-    DEV_BACKEND.unloadChunk?.(chunkUrl);
-    const chunkModules = chunkModulesMap.get(chunkPath);
-    if (chunkModules == null) {
-        return false;
-    }
-    chunkModules.delete(chunkPath);
-    for (const moduleId of chunkModules){
-        const moduleChunks = moduleChunksMap.get(moduleId);
-        moduleChunks.delete(chunkPath);
-        const noRemainingChunks = moduleChunks.size === 0;
-        if (noRemainingChunks) {
-            moduleChunksMap.delete(moduleId);
-            disposeModule(moduleId, 'clear');
-            availableModules.delete(moduleId);
-        }
-    }
-    return true;
-}
-/**
- * Adds a module to a chunk.
- */ function addModuleToChunk(moduleId, chunkPath) {
-    let moduleChunks = moduleChunksMap.get(moduleId);
-    if (!moduleChunks) {
-        moduleChunks = new Set([
-            chunkPath
-        ]);
-        moduleChunksMap.set(moduleId, moduleChunks);
-    } else {
-        moduleChunks.add(chunkPath);
-    }
-    let chunkModules = chunkModulesMap.get(chunkPath);
-    if (!chunkModules) {
-        chunkModules = new Set([
-            moduleId
-        ]);
-        chunkModulesMap.set(chunkPath, chunkModules);
-    } else {
-        chunkModules.add(moduleId);
-    }
-}
-/**
- * Marks a chunk list as a runtime chunk list. There can be more than one
- * runtime chunk list. For instance, integration tests can have multiple chunk
- * groups loaded at runtime, each with its own chunk list.
- */ function markChunkListAsRuntime(chunkListPath) {
-    runtimeChunkLists.add(chunkListPath);
-}
-function getDevChunkFromRegistration(chunk) {
-    if (typeof chunk === 'string') {
-        if (typeof document !== 'undefined') {
-            const src = document.currentScript?.getAttribute('src');
-            if (src && /[?&]hmr=/.test(src) && getPathFromScript({
-                src
-            }) === chunk) {
-                return {
-                    src
-                };
-            }
-        }
-    }
-    return getChunkFromRegistration(chunk);
-}
-function registerChunk(registration) {
-    const chunk = getDevChunkFromRegistration(registration[0]);
-    let runtimeParams;
-    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
-    if (registration.length === 2) {
-        runtimeParams = registration[1];
-    } else {
-        let chunkPath = getPathFromScript(chunk);
-        runtimeParams = undefined;
-        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
-    }
-    return BACKEND.registerChunk(chunk, runtimeParams);
-}
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-function loadVersionedInitialChunk(chunkListPath, chunkData, versionToken) {
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkListPath, getVersionedChunkUrl(getChunkPath(chunkData), versionToken));
-}
-/**
- * Subscribes to chunk list updates from the update server and applies them.
- */ function registerChunkList(chunkList) {
-    const chunkListScript = getDevChunkFromRegistration(chunkList.script);
-    const chunkListPath = getPathFromScript(chunkListScript);
-    // Adding chunks to chunk lists and vice versa.
-    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    chunkListChunksMap.set(chunkListPath, chunkPaths);
-    for (const chunkPath of chunkPaths){
-        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        if (!chunkChunkLists) {
-            chunkChunkLists = new Set([
-                chunkListPath
-            ]);
-            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
-        } else {
-            chunkChunkLists.add(chunkListPath);
-        }
-    }
-    if (chunkList.source === 'entry') {
-        // Entry lists keep the legacy loading and update behavior.
-        BACKEND.registerChunk(chunkListPath);
-        CHUNK_UPDATE_LISTENERS.push([
-            chunkListPath,
-            handleApply.bind(null, chunkListPath)
-        ]);
-        markChunkListAsRuntime(chunkListPath);
-        return;
-    }
-    dynamicChunkLists.add(chunkListPath);
-    if (typeof document === 'undefined') {
-        // Workers do not have the browser HMR transport. Load the manifest members
-        // directly so the dynamic import cannot wait for a subscription forever.
-        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), ()=>DEV_BACKEND.restart());
-        return;
-    }
-    loadingDynamicChunkLists.add(chunkListPath);
-    let resolveSubscribed;
-    let revalidateSubscription;
-    const subscribed = new Promise((resolve)=>{
-        resolveSubscribed = resolve;
-    });
-    CHUNK_UPDATE_LISTENERS.push([
-        chunkListPath,
-        handleApply.bind(null, chunkListPath),
-        {
-            conservative: true,
-            expectedVersion: chunkList.version,
-            onSubscribed: (revalidate)=>{
-                revalidateSubscription = revalidate;
-                resolveSubscribed();
-            }
-        }
-    ]);
-    void (async ()=>{
-        try {
-            await subscribed;
-            await Promise.all(chunkList.chunks.map((chunkData)=>{
-                const chunkPath = getChunkPath(chunkData);
-                const chunkVersion = chunkList.chunkVersions[chunkPath];
-                if (chunkVersion === undefined) {
-                    throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
-                }
-                return loadVersionedInitialChunk(chunkListPath, chunkData, chunkVersion);
-            }));
-            // Member URLs are served from the live output directory. Verify that
-            // the manifest did not change while those HTTP responses were loading.
-            await revalidateSubscription();
-            loadingDynamicChunkLists.delete(chunkListPath);
-            BACKEND.registerChunk(chunkListPath);
-        } catch  {
-            loadingDynamicChunkLists.delete(chunkListPath);
-            DEV_BACKEND.restart();
-        }
-    })();
-}
-/**
- * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
- *
- * It will be appended to the base runtime code.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
-/// <reference path="../../../shared/runtime/runtime-types.d.ts" />
-function getAssetSuffixFromScriptSrc() {
-    // TURBOPACK_ASSET_SUFFIX is set in web workers
-    if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX;
-    const src = document?.currentScript?.getAttribute?.('src') ?? '';
-    const qi = src.indexOf('?');
-    return qi >= 0 ? src.slice(qi) : '';
-}
-let BACKEND;
-/**
- * Maps chunk paths to the corresponding resolver.
- */ const chunkResolvers = new Map();
-(()=>{
-    BACKEND = {
-        async registerChunk (chunk, params) {
-            let chunkPath = getPathFromScript(chunk);
-            let chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = getOrCreateResolver(chunkUrl);
-            resolver.resolve();
-            const exactChunkUrl = getUrlFromScript(chunk);
-            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
-                getOrCreateResolver(exactChunkUrl).resolve();
-            }
-            if (params == null) {
-                return;
-            }
-            for (const otherChunkData of params.otherChunks){
-                const otherChunkPath = getChunkPath(otherChunkData);
-                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
-                // Chunk might have started loading, so we want to avoid triggering another load.
-                getOrCreateResolver(otherChunkUrl);
-            }
-            // This waits for chunks to be loaded, but also marks included items as available.
-            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
-            if (params.runtimeModuleIds.length > 0) {
-                for (const moduleId of params.runtimeModuleIds){
-                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
-                }
-            }
-        },
-        /**
-     * Loads the given chunk, and returns a promise that resolves once the chunk
-     * has been loaded.
-     */ loadChunkCached (sourceType, chunkUrl) {
-            return doLoadChunk(sourceType, chunkUrl);
-        }
-    };
-    function getOrCreateResolver(chunkUrl) {
-        let resolver = chunkResolvers.get(chunkUrl);
-        if (!resolver) {
-            let resolve;
-            let reject;
-            const promise = new Promise((innerResolve, innerReject)=>{
-                resolve = innerResolve;
-                reject = innerReject;
-            });
-            resolver = {
-                resolved: false,
-                loadingStarted: false,
-                retryAttempts: 0,
-                promise,
-                resolve: ()=>{
-                    resolver.resolved = true;
-                    resolve();
-                },
-                reject: reject
-            };
-            chunkResolvers.set(chunkUrl, resolver);
-        }
-        return resolver;
-    }
-    /**
-   * Rejects a chunk resolver and drops it from the cache.
-   * We don't want to cache failed chunk loads: a later
-   * request for the same chunk should try again.
-   */ function rejectChunkResolver(chunkUrl, resolver, error) {
-        if (chunkResolvers.get(chunkUrl) === resolver) {
-            chunkResolvers.delete(chunkUrl);
-        }
-        resolver.reject(error);
-    }
-    function getChunkLoadRetryDelayMs() {
-        const jitter = Math.floor(Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1));
-        return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter;
-    }
-    function isRetryableChunkLoadError(error) {
-        return error == null || error instanceof DOMException && error.name === 'NetworkError';
-    }
-    /**
-   * Handles a failed chunk load: retries the load once after a short delay.
-   */ function onChunkLoadError(sourceType, chunkUrl, resolver, error, reload) {
-        if (!isRetryableChunkLoadError(error) || resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS || chunkResolvers.get(chunkUrl) !== resolver) {
-            rejectChunkResolver(chunkUrl, resolver, error);
-            return;
-        }
-        resolver.retryAttempts++;
-        setTimeout(()=>{
-            // if this chunk is being fetched multiple times, and one of those
-            // attempts succeeds. or, if this chunk has another resolver
-            // mapped to it - it's safe to skip retrying.
-            if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {
-                return;
-            }
-            if (reload) {
-                reload();
-            } else {
-                resolver.loadingStarted = false;
-                doLoadChunk(sourceType, chunkUrl);
-            }
-        }, getChunkLoadRetryDelayMs());
-    }
-    /**
-   * Loads the given chunk, and returns a promise that resolves once the chunk
-   * has been loaded.
-   */ function doLoadChunk(sourceType, chunkUrl) {
-        const resolver = getOrCreateResolver(chunkUrl);
-        if (resolver.loadingStarted) {
-            return resolver.promise;
-        }
-        if (sourceType === SourceType.Runtime) {
-            // CSS chunks do not register themselves, and as such must be marked as
-            // loaded instantly.
-            resolver.loadingStarted = true;
-            if (isCss(chunkUrl)) {
-                if (typeof importScripts !== 'function') {
-                    const decodedChunkUrl = decodeURI(chunkUrl);
-                    const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
-                    if (previousLinks.length === 0) {
-                        const link = document.createElement('link');
-                        link.rel = 'stylesheet';
-                        link.crossOrigin = CROSS_ORIGIN;
-                        link.href = chunkUrl;
-                        link.onerror = ()=>{
-                            resolver.reject();
-                        };
-                        link.onload = ()=>{
-                            resolver.resolve();
-                        };
-                        document.head.appendChild(link);
-                        return resolver.promise;
-                    }
-                }
-                resolver.resolve();
-                return resolver.promise;
-            }
-            // Runtime JS chunks are expected to be present in the DOM already.
-            // Load it first
-            if (typeof importScripts !== 'function') {
-                const decodedChunkUrl = decodeURI(chunkUrl);
-                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
-                if (previousScripts.length > 0) {
-                    for (const script of Array.from(previousScripts)){
-                        script.addEventListener('error', ()=>{
-                            resolver.reject();
-                        });
-                    }
-                    return resolver.promise;
-                }
-            }
-        // If it wasn't present in the DOM, fallback to loading logic.
-        }
-        if (typeof importScripts === 'function') {
-            // We're in a web worker
-            if (isCss(chunkUrl)) {
-            // ignore
-            } else if (isJs(chunkUrl)) {
-                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
-                try {
-                    importScripts(chunkUrl);
-                } catch (error) {
-                    onChunkLoadError(sourceType, chunkUrl, resolver, error);
-                }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
-            }
-        } else {
-            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-            const decodedChunkUrl = decodeURI(chunkUrl);
-            if (isCss(chunkUrl)) {
-                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
-                if (previousLinks.length > 0) {
-                    // CSS chunks do not register themselves, and as such must be marked as
-                    // loaded instantly.
-                    resolver.resolve();
-                } else {
-                    const createLink = ()=>{
-                        const link = document.createElement('link');
-                        link.rel = 'stylesheet';
-                        link.crossOrigin = CROSS_ORIGIN;
-                        link.href = chunkUrl;
-                        link.onerror = ()=>{
-                            // Re-insert a fresh tag at the same position on retry to preserve
-                            // cascade order.
-                            const anchor = document.createComment('');
-                            link.replaceWith(anchor);
-                            onChunkLoadError(sourceType, chunkUrl, resolver, undefined, ()=>anchor.replaceWith(createLink()));
-                        };
-                        link.onload = ()=>{
-                            // CSS chunks do not register themselves, and as such must be marked as
-                            // loaded instantly.
-                            resolver.resolve();
-                        };
-                        return link;
-                    };
-                    // Append to the `head` for webpack compatibility.
-                    document.head.appendChild(createLink());
-                }
-            } else if (isJs(chunkUrl)) {
-                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
-                if (previousScripts.length > 0) {
-                    for (const script of Array.from(previousScripts)){
-                        script.addEventListener('error', ()=>{
-                            // Drop the failed tag so a retry can re-add it cleanly.
-                            script.remove();
-                            onChunkLoadError(sourceType, chunkUrl, resolver);
-                        }, {
-                            once: true
-                        });
-                    }
-                } else {
-                    const script = document.createElement('script');
-                    script.crossOrigin = CROSS_ORIGIN;
-                    script.src = chunkUrl;
-                    // We'll only mark the chunk as loaded once the script has been executed,
-                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
-                    // this branch.
-                    script.onerror = ()=>{
-                        // Drop the failed tag so a retry can re-add it cleanly.
-                        script.remove();
-                        onChunkLoadError(sourceType, chunkUrl, resolver);
-                    };
-                    // Append to the `head` for webpack compatibility.
-                    document.head.appendChild(script);
-                }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-            }
-        }
-        resolver.loadingStarted = true;
-        return resolver.promise;
-    }
-})();
-/**
- * This file contains the runtime code specific to the Turbopack development
- * ECMAScript DOM runtime.
- *
- * It will be appended to the base development runtime code.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
-/// <reference path="../base/dev-base.ts" />
-/// <reference path="./runtime-backend-dom.ts" />
-/// <reference path="../../../shared/require-type.d.ts" />
-let DEV_BACKEND;
-(()=>{
-    DEV_BACKEND = {
-        unloadChunk (chunkUrl) {
-            deleteResolver(chunkUrl);
-            // Strip query string so we match links regardless of cache-busting
-            // params (e.g. ?ts=) that may differ between HMR updates.
-            const baseChunkUrl = chunkUrl.split('?')[0];
-            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-            const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            if (isCss(chunkUrl)) {
-                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
-                for (const link of Array.from(links)){
-                    link.remove();
-                }
-            } else if (isJs(chunkUrl)) {
-                // Unloading a JS chunk would have no effect, as it lives in the JS
-                // runtime once evaluated.
-                // However, we still want to remove the script tag from the DOM to keep
-                // the HTML somewhat consistent from the user's perspective.
-                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
-                for (const script of Array.from(scripts)){
-                    script.remove();
-                }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-            }
-        },
-        reloadChunk (chunkUrl) {
-            return new Promise((resolve, reject)=>{
-                if (!isCss(chunkUrl)) {
-                    reject(new Error('The DOM backend can only reload CSS chunks'));
-                    return;
-                }
-                // Strip query string so we match links regardless of cache-busting
-                // params (e.g. ?ts=) that may differ between HMR updates.
-                const baseChunkUrl = chunkUrl.split('?')[0];
-                const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-                if (previousLinks.length === 0) {
-                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
-                    return;
-                }
-                const link = document.createElement('link');
-                link.rel = 'stylesheet';
-                link.crossOrigin = CROSS_ORIGIN;
-                if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
-                    // Firefox won't reload CSS files that were previously loaded on the
-                    // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
-                    //
-                    // Safari serves cached CSS when a <link rel=preload> exists for the
-                    // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726
-                    //
-                    // Replace or add a fresh `ts` cache-busting param without
-                    // discarding other query parameters that may already be present.
-                    const url = new URL(chunkUrl, location.origin);
-                    // Reduced timer precision in some browers could lead to an update getting dropped
-                    // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).
-                    // So trust that the server is only updating us when it is important and use a
-                    // random number to bust the cache.
-                    url.searchParams.set('ts', `${Date.now()}.${Math.random()}`);
-                    link.href = url.pathname + url.search;
-                } else {
-                    link.href = chunkUrl;
-                }
-                link.onerror = ()=>{
-                    reject();
-                };
-                link.onload = ()=>{
-                    // First load the new CSS, then remove the old ones. This prevents visible
-                    // flickering that would happen in-between removing the previous CSS and
-                    // loading the new one.
-                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
-                    // CSS chunks do not register themselves, and as such must be marked as
-                    // loaded instantly.
-                    resolve();
-                };
-                // Make sure to insert the new CSS right after the previous one, so that
-                // its precedence is higher.
-                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
-            });
-        },
-        restart: ()=>self.location.reload()
-    };
-    function deleteResolver(chunkUrl) {
-        chunkResolvers.delete(chunkUrl);
-    }
-})();
-function _eval({ code, url, map }) {
-    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX)}`;
-    if (map) {
-        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
-        // See https://stackoverflow.com/a/26603875
-        unescape(encodeURIComponent(map)))}`;
-    }
-    // eslint-disable-next-line no-eval
-    return eval(code);
-}
-var chunksToRegister = globalThis["TURBOPACK"];
-globalThis["TURBOPACK"] = { push: registerChunk };
-chunksToRegister.forEach(registerChunk);
-var chunkListsToRegister = globalThis["TURBOPACK_CHUNK_LISTS"] || [];
-globalThis["TURBOPACK_CHUNK_LISTS"] = { push: registerChunkList };
-chunkListsToRegister.forEach(registerChunkList);
-})();
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js
deleted file mode 100644
index bc784065f..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/assert.js
+++ /dev/null
@@ -1,33 +0,0 @@
-const assert = require("node:assert/strict");
-const fs = require("node:fs");
-const path = require("node:path");
-
-const outputDir = path.join(__dirname, "output");
-const javascriptAssets = fs
-  .readdirSync(outputDir)
-  .filter((file) => file.endsWith(".js"))
-  .map((file) => ({
-    file,
-    content: fs.readFileSync(path.join(outputDir, file), "utf8"),
-  }));
-
-assert.equal(
-  javascriptAssets.filter(({ content }) =>
-    /source:\s*["'](?:entry|dynamic)["']/.test(content),
-  ).length,
-  0,
-  "hot=false must not emit chunk-list bootstraps that wait for an HMR client",
-);
-
-const asyncLoader = javascriptAssets.find(({ content }) =>
-  content.includes("return parentImport("),
-);
-assert.ok(asyncLoader, "the fixture should emit an async loader");
-const loaderMatch = asyncLoader.content.match(
-  /return Promise\.all\((\[[\s\S]*?\])\.map/,
-);
-assert.ok(loaderMatch, "the async loader should contain a chunk array");
-assert.ok(
-  JSON.parse(loaderMatch[1]).length > 0,
-  "hot=false must load dynamic content chunks directly",
-);
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json
deleted file mode 100644
index b09219d5f..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/config.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-  "config": {
-    "entry": [
-      {
-        "import": "input/index.js",
-        "name": "main"
-      }
-    ],
-    "mode": "development",
-    "devServer": {
-      "hot": false
-    },
-    "sourceMaps": false,
-    "optimization": {
-      "minify": false
-    },
-    "output": {
-      "path": "output"
-    }
-  },
-  "runtimeType": "Development",
-  "watch": true
-}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js
deleted file mode 100644
index 0af5803a0..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/index.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export async function loadLazy() {
-  return import("./lazy");
-}
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js
deleted file mode 100644
index 24e545669..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js
+++ /dev/null
@@ -1 +0,0 @@
-export const value = "lazy";
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js
deleted file mode 100644
index 5883f8f7c..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/_root-of-the-server___2651c4ea.js
+++ /dev/null
@@ -1,453 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "default",
-    ()=>__TURBOPACK__default__export__
-]);
-/**
- * MIT License
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */ // This file is copied from the Metro JavaScript bundler, with minor tweaks for
-// webpack 4 compatibility.
-//
-// https://github.com/facebook/metro/blob/d6b9685c730d0d63577db40f41369157f28dfa3a/packages/metro/src/lib/polyfills/require.js
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
-;
-const { m: turbopackModule } = __turbopack_context__;
-function isSafeExport(key) {
-    return key === "__esModule" || key === "__N_SSG" || key === "__N_SSP" || // TODO: remove this key from page config instead of allow listing it
-    key === "config";
-}
-function registerExportsForReactRefresh(moduleExports, moduleID) {
-    __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(moduleExports, moduleID + " %exports%");
-    if (moduleExports == null || typeof moduleExports !== "object") {
-        // Exit if we can't iterate over exports.
-        // (This is important for legacy environments.)
-        return;
-    }
-    for(var key in moduleExports){
-        if (isSafeExport(key)) {
-            continue;
-        }
-        try {
-            var exportValue = moduleExports[key];
-        } catch  {
-            continue;
-        }
-        var typeID = moduleID + " %exports% " + key;
-        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(exportValue, typeID);
-    }
-}
-function getRefreshBoundarySignature(moduleExports) {
-    var signature = [];
-    signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(moduleExports));
-    if (moduleExports == null || typeof moduleExports !== "object") {
-        // Exit if we can't iterate over exports.
-        // (This is important for legacy environments.)
-        return signature;
-    }
-    for(var key in moduleExports){
-        if (isSafeExport(key)) {
-            continue;
-        }
-        try {
-            var exportValue = moduleExports[key];
-        } catch  {
-            continue;
-        }
-        signature.push(key);
-        signature.push(__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].getFamilyByType(exportValue));
-    }
-    return signature;
-}
-function isReactRefreshBoundary(moduleExports) {
-    if (__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(moduleExports)) {
-        return true;
-    }
-    if (moduleExports == null || typeof moduleExports !== "object") {
-        // Exit if we can't iterate over exports.
-        return false;
-    }
-    var hasExports = false;
-    var areAllExportsComponents = true;
-    for(var key in moduleExports){
-        hasExports = true;
-        if (isSafeExport(key)) {
-            continue;
-        }
-        try {
-            var exportValue = moduleExports[key];
-        } catch  {
-            // This might fail due to circular dependencies
-            return false;
-        }
-        if (!__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].isLikelyComponentType(exportValue)) {
-            areAllExportsComponents = false;
-        }
-    }
-    return hasExports && areAllExportsComponents;
-}
-function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) {
-    if (prevSignature.length !== nextSignature.length) {
-        return true;
-    }
-    for(var i = 0; i < nextSignature.length; i++){
-        if (prevSignature[i] !== nextSignature[i]) {
-            return true;
-        }
-    }
-    return false;
-}
-var isUpdateScheduled = false;
-// This function aggregates updates from multiple modules into a single React Refresh call.
-function scheduleUpdate() {
-    if (isUpdateScheduled) {
-        return;
-    }
-    isUpdateScheduled = true;
-    function canApplyUpdate(status) {
-        return status === "idle";
-    }
-    function applyUpdate() {
-        isUpdateScheduled = false;
-        try {
-            __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].performReactRefresh();
-        } catch (err) {
-            console.warn("Warning: Failed to re-render. We will retry on the next Fast Refresh event.\n" + err);
-        }
-    }
-    if (canApplyUpdate(turbopackModule.hot.status())) {
-        // Apply update on the next tick.
-        Promise.resolve().then(()=>{
-            applyUpdate();
-        });
-        return;
-    }
-    const statusHandler = (status)=>{
-        if (canApplyUpdate(status)) {
-            turbopackModule.hot.removeStatusHandler(statusHandler);
-            applyUpdate();
-        }
-    };
-    // Apply update once the HMR runtime's status is idle.
-    turbopackModule.hot.addStatusHandler(statusHandler);
-}
-var __TURBOPACK__default__export__ = {
-    registerExportsForReactRefresh: registerExportsForReactRefresh,
-    isReactRefreshBoundary: isReactRefreshBoundary,
-    shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary,
-    getRefreshBoundarySignature: getRefreshBoundarySignature,
-    scheduleUpdate: scheduleUpdate
-};
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)", ((__turbopack_context__, module, exports) => {
-"use strict";
-
-// react@0.18.0: https://unpkg.com/react-refresh@0.18.0/cjs/react-refresh-runtime.development.js
-/**
- * @license React
- * react-refresh-runtime.development.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */ "production" !== ("TURBOPACK compile-time value", "development") && function() {
-    function computeFullKey(signature) {
-        if (null !== signature.fullKey) return signature.fullKey;
-        var fullKey = signature.ownKey;
-        try {
-            var hooks = signature.getCustomHooks();
-        } catch (err) {
-            return signature.forceReset = !0, signature.fullKey = fullKey;
-        }
-        for(var i = 0; i < hooks.length; i++){
-            var hook = hooks[i];
-            if ("function" !== typeof hook) return signature.forceReset = !0, signature.fullKey = fullKey;
-            hook = allSignaturesByType.get(hook);
-            if (void 0 !== hook) {
-                var nestedHookKey = computeFullKey(hook);
-                hook.forceReset && (signature.forceReset = !0);
-                fullKey += "\n---\n" + nestedHookKey;
-            }
-        }
-        return signature.fullKey = fullKey;
-    }
-    function resolveFamily(type) {
-        return updatedFamiliesByType.get(type);
-    }
-    function cloneMap(map) {
-        var clone = new Map();
-        map.forEach(function(value, key) {
-            clone.set(key, value);
-        });
-        return clone;
-    }
-    function cloneSet(set) {
-        var clone = new Set();
-        set.forEach(function(value) {
-            clone.add(value);
-        });
-        return clone;
-    }
-    function getProperty(object, property) {
-        try {
-            return object[property];
-        } catch (err) {}
-    }
-    function register(type, id) {
-        if (!(null === type || "function" !== typeof type && "object" !== typeof type || allFamiliesByType.has(type))) {
-            var family = allFamiliesByID.get(id);
-            void 0 === family ? (family = {
-                current: type
-            }, allFamiliesByID.set(id, family)) : pendingUpdates.push([
-                family,
-                type
-            ]);
-            allFamiliesByType.set(type, family);
-            if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
-                case REACT_FORWARD_REF_TYPE:
-                    register(type.render, id + "$render");
-                    break;
-                case REACT_MEMO_TYPE:
-                    register(type.type, id + "$type");
-            }
-        }
-    }
-    function setSignature(type, key) {
-        var forceReset = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1, getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
-        allSignaturesByType.has(type) || allSignaturesByType.set(type, {
-            forceReset: forceReset,
-            ownKey: key,
-            fullKey: null,
-            getCustomHooks: getCustomHooks || function() {
-                return [];
-            }
-        });
-        if ("object" === typeof type && null !== type) switch(getProperty(type, "$$typeof")){
-            case REACT_FORWARD_REF_TYPE:
-                setSignature(type.render, key, forceReset, getCustomHooks);
-                break;
-            case REACT_MEMO_TYPE:
-                setSignature(type.type, key, forceReset, getCustomHooks);
-        }
-    }
-    function collectCustomHooksForSignature(type) {
-        type = allSignaturesByType.get(type);
-        void 0 !== type && computeFullKey(type);
-    }
-    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_MEMO_TYPE = Symbol.for("react.memo"), PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map, allFamiliesByID = new Map(), allFamiliesByType = new PossiblyWeakMap(), allSignaturesByType = new PossiblyWeakMap(), updatedFamiliesByType = new PossiblyWeakMap(), pendingUpdates = [], helpersByRendererID = new Map(), helpersByRoot = new Map(), mountedRoots = new Set(), failedRoots = new Set(), rootElements = "function" === typeof WeakMap ? new WeakMap() : null, isPerformingRefresh = !1;
-    exports._getMountedRootCount = function() {
-        return mountedRoots.size;
-    };
-    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
-    exports.createSignatureFunctionForTransform = function() {
-        var savedType, hasCustomHooks, didCollectHooks = !1;
-        return function(type, key, forceReset, getCustomHooks) {
-            if ("string" === typeof key) return savedType || (savedType = type, hasCustomHooks = "function" === typeof getCustomHooks), null == type || "function" !== typeof type && "object" !== typeof type || setSignature(type, key, forceReset, getCustomHooks), type;
-            !didCollectHooks && hasCustomHooks && (didCollectHooks = !0, collectCustomHooksForSignature(savedType));
-        };
-    };
-    exports.getFamilyByID = function(id) {
-        return allFamiliesByID.get(id);
-    };
-    exports.getFamilyByType = function(type) {
-        return allFamiliesByType.get(type);
-    };
-    exports.hasUnrecoverableErrors = function() {
-        return !1;
-    };
-    exports.injectIntoGlobalHook = function(globalObject) {
-        var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-        if (void 0 === hook) {
-            var nextID = 0;
-            globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
-                renderers: new Map(),
-                supportsFiber: !0,
-                inject: function() {
-                    return nextID++;
-                },
-                onScheduleFiberRoot: function() {},
-                onCommitFiberRoot: function() {},
-                onCommitFiberUnmount: function() {}
-            };
-        }
-        if (hook.isDisabled) console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
-        else {
-            var oldInject = hook.inject;
-            hook.inject = function(injected) {
-                var id = oldInject.apply(this, arguments);
-                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
-                return id;
-            };
-            hook.renderers.forEach(function(injected, id) {
-                "function" === typeof injected.scheduleRefresh && "function" === typeof injected.setRefreshHandler && helpersByRendererID.set(id, injected);
-            });
-            var oldOnCommitFiberRoot = hook.onCommitFiberRoot, oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {};
-            hook.onScheduleFiberRoot = function(id, root, children) {
-                isPerformingRefresh || (failedRoots.delete(root), null !== rootElements && rootElements.set(root, children));
-                return oldOnScheduleFiberRoot.apply(this, arguments);
-            };
-            hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
-                var helpers = helpersByRendererID.get(id);
-                if (void 0 !== helpers) {
-                    helpersByRoot.set(root, helpers);
-                    helpers = root.current;
-                    var alternate = helpers.alternate;
-                    null !== alternate ? (alternate = null != alternate.memoizedState && null != alternate.memoizedState.element && mountedRoots.has(root), helpers = null != helpers.memoizedState && null != helpers.memoizedState.element, !alternate && helpers ? (mountedRoots.add(root), failedRoots.delete(root)) : alternate && helpers || (alternate && !helpers ? (mountedRoots.delete(root), didError ? failedRoots.add(root) : helpersByRoot.delete(root)) : alternate || helpers || didError && failedRoots.add(root))) : mountedRoots.add(root);
-                }
-                return oldOnCommitFiberRoot.apply(this, arguments);
-            };
-        }
-    };
-    exports.isLikelyComponentType = function(type) {
-        switch(typeof type){
-            case "function":
-                if (null != type.prototype) {
-                    if (type.prototype.isReactComponent) return !0;
-                    var ownNames = Object.getOwnPropertyNames(type.prototype);
-                    if (1 < ownNames.length || "constructor" !== ownNames[0] || type.prototype.__proto__ !== Object.prototype) return !1;
-                }
-                type = type.name || type.displayName;
-                return "string" === typeof type && /^[A-Z]/.test(type);
-            case "object":
-                if (null != type) switch(getProperty(type, "$$typeof")){
-                    case REACT_FORWARD_REF_TYPE:
-                    case REACT_MEMO_TYPE:
-                        return !0;
-                }
-                return !1;
-            default:
-                return !1;
-        }
-    };
-    exports.performReactRefresh = function() {
-        if (0 === pendingUpdates.length || isPerformingRefresh) return null;
-        isPerformingRefresh = !0;
-        try {
-            var staleFamilies = new Set(), updatedFamilies = new Set(), updates = pendingUpdates;
-            pendingUpdates = [];
-            updates.forEach(function(_ref) {
-                var family = _ref[0];
-                _ref = _ref[1];
-                var prevType = family.current;
-                updatedFamiliesByType.set(prevType, family);
-                updatedFamiliesByType.set(_ref, family);
-                family.current = _ref;
-                prevType.prototype && prevType.prototype.isReactComponent || _ref.prototype && _ref.prototype.isReactComponent ? _ref = !1 : (prevType = allSignaturesByType.get(prevType), _ref = allSignaturesByType.get(_ref), _ref = void 0 === prevType && void 0 === _ref || void 0 !== prevType && void 0 !== _ref && computeFullKey(prevType) === computeFullKey(_ref) && !_ref.forceReset ? !0 : !1);
-                _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
-            });
-            var update = {
-                updatedFamilies: updatedFamilies,
-                staleFamilies: staleFamilies
-            };
-            helpersByRendererID.forEach(function(helpers) {
-                helpers.setRefreshHandler(resolveFamily);
-            });
-            var didError = !1, firstError = null, failedRootsSnapshot = cloneSet(failedRoots), mountedRootsSnapshot = cloneSet(mountedRoots), helpersByRootSnapshot = cloneMap(helpersByRoot);
-            failedRootsSnapshot.forEach(function(root) {
-                var helpers = helpersByRootSnapshot.get(root);
-                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
-                failedRoots.has(root);
-                if (null !== rootElements && rootElements.has(root)) {
-                    var element = rootElements.get(root);
-                    try {
-                        helpers.scheduleRoot(root, element);
-                    } catch (err) {
-                        didError || (didError = !0, firstError = err);
-                    }
-                }
-            });
-            mountedRootsSnapshot.forEach(function(root) {
-                var helpers = helpersByRootSnapshot.get(root);
-                if (void 0 === helpers) throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
-                mountedRoots.has(root);
-                try {
-                    helpers.scheduleRefresh(root, update);
-                } catch (err) {
-                    didError || (didError = !0, firstError = err);
-                }
-            });
-            if (didError) throw firstError;
-            return update;
-        } finally{
-            isPerformingRefresh = !1;
-        }
-    };
-    exports.register = register;
-    exports.setSignature = setSignature;
-}();
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([]);
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/helpers.ts [client] (ecmascript)");
-var __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[@utoo/pack-runtime]/react-refresh/internal/react-refresh-runtime.development.js [client] (ecmascript)");
-;
-;
-// Hook into ReactDOM initialization
-__TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].injectIntoGlobalHook(self);
-// Register global helpers
-self.$RefreshHelpers$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$helpers$2e$ts__$5b$client$5d$__$28$ecmascript$29$__["default"];
-// Register a helper for module execution interception
-self.$RefreshInterceptModuleExecution$ = function(webpackModuleId) {
-    var prevRefreshReg = self.$RefreshReg$;
-    var prevRefreshSig = self.$RefreshSig$;
-    self.$RefreshReg$ = function(type, id) {
-        __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].register(type, webpackModuleId + " " + id);
-    };
-    self.$RefreshSig$ = __TURBOPACK__imported__module__$5b40$utoo$2f$pack$2d$runtime$5d2f$react$2d$refresh$2f$internal$2f$react$2d$refresh$2d$runtime$2e$development$2e$js__$5b$client$5d$__$28$ecmascript$29$__["default"].createSignatureFunctionForTransform;
-    // Modeled after `useEffect` cleanup pattern:
-    // https://react.dev/learn/synchronizing-with-effects#step-3-add-cleanup-if-needed
-    return function() {
-        self.$RefreshReg$ = prevRefreshReg;
-        self.$RefreshSig$ = prevRefreshSig;
-    };
-};
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-"[project]/hmr/dynamic_chunk_lists_hot_disabled/input/index.js [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "loadLazy",
-    ()=>loadLazy
-]);
-async function loadLazy() {
-    return __turbopack_context__.A("[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript, async loader)");
-}
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js
deleted file mode 100644
index 2c44130bc..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_b65347b5.js
+++ /dev/null
@@ -1,12 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript, async loader)", ((__turbopack_context__) => {
-
-__turbopack_context__.v((parentImport) => {
-    return Promise.all([
-  "input_lazy_c5880b16.js"
-].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
-        return parentImport("[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript)");
-    });
-});
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js
deleted file mode 100644
index 6669c1054..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/input_lazy_c5880b16.js
+++ /dev/null
@@ -1,14 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
-"[project]/hmr/dynamic_chunk_lists_hot_disabled/input/lazy.js [client] (ecmascript)", ((__turbopack_context__) => {
-"use strict";
-
-__turbopack_context__.s([
-    "value",
-    ()=>value
-]);
-const value = "lazy";
-if (typeof globalThis.$RefreshHelpers$ === 'object' && globalThis.$RefreshHelpers !== null) {
-    __turbopack_context__.k.registerExports(__turbopack_context__.m, globalThis.$RefreshHelpers$);
-}
-}),
-]);
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js b/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
deleted file mode 100644
index c375b1cb5..000000000
--- a/crates/pack-tests/tests/snapshot/hmr/dynamic_chunk_lists_hot_disabled/output/main.js
+++ /dev/null
@@ -1,2470 +0,0 @@
-(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
-    typeof document === "object" ? document.currentScript : undefined,
-    {"otherChunks":["input_lazy_b65347b5.js","_root-of-the-server___2651c4ea.js"],"runtimeModuleIds":["[@utoo/pack-runtime]/react-refresh/runtime.ts [client] (ecmascript)","[project]/hmr/dynamic_chunk_lists_hot_disabled/input/index.js [client] (ecmascript)"]}
-]);
-(() => {
-if (!Array.isArray(globalThis["TURBOPACK"])) {
-    return;
-}
-
-var CHUNK_BASE_PATH = "/";
-var WORKER_BASE_PATH = null;
-var RELATIVE_ROOT_PATH = "/ROOT";
-var RUNTIME_PUBLIC_PATH = "/";
-globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"] ||= [];
-var CHUNK_UPDATE_LISTENERS = {
-    push: (registration) => globalThis["TURBOPACK_CHUNK_UPDATE_LISTENERS"].push(registration),
-};
-var ASSET_SUFFIX = "";
-var CROSS_ORIGIN = null;
-var CHUNK_LOAD_RETRY_MAX_ATTEMPTS = 1;
-var CHUNK_LOAD_RETRY_BASE_DELAY_MS = 200;
-var CHUNK_LOAD_RETRY_MAX_JITTER_MS = 400;
-var WORKER_FORWARDED_GLOBALS = [];
-/**
- * This file contains runtime types and functions that are shared between all
- * TurboPack ECMAScript runtimes.
- *
- * It will be prepended to the runtime code of each runtime.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
-/// <reference path="./async-module.ts" />
-/**
- * Describes why a module was instantiated.
- * Shared between browser and Node.js runtimes.
- */ var SourceType = function(SourceType) {
-    /**
-   * The module was instantiated because it was included in an evaluated chunk's
-   * runtime.
-   * SourceData is a ChunkPath.
-   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
-    /**
-   * The module was instantiated because a parent module imported it.
-   * SourceData is a ModuleId.
-   */ SourceType[SourceType["Parent"] = 1] = "Parent";
-    /**
-   * The module was instantiated because it was included in a chunk's hot module
-   * update.
-   * SourceData is an array of ModuleIds or undefined.
-   */ SourceType[SourceType["Update"] = 2] = "Update";
-    return SourceType;
-}(SourceType || {});
-/**
- * Flag indicating which module object type to create when a module is merged. Set to `true`
- * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,
- * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it
- * uses plain Module objects.
- */ let createModuleWithDirectionFlag = false;
-const REEXPORTED_OBJECTS = new WeakMap();
-/**
- * Constructs the `__turbopack_context__` object for a module.
- */ function Context(module, exports) {
-    this.m = module;
-    // We need to store this here instead of accessing it from the module object to:
-    // 1. Make it available to factories directly, since we rewrite `this` to
-    //    `__turbopack_context__.e` in CJS modules.
-    // 2. Support async modules which rewrite `module.exports` to a promise, so we
-    //    can still access the original exports object from functions like
-    //    `esmExport`
-    // Ideally we could find a new approach for async modules and drop this property altogether.
-    this.e = exports;
-}
-const contextPrototype = Context.prototype;
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
-function defineProp(obj, name, options) {
-    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
-}
-function getOverwrittenModule(moduleCache, id) {
-    let module = moduleCache[id];
-    if (!module) {
-        if (createModuleWithDirectionFlag) {
-            // set in development modes for hmr support
-            module = createModuleWithDirection(id);
-        } else {
-            module = createModuleObject(id);
-        }
-        moduleCache[id] = module;
-    }
-    return module;
-}
-/**
- * Creates the module object. Only done here to ensure all module objects have the same shape.
- */ function createModuleObject(id) {
-    return {
-        exports: {},
-        error: undefined,
-        id,
-        namespaceObject: undefined
-    };
-}
-function createModuleWithDirection(id) {
-    return {
-        exports: {},
-        error: undefined,
-        id,
-        namespaceObject: undefined,
-        parents: [],
-        children: []
-    };
-}
-const BindingTag_Value = 0;
-/**
- * Adds the getters to the exports object.
- */ function esm(exports, bindings) {
-    defineProp(exports, '__esModule', {
-        value: true
-    });
-    if (toStringTag) defineProp(exports, toStringTag, {
-        value: 'Module'
-    });
-    let i = 0;
-    while(i < bindings.length){
-        const propName = bindings[i++];
-        const tagOrFunction = bindings[i++];
-        if (typeof tagOrFunction === 'number') {
-            if (tagOrFunction === BindingTag_Value) {
-                defineProp(exports, propName, {
-                    value: bindings[i++],
-                    enumerable: true,
-                    writable: false
-                });
-            } else {
-                throw new Error(`unexpected tag: ${tagOrFunction}`);
-            }
-        } else {
-            const getterFn = tagOrFunction;
-            if (typeof bindings[i] === 'function') {
-                const setterFn = bindings[i++];
-                defineProp(exports, propName, {
-                    get: getterFn,
-                    set: setterFn,
-                    enumerable: true
-                });
-            } else {
-                defineProp(exports, propName, {
-                    get: getterFn,
-                    enumerable: true
-                });
-            }
-        }
-    }
-    Object.seal(exports);
-}
-/**
- * Makes the module an ESM with exports
- */ function esmExport(bindings, id) {
-    let module;
-    let exports;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-        exports = module.exports;
-    } else {
-        module = this.m;
-        exports = this.e;
-    }
-    module.namespaceObject = exports;
-    esm(exports, bindings);
-}
-contextPrototype.s = esmExport;
-function ensureDynamicExports(module, exports) {
-    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
-    if (!reexportedObjects) {
-        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
-        module.exports = module.namespaceObject = new Proxy(exports, {
-            get (target, prop) {
-                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
-                    return Reflect.get(target, prop);
-                }
-                for (const obj of reexportedObjects){
-                    const value = Reflect.get(obj, prop);
-                    if (value !== undefined) return value;
-                }
-                return undefined;
-            },
-            ownKeys (target) {
-                const keys = Reflect.ownKeys(target);
-                for (const obj of reexportedObjects){
-                    for (const key of Reflect.ownKeys(obj)){
-                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
-                    }
-                }
-                return keys;
-            }
-        });
-    }
-    return reexportedObjects;
-}
-/**
- * Dynamically exports properties from an object
- */ function dynamicExport(object, id) {
-    let module;
-    let exports;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-        exports = module.exports;
-    } else {
-        module = this.m;
-        exports = this.e;
-    }
-    const reexportedObjects = ensureDynamicExports(module, exports);
-    if (typeof object === 'object' && object !== null) {
-        reexportedObjects.push(object);
-    }
-}
-contextPrototype.j = dynamicExport;
-function exportValue(value, id) {
-    let module;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-    } else {
-        module = this.m;
-    }
-    module.exports = value;
-}
-contextPrototype.v = exportValue;
-function exportNamespace(namespace, id) {
-    let module;
-    if (id != null) {
-        module = getOverwrittenModule(this.c, id);
-    } else {
-        module = this.m;
-    }
-    module.exports = module.namespaceObject = namespace;
-}
-contextPrototype.n = exportNamespace;
-function createGetter(obj, key) {
-    return ()=>obj[key];
-}
-/**
- * @returns prototype of the object
- */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
-/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
-    null,
-    getProto({}),
-    getProto([]),
-    getProto(getProto)
-];
-/**
- * @param raw
- * @param ns
- * @param allowExportDefault
- *   * `false`: will have the raw module as default export
- *   * `true`: will have the default property as default export
- */ function interopEsm(raw, ns, allowExportDefault) {
-    const bindings = [];
-    let defaultLocation = -1;
-    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
-        for (const key of Object.getOwnPropertyNames(current)){
-            bindings.push(key, createGetter(raw, key));
-            if (defaultLocation === -1 && key === 'default') {
-                defaultLocation = bindings.length - 1;
-            }
-        }
-    }
-    // this is not really correct
-    // we should set the `default` getter if the imported module is a `.cjs file`
-    if (!(allowExportDefault && defaultLocation >= 0)) {
-        // Replace the binding with one for the namespace itself in order to preserve iteration order.
-        if (defaultLocation >= 0) {
-            // Replace the getter with the value
-            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
-        } else {
-            bindings.push('default', BindingTag_Value, raw);
-        }
-    }
-    esm(ns, bindings);
-    return ns;
-}
-function createNS(raw) {
-    if (typeof raw === 'function') {
-        return function(...args) {
-            return raw.apply(this, args);
-        };
-    } else {
-        return Object.create(null);
-    }
-}
-function esmImport(id) {
-    const module = getOrInstantiateModuleFromParent(id, this.m);
-    // any ES module has to have `module.namespaceObject` defined.
-    if (module.namespaceObject) return module.namespaceObject;
-    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
-    const raw = module.exports;
-    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
-}
-contextPrototype.i = esmImport;
-function asyncLoader(moduleId) {
-    const loader = this.r(moduleId);
-    return loader(esmImport.bind(this));
-}
-contextPrototype.A = asyncLoader;
-// Add a simple runtime require so that environments without one can still pass
-// `typeof require` CommonJS checks so that exports are correctly registered.
-const runtimeRequire = // @ts-ignore
-typeof require === 'function' ? require : function require1() {
-    throw new Error('Unexpected use of runtime require');
-};
-contextPrototype.t = runtimeRequire;
-function commonJsRequire(id) {
-    return getOrInstantiateModuleFromParent(id, this.m).exports;
-}
-contextPrototype.r = commonJsRequire;
-/**
- * Remove fragments and query parameters since they are never part of the context map keys
- *
- * This matches how we parse patterns at resolving time.  Arguably we should only do this for
- * strings passed to `import` but the resolve does it for `import` and `require` and so we do
- * here as well.
- */ function parseRequest(request) {
-    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
-    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
-    const hashIndex = request.indexOf('#');
-    if (hashIndex !== -1) {
-        request = request.substring(0, hashIndex);
-    }
-    const queryIndex = request.indexOf('?');
-    if (queryIndex !== -1) {
-        request = request.substring(0, queryIndex);
-    }
-    return request;
-}
-/**
- * `require.context` and require/import expression runtime.
- */ function moduleContext(map) {
-    function moduleContext(id) {
-        id = parseRequest(id);
-        if (hasOwnProperty.call(map, id)) {
-            return map[id].module();
-        }
-        const e = new Error(`Cannot find module '${id}'`);
-        e.code = 'MODULE_NOT_FOUND';
-        throw e;
-    }
-    moduleContext.keys = ()=>{
-        return Object.keys(map);
-    };
-    moduleContext.resolve = (id)=>{
-        id = parseRequest(id);
-        if (hasOwnProperty.call(map, id)) {
-            return map[id].id();
-        }
-        const e = new Error(`Cannot find module '${id}'`);
-        e.code = 'MODULE_NOT_FOUND';
-        throw e;
-    };
-    moduleContext.import = async (id)=>{
-        return await moduleContext(id);
-    };
-    return moduleContext;
-}
-contextPrototype.f = moduleContext;
-/**
- * Returns the path of a chunk defined by its data.
- */ function getChunkPath(chunkData) {
-    return typeof chunkData === 'string' ? chunkData : chunkData.path;
-}
-// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
-// The CompressedModuleFactories format is
-// - 1 or more module ids
-// - a module factory function
-// So walking this is a little complex but the flat structure is also fast to
-// traverse, we can use `typeof` operators to distinguish the two cases.
-function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
-    let i = offset;
-    while(i < chunkModules.length){
-        let end = i + 1;
-        // Find our factory function
-        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
-            end++;
-        }
-        if (end === chunkModules.length) {
-            throw new Error('malformed chunk format, expected a factory function');
-        }
-        // Install the factory for each module ID that doesn't already have one.
-        // When some IDs in this group already have a factory, reuse that existing
-        // group factory for the missing IDs to keep all IDs in the group consistent.
-        // Otherwise, install the factory from this chunk.
-        const moduleFactoryFn = chunkModules[end];
-        let existingGroupFactory = undefined;
-        for(let j = i; j < end; j++){
-            const id = chunkModules[j];
-            const existingFactory = moduleFactories.get(id);
-            if (existingFactory) {
-                existingGroupFactory = existingFactory;
-                break;
-            }
-        }
-        const factoryToInstall = existingGroupFactory ?? moduleFactoryFn;
-        let didInstallFactory = false;
-        for(let j = i; j < end; j++){
-            const id = chunkModules[j];
-            if (!moduleFactories.has(id)) {
-                if (!didInstallFactory) {
-                    if (factoryToInstall === moduleFactoryFn) {
-                        applyModuleFactoryName(moduleFactoryFn);
-                    }
-                    didInstallFactory = true;
-                }
-                moduleFactories.set(id, factoryToInstall);
-                newModuleId?.(id);
-            }
-        }
-        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
-    }
-}
-/**
- * A pseudo "fake" URL object to resolve to its relative path.
- *
- * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
- * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
- * hydration mismatch.
- *
- * This is based on webpack's existing implementation:
- * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
- */ const relativeURL = function relativeURL(inputUrl) {
-    const realUrl = new URL(inputUrl, 'x:/');
-    const values = {};
-    for(const key in realUrl)values[key] = realUrl[key];
-    values.href = inputUrl;
-    values.pathname = inputUrl.replace(/[?#].*/, '');
-    values.origin = values.protocol = '';
-    values.toString = values.toJSON = (..._args)=>inputUrl;
-    for(const key in values)Object.defineProperty(this, key, {
-        enumerable: true,
-        configurable: true,
-        value: values[key]
-    });
-};
-relativeURL.prototype = URL.prototype;
-contextPrototype.U = relativeURL;
-/**
- * Utility function to ensure all variants of an enum are handled.
- */ function invariant(never, computeMessage) {
-    throw new Error(`Invariant: ${computeMessage(never)}`);
-}
-/**
- * Constructs an error message for when a module factory is not available.
- */ function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
-    let instantiationReason;
-    switch(sourceType){
-        case 0:
-            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
-            break;
-        case 1:
-            instantiationReason = `because it was required from module ${sourceData}`;
-            break;
-        case 2:
-            instantiationReason = 'because of an HMR update';
-            break;
-        default:
-            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
-    }
-    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
-}
-/**
- * A stub function to make `require` available but non-functional in ESM.
- */ function requireStub(_moduleId) {
-    throw new Error('dynamic usage of require is not supported');
-}
-contextPrototype.z = requireStub;
-// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
-contextPrototype.g = globalThis;
-let cachedAutomaticPublicPath;
-function getAutomaticPublicPath() {
-    if (cachedAutomaticPublicPath !== undefined) {
-        return cachedAutomaticPublicPath;
-    }
-    let scriptUrl;
-    if (typeof document === 'object') {
-        const currentScript = document.currentScript;
-        scriptUrl = currentScript?.src;
-        if (!scriptUrl) {
-            const scripts = document.getElementsByTagName('script');
-            const script = scripts[scripts.length - 1];
-            scriptUrl = script?.src;
-        }
-    }
-    if (!scriptUrl && typeof globalThis.importScripts === 'function' && globalThis.location) {
-        scriptUrl = String(globalThis.location);
-    }
-    cachedAutomaticPublicPath = scriptUrl ? scriptUrl.replace(/^blob:/, '').replace(/#.*$/, '').replace(/\?.*$/, '').replace(/\/[^/]*$/, '/') : '';
-    return cachedAutomaticPublicPath;
-}
-/**
- * Gets the public path for runtime assets.
- * Checks globalThis.publicPath and falls back to "/".
- */ function getPublicPath(mode) {
-    if (mode === 'auto') {
-        return getAutomaticPublicPath();
-    }
-    if (typeof globalThis !== 'undefined' && typeof globalThis.publicPath === 'string') {
-        const publicPath = globalThis.publicPath;
-        return publicPath.endsWith('/') ? publicPath : `${publicPath}/`;
-    }
-    return '/';
-}
-contextPrototype.p = getPublicPath;
-function applyModuleFactoryName(factory) {
-    // Give the module factory a nice name to improve stack traces.
-    Object.defineProperty(factory, 'name', {
-        value: 'module evaluation'
-    });
-}
-/// <reference path="./runtime-types.d.ts" />
-/// <reference path="./runtime-utils.ts" />
-/**
- * Top-level-await / async-module machinery. This is only included in the runtime
- * when the module graph actually contains an async module (a module with
- * top-level await, or one that transitively depends on one). When no async
- * module is present, the chunk items never reference `__turbopack_context__.a`,
- * so this whole file can be omitted.
- *
- * everything below is adapted from webpack
- * https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
- */ const turbopackQueues = Symbol('turbopack queues');
-const turbopackExports = Symbol('turbopack exports');
-const turbopackError = Symbol('turbopack error');
-function isPromise(maybePromise) {
-    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
-}
-function isAsyncModuleExt(obj) {
-    return turbopackQueues in obj;
-}
-function createPromise() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        reject = rej;
-        resolve = res;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject
-    };
-}
-function resolveQueue(queue) {
-    if (queue && queue.status !== 1) {
-        queue.status = 1;
-        queue.forEach((fn)=>fn.queueCount--);
-        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
-    }
-}
-function wrapDeps(deps) {
-    return deps.map((dep)=>{
-        if (dep !== null && typeof dep === 'object') {
-            if (isAsyncModuleExt(dep)) return dep;
-            if (isPromise(dep)) {
-                const queue = Object.assign([], {
-                    status: 0
-                });
-                const obj = {
-                    [turbopackExports]: {},
-                    [turbopackQueues]: (fn)=>fn(queue)
-                };
-                dep.then((res)=>{
-                    obj[turbopackExports] = res;
-                    resolveQueue(queue);
-                }, (err)=>{
-                    obj[turbopackError] = err;
-                    resolveQueue(queue);
-                });
-                return obj;
-            }
-        }
-        return {
-            [turbopackExports]: dep,
-            [turbopackQueues]: ()=>{}
-        };
-    });
-}
-function asyncModule(body, hasAwait) {
-    const module = this.m;
-    const queue = hasAwait ? Object.assign([], {
-        status: -1
-    }) : undefined;
-    const depQueues = new Set();
-    const { resolve, reject, promise: rawPromise } = createPromise();
-    const promise = Object.assign(rawPromise, {
-        [turbopackExports]: module.exports,
-        [turbopackQueues]: (fn)=>{
-            queue && fn(queue);
-            depQueues.forEach(fn);
-            promise['catch'](()=>{});
-        }
-    });
-    const attributes = {
-        get () {
-            return promise;
-        },
-        set (v) {
-            // Calling `esmExport` leads to this.
-            if (v !== promise) {
-                promise[turbopackExports] = v;
-            }
-        }
-    };
-    Object.defineProperty(module, 'exports', attributes);
-    Object.defineProperty(module, 'namespaceObject', attributes);
-    function handleAsyncDependencies(deps) {
-        const currentDeps = wrapDeps(deps);
-        const getResult = ()=>currentDeps.map((d)=>{
-                if (d[turbopackError]) throw d[turbopackError];
-                return d[turbopackExports];
-            });
-        const { promise, resolve } = createPromise();
-        const fn = Object.assign(()=>resolve(getResult), {
-            queueCount: 0
-        });
-        function fnQueue(q) {
-            if (q !== queue && !depQueues.has(q)) {
-                depQueues.add(q);
-                if (q && q.status === 0) {
-                    fn.queueCount++;
-                    q.push(fn);
-                }
-            }
-        }
-        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
-        return fn.queueCount ? promise : getResult();
-    }
-    function asyncResult(err) {
-        if (err) {
-            reject(promise[turbopackError] = err);
-        } else {
-            resolve(promise[turbopackExports]);
-        }
-        resolveQueue(queue);
-    }
-    body(handleAsyncDependencies, asyncResult);
-    if (queue && queue.status === -1) {
-        queue.status = 0;
-    }
-}
-contextPrototype.a = asyncModule;
-/**
- * This file contains runtime types and functions that are shared between all
- * Turbopack *browser* ECMAScript runtimes.
- *
- * It will be appended to the runtime code of each runtime right after the
- * shared runtime utils.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
-/// <reference path="../../../shared/runtime/runtime-utils.ts" />
-// Used in WebWorkers to tell the runtime about the chunk suffix
-// Support runtime public path modes.
-function getRuntimeChunkBasePath(basePath = CHUNK_BASE_PATH) {
-    if (basePath === '__RUNTIME_PUBLIC_PATH__') {
-        return contextPrototype.p();
-    }
-    if (basePath === '__AUTO_PUBLIC_PATH__') {
-        return contextPrototype.p('auto');
-    }
-    return basePath;
-}
-const browserContextPrototype = Context.prototype;
-const moduleFactories = new Map();
-contextPrototype.M = moduleFactories;
-const availableModules = new Map();
-const availableModuleChunks = new Map();
-function loadChunk(chunkData) {
-    return loadChunkInternal(SourceType.Parent, this.m.id, chunkData);
-}
-browserContextPrototype.l = loadChunk;
-function loadInitialChunk(chunkPath, chunkData) {
-    return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData);
-}
-async function loadChunkInternal(sourceType, sourceData, chunkData) {
-    if (typeof chunkData === 'string') {
-        return loadChunkPath(sourceType, sourceData, chunkData);
-    }
-    const includedList = chunkData.included || [];
-    const modulesPromises = includedList.map((included)=>{
-        if (moduleFactories.has(included)) return true;
-        return availableModules.get(included);
-    });
-    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
-        // When all included items are already loaded or loading, we can skip loading ourselves
-        await Promise.all(modulesPromises);
-        return;
-    }
-    const includedModuleChunksList = chunkData.moduleChunks || [];
-    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
-        // TODO(alexkirsz) Do we need this check?
-        // if (moduleFactories[included]) return true;
-        return availableModuleChunks.get(included);
-    }).filter((p)=>p);
-    let promise;
-    if (moduleChunksPromises.length > 0) {
-        // Some module chunks are already loaded or loading.
-        if (moduleChunksPromises.length === includedModuleChunksList.length) {
-            // When all included module chunks are already loaded or loading, we can skip loading ourselves
-            await Promise.all(moduleChunksPromises);
-            return;
-        }
-        const moduleChunksToLoad = new Set();
-        for (const moduleChunk of includedModuleChunksList){
-            if (!availableModuleChunks.has(moduleChunk)) {
-                moduleChunksToLoad.add(moduleChunk);
-            }
-        }
-        for (const moduleChunkToLoad of moduleChunksToLoad){
-            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
-            availableModuleChunks.set(moduleChunkToLoad, promise);
-            moduleChunksPromises.push(promise);
-        }
-        promise = Promise.all(moduleChunksPromises);
-    } else {
-        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
-        // Mark all included module chunks as loading if they are not already loaded or loading.
-        for (const includedModuleChunk of includedModuleChunksList){
-            if (!availableModuleChunks.has(includedModuleChunk)) {
-                availableModuleChunks.set(includedModuleChunk, promise);
-            }
-        }
-    }
-    for (const included of includedList){
-        if (!availableModules.has(included)) {
-            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
-            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
-            availableModules.set(included, promise);
-        }
-    }
-    await promise;
-}
-const loadedChunk = Promise.resolve(undefined);
-const instrumentedBackendLoadChunks = new WeakMap();
-// Do not make this async. React relies on referential equality of the returned Promise.
-function loadChunkByUrl(chunkUrl) {
-    return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl);
-}
-browserContextPrototype.L = loadChunkByUrl;
-const loadedScripts = new Map();
-/**
- * Load an external script by creating a <script> tag.
- * This is used for script externals that need to be loaded from CDN or other external sources.
- */ function loadScript(scriptUrl) {
-    // Return cached promise if script is already loading or loaded
-    let promise = loadedScripts.get(scriptUrl);
-    if (promise) {
-        return promise;
-    }
-    promise = new Promise((resolve, reject)=>{
-        const script = document.createElement('script');
-        script.crossOrigin = CROSS_ORIGIN;
-        script.src = scriptUrl;
-        script.onload = ()=>resolve();
-        script.onerror = ()=>reject(new Error(`Failed to load script: ${scriptUrl}`));
-        document.head.appendChild(script);
-    });
-    loadedScripts.set(scriptUrl, promise);
-    return promise;
-}
-browserContextPrototype.S = loadScript;
-// Do not make this async. React relies on referential equality of the returned Promise.
-function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
-    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
-    let entry = instrumentedBackendLoadChunks.get(thenable);
-    if (entry === undefined) {
-        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
-        entry = thenable.then(resolve).catch((cause)=>{
-            let loadReason;
-            switch(sourceType){
-                case SourceType.Runtime:
-                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
-                    break;
-                case SourceType.Parent:
-                    loadReason = `from module ${sourceData}`;
-                    break;
-                case SourceType.Update:
-                    loadReason = 'from an HMR update';
-                    break;
-                default:
-                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
-            }
-            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
-                cause
-            } : undefined);
-            error.name = 'ChunkLoadError';
-            throw error;
-        });
-        instrumentedBackendLoadChunks.set(thenable, entry);
-    }
-    return entry;
-}
-// Do not make this async. React relies on referential equality of the returned Promise.
-function loadChunkPath(sourceType, sourceData, chunkPath) {
-    const url = getChunkRelativeUrl(chunkPath);
-    return loadChunkByUrlInternal(sourceType, sourceData, url);
-}
-/**
- * Returns an absolute url to an asset.
- */ function resolvePathFromModule(moduleId) {
-    const exported = this.r(moduleId);
-    return exported?.default ?? exported;
-}
-browserContextPrototype.R = resolvePathFromModule;
-/**
- * no-op for browser
- * @param modulePath
- */ function resolveAbsolutePath(modulePath) {
-    return `/ROOT/${modulePath ?? ''}`;
-}
-browserContextPrototype.P = resolveAbsolutePath;
-/**
- * Returns a placeholder `file://` URL for the given module path. The browser
- * runtime intentionally does not expose the real filesystem path. Path
- * segments are percent-encoded so the result is always a valid file URI.
- */ function resolveFileUrl(modulePath) {
-    if (!modulePath) return 'file:///ROOT/';
-    return `file:///ROOT/${modulePath.split('/').map(encodeURIComponent).join('/')}`;
-}
-browserContextPrototype.F = resolveFileUrl;
-/**
- * Exports a URL with the static suffix appended.
- */ function exportUrl(url, id) {
-    exportValue.call(this, `${url}${ASSET_SUFFIX}`, id);
-}
-browserContextPrototype.q = exportUrl;
-/**
- * Instantiates a runtime module.
- */ function instantiateRuntimeModule(moduleId, chunkPath) {
-    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
-}
-/**
- * Returns the URL relative to the origin where a chunk can be fetched from.
- */ function getChunkRelativeUrl(chunkPath, basePath = CHUNK_BASE_PATH) {
-    return `${getRuntimeChunkBasePath(basePath)}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${ASSET_SUFFIX}`;
-}
-// Shared runtime primitives consumed by the bundled `createWorker` helper,
-// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.
-browserContextPrototype.b = CHUNK_BASE_PATH;
-browserContextPrototype.X = ASSET_SUFFIX;
-// Shared runtime primitive: build a chunk's URL. Used by the bundled worker
-// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.
-browserContextPrototype.h = getChunkRelativeUrl;
-function getPathFromScript(chunkScript) {
-    if (typeof chunkScript === 'string') {
-        return chunkScript;
-    }
-    const chunkUrl = chunkScript.src;
-    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
-    const runtimeBasePath = getRuntimeChunkBasePath();
-    let path = src.startsWith(runtimeBasePath) ? src.slice(runtimeBasePath.length) : src;
-    if (path.startsWith('/')) {
-        path = path.slice(1);
-    }
-    return path;
-}
-/**
- * Return the ChunkUrl from a ChunkScript.
- */ function getUrlFromScript(chunk) {
-    if (typeof chunk === 'string') {
-        return getChunkRelativeUrl(chunk);
-    } else {
-        // This is already exactly what we want
-        return chunk.src;
-    }
-}
-/**
- * Determine the chunk to register. Note that this function has side-effects!
- */ function getChunkFromRegistration(chunk) {
-    if (typeof chunk === 'string') {
-        return chunk;
-    } else if (!chunk) {
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        } else {
-            throw new Error('chunk path empty but not in a worker');
-        }
-    } else {
-        return {
-            src: chunk.getAttribute('src')
-        };
-    }
-}
-/**
- * Checks if a given path/URL ends with the given extension,
- * optionally followed by ?query or #fragment.
- */ function endsWithExtension(chunkUrlOrPath, ext) {
-    // Find where the path ends (before query or fragment)
-    const q = chunkUrlOrPath.indexOf('?');
-    let end;
-    if (q !== -1) {
-        end = q;
-    } else {
-        const h = chunkUrlOrPath.indexOf('#');
-        end = h !== -1 ? h : chunkUrlOrPath.length;
-    }
-    // Check if the path portion ends with the extension
-    return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length);
-}
-function isJs(chunkUrlOrPath) {
-    return endsWithExtension(chunkUrlOrPath, '.js');
-}
-function isCss(chunkUrl) {
-    return endsWithExtension(chunkUrl, '.css');
-}
-/// <reference path="./runtime-utils.ts" />
-/// <reference path="./runtime-types.d.ts" />
-/// <reference path="./dev-extensions.ts" />
-/// <reference path="./dev-protocol.d.ts" />
-/**
- * Shared HMR (Hot Module Replacement) implementation.
- *
- * This file contains the complete HMR implementation that's shared between
- * browser and Node.js runtimes. It manages module hot state, dependency
- * tracking, the module.hot API, and the full HMR update flow.
- */ /**
- * The development module cache shared across the runtime.
- * Browser runtime declares this directly.
- * Node.js runtime assigns globalThis.__turbopack_module_cache__ to this.
- */ let devModuleCache;
-/**
- * Module IDs that are instantiated as part of the runtime of a chunk.
- */ let runtimeModules;
-/**
- * Maps module IDs to persisted data between executions of their hot module
- * implementation (`hot.data`).
- */ const moduleHotData = new Map();
-/**
- * Maps module instances to their hot module state.
- * Uses WeakMap so it works with both HotModule and ModuleWithDirection.
- */ const moduleHotState = new WeakMap();
-/**
- * Modules that call `module.hot.invalidate()` (while being updated).
- */ const queuedInvalidatedModules = new Set();
-class UpdateApplyError extends Error {
-    name = 'UpdateApplyError';
-    constructor(message, dependencyChain){
-        super(message);
-        this.dependencyChain = dependencyChain;
-    }
-}
-/**
- * Records parent-child relationship when a module imports another.
- * Should be called during module instantiation.
- */ // eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackModuleImport(parentModule, childModuleId, childModule) {
-    // Record that parent imports child
-    if (parentModule.children.indexOf(childModuleId) === -1) {
-        parentModule.children.push(childModuleId);
-    }
-    // Record that child is imported by parent
-    if (childModule && childModule.parents.indexOf(parentModule.id) === -1) {
-        childModule.parents.push(parentModule.id);
-    }
-}
-function formatDependencyChain(dependencyChain) {
-    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
-}
-/**
- * Walks the dependency tree to find all modules affected by a change.
- * Returns information about whether the update can be accepted and which
- * modules need to be invalidated.
- *
- * @param moduleId - The module that changed
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().
- *                           This is used for server-side HMR where pages auto-accept at the top level.
- */ function getAffectedModuleEffects(moduleId, autoAcceptRootModules) {
-    const outdatedModules = new Set();
-    const outdatedDependencies = new Map();
-    const queue = [
-        {
-            moduleId,
-            dependencyChain: []
-        }
-    ];
-    let nextItem;
-    while(nextItem = queue.shift()){
-        const { moduleId, dependencyChain } = nextItem;
-        if (moduleId != null) {
-            if (outdatedModules.has(moduleId)) {
-                continue;
-            }
-            outdatedModules.add(moduleId);
-        }
-        // We've arrived at the runtime of the chunk, which means that nothing
-        // else above can accept this update.
-        if (moduleId === undefined) {
-            if (autoAcceptRootModules) {
-                return {
-                    type: 'accepted',
-                    moduleId,
-                    outdatedModules,
-                    outdatedDependencies
-                };
-            }
-            return {
-                type: 'unaccepted',
-                dependencyChain
-            };
-        }
-        const module = devModuleCache[moduleId];
-        const hotState = moduleHotState.get(module);
-        if (// The module is not in the cache. Since this is a "modified" update,
-        // it means that the module was never instantiated before.
-        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
-            continue;
-        }
-        if (hotState.selfDeclined) {
-            return {
-                type: 'self-declined',
-                dependencyChain,
-                moduleId
-            };
-        }
-        if (runtimeModules.has(moduleId)) {
-            if (autoAcceptRootModules) {
-                continue;
-            }
-            queue.push({
-                moduleId: undefined,
-                dependencyChain: [
-                    ...dependencyChain,
-                    moduleId
-                ]
-            });
-            continue;
-        }
-        for (const parentId of module.parents){
-            const parent = devModuleCache[parentId];
-            if (!parent) {
-                continue;
-            }
-            const parentHotState = moduleHotState.get(parent);
-            // Check if parent declined this dependency
-            if (parentHotState?.declinedDependencies[moduleId]) {
-                return {
-                    type: 'declined',
-                    dependencyChain: [
-                        ...dependencyChain,
-                        moduleId
-                    ],
-                    moduleId,
-                    parentId
-                };
-            }
-            // Skip if parent is already outdated
-            if (outdatedModules.has(parentId)) {
-                continue;
-            }
-            // Check if parent accepts this dependency
-            if (parentHotState?.acceptedDependencies[moduleId]) {
-                if (!outdatedDependencies.has(parentId)) {
-                    outdatedDependencies.set(parentId, new Set());
-                }
-                outdatedDependencies.get(parentId).add(moduleId);
-                continue;
-            }
-            // Neither accepted nor declined — propagate to parent
-            queue.push({
-                moduleId: parentId,
-                dependencyChain: [
-                    ...dependencyChain,
-                    moduleId
-                ]
-            });
-        }
-        // If no parents and we're at a root module, auto-accept if configured
-        if (module.parents.length === 0 && autoAcceptRootModules) {
-            continue;
-        }
-    }
-    return {
-        type: 'accepted',
-        moduleId,
-        outdatedModules,
-        outdatedDependencies
-    };
-}
-/**
- * Merges source dependency map into target dependency map.
- */ function mergeDependencies(target, source) {
-    for (const [parentId, deps] of source){
-        const existing = target.get(parentId);
-        if (existing) {
-            for (const dep of deps){
-                existing.add(dep);
-            }
-        } else {
-            target.set(parentId, new Set(deps));
-        }
-    }
-}
-/**
- * Computes all modules that need to be invalidated based on which modules changed.
- *
- * @param invalidated - The modules that have been invalidated
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function computedInvalidatedModules(invalidated, autoAcceptRootModules) {
-    const outdatedModules = new Set();
-    const outdatedDependencies = new Map();
-    for (const moduleId of invalidated){
-        const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules);
-        switch(effect.type){
-            case 'unaccepted':
-                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
-            case 'self-declined':
-                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
-            case 'declined':
-                throw new UpdateApplyError(`cannot apply update: declined dependency. ${formatDependencyChain(effect.dependencyChain)}. Declined by ${effect.parentId}.`, effect.dependencyChain);
-            case 'accepted':
-                for (const outdatedModuleId of effect.outdatedModules){
-                    outdatedModules.add(outdatedModuleId);
-                }
-                mergeDependencies(outdatedDependencies, effect.outdatedDependencies);
-                break;
-            default:
-                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
-        }
-    }
-    return {
-        outdatedModules,
-        outdatedDependencies
-    };
-}
-/**
- * Creates the module.hot API object and its internal state.
- * This provides the HMR API that user code calls (module.hot.accept(), etc.)
- */ function createModuleHot(moduleId, hotData) {
-    const hotState = {
-        selfAccepted: false,
-        selfDeclined: false,
-        selfInvalidated: false,
-        disposeHandlers: [],
-        acceptedDependencies: {},
-        acceptedErrorHandlers: {},
-        declinedDependencies: {}
-    };
-    const hot = {
-        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
-        // decide whether to warn whenever an HMR-disposed module required other
-        // modules. We might want to remove it.
-        active: true,
-        data: hotData ?? {},
-        accept: (modules, callback, errorHandler)=>{
-            if (modules === undefined) {
-                hotState.selfAccepted = true;
-            } else if (typeof modules === 'function') {
-                hotState.selfAccepted = modules;
-            } else if (typeof modules === 'object' && modules !== null) {
-                for(let i = 0; i < modules.length; i++){
-                    hotState.acceptedDependencies[modules[i]] = callback || function() {};
-                    hotState.acceptedErrorHandlers[modules[i]] = errorHandler;
-                }
-            } else {
-                hotState.acceptedDependencies[modules] = callback || function() {};
-                hotState.acceptedErrorHandlers[modules] = errorHandler;
-            }
-        },
-        decline: (dep)=>{
-            if (dep === undefined) {
-                hotState.selfDeclined = true;
-            } else if (typeof dep === 'object' && dep !== null) {
-                for(let i = 0; i < dep.length; i++){
-                    hotState.declinedDependencies[dep[i]] = true;
-                }
-            } else {
-                hotState.declinedDependencies[dep] = true;
-            }
-        },
-        dispose: (callback)=>{
-            hotState.disposeHandlers.push(callback);
-        },
-        addDisposeHandler: (callback)=>{
-            hotState.disposeHandlers.push(callback);
-        },
-        removeDisposeHandler: (callback)=>{
-            const idx = hotState.disposeHandlers.indexOf(callback);
-            if (idx >= 0) {
-                hotState.disposeHandlers.splice(idx, 1);
-            }
-        },
-        invalidate: ()=>{
-            hotState.selfInvalidated = true;
-            queuedInvalidatedModules.add(moduleId);
-        },
-        // NOTE(alexkirsz) This is part of the management API, which we don't
-        // implement, but the Next.js React Refresh runtime uses this to decide
-        // whether to schedule an update.
-        status: ()=>'idle',
-        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
-        addStatusHandler: (_handler)=>{},
-        removeStatusHandler: (_handler)=>{},
-        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
-        // want the webpack code paths to ever update (the turbopack paths handle
-        // this already).
-        check: ()=>Promise.resolve(null)
-    };
-    return {
-        hot,
-        hotState
-    };
-}
-/**
- * Processes queued invalidated modules and adds them to the outdated modules set.
- * Modules that call module.hot.invalidate() are queued and processed here.
- *
- * @param outdatedModules - The current set of outdated modules
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules) {
-    if (queuedInvalidatedModules.size > 0) {
-        const result = computedInvalidatedModules(queuedInvalidatedModules, autoAcceptRootModules);
-        for (const moduleId of result.outdatedModules){
-            outdatedModules.add(moduleId);
-        }
-        mergeDependencies(outdatedDependencies, result.outdatedDependencies);
-        queuedInvalidatedModules.clear();
-    }
-    return {
-        outdatedModules,
-        outdatedDependencies
-    };
-}
-/**
- * Computes which outdated modules have self-accepted and can be hot reloaded.
- */ function computeOutdatedSelfAcceptedModules(outdatedModules) {
-    const outdatedSelfAcceptedModules = [];
-    for (const moduleId of outdatedModules){
-        const module = devModuleCache[moduleId];
-        const hotState = moduleHotState.get(module);
-        if (module && hotState?.selfAccepted && !hotState.selfInvalidated) {
-            outdatedSelfAcceptedModules.push({
-                moduleId,
-                errorHandler: hotState.selfAccepted
-            });
-        }
-    }
-    return outdatedSelfAcceptedModules;
-}
-/**
- * Disposes of an instance of a module.
- * Runs hot.dispose handlers and manages persistent hot data.
- *
- * NOTE: mode = "replace" will not remove modules from devModuleCache.
- * This must be done in a separate step afterwards.
- */ function disposeModule(moduleId, mode) {
-    const module = devModuleCache[moduleId];
-    if (!module) {
-        return;
-    }
-    const hotState = moduleHotState.get(module);
-    if (!hotState) {
-        return;
-    }
-    const data = {};
-    // Run the `hot.dispose` handler, if any, passing in the persistent
-    // `hot.data` object.
-    for (const disposeHandler of hotState.disposeHandlers){
-        disposeHandler(data);
-    }
-    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
-    // module is still importing other modules.
-    if (module.hot) {
-        module.hot.active = false;
-    }
-    moduleHotState.delete(module);
-    // Remove the disposed module from its children's parent list.
-    // It will be added back once the module re-instantiates and imports its
-    // children again.
-    for (const childId of module.children){
-        const child = devModuleCache[childId];
-        if (!child) {
-            continue;
-        }
-        const idx = child.parents.indexOf(module.id);
-        if (idx >= 0) {
-            child.parents.splice(idx, 1);
-        }
-    }
-    switch(mode){
-        case 'clear':
-            delete devModuleCache[module.id];
-            moduleHotData.delete(module.id);
-            break;
-        case 'replace':
-            moduleHotData.set(module.id, data);
-            break;
-        default:
-            invariant(mode, (mode)=>`invalid mode: ${mode}`);
-    }
-}
-/**
- * Dispose phase: runs dispose handlers and cleans up outdated/disposed modules.
- * Returns the parent modules of outdated modules for use in the apply phase.
- */ function disposePhase(outdatedModules, disposedModules, outdatedDependencies) {
-    for (const moduleId of outdatedModules){
-        disposeModule(moduleId, 'replace');
-    }
-    for (const moduleId of disposedModules){
-        disposeModule(moduleId, 'clear');
-    }
-    // Removing modules from the module cache is a separate step.
-    // We also want to keep track of previous parents of the outdated modules.
-    const outdatedModuleParents = new Map();
-    for (const moduleId of outdatedModules){
-        const oldModule = devModuleCache[moduleId];
-        outdatedModuleParents.set(moduleId, oldModule?.parents);
-        delete devModuleCache[moduleId];
-    }
-    // Remove outdated dependencies from parent module's children list.
-    // When a parent accepts a child's update, the child is re-instantiated
-    // but the parent stays alive. We remove the old child reference so it
-    // gets re-added when the child re-imports.
-    for (const [parentId, deps] of outdatedDependencies){
-        const module = devModuleCache[parentId];
-        if (module) {
-            for (const dep of deps){
-                const idx = module.children.indexOf(dep);
-                if (idx >= 0) {
-                    module.children.splice(idx, 1);
-                }
-            }
-        }
-    }
-    return {
-        outdatedModuleParents
-    };
-}
-/* eslint-disable @typescript-eslint/no-unused-vars */ /**
- * Shared module instantiation logic.
- * This handles the full module instantiation flow for both browser and Node.js.
- * Only React Refresh hooks differ between platforms (passed as callback).
- */ function instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContextFn, runModuleExecutionHooksFn) {
-    // 1. Factory validation (same in both browser and Node.js)
-    const id = moduleId;
-    const moduleFactory = moduleFactories.get(id);
-    if (typeof moduleFactory !== 'function') {
-        throw new Error(factoryNotAvailableMessage(moduleId, sourceType, sourceData) + `\nThis is often caused by a stale browser cache, misconfigured Cache-Control headers, or a service worker serving outdated responses.` + `\nTo fix this, make sure your Cache-Control headers allow revalidation of chunks and review your service worker configuration. ` + `As an immediate workaround, try hard-reloading the page, clearing the browser cache, or unregistering any service workers.`);
-    }
-    // 2. Hot API setup (same in both - works for browser, included for Node.js)
-    const hotData = moduleHotData.get(id);
-    const { hot, hotState } = createModuleHot(id, hotData);
-    // 3. Parent assignment logic (same in both)
-    let parents;
-    switch(sourceType){
-        case SourceType.Runtime:
-            runtimeModules.add(id);
-            parents = [];
-            break;
-        case SourceType.Parent:
-            parents = [
-                sourceData
-            ];
-            break;
-        case SourceType.Update:
-            parents = sourceData || [];
-            break;
-        default:
-            throw new Error(`Unknown source type: ${sourceType}`);
-    }
-    // 4. Module creation (platform creates base module object)
-    const module = createModuleObjectFn(id);
-    const exports = module.exports;
-    module.parents = parents;
-    module.children = [];
-    module.hot = hot;
-    devModuleCache[id] = module;
-    moduleHotState.set(module, hotState);
-    // 5. Module execution (React Refresh hooks are platform-specific)
-    try {
-        runModuleExecutionHooksFn(module, (refresh)=>{
-            const context = createContextFn(module, exports, refresh);
-            moduleFactory.call(exports, context, module, exports);
-        });
-    } catch (error) {
-        module.error = error;
-        throw error;
-    }
-    // 6. ESM interop (same in both)
-    if (module.namespaceObject && module.exports !== module.namespaceObject) {
-        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
-        interopEsm(module.exports, module.namespaceObject);
-    }
-    return module;
-}
-/**
- * Analyzes update entries and chunks to determine which modules were added, modified, or deleted.
- * This is pure logic that doesn't depend on the runtime environment.
- */ function computeChangedModules(entries, updates, chunkModulesMap) {
-    const chunksAdded = new Map();
-    const chunksDeleted = new Map();
-    const added = new Map();
-    const modified = new Map();
-    const deleted = new Set();
-    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
-        switch(mergedChunkUpdate.type){
-            case 'added':
-                {
-                    const updateAdded = new Set(mergedChunkUpdate.modules);
-                    for (const moduleId of updateAdded){
-                        added.set(moduleId, entries[moduleId]);
-                    }
-                    chunksAdded.set(chunkPath, updateAdded);
-                    break;
-                }
-            case 'deleted':
-                {
-                    const updateDeleted = chunkModulesMap ? new Set(chunkModulesMap.get(chunkPath)) : new Set();
-                    for (const moduleId of updateDeleted){
-                        deleted.add(moduleId);
-                    }
-                    chunksDeleted.set(chunkPath, updateDeleted);
-                    break;
-                }
-            case 'partial':
-                {
-                    const updateAdded = new Set(mergedChunkUpdate.added);
-                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
-                    for (const moduleId of updateAdded){
-                        added.set(moduleId, entries[moduleId]);
-                    }
-                    for (const moduleId of updateDeleted){
-                        deleted.add(moduleId);
-                    }
-                    chunksAdded.set(chunkPath, updateAdded);
-                    chunksDeleted.set(chunkPath, updateDeleted);
-                    break;
-                }
-            default:
-                throw new Error('Unknown merged chunk update type');
-        }
-    }
-    // If a module was added from one chunk and deleted from another in the same update,
-    // consider it to be modified, as it means the module was moved from one chunk to another
-    // AND has new code in a single update.
-    for (const moduleId of added.keys()){
-        if (deleted.has(moduleId)) {
-            added.delete(moduleId);
-            deleted.delete(moduleId);
-        }
-    }
-    for (const [moduleId, entry] of Object.entries(entries)){
-        // Modules that haven't been added to any chunk but have new code are considered
-        // to be modified.
-        // This needs to be under the previous loop, as we need it to get rid of modules
-        // that were added and deleted in the same update.
-        if (!added.has(moduleId)) {
-            modified.set(moduleId, entry);
-        }
-    }
-    return {
-        added,
-        deleted,
-        modified,
-        chunksAdded,
-        chunksDeleted
-    };
-}
-/**
- * Compiles new module code and walks the dependency tree to find all outdated modules.
- * Uses the evalModuleEntry function to compile code (platform-specific).
- *
- * @param added - Map of added modules
- * @param modified - Map of modified modules
- * @param evalModuleEntry - Function to compile module code
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules) {
-    const newModuleFactories = new Map();
-    // Compile added modules
-    for (const [moduleId, entry] of added){
-        if (entry != null) {
-            newModuleFactories.set(moduleId, evalModuleEntry(entry));
-        }
-    }
-    // Walk dependency tree to find all modules affected by modifications
-    const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(modified.keys(), autoAcceptRootModules);
-    // Compile modified modules
-    for (const [moduleId, entry] of modified){
-        newModuleFactories.set(moduleId, evalModuleEntry(entry));
-    }
-    return {
-        outdatedModules,
-        outdatedDependencies,
-        newModuleFactories
-    };
-}
-/**
- * Updates module factories and re-instantiates self-accepted modules.
- * Uses the instantiateModule function (platform-specific via callback).
- */ function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError) {
-    // Update module factories
-    for (const [moduleId, factory] of newModuleFactories.entries()){
-        applyModuleFactoryNameFn(factory);
-        moduleFactories.set(moduleId, factory);
-    }
-    // TODO(alexkirsz) Run new runtime entries here.
-    // Call accept handlers for outdated dependencies.
-    // This runs BEFORE re-instantiating self-accepted modules, matching
-    // webpack's behavior.
-    for (const [parentId, deps] of outdatedDependencies){
-        const module = devModuleCache[parentId];
-        if (!module) continue;
-        const hotState = moduleHotState.get(module);
-        if (!hotState) continue;
-        // Group deps by callback, deduplicating callbacks that handle multiple deps.
-        // Each callback receives only the deps it was registered for.
-        const callbackDeps = new Map();
-        const callbackErrorHandlers = new Map();
-        for (const dep of deps){
-            const acceptCallback = hotState.acceptedDependencies[dep];
-            if (acceptCallback) {
-                let depList = callbackDeps.get(acceptCallback);
-                if (!depList) {
-                    depList = [];
-                    callbackDeps.set(acceptCallback, depList);
-                    callbackErrorHandlers.set(acceptCallback, hotState.acceptedErrorHandlers[dep]);
-                }
-                depList.push(dep);
-            }
-        }
-        for (const [callback, cbDeps] of callbackDeps){
-            try {
-                callback.call(null, cbDeps);
-            } catch (err) {
-                const errorHandler = callbackErrorHandlers.get(callback);
-                if (typeof errorHandler === 'function') {
-                    try {
-                        errorHandler(err, {
-                            moduleId: parentId,
-                            dependencyId: cbDeps[0]
-                        });
-                    } catch (err2) {
-                        reportError(err2);
-                        reportError(err);
-                    }
-                } else {
-                    reportError(err);
-                }
-            }
-        }
-    }
-    // Re-instantiate all outdated self-accepted modules
-    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
-        try {
-            instantiateModuleFn(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
-        } catch (err) {
-            if (typeof errorHandler === 'function') {
-                try {
-                    errorHandler(err, {
-                        moduleId,
-                        module: devModuleCache[moduleId]
-                    });
-                } catch (err2) {
-                    reportError(err2);
-                    reportError(err);
-                }
-            } else {
-                reportError(err);
-            }
-        }
-    }
-}
-/**
- * Internal implementation that orchestrates the full HMR update flow:
- * invalidation, disposal, and application of new modules.
- *
- * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()
- */ function applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules) {
-    ;
-    ({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(outdatedModules, outdatedDependencies, autoAcceptRootModules));
-    // Find self-accepted modules to re-instantiate
-    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
-    // Run dispose handlers, save hot.data, clear caches
-    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules, outdatedDependencies);
-    let error;
-    function reportError(err) {
-        if (!error) error = err; // Keep first error
-    }
-    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, outdatedDependencies, moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, reportError);
-    if (error) {
-        throw error;
-    }
-    // Recursively apply any queued invalidations from new module execution
-    if (queuedInvalidatedModules.size > 0) {
-        applyInternal(new Set(), new Map(), [], new Map(), moduleFactories, devModuleCache, instantiateModuleFn, applyModuleFactoryNameFn, autoAcceptRootModules);
-    }
-}
-/**
- * Main entry point for applying an ECMAScript merged update.
- * This is called by both browser and Node.js runtimes with platform-specific callbacks.
- *
- * @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit
- *                                   module.hot.accept(). Used for server-side HMR where pages
- *                                   auto-accept at the top level.
- */ function applyEcmascriptMergedUpdateShared(options) {
-    const { added, modified, disposedModules, evalModuleEntry, instantiateModule, applyModuleFactoryName, moduleFactories, devModuleCache, autoAcceptRootModules } = options;
-    const { outdatedModules, outdatedDependencies, newModuleFactories } = computeOutdatedModules(added, modified, evalModuleEntry, autoAcceptRootModules);
-    applyInternal(outdatedModules, outdatedDependencies, disposedModules, newModuleFactories, moduleFactories, devModuleCache, instantiateModule, applyModuleFactoryName, autoAcceptRootModules);
-}
-/// <reference path="../../../shared/runtime/dev-globals.d.ts" />
-/// <reference path="../../../shared/runtime/dev-protocol.d.ts" />
-const devContextPrototype = Context.prototype;
-/**
- * This file contains runtime types and functions that are shared between all
- * Turbopack *development* ECMAScript runtimes.
- *
- * It will be appended to the runtime code of each runtime right after the
- * shared runtime utils.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ // Assign browser's module cache and runtime modules to shared HMR state
-devModuleCache = Object.create(null);
-devContextPrototype.c = devModuleCache;
-runtimeModules = new Set();
-// Set flag to indicate we use ModuleWithDirection
-createModuleWithDirectionFlag = true;
-function getRefreshBoundaryExports(exports) {
-    if (typeof isAsyncModuleExt === 'function' && exports != null && typeof exports === 'object' && isAsyncModuleExt(exports)) {
-        return exports[turbopackExports];
-    }
-    return exports;
-}
-/**
- * Map from module ID to the chunks that contain this module.
- *
- * In HMR, we need to keep track of which modules are contained in which so
- * chunks. This is so we don't eagerly dispose of a module when it is removed
- * from chunk A, but still exists in chunk B.
- */ const moduleChunksMap = new Map();
-/**
- * Map from a chunk path to all modules it contains.
- */ const chunkModulesMap = new Map();
-/**
- * Chunk lists that contain a runtime. When these chunk lists receive an update
- * that can't be reconciled with the current state of the page, we need to
- * reload the runtime entirely.
- */ const runtimeChunkLists = new Set();
-/**
- * Map from a chunk list to the chunk paths it contains.
- */ const chunkListChunksMap = new Map();
-/**
- * Map from a chunk path to the chunk lists it belongs to.
- */ const chunkChunkListsMap = new Map();
-/** Dynamic lists use a stricter, reload-on-ambiguity update policy. */ const dynamicChunkLists = new Set();
-/** Dynamic manifests which have not finished their subscribe/load/revalidate handshake. */ const loadingDynamicChunkLists = new Set();
-/**
- * Gets or instantiates a runtime module.
- */ // @ts-ignore
-function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
-    const module = devModuleCache[moduleId];
-    if (module) {
-        if (module.error) {
-            throw module.error;
-        }
-        return module;
-    }
-    // @ts-ignore
-    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
-}
-/**
- * Retrieves a module from the cache, or instantiate it if it is not cached.
- */ // @ts-ignore Defined in `runtime-utils.ts`
-const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
-    if (!sourceModule.hot.active) {
-        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
-    }
-    const module = devModuleCache[id];
-    if (sourceModule.children.indexOf(id) === -1) {
-        sourceModule.children.push(id);
-    }
-    if (module) {
-        if (module.error) {
-            throw module.error;
-        }
-        if (module.parents.indexOf(sourceModule.id) === -1) {
-            module.parents.push(sourceModule.id);
-        }
-        return module;
-    }
-    return instantiateModule(id, SourceType.Parent, sourceModule.id);
-};
-function DevContext(module, exports, refresh) {
-    Context.call(this, module, exports);
-    this.k = refresh;
-}
-DevContext.prototype = Context.prototype;
-function instantiateModule(moduleId, sourceType, sourceData) {
-    // Browser: creates base HotModule object (hot API added by shared code)
-    const createModuleObjectFn = (id)=>{
-        return createModuleObject(id);
-    };
-    // Browser: creates DevContext with refresh
-    const createContext = (module, exports, refresh)=>{
-        return new DevContext(module, exports, refresh);
-    };
-    // Use shared instantiation logic (includes hot API setup)
-    return instantiateModuleShared(moduleId, sourceType, sourceData, moduleFactories, devModuleCache, runtimeModules, createModuleObjectFn, createContext, runModuleExecutionHooks);
-}
-const DUMMY_REFRESH_CONTEXT = {
-    register: (_type, _id)=>{},
-    signature: ()=>(_type)=>{},
-    registerExports: (_module, _helpers)=>{}
-};
-/**
- * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
- * Next.js' React Refresh runtime hooks into to add module context to the
- * refresh registry.
- */ function runModuleExecutionHooks(module, executeModule) {
-    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
-        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
-        try {
-            executeModule({
-                register: globalThis.$RefreshReg$,
-                signature: globalThis.$RefreshSig$,
-                registerExports: registerExportsAndSetupBoundaryForReactRefresh
-            });
-        } finally{
-            // Always cleanup the intercept, even if module execution failed.
-            cleanupReactRefreshIntercept();
-        }
-    } else {
-        // If the react refresh hooks are not installed we need to bind dummy functions.
-        // This is expected when running in a Web Worker.  It is also common in some of
-        // our test environments.
-        executeModule(DUMMY_REFRESH_CONTEXT);
-    }
-}
-/**
- * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
- */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
-    const currentExports = getRefreshBoundaryExports(module.exports);
-    const prevExports = module.hot.data.prevExports ?? null;
-    helpers.registerExportsForReactRefresh(currentExports, module.id);
-    // A module can be accepted automatically based on its exports, e.g. when
-    // it is a Refresh Boundary.
-    if (helpers.isReactRefreshBoundary(currentExports)) {
-        // Save the previous exports on update, so we can compare the boundary
-        // signatures.
-        module.hot.dispose((data)=>{
-            data.prevExports = currentExports;
-        });
-        // Unconditionally accept an update to this module, we'll check if it's
-        // still a Refresh Boundary later.
-        module.hot.accept();
-        // This field is set when the previous version of this module was a
-        // Refresh Boundary, letting us know we need to check for invalidation or
-        // enqueue an update.
-        if (prevExports !== null) {
-            // A boundary can become ineligible if its exports are incompatible
-            // with the previous exports.
-            //
-            // For example, if you add/remove/change exports, we'll want to
-            // re-execute the importing modules, and force those components to
-            // re-render. Similarly, if you convert a class component to a
-            // function, we want to invalidate the boundary.
-            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
-                module.hot.invalidate();
-            } else {
-                helpers.scheduleUpdate();
-            }
-        }
-    } else {
-        // Since we just executed the code for the module, it's possible that the
-        // new exports made it ineligible for being a boundary.
-        // We only care about the case when we were _previously_ a boundary,
-        // because we already accepted this update (accidental side effect).
-        const isNoLongerABoundary = prevExports !== null;
-        if (isNoLongerABoundary) {
-            module.hot.invalidate();
-        }
-    }
-}
-/**
- * Adds, deletes, and moves modules between chunks. This must happen before the
- * dispose phase as it needs to know which modules were removed from all chunks,
- * which we can only compute *after* taking care of added and moved modules.
- */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
-    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
-        for (const moduleId of addedModuleIds){
-            addModuleToChunk(moduleId, chunkPath);
-        }
-    }
-    const disposedModules = new Set();
-    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
-        for (const moduleId of addedModuleIds){
-            if (removeModuleFromChunk(moduleId, chunkPath)) {
-                disposedModules.add(moduleId);
-            }
-        }
-    }
-    return {
-        disposedModules
-    };
-}
-function applyUpdate(update) {
-    switch(update.type){
-        case 'ChunkListUpdate':
-            applyChunkListUpdate(update);
-            break;
-        default:
-            invariant(update, (update)=>`Unknown update type: ${update.type}`);
-    }
-}
-function applyChunkListUpdate(update) {
-    if (update.merged != null) {
-        for (const merged of update.merged){
-            switch(merged.type){
-                case 'EcmascriptMergedUpdate':
-                    applyEcmascriptMergedUpdate(merged);
-                    break;
-                default:
-                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
-            }
-        }
-    }
-    if (update.chunks != null) {
-        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-            const chunkUrl = getChunkRelativeUrl(chunkPath);
-            switch(chunkUpdate.type){
-                case 'added':
-                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
-                    break;
-                case 'total':
-                    DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    break;
-                case 'deleted':
-                    DEV_BACKEND.unloadChunk?.(chunkUrl);
-                    break;
-                case 'partial':
-                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                    break;
-                default:
-                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
-            }
-        }
-    }
-}
-function applyEcmascriptMergedUpdate(update) {
-    // Browser-specific chunk management phase
-    const { entries = {}, chunks = {} } = update;
-    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks, chunkModulesMap);
-    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
-    // Use shared HMR update implementation
-    applyEcmascriptMergedUpdateShared({
-        added,
-        modified,
-        disposedModules,
-        evalModuleEntry: _eval,
-        instantiateModule,
-        applyModuleFactoryName,
-        moduleFactories,
-        devModuleCache,
-        autoAcceptRootModules: false
-    });
-}
-function handleApply(chunkListPath, update) {
-    switch(update.type){
-        case 'partial':
-            {
-                // This indicates that the update is can be applied to the current state of the application.
-                if (dynamicChunkLists.has(chunkListPath)) {
-                    if (loadingDynamicChunkLists.has(chunkListPath)) {
-                        throw new Error(`Dynamic chunk list ${chunkListPath} changed while it was loading.`);
-                    }
-                    if (update.instruction.type === 'ChunkListUpdate' && update.instruction.chunks != null) {
-                        throw new Error(`Dynamic chunk list ${chunkListPath} changed structure.`);
-                    }
-                    const hasSharedChunk = [
-                        ...chunkListChunksMap.get(chunkListPath) ?? []
-                    ].some((chunkPath)=>(chunkChunkListsMap.get(chunkPath)?.size ?? 0) > 1);
-                    if (hasSharedChunk) {
-                        throw new Error(`Dynamic chunk list ${chunkListPath} shares chunks with another active list.`);
-                    }
-                }
-                applyUpdate(update.instruction);
-                break;
-            }
-        case 'restart':
-            {
-                // This indicates that there is no way to apply the update to the
-                // current state of the application, and that the application must be
-                // restarted.
-                DEV_BACKEND.restart();
-                break;
-            }
-        case 'notFound':
-            {
-                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
-                // or the page itself was deleted.
-                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
-                // If it is a runtime chunk list, we restart the application.
-                if (runtimeChunkLists.has(chunkListPath) || dynamicChunkLists.has(chunkListPath)) {
-                    DEV_BACKEND.restart();
-                } else {
-                    disposeChunkList(chunkListPath);
-                }
-                break;
-            }
-        default:
-            throw new Error(`Unknown update type: ${update.type}`);
-    }
-}
-/**
- * Removes a module from a chunk.
- * Returns `true` if there are no remaining chunks including this module.
- */ function removeModuleFromChunk(moduleId, chunkPath) {
-    const moduleChunks = moduleChunksMap.get(moduleId);
-    moduleChunks.delete(chunkPath);
-    const chunkModules = chunkModulesMap.get(chunkPath);
-    chunkModules.delete(moduleId);
-    const noRemainingModules = chunkModules.size === 0;
-    if (noRemainingModules) {
-        chunkModulesMap.delete(chunkPath);
-    }
-    const noRemainingChunks = moduleChunks.size === 0;
-    if (noRemainingChunks) {
-        moduleChunksMap.delete(moduleId);
-    }
-    return noRemainingChunks;
-}
-/**
- * Disposes of a chunk list and its corresponding exclusive chunks.
- */ function disposeChunkList(chunkListPath) {
-    const chunkPaths = chunkListChunksMap.get(chunkListPath);
-    if (chunkPaths == null) {
-        return false;
-    }
-    chunkListChunksMap.delete(chunkListPath);
-    for (const chunkPath of chunkPaths){
-        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        chunkChunkLists.delete(chunkListPath);
-        if (chunkChunkLists.size === 0) {
-            chunkChunkListsMap.delete(chunkPath);
-            disposeChunk(chunkPath);
-        }
-    }
-    // We must also dispose of the chunk list's chunk itself to ensure it may
-    // be reloaded properly in the future.
-    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
-    DEV_BACKEND.unloadChunk?.(chunkListUrl);
-    return true;
-}
-/**
- * Disposes of a chunk and its corresponding exclusive modules.
- *
- * @returns Whether the chunk was disposed of.
- */ function disposeChunk(chunkPath) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    // This should happen whether the chunk has any modules in it or not.
-    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
-    DEV_BACKEND.unloadChunk?.(chunkUrl);
-    const chunkModules = chunkModulesMap.get(chunkPath);
-    if (chunkModules == null) {
-        return false;
-    }
-    chunkModules.delete(chunkPath);
-    for (const moduleId of chunkModules){
-        const moduleChunks = moduleChunksMap.get(moduleId);
-        moduleChunks.delete(chunkPath);
-        const noRemainingChunks = moduleChunks.size === 0;
-        if (noRemainingChunks) {
-            moduleChunksMap.delete(moduleId);
-            disposeModule(moduleId, 'clear');
-            availableModules.delete(moduleId);
-        }
-    }
-    return true;
-}
-/**
- * Adds a module to a chunk.
- */ function addModuleToChunk(moduleId, chunkPath) {
-    let moduleChunks = moduleChunksMap.get(moduleId);
-    if (!moduleChunks) {
-        moduleChunks = new Set([
-            chunkPath
-        ]);
-        moduleChunksMap.set(moduleId, moduleChunks);
-    } else {
-        moduleChunks.add(chunkPath);
-    }
-    let chunkModules = chunkModulesMap.get(chunkPath);
-    if (!chunkModules) {
-        chunkModules = new Set([
-            moduleId
-        ]);
-        chunkModulesMap.set(chunkPath, chunkModules);
-    } else {
-        chunkModules.add(moduleId);
-    }
-}
-/**
- * Marks a chunk list as a runtime chunk list. There can be more than one
- * runtime chunk list. For instance, integration tests can have multiple chunk
- * groups loaded at runtime, each with its own chunk list.
- */ function markChunkListAsRuntime(chunkListPath) {
-    runtimeChunkLists.add(chunkListPath);
-}
-function getDevChunkFromRegistration(chunk) {
-    if (typeof chunk === 'string') {
-        if (typeof document !== 'undefined') {
-            const src = document.currentScript?.getAttribute('src');
-            if (src && /[?&]hmr=/.test(src) && getPathFromScript({
-                src
-            }) === chunk) {
-                return {
-                    src
-                };
-            }
-        }
-    }
-    return getChunkFromRegistration(chunk);
-}
-function registerChunk(registration) {
-    const chunk = getDevChunkFromRegistration(registration[0]);
-    let runtimeParams;
-    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
-    if (registration.length === 2) {
-        runtimeParams = registration[1];
-    } else {
-        let chunkPath = getPathFromScript(chunk);
-        runtimeParams = undefined;
-        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
-    }
-    return BACKEND.registerChunk(chunk, runtimeParams);
-}
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-function loadVersionedInitialChunk(chunkListPath, chunkData, versionToken) {
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkListPath, getVersionedChunkUrl(getChunkPath(chunkData), versionToken));
-}
-/**
- * Subscribes to chunk list updates from the update server and applies them.
- */ function registerChunkList(chunkList) {
-    const chunkListScript = getDevChunkFromRegistration(chunkList.script);
-    const chunkListPath = getPathFromScript(chunkListScript);
-    // Adding chunks to chunk lists and vice versa.
-    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    chunkListChunksMap.set(chunkListPath, chunkPaths);
-    for (const chunkPath of chunkPaths){
-        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
-        if (!chunkChunkLists) {
-            chunkChunkLists = new Set([
-                chunkListPath
-            ]);
-            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
-        } else {
-            chunkChunkLists.add(chunkListPath);
-        }
-    }
-    if (chunkList.source === 'entry') {
-        // Entry lists keep the legacy loading and update behavior.
-        BACKEND.registerChunk(chunkListPath);
-        CHUNK_UPDATE_LISTENERS.push([
-            chunkListPath,
-            handleApply.bind(null, chunkListPath)
-        ]);
-        markChunkListAsRuntime(chunkListPath);
-        return;
-    }
-    dynamicChunkLists.add(chunkListPath);
-    if (typeof document === 'undefined') {
-        // Workers do not have the browser HMR transport. Load the manifest members
-        // directly so the dynamic import cannot wait for a subscription forever.
-        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), ()=>DEV_BACKEND.restart());
-        return;
-    }
-    loadingDynamicChunkLists.add(chunkListPath);
-    let resolveSubscribed;
-    let revalidateSubscription;
-    const subscribed = new Promise((resolve)=>{
-        resolveSubscribed = resolve;
-    });
-    CHUNK_UPDATE_LISTENERS.push([
-        chunkListPath,
-        handleApply.bind(null, chunkListPath),
-        {
-            conservative: true,
-            expectedVersion: chunkList.version,
-            onSubscribed: (revalidate)=>{
-                revalidateSubscription = revalidate;
-                resolveSubscribed();
-            }
-        }
-    ]);
-    void (async ()=>{
-        try {
-            await subscribed;
-            await Promise.all(chunkList.chunks.map((chunkData)=>{
-                const chunkPath = getChunkPath(chunkData);
-                const chunkVersion = chunkList.chunkVersions[chunkPath];
-                if (chunkVersion === undefined) {
-                    throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
-                }
-                return loadVersionedInitialChunk(chunkListPath, chunkData, chunkVersion);
-            }));
-            // Member URLs are served from the live output directory. Verify that
-            // the manifest did not change while those HTTP responses were loading.
-            await revalidateSubscription();
-            loadingDynamicChunkLists.delete(chunkListPath);
-            BACKEND.registerChunk(chunkListPath);
-        } catch  {
-            loadingDynamicChunkLists.delete(chunkListPath);
-            DEV_BACKEND.restart();
-        }
-    })();
-}
-/**
- * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
- *
- * It will be appended to the base runtime code.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
-/// <reference path="../../../shared/runtime/runtime-types.d.ts" />
-function getAssetSuffixFromScriptSrc() {
-    // TURBOPACK_ASSET_SUFFIX is set in web workers
-    if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX;
-    const src = document?.currentScript?.getAttribute?.('src') ?? '';
-    const qi = src.indexOf('?');
-    return qi >= 0 ? src.slice(qi) : '';
-}
-let BACKEND;
-/**
- * Maps chunk paths to the corresponding resolver.
- */ const chunkResolvers = new Map();
-(()=>{
-    BACKEND = {
-        async registerChunk (chunk, params) {
-            let chunkPath = getPathFromScript(chunk);
-            let chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = getOrCreateResolver(chunkUrl);
-            resolver.resolve();
-            const exactChunkUrl = getUrlFromScript(chunk);
-            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
-                getOrCreateResolver(exactChunkUrl).resolve();
-            }
-            if (params == null) {
-                return;
-            }
-            for (const otherChunkData of params.otherChunks){
-                const otherChunkPath = getChunkPath(otherChunkData);
-                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
-                // Chunk might have started loading, so we want to avoid triggering another load.
-                getOrCreateResolver(otherChunkUrl);
-            }
-            // This waits for chunks to be loaded, but also marks included items as available.
-            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
-            if (params.runtimeModuleIds.length > 0) {
-                for (const moduleId of params.runtimeModuleIds){
-                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
-                }
-            }
-        },
-        /**
-     * Loads the given chunk, and returns a promise that resolves once the chunk
-     * has been loaded.
-     */ loadChunkCached (sourceType, chunkUrl) {
-            return doLoadChunk(sourceType, chunkUrl);
-        }
-    };
-    function getOrCreateResolver(chunkUrl) {
-        let resolver = chunkResolvers.get(chunkUrl);
-        if (!resolver) {
-            let resolve;
-            let reject;
-            const promise = new Promise((innerResolve, innerReject)=>{
-                resolve = innerResolve;
-                reject = innerReject;
-            });
-            resolver = {
-                resolved: false,
-                loadingStarted: false,
-                retryAttempts: 0,
-                promise,
-                resolve: ()=>{
-                    resolver.resolved = true;
-                    resolve();
-                },
-                reject: reject
-            };
-            chunkResolvers.set(chunkUrl, resolver);
-        }
-        return resolver;
-    }
-    /**
-   * Rejects a chunk resolver and drops it from the cache.
-   * We don't want to cache failed chunk loads: a later
-   * request for the same chunk should try again.
-   */ function rejectChunkResolver(chunkUrl, resolver, error) {
-        if (chunkResolvers.get(chunkUrl) === resolver) {
-            chunkResolvers.delete(chunkUrl);
-        }
-        resolver.reject(error);
-    }
-    function getChunkLoadRetryDelayMs() {
-        const jitter = Math.floor(Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1));
-        return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter;
-    }
-    function isRetryableChunkLoadError(error) {
-        return error == null || error instanceof DOMException && error.name === 'NetworkError';
-    }
-    /**
-   * Handles a failed chunk load: retries the load once after a short delay.
-   */ function onChunkLoadError(sourceType, chunkUrl, resolver, error, reload) {
-        if (!isRetryableChunkLoadError(error) || resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS || chunkResolvers.get(chunkUrl) !== resolver) {
-            rejectChunkResolver(chunkUrl, resolver, error);
-            return;
-        }
-        resolver.retryAttempts++;
-        setTimeout(()=>{
-            // if this chunk is being fetched multiple times, and one of those
-            // attempts succeeds. or, if this chunk has another resolver
-            // mapped to it - it's safe to skip retrying.
-            if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {
-                return;
-            }
-            if (reload) {
-                reload();
-            } else {
-                resolver.loadingStarted = false;
-                doLoadChunk(sourceType, chunkUrl);
-            }
-        }, getChunkLoadRetryDelayMs());
-    }
-    /**
-   * Loads the given chunk, and returns a promise that resolves once the chunk
-   * has been loaded.
-   */ function doLoadChunk(sourceType, chunkUrl) {
-        const resolver = getOrCreateResolver(chunkUrl);
-        if (resolver.loadingStarted) {
-            return resolver.promise;
-        }
-        if (sourceType === SourceType.Runtime) {
-            // CSS chunks do not register themselves, and as such must be marked as
-            // loaded instantly.
-            resolver.loadingStarted = true;
-            if (isCss(chunkUrl)) {
-                if (typeof importScripts !== 'function') {
-                    const decodedChunkUrl = decodeURI(chunkUrl);
-                    const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
-                    if (previousLinks.length === 0) {
-                        const link = document.createElement('link');
-                        link.rel = 'stylesheet';
-                        link.crossOrigin = CROSS_ORIGIN;
-                        link.href = chunkUrl;
-                        link.onerror = ()=>{
-                            resolver.reject();
-                        };
-                        link.onload = ()=>{
-                            resolver.resolve();
-                        };
-                        document.head.appendChild(link);
-                        return resolver.promise;
-                    }
-                }
-                resolver.resolve();
-                return resolver.promise;
-            }
-            // Runtime JS chunks are expected to be present in the DOM already.
-            // Load it first
-            if (typeof importScripts !== 'function') {
-                const decodedChunkUrl = decodeURI(chunkUrl);
-                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
-                if (previousScripts.length > 0) {
-                    for (const script of Array.from(previousScripts)){
-                        script.addEventListener('error', ()=>{
-                            resolver.reject();
-                        });
-                    }
-                    return resolver.promise;
-                }
-            }
-        // If it wasn't present in the DOM, fallback to loading logic.
-        }
-        if (typeof importScripts === 'function') {
-            // We're in a web worker
-            if (isCss(chunkUrl)) {
-            // ignore
-            } else if (isJs(chunkUrl)) {
-                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
-                try {
-                    importScripts(chunkUrl);
-                } catch (error) {
-                    onChunkLoadError(sourceType, chunkUrl, resolver, error);
-                }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
-            }
-        } else {
-            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-            const decodedChunkUrl = decodeURI(chunkUrl);
-            if (isCss(chunkUrl)) {
-                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
-                if (previousLinks.length > 0) {
-                    // CSS chunks do not register themselves, and as such must be marked as
-                    // loaded instantly.
-                    resolver.resolve();
-                } else {
-                    const createLink = ()=>{
-                        const link = document.createElement('link');
-                        link.rel = 'stylesheet';
-                        link.crossOrigin = CROSS_ORIGIN;
-                        link.href = chunkUrl;
-                        link.onerror = ()=>{
-                            // Re-insert a fresh tag at the same position on retry to preserve
-                            // cascade order.
-                            const anchor = document.createComment('');
-                            link.replaceWith(anchor);
-                            onChunkLoadError(sourceType, chunkUrl, resolver, undefined, ()=>anchor.replaceWith(createLink()));
-                        };
-                        link.onload = ()=>{
-                            // CSS chunks do not register themselves, and as such must be marked as
-                            // loaded instantly.
-                            resolver.resolve();
-                        };
-                        return link;
-                    };
-                    // Append to the `head` for webpack compatibility.
-                    document.head.appendChild(createLink());
-                }
-            } else if (isJs(chunkUrl)) {
-                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
-                if (previousScripts.length > 0) {
-                    for (const script of Array.from(previousScripts)){
-                        script.addEventListener('error', ()=>{
-                            // Drop the failed tag so a retry can re-add it cleanly.
-                            script.remove();
-                            onChunkLoadError(sourceType, chunkUrl, resolver);
-                        }, {
-                            once: true
-                        });
-                    }
-                } else {
-                    const script = document.createElement('script');
-                    script.crossOrigin = CROSS_ORIGIN;
-                    script.src = chunkUrl;
-                    // We'll only mark the chunk as loaded once the script has been executed,
-                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
-                    // this branch.
-                    script.onerror = ()=>{
-                        // Drop the failed tag so a retry can re-add it cleanly.
-                        script.remove();
-                        onChunkLoadError(sourceType, chunkUrl, resolver);
-                    };
-                    // Append to the `head` for webpack compatibility.
-                    document.head.appendChild(script);
-                }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-            }
-        }
-        resolver.loadingStarted = true;
-        return resolver.promise;
-    }
-})();
-/**
- * This file contains the runtime code specific to the Turbopack development
- * ECMAScript DOM runtime.
- *
- * It will be appended to the base development runtime code.
- */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
-/// <reference path="../base/dev-base.ts" />
-/// <reference path="./runtime-backend-dom.ts" />
-/// <reference path="../../../shared/require-type.d.ts" />
-let DEV_BACKEND;
-(()=>{
-    DEV_BACKEND = {
-        unloadChunk (chunkUrl) {
-            deleteResolver(chunkUrl);
-            // Strip query string so we match links regardless of cache-busting
-            // params (e.g. ?ts=) that may differ between HMR updates.
-            const baseChunkUrl = chunkUrl.split('?')[0];
-            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-            const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            if (isCss(chunkUrl)) {
-                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
-                for (const link of Array.from(links)){
-                    link.remove();
-                }
-            } else if (isJs(chunkUrl)) {
-                // Unloading a JS chunk would have no effect, as it lives in the JS
-                // runtime once evaluated.
-                // However, we still want to remove the script tag from the DOM to keep
-                // the HTML somewhat consistent from the user's perspective.
-                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
-                for (const script of Array.from(scripts)){
-                    script.remove();
-                }
-            } else {
-                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-            }
-        },
-        reloadChunk (chunkUrl) {
-            return new Promise((resolve, reject)=>{
-                if (!isCss(chunkUrl)) {
-                    reject(new Error('The DOM backend can only reload CSS chunks'));
-                    return;
-                }
-                // Strip query string so we match links regardless of cache-busting
-                // params (e.g. ?ts=) that may differ between HMR updates.
-                const baseChunkUrl = chunkUrl.split('?')[0];
-                const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-                if (previousLinks.length === 0) {
-                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
-                    return;
-                }
-                const link = document.createElement('link');
-                link.rel = 'stylesheet';
-                link.crossOrigin = CROSS_ORIGIN;
-                if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
-                    // Firefox won't reload CSS files that were previously loaded on the
-                    // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
-                    //
-                    // Safari serves cached CSS when a <link rel=preload> exists for the
-                    // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726
-                    //
-                    // Replace or add a fresh `ts` cache-busting param without
-                    // discarding other query parameters that may already be present.
-                    const url = new URL(chunkUrl, location.origin);
-                    // Reduced timer precision in some browers could lead to an update getting dropped
-                    // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).
-                    // So trust that the server is only updating us when it is important and use a
-                    // random number to bust the cache.
-                    url.searchParams.set('ts', `${Date.now()}.${Math.random()}`);
-                    link.href = url.pathname + url.search;
-                } else {
-                    link.href = chunkUrl;
-                }
-                link.onerror = ()=>{
-                    reject();
-                };
-                link.onload = ()=>{
-                    // First load the new CSS, then remove the old ones. This prevents visible
-                    // flickering that would happen in-between removing the previous CSS and
-                    // loading the new one.
-                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
-                    // CSS chunks do not register themselves, and as such must be marked as
-                    // loaded instantly.
-                    resolve();
-                };
-                // Make sure to insert the new CSS right after the previous one, so that
-                // its precedence is higher.
-                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
-            });
-        },
-        restart: ()=>self.location.reload()
-    };
-    function deleteResolver(chunkUrl) {
-        chunkResolvers.delete(chunkUrl);
-    }
-})();
-function _eval({ code, url, map }) {
-    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX)}`;
-    if (map) {
-        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
-        // See https://stackoverflow.com/a/26603875
-        unescape(encodeURIComponent(map)))}`;
-    }
-    // eslint-disable-next-line no-eval
-    return eval(code);
-}
-var chunksToRegister = globalThis["TURBOPACK"];
-globalThis["TURBOPACK"] = { push: registerChunk };
-chunksToRegister.forEach(registerChunk);
-var chunkListsToRegister = globalThis["TURBOPACK_CHUNK_LISTS"] || [];
-globalThis["TURBOPACK_CHUNK_LISTS"] = { push: registerChunkList };
-chunkListsToRegister.forEach(registerChunkList);
-})();
\ No newline at end of file

From b3e11357d7bc04e2e026441811d812ff9f22eab2 Mon Sep 17 00:00:00 2001
From: fireairforce <1344492820@qq.com>
Date: Fri, 24 Jul 2026 18:57:31 +0800
Subject: [PATCH 11/11] test(pack): sync runtime snapshots

---
 .../snapshot/externals/basic/output/main.js   |   4 +
 .../externals/basic/output/main.js.map        |   2 +-
 .../snapshot/public_path/auto/output/main.js  |   4 +
 .../public_path/auto/output/main.js.map       |   2 +-
 .../snapshot/public_path/basic/output/main.js |   4 +
 .../public_path/basic/output/main.js.map      |   2 +-
 .../public_path/runtime/output/main.js        |   4 +
 .../public_path/runtime/output/main.js.map    |   2 +-
 .../runtime/app_build_runtime/output/main.js  |   4 +
 .../app_build_runtime/output/main.js.map      |   2 +-
 .../runtime/app_dev_runtime/output/main.js    | 996 +++---------------
 .../app_dev_runtime/output/main.js.map        |   6 +-
 .../output/main.js                            |   4 +
 .../output/main.js.map                        |   2 +-
 .../export_entry_exports/output/main.js       |   4 +
 .../export_entry_exports/output/main.js.map   |   2 +-
 16 files changed, 174 insertions(+), 870 deletions(-)

diff --git a/crates/pack-tests/tests/snapshot/externals/basic/output/main.js b/crates/pack-tests/tests/snapshot/externals/basic/output/main.js
index 529efc903..e577587e6 100644
--- a/crates/pack-tests/tests/snapshot/externals/basic/output/main.js
+++ b/crates/pack-tests/tests/snapshot/externals/basic/output/main.js
@@ -1038,6 +1038,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/externals/basic/output/main.js.map b/crates/pack-tests/tests/snapshot/externals/basic/output/main.js.map
index bc35dd990..4b117e2c6 100644
--- a/crates/pack-tests/tests/snapshot/externals/basic/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/externals/basic/output/main.js.map
@@ -7,5 +7,5 @@
     {"offset": {"line": 640, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 904, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
     {"offset": {"line": 975, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/base-externals-utils.ts"],"sourcesContent":["/// <reference path=\"../shared/runtime/runtime-utils.ts\" />\n\n/// A 'base' utilities to support runtime can have externals.\n/// Currently this is for node.js / edge runtime both.\n/// If a fn requires node.js specific behavior, it should be placed in `node-external-utils` instead.\n\nasync function externalImport(id: DependencySpecifier) {\n  let raw\n  try {\n    raw = await import(id)\n  } catch (err) {\n    // TODO(alexkirsz) This can happen when a client-side module tries to load\n    // an external module we don't provide a shim for (e.g. querystring, url).\n    // For now, we fail semi-silently, but in the future this should be a\n    // compilation error.\n    throw new Error(`Failed to load external module ${id}: ${err}`)\n  }\n\n  if (raw && raw.__esModule && raw.default && 'default' in raw.default) {\n    return interopEsm(raw.default, createNS(raw), true)\n  }\n\n  return raw\n}\ncontextPrototype.y = externalImport\n\nfunction externalRequire(\n  id: ModuleId,\n  thunk: () => any,\n  esm: boolean = false\n): Exports | EsmNamespaceObject {\n  let raw\n  try {\n    raw = thunk()\n  } catch (err) {\n    // TODO(alexkirsz) This can happen when a client-side module tries to load\n    // an external module we don't provide a shim for (e.g. querystring, url).\n    // For now, we fail semi-silently, but in the future this should be a\n    // compilation error.\n    throw new Error(`Failed to load external module ${id}: ${err}`)\n  }\n\n  if (!esm || raw.__esModule) {\n    return raw\n  }\n\n  return interopEsm(raw, createNS(raw), true)\n}\n\nexternalRequire.resolve = (\n  id: string,\n  options?: {\n    paths?: string[]\n  }\n) => {\n  return require.resolve(id, options)\n}\ncontextPrototype.x = externalRequire\n"],"names":["externalImport","id","raw","err","Error","__esModule","default","interopEsm","createNS","contextPrototype","y","externalRequire","thunk","esm","resolve","options","require","x"],"mappings":"AAAA,2DAA2D;AAE3D,6DAA6D;AAC7D,sDAAsD;AACtD,qGAAqG;AAErG,eAAeA,eAAeC,EAAuB;IACnD,IAAIC;IACJ,IAAI;QACFA,MAAM,MAAM,MAAM,CAACD;IACrB,EAAE,OAAOE,KAAK;QACZ,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,qBAAqB;QACrB,MAAM,IAAIC,MAAM,CAAC,+BAA+B,EAAEH,GAAG,EAAE,EAAEE,KAAK;IAChE;IAEA,IAAID,OAAOA,IAAIG,UAAU,IAAIH,IAAII,OAAO,IAAI,aAAaJ,IAAII,OAAO,EAAE;QACpE,OAAOC,WAAWL,IAAII,OAAO,EAAEE,SAASN,MAAM;IAChD;IAEA,OAAOA;AACT;AACAO,iBAAiBC,CAAC,GAAGV;AAErB,SAASW,gBACPV,EAAY,EACZW,KAAgB,EAChBC,MAAe,KAAK;IAEpB,IAAIX;IACJ,IAAI;QACFA,MAAMU;IACR,EAAE,OAAOT,KAAK;QACZ,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,qBAAqB;QACrB,MAAM,IAAIC,MAAM,CAAC,+BAA+B,EAAEH,GAAG,EAAE,EAAEE,KAAK;IAChE;IAEA,IAAI,CAACU,OAAOX,IAAIG,UAAU,EAAE;QAC1B,OAAOH;IACT;IAEA,OAAOK,WAAWL,KAAKM,SAASN,MAAM;AACxC;AAEAS,gBAAgBG,OAAO,GAAG,CACxBb,IACAc;IAIA,OAAOC,QAAQF,OAAO,CAACb,IAAIc;AAC7B;AACAN,iBAAiBQ,CAAC,GAAGN","ignoreList":[0]}},
-    {"offset": {"line": 1016, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 1016, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js b/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js
index b4164a77c..1fcaaddc4 100644
--- a/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js
+++ b/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js
@@ -865,6 +865,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js.map b/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js.map
index 19165db43..b787f61ba 100644
--- a/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/public_path/auto/output/main.js.map
@@ -5,5 +5,5 @@
     {"offset": {"line": 19, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./async-module.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n/**\n * Describes why a module was instantiated.\n * Shared between browser and Node.js runtimes.\n */\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\n// @ts-ignore Defined in `hmr-runtime.ts` (dev mode only)\ndeclare let devModuleCache: Record<ModuleId, any> | undefined\n\n/**\n * Flag indicating which module object type to create when a module is merged. Set to `true`\n * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,\n * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it\n * uses plain Module objects.\n */\nlet createModuleWithDirectionFlag = false\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    if (createModuleWithDirectionFlag) {\n      // set in development modes for hmr support\n      module = createModuleWithDirection(id)\n    } else {\n      module = createModuleObject(id)\n    }\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\nfunction createModuleWithDirection(id: ModuleId): ModuleWithDirection {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n    parents: [],\n    children: [],\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n\n    // Install the factory for each module ID that doesn't already have one.\n    // When some IDs in this group already have a factory, reuse that existing\n    // group factory for the missing IDs to keep all IDs in the group consistent.\n    // Otherwise, install the factory from this chunk.\n    const moduleFactoryFn = chunkModules[end] as Function\n    let existingGroupFactory: Function | undefined = undefined\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      const existingFactory = moduleFactories.get(id)\n      if (existingFactory) {\n        existingGroupFactory = existingFactory\n        break\n      }\n    }\n    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn\n\n    let didInstallFactory = false\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      if (!moduleFactories.has(id)) {\n        if (!didInstallFactory) {\n          if (factoryToInstall === moduleFactoryFn) {\n            applyModuleFactoryName(moduleFactoryFn)\n          }\n          didInstallFactory = true\n        }\n        moduleFactories.set(id, factoryToInstall)\n        newModuleId?.(id)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * Constructs an error message for when a module factory is not available.\n */\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason: string\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\nlet cachedAutomaticPublicPath: string | undefined\n\nfunction getAutomaticPublicPath(): string {\n  if (cachedAutomaticPublicPath !== undefined) {\n    return cachedAutomaticPublicPath\n  }\n\n  let scriptUrl: string | undefined\n  if (typeof document === 'object') {\n    const currentScript = document.currentScript as HTMLScriptElement | null\n    scriptUrl = currentScript?.src\n\n    if (!scriptUrl) {\n      const scripts = document.getElementsByTagName('script')\n      const script = scripts[scripts.length - 1]\n      scriptUrl = script?.src\n    }\n  }\n\n  if (\n    !scriptUrl &&\n    typeof (globalThis as any).importScripts === 'function' &&\n    (globalThis as any).location\n  ) {\n    scriptUrl = String((globalThis as any).location)\n  }\n\n  cachedAutomaticPublicPath = scriptUrl\n    ? scriptUrl\n        .replace(/^blob:/, '')\n        .replace(/#.*$/, '')\n        .replace(/\\?.*$/, '')\n        .replace(/\\/[^/]*$/, '/')\n    : ''\n\n  return cachedAutomaticPublicPath\n}\n\n/**\n * Gets the public path for runtime assets.\n * Checks globalThis.publicPath and falls back to \"/\".\n */\nfunction getPublicPath(mode?: 'auto'): string {\n  if (mode === 'auto') {\n    return getAutomaticPublicPath()\n  }\n\n  if (\n    typeof globalThis !== 'undefined' &&\n    typeof (globalThis as any).publicPath === 'string'\n  ) {\n    const publicPath = (globalThis as any).publicPath as string\n    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`\n  }\n  return '/'\n}\ncontextPrototype.p = getPublicPath\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["SourceType","createModuleWithDirectionFlag","REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleWithDirection","createModuleObject","error","undefined","namespaceObject","parents","children","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","moduleFactoryFn","existingGroupFactory","existingFactory","factoryToInstall","didInstallFactory","has","applyModuleFactoryName","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","factoryNotAvailableMessage","sourceType","sourceData","instantiationReason","requireStub","_moduleId","z","g","globalThis","cachedAutomaticPublicPath","getAutomaticPublicPath","scriptUrl","document","currentScript","src","scripts","getElementsByTagName","script","importScripts","location","String","getPublicPath","mode","publicPath","endsWith","p","factory"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 508, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 772, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
-    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js b/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js
index 507ba1c52..b1998f28a 100644
--- a/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js
+++ b/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js
@@ -865,6 +865,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js.map b/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js.map
index 19165db43..b787f61ba 100644
--- a/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/public_path/basic/output/main.js.map
@@ -5,5 +5,5 @@
     {"offset": {"line": 19, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./async-module.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n/**\n * Describes why a module was instantiated.\n * Shared between browser and Node.js runtimes.\n */\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\n// @ts-ignore Defined in `hmr-runtime.ts` (dev mode only)\ndeclare let devModuleCache: Record<ModuleId, any> | undefined\n\n/**\n * Flag indicating which module object type to create when a module is merged. Set to `true`\n * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,\n * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it\n * uses plain Module objects.\n */\nlet createModuleWithDirectionFlag = false\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    if (createModuleWithDirectionFlag) {\n      // set in development modes for hmr support\n      module = createModuleWithDirection(id)\n    } else {\n      module = createModuleObject(id)\n    }\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\nfunction createModuleWithDirection(id: ModuleId): ModuleWithDirection {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n    parents: [],\n    children: [],\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n\n    // Install the factory for each module ID that doesn't already have one.\n    // When some IDs in this group already have a factory, reuse that existing\n    // group factory for the missing IDs to keep all IDs in the group consistent.\n    // Otherwise, install the factory from this chunk.\n    const moduleFactoryFn = chunkModules[end] as Function\n    let existingGroupFactory: Function | undefined = undefined\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      const existingFactory = moduleFactories.get(id)\n      if (existingFactory) {\n        existingGroupFactory = existingFactory\n        break\n      }\n    }\n    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn\n\n    let didInstallFactory = false\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      if (!moduleFactories.has(id)) {\n        if (!didInstallFactory) {\n          if (factoryToInstall === moduleFactoryFn) {\n            applyModuleFactoryName(moduleFactoryFn)\n          }\n          didInstallFactory = true\n        }\n        moduleFactories.set(id, factoryToInstall)\n        newModuleId?.(id)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * Constructs an error message for when a module factory is not available.\n */\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason: string\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\nlet cachedAutomaticPublicPath: string | undefined\n\nfunction getAutomaticPublicPath(): string {\n  if (cachedAutomaticPublicPath !== undefined) {\n    return cachedAutomaticPublicPath\n  }\n\n  let scriptUrl: string | undefined\n  if (typeof document === 'object') {\n    const currentScript = document.currentScript as HTMLScriptElement | null\n    scriptUrl = currentScript?.src\n\n    if (!scriptUrl) {\n      const scripts = document.getElementsByTagName('script')\n      const script = scripts[scripts.length - 1]\n      scriptUrl = script?.src\n    }\n  }\n\n  if (\n    !scriptUrl &&\n    typeof (globalThis as any).importScripts === 'function' &&\n    (globalThis as any).location\n  ) {\n    scriptUrl = String((globalThis as any).location)\n  }\n\n  cachedAutomaticPublicPath = scriptUrl\n    ? scriptUrl\n        .replace(/^blob:/, '')\n        .replace(/#.*$/, '')\n        .replace(/\\?.*$/, '')\n        .replace(/\\/[^/]*$/, '/')\n    : ''\n\n  return cachedAutomaticPublicPath\n}\n\n/**\n * Gets the public path for runtime assets.\n * Checks globalThis.publicPath and falls back to \"/\".\n */\nfunction getPublicPath(mode?: 'auto'): string {\n  if (mode === 'auto') {\n    return getAutomaticPublicPath()\n  }\n\n  if (\n    typeof globalThis !== 'undefined' &&\n    typeof (globalThis as any).publicPath === 'string'\n  ) {\n    const publicPath = (globalThis as any).publicPath as string\n    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`\n  }\n  return '/'\n}\ncontextPrototype.p = getPublicPath\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["SourceType","createModuleWithDirectionFlag","REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleWithDirection","createModuleObject","error","undefined","namespaceObject","parents","children","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","moduleFactoryFn","existingGroupFactory","existingFactory","factoryToInstall","didInstallFactory","has","applyModuleFactoryName","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","factoryNotAvailableMessage","sourceType","sourceData","instantiationReason","requireStub","_moduleId","z","g","globalThis","cachedAutomaticPublicPath","getAutomaticPublicPath","scriptUrl","document","currentScript","src","scripts","getElementsByTagName","script","importScripts","location","String","getPublicPath","mode","publicPath","endsWith","p","factory"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 508, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 772, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
-    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js b/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js
index 95643b735..68f218bee 100644
--- a/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js
+++ b/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js
@@ -865,6 +865,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js.map b/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js.map
index 19165db43..b787f61ba 100644
--- a/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/public_path/runtime/output/main.js.map
@@ -5,5 +5,5 @@
     {"offset": {"line": 19, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./async-module.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n/**\n * Describes why a module was instantiated.\n * Shared between browser and Node.js runtimes.\n */\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\n// @ts-ignore Defined in `hmr-runtime.ts` (dev mode only)\ndeclare let devModuleCache: Record<ModuleId, any> | undefined\n\n/**\n * Flag indicating which module object type to create when a module is merged. Set to `true`\n * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,\n * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it\n * uses plain Module objects.\n */\nlet createModuleWithDirectionFlag = false\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    if (createModuleWithDirectionFlag) {\n      // set in development modes for hmr support\n      module = createModuleWithDirection(id)\n    } else {\n      module = createModuleObject(id)\n    }\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\nfunction createModuleWithDirection(id: ModuleId): ModuleWithDirection {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n    parents: [],\n    children: [],\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n\n    // Install the factory for each module ID that doesn't already have one.\n    // When some IDs in this group already have a factory, reuse that existing\n    // group factory for the missing IDs to keep all IDs in the group consistent.\n    // Otherwise, install the factory from this chunk.\n    const moduleFactoryFn = chunkModules[end] as Function\n    let existingGroupFactory: Function | undefined = undefined\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      const existingFactory = moduleFactories.get(id)\n      if (existingFactory) {\n        existingGroupFactory = existingFactory\n        break\n      }\n    }\n    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn\n\n    let didInstallFactory = false\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      if (!moduleFactories.has(id)) {\n        if (!didInstallFactory) {\n          if (factoryToInstall === moduleFactoryFn) {\n            applyModuleFactoryName(moduleFactoryFn)\n          }\n          didInstallFactory = true\n        }\n        moduleFactories.set(id, factoryToInstall)\n        newModuleId?.(id)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * Constructs an error message for when a module factory is not available.\n */\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason: string\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\nlet cachedAutomaticPublicPath: string | undefined\n\nfunction getAutomaticPublicPath(): string {\n  if (cachedAutomaticPublicPath !== undefined) {\n    return cachedAutomaticPublicPath\n  }\n\n  let scriptUrl: string | undefined\n  if (typeof document === 'object') {\n    const currentScript = document.currentScript as HTMLScriptElement | null\n    scriptUrl = currentScript?.src\n\n    if (!scriptUrl) {\n      const scripts = document.getElementsByTagName('script')\n      const script = scripts[scripts.length - 1]\n      scriptUrl = script?.src\n    }\n  }\n\n  if (\n    !scriptUrl &&\n    typeof (globalThis as any).importScripts === 'function' &&\n    (globalThis as any).location\n  ) {\n    scriptUrl = String((globalThis as any).location)\n  }\n\n  cachedAutomaticPublicPath = scriptUrl\n    ? scriptUrl\n        .replace(/^blob:/, '')\n        .replace(/#.*$/, '')\n        .replace(/\\?.*$/, '')\n        .replace(/\\/[^/]*$/, '/')\n    : ''\n\n  return cachedAutomaticPublicPath\n}\n\n/**\n * Gets the public path for runtime assets.\n * Checks globalThis.publicPath and falls back to \"/\".\n */\nfunction getPublicPath(mode?: 'auto'): string {\n  if (mode === 'auto') {\n    return getAutomaticPublicPath()\n  }\n\n  if (\n    typeof globalThis !== 'undefined' &&\n    typeof (globalThis as any).publicPath === 'string'\n  ) {\n    const publicPath = (globalThis as any).publicPath as string\n    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`\n  }\n  return '/'\n}\ncontextPrototype.p = getPublicPath\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["SourceType","createModuleWithDirectionFlag","REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleWithDirection","createModuleObject","error","undefined","namespaceObject","parents","children","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","moduleFactoryFn","existingGroupFactory","existingFactory","factoryToInstall","didInstallFactory","has","applyModuleFactoryName","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","factoryNotAvailableMessage","sourceType","sourceData","instantiationReason","requireStub","_moduleId","z","g","globalThis","cachedAutomaticPublicPath","getAutomaticPublicPath","scriptUrl","document","currentScript","src","scripts","getElementsByTagName","script","importScripts","location","String","getPublicPath","mode","publicPath","endsWith","p","factory"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 508, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 772, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
-    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js b/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js
index a8e4498c4..16f6db595 100644
--- a/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js
+++ b/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js
@@ -865,6 +865,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js.map b/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js.map
index 19165db43..b787f61ba 100644
--- a/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/runtime/app_build_runtime/output/main.js.map
@@ -5,5 +5,5 @@
     {"offset": {"line": 19, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./async-module.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n/**\n * Describes why a module was instantiated.\n * Shared between browser and Node.js runtimes.\n */\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\n// @ts-ignore Defined in `hmr-runtime.ts` (dev mode only)\ndeclare let devModuleCache: Record<ModuleId, any> | undefined\n\n/**\n * Flag indicating which module object type to create when a module is merged. Set to `true`\n * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,\n * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it\n * uses plain Module objects.\n */\nlet createModuleWithDirectionFlag = false\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    if (createModuleWithDirectionFlag) {\n      // set in development modes for hmr support\n      module = createModuleWithDirection(id)\n    } else {\n      module = createModuleObject(id)\n    }\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\nfunction createModuleWithDirection(id: ModuleId): ModuleWithDirection {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n    parents: [],\n    children: [],\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n\n    // Install the factory for each module ID that doesn't already have one.\n    // When some IDs in this group already have a factory, reuse that existing\n    // group factory for the missing IDs to keep all IDs in the group consistent.\n    // Otherwise, install the factory from this chunk.\n    const moduleFactoryFn = chunkModules[end] as Function\n    let existingGroupFactory: Function | undefined = undefined\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      const existingFactory = moduleFactories.get(id)\n      if (existingFactory) {\n        existingGroupFactory = existingFactory\n        break\n      }\n    }\n    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn\n\n    let didInstallFactory = false\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      if (!moduleFactories.has(id)) {\n        if (!didInstallFactory) {\n          if (factoryToInstall === moduleFactoryFn) {\n            applyModuleFactoryName(moduleFactoryFn)\n          }\n          didInstallFactory = true\n        }\n        moduleFactories.set(id, factoryToInstall)\n        newModuleId?.(id)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * Constructs an error message for when a module factory is not available.\n */\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason: string\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\nlet cachedAutomaticPublicPath: string | undefined\n\nfunction getAutomaticPublicPath(): string {\n  if (cachedAutomaticPublicPath !== undefined) {\n    return cachedAutomaticPublicPath\n  }\n\n  let scriptUrl: string | undefined\n  if (typeof document === 'object') {\n    const currentScript = document.currentScript as HTMLScriptElement | null\n    scriptUrl = currentScript?.src\n\n    if (!scriptUrl) {\n      const scripts = document.getElementsByTagName('script')\n      const script = scripts[scripts.length - 1]\n      scriptUrl = script?.src\n    }\n  }\n\n  if (\n    !scriptUrl &&\n    typeof (globalThis as any).importScripts === 'function' &&\n    (globalThis as any).location\n  ) {\n    scriptUrl = String((globalThis as any).location)\n  }\n\n  cachedAutomaticPublicPath = scriptUrl\n    ? scriptUrl\n        .replace(/^blob:/, '')\n        .replace(/#.*$/, '')\n        .replace(/\\?.*$/, '')\n        .replace(/\\/[^/]*$/, '/')\n    : ''\n\n  return cachedAutomaticPublicPath\n}\n\n/**\n * Gets the public path for runtime assets.\n * Checks globalThis.publicPath and falls back to \"/\".\n */\nfunction getPublicPath(mode?: 'auto'): string {\n  if (mode === 'auto') {\n    return getAutomaticPublicPath()\n  }\n\n  if (\n    typeof globalThis !== 'undefined' &&\n    typeof (globalThis as any).publicPath === 'string'\n  ) {\n    const publicPath = (globalThis as any).publicPath as string\n    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`\n  }\n  return '/'\n}\ncontextPrototype.p = getPublicPath\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["SourceType","createModuleWithDirectionFlag","REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleWithDirection","createModuleObject","error","undefined","namespaceObject","parents","children","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","moduleFactoryFn","existingGroupFactory","existingFactory","factoryToInstall","didInstallFactory","has","applyModuleFactoryName","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","factoryNotAvailableMessage","sourceType","sourceData","instantiationReason","requireStub","_moduleId","z","g","globalThis","cachedAutomaticPublicPath","getAutomaticPublicPath","scriptUrl","document","currentScript","src","scripts","getElementsByTagName","script","importScripts","location","String","getPublicPath","mode","publicPath","endsWith","p","factory"],"mappings":"AAAA;;;;;CAKC,GAED,oDAAoD,GAEpD,6CAA6C;AAC7C,0CAA0C;AAI1C;;;CAGC,GACD,IAAA,AAAKA,oCAAAA;IACH;;;;GAIC;IAED;;;GAGC;IAED;;;;GAIC;WAhBEA;EAAAA;AA+BL;;;;;CAKC,GACD,IAAIC,gCAAgC;AAEpC,MAAMC,qBAAqB,IAAIC;AAE/B;;CAEC,GACD,SAASC,QAEPC,MAAc,EACdC,OAAgB;IAEhB,IAAI,CAACC,CAAC,GAAGF;IACT,gFAAgF;IAChF,yEAAyE;IACzE,+CAA+C;IAC/C,8EAA8E;IAC9E,sEAAsE;IACtE,iBAAiB;IACjB,4FAA4F;IAC5F,IAAI,CAACG,CAAC,GAAGF;AACX;AACA,MAAMG,mBAAmBL,QAAQM,SAAS;AA+B1C,MAAMC,iBAAiBC,OAAOF,SAAS,CAACC,cAAc;AACtD,MAAME,cAAc,OAAOC,WAAW,eAAeA,OAAOD,WAAW;AAEvE,SAASE,WACPC,GAAQ,EACRC,IAAiB,EACjBC,OAA2C;IAE3C,IAAI,CAACP,eAAeQ,IAAI,CAACH,KAAKC,OAAOL,OAAOQ,cAAc,CAACJ,KAAKC,MAAMC;AACxE;AAEA,SAASG,qBACPC,WAAgC,EAChCC,EAAY;IAEZ,IAAIlB,SAASiB,WAAW,CAACC,GAAG;IAC5B,IAAI,CAAClB,QAAQ;QACX,IAAIJ,+BAA+B;YACjC,2CAA2C;YAC3CI,SAASmB,0BAA0BD;QACrC,OAAO;YACLlB,SAASoB,mBAAmBF;QAC9B;QACAD,WAAW,CAACC,GAAG,GAAGlB;IACpB;IACA,OAAOA;AACT;AAEA;;CAEC,GACD,SAASoB,mBAAmBF,EAAY;IACtC,OAAO;QACLjB,SAAS,CAAC;QACVoB,OAAOC;QACPJ;QACAK,iBAAiBD;IACnB;AACF;AAEA,SAASH,0BAA0BD,EAAY;IAC7C,OAAO;QACLjB,SAAS,CAAC;QACVoB,OAAOC;QACPJ;QACAK,iBAAiBD;QACjBE,SAAS,EAAE;QACXC,UAAU,EAAE;IACd;AACF;AAGA,MAAMC,mBAAmB;AAUzB;;CAEC,GACD,SAASC,IAAI1B,OAAgB,EAAE2B,QAAqB;IAClDlB,WAAWT,SAAS,cAAc;QAAE4B,OAAO;IAAK;IAChD,IAAIrB,aAAaE,WAAWT,SAASO,aAAa;QAAEqB,OAAO;IAAS;IACpE,IAAIC,IAAI;IACR,MAAOA,IAAIF,SAASG,MAAM,CAAE;QAC1B,MAAMC,WAAWJ,QAAQ,CAACE,IAAI;QAC9B,MAAMG,gBAAgBL,QAAQ,CAACE,IAAI;QACnC,IAAI,OAAOG,kBAAkB,UAAU;YACrC,IAAIA,kBAAkBP,kBAAkB;gBACtChB,WAAWT,SAAS+B,UAAU;oBAC5BH,OAAOD,QAAQ,CAACE,IAAI;oBACpBI,YAAY;oBACZC,UAAU;gBACZ;YACF,OAAO;gBACL,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEH,eAAe;YACpD;QACF,OAAO;YACL,MAAMI,WAAWJ;YACjB,IAAI,OAAOL,QAAQ,CAACE,EAAE,KAAK,YAAY;gBACrC,MAAMQ,WAAWV,QAAQ,CAACE,IAAI;gBAC9BpB,WAAWT,SAAS+B,UAAU;oBAC5BO,KAAKF;oBACLG,KAAKF;oBACLJ,YAAY;gBACd;YACF,OAAO;gBACLxB,WAAWT,SAAS+B,UAAU;oBAC5BO,KAAKF;oBACLH,YAAY;gBACd;YACF;QACF;IACF;IACA3B,OAAOkC,IAAI,CAACxC;AACd;AAEA;;CAEC,GACD,SAASyC,UAEPd,QAAqB,EACrBV,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAAC2B,CAAC,EAAEzB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACAH,OAAOuB,eAAe,GAAGtB;IACzB0B,IAAI1B,SAAS2B;AACf;AACAxB,iBAAiBwC,CAAC,GAAGF;AAGrB,SAASG,qBACP7C,MAAc,EACdC,OAAgB;IAEhB,IAAI6C,oBACFjD,mBAAmB0C,GAAG,CAACvC;IAEzB,IAAI,CAAC8C,mBAAmB;QACtBjD,mBAAmB2C,GAAG,CAACxC,QAAS8C,oBAAoB,EAAE;QACtD9C,OAAOC,OAAO,GAAGD,OAAOuB,eAAe,GAAG,IAAIwB,MAAM9C,SAAS;YAC3DsC,KAAIS,MAAM,EAAEC,IAAI;gBACd,IACE3C,eAAeQ,IAAI,CAACkC,QAAQC,SAC5BA,SAAS,aACTA,SAAS,cACT;oBACA,OAAOC,QAAQX,GAAG,CAACS,QAAQC;gBAC7B;gBACA,KAAK,MAAMtC,OAAOmC,kBAAoB;oBACpC,MAAMjB,QAAQqB,QAAQX,GAAG,CAAC5B,KAAKsC;oBAC/B,IAAIpB,UAAUP,WAAW,OAAOO;gBAClC;gBACA,OAAOP;YACT;YACA6B,SAAQH,MAAM;gBACZ,MAAMI,OAAOF,QAAQC,OAAO,CAACH;gBAC7B,KAAK,MAAMrC,OAAOmC,kBAAoB;oBACpC,KAAK,MAAMO,OAAOH,QAAQC,OAAO,CAACxC,KAAM;wBACtC,IAAI0C,QAAQ,aAAa,CAACD,KAAKE,QAAQ,CAACD,MAAMD,KAAKG,IAAI,CAACF;oBAC1D;gBACF;gBACA,OAAOD;YACT;QACF;IACF;IACA,OAAON;AACT;AAEA;;CAEC,GACD,SAASU,cAEPC,MAA2B,EAC3BvC,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAAC2B,CAAC,EAAEzB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACA,MAAM2C,oBAAoBD,qBAAqB7C,QAAQC;IAEvD,IAAI,OAAOwD,WAAW,YAAYA,WAAW,MAAM;QACjDX,kBAAkBS,IAAI,CAACE;IACzB;AACF;AACArD,iBAAiBsD,CAAC,GAAGF;AAErB,SAASG,YAEP9B,KAAU,EACVX,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAAC2B,CAAC,EAAEzB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAG4B;AACnB;AACAzB,iBAAiBwD,CAAC,GAAGD;AAErB,SAASE,gBAEPC,SAAc,EACd5C,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAAC2B,CAAC,EAAEzB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGD,OAAOuB,eAAe,GAAGuC;AAC5C;AACA1D,iBAAiB2D,CAAC,GAAGF;AAErB,SAASG,aAAarD,GAAiC,EAAE0C,GAAoB;IAC3E,OAAO,IAAM1C,GAAG,CAAC0C,IAAI;AACvB;AAEA;;CAEC,GACD,MAAMY,WAA8B1D,OAAO2D,cAAc,GACrD,CAACvD,MAAQJ,OAAO2D,cAAc,CAACvD,OAC/B,CAACA,MAAQA,IAAIwD,SAAS;AAE1B,iDAAiD,GACjD,MAAMC,kBAAkB;IAAC;IAAMH,SAAS,CAAC;IAAIA,SAAS,EAAE;IAAGA,SAASA;CAAU;AAE9E;;;;;;CAMC,GACD,SAASI,WACPC,GAAY,EACZC,EAAsB,EACtBC,kBAA4B;IAE5B,MAAM5C,WAAwB,EAAE;IAChC,IAAI6C,kBAAkB,CAAC;IACvB,IACE,IAAIC,UAAUJ,KACd,CAAC,OAAOI,YAAY,YAAY,OAAOA,YAAY,UAAU,KAC7D,CAACN,gBAAgBd,QAAQ,CAACoB,UAC1BA,UAAUT,SAASS,SACnB;QACA,KAAK,MAAMrB,OAAO9C,OAAOoE,mBAAmB,CAACD,SAAU;YACrD9C,SAAS2B,IAAI,CAACF,KAAKW,aAAaM,KAAKjB;YACrC,IAAIoB,oBAAoB,CAAC,KAAKpB,QAAQ,WAAW;gBAC/CoB,kBAAkB7C,SAASG,MAAM,GAAG;YACtC;QACF;IACF;IAEA,6BAA6B;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,CAACyC,sBAAsBC,mBAAmB,CAAC,GAAG;QACjD,8FAA8F;QAC9F,IAAIA,mBAAmB,GAAG;YACxB,oCAAoC;YACpC7C,SAASgD,MAAM,CAACH,iBAAiB,GAAG/C,kBAAkB4C;QACxD,OAAO;YACL1C,SAAS2B,IAAI,CAAC,WAAW7B,kBAAkB4C;QAC7C;IACF;IAEA3C,IAAI4C,IAAI3C;IACR,OAAO2C;AACT;AAEA,SAASM,SAASP,GAAsB;IACtC,IAAI,OAAOA,QAAQ,YAAY;QAC7B,OAAO,SAAqB,GAAGQ,IAAW;YACxC,OAAOR,IAAIS,KAAK,CAAC,IAAI,EAAED;QACzB;IACF,OAAO;QACL,OAAOvE,OAAOyE,MAAM,CAAC;IACvB;AACF;AAEA,SAASC,UAEP/D,EAAY;IAEZ,MAAMlB,SAASkF,iCAAiChE,IAAI,IAAI,CAAChB,CAAC;IAE1D,8DAA8D;IAC9D,IAAIF,OAAOuB,eAAe,EAAE,OAAOvB,OAAOuB,eAAe;IAEzD,iGAAiG;IACjG,MAAM+C,MAAMtE,OAAOC,OAAO;IAC1B,OAAQD,OAAOuB,eAAe,GAAG8C,WAC/BC,KACAO,SAASP,MACTA,OAAO,AAACA,IAAYa,UAAU;AAElC;AACA/E,iBAAiB0B,CAAC,GAAGmD;AAErB,SAASG,YAEPC,QAAkB;IAElB,MAAMC,SAAS,IAAI,CAACC,CAAC,CAACF;IAGtB,OAAOC,OAAOL,UAAUO,IAAI,CAAC,IAAI;AACnC;AACApF,iBAAiBqF,CAAC,GAAGL;AAErB,+EAA+E;AAC/E,6EAA6E;AAC7E,MAAMM,iBACJ,aAAa;AACb,OAAOC,YAAY,aAEfA,UACA,SAASC;IACP,MAAM,IAAIxD,MAAM;AAClB;AACNhC,iBAAiByF,CAAC,GAAGH;AAErB,SAASI,gBAEP5E,EAAY;IAEZ,OAAOgE,iCAAiChE,IAAI,IAAI,CAAChB,CAAC,EAAED,OAAO;AAC7D;AACAG,iBAAiBmF,CAAC,GAAGO;AAErB;;;;;;CAMC,GACD,SAASC,aAAaC,OAAe;IACnC,wFAAwF;IACxF,4DAA4D;IAC5D,MAAMC,YAAYD,QAAQE,OAAO,CAAC;IAClC,IAAID,cAAc,CAAC,GAAG;QACpBD,UAAUA,QAAQG,SAAS,CAAC,GAAGF;IACjC;IAEA,MAAMG,aAAaJ,QAAQE,OAAO,CAAC;IACnC,IAAIE,eAAe,CAAC,GAAG;QACrBJ,UAAUA,QAAQG,SAAS,CAAC,GAAGC;IACjC;IAEA,OAAOJ;AACT;AACA;;CAEC,GACD,SAASK,cAAcC,GAAqB;IAC1C,SAASD,cAAcnF,EAAU;QAC/BA,KAAK6E,aAAa7E;QAClB,IAAIZ,eAAeQ,IAAI,CAACwF,KAAKpF,KAAK;YAChC,OAAOoF,GAAG,CAACpF,GAAG,CAAClB,MAAM;QACvB;QAEA,MAAMG,IAAI,IAAIiC,MAAM,CAAC,oBAAoB,EAAElB,GAAG,CAAC,CAAC;QAC9Cf,EAAUoG,IAAI,GAAG;QACnB,MAAMpG;IACR;IAEAkG,cAAcjD,IAAI,GAAG;QACnB,OAAO7C,OAAO6C,IAAI,CAACkD;IACrB;IAEAD,cAAcG,OAAO,GAAG,CAACtF;QACvBA,KAAK6E,aAAa7E;QAClB,IAAIZ,eAAeQ,IAAI,CAACwF,KAAKpF,KAAK;YAChC,OAAOoF,GAAG,CAACpF,GAAG,CAACA,EAAE;QACnB;QAEA,MAAMf,IAAI,IAAIiC,MAAM,CAAC,oBAAoB,EAAElB,GAAG,CAAC,CAAC;QAC9Cf,EAAUoG,IAAI,GAAG;QACnB,MAAMpG;IACR;IAEAkG,cAAcI,MAAM,GAAG,OAAOvF;QAC5B,OAAO,MAAOmF,cAAcnF;IAC9B;IAEA,OAAOmF;AACT;AACAjG,iBAAiBsG,CAAC,GAAGL;AAErB;;CAEC,GACD,SAASM,aAAaC,SAAoB;IACxC,OAAO,OAAOA,cAAc,WAAWA,YAAYA,UAAUC,IAAI;AACnE;AAEA,gFAAgF;AAChF,0CAA0C;AAC1C,yBAAyB;AACzB,8BAA8B;AAC9B,6EAA6E;AAC7E,wEAAwE;AACxE,SAASC,iCACPC,YAAuC,EACvCC,MAAc,EACdC,eAAgC,EAChCC,WAAoC;IAEpC,IAAIpF,IAAIkF;IACR,MAAOlF,IAAIiF,aAAahF,MAAM,CAAE;QAC9B,IAAIoF,MAAMrF,IAAI;QACd,4BAA4B;QAC5B,MACEqF,MAAMJ,aAAahF,MAAM,IACzB,OAAOgF,YAAY,CAACI,IAAI,KAAK,WAC7B;YACAA;QACF;QACA,IAAIA,QAAQJ,aAAahF,MAAM,EAAE;YAC/B,MAAM,IAAIK,MAAM;QAClB;QAEA,wEAAwE;QACxE,0EAA0E;QAC1E,6EAA6E;QAC7E,kDAAkD;QAClD,MAAMgF,kBAAkBL,YAAY,CAACI,IAAI;QACzC,IAAIE,uBAA6C/F;QACjD,IAAK,IAAIoC,IAAI5B,GAAG4B,IAAIyD,KAAKzD,IAAK;YAC5B,MAAMxC,KAAK6F,YAAY,CAACrD,EAAE;YAC1B,MAAM4D,kBAAkBL,gBAAgB1E,GAAG,CAACrB;YAC5C,IAAIoG,iBAAiB;gBACnBD,uBAAuBC;gBACvB;YACF;QACF;QACA,MAAMC,mBAAmBF,wBAAwBD;QAEjD,IAAII,oBAAoB;QACxB,IAAK,IAAI9D,IAAI5B,GAAG4B,IAAIyD,KAAKzD,IAAK;YAC5B,MAAMxC,KAAK6F,YAAY,CAACrD,EAAE;YAC1B,IAAI,CAACuD,gBAAgBQ,GAAG,CAACvG,KAAK;gBAC5B,IAAI,CAACsG,mBAAmB;oBACtB,IAAID,qBAAqBH,iBAAiB;wBACxCM,uBAAuBN;oBACzB;oBACAI,oBAAoB;gBACtB;gBACAP,gBAAgBzE,GAAG,CAACtB,IAAIqG;gBACxBL,cAAchG;YAChB;QACF;QACAY,IAAIqF,MAAM,GAAE,sFAAsF;IACpG;AACF;AAEA;;;;;;;;;CASC,GACD,MAAMQ,cAAc,SAASA,YAAuBC,QAAgB;IAClE,MAAMC,UAAU,IAAIC,IAAIF,UAAU;IAClC,MAAMG,SAA8B,CAAC;IACrC,IAAK,MAAM1E,OAAOwE,QAASE,MAAM,CAAC1E,IAAI,GAAG,AAACwE,OAAe,CAACxE,IAAI;IAC9D0E,OAAOC,IAAI,GAAGJ;IACdG,OAAOE,QAAQ,GAAGL,SAASM,OAAO,CAAC,UAAU;IAC7CH,OAAOI,MAAM,GAAGJ,OAAOK,QAAQ,GAAG;IAClCL,OAAOM,QAAQ,GAAGN,OAAOO,MAAM,GAAG,CAAC,GAAGC,QAAsBX;IAC5D,IAAK,MAAMvE,OAAO0E,OAChBxH,OAAOQ,cAAc,CAAC,IAAI,EAAEsC,KAAK;QAC/BnB,YAAY;QACZsG,cAAc;QACd3G,OAAOkG,MAAM,CAAC1E,IAAI;IACpB;AACJ;AACAsE,YAAYtH,SAAS,GAAGyH,IAAIzH,SAAS;AACrCD,iBAAiBqI,CAAC,GAAGd;AAErB;;CAEC,GACD,SAASe,UAAUC,KAAY,EAAEC,cAAoC;IACnE,MAAM,IAAIxG,MAAM,CAAC,WAAW,EAAEwG,eAAeD,QAAQ;AACvD;AAEA;;CAEC,GACD,SAASE,2BACPxD,QAAkB,EAClByD,UAAsB,EACtBC,UAAsB;IAEtB,IAAIC;IACJ,OAAQF;QACN;YACEE,sBAAsB,CAAC,4BAA4B,EAAED,YAAY;YACjE;QACF;YACEC,sBAAsB,CAAC,oCAAoC,EAAED,YAAY;YACzE;QACF;YACEC,sBAAsB;YACtB;QACF;YACEN,UACEI,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;IAE1D;IACA,OAAO,CAAC,OAAO,EAAEzD,SAAS,kBAAkB,EAAE2D,oBAAoB,0CAA0C,CAAC;AAC/G;AAEA;;CAEC,GACD,SAASC,YAAYC,SAAmB;IACtC,MAAM,IAAI9G,MAAM;AAClB;AACAhC,iBAAiB+I,CAAC,GAAGF;AAErB,kGAAkG;AAClG7I,iBAAiBgJ,CAAC,GAAGC;AAErB,IAAIC;AAEJ,SAASC;IACP,IAAID,8BAA8BhI,WAAW;QAC3C,OAAOgI;IACT;IAEA,IAAIE;IACJ,IAAI,OAAOC,aAAa,UAAU;QAChC,MAAMC,gBAAgBD,SAASC,aAAa;QAC5CF,YAAYE,eAAeC;QAE3B,IAAI,CAACH,WAAW;YACd,MAAMI,UAAUH,SAASI,oBAAoB,CAAC;YAC9C,MAAMC,SAASF,OAAO,CAACA,QAAQ7H,MAAM,GAAG,EAAE;YAC1CyH,YAAYM,QAAQH;QACtB;IACF;IAEA,IACE,CAACH,aACD,OAAO,AAACH,WAAmBU,aAAa,KAAK,cAC7C,AAACV,WAAmBW,QAAQ,EAC5B;QACAR,YAAYS,OAAO,AAACZ,WAAmBW,QAAQ;IACjD;IAEAV,4BAA4BE,YACxBA,UACGtB,OAAO,CAAC,UAAU,IAClBA,OAAO,CAAC,QAAQ,IAChBA,OAAO,CAAC,SAAS,IACjBA,OAAO,CAAC,YAAY,OACvB;IAEJ,OAAOoB;AACT;AAEA;;;CAGC,GACD,SAASY,cAAcC,IAAa;IAClC,IAAIA,SAAS,QAAQ;QACnB,OAAOZ;IACT;IAEA,IACE,OAAOF,eAAe,eACtB,OAAO,AAACA,WAAmBe,UAAU,KAAK,UAC1C;QACA,MAAMA,aAAa,AAACf,WAAmBe,UAAU;QACjD,OAAOA,WAAWC,QAAQ,CAAC,OAAOD,aAAa,GAAGA,WAAW,CAAC,CAAC;IACjE;IACA,OAAO;AACT;AACAhK,iBAAiBkK,CAAC,GAAGJ;AAMrB,SAASxC,uBAAuB6C,OAAiB;IAC/C,+DAA+D;IAC/DhK,OAAOQ,cAAc,CAACwJ,SAAS,QAAQ;QACrC1I,OAAO;IACT;AACF","ignoreList":[0]}},
     {"offset": {"line": 508, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 772, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
-    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js
index 6b13b9e4a..3fc3f810d 100644
--- a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js
+++ b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js
@@ -1641,12 +1641,8 @@ function getRefreshBoundaryExports(exports) {
 /**
  * Map from a chunk path to the chunk lists it belongs to.
  */ const chunkChunkListsMap = new Map();
-const dynamicChunkListLoadStates = new Map();
-const pendingHmrTasks = [];
-const chunkListGenerations = new Map();
-let nextChunkListGeneration = 1;
-let activeHmrTask;
-const dynamicMemberChunkUrlOwners = new Map();
+/** Dynamic lists use a stricter, reload-on-ambiguity update policy. */ const dynamicChunkLists = new Set();
+/** Dynamic manifests which have not finished their subscribe/load/revalidate handshake. */ const loadingDynamicChunkLists = new Set();
 /**
  * Gets or instantiates a runtime module.
  */ // @ts-ignore
@@ -1796,259 +1792,48 @@ const DUMMY_REFRESH_CONTEXT = {
         disposedModules
     };
 }
-const PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict');
-function mergeParallelChunkUpdate(updateA, updateB) {
-    if (updateA.type === updateB.type) {
-        return updateA;
-    }
-    if (updateA.type === 'total' || updateB.type === 'total') {
-        return {
-            type: 'total'
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        return null;
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
     }
-    return PARALLEL_UPDATE_CONFLICT;
 }
-function mergeParallelEcmascriptChunkUpdate(updateA, updateB) {
-    if (updateA.type === 'added' && updateB.type === 'added') {
-        return {
-            type: 'added',
-            modules: [
-                ...new Set([
-                    ...updateA.modules ?? [],
-                    ...updateB.modules ?? []
-                ])
-            ]
-        };
-    }
-    if (updateA.type === 'deleted' && updateB.type === 'deleted') {
-        return {
-            type: 'deleted',
-            modules: [
-                ...new Set([
-                    ...updateA.modules ?? [],
-                    ...updateB.modules ?? []
-                ])
-            ]
-        };
-    }
-    if (updateA.type === 'partial' && updateB.type === 'partial') {
-        const added = new Set([
-            ...updateA.added ?? [],
-            ...updateB.added ?? []
-        ]);
-        const deleted = new Set([
-            ...updateA.deleted ?? [],
-            ...updateB.deleted ?? []
-        ]);
-        for (const moduleId of added){
-            if (deleted.has(moduleId)) {
-                added.delete(moduleId);
-                deleted.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'added' && updateB.type === 'deleted' || updateA.type === 'deleted' && updateB.type === 'added') {
-        const addedUpdate = updateA.type === 'added' ? updateA : updateB;
-        const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB;
-        const added = new Set(addedUpdate.modules ?? []);
-        const deleted = new Set(deletedUpdate.modules ?? []);
-        for (const moduleId of added){
-            if (deleted.has(moduleId)) {
-                added.delete(moduleId);
-                deleted.delete(moduleId);
-            }
-        }
-        return {
-            type: 'partial',
-            added: [
-                ...added
-            ],
-            deleted: [
-                ...deleted
-            ]
-        };
-    }
-    if (updateA.type === 'partial') {
-        if ((updateA.added?.length ?? 0) === 0 && (updateA.deleted?.length ?? 0) === 0) {
-            return updateB;
-        }
-        return PARALLEL_UPDATE_CONFLICT;
-    }
-    if (updateB.type === 'partial') {
-        if ((updateB.added?.length ?? 0) === 0 && (updateB.deleted?.length ?? 0) === 0) {
-            return updateA;
-        }
-        return PARALLEL_UPDATE_CONFLICT;
-    }
-    return PARALLEL_UPDATE_CONFLICT;
-}
-function moduleEntriesEqual(entryA, entryB) {
-    // The same module can be emitted into multiple chunks. Its source URL is
-    // chunk-relative, so it is allowed to differ even when the executable entry
-    // is identical. Treat only code and source map differences as conflicts.
-    return entryA.code === entryB.code && entryA.map === entryB.map;
-}
-function applyChunkListUpdates(updates) {
-    const resourceOperations = [];
-    const ownershipTransitions = new Map();
-    const chunks = new Map();
-    const ecmascriptChunks = new Map();
-    const entries = {};
-    const explicitlyModifiedModules = new Set();
-    let hasConflict = false;
-    for (const { chunkListPath, update } of updates){
-        if (update.chunks) {
-            for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
-                if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, chunkUpdate.type, ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                }
-                if (!chunks.has(chunkPath)) {
-                    chunks.set(chunkPath, chunkUpdate);
-                } else {
-                    const previous = chunks.get(chunkPath);
-                    if (previous === null) {
-                        chunks.set(chunkPath, chunkUpdate);
-                    } else {
-                        const merged = mergeParallelChunkUpdate(previous, chunkUpdate);
-                        if (merged === PARALLEL_UPDATE_CONFLICT) {
-                            hasConflict = true;
-                        } else {
-                            chunks.set(chunkPath, merged);
-                        }
-                    }
-                }
-            }
-        }
-        for (const merged of update.merged ?? []){
-            if (merged.type !== 'EcmascriptMergedUpdate') {
-                invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
-            }
-            const addedInThisUpdate = new Set();
-            for (const [chunkPath, chunkUpdate] of Object.entries(merged.chunks ?? {})){
-                if (chunkUpdate.type === 'added') {
-                    for (const moduleId of chunkUpdate.modules ?? []){
-                        addedInThisUpdate.add(moduleId);
-                    }
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'added', ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                } else if (chunkUpdate.type === 'deleted') {
-                    if (!applyChunkListMembershipDelta(chunkListPath, chunkPath, 'deleted', ownershipTransitions)) {
-                        hasConflict = true;
-                    }
-                } else {
-                    for (const moduleId of chunkUpdate.added ?? []){
-                        addedInThisUpdate.add(moduleId);
-                    }
-                }
-                const previous = ecmascriptChunks.get(chunkPath);
-                if (!previous) {
-                    ecmascriptChunks.set(chunkPath, chunkUpdate);
-                } else {
-                    const combined = mergeParallelEcmascriptChunkUpdate(previous, chunkUpdate);
-                    if (combined === PARALLEL_UPDATE_CONFLICT) {
-                        hasConflict = true;
-                    } else {
-                        ecmascriptChunks.set(chunkPath, combined);
-                    }
-                }
-            }
-            for (const [moduleId, entry] of Object.entries(merged.entries ?? {})){
-                const previous = entries[moduleId];
-                if (previous) {
-                    if (!moduleEntriesEqual(previous, entry)) {
-                        hasConflict = true;
-                    }
-                } else {
-                    entries[moduleId] = entry;
-                }
-                if (!addedInThisUpdate.has(moduleId)) {
-                    explicitlyModifiedModules.add(moduleId);
-                }
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
             }
         }
     }
-    if (hasConflict) {
-        DEV_BACKEND.restart();
-        return resourceOperations;
-    }
-    const filteredEcmascriptChunks = {};
-    for (const [chunkPath, chunkUpdate] of ecmascriptChunks){
-        const transition = ownershipTransitions.get(chunkPath);
-        if (chunkUpdate.type === 'added' && transition && transition.before > 0) {
-            for (const moduleId of chunkUpdate.modules ?? []){
-                if (!explicitlyModifiedModules.has(moduleId)) {
-                    delete entries[moduleId];
-                }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
             }
-            continue;
-        }
-        if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {
-            continue;
-        }
-        filteredEcmascriptChunks[chunkPath] = chunkUpdate;
-    }
-    if (Object.keys(entries).length > 0 || Object.keys(filteredEcmascriptChunks).length > 0) {
-        applyEcmascriptMergedUpdate({
-            type: 'EcmascriptMergedUpdate',
-            entries,
-            chunks: filteredEcmascriptChunks
-        });
-    }
-    for (const [chunkPath, chunkUpdate] of chunks){
-        if (chunkUpdate === null) {
-            continue;
-        }
-        const transition = ownershipTransitions.get(chunkPath);
-        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-        const chunkUrl = getChunkRelativeUrl(chunkPath);
-        switch(chunkUpdate.type){
-            case 'added':
-                if (!transition || transition.before === 0 && transition.after > 0) {
-                    resourceOperations.push({
-                        chunkPath,
-                        promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl)
-                    });
-                }
-                break;
-            case 'total':
-                if (ownerCount > 0) {
-                    const promise = DEV_BACKEND.reloadChunk?.(chunkUrl);
-                    if (promise) {
-                        resourceOperations.push({
-                            chunkPath,
-                            promise
-                        });
-                    }
-                }
-                break;
-            case 'deleted':
-                if (!transition || transition.before > 0 && transition.after === 0) {
-                    disposeChunk(chunkPath);
-                }
-                break;
-            case 'partial':
-                invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
-                break;
-            default:
-                invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
         }
     }
-    return resourceOperations;
 }
 function applyEcmascriptMergedUpdate(update) {
     // Browser-specific chunk management phase
@@ -2068,196 +1853,27 @@ function applyEcmascriptMergedUpdate(update) {
         autoAcceptRootModules: false
     });
 }
-function getCurrentTaskPaths(task) {
-    return task.chunkLists.filter(({ path, generation })=>chunkListGenerations.get(path) === generation).map(({ path })=>path);
-}
-function isHmrTaskBlocked(task) {
-    return task.chunkLists.some(({ path, generation })=>{
-        if (chunkListGenerations.get(path) !== generation) return false;
-        const state = dynamicChunkListLoadStates.get(path);
-        return state?.generation === generation && state.loading;
-    });
-}
-function runHmrTask(task) {
-    activeHmrTask = task;
-    void (async ()=>{
-        let resourceOperations = [];
-        try {
-            const currentPaths = new Set(getCurrentTaskPaths(task));
-            if (currentPaths.size > 0) {
-                resourceOperations = task.apply(currentPaths);
-                const results = await Promise.allSettled(resourceOperations.map(({ promise })=>promise));
-                const failedIndex = results.findIndex((result, index)=>result.status === 'rejected' && chunkChunkListsMap.has(resourceOperations[index].chunkPath));
-                if (failedIndex !== -1) {
-                    throw results[failedIndex].reason;
-                }
-            }
-            task.resolve();
-        } catch (cause) {
-            // A terminal update invalidates the generation immediately. Any member
-            // request it cancelled belongs to that old generation and must not turn
-            // a valid replacement subscription into a page reload.
-            if (getCurrentTaskPaths(task).length === 0) {
-                task.resolve();
-            } else {
-                task.reject(cause);
-            }
-        } finally{
-            for (const { chunkPath } of resourceOperations){
-                if (!chunkChunkListsMap.has(chunkPath)) {
-                    disposeChunk(chunkPath);
-                }
-            }
-            if (activeHmrTask === task) {
-                activeHmrTask = undefined;
-            }
-            flushPendingHmrTasks();
-        }
-    })();
-}
-function scheduleHmrTask(chunkListPaths, apply) {
-    const chunkLists = [
-        ...new Set(chunkListPaths)
-    ].flatMap((path)=>{
-        const generation = chunkListGenerations.get(path);
-        return generation === undefined ? [] : [
-            {
-                path,
-                generation
-            }
-        ];
-    });
-    if (chunkLists.length === 0) {
-        return Promise.resolve();
-    }
-    let resolve;
-    let reject;
-    const completion = new Promise((innerResolve, innerReject)=>{
-        resolve = innerResolve;
-        reject = innerReject;
-    });
-    const task = {
-        chunkLists,
-        apply,
-        resolve,
-        reject
-    };
-    for (const { path, generation } of chunkLists){
-        const state = dynamicChunkListLoadStates.get(path);
-        if (state?.generation === generation && state.bootstrapping && !state.terminated) {
-            state.pendingTasks.add(completion);
-            void completion.then(()=>state.pendingTasks.delete(completion), ()=>state.pendingTasks.delete(completion));
-        }
-    }
-    if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {
-        pendingHmrTasks.push(task);
-        flushPendingHmrTasks();
-    } else {
-        runHmrTask(task);
-    }
-    return completion;
-}
-function flushPendingHmrTasks() {
-    if (activeHmrTask) return;
-    while(pendingHmrTasks.length > 0){
-        const task = pendingHmrTasks[0];
-        if (getCurrentTaskPaths(task).length === 0) {
-            pendingHmrTasks.shift();
-            task.resolve();
-            continue;
-        }
-        if (isHmrTaskBlocked(task)) {
-            return;
-        }
-        pendingHmrTasks.shift();
-        runHmrTask(task);
-        return;
-    }
-}
-function handleApplyBatch(updates) {
-    const relevantUpdates = updates.map((update)=>({
-            chunkListPath: update.resource.path,
-            update: update.instruction
-        })).filter(({ chunkListPath })=>chunkListChunksMap.has(chunkListPath));
-    const chunkListPaths = [
-        ...new Set(relevantUpdates.map(({ chunkListPath })=>chunkListPath))
-    ];
-    if (chunkListPaths.length === 0) {
-        return {
-            handledPaths: []
-        };
-    }
-    const bootstrappingPaths = chunkListPaths.filter((chunkListPath)=>{
-        const state = dynamicChunkListLoadStates.get(chunkListPath);
-        return state?.bootstrapping && !state.terminated;
-    });
-    if (bootstrappingPaths.length > 0) {
-        for (const chunkListPath of bootstrappingPaths){
-            const state = dynamicChunkListLoadStates.get(chunkListPath);
-            terminateDynamicChunkListLoad(chunkListPath, state, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
-        }
-        DEV_BACKEND.restart();
-        flushPendingHmrTasks();
-        return {
-            handledPaths: chunkListPaths
-        };
-    }
-    const completion = scheduleHmrTask(chunkListPaths, (currentPaths)=>{
-        const chunkListUpdates = relevantUpdates.filter(({ chunkListPath })=>currentPaths.has(chunkListPath)).map(({ chunkListPath, update })=>{
-            if (update.type !== 'ChunkListUpdate') {
-                invariant(update, (update)=>`Unknown update type: ${update.type}`);
-            }
-            return {
-                chunkListPath,
-                update
-            };
-        });
-        return chunkListUpdates.length > 0 ? applyChunkListUpdates(chunkListUpdates) : [];
-    });
-    return {
-        handledPaths: chunkListPaths,
-        completion
-    };
-}
 function handleApply(chunkListPath, update) {
-    const loadState = dynamicChunkListLoadStates.get(chunkListPath);
-    if (update.type === 'partial' && loadState?.bootstrapping && !loadState.terminated) {
-        terminateDynamicChunkListLoad(chunkListPath, loadState, new Error(`Dynamic chunk list ${chunkListPath} changed while its members were loading.`));
-        DEV_BACKEND.restart();
-        flushPendingHmrTasks();
-        return Promise.resolve();
-    }
-    if (update.type === 'notFound' || update.type === 'restart') {
-        if (loadState && !loadState.terminated) {
-            const error = new Error(update.type === 'notFound' ? `Dynamic chunk list ${chunkListPath} disappeared while loading.` : `Dynamic chunk list ${chunkListPath} must restart while loading.`);
-            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
-        }
-        if (update.type === 'restart') {
-            chunkListGenerations.delete(chunkListPath);
-            dynamicChunkListLoadStates.delete(chunkListPath);
-        }
-        handleApplyImmediately(chunkListPath, update);
-        flushPendingHmrTasks();
-        return Promise.resolve();
-    }
-    return scheduleHmrTask([
-        chunkListPath
-    ], (currentPaths)=>currentPaths.has(chunkListPath) ? handleApplyImmediately(chunkListPath, update) : []);
-}
-function handleApplyImmediately(chunkListPath, update) {
     switch(update.type){
         case 'partial':
             {
                 // This indicates that the update is can be applied to the current state of the application.
-                if (update.instruction.type !== 'ChunkListUpdate') {
-                    invariant(update.instruction, (instruction)=>`Unknown update type: ${instruction.type}`);
-                }
-                return applyChunkListUpdates([
-                    {
-                        chunkListPath,
-                        update: update.instruction
+                if (dynamicChunkLists.has(chunkListPath)) {
+                    if (loadingDynamicChunkLists.has(chunkListPath)) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} changed while it was loading.`);
+                    }
+                    if (update.instruction.type === 'ChunkListUpdate' && update.instruction.chunks != null) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} changed structure.`);
+                    }
+                    const hasSharedChunk = [
+                        ...chunkListChunksMap.get(chunkListPath) ?? []
+                    ].some((chunkPath)=>(chunkChunkListsMap.get(chunkPath)?.size ?? 0) > 1);
+                    if (hasSharedChunk) {
+                        throw new Error(`Dynamic chunk list ${chunkListPath} shares chunks with another active list.`);
                     }
-                ]);
+                }
+                applyUpdate(update.instruction);
+                break;
             }
         case 'restart':
             {
@@ -2265,7 +1881,7 @@ function handleApplyImmediately(chunkListPath, update) {
                 // current state of the application, and that the application must be
                 // restarted.
                 DEV_BACKEND.restart();
-                return [];
+                break;
             }
         case 'notFound':
             {
@@ -2273,78 +1889,17 @@ function handleApplyImmediately(chunkListPath, update) {
                 // or the page itself was deleted.
                 // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
                 // If it is a runtime chunk list, we restart the application.
-                if (runtimeChunkLists.has(chunkListPath)) {
+                if (runtimeChunkLists.has(chunkListPath) || dynamicChunkLists.has(chunkListPath)) {
                     DEV_BACKEND.restart();
                 } else {
                     disposeChunkList(chunkListPath);
                 }
-                return [];
+                break;
             }
         default:
             throw new Error(`Unknown update type: ${update.type}`);
     }
 }
-function applyChunkListMembershipDelta(chunkListPath, chunkPath, type, transitions) {
-    let transition = transitions.get(chunkPath);
-    if (!transition) {
-        const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-        transition = {
-            before: ownerCount,
-            after: ownerCount
-        };
-        transitions.set(chunkPath, transition);
-    }
-    const changed = type === 'added' ? addChunkToChunkList(chunkListPath, chunkPath) : removeChunkFromChunkList(chunkListPath, chunkPath);
-    transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0;
-    return changed;
-}
-function addChunkToChunkList(chunkListPath, chunkPath) {
-    let chunkPaths = chunkListChunksMap.get(chunkListPath);
-    if (!chunkPaths) {
-        chunkPaths = new Set();
-        chunkListChunksMap.set(chunkListPath, chunkPaths);
-    }
-    if (chunkPaths.has(chunkPath)) {
-        return false;
-    }
-    chunkPaths.add(chunkPath);
-    let chunkLists = chunkChunkListsMap.get(chunkPath);
-    if (!chunkLists) {
-        chunkLists = new Set();
-        chunkChunkListsMap.set(chunkPath, chunkLists);
-    }
-    chunkLists.add(chunkListPath);
-    return true;
-}
-function removeChunkFromChunkList(chunkListPath, chunkPath) {
-    const chunkPaths = chunkListChunksMap.get(chunkListPath);
-    const chunkLists = chunkChunkListsMap.get(chunkPath);
-    if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {
-        return false;
-    }
-    chunkPaths.delete(chunkPath);
-    chunkLists.delete(chunkListPath);
-    if (chunkLists.size === 0) {
-        chunkChunkListsMap.delete(chunkPath);
-    }
-    return true;
-}
-function setChunkListChunks(chunkListPath, nextChunkPaths) {
-    const previousChunkPaths = new Set(chunkListChunksMap.get(chunkListPath) ?? []);
-    if (!chunkListChunksMap.has(chunkListPath)) {
-        chunkListChunksMap.set(chunkListPath, new Set());
-    }
-    for (const chunkPath of previousChunkPaths){
-        if (!nextChunkPaths.has(chunkPath) && removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
-            disposeChunk(chunkPath);
-        }
-    }
-    for (const chunkPath of nextChunkPaths){
-        if (!previousChunkPaths.has(chunkPath)) {
-            addChunkToChunkList(chunkListPath, chunkPath);
-        }
-    }
-}
 /**
  * Removes a module from a chunk.
  * Returns `true` if there are no remaining chunks including this module.
@@ -2363,82 +1918,6 @@ function setChunkListChunks(chunkListPath, nextChunkPaths) {
     }
     return noRemainingChunks;
 }
-function terminateDynamicChunkListLoad(chunkListPath, state, error) {
-    if (state.terminated) return;
-    state.loading = false;
-    state.bootstrapping = false;
-    state.terminated = true;
-    state.rejectSubscribed?.(error);
-    DEV_BACKEND.rejectChunk?.(chunkListPath, error);
-    for (const [chunkPath, chunkUrl] of state.memberChunkUrls){
-        releaseDynamicMemberChunkUrlOwner(chunkListPath, state.generation, chunkPath, chunkUrl);
-    }
-}
-function addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    let owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (!owners) {
-        owners = new Map();
-        dynamicMemberChunkUrlOwners.set(chunkUrl, owners);
-    }
-    owners.set(chunkListPath, generation);
-}
-function releaseDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkPath, chunkUrl) {
-    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (owners?.get(chunkListPath) !== generation) return;
-    owners.delete(chunkListPath);
-    if (owners.size > 0) return;
-    dynamicMemberChunkUrlOwners.delete(chunkUrl);
-    if (isJs(chunkUrl)) {
-        // Executed factories are already tracked by logical chunk ownership. The
-        // exact URL is removed so a cancelled in-flight script cannot satisfy a
-        // later request for the same logical chunk.
-        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-    } else {
-        const hasOtherChunkListOwner = [
-            ...chunkChunkListsMap.get(chunkPath) ?? []
-        ].some((owner)=>owner !== chunkListPath);
-        if (hasOtherChunkListOwner) return;
-        DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-    }
-    if (!chunkChunkListsMap.has(chunkPath)) {
-        disposeChunk(chunkPath);
-    }
-}
-function completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl) {
-    const owners = dynamicMemberChunkUrlOwners.get(chunkUrl);
-    if (owners?.get(chunkListPath) !== generation) return;
-    owners.delete(chunkListPath);
-    if (owners.size === 0) {
-        dynamicMemberChunkUrlOwners.delete(chunkUrl);
-    }
-}
-function loadVersionedDynamicMemberChunk(chunkListPath, chunkData, versionToken) {
-    const chunkPath = getChunkPath(chunkData);
-    const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken);
-    if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {
-        // A previous owner may have loaded an older content-version URL for the
-        // same stylesheet. Swap it only after the new CSS has loaded so dynamic
-        // lists never accumulate duplicate cascade entries.
-        return DEV_BACKEND.loadChunkReplacing(chunkUrl);
-    }
-    return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken);
-}
-function getVersionedChunkUrl(chunkPath, versionToken) {
-    const chunkUrl = getChunkRelativeUrl(chunkPath);
-    const separator = chunkUrl.includes('?') ? '&' : '?';
-    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
-}
-function isVersionedDynamicMemberChunkUrl(chunkUrl) {
-    return /(?:[?&])hmr=/.test(chunkUrl);
-}
-/**
- * Dynamic chunk-list manifests have already done their own availability
- * calculation. Load the exact member URL for this manifest generation so an
- * older in-flight request cannot be reused by a replacement generation.
- */ function loadVersionedInitialChunk(chunkPath, chunkData, versionToken) {
-    const memberChunkPath = getChunkPath(chunkData);
-    return loadChunkByUrlInternal(SourceType.Runtime, chunkPath, getVersionedChunkUrl(memberChunkPath, versionToken));
-}
 /**
  * Disposes of a chunk list and its corresponding exclusive chunks.
  */ function disposeChunkList(chunkListPath) {
@@ -2446,17 +1925,15 @@ function isVersionedDynamicMemberChunkUrl(chunkUrl) {
     if (chunkPaths == null) {
         return false;
     }
-    for (const chunkPath of [
-        ...chunkPaths
-    ]){
-        if (removeChunkFromChunkList(chunkListPath, chunkPath) && !chunkChunkListsMap.has(chunkPath)) {
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
             disposeChunk(chunkPath);
         }
     }
-    chunkListChunksMap.delete(chunkListPath);
-    chunkListGenerations.delete(chunkListPath);
-    dynamicChunkListLoadStates.delete(chunkListPath);
-    runtimeChunkLists.delete(chunkListPath);
     // We must also dispose of the chunk list's chunk itself to ensure it may
     // be reloaded properly in the future.
     const chunkListUrl = getChunkRelativeUrl(chunkListPath);
@@ -2476,7 +1953,7 @@ function isVersionedDynamicMemberChunkUrl(chunkUrl) {
     if (chunkModules == null) {
         return false;
     }
-    chunkModulesMap.delete(chunkPath);
+    chunkModules.delete(chunkPath);
     for (const moduleId of chunkModules){
         const moduleChunks = moduleChunksMap.get(moduleId);
         moduleChunks.delete(chunkPath);
@@ -2522,7 +1999,7 @@ function getDevChunkFromRegistration(chunk) {
     if (typeof chunk === 'string') {
         if (typeof document !== 'undefined') {
             const src = document.currentScript?.getAttribute('src');
-            if (src && getPathFromScript({
+            if (src && /[?&]hmr=/.test(src) && getPathFromScript({
                 src
             }) === chunk) {
                 return {
@@ -2530,177 +2007,102 @@ function getDevChunkFromRegistration(chunk) {
                 };
             }
         }
-        if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' && TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
-            return {
-                src: TURBOPACK_NEXT_CHUNK_URLS.pop()
-            };
-        }
     }
     return getChunkFromRegistration(chunk);
 }
 function registerChunk(registration) {
     const chunk = getDevChunkFromRegistration(registration[0]);
-    const chunkPath = getPathFromScript(chunk);
-    const chunkUrl = getUrlFromScript(chunk);
-    const canonicalChunkUrl = getChunkRelativeUrl(chunkPath);
     let runtimeParams;
     // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
     if (registration.length === 2) {
         runtimeParams = registration[1];
     } else {
+        let chunkPath = getPathFromScript(chunk);
         runtimeParams = undefined;
-        if (chunkUrl !== canonicalChunkUrl && isVersionedDynamicMemberChunkUrl(chunkUrl) && !dynamicMemberChunkUrlOwners.has(chunkUrl)) {
-            // Registration can race with cancellation even after its script element
-            // was removed. Only a live owner may install this content-versioned
-            // chunk; a later owner of the same URL is safe because its content is
-            // identical.
-            DEV_BACKEND.unloadChunkExact?.(chunkUrl);
-            return;
-        }
         installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
     }
-    if (runtimeParams === undefined && chunkUrl !== canonicalChunkUrl && DEV_BACKEND.resolveChunk) {
-        // Versioned development chunks have their own resolver. Resolving the
-        // canonical path here could let an older generation wake a newer load.
-        DEV_BACKEND.resolveChunk(chunkUrl);
-        return;
-    }
-    const result = BACKEND.registerChunk(chunk, runtimeParams);
-    if (chunkUrl !== canonicalChunkUrl) {
-        DEV_BACKEND.resolveChunk?.(chunkUrl);
-    }
-    return result;
+    return BACKEND.registerChunk(chunk, runtimeParams);
+}
+function getVersionedChunkUrl(chunkPath, versionToken) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    const separator = chunkUrl.includes('?') ? '&' : '?';
+    return `${chunkUrl}${separator}hmr=${encodeURIComponent(versionToken)}`;
+}
+function loadVersionedInitialChunk(chunkListPath, chunkData, versionToken) {
+    return loadChunkByUrlInternal(SourceType.Runtime, chunkListPath, getVersionedChunkUrl(getChunkPath(chunkData), versionToken));
 }
 /**
  * Subscribes to chunk list updates from the update server and applies them.
  */ function registerChunkList(chunkList) {
     const chunkListScript = getDevChunkFromRegistration(chunkList.script);
     const chunkListPath = getPathFromScript(chunkListScript);
-    const generation = nextChunkListGeneration++;
-    chunkListGenerations.set(chunkListPath, generation);
+    // Adding chunks to chunk lists and vice versa.
     const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
-    setChunkListChunks(chunkListPath, chunkPaths);
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
     if (chunkList.source === 'entry') {
-        // Entry chunks have already loaded their member chunks while bootstrapping.
-        // The "chunk" registration completes the backend's initial load.
+        // Entry lists keep the legacy loading and update behavior.
         BACKEND.registerChunk(chunkListPath);
-        markChunkListAsRuntime(chunkListPath);
         CHUNK_UPDATE_LISTENERS.push([
             chunkListPath,
-            handleApply.bind(null, chunkListPath),
-            {
-                batch: handleApplyBatch,
-                expectedVersion: chunkList.version
-            }
+            handleApply.bind(null, chunkListPath)
         ]);
+        markChunkListAsRuntime(chunkListPath);
         return;
     }
+    dynamicChunkLists.add(chunkListPath);
     if (typeof document === 'undefined') {
-        // Workers currently have no HMR transport/provider. Keep the dynamic
-        // chunk-list as a lightweight bootstrap, but load its members directly
-        // instead of waiting forever for an onSubscribed acknowledgement.
-        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), (cause)=>{
-            const error = cause instanceof Error ? cause : new Error(`Failed to load a worker dynamic chunk group: ${String(cause)}`);
-            DEV_BACKEND.rejectChunk?.(chunkListPath, error);
-        });
+        // Workers do not have the browser HMR transport. Load the manifest members
+        // directly so the dynamic import cannot wait for a subscription forever.
+        void Promise.all(chunkList.chunks.map((chunkData)=>loadInitialChunk(chunkListPath, chunkData))).then(()=>BACKEND.registerChunk(chunkListPath), ()=>DEV_BACKEND.restart());
         return;
     }
-    // A dynamic chunk list is the bootstrap for its group. Establish the server
-    // baseline before fetching content, then hold updates while content loads.
-    // This closes the HTTP/WebSocket race where stale content could otherwise be
-    // fetched immediately before a newer subscription baseline was created.
-    const loadState = {
-        generation,
-        loading: true,
-        bootstrapping: true,
-        terminated: false,
-        pendingTasks: new Set(),
-        memberChunkUrls: new Map()
-    };
-    for (const chunkData of chunkList.chunks){
-        const chunkPath = getChunkPath(chunkData);
-        const chunkVersion = chunkList.chunkVersions[chunkPath];
-        if (chunkVersion === undefined) {
-            throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
-        }
-        const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion);
-        loadState.memberChunkUrls.set(chunkPath, chunkUrl);
-        addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
-    }
-    dynamicChunkListLoadStates.set(chunkListPath, loadState);
+    loadingDynamicChunkLists.add(chunkListPath);
     let resolveSubscribed;
     let revalidateSubscription;
-    const subscribed = new Promise((resolve, reject)=>{
+    const subscribed = new Promise((resolve)=>{
         resolveSubscribed = resolve;
-        loadState.rejectSubscribed = reject;
     });
     CHUNK_UPDATE_LISTENERS.push([
         chunkListPath,
         handleApply.bind(null, chunkListPath),
         {
-            batch: handleApplyBatch,
+            conservative: true,
+            expectedVersion: chunkList.version,
             onSubscribed: (revalidate)=>{
                 revalidateSubscription = revalidate;
                 resolveSubscribed();
-            },
-            expectedVersion: chunkList.version
+            }
         }
     ]);
     void (async ()=>{
         try {
             await subscribed;
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            const memberResults = await Promise.allSettled(chunkList.chunks.map((chunkData)=>loadVersionedDynamicMemberChunk(chunkListPath, chunkData, chunkList.chunkVersions[getChunkPath(chunkData)])));
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                for (const chunkPath of chunkPaths){
-                    if (!chunkChunkListsMap.has(chunkPath)) {
-                        disposeChunk(chunkPath);
-                    }
+            await Promise.all(chunkList.chunks.map((chunkData)=>{
+                const chunkPath = getChunkPath(chunkData);
+                const chunkVersion = chunkList.chunkVersions[chunkPath];
+                if (chunkVersion === undefined) {
+                    throw new Error(`Missing version for dynamic member chunk ${chunkPath}`);
                 }
-                return;
-            }
-            const failedMember = memberResults.find((result)=>result.status === 'rejected');
-            if (failedMember) {
-                throw failedMember.reason;
-            }
-            // The member URLs are served from the live output directory rather than
-            // a historical snapshot. Validate the manifest version again after all
-            // HTTP responses have completed, closing the subscription/HTTP race.
+                return loadVersionedInitialChunk(chunkListPath, chunkData, chunkVersion);
+            }));
+            // Member URLs are served from the live output directory. Verify that
+            // the manifest did not change while those HTTP responses were loading.
             await revalidateSubscription();
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            for (const chunkUrl of loadState.memberChunkUrls.values()){
-                completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl);
-            }
-            loadState.loading = false;
-            flushPendingHmrTasks();
-            while(loadState.pendingTasks.size > 0){
-                await Promise.all([
-                    ...loadState.pendingTasks
-                ]);
-            }
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                for (const chunkPath of chunkPaths){
-                    if (!chunkChunkListsMap.has(chunkPath)) {
-                        disposeChunk(chunkPath);
-                    }
-                }
-                return;
-            }
-            // Resolving the bootstrap schedules the import continuation as a
-            // microtask. Every queued update and resource load has completed first,
-            // so user code cannot observe factories from an older manifest.
-            loadState.bootstrapping = false;
+            loadingDynamicChunkLists.delete(chunkListPath);
             BACKEND.registerChunk(chunkListPath);
-        } catch (cause) {
-            if (loadState.terminated || dynamicChunkListLoadStates.get(chunkListPath) !== loadState || chunkListGenerations.get(chunkListPath) !== generation) {
-                return;
-            }
-            const error = cause instanceof Error ? cause : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`);
-            terminateDynamicChunkListLoad(chunkListPath, loadState, error);
+        } catch  {
+            loadingDynamicChunkLists.delete(chunkListPath);
             DEV_BACKEND.restart();
         }
     })();
@@ -2729,6 +2131,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
@@ -2959,47 +2365,31 @@ let BACKEND;
 /// <reference path="../../../shared/require-type.d.ts" />
 let DEV_BACKEND;
 (()=>{
-    const pendingChunkReloads = new Map();
-    const replacingCssLoads = new Map();
     DEV_BACKEND = {
-        loadChunkReplacing (chunkUrl) {
-            if (!isCss(chunkUrl)) {
-                return Promise.reject(new Error(`Only CSS chunks can be replaced while loading: ${chunkUrl}`));
-            }
-            const existingLoad = replacingCssLoads.get(chunkUrl);
-            if (existingLoad) return existingLoad;
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // Strip query string so we match links regardless of cache-busting
+            // params (e.g. ?ts=) that may differ between HMR updates.
             const baseChunkUrl = chunkUrl.split('?')[0];
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
             const decodedBaseChunkUrl = decodeURI(baseChunkUrl);
-            const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?';
-            const decodedChunkUrl = decodeURI(chunkUrl);
-            const exactLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}${cacheBusterSeparator}"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}${cacheBusterSeparator}"]`);
-            const baseLinks = document.querySelectorAll(`link[rel=stylesheet][href="${baseChunkUrl}"],link[rel=stylesheet][href^="${baseChunkUrl}?"],link[rel=stylesheet][href="${decodedBaseChunkUrl}"],link[rel=stylesheet][href^="${decodedBaseChunkUrl}?"]`);
-            const load = exactLinks.length > 0 ? resolveChunkResolver(chunkUrl) : baseLinks.length === 0 ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl) : DEV_BACKEND.reloadChunk(chunkUrl).then(()=>resolveChunkResolver(chunkUrl));
-            replacingCssLoads.set(chunkUrl, load);
-            void load.then(()=>{
-                if (replacingCssLoads.get(chunkUrl) === load) {
-                    replacingCssLoads.delete(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${baseChunkUrl}"],link[href^="${baseChunkUrl}?"],link[href="${decodedBaseChunkUrl}"],link[href^="${decodedBaseChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
                 }
-            }, ()=>{
-                if (replacingCssLoads.get(chunkUrl) === load) {
-                    replacingCssLoads.delete(chunkUrl);
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${baseChunkUrl}"],script[src^="${baseChunkUrl}?"],script[src="${decodedBaseChunkUrl}"],script[src^="${decodedBaseChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
                 }
-            });
-            return load;
-        },
-        unloadChunk (chunkUrl) {
-            unloadChunk(chunkUrl, false);
-        },
-        unloadChunkExact (chunkUrl) {
-            unloadChunk(chunkUrl, true);
-        },
-        rejectChunk (chunkPath, error) {
-            const chunkUrl = getUrlFromScript(chunkPath);
-            const resolver = chunkResolvers.get(chunkUrl);
-            if (resolver) rejectResolver(chunkUrl, resolver, error);
-        },
-        resolveChunk (chunkUrl) {
-            resolveChunkResolver(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
         },
         reloadChunk (chunkUrl) {
             return new Promise((resolve, reject)=>{
@@ -3016,43 +2406,9 @@ let DEV_BACKEND;
                     reject(new Error(`No link element found for chunk ${chunkUrl}`));
                     return;
                 }
-                const currentReloads = pendingChunkReloads.get(baseChunkUrl);
-                if (currentReloads) {
-                    const suffix = chunkUrl.includes('?') ? '&' : '?';
-                    for (const reload of [
-                        ...currentReloads
-                    ]){
-                        const href = reload.link.getAttribute('href');
-                        if (href !== chunkUrl && !href?.startsWith(`${chunkUrl}${suffix}`)) {
-                            reload.reject(new Error(`CSS chunk ${chunkUrl} superseded an in-flight reload.`));
-                        }
-                    }
-                }
                 const link = document.createElement('link');
                 link.rel = 'stylesheet';
                 link.crossOrigin = CROSS_ORIGIN;
-                let pendingReloads = pendingChunkReloads.get(baseChunkUrl);
-                if (!pendingReloads) {
-                    pendingReloads = new Set();
-                    pendingChunkReloads.set(baseChunkUrl, pendingReloads);
-                }
-                const cleanup = ()=>{
-                    pendingReloads.delete(pendingReload);
-                    if (pendingReloads.size === 0) {
-                        pendingChunkReloads.delete(baseChunkUrl);
-                    }
-                };
-                const pendingReload = {
-                    link,
-                    reject: (error)=>{
-                        cleanup();
-                        link.onload = null;
-                        link.onerror = null;
-                        link.remove();
-                        reject(error);
-                    }
-                };
-                pendingReloads.add(pendingReload);
                 if (navigator.userAgent.includes('Firefox') || navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome') && !navigator.userAgent.includes('Chromium')) {
                     // Firefox won't reload CSS files that were previously loaded on the
                     // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
@@ -3073,10 +2429,9 @@ let DEV_BACKEND;
                     link.href = chunkUrl;
                 }
                 link.onerror = ()=>{
-                    pendingReload.reject(new Error(`Failed to reload CSS chunk ${chunkUrl}`));
+                    reject();
                 };
                 link.onload = ()=>{
-                    cleanup();
                     // First load the new CSS, then remove the old ones. This prevents visible
                     // flickering that would happen in-between removing the previous CSS and
                     // loading the new one.
@@ -3092,87 +2447,8 @@ let DEV_BACKEND;
         },
         restart: ()=>self.location.reload()
     };
-    function rejectResolver(chunkUrl, resolver, error) {
-        if (chunkResolvers.get(chunkUrl) === resolver) {
-            chunkResolvers.delete(chunkUrl);
-        }
-        resolver.reject(error);
-    }
-    function resolveChunkResolver(chunkUrl) {
-        let resolver = chunkResolvers.get(chunkUrl);
-        if (!resolver) {
-            let resolve;
-            let reject;
-            const promise = new Promise((innerResolve, innerReject)=>{
-                resolve = innerResolve;
-                reject = innerReject;
-            });
-            resolver = {
-                resolved: false,
-                loadingStarted: false,
-                retryAttempts: 0,
-                promise,
-                resolve: ()=>{
-                    resolver.resolved = true;
-                    resolve();
-                },
-                reject: reject
-            };
-            chunkResolvers.set(chunkUrl, resolver);
-        }
-        resolver.resolve();
-        return resolver.promise;
-    }
-    function unloadChunk(chunkUrl, exact) {
-        deleteResolvers(chunkUrl, exact);
-        const baseChunkUrl = chunkUrl.split('?')[0];
-        const reloads = pendingChunkReloads.get(baseChunkUrl);
-        if (reloads) {
-            for (const reload of [
-                ...reloads
-            ]){
-                const href = reload.link.getAttribute('href');
-                const suffix = chunkUrl.includes('?') ? '&' : '?';
-                if (!exact || href === chunkUrl || href?.startsWith(`${chunkUrl}${suffix}`)) {
-                    reload.reject(new Error(`Chunk ${chunkUrl} was unloaded while reloading.`));
-                }
-            }
-        }
-        // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
-        const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl);
-        const path = exact ? chunkUrl : baseChunkUrl;
-        const suffix = exact ? path.includes('?') ? '&' : '?' : '?';
-        if (isCss(chunkUrl)) {
-            const links = document.querySelectorAll(`link[href="${path}"],link[href^="${path}${suffix}"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}${suffix}"]`);
-            for (const link of Array.from(links)){
-                link.remove();
-            }
-        } else if (isJs(chunkUrl)) {
-            // Unloading a JS chunk would have no effect once it has executed, but
-            // removing the exact stale registration keeps the DOM and resolver cache
-            // bounded without touching a newer generation of the same chunk path.
-            const scripts = document.querySelectorAll(`script[src="${path}"],script[src^="${path}${suffix}"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}${suffix}"]`);
-            for (const script of Array.from(scripts)){
-                script.remove();
-            }
-        } else {
-            throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
-        }
-    }
-    function deleteResolvers(chunkUrl, exact) {
-        const baseChunkUrl = chunkUrl.split('?')[0];
-        for (const [resolverUrl, resolver] of [
-            ...chunkResolvers
-        ]){
-            if (exact ? resolverUrl !== chunkUrl : resolverUrl.split('?')[0] !== baseChunkUrl) {
-                continue;
-            }
-            if (resolver.resolved) {
-                chunkResolvers.delete(resolverUrl);
-            } else {
-                rejectResolver(resolverUrl, resolver, new Error(`Chunk ${resolverUrl} was unloaded while loading.`));
-            }
-        }
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
     }
 })();
 function _eval({ code, url, map }) {
diff --git a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map
index e3743b692..fac13cace 100644
--- a/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/runtime/app_dev_runtime/output/main.js.map
@@ -6,7 +6,7 @@
     {"offset": {"line": 512, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/async-module.ts"],"sourcesContent":["/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./runtime-utils.ts\" />\n\n/**\n * Top-level-await / async-module machinery. This is only included in the runtime\n * when the module graph actually contains an async module (a module with\n * top-level await, or one that transitively depends on one). When no async\n * module is present, the chunk items never reference `__turbopack_context__.a`,\n * so this whole file can be omitted.\n *\n * everything below is adapted from webpack\n * https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n */\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n"],"names":["turbopackQueues","Symbol","turbopackExports","turbopackError","isPromise","maybePromise","then","isAsyncModuleExt","obj","createPromise","resolve","reject","promise","Promise","res","rej","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","map","dep","Object","assign","err","asyncModule","body","hasAwait","module","m","undefined","depQueues","Set","rawPromise","exports","attributes","get","set","v","defineProperty","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","has","add","push","asyncResult","contextPrototype","a"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 644, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"AAAA;;;;;;CAMC,GAED,oDAAoD,GAEpD,6CAA6C;AAC7C,iEAAiE;AAEjE,gEAAgE;AAehE,qCAAqC;AACrC,SAASA,wBAAwBC,WAAmBC,eAAe;IACjE,IAAID,aAAa,2BAA2B;QAC1C,OAAOE,iBAAiBC,CAAC;IAC3B;IACA,IAAIH,aAAa,wBAAwB;QACvC,OAAOE,iBAAiBC,CAAC,CAAC;IAC5B;IACA,OAAOH;AACT;AAMA,MAAMI,0BACJC,QAAQC,SAAS;AA+CnB,MAAMC,kBAAmC,IAAIC;AAC7CN,iBAAiBO,CAAC,GAAGF;AAErB,MAAMG,mBAAuD,IAAIF;AAEjE,MAAMG,wBAA6D,IAAIH;AAEvE,SAASI,UAEPC,SAAoB;IAEpB,OAAOC,kBAAkBC,WAAWC,MAAM,EAAE,IAAI,CAACC,CAAC,CAACC,EAAE,EAAEL;AACzD;AACAT,wBAAwBe,CAAC,GAAGP;AAE5B,SAASQ,iBAAiBC,SAAoB,EAAER,SAAoB;IAClE,OAAOC,kBAAkBC,WAAWO,OAAO,EAAED,WAAWR;AAC1D;AAEA,eAAeC,kBACbS,UAAsB,EACtBC,UAAsB,EACtBX,SAAoB;IAEpB,IAAI,OAAOA,cAAc,UAAU;QACjC,OAAOY,cAAcF,YAAYC,YAAYX;IAC/C;IAEA,MAAMa,eAAeb,UAAUc,QAAQ,IAAI,EAAE;IAC7C,MAAMC,kBAAkBF,aAAaG,GAAG,CAAC,CAACF;QACxC,IAAIpB,gBAAgBuB,GAAG,CAACH,WAAW,OAAO;QAC1C,OAAOjB,iBAAiBqB,GAAG,CAACJ;IAC9B;IACA,IAAIC,gBAAgBI,MAAM,GAAG,KAAKJ,gBAAgBK,KAAK,CAAC,CAAC9B,IAAMA,IAAI;QACjE,uFAAuF;QACvF,MAAM+B,QAAQC,GAAG,CAACP;QAClB;IACF;IAEA,MAAMQ,2BAA2BvB,UAAUwB,YAAY,IAAI,EAAE;IAC7D,MAAMC,uBAAuBF,yBAC1BP,GAAG,CAAC,CAACF;QACJ,yCAAyC;QACzC,8CAA8C;QAC9C,OAAOhB,sBAAsBoB,GAAG,CAACJ;IACnC,GACCY,MAAM,CAAC,CAACpC,IAAMA;IAEjB,IAAIqC;IACJ,IAAIF,qBAAqBN,MAAM,GAAG,GAAG;QACnC,oDAAoD;QAEpD,IAAIM,qBAAqBN,MAAM,KAAKI,yBAAyBJ,MAAM,EAAE;YACnE,+FAA+F;YAC/F,MAAME,QAAQC,GAAG,CAACG;YAClB;QACF;QAEA,MAAMG,qBAAqC,IAAIC;QAC/C,KAAK,MAAMC,eAAeP,yBAA0B;YAClD,IAAI,CAACzB,sBAAsBmB,GAAG,CAACa,cAAc;gBAC3CF,mBAAmBG,GAAG,CAACD;YACzB;QACF;QAEA,KAAK,MAAME,qBAAqBJ,mBAAoB;YAClD,MAAMD,UAAUf,cAAcF,YAAYC,YAAYqB;YAEtDlC,sBAAsBmC,GAAG,CAACD,mBAAmBL;YAE7CF,qBAAqBS,IAAI,CAACP;QAC5B;QAEAA,UAAUN,QAAQC,GAAG,CAACG;IACxB,OAAO;QACLE,UAAUf,cAAcF,YAAYC,YAAYX,UAAUmC,IAAI;QAE9D,wFAAwF;QACxF,KAAK,MAAMC,uBAAuBb,yBAA0B;YAC1D,IAAI,CAACzB,sBAAsBmB,GAAG,CAACmB,sBAAsB;gBACnDtC,sBAAsBmC,GAAG,CAACG,qBAAqBT;YACjD;QACF;IACF;IAEA,KAAK,MAAMb,YAAYD,aAAc;QACnC,IAAI,CAAChB,iBAAiBoB,GAAG,CAACH,WAAW;YACnC,qIAAqI;YACrI,yGAAyG;YACzGjB,iBAAiBoC,GAAG,CAACnB,UAAUa;QACjC;IACF;IAEA,MAAMA;AACR;AAEA,MAAMU,cAAchB,QAAQiB,OAAO,CAACC;AACpC,MAAMC,gCAAgC,IAAIC;AAI1C,wFAAwF;AACxF,SAASC,eAEPC,QAAkB;IAElB,OAAOC,uBAAuB1C,WAAWC,MAAM,EAAE,IAAI,CAACC,CAAC,CAACC,EAAE,EAAEsC;AAC9D;AACApD,wBAAwBsD,CAAC,GAAGH;AAE5B,MAAMI,gBAAgB,IAAInD;AAE1B;;;CAGC,GACD,SAASoD,WAEPC,SAAiB;IAEjB,+DAA+D;IAC/D,IAAIrB,UAAUmB,cAAc5B,GAAG,CAAC8B;IAChC,IAAIrB,SAAS;QACX,OAAOA;IACT;IAEAA,UAAU,IAAIN,QAAc,CAACiB,SAASW;QACpC,MAAMC,SAASC,SAASC,aAAa,CAAC;QACtCF,OAAOG,WAAW,GAAGC;QACrBJ,OAAOK,GAAG,GAAGP;QACbE,OAAOM,MAAM,GAAG,IAAMlB;QACtBY,OAAOO,OAAO,GAAG,IACfR,OAAO,IAAIS,MAAM,CAAC,uBAAuB,EAAEV,WAAW;QACxDG,SAASQ,IAAI,CAACC,WAAW,CAACV;IAC5B;IAEAJ,cAAcb,GAAG,CAACe,WAAWrB;IAC7B,OAAOA;AACT;AACApC,wBAAwBsE,CAAC,GAAGd;AAE5B,wFAAwF;AACxF,SAASH,uBACPlC,UAAsB,EACtBC,UAAsB,EACtBgC,QAAkB;IAElB,MAAMmB,WAAWC,QAAQC,eAAe,CAACtD,YAAYiC;IACrD,IAAIsB,QAAQzB,8BAA8BtB,GAAG,CAAC4C;IAC9C,IAAIG,UAAU1B,WAAW;QACvB,MAAMD,UAAUE,8BAA8BP,GAAG,CAACiC,IAAI,CACpD1B,+BACAsB,UACAzB;QAEF4B,QAAQH,SAASK,IAAI,CAAC7B,SAAS8B,KAAK,CAAC,CAACC;YACpC,IAAIC;YACJ,OAAQ5D;gBACN,KAAKR,WAAWO,OAAO;oBACrB6D,aAAa,CAAC,iCAAiC,EAAE3D,YAAY;oBAC7D;gBACF,KAAKT,WAAWC,MAAM;oBACpBmE,aAAa,CAAC,YAAY,EAAE3D,YAAY;oBACxC;gBACF,KAAKT,WAAWqE,MAAM;oBACpBD,aAAa;oBACb;gBACF;oBACEE,UACE9D,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;YAE1D;YACA,IAAI+D,QAAQ,IAAIf,MACd,CAAC,qBAAqB,EAAEf,SAAS,CAAC,EAAE2B,aAClCD,QAAQ,CAAC,EAAE,EAAEA,OAAO,GAAG,IACvB,EACFA,QAAQ;gBAAEA;YAAM,IAAI9B;YAEtBkC,MAAMC,IAAI,GAAG;YACb,MAAMD;QACR;QACAjC,8BAA8BP,GAAG,CAAC6B,UAAUG;IAC9C;IAEA,OAAOA;AACT;AAEA,wFAAwF;AACxF,SAASrD,cACPF,UAAsB,EACtBC,UAAsB,EACtBH,SAAoB;IAEpB,MAAMmE,MAAMC,oBAAoBpE;IAChC,OAAOoC,uBAAuBlC,YAAYC,YAAYgE;AACxD;AAEA;;CAEC,GACD,SAASE,sBAEPC,QAAgB;IAEhB,MAAMC,WAAW,IAAI,CAACC,CAAC,CAACF;IACxB,OAAOC,UAAUE,WAAWF;AAC9B;AACAxF,wBAAwB2F,CAAC,GAAGL;AAE5B;;;CAGC,GACD,SAASM,oBAAoBC,UAAmB;IAC9C,OAAO,CAAC,MAAM,EAAEA,cAAc,IAAI;AACpC;AACA7F,wBAAwB8F,CAAC,GAAGF;AAE5B;;;;CAIC,GACD,SAASG,eAAeF,UAAmB;IACzC,IAAI,CAACA,YAAY,OAAO;IACxB,OAAO,CAAC,aAAa,EAAEA,WACpBG,KAAK,CAAC,KACNvE,GAAG,CAACwE,oBACJC,IAAI,CAAC,MAAM;AAChB;AACAlG,wBAAwBmG,CAAC,GAAGJ;AAE5B;;CAEC,GACD,SAASK,UAEPhB,GAAW,EACXtE,EAAwB;IAExBuF,YAAYC,IAAI,CAAC,IAAI,EAAE,GAAGlB,MAAMmB,cAAc,EAAEzF;AAClD;AACAd,wBAAwBwG,CAAC,GAAGJ;AAE5B;;CAEC,GACD,SAASK,yBACPlB,QAAkB,EAClBtE,SAAoB;IAEpB,OAAOyF,kBAAkBnB,UAAU5E,WAAWO,OAAO,EAAED;AACzD;AACA;;CAEC,GACD,SAASoE,oBACPpE,SAAoC,EACpCrB,WAAmBC,eAAe;IAElC,OAAO,GAAGF,wBAAwBC,YAAYqB,UAC3C+E,KAAK,CAAC,KACNvE,GAAG,CAAC,CAAC1B,IAAMkG,mBAAmBlG,IAC9BmG,IAAI,CAAC,OAAOK,cAAc;AAC/B;AAEA,2EAA2E;AAC3E,qFAAqF;AACrFvG,wBAAwB2G,CAAC,GAAG9G;AAC5BG,wBAAwB4G,CAAC,GAAGL;AAE5B,4EAA4E;AAC5E,6EAA6E;AAC7EvG,wBAAwB6G,CAAC,GAAGxB;AAS5B,SAASyB,kBACPC,WAAsE;IAEtE,IAAI,OAAOA,gBAAgB,UAAU;QACnC,OAAOA;IACT;IACA,MAAM3D,WAAW2D,YAAY/C,GAAG;IAChC,MAAMA,MAAMgD,mBAAmB5D,SAAS6D,OAAO,CAAC,WAAW;IAC3D,MAAMC,kBAAkBvH;IACxB,IAAIiD,OAAOoB,IAAImD,UAAU,CAACD,mBACtBlD,IAAIoD,KAAK,CAACF,gBAAgBtF,MAAM,IAChCoC;IACJ,IAAIpB,KAAKuE,UAAU,CAAC,MAAM;QACxBvE,OAAOA,KAAKwE,KAAK,CAAC;IACpB;IACA,OAAOxE;AACT;AAEA;;CAEC,GACD,SAASyE,iBAAiBC,KAA8B;IACtD,IAAI,OAAOA,UAAU,UAAU;QAC7B,OAAOjC,oBAAoBiC;IAC7B,OAAO;QACL,uCAAuC;QACvC,OAAOA,MAAMtD,GAAG;IAClB;AACF;AAEA;;CAEC,GACD,SAASuD,yBACPD,KAA6B;IAE7B,IAAI,OAAOA,UAAU,UAAU;QAC7B,OAAOA;IACT,OAAO,IAAI,CAACA,OAAO;QACjB,IAAI,OAAOE,8BAA8B,aAAa;YACpD,OAAO;gBAAExD,KAAKwD,0BAA0BC,GAAG;YAAI;QACjD,OAAO;YACL,MAAM,IAAItD,MAAM;QAClB;IACF,OAAO;QACL,OAAO;YAAEH,KAAKsD,MAAMI,YAAY,CAAC;QAAQ;IAC3C;AACF;AAEA;;;CAGC,GACD,SAASC,kBACPC,cAAoC,EACpCC,GAAW;IAEX,sDAAsD;IACtD,MAAMrB,IAAIoB,eAAeE,OAAO,CAAC;IACjC,IAAIC;IACJ,IAAIvB,MAAM,CAAC,GAAG;QACZuB,MAAMvB;IACR,OAAO;QACL,MAAMK,IAAIe,eAAeE,OAAO,CAAC;QACjCC,MAAMlB,MAAM,CAAC,IAAIA,IAAIe,eAAehG,MAAM;IAC5C;IACA,oDAAoD;IACpD,OAAOmG,OAAOF,IAAIjG,MAAM,IAAIgG,eAAeT,UAAU,CAACU,KAAKE,MAAMF,IAAIjG,MAAM;AAC7E;AAEA,SAASoG,KAAKJ,cAAoC;IAChD,OAAOD,kBAAkBC,gBAAgB;AAC3C;AAEA,SAASK,MAAM7E,QAAkB;IAC/B,OAAOuE,kBAAkBvE,UAAU;AACrC","ignoreList":[0]}},
     {"offset": {"line": 908, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/hmr-runtime.ts"],"sourcesContent":["/// <reference path=\"./runtime-utils.ts\" />\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n\ntype HotModuleFactoryFunction = ModuleFactoryFunction<\n  HotModule,\n  TurbopackBaseContext<HotModule>\n>\n\n/**\n * Shared HMR (Hot Module Replacement) implementation.\n *\n * This file contains the complete HMR implementation that's shared between\n * browser and Node.js runtimes. It manages module hot state, dependency\n * tracking, the module.hot API, and the full HMR update flow.\n */\n\n/**\n * The development module cache shared across the runtime.\n * Browser runtime declares this directly.\n * Node.js runtime assigns globalThis.__turbopack_module_cache__ to this.\n */\nlet devModuleCache: Record<ModuleId, any>\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nlet runtimeModules: Set<ModuleId>\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n\n/**\n * Maps module instances to their hot module state.\n * Uses WeakMap so it works with both HotModule and ModuleWithDirection.\n */\nconst moduleHotState: WeakMap<any, HotState> = new WeakMap()\n\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n      parentId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n      outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n    }\n\n/**\n * Records parent-child relationship when a module imports another.\n * Should be called during module instantiation.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction trackModuleImport(\n  parentModule: ModuleWithDirection,\n  childModuleId: ModuleId,\n  childModule: ModuleWithDirection | undefined\n): void {\n  // Record that parent imports child\n  if (parentModule.children.indexOf(childModuleId) === -1) {\n    parentModule.children.push(childModuleId)\n  }\n\n  // Record that child is imported by parent\n  if (childModule && childModule.parents.indexOf(parentModule.id) === -1) {\n    childModule.parents.push(parentModule.id)\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\n/**\n * Walks the dependency tree to find all modules affected by a change.\n * Returns information about whether the update can be accepted and which\n * modules need to be invalidated.\n *\n * @param moduleId - The module that changed\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept().\n *                           This is used for server-side HMR where pages auto-accept at the top level.\n */\nfunction getAffectedModuleEffects(\n  moduleId: ModuleId,\n  autoAcceptRootModules: boolean\n): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n  const outdatedDependencies: Map<ModuleId, Set<ModuleId>> = new Map()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      if (autoAcceptRootModules) {\n        return {\n          type: 'accepted',\n          moduleId,\n          outdatedModules,\n          outdatedDependencies,\n        }\n      }\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      if (autoAcceptRootModules) {\n        continue\n      }\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        continue\n      }\n\n      const parentHotState = moduleHotState.get(parent)\n\n      // Check if parent declined this dependency\n      if (parentHotState?.declinedDependencies[moduleId]) {\n        return {\n          type: 'declined',\n          dependencyChain: [...dependencyChain, moduleId],\n          moduleId,\n          parentId,\n        }\n      }\n\n      // Skip if parent is already outdated\n      if (outdatedModules.has(parentId)) {\n        continue\n      }\n\n      // Check if parent accepts this dependency\n      if (parentHotState?.acceptedDependencies[moduleId]) {\n        if (!outdatedDependencies.has(parentId)) {\n          outdatedDependencies.set(parentId, new Set())\n        }\n        outdatedDependencies.get(parentId)!.add(moduleId)\n        continue\n      }\n\n      // Neither accepted nor declined — propagate to parent\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n\n    // If no parents and we're at a root module, auto-accept if configured\n    if (module.parents.length === 0 && autoAcceptRootModules) {\n      continue\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n    outdatedDependencies,\n  }\n}\n\n/**\n * Merges source dependency map into target dependency map.\n */\nfunction mergeDependencies(\n  target: Map<ModuleId, Set<ModuleId>>,\n  source: Map<ModuleId, Set<ModuleId>>\n): void {\n  for (const [parentId, deps] of source) {\n    const existing = target.get(parentId)\n    if (existing) {\n      for (const dep of deps) {\n        existing.add(dep)\n      }\n    } else {\n      target.set(parentId, new Set(deps))\n    }\n  }\n}\n\n/**\n * Computes all modules that need to be invalidated based on which modules changed.\n *\n * @param invalidated - The modules that have been invalidated\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>,\n  autoAcceptRootModules: boolean\n): {\n  outdatedModules: Set<ModuleId>\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n} {\n  const outdatedModules = new Set<ModuleId>()\n  const outdatedDependencies = new Map<ModuleId, Set<ModuleId>>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId, autoAcceptRootModules)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'declined':\n        throw new UpdateApplyError(\n          `cannot apply update: declined dependency. ${formatDependencyChain(\n            effect.dependencyChain\n          )}. Declined by ${effect.parentId}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        mergeDependencies(outdatedDependencies, effect.outdatedDependencies)\n        break\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return { outdatedModules, outdatedDependencies }\n}\n\n/**\n * Creates the module.hot API object and its internal state.\n * This provides the HMR API that user code calls (module.hot.accept(), etc.)\n */\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n    acceptedDependencies: {},\n    acceptedErrorHandlers: {},\n    declinedDependencies: {},\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      callback?: AcceptCallback,\n      errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else if (typeof modules === 'object' && modules !== null) {\n        for (let i = 0; i < modules.length; i++) {\n          hotState.acceptedDependencies[modules[i]] = callback || function () {}\n          hotState.acceptedErrorHandlers[modules[i]] = errorHandler\n        }\n      } else {\n        hotState.acceptedDependencies[modules] = callback || function () {}\n        hotState.acceptedErrorHandlers[modules] = errorHandler\n      }\n    },\n\n    decline: (dep?: string | string[]) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else if (typeof dep === 'object' && dep !== null) {\n        for (let i = 0; i < dep.length; i++) {\n          hotState.declinedDependencies[dep[i]] = true\n        }\n      } else {\n        hotState.declinedDependencies[dep] = true\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Processes queued invalidated modules and adds them to the outdated modules set.\n * Modules that call module.hot.invalidate() are queued and processed here.\n *\n * @param outdatedModules - The current set of outdated modules\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction applyInvalidatedModules(\n  outdatedModules: Set<ModuleId>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>,\n  autoAcceptRootModules: boolean\n): {\n  outdatedModules: Set<ModuleId>\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n} {\n  if (queuedInvalidatedModules.size > 0) {\n    const result = computedInvalidatedModules(\n      queuedInvalidatedModules,\n      autoAcceptRootModules\n    )\n    for (const moduleId of result.outdatedModules) {\n      outdatedModules.add(moduleId)\n    }\n    mergeDependencies(outdatedDependencies, result.outdatedDependencies)\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return { outdatedModules, outdatedDependencies }\n}\n\n/**\n * Computes which outdated modules have self-accepted and can be hot reloaded.\n */\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)\n    if (module && hotState?.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Disposes of an instance of a module.\n * Runs hot.dispose handlers and manages persistent hot data.\n *\n * NOTE: mode = \"replace\" will not remove modules from devModuleCache.\n * This must be done in a separate step afterwards.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)\n  if (!hotState) {\n    return\n  }\n\n  const data: HotData = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  if (module.hot) {\n    module.hot.active = false\n  }\n\n  moduleHotState.delete(module)\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\n/**\n * Dispose phase: runs dispose handlers and cleans up outdated/disposed modules.\n * Returns the parent modules of outdated modules for use in the apply phase.\n */\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map<ModuleId, Array<ModuleId>>()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // Remove outdated dependencies from parent module's children list.\n  // When a parent accepts a child's update, the child is re-instantiated\n  // but the parent stays alive. We remove the old child reference so it\n  // gets re-added when the child re-imports.\n  for (const [parentId, deps] of outdatedDependencies) {\n    const module = devModuleCache[parentId]\n    if (module) {\n      for (const dep of deps) {\n        const idx = module.children.indexOf(dep)\n        if (idx >= 0) {\n          module.children.splice(idx, 1)\n        }\n      }\n    }\n  }\n\n  return { outdatedModuleParents }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/**\n * Shared module instantiation logic.\n * This handles the full module instantiation flow for both browser and Node.js.\n * Only React Refresh hooks differ between platforms (passed as callback).\n */\nfunction instantiateModuleShared(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData,\n  moduleFactories: ModuleFactories,\n  devModuleCache: ModuleCache<HotModule>,\n  runtimeModules: Set<ModuleId>,\n  createModuleObjectFn: (id: ModuleId) => HotModule,\n  createContextFn: (module: HotModule, exports: Exports, refresh?: any) => any,\n  runModuleExecutionHooksFn: (\n    module: HotModule,\n    exec: (refresh: any) => void\n  ) => void\n): HotModule {\n  // 1. Factory validation (same in both browser and Node.js)\n  const id = moduleId\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    throw new Error(\n      factoryNotAvailableMessage(moduleId, sourceType, sourceData) +\n        `\\nThis is often caused by a stale browser cache, misconfigured Cache-Control headers, or a service worker serving outdated responses.` +\n        `\\nTo fix this, make sure your Cache-Control headers allow revalidation of chunks and review your service worker configuration. ` +\n        `As an immediate workaround, try hard-reloading the page, clearing the browser cache, or unregistering any service workers.`\n    )\n  }\n\n  // 2. Hot API setup (same in both - works for browser, included for Node.js)\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  // 3. Parent assignment logic (same in both)\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      throw new Error(`Unknown source type: ${sourceType}`)\n  }\n\n  // 4. Module creation (platform creates base module object)\n  const module = createModuleObjectFn(id)\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // 5. Module execution (React Refresh hooks are platform-specific)\n  try {\n    runModuleExecutionHooksFn(module, (refresh) => {\n      const context = createContextFn(module, exports, refresh)\n      moduleFactory.call(exports, context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  // 6. ESM interop (same in both)\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n/**\n * Analyzes update entries and chunks to determine which modules were added, modified, or deleted.\n * This is pure logic that doesn't depend on the runtime environment.\n */\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>,\n  chunkModulesMap?: Map<ChunkPath, Set<ModuleId>>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        const updateDeleted = chunkModulesMap\n          ? new Set(chunkModulesMap.get(chunkPath))\n          : new Set<ModuleId>()\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        throw new Error('Unknown merged chunk update type')\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\n/**\n * Compiles new module code and walks the dependency tree to find all outdated modules.\n * Uses the evalModuleEntry function to compile code (platform-specific).\n *\n * @param added - Map of added modules\n * @param modified - Map of modified modules\n * @param evalModuleEntry - Function to compile module code\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>,\n  evalModuleEntry: (entry: EcmascriptModuleEntry) => HotModuleFactoryFunction,\n  autoAcceptRootModules: boolean\n): {\n  outdatedModules: Set<ModuleId>\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>\n  newModuleFactories: Map<ModuleId, HotModuleFactoryFunction>\n} {\n  const newModuleFactories = new Map<ModuleId, HotModuleFactoryFunction>()\n\n  // Compile added modules\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, evalModuleEntry(entry))\n    }\n  }\n\n  // Walk dependency tree to find all modules affected by modifications\n  const { outdatedModules, outdatedDependencies } = computedInvalidatedModules(\n    modified.keys(),\n    autoAcceptRootModules\n  )\n\n  // Compile modified modules\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, evalModuleEntry(entry))\n  }\n\n  return { outdatedModules, outdatedDependencies, newModuleFactories }\n}\n\n/**\n * Updates module factories and re-instantiates self-accepted modules.\n * Uses the instantiateModule function (platform-specific via callback).\n */\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, HotModuleFactoryFunction>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>,\n  moduleFactories: ModuleFactories,\n  devModuleCache: ModuleCache<HotModule>,\n  instantiateModuleFn: (\n    moduleId: ModuleId,\n    sourceType: SourceType,\n    sourceData: SourceData\n  ) => HotModule,\n  applyModuleFactoryNameFn: (factory: HotModuleFactoryFunction) => void,\n  reportError: (err: any) => void\n) {\n  // Update module factories\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryNameFn(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // Call accept handlers for outdated dependencies.\n  // This runs BEFORE re-instantiating self-accepted modules, matching\n  // webpack's behavior.\n  for (const [parentId, deps] of outdatedDependencies) {\n    const module = devModuleCache[parentId]\n    if (!module) continue\n\n    const hotState = moduleHotState.get(module)\n    if (!hotState) continue\n\n    // Group deps by callback, deduplicating callbacks that handle multiple deps.\n    // Each callback receives only the deps it was registered for.\n    const callbackDeps = new Map<AcceptCallback | (() => void), ModuleId[]>()\n    const callbackErrorHandlers = new Map<\n      AcceptCallback | (() => void),\n      AcceptErrorHandler | undefined\n    >()\n\n    for (const dep of deps) {\n      const acceptCallback = hotState.acceptedDependencies[dep]\n      if (acceptCallback) {\n        let depList = callbackDeps.get(acceptCallback)\n        if (!depList) {\n          depList = []\n          callbackDeps.set(acceptCallback, depList)\n          callbackErrorHandlers.set(\n            acceptCallback,\n            hotState.acceptedErrorHandlers[dep]\n          )\n        }\n        depList.push(dep)\n      }\n    }\n\n    for (const [callback, cbDeps] of callbackDeps) {\n      try {\n        callback.call(null, cbDeps)\n      } catch (err: any) {\n        const errorHandler = callbackErrorHandlers.get(callback)\n        if (typeof errorHandler === 'function') {\n          try {\n            errorHandler(err, {\n              moduleId: parentId,\n              dependencyId: cbDeps[0],\n            })\n          } catch (err2) {\n            reportError(err2)\n            reportError(err)\n          }\n        } else {\n          reportError(err)\n        }\n      }\n    }\n  }\n\n  // Re-instantiate all outdated self-accepted modules\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModuleFn(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\n/**\n * Internal implementation that orchestrates the full HMR update flow:\n * invalidation, disposal, and application of new modules.\n *\n * @param autoAcceptRootModules - If true, root modules auto-accept updates without explicit module.hot.accept()\n */\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  outdatedDependencies: Map<ModuleId, Set<ModuleId>>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, HotModuleFactoryFunction>,\n  moduleFactories: ModuleFactories,\n  devModuleCache: ModuleCache<HotModule>,\n  instantiateModuleFn: (\n    moduleId: ModuleId,\n    sourceType: SourceType,\n    sourceData: SourceData\n  ) => HotModule,\n  applyModuleFactoryNameFn: (factory: HotModuleFactoryFunction) => void,\n  autoAcceptRootModules: boolean\n) {\n  ;({ outdatedModules, outdatedDependencies } = applyInvalidatedModules(\n    outdatedModules,\n    outdatedDependencies,\n    autoAcceptRootModules\n  ))\n\n  // Find self-accepted modules to re-instantiate\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  // Run dispose handlers, save hot.data, clear caches\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules,\n    outdatedDependencies\n  )\n\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err // Keep first error\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    outdatedDependencies,\n    moduleFactories,\n    devModuleCache,\n    instantiateModuleFn,\n    applyModuleFactoryNameFn,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  // Recursively apply any queued invalidations from new module execution\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(\n      new Set(),\n      new Map(),\n      [],\n      new Map(),\n      moduleFactories,\n      devModuleCache,\n      instantiateModuleFn,\n      applyModuleFactoryNameFn,\n      autoAcceptRootModules\n    )\n  }\n}\n\n/**\n * Main entry point for applying an ECMAScript merged update.\n * This is called by both browser and Node.js runtimes with platform-specific callbacks.\n *\n * @param options.autoAcceptRootModules - If true, root modules auto-accept updates without explicit\n *                                   module.hot.accept(). Used for server-side HMR where pages\n *                                   auto-accept at the top level.\n */\nfunction applyEcmascriptMergedUpdateShared(options: {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  disposedModules: Iterable<ModuleId>\n  evalModuleEntry: (entry: EcmascriptModuleEntry) => HotModuleFactoryFunction\n  instantiateModule: (\n    moduleId: ModuleId,\n    sourceType: SourceType,\n    sourceData: SourceData\n  ) => HotModule\n  applyModuleFactoryName: (factory: HotModuleFactoryFunction) => void\n  moduleFactories: ModuleFactories\n  devModuleCache: ModuleCache<HotModule>\n  autoAcceptRootModules: boolean\n}) {\n  const {\n    added,\n    modified,\n    disposedModules,\n    evalModuleEntry,\n    instantiateModule,\n    applyModuleFactoryName,\n    moduleFactories,\n    devModuleCache,\n    autoAcceptRootModules,\n  } = options\n\n  const { outdatedModules, outdatedDependencies, newModuleFactories } =\n    computeOutdatedModules(\n      added,\n      modified,\n      evalModuleEntry,\n      autoAcceptRootModules\n    )\n\n  applyInternal(\n    outdatedModules,\n    outdatedDependencies,\n    disposedModules,\n    newModuleFactories,\n    moduleFactories,\n    devModuleCache,\n    instantiateModule,\n    applyModuleFactoryName,\n    autoAcceptRootModules\n  )\n}\n"],"names":["devModuleCache","runtimeModules","moduleHotData","Map","moduleHotState","WeakMap","queuedInvalidatedModules","Set","UpdateApplyError","Error","name","message","dependencyChain","trackModuleImport","parentModule","childModuleId","childModule","children","indexOf","push","parents","id","formatDependencyChain","join","getAffectedModuleEffects","moduleId","autoAcceptRootModules","outdatedModules","outdatedDependencies","queue","nextItem","shift","has","add","undefined","type","module","hotState","get","selfAccepted","selfInvalidated","selfDeclined","parentId","parent","parentHotState","declinedDependencies","acceptedDependencies","set","length","mergeDependencies","target","source","deps","existing","dep","computedInvalidatedModules","invalidated","effect","outdatedModuleId","invariant","createModuleHot","hotData","disposeHandlers","acceptedErrorHandlers","hot","active","data","accept","modules","callback","errorHandler","i","decline","dispose","addDisposeHandler","removeDisposeHandler","idx","splice","invalidate","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","applyInvalidatedModules","size","result","clear","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","disposeModule","mode","disposeHandler","delete","childId","child","disposePhase","disposedModules","outdatedModuleParents","oldModule","instantiateModuleShared","sourceType","sourceData","moduleFactories","createModuleObjectFn","createContextFn","runModuleExecutionHooksFn","moduleFactory","factoryNotAvailableMessage","SourceType","Runtime","Parent","Update","exports","refresh","context","call","error","namespaceObject","interopEsm","computeChangedModules","entries","updates","chunkModulesMap","chunksAdded","chunksDeleted","added","modified","deleted","chunkPath","mergedChunkUpdate","Object","updateAdded","updateDeleted","keys","entry","computeOutdatedModules","evalModuleEntry","newModuleFactories","applyPhase","instantiateModuleFn","applyModuleFactoryNameFn","reportError","factory","callbackDeps","callbackErrorHandlers","acceptCallback","depList","cbDeps","err","dependencyId","err2","applyInternal","applyEcmascriptMergedUpdateShared","options","instantiateModule","applyModuleFactoryName"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"../../../shared/runtime/dev-globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/dev-protocol.d.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// Assign browser's module cache and runtime modules to shared HMR state\ndevModuleCache = Object.create(null)\ndevContextPrototype.c = devModuleCache\nruntimeModules = new Set()\n\n// Set flag to indicate we use ModuleWithDirection\ncreateModuleWithDirectionFlag = true\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\nfunction getRefreshBoundaryExports<T>(exports: T): T {\n  if (\n    typeof isAsyncModuleExt === 'function' &&\n    exports != null &&\n    typeof exports === 'object' &&\n    isAsyncModuleExt(exports)\n  ) {\n    return exports[turbopackExports] as T\n  }\n  return exports\n}\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  loadChunkReplacing?: (chunkUrl: ChunkUrl) => Promise<void>\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  rejectChunk?: (chunkPath: ChunkPath, error: Error) => void\n  resolveChunk?: (chunkUrl: ChunkUrl) => void\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  unloadChunkExact?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\ntype DevChunkList = ChunkList & {\n  chunkVersions: Record<ChunkPath, string>\n  version: string\n}\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\ntype DynamicChunkListLoadState = {\n  generation: number\n  loading: boolean\n  bootstrapping: boolean\n  terminated: boolean\n  pendingTasks: Set<Promise<void>>\n  memberChunkUrls: Map<ChunkPath, ChunkUrl>\n  rejectSubscribed?: (error: Error) => void\n}\n\ntype PendingHmrTask = {\n  chunkLists: Array<{ path: ChunkListPath; generation: number }>\n  apply: (currentPaths: ReadonlySet<ChunkListPath>) => HmrResourceOperation[]\n  resolve: () => void\n  reject: (error: unknown) => void\n}\n\ntype HmrResourceOperation = {\n  chunkPath: ChunkPath\n  promise: Promise<void>\n}\n\nconst dynamicChunkListLoadStates: Map<\n  ChunkListPath,\n  DynamicChunkListLoadState\n> = new Map()\nconst pendingHmrTasks: PendingHmrTask[] = []\nconst chunkListGenerations: Map<ChunkListPath, number> = new Map()\nlet nextChunkListGeneration = 1\nlet activeHmrTask: PendingHmrTask | undefined\nconst dynamicMemberChunkUrlOwners: Map<\n  ChunkUrl,\n  Map<ChunkListPath, number>\n> = new Map()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // Browser: creates base HotModule object (hot API added by shared code)\n  const createModuleObjectFn = (id: ModuleId) => {\n    return createModuleObject(id) as HotModule\n  }\n\n  // Browser: creates DevContext with refresh\n  const createContext = (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ) => {\n    return new (DevContext as any as DevContextConstructor)(\n      module,\n      exports,\n      refresh\n    )\n  }\n\n  // Use shared instantiation logic (includes hot API setup)\n  return instantiateModuleShared(\n    moduleId,\n    sourceType,\n    sourceData,\n    moduleFactories,\n    devModuleCache,\n    runtimeModules,\n    createModuleObjectFn,\n    createContext,\n    runModuleExecutionHooks\n  )\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = getRefreshBoundaryExports(module.exports)\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\ntype ChunkOwnershipTransition = {\n  before: number\n  after: number\n}\n\nconst PARALLEL_UPDATE_CONFLICT = Symbol('parallel update conflict')\n\nfunction mergeParallelChunkUpdate(\n  updateA: ChunkUpdate,\n  updateB: ChunkUpdate\n): ChunkUpdate | null | typeof PARALLEL_UPDATE_CONFLICT {\n  if (updateA.type === updateB.type) {\n    return updateA\n  }\n  if (updateA.type === 'total' || updateB.type === 'total') {\n    return { type: 'total' }\n  }\n  if (\n    (updateA.type === 'added' && updateB.type === 'deleted') ||\n    (updateA.type === 'deleted' && updateB.type === 'added')\n  ) {\n    return null\n  }\n  return PARALLEL_UPDATE_CONFLICT\n}\n\nfunction mergeParallelEcmascriptChunkUpdate(\n  updateA: EcmascriptMergedChunkUpdate,\n  updateB: EcmascriptMergedChunkUpdate\n): EcmascriptMergedChunkUpdate | typeof PARALLEL_UPDATE_CONFLICT {\n  if (updateA.type === 'added' && updateB.type === 'added') {\n    return {\n      type: 'added',\n      modules: [\n        ...new Set([...(updateA.modules ?? []), ...(updateB.modules ?? [])]),\n      ],\n    }\n  }\n  if (updateA.type === 'deleted' && updateB.type === 'deleted') {\n    return {\n      type: 'deleted',\n      modules: [\n        ...new Set([...(updateA.modules ?? []), ...(updateB.modules ?? [])]),\n      ],\n    }\n  }\n  if (updateA.type === 'partial' && updateB.type === 'partial') {\n    const added = new Set([...(updateA.added ?? []), ...(updateB.added ?? [])])\n    const deleted = new Set([\n      ...(updateA.deleted ?? []),\n      ...(updateB.deleted ?? []),\n    ])\n    for (const moduleId of added) {\n      if (deleted.has(moduleId)) {\n        added.delete(moduleId)\n        deleted.delete(moduleId)\n      }\n    }\n    return { type: 'partial', added: [...added], deleted: [...deleted] }\n  }\n  if (\n    (updateA.type === 'added' && updateB.type === 'deleted') ||\n    (updateA.type === 'deleted' && updateB.type === 'added')\n  ) {\n    const addedUpdate = updateA.type === 'added' ? updateA : updateB\n    const deletedUpdate = updateA.type === 'deleted' ? updateA : updateB\n    const added = new Set(addedUpdate.modules ?? [])\n    const deleted = new Set(deletedUpdate.modules ?? [])\n    for (const moduleId of added) {\n      if (deleted.has(moduleId)) {\n        added.delete(moduleId)\n        deleted.delete(moduleId)\n      }\n    }\n    return { type: 'partial', added: [...added], deleted: [...deleted] }\n  }\n\n  if (updateA.type === 'partial') {\n    if (\n      (updateA.added?.length ?? 0) === 0 &&\n      (updateA.deleted?.length ?? 0) === 0\n    ) {\n      return updateB\n    }\n    return PARALLEL_UPDATE_CONFLICT\n  }\n  if (updateB.type === 'partial') {\n    if (\n      (updateB.added?.length ?? 0) === 0 &&\n      (updateB.deleted?.length ?? 0) === 0\n    ) {\n      return updateA\n    }\n    return PARALLEL_UPDATE_CONFLICT\n  }\n  return PARALLEL_UPDATE_CONFLICT\n}\n\nfunction moduleEntriesEqual(\n  entryA: EcmascriptModuleEntry,\n  entryB: EcmascriptModuleEntry\n) {\n  // The same module can be emitted into multiple chunks. Its source URL is\n  // chunk-relative, so it is allowed to differ even when the executable entry\n  // is identical. Treat only code and source map differences as conflicts.\n  return entryA.code === entryB.code && entryA.map === entryB.map\n}\n\nfunction applyChunkListUpdates(\n  updates: Array<{\n    chunkListPath: ChunkListPath\n    update: ChunkListUpdate\n  }>\n): HmrResourceOperation[] {\n  const resourceOperations: HmrResourceOperation[] = []\n  const ownershipTransitions = new Map<ChunkPath, ChunkOwnershipTransition>()\n  const chunks = new Map<ChunkPath, ChunkUpdate | null>()\n  const ecmascriptChunks = new Map<ChunkPath, EcmascriptMergedChunkUpdate>()\n  const entries: Record<ModuleId, EcmascriptModuleEntry> = {}\n  const explicitlyModifiedModules = new Set<ModuleId>()\n  let hasConflict = false\n\n  for (const { chunkListPath, update } of updates) {\n    if (update.chunks) {\n      for (const [chunkPath, chunkUpdate] of Object.entries(\n        update.chunks\n      ) as Array<[ChunkPath, ChunkUpdate]>) {\n        if (chunkUpdate.type === 'added' || chunkUpdate.type === 'deleted') {\n          if (\n            !applyChunkListMembershipDelta(\n              chunkListPath,\n              chunkPath,\n              chunkUpdate.type,\n              ownershipTransitions\n            )\n          ) {\n            hasConflict = true\n          }\n        }\n\n        if (!chunks.has(chunkPath)) {\n          chunks.set(chunkPath, chunkUpdate)\n        } else {\n          const previous = chunks.get(chunkPath)\n          if (previous === null) {\n            chunks.set(chunkPath, chunkUpdate)\n          } else {\n            const merged = mergeParallelChunkUpdate(previous!, chunkUpdate)\n            if (merged === PARALLEL_UPDATE_CONFLICT) {\n              hasConflict = true\n            } else {\n              chunks.set(chunkPath, merged)\n            }\n          }\n        }\n      }\n    }\n\n    for (const merged of update.merged ?? []) {\n      if (merged.type !== 'EcmascriptMergedUpdate') {\n        invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n\n      const addedInThisUpdate = new Set<ModuleId>()\n      for (const [chunkPath, chunkUpdate] of Object.entries(\n        merged.chunks ?? {}\n      ) as Array<[ChunkPath, EcmascriptMergedChunkUpdate]>) {\n        if (chunkUpdate.type === 'added') {\n          for (const moduleId of chunkUpdate.modules ?? []) {\n            addedInThisUpdate.add(moduleId)\n          }\n          if (\n            !applyChunkListMembershipDelta(\n              chunkListPath,\n              chunkPath,\n              'added',\n              ownershipTransitions\n            )\n          ) {\n            hasConflict = true\n          }\n        } else if (chunkUpdate.type === 'deleted') {\n          if (\n            !applyChunkListMembershipDelta(\n              chunkListPath,\n              chunkPath,\n              'deleted',\n              ownershipTransitions\n            )\n          ) {\n            hasConflict = true\n          }\n        } else {\n          for (const moduleId of chunkUpdate.added ?? []) {\n            addedInThisUpdate.add(moduleId)\n          }\n        }\n\n        const previous = ecmascriptChunks.get(chunkPath)\n        if (!previous) {\n          ecmascriptChunks.set(chunkPath, chunkUpdate)\n        } else {\n          const combined = mergeParallelEcmascriptChunkUpdate(\n            previous,\n            chunkUpdate\n          )\n          if (combined === PARALLEL_UPDATE_CONFLICT) {\n            hasConflict = true\n          } else {\n            ecmascriptChunks.set(chunkPath, combined)\n          }\n        }\n      }\n\n      for (const [moduleId, entry] of Object.entries(merged.entries ?? {})) {\n        const previous = entries[moduleId]\n        if (previous) {\n          if (!moduleEntriesEqual(previous, entry)) {\n            hasConflict = true\n          }\n        } else {\n          entries[moduleId] = entry\n        }\n        if (!addedInThisUpdate.has(moduleId)) {\n          explicitlyModifiedModules.add(moduleId)\n        }\n      }\n    }\n  }\n\n  if (hasConflict) {\n    DEV_BACKEND.restart()\n    return resourceOperations\n  }\n\n  const filteredEcmascriptChunks: Record<\n    ChunkPath,\n    EcmascriptMergedChunkUpdate\n  > = {}\n  for (const [chunkPath, chunkUpdate] of ecmascriptChunks) {\n    const transition = ownershipTransitions.get(chunkPath)\n    if (chunkUpdate.type === 'added' && transition && transition.before > 0) {\n      for (const moduleId of chunkUpdate.modules ?? []) {\n        if (!explicitlyModifiedModules.has(moduleId)) {\n          delete entries[moduleId]\n        }\n      }\n      continue\n    }\n    if (chunkUpdate.type === 'deleted' && transition && transition.after > 0) {\n      continue\n    }\n    filteredEcmascriptChunks[chunkPath] = chunkUpdate\n  }\n\n  if (\n    Object.keys(entries).length > 0 ||\n    Object.keys(filteredEcmascriptChunks).length > 0\n  ) {\n    applyEcmascriptMergedUpdate({\n      type: 'EcmascriptMergedUpdate',\n      entries,\n      chunks: filteredEcmascriptChunks,\n    })\n  }\n\n  for (const [chunkPath, chunkUpdate] of chunks) {\n    if (chunkUpdate === null) {\n      continue\n    }\n    const transition = ownershipTransitions.get(chunkPath)\n    const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0\n    const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n    switch (chunkUpdate.type) {\n      case 'added':\n        if (!transition || (transition.before === 0 && transition.after > 0)) {\n          resourceOperations.push({\n            chunkPath,\n            promise: BACKEND.loadChunkCached(SourceType.Update, chunkUrl),\n          })\n        }\n        break\n      case 'total':\n        if (ownerCount > 0) {\n          const promise = DEV_BACKEND.reloadChunk?.(chunkUrl)\n          if (promise) {\n            resourceOperations.push({ chunkPath, promise })\n          }\n        }\n        break\n      case 'deleted':\n        if (!transition || (transition.before > 0 && transition.after === 0)) {\n          disposeChunk(chunkPath)\n        }\n        break\n      case 'partial':\n        invariant(\n          chunkUpdate.instruction,\n          (instruction) =>\n            `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n        )\n        break\n      default:\n        invariant(\n          chunkUpdate,\n          (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n        )\n    }\n  }\n\n  return resourceOperations\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  // Browser-specific chunk management phase\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks,\n    chunkModulesMap\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  // Use shared HMR update implementation\n  applyEcmascriptMergedUpdateShared({\n    added,\n    modified,\n    disposedModules,\n    evalModuleEntry: _eval, // browser's eval with source maps\n    instantiateModule, // now wraps shared logic\n    applyModuleFactoryName,\n    moduleFactories,\n    devModuleCache,\n    autoAcceptRootModules: false,\n  })\n}\n\nfunction getCurrentTaskPaths(task: PendingHmrTask): ChunkListPath[] {\n  return task.chunkLists\n    .filter(\n      ({ path, generation }) => chunkListGenerations.get(path) === generation\n    )\n    .map(({ path }) => path)\n}\n\nfunction isHmrTaskBlocked(task: PendingHmrTask): boolean {\n  return task.chunkLists.some(({ path, generation }) => {\n    if (chunkListGenerations.get(path) !== generation) return false\n    const state = dynamicChunkListLoadStates.get(path)\n    return state?.generation === generation && state.loading\n  })\n}\n\nfunction runHmrTask(task: PendingHmrTask) {\n  activeHmrTask = task\n  void (async () => {\n    let resourceOperations: HmrResourceOperation[] = []\n    try {\n      const currentPaths = new Set(getCurrentTaskPaths(task))\n      if (currentPaths.size > 0) {\n        resourceOperations = task.apply(currentPaths)\n        const results = await Promise.allSettled(\n          resourceOperations.map(({ promise }) => promise)\n        )\n        const failedIndex = results.findIndex(\n          (result, index) =>\n            result.status === 'rejected' &&\n            chunkChunkListsMap.has(resourceOperations[index].chunkPath)\n        )\n        if (failedIndex !== -1) {\n          throw (results[failedIndex] as PromiseRejectedResult).reason\n        }\n      }\n      task.resolve()\n    } catch (cause) {\n      // A terminal update invalidates the generation immediately. Any member\n      // request it cancelled belongs to that old generation and must not turn\n      // a valid replacement subscription into a page reload.\n      if (getCurrentTaskPaths(task).length === 0) {\n        task.resolve()\n      } else {\n        task.reject(cause)\n      }\n    } finally {\n      for (const { chunkPath } of resourceOperations) {\n        if (!chunkChunkListsMap.has(chunkPath)) {\n          disposeChunk(chunkPath)\n        }\n      }\n      if (activeHmrTask === task) {\n        activeHmrTask = undefined\n      }\n      flushPendingHmrTasks()\n    }\n  })()\n}\n\nfunction scheduleHmrTask(\n  chunkListPaths: ChunkListPath[],\n  apply: (currentPaths: ReadonlySet<ChunkListPath>) => HmrResourceOperation[]\n): Promise<void> {\n  const chunkLists = [...new Set(chunkListPaths)].flatMap((path) => {\n    const generation = chunkListGenerations.get(path)\n    return generation === undefined ? [] : [{ path, generation }]\n  })\n  if (chunkLists.length === 0) {\n    return Promise.resolve()\n  }\n\n  let resolve!: () => void\n  let reject!: (error: unknown) => void\n  const completion = new Promise<void>((innerResolve, innerReject) => {\n    resolve = innerResolve\n    reject = innerReject\n  })\n  const task: PendingHmrTask = { chunkLists, apply, resolve, reject }\n\n  for (const { path, generation } of chunkLists) {\n    const state = dynamicChunkListLoadStates.get(path)\n    if (\n      state?.generation === generation &&\n      state.bootstrapping &&\n      !state.terminated\n    ) {\n      state.pendingTasks.add(completion)\n      void completion.then(\n        () => state.pendingTasks.delete(completion),\n        () => state.pendingTasks.delete(completion)\n      )\n    }\n  }\n\n  if (activeHmrTask || pendingHmrTasks.length > 0 || isHmrTaskBlocked(task)) {\n    pendingHmrTasks.push(task)\n    flushPendingHmrTasks()\n  } else {\n    runHmrTask(task)\n  }\n  return completion\n}\n\nfunction flushPendingHmrTasks() {\n  if (activeHmrTask) return\n\n  while (pendingHmrTasks.length > 0) {\n    const task = pendingHmrTasks[0]\n    if (getCurrentTaskPaths(task).length === 0) {\n      pendingHmrTasks.shift()\n      task.resolve()\n      continue\n    }\n    if (isHmrTaskBlocked(task)) {\n      return\n    }\n    pendingHmrTasks.shift()\n    runHmrTask(task)\n    return\n  }\n}\n\nfunction handleApplyBatch(updates: PartialServerMessage[]): UpdateBatchResult {\n  const relevantUpdates = updates\n    .map((update) => ({\n      chunkListPath: update.resource.path as ChunkListPath,\n      update: update.instruction,\n    }))\n    .filter(({ chunkListPath }) => chunkListChunksMap.has(chunkListPath))\n\n  const chunkListPaths = [\n    ...new Set(relevantUpdates.map(({ chunkListPath }) => chunkListPath)),\n  ]\n  if (chunkListPaths.length === 0) {\n    return { handledPaths: [] }\n  }\n\n  const bootstrappingPaths = chunkListPaths.filter((chunkListPath) => {\n    const state = dynamicChunkListLoadStates.get(chunkListPath)\n    return state?.bootstrapping && !state.terminated\n  })\n  if (bootstrappingPaths.length > 0) {\n    for (const chunkListPath of bootstrappingPaths) {\n      const state = dynamicChunkListLoadStates.get(chunkListPath)!\n      terminateDynamicChunkListLoad(\n        chunkListPath,\n        state,\n        new Error(\n          `Dynamic chunk list ${chunkListPath} changed while its members were loading.`\n        )\n      )\n    }\n    DEV_BACKEND.restart()\n    flushPendingHmrTasks()\n    return { handledPaths: chunkListPaths }\n  }\n\n  const completion = scheduleHmrTask(chunkListPaths, (currentPaths) => {\n    const chunkListUpdates = relevantUpdates\n      .filter(({ chunkListPath }) => currentPaths.has(chunkListPath))\n      .map(({ chunkListPath, update }) => {\n        if (update.type !== 'ChunkListUpdate') {\n          invariant(update, (update) => `Unknown update type: ${update.type}`)\n        }\n        return { chunkListPath, update }\n      })\n    return chunkListUpdates.length > 0\n      ? applyChunkListUpdates(chunkListUpdates)\n      : []\n  })\n  return { handledPaths: chunkListPaths, completion }\n}\n\nfunction handleApply(\n  chunkListPath: ChunkListPath,\n  update: ServerMessage\n): Promise<void> {\n  const loadState = dynamicChunkListLoadStates.get(chunkListPath)\n  if (\n    update.type === 'partial' &&\n    loadState?.bootstrapping &&\n    !loadState.terminated\n  ) {\n    terminateDynamicChunkListLoad(\n      chunkListPath,\n      loadState,\n      new Error(\n        `Dynamic chunk list ${chunkListPath} changed while its members were loading.`\n      )\n    )\n    DEV_BACKEND.restart()\n    flushPendingHmrTasks()\n    return Promise.resolve()\n  }\n  if (update.type === 'notFound' || update.type === 'restart') {\n    if (loadState && !loadState.terminated) {\n      const error = new Error(\n        update.type === 'notFound'\n          ? `Dynamic chunk list ${chunkListPath} disappeared while loading.`\n          : `Dynamic chunk list ${chunkListPath} must restart while loading.`\n      )\n      terminateDynamicChunkListLoad(chunkListPath, loadState, error)\n    }\n    if (update.type === 'restart') {\n      chunkListGenerations.delete(chunkListPath)\n      dynamicChunkListLoadStates.delete(chunkListPath)\n    }\n    handleApplyImmediately(chunkListPath, update)\n    flushPendingHmrTasks()\n    return Promise.resolve()\n  }\n\n  return scheduleHmrTask([chunkListPath], (currentPaths) =>\n    currentPaths.has(chunkListPath)\n      ? handleApplyImmediately(chunkListPath, update)\n      : []\n  )\n}\n\nfunction handleApplyImmediately(\n  chunkListPath: ChunkListPath,\n  update: ServerMessage\n): HmrResourceOperation[] {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      if (update.instruction.type !== 'ChunkListUpdate') {\n        invariant(\n          update.instruction,\n          (instruction) => `Unknown update type: ${instruction.type}`\n        )\n      }\n      return applyChunkListUpdates([\n        { chunkListPath, update: update.instruction },\n      ])\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      return []\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      return []\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListMembershipDelta(\n  chunkListPath: ChunkListPath,\n  chunkPath: ChunkPath,\n  type: 'added' | 'deleted',\n  transitions: Map<ChunkPath, ChunkOwnershipTransition>\n): boolean {\n  let transition = transitions.get(chunkPath)\n  if (!transition) {\n    const ownerCount = chunkChunkListsMap.get(chunkPath)?.size ?? 0\n    transition = { before: ownerCount, after: ownerCount }\n    transitions.set(chunkPath, transition)\n  }\n\n  const changed =\n    type === 'added'\n      ? addChunkToChunkList(chunkListPath, chunkPath)\n      : removeChunkFromChunkList(chunkListPath, chunkPath)\n  transition.after = chunkChunkListsMap.get(chunkPath)?.size ?? 0\n  return changed\n}\n\nfunction addChunkToChunkList(\n  chunkListPath: ChunkListPath,\n  chunkPath: ChunkPath\n): boolean {\n  let chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (!chunkPaths) {\n    chunkPaths = new Set()\n    chunkListChunksMap.set(chunkListPath, chunkPaths)\n  }\n  if (chunkPaths.has(chunkPath)) {\n    return false\n  }\n  chunkPaths.add(chunkPath)\n\n  let chunkLists = chunkChunkListsMap.get(chunkPath)\n  if (!chunkLists) {\n    chunkLists = new Set()\n    chunkChunkListsMap.set(chunkPath, chunkLists)\n  }\n  chunkLists.add(chunkListPath)\n  return true\n}\n\nfunction removeChunkFromChunkList(\n  chunkListPath: ChunkListPath,\n  chunkPath: ChunkPath\n): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  const chunkLists = chunkChunkListsMap.get(chunkPath)\n  if (!chunkPaths?.has(chunkPath) || !chunkLists?.has(chunkListPath)) {\n    return false\n  }\n\n  chunkPaths.delete(chunkPath)\n  chunkLists.delete(chunkListPath)\n  if (chunkLists.size === 0) {\n    chunkChunkListsMap.delete(chunkPath)\n  }\n  return true\n}\n\nfunction setChunkListChunks(\n  chunkListPath: ChunkListPath,\n  nextChunkPaths: Set<ChunkPath>\n) {\n  const previousChunkPaths = new Set(\n    chunkListChunksMap.get(chunkListPath) ?? []\n  )\n  if (!chunkListChunksMap.has(chunkListPath)) {\n    chunkListChunksMap.set(chunkListPath, new Set())\n  }\n\n  for (const chunkPath of previousChunkPaths) {\n    if (\n      !nextChunkPaths.has(chunkPath) &&\n      removeChunkFromChunkList(chunkListPath, chunkPath) &&\n      !chunkChunkListsMap.has(chunkPath)\n    ) {\n      disposeChunk(chunkPath)\n    }\n  }\n  for (const chunkPath of nextChunkPaths) {\n    if (!previousChunkPaths.has(chunkPath)) {\n      addChunkToChunkList(chunkListPath, chunkPath)\n    }\n  }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\nfunction terminateDynamicChunkListLoad(\n  chunkListPath: ChunkListPath,\n  state: DynamicChunkListLoadState,\n  error: Error\n) {\n  if (state.terminated) return\n\n  state.loading = false\n  state.bootstrapping = false\n  state.terminated = true\n  state.rejectSubscribed?.(error)\n  DEV_BACKEND.rejectChunk?.(chunkListPath as string as ChunkPath, error)\n\n  for (const [chunkPath, chunkUrl] of state.memberChunkUrls) {\n    releaseDynamicMemberChunkUrlOwner(\n      chunkListPath,\n      state.generation,\n      chunkPath,\n      chunkUrl\n    )\n  }\n}\n\nfunction addDynamicMemberChunkUrlOwner(\n  chunkListPath: ChunkListPath,\n  generation: number,\n  chunkUrl: ChunkUrl\n) {\n  let owners = dynamicMemberChunkUrlOwners.get(chunkUrl)\n  if (!owners) {\n    owners = new Map()\n    dynamicMemberChunkUrlOwners.set(chunkUrl, owners)\n  }\n  owners.set(chunkListPath, generation)\n}\n\nfunction releaseDynamicMemberChunkUrlOwner(\n  chunkListPath: ChunkListPath,\n  generation: number,\n  chunkPath: ChunkPath,\n  chunkUrl: ChunkUrl\n) {\n  const owners = dynamicMemberChunkUrlOwners.get(chunkUrl)\n  if (owners?.get(chunkListPath) !== generation) return\n\n  owners.delete(chunkListPath)\n  if (owners.size > 0) return\n\n  dynamicMemberChunkUrlOwners.delete(chunkUrl)\n  if (isJs(chunkUrl)) {\n    // Executed factories are already tracked by logical chunk ownership. The\n    // exact URL is removed so a cancelled in-flight script cannot satisfy a\n    // later request for the same logical chunk.\n    DEV_BACKEND.unloadChunkExact?.(chunkUrl)\n  } else {\n    const hasOtherChunkListOwner = [\n      ...(chunkChunkListsMap.get(chunkPath) ?? []),\n    ].some((owner) => owner !== chunkListPath)\n    if (hasOtherChunkListOwner) return\n    DEV_BACKEND.unloadChunkExact?.(chunkUrl)\n  }\n\n  if (!chunkChunkListsMap.has(chunkPath)) {\n    disposeChunk(chunkPath)\n  }\n}\n\nfunction completeDynamicMemberChunkUrlOwner(\n  chunkListPath: ChunkListPath,\n  generation: number,\n  chunkUrl: ChunkUrl\n) {\n  const owners = dynamicMemberChunkUrlOwners.get(chunkUrl)\n  if (owners?.get(chunkListPath) !== generation) return\n\n  owners.delete(chunkListPath)\n  if (owners.size === 0) {\n    dynamicMemberChunkUrlOwners.delete(chunkUrl)\n  }\n}\n\nfunction loadVersionedDynamicMemberChunk(\n  chunkListPath: ChunkPath,\n  chunkData: ChunkData,\n  versionToken: string\n) {\n  const chunkPath = getChunkPath(chunkData)\n  const chunkUrl = getVersionedChunkUrl(chunkPath, versionToken)\n  if (isCss(chunkUrl) && DEV_BACKEND.loadChunkReplacing) {\n    // A previous owner may have loaded an older content-version URL for the\n    // same stylesheet. Swap it only after the new CSS has loaded so dynamic\n    // lists never accumulate duplicate cascade entries.\n    return DEV_BACKEND.loadChunkReplacing(chunkUrl)\n  }\n  return loadVersionedInitialChunk(chunkListPath, chunkData, versionToken)\n}\n\nfunction getVersionedChunkUrl(\n  chunkPath: ChunkPath,\n  versionToken: string\n): ChunkUrl {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  const separator = chunkUrl.includes('?') ? '&' : '?'\n  return `${chunkUrl}${separator}hmr=${encodeURIComponent(\n    versionToken\n  )}` as ChunkUrl\n}\n\nfunction isVersionedDynamicMemberChunkUrl(chunkUrl: ChunkUrl): boolean {\n  return /(?:[?&])hmr=/.test(chunkUrl)\n}\n\n/**\n * Dynamic chunk-list manifests have already done their own availability\n * calculation. Load the exact member URL for this manifest generation so an\n * older in-flight request cannot be reused by a replacement generation.\n */\nfunction loadVersionedInitialChunk(\n  chunkPath: ChunkPath,\n  chunkData: ChunkData,\n  versionToken: string\n) {\n  const memberChunkPath = getChunkPath(chunkData)\n  return loadChunkByUrlInternal(\n    SourceType.Runtime,\n    chunkPath,\n    getVersionedChunkUrl(memberChunkPath, versionToken)\n  )\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  for (const chunkPath of [...chunkPaths]) {\n    if (\n      removeChunkFromChunkList(chunkListPath, chunkPath) &&\n      !chunkChunkListsMap.has(chunkPath)\n    ) {\n      disposeChunk(chunkPath)\n    }\n  }\n  chunkListChunksMap.delete(chunkListPath)\n  chunkListGenerations.delete(chunkListPath)\n  dynamicChunkListLoadStates.delete(chunkListPath)\n  runtimeChunkLists.delete(chunkListPath)\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModulesMap.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction getDevChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    if (typeof document !== 'undefined') {\n      const src = document.currentScript?.getAttribute('src')\n      if (\n        src &&\n        getPathFromScript({ src } as ChunkScript) === (chunk as ChunkPath)\n      ) {\n        return { src } as CurrentScript\n      }\n    }\n    if (\n      typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' &&\n      TURBOPACK_NEXT_CHUNK_URLS.length > 0\n    ) {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    }\n  }\n  return getChunkFromRegistration(chunk)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getDevChunkFromRegistration(registration[0]) as\n    | ChunkPath\n    | ChunkScript\n  const chunkPath = getPathFromScript(chunk)\n  const chunkUrl = getUrlFromScript(chunk)\n  const canonicalChunkUrl = getChunkRelativeUrl(chunkPath)\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    if (\n      chunkUrl !== canonicalChunkUrl &&\n      isVersionedDynamicMemberChunkUrl(chunkUrl) &&\n      !dynamicMemberChunkUrlOwners.has(chunkUrl)\n    ) {\n      // Registration can race with cancellation even after its script element\n      // was removed. Only a live owner may install this content-versioned\n      // chunk; a later owner of the same URL is safe because its content is\n      // identical.\n      DEV_BACKEND.unloadChunkExact?.(chunkUrl)\n      return\n    }\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n\n  if (\n    runtimeParams === undefined &&\n    chunkUrl !== canonicalChunkUrl &&\n    DEV_BACKEND.resolveChunk\n  ) {\n    // Versioned development chunks have their own resolver. Resolving the\n    // canonical path here could let an older generation wake a newer load.\n    DEV_BACKEND.resolveChunk(chunkUrl)\n    return\n  }\n\n  const result = BACKEND.registerChunk(chunk, runtimeParams)\n  if (chunkUrl !== canonicalChunkUrl) {\n    DEV_BACKEND.resolveChunk?.(chunkUrl)\n  }\n  return result\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: DevChunkList) {\n  const chunkListScript = getDevChunkFromRegistration(chunkList.script) as\n    | ChunkListPath\n    | ChunkListScript\n  const chunkListPath = getPathFromScript(chunkListScript)\n  const generation = nextChunkListGeneration++\n  chunkListGenerations.set(chunkListPath, generation)\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  setChunkListChunks(chunkListPath, chunkPaths)\n\n  if (chunkList.source === 'entry') {\n    // Entry chunks have already loaded their member chunks while bootstrapping.\n    // The \"chunk\" registration completes the backend's initial load.\n    BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n    markChunkListAsRuntime(chunkListPath)\n    CHUNK_UPDATE_LISTENERS.push([\n      chunkListPath,\n      handleApply.bind(null, chunkListPath),\n      { batch: handleApplyBatch, expectedVersion: chunkList.version },\n    ])\n    return\n  }\n\n  if (typeof document === 'undefined') {\n    // Workers currently have no HMR transport/provider. Keep the dynamic\n    // chunk-list as a lightweight bootstrap, but load its members directly\n    // instead of waiting forever for an onSubscribed acknowledgement.\n    void Promise.all(\n      chunkList.chunks.map((chunkData) =>\n        loadInitialChunk(chunkListPath as string as ChunkPath, chunkData)\n      )\n    ).then(\n      () => BACKEND.registerChunk(chunkListPath as string as ChunkPath),\n      (cause) => {\n        const error =\n          cause instanceof Error\n            ? cause\n            : new Error(\n                `Failed to load a worker dynamic chunk group: ${String(cause)}`\n              )\n        DEV_BACKEND.rejectChunk?.(chunkListPath as string as ChunkPath, error)\n      }\n    )\n    return\n  }\n\n  // A dynamic chunk list is the bootstrap for its group. Establish the server\n  // baseline before fetching content, then hold updates while content loads.\n  // This closes the HTTP/WebSocket race where stale content could otherwise be\n  // fetched immediately before a newer subscription baseline was created.\n  const loadState: DynamicChunkListLoadState = {\n    generation,\n    loading: true,\n    bootstrapping: true,\n    terminated: false,\n    pendingTasks: new Set(),\n    memberChunkUrls: new Map(),\n  }\n  for (const chunkData of chunkList.chunks) {\n    const chunkPath = getChunkPath(chunkData)\n    const chunkVersion = chunkList.chunkVersions[chunkPath]\n    if (chunkVersion === undefined) {\n      throw new Error(`Missing version for dynamic member chunk ${chunkPath}`)\n    }\n    const chunkUrl = getVersionedChunkUrl(chunkPath, chunkVersion)\n    loadState.memberChunkUrls.set(chunkPath, chunkUrl)\n    addDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl)\n  }\n  dynamicChunkListLoadStates.set(chunkListPath, loadState)\n\n  let resolveSubscribed!: () => void\n  let revalidateSubscription!: () => Promise<void>\n  const subscribed = new Promise<void>((resolve, reject) => {\n    resolveSubscribed = resolve\n    loadState.rejectSubscribed = reject\n  })\n  CHUNK_UPDATE_LISTENERS.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n    {\n      batch: handleApplyBatch,\n      onSubscribed: (revalidate) => {\n        revalidateSubscription = revalidate\n        resolveSubscribed()\n      },\n      expectedVersion: chunkList.version,\n    },\n  ])\n\n  void (async () => {\n    try {\n      await subscribed\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        return\n      }\n\n      const memberResults = await Promise.allSettled(\n        chunkList.chunks.map((chunkData) =>\n          loadVersionedDynamicMemberChunk(\n            chunkListPath as string as ChunkPath,\n            chunkData,\n            chunkList.chunkVersions[getChunkPath(chunkData)]\n          )\n        )\n      )\n\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        for (const chunkPath of chunkPaths) {\n          if (!chunkChunkListsMap.has(chunkPath)) {\n            disposeChunk(chunkPath)\n          }\n        }\n        return\n      }\n\n      const failedMember = memberResults.find(\n        (result): result is PromiseRejectedResult =>\n          result.status === 'rejected'\n      )\n      if (failedMember) {\n        throw failedMember.reason\n      }\n\n      // The member URLs are served from the live output directory rather than\n      // a historical snapshot. Validate the manifest version again after all\n      // HTTP responses have completed, closing the subscription/HTTP race.\n      await revalidateSubscription()\n\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        return\n      }\n\n      for (const chunkUrl of loadState.memberChunkUrls.values()) {\n        completeDynamicMemberChunkUrlOwner(chunkListPath, generation, chunkUrl)\n      }\n\n      loadState.loading = false\n      flushPendingHmrTasks()\n      while (loadState.pendingTasks.size > 0) {\n        await Promise.all([...loadState.pendingTasks])\n      }\n\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        for (const chunkPath of chunkPaths) {\n          if (!chunkChunkListsMap.has(chunkPath)) {\n            disposeChunk(chunkPath)\n          }\n        }\n        return\n      }\n\n      // Resolving the bootstrap schedules the import continuation as a\n      // microtask. Every queued update and resource load has completed first,\n      // so user code cannot observe factories from an older manifest.\n      loadState.bootstrapping = false\n      BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n    } catch (cause) {\n      if (\n        loadState.terminated ||\n        dynamicChunkListLoadStates.get(chunkListPath) !== loadState ||\n        chunkListGenerations.get(chunkListPath) !== generation\n      ) {\n        return\n      }\n      const error =\n        cause instanceof Error\n          ? cause\n          : new Error(`Failed to load a dynamic chunk group: ${String(cause)}`)\n      terminateDynamicChunkListLoad(chunkListPath, loadState, error)\n      DEV_BACKEND.restart()\n    }\n  })()\n}\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","runtimeModules","Set","createModuleWithDirectionFlag","getRefreshBoundaryExports","exports","isAsyncModuleExt","turbopackExports","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","dynamicChunkListLoadStates","pendingHmrTasks","chunkListGenerations","nextChunkListGeneration","activeHmrTask","dynamicMemberChunkUrlOwners","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","refresh","call","k","sourceType","sourceData","createModuleObjectFn","createModuleObject","createContext","instantiateModuleShared","moduleFactories","runModuleExecutionHooks","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","add","PARALLEL_UPDATE_CONFLICT","Symbol","mergeParallelChunkUpdate","updateA","updateB","type","mergeParallelEcmascriptChunkUpdate","modules","added","deleted","has","delete","addedUpdate","deletedUpdate","length","moduleEntriesEqual","entryA","entryB","code","map","applyChunkListUpdates","updates","resourceOperations","ownershipTransitions","chunks","ecmascriptChunks","entries","explicitlyModifiedModules","hasConflict","chunkListPath","update","chunkUpdate","applyChunkListMembershipDelta","set","previous","get","merged","invariant","addedInThisUpdate","combined","entry","DEV_BACKEND","restart","filteredEcmascriptChunks","transition","before","after","keys","applyEcmascriptMergedUpdate","ownerCount","size","chunkUrl","getChunkRelativeUrl","promise","BACKEND","loadChunkCached","Update","reloadChunk","disposeChunk","instruction","JSON","stringify","modified","chunksAdded","chunksDeleted","computeChangedModules","applyEcmascriptMergedUpdateShared","evalModuleEntry","_eval","applyModuleFactoryName","autoAcceptRootModules","getCurrentTaskPaths","task","chunkLists","filter","path","generation","isHmrTaskBlocked","some","state","loading","runHmrTask","currentPaths","apply","results","Promise","allSettled","failedIndex","findIndex","result","index","status","reason","resolve","cause","reject","undefined","flushPendingHmrTasks","scheduleHmrTask","chunkListPaths","flatMap","completion","innerResolve","innerReject","bootstrapping","terminated","pendingTasks","then","shift","handleApplyBatch","relevantUpdates","resource","handledPaths","bootstrappingPaths","terminateDynamicChunkListLoad","Error","chunkListUpdates","handleApply","loadState","handleApplyImmediately","disposeChunkList","transitions","changed","addChunkToChunkList","removeChunkFromChunkList","chunkPaths","setChunkListChunks","nextChunkPaths","previousChunkPaths","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","rejectSubscribed","rejectChunk","memberChunkUrls","releaseDynamicMemberChunkUrlOwner","addDynamicMemberChunkUrlOwner","owners","isJs","unloadChunkExact","hasOtherChunkListOwner","owner","completeDynamicMemberChunkUrlOwner","loadVersionedDynamicMemberChunk","chunkData","versionToken","getChunkPath","getVersionedChunkUrl","isCss","loadChunkReplacing","loadVersionedInitialChunk","separator","includes","encodeURIComponent","isVersionedDynamicMemberChunkUrl","test","memberChunkPath","loadChunkByUrlInternal","chunkListUrl","unloadChunk","disposeModule","availableModules","markChunkListAsRuntime","getDevChunkFromRegistration","chunk","document","src","currentScript","getAttribute","getPathFromScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getChunkFromRegistration","registerChunk","registration","getUrlFromScript","canonicalChunkUrl","runtimeParams","installCompressedModuleFactories","resolveChunk","registerChunkList","chunkList","chunkListScript","script","source","CHUNK_UPDATE_LISTENERS","bind","batch","expectedVersion","version","all","loadInitialChunk","String","chunkVersion","chunkVersions","resolveSubscribed","revalidateSubscription","subscribed","onSubscribed","revalidate","memberResults","failedMember","find","values"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 2707, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 2950, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  type PendingChunkReload = {\n    link: HTMLLinkElement\n    reject: (error: Error) => void\n  }\n  const pendingChunkReloads = new Map<string, Set<PendingChunkReload>>()\n  const replacingCssLoads = new Map<ChunkUrl, Promise<void>>()\n\n  DEV_BACKEND = {\n    loadChunkReplacing(chunkUrl) {\n      if (!isCss(chunkUrl)) {\n        return Promise.reject(\n          new Error(\n            `Only CSS chunks can be replaced while loading: ${chunkUrl}`\n          )\n        )\n      }\n\n      const existingLoad = replacingCssLoads.get(chunkUrl)\n      if (existingLoad) return existingLoad\n\n      const baseChunkUrl = chunkUrl.split('?')[0]\n      const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n      const cacheBusterSeparator = chunkUrl.includes('?') ? '&' : '?'\n      const decodedChunkUrl = decodeURI(chunkUrl)\n      const exactLinks = document.querySelectorAll(\n        `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}${cacheBusterSeparator}\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}${cacheBusterSeparator}\"]`\n      )\n      const baseLinks = document.querySelectorAll(\n        `link[rel=stylesheet][href=\"${baseChunkUrl}\"],link[rel=stylesheet][href^=\"${baseChunkUrl}?\"],link[rel=stylesheet][href=\"${decodedBaseChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedBaseChunkUrl}?\"]`\n      )\n\n      const load =\n        exactLinks.length > 0\n          ? resolveChunkResolver(chunkUrl)\n          : baseLinks.length === 0\n            ? BACKEND.loadChunkCached(SourceType.Runtime, chunkUrl)\n            : DEV_BACKEND.reloadChunk!(chunkUrl).then(() =>\n                resolveChunkResolver(chunkUrl)\n              )\n      replacingCssLoads.set(chunkUrl, load)\n      void load.then(\n        () => {\n          if (replacingCssLoads.get(chunkUrl) === load) {\n            replacingCssLoads.delete(chunkUrl)\n          }\n        },\n        () => {\n          if (replacingCssLoads.get(chunkUrl) === load) {\n            replacingCssLoads.delete(chunkUrl)\n          }\n        }\n      )\n      return load\n    },\n\n    unloadChunk(chunkUrl) {\n      unloadChunk(chunkUrl, false)\n    },\n\n    unloadChunkExact(chunkUrl) {\n      unloadChunk(chunkUrl, true)\n    },\n\n    rejectChunk(chunkPath, error) {\n      const chunkUrl = getUrlFromScript(chunkPath)\n      const resolver = chunkResolvers.get(chunkUrl)\n      if (resolver) rejectResolver(chunkUrl, resolver, error)\n    },\n\n    resolveChunk(chunkUrl) {\n      resolveChunkResolver(chunkUrl)\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        // Strip query string so we match links regardless of cache-busting\n        // params (e.g. ?ts=) that may differ between HMR updates.\n        const baseChunkUrl = chunkUrl.split('?')[0]\n        const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${baseChunkUrl}\"],link[rel=stylesheet][href^=\"${baseChunkUrl}?\"],link[rel=stylesheet][href=\"${decodedBaseChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedBaseChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const currentReloads = pendingChunkReloads.get(baseChunkUrl)\n        if (currentReloads) {\n          const suffix = chunkUrl.includes('?') ? '&' : '?'\n          for (const reload of [...currentReloads]) {\n            const href = reload.link.getAttribute('href')\n            if (\n              href !== chunkUrl &&\n              !href?.startsWith(`${chunkUrl}${suffix}`)\n            ) {\n              reload.reject(\n                new Error(\n                  `CSS chunk ${chunkUrl} superseded an in-flight reload.`\n                )\n              )\n            }\n          }\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n        link.crossOrigin = CROSS_ORIGIN\n        let pendingReloads = pendingChunkReloads.get(baseChunkUrl)\n        if (!pendingReloads) {\n          pendingReloads = new Set()\n          pendingChunkReloads.set(baseChunkUrl, pendingReloads)\n        }\n        const cleanup = () => {\n          pendingReloads!.delete(pendingReload)\n          if (pendingReloads!.size === 0) {\n            pendingChunkReloads.delete(baseChunkUrl)\n          }\n        }\n        const pendingReload: PendingChunkReload = {\n          link,\n          reject: (error) => {\n            cleanup()\n            link.onload = null\n            link.onerror = null\n            link.remove()\n            reject(error)\n          },\n        }\n        pendingReloads.add(pendingReload)\n\n        if (\n          navigator.userAgent.includes('Firefox') ||\n          (navigator.userAgent.includes('Safari') &&\n            !navigator.userAgent.includes('Chrome') &&\n            !navigator.userAgent.includes('Chromium'))\n        ) {\n          // Firefox won't reload CSS files that were previously loaded on the\n          // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari serves cached CSS when a <link rel=preload> exists for the\n          // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726\n          //\n          // Replace or add a fresh `ts` cache-busting param without\n          // discarding other query parameters that may already be present.\n          const url = new URL(chunkUrl, location.origin)\n          // Reduced timer precision in some browers could lead to an update getting dropped\n          // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).\n          // So trust that the server is only updating us when it is important and use a\n          // random number to bust the cache.\n          url.searchParams.set('ts', `${Date.now()}.${Math.random()}`)\n          link.href = url.pathname + url.search\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          pendingReload.reject(\n            new Error(`Failed to reload CSS chunk ${chunkUrl}`)\n          )\n        }\n        link.onload = () => {\n          cleanup()\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function rejectResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function resolveChunkResolver(chunkUrl: ChunkUrl): Promise<void> {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    resolver.resolve()\n    return resolver.promise\n  }\n\n  function unloadChunk(chunkUrl: ChunkUrl, exact: boolean) {\n    deleteResolvers(chunkUrl, exact)\n\n    const baseChunkUrl = chunkUrl.split('?')[0]\n    const reloads = pendingChunkReloads.get(baseChunkUrl)\n    if (reloads) {\n      for (const reload of [...reloads]) {\n        const href = reload.link.getAttribute('href')\n        const suffix = chunkUrl.includes('?') ? '&' : '?'\n        if (\n          !exact ||\n          href === chunkUrl ||\n          href?.startsWith(`${chunkUrl}${suffix}`)\n        ) {\n          reload.reject(\n            new Error(`Chunk ${chunkUrl} was unloaded while reloading.`)\n          )\n        }\n      }\n    }\n\n    // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n    const decodedChunkUrl = decodeURI(exact ? chunkUrl : baseChunkUrl)\n    const path = exact ? chunkUrl : baseChunkUrl\n    const suffix = exact ? (path.includes('?') ? '&' : '?') : '?'\n\n    if (isCss(chunkUrl)) {\n      const links = document.querySelectorAll(\n        `link[href=\"${path}\"],link[href^=\"${path}${suffix}\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}${suffix}\"]`\n      )\n      for (const link of Array.from(links)) {\n        link.remove()\n      }\n    } else if (isJs(chunkUrl)) {\n      // Unloading a JS chunk would have no effect once it has executed, but\n      // removing the exact stale registration keeps the DOM and resolver cache\n      // bounded without touching a newer generation of the same chunk path.\n      const scripts = document.querySelectorAll(\n        `script[src=\"${path}\"],script[src^=\"${path}${suffix}\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}${suffix}\"]`\n      )\n      for (const script of Array.from(scripts)) {\n        script.remove()\n      }\n    } else {\n      throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n    }\n  }\n\n  function deleteResolvers(chunkUrl: ChunkUrl, exact: boolean) {\n    const baseChunkUrl = chunkUrl.split('?')[0]\n    for (const [resolverUrl, resolver] of [...chunkResolvers]) {\n      if (\n        exact\n          ? resolverUrl !== chunkUrl\n          : resolverUrl.split('?')[0] !== baseChunkUrl\n      ) {\n        continue\n      }\n      if (resolver.resolved) {\n        chunkResolvers.delete(resolverUrl)\n      } else {\n        rejectResolver(\n          resolverUrl,\n          resolver,\n          new Error(`Chunk ${resolverUrl} was unloaded while loading.`)\n        )\n      }\n    }\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","pendingChunkReloads","Map","replacingCssLoads","loadChunkReplacing","chunkUrl","isCss","Promise","reject","Error","existingLoad","get","baseChunkUrl","split","decodedBaseChunkUrl","decodeURI","cacheBusterSeparator","includes","decodedChunkUrl","exactLinks","document","querySelectorAll","baseLinks","load","length","resolveChunkResolver","BACKEND","loadChunkCached","SourceType","Runtime","reloadChunk","then","set","delete","unloadChunk","unloadChunkExact","rejectChunk","chunkPath","error","getUrlFromScript","resolver","chunkResolvers","rejectResolver","resolveChunk","resolve","previousLinks","currentReloads","suffix","reload","href","link","getAttribute","startsWith","createElement","rel","crossOrigin","CROSS_ORIGIN","pendingReloads","Set","cleanup","pendingReload","size","onload","onerror","remove","add","navigator","userAgent","url","URL","location","origin","searchParams","Date","now","Math","random","pathname","search","previousLink","Array","from","parentElement","insertBefore","nextSibling","restart","self","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","exact","deleteResolvers","reloads","path","links","isJs","scripts","script","resolverUrl","_eval","code","map","encodeURI","CHUNK_BASE_PATH","ASSET_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"AAAA;;;;;CAKC,GAED,oDAAoD,GAEpD,gDAAgD;AAChD,4CAA4C;AAC5C,iDAAiD;AACjD,0DAA0D;AAE1D,IAAIA;AACH,CAAC;IAKA,MAAMC,sBAAsB,IAAIC;IAChC,MAAMC,oBAAoB,IAAID;IAE9BF,cAAc;QACZI,oBAAmBC,QAAQ;YACzB,IAAI,CAACC,MAAMD,WAAW;gBACpB,OAAOE,QAAQC,MAAM,CACnB,IAAIC,MACF,CAAC,+CAA+C,EAAEJ,UAAU;YAGlE;YAEA,MAAMK,eAAeP,kBAAkBQ,GAAG,CAACN;YAC3C,IAAIK,cAAc,OAAOA;YAEzB,MAAME,eAAeP,SAASQ,KAAK,CAAC,IAAI,CAAC,EAAE;YAC3C,MAAMC,sBAAsBC,UAAUH;YACtC,MAAMI,uBAAuBX,SAASY,QAAQ,CAAC,OAAO,MAAM;YAC5D,MAAMC,kBAAkBH,UAAUV;YAClC,MAAMc,aAAaC,SAASC,gBAAgB,CAC1C,CAAC,2BAA2B,EAAEhB,SAAS,+BAA+B,EAAEA,WAAWW,qBAAqB,8BAA8B,EAAEE,gBAAgB,+BAA+B,EAAEA,kBAAkBF,qBAAqB,EAAE,CAAC;YAErO,MAAMM,YAAYF,SAASC,gBAAgB,CACzC,CAAC,2BAA2B,EAAET,aAAa,+BAA+B,EAAEA,aAAa,+BAA+B,EAAEE,oBAAoB,+BAA+B,EAAEA,oBAAoB,GAAG,CAAC;YAGzM,MAAMS,OACJJ,WAAWK,MAAM,GAAG,IAChBC,qBAAqBpB,YACrBiB,UAAUE,MAAM,KAAK,IACnBE,QAAQC,eAAe,CAACC,WAAWC,OAAO,EAAExB,YAC5CL,YAAY8B,WAAW,CAAEzB,UAAU0B,IAAI,CAAC,IACtCN,qBAAqBpB;YAE/BF,kBAAkB6B,GAAG,CAAC3B,UAAUkB;YAChC,KAAKA,KAAKQ,IAAI,CACZ;gBACE,IAAI5B,kBAAkBQ,GAAG,CAACN,cAAckB,MAAM;oBAC5CpB,kBAAkB8B,MAAM,CAAC5B;gBAC3B;YACF,GACA;gBACE,IAAIF,kBAAkBQ,GAAG,CAACN,cAAckB,MAAM;oBAC5CpB,kBAAkB8B,MAAM,CAAC5B;gBAC3B;YACF;YAEF,OAAOkB;QACT;QAEAW,aAAY7B,QAAQ;YAClB6B,YAAY7B,UAAU;QACxB;QAEA8B,kBAAiB9B,QAAQ;YACvB6B,YAAY7B,UAAU;QACxB;QAEA+B,aAAYC,SAAS,EAAEC,KAAK;YAC1B,MAAMjC,WAAWkC,iBAAiBF;YAClC,MAAMG,WAAWC,eAAe9B,GAAG,CAACN;YACpC,IAAImC,UAAUE,eAAerC,UAAUmC,UAAUF;QACnD;QAEAK,cAAatC,QAAQ;YACnBoB,qBAAqBpB;QACvB;QAEAyB,aAAYzB,QAAQ;YAClB,OAAO,IAAIE,QAAc,CAACqC,SAASpC;gBACjC,IAAI,CAACF,MAAMD,WAAW;oBACpBG,OAAO,IAAIC,MAAM;oBACjB;gBACF;gBAEA,mEAAmE;gBACnE,0DAA0D;gBAC1D,MAAMG,eAAeP,SAASQ,KAAK,CAAC,IAAI,CAAC,EAAE;gBAC3C,MAAMC,sBAAsBC,UAAUH;gBACtC,MAAMiC,gBAAgBzB,SAASC,gBAAgB,CAC7C,CAAC,2BAA2B,EAAET,aAAa,+BAA+B,EAAEA,aAAa,+BAA+B,EAAEE,oBAAoB,+BAA+B,EAAEA,oBAAoB,GAAG,CAAC;gBAGzM,IAAI+B,cAAcrB,MAAM,KAAK,GAAG;oBAC9BhB,OAAO,IAAIC,MAAM,CAAC,gCAAgC,EAAEJ,UAAU;oBAC9D;gBACF;gBAEA,MAAMyC,iBAAiB7C,oBAAoBU,GAAG,CAACC;gBAC/C,IAAIkC,gBAAgB;oBAClB,MAAMC,SAAS1C,SAASY,QAAQ,CAAC,OAAO,MAAM;oBAC9C,KAAK,MAAM+B,UAAU;2BAAIF;qBAAe,CAAE;wBACxC,MAAMG,OAAOD,OAAOE,IAAI,CAACC,YAAY,CAAC;wBACtC,IACEF,SAAS5C,YACT,CAAC4C,MAAMG,WAAW,GAAG/C,WAAW0C,QAAQ,GACxC;4BACAC,OAAOxC,MAAM,CACX,IAAIC,MACF,CAAC,UAAU,EAAEJ,SAAS,gCAAgC,CAAC;wBAG7D;oBACF;gBACF;gBAEA,MAAM6C,OAAO9B,SAASiC,aAAa,CAAC;gBACpCH,KAAKI,GAAG,GAAG;gBACXJ,KAAKK,WAAW,GAAGC;gBACnB,IAAIC,iBAAiBxD,oBAAoBU,GAAG,CAACC;gBAC7C,IAAI,CAAC6C,gBAAgB;oBACnBA,iBAAiB,IAAIC;oBACrBzD,oBAAoB+B,GAAG,CAACpB,cAAc6C;gBACxC;gBACA,MAAME,UAAU;oBACdF,eAAgBxB,MAAM,CAAC2B;oBACvB,IAAIH,eAAgBI,IAAI,KAAK,GAAG;wBAC9B5D,oBAAoBgC,MAAM,CAACrB;oBAC7B;gBACF;gBACA,MAAMgD,gBAAoC;oBACxCV;oBACA1C,QAAQ,CAAC8B;wBACPqB;wBACAT,KAAKY,MAAM,GAAG;wBACdZ,KAAKa,OAAO,GAAG;wBACfb,KAAKc,MAAM;wBACXxD,OAAO8B;oBACT;gBACF;gBACAmB,eAAeQ,GAAG,CAACL;gBAEnB,IACEM,UAAUC,SAAS,CAAClD,QAAQ,CAAC,cAC5BiD,UAAUC,SAAS,CAAClD,QAAQ,CAAC,aAC5B,CAACiD,UAAUC,SAAS,CAAClD,QAAQ,CAAC,aAC9B,CAACiD,UAAUC,SAAS,CAAClD,QAAQ,CAAC,aAChC;oBACA,oEAAoE;oBACpE,qEAAqE;oBACrE,EAAE;oBACF,oEAAoE;oBACpE,2DAA2D;oBAC3D,EAAE;oBACF,0DAA0D;oBAC1D,iEAAiE;oBACjE,MAAMmD,MAAM,IAAIC,IAAIhE,UAAUiE,SAASC,MAAM;oBAC7C,kFAAkF;oBAClF,mFAAmF;oBACnF,8EAA8E;oBAC9E,mCAAmC;oBACnCH,IAAII,YAAY,CAACxC,GAAG,CAAC,MAAM,GAAGyC,KAAKC,GAAG,GAAG,CAAC,EAAEC,KAAKC,MAAM,IAAI;oBAC3D1B,KAAKD,IAAI,GAAGmB,IAAIS,QAAQ,GAAGT,IAAIU,MAAM;gBACvC,OAAO;oBACL5B,KAAKD,IAAI,GAAG5C;gBACd;gBAEA6C,KAAKa,OAAO,GAAG;oBACbH,cAAcpD,MAAM,CAClB,IAAIC,MAAM,CAAC,2BAA2B,EAAEJ,UAAU;gBAEtD;gBACA6C,KAAKY,MAAM,GAAG;oBACZH;oBACA,0EAA0E;oBAC1E,wEAAwE;oBACxE,uBAAuB;oBACvB,KAAK,MAAMoB,gBAAgBC,MAAMC,IAAI,CAACpC,eACpCkC,aAAaf,MAAM;oBAErB,uEAAuE;oBACvE,oBAAoB;oBACpBpB;gBACF;gBAEA,wEAAwE;gBACxE,4BAA4B;gBAC5BC,aAAa,CAAC,EAAE,CAACqC,aAAa,CAAEC,YAAY,CAC1CjC,MACAL,aAAa,CAAC,EAAE,CAACuC,WAAW;YAEhC;QACF;QAEAC,SAAS,IAAMC,KAAKhB,QAAQ,CAACtB,MAAM;IACrC;IAEA,SAASN,eACPrC,QAAkB,EAClBmC,QAAuB,EACvBF,KAAY;QAEZ,IAAIG,eAAe9B,GAAG,CAACN,cAAcmC,UAAU;YAC7CC,eAAeR,MAAM,CAAC5B;QACxB;QACAmC,SAAShC,MAAM,CAAC8B;IAClB;IAEA,SAASb,qBAAqBpB,QAAkB;QAC9C,IAAImC,WAAWC,eAAe9B,GAAG,CAACN;QAClC,IAAI,CAACmC,UAAU;YACb,IAAII;YACJ,IAAIpC;YACJ,MAAM+E,UAAU,IAAIhF,QAAc,CAACiF,cAAcC;gBAC/C7C,UAAU4C;gBACVhF,SAASiF;YACX;YACAjD,WAAW;gBACTkD,UAAU;gBACVC,gBAAgB;gBAChBC,eAAe;gBACfL;gBACA3C,SAAS;oBACPJ,SAAUkD,QAAQ,GAAG;oBACrB9C;gBACF;gBACApC,QAAQA;YACV;YACAiC,eAAeT,GAAG,CAAC3B,UAAUmC;QAC/B;QACAA,SAASI,OAAO;QAChB,OAAOJ,SAAS+C,OAAO;IACzB;IAEA,SAASrD,YAAY7B,QAAkB,EAAEwF,KAAc;QACrDC,gBAAgBzF,UAAUwF;QAE1B,MAAMjF,eAAeP,SAASQ,KAAK,CAAC,IAAI,CAAC,EAAE;QAC3C,MAAMkF,UAAU9F,oBAAoBU,GAAG,CAACC;QACxC,IAAImF,SAAS;YACX,KAAK,MAAM/C,UAAU;mBAAI+C;aAAQ,CAAE;gBACjC,MAAM9C,OAAOD,OAAOE,IAAI,CAACC,YAAY,CAAC;gBACtC,MAAMJ,SAAS1C,SAASY,QAAQ,CAAC,OAAO,MAAM;gBAC9C,IACE,CAAC4E,SACD5C,SAAS5C,YACT4C,MAAMG,WAAW,GAAG/C,WAAW0C,QAAQ,GACvC;oBACAC,OAAOxC,MAAM,CACX,IAAIC,MAAM,CAAC,MAAM,EAAEJ,SAAS,8BAA8B,CAAC;gBAE/D;YACF;QACF;QAEA,gFAAgF;QAChF,MAAMa,kBAAkBH,UAAU8E,QAAQxF,WAAWO;QACrD,MAAMoF,OAAOH,QAAQxF,WAAWO;QAChC,MAAMmC,SAAS8C,QAASG,KAAK/E,QAAQ,CAAC,OAAO,MAAM,MAAO;QAE1D,IAAIX,MAAMD,WAAW;YACnB,MAAM4F,QAAQ7E,SAASC,gBAAgB,CACrC,CAAC,WAAW,EAAE2E,KAAK,eAAe,EAAEA,OAAOjD,OAAO,cAAc,EAAE7B,gBAAgB,eAAe,EAAEA,kBAAkB6B,OAAO,EAAE,CAAC;YAEjI,KAAK,MAAMG,QAAQ8B,MAAMC,IAAI,CAACgB,OAAQ;gBACpC/C,KAAKc,MAAM;YACb;QACF,OAAO,IAAIkC,KAAK7F,WAAW;YACzB,sEAAsE;YACtE,yEAAyE;YACzE,sEAAsE;YACtE,MAAM8F,UAAU/E,SAASC,gBAAgB,CACvC,CAAC,YAAY,EAAE2E,KAAK,gBAAgB,EAAEA,OAAOjD,OAAO,eAAe,EAAE7B,gBAAgB,gBAAgB,EAAEA,kBAAkB6B,OAAO,EAAE,CAAC;YAErI,KAAK,MAAMqD,UAAUpB,MAAMC,IAAI,CAACkB,SAAU;gBACxCC,OAAOpC,MAAM;YACf;QACF,OAAO;YACL,MAAM,IAAIvD,MAAM,CAAC,mCAAmC,EAAEJ,UAAU;QAClE;IACF;IAEA,SAASyF,gBAAgBzF,QAAkB,EAAEwF,KAAc;QACzD,MAAMjF,eAAeP,SAASQ,KAAK,CAAC,IAAI,CAAC,EAAE;QAC3C,KAAK,MAAM,CAACwF,aAAa7D,SAAS,IAAI;eAAIC;SAAe,CAAE;YACzD,IACEoD,QACIQ,gBAAgBhG,WAChBgG,YAAYxF,KAAK,CAAC,IAAI,CAAC,EAAE,KAAKD,cAClC;gBACA;YACF;YACA,IAAI4B,SAASkD,QAAQ,EAAE;gBACrBjD,eAAeR,MAAM,CAACoE;YACxB,OAAO;gBACL3D,eACE2D,aACA7D,UACA,IAAI/B,MAAM,CAAC,MAAM,EAAE4F,YAAY,4BAA4B,CAAC;YAEhE;QACF;IACF;AACF,CAAC;AAED,SAASC,MAAM,EAAEC,IAAI,EAAEnC,GAAG,EAAEoC,GAAG,EAAyB;IACtDD,QAAQ,CAAC,kBAAkB,EAAEE,UAC3BnC,SAASC,MAAM,GAAGmC,kBAAkBtC,MAAMuC,eACzC;IACH,IAAIH,KAAK;QACPD,QAAQ,CAAC,kEAAkE,EAAEK,KAC3E,0EAA0E;QAC1E,2CAA2C;QAC3CC,SAASC,mBAAmBN,QAC3B;IACL;IAEA,mCAAmC;IACnC,OAAOO,KAAKR;AACd","ignoreList":[0]}}]
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"../../../shared/runtime/dev-globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/dev-protocol.d.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// Assign browser's module cache and runtime modules to shared HMR state\ndevModuleCache = Object.create(null)\ndevContextPrototype.c = devModuleCache\nruntimeModules = new Set()\n\n// Set flag to indicate we use ModuleWithDirection\ncreateModuleWithDirectionFlag = true\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\nfunction getRefreshBoundaryExports<T>(exports: T): T {\n  if (\n    typeof isAsyncModuleExt === 'function' &&\n    exports != null &&\n    typeof exports === 'object' &&\n    isAsyncModuleExt(exports)\n  ) {\n    return exports[turbopackExports] as T\n  }\n  return exports\n}\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\ntype DevChunkList =\n  | (Omit<ChunkList, 'source'> & { source: 'entry' })\n  | (Omit<ChunkList, 'source'> & {\n      source: 'dynamic'\n      chunkVersions: Record<ChunkPath, string>\n      version: string\n    })\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n/** Dynamic lists use a stricter, reload-on-ambiguity update policy. */\nconst dynamicChunkLists: Set<ChunkListPath> = new Set()\n/** Dynamic manifests which have not finished their subscribe/load/revalidate handshake. */\nconst loadingDynamicChunkLists: Set<ChunkListPath> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // Browser: creates base HotModule object (hot API added by shared code)\n  const createModuleObjectFn = (id: ModuleId) => {\n    return createModuleObject(id) as HotModule\n  }\n\n  // Browser: creates DevContext with refresh\n  const createContext = (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ) => {\n    return new (DevContext as any as DevContextConstructor)(\n      module,\n      exports,\n      refresh\n    )\n  }\n\n  // Use shared instantiation logic (includes hot API setup)\n  return instantiateModuleShared(\n    moduleId,\n    sourceType,\n    sourceData,\n    moduleFactories,\n    devModuleCache,\n    runtimeModules,\n    createModuleObjectFn,\n    createContext,\n    runModuleExecutionHooks\n  )\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = getRefreshBoundaryExports(module.exports)\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  // Browser-specific chunk management phase\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks,\n    chunkModulesMap\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  // Use shared HMR update implementation\n  applyEcmascriptMergedUpdateShared({\n    added,\n    modified,\n    disposedModules,\n    evalModuleEntry: _eval, // browser's eval with source maps\n    instantiateModule, // now wraps shared logic\n    applyModuleFactoryName,\n    moduleFactories,\n    devModuleCache,\n    autoAcceptRootModules: false,\n  })\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      if (dynamicChunkLists.has(chunkListPath)) {\n        if (loadingDynamicChunkLists.has(chunkListPath)) {\n          throw new Error(\n            `Dynamic chunk list ${chunkListPath} changed while it was loading.`\n          )\n        }\n        if (\n          update.instruction.type === 'ChunkListUpdate' &&\n          update.instruction.chunks != null\n        ) {\n          throw new Error(\n            `Dynamic chunk list ${chunkListPath} changed structure.`\n          )\n        }\n        const hasSharedChunk = [\n          ...(chunkListChunksMap.get(chunkListPath) ?? []),\n        ].some(\n          (chunkPath) => (chunkChunkListsMap.get(chunkPath)?.size ?? 0) > 1\n        )\n        if (hasSharedChunk) {\n          throw new Error(\n            `Dynamic chunk list ${chunkListPath} shares chunks with another active list.`\n          )\n        }\n      }\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (\n        runtimeChunkLists.has(chunkListPath) ||\n        dynamicChunkLists.has(chunkListPath)\n      ) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction getDevChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    if (typeof document !== 'undefined') {\n      const src = document.currentScript?.getAttribute('src')\n      if (\n        src &&\n        /[?&]hmr=/.test(src) &&\n        getPathFromScript({ src } as ChunkScript) === (chunk as ChunkPath)\n      ) {\n        return { src } as CurrentScript\n      }\n    }\n  }\n  return getChunkFromRegistration(chunk)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getDevChunkFromRegistration(registration[0]) as\n    | ChunkPath\n    | ChunkScript\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    let chunkPath = getPathFromScript(chunk)\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n\nfunction getVersionedChunkUrl(\n  chunkPath: ChunkPath,\n  versionToken: string\n): ChunkUrl {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  const separator = chunkUrl.includes('?') ? '&' : '?'\n  return `${chunkUrl}${separator}hmr=${encodeURIComponent(\n    versionToken\n  )}` as ChunkUrl\n}\n\nfunction loadVersionedInitialChunk(\n  chunkListPath: ChunkPath,\n  chunkData: ChunkData,\n  versionToken: string\n) {\n  return loadChunkByUrlInternal(\n    SourceType.Runtime,\n    chunkListPath,\n    getVersionedChunkUrl(getChunkPath(chunkData), versionToken)\n  )\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: DevChunkList) {\n  const chunkListScript = getDevChunkFromRegistration(chunkList.script) as\n    | ChunkListPath\n    | ChunkListScript\n  const chunkListPath = getPathFromScript(chunkListScript)\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    // Entry lists keep the legacy loading and update behavior.\n    BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n    CHUNK_UPDATE_LISTENERS.push([\n      chunkListPath,\n      handleApply.bind(null, chunkListPath),\n    ])\n    markChunkListAsRuntime(chunkListPath)\n    return\n  }\n\n  dynamicChunkLists.add(chunkListPath)\n\n  if (typeof document === 'undefined') {\n    // Workers do not have the browser HMR transport. Load the manifest members\n    // directly so the dynamic import cannot wait for a subscription forever.\n    void Promise.all(\n      chunkList.chunks.map((chunkData) =>\n        loadInitialChunk(chunkListPath as string as ChunkPath, chunkData)\n      )\n    ).then(\n      () => BACKEND.registerChunk(chunkListPath as string as ChunkPath),\n      () => DEV_BACKEND.restart()\n    )\n    return\n  }\n\n  loadingDynamicChunkLists.add(chunkListPath)\n  let resolveSubscribed!: () => void\n  let revalidateSubscription!: () => Promise<void>\n  const subscribed = new Promise<void>((resolve) => {\n    resolveSubscribed = resolve\n  })\n\n  CHUNK_UPDATE_LISTENERS.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n    {\n      conservative: true,\n      expectedVersion: chunkList.version,\n      onSubscribed: (revalidate) => {\n        revalidateSubscription = revalidate\n        resolveSubscribed()\n      },\n    },\n  ])\n\n  void (async () => {\n    try {\n      await subscribed\n      await Promise.all(\n        chunkList.chunks.map((chunkData) => {\n          const chunkPath = getChunkPath(chunkData)\n          const chunkVersion = chunkList.chunkVersions[chunkPath]\n          if (chunkVersion === undefined) {\n            throw new Error(\n              `Missing version for dynamic member chunk ${chunkPath}`\n            )\n          }\n          return loadVersionedInitialChunk(\n            chunkListPath as string as ChunkPath,\n            chunkData,\n            chunkVersion\n          )\n        })\n      )\n      // Member URLs are served from the live output directory. Verify that\n      // the manifest did not change while those HTTP responses were loading.\n      await revalidateSubscription()\n      loadingDynamicChunkLists.delete(chunkListPath)\n      BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n    } catch {\n      loadingDynamicChunkLists.delete(chunkListPath)\n      DEV_BACKEND.restart()\n    }\n  })()\n}\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","runtimeModules","Set","createModuleWithDirectionFlag","getRefreshBoundaryExports","exports","isAsyncModuleExt","turbopackExports","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","dynamicChunkLists","loadingDynamicChunkLists","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","refresh","call","k","sourceType","sourceData","createModuleObjectFn","createModuleObject","createContext","instantiateModuleShared","moduleFactories","runModuleExecutionHooks","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","add","applyUpdate","update","type","applyChunkListUpdate","invariant","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","entries","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","Update","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","added","modified","chunksAdded","chunksDeleted","computeChangedModules","applyEcmascriptMergedUpdateShared","evalModuleEntry","_eval","applyModuleFactoryName","autoAcceptRootModules","handleApply","chunkListPath","has","Error","hasSharedChunk","get","some","size","restart","disposeChunkList","moduleChunks","delete","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","disposeModule","availableModules","set","markChunkListAsRuntime","getDevChunkFromRegistration","chunk","document","src","currentScript","getAttribute","test","getPathFromScript","getChunkFromRegistration","registerChunk","registration","runtimeParams","length","undefined","installCompressedModuleFactories","getVersionedChunkUrl","versionToken","separator","includes","encodeURIComponent","loadVersionedInitialChunk","chunkData","loadChunkByUrlInternal","getChunkPath","registerChunkList","chunkList","chunkListScript","script","map","source","CHUNK_UPDATE_LISTENERS","bind","Promise","all","loadInitialChunk","then","resolveSubscribed","revalidateSubscription","subscribed","resolve","conservative","expectedVersion","version","onSubscribed","revalidate","chunkVersion","chunkVersions"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 2109, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 2356, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // Strip query string so we match links regardless of cache-busting\n      // params (e.g. ?ts=) that may differ between HMR updates.\n      const baseChunkUrl = chunkUrl.split('?')[0]\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${baseChunkUrl}\"],link[href^=\"${baseChunkUrl}?\"],link[href=\"${decodedBaseChunkUrl}\"],link[href^=\"${decodedBaseChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${baseChunkUrl}\"],script[src^=\"${baseChunkUrl}?\"],script[src=\"${decodedBaseChunkUrl}\"],script[src^=\"${decodedBaseChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        // Strip query string so we match links regardless of cache-busting\n        // params (e.g. ?ts=) that may differ between HMR updates.\n        const baseChunkUrl = chunkUrl.split('?')[0]\n        const decodedBaseChunkUrl = decodeURI(baseChunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${baseChunkUrl}\"],link[rel=stylesheet][href^=\"${baseChunkUrl}?\"],link[rel=stylesheet][href=\"${decodedBaseChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedBaseChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n        link.crossOrigin = CROSS_ORIGIN\n\n        if (\n          navigator.userAgent.includes('Firefox') ||\n          (navigator.userAgent.includes('Safari') &&\n            !navigator.userAgent.includes('Chrome') &&\n            !navigator.userAgent.includes('Chromium'))\n        ) {\n          // Firefox won't reload CSS files that were previously loaded on the\n          // current page: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari serves cached CSS when a <link rel=preload> exists for the\n          // same URL: https://bugs.webkit.org/show_bug.cgi?id=187726\n          //\n          // Replace or add a fresh `ts` cache-busting param without\n          // discarding other query parameters that may already be present.\n          const url = new URL(chunkUrl, location.origin)\n          // Reduced timer precision in some browers could lead to an update getting dropped\n          // in Firefox if it happens fast enough (in firefox precision is sometimes 100ms!).\n          // So trust that the server is only updating us when it is important and use a\n          // random number to bust the cache.\n          url.searchParams.set('ts', `${Date.now()}.${Math.random()}`)\n          link.href = url.pathname + url.search\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + ASSET_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","baseChunkUrl","split","decodedBaseChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","crossOrigin","CROSS_ORIGIN","navigator","userAgent","includes","url","URL","location","origin","searchParams","set","Date","now","Math","random","href","pathname","search","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","reload","chunkResolvers","delete","_eval","code","map","encodeURI","CHUNK_BASE_PATH","ASSET_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js b/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js
index 3672de7c1..67dd099e8 100644
--- a/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js
+++ b/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js
@@ -865,6 +865,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js.map b/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js.map
index 19165db43..b787f61ba 100644
--- a/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/runtime/cross_origin_loading_anonymous/output/main.js.map
@@ -5,5 +5,5 @@
     {"offset": {"line": 19, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./async-module.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n/**\n * Describes why a module was instantiated.\n * Shared between browser and Node.js runtimes.\n */\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\n// @ts-ignore Defined in `hmr-runtime.ts` (dev mode only)\ndeclare let devModuleCache: Record<ModuleId, any> | undefined\n\n/**\n * Flag indicating which module object type to create when a module is merged. Set to `true`\n * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,\n * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it\n * uses plain Module objects.\n */\nlet createModuleWithDirectionFlag = false\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    if (createModuleWithDirectionFlag) {\n      // set in development modes for hmr support\n      module = createModuleWithDirection(id)\n    } else {\n      module = createModuleObject(id)\n    }\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\nfunction createModuleWithDirection(id: ModuleId): ModuleWithDirection {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n    parents: [],\n    children: [],\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n\n    // Install the factory for each module ID that doesn't already have one.\n    // When some IDs in this group already have a factory, reuse that existing\n    // group factory for the missing IDs to keep all IDs in the group consistent.\n    // Otherwise, install the factory from this chunk.\n    const moduleFactoryFn = chunkModules[end] as Function\n    let existingGroupFactory: Function | undefined = undefined\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      const existingFactory = moduleFactories.get(id)\n      if (existingFactory) {\n        existingGroupFactory = existingFactory\n        break\n      }\n    }\n    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn\n\n    let didInstallFactory = false\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      if (!moduleFactories.has(id)) {\n        if (!didInstallFactory) {\n          if (factoryToInstall === moduleFactoryFn) {\n            applyModuleFactoryName(moduleFactoryFn)\n          }\n          didInstallFactory = true\n        }\n        moduleFactories.set(id, factoryToInstall)\n        newModuleId?.(id)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * Constructs an error message for when a module factory is not available.\n */\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason: string\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\nlet cachedAutomaticPublicPath: string | undefined\n\nfunction getAutomaticPublicPath(): string {\n  if (cachedAutomaticPublicPath !== undefined) {\n    return cachedAutomaticPublicPath\n  }\n\n  let scriptUrl: string | undefined\n  if (typeof document === 'object') {\n    const currentScript = document.currentScript as HTMLScriptElement | null\n    scriptUrl = currentScript?.src\n\n    if (!scriptUrl) {\n      const scripts = document.getElementsByTagName('script')\n      const script = scripts[scripts.length - 1]\n      scriptUrl = script?.src\n    }\n  }\n\n  if (\n    !scriptUrl &&\n    typeof (globalThis as any).importScripts === 'function' &&\n    (globalThis as any).location\n  ) {\n    scriptUrl = String((globalThis as any).location)\n  }\n\n  cachedAutomaticPublicPath = scriptUrl\n    ? scriptUrl\n        .replace(/^blob:/, '')\n        .replace(/#.*$/, '')\n        .replace(/\\?.*$/, '')\n        .replace(/\\/[^/]*$/, '/')\n    : ''\n\n  return cachedAutomaticPublicPath\n}\n\n/**\n * Gets the public path for runtime assets.\n * Checks globalThis.publicPath and falls back to \"/\".\n */\nfunction getPublicPath(mode?: 'auto'): string {\n  if (mode === 'auto') {\n    return getAutomaticPublicPath()\n  }\n\n  if (\n    typeof globalThis !== 'undefined' &&\n    typeof (globalThis as any).publicPath === 'string'\n  ) {\n    const publicPath = (globalThis as any).publicPath as string\n    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`\n  }\n  return '/'\n}\ncontextPrototype.p = getPublicPath\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["SourceType","createModuleWithDirectionFlag","REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleWithDirection","createModuleObject","error","undefined","namespaceObject","parents","children","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","moduleFactoryFn","existingGroupFactory","existingFactory","factoryToInstall","didInstallFactory","has","applyModuleFactoryName","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","factoryNotAvailableMessage","sourceType","sourceData","instantiationReason","requireStub","_moduleId","z","g","globalThis","cachedAutomaticPublicPath","getAutomaticPublicPath","scriptUrl","document","currentScript","src","scripts","getElementsByTagName","script","importScripts","location","String","getPublicPath","mode","publicPath","endsWith","p","factory"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 508, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 772, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
-    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 843, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js b/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js
index d9e2a5147..269b096d9 100644
--- a/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js
+++ b/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js
@@ -877,6 +877,10 @@ let BACKEND;
             let chunkUrl = getUrlFromScript(chunkPath);
             const resolver = getOrCreateResolver(chunkUrl);
             resolver.resolve();
+            const exactChunkUrl = getUrlFromScript(chunk);
+            if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {
+                getOrCreateResolver(exactChunkUrl).resolve();
+            }
             if (params == null) {
                 return;
             }
diff --git a/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js.map b/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js.map
index 5c0a8cfc2..56bc60df1 100644
--- a/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js.map
+++ b/crates/pack-tests/tests/snapshot/runtime/export_entry_exports/output/main.js.map
@@ -5,5 +5,5 @@
     {"offset": {"line": 31, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n/// <reference path=\"./async-module.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n/**\n * Describes why a module was instantiated.\n * Shared between browser and Node.js runtimes.\n */\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\n// @ts-ignore Defined in `hmr-runtime.ts` (dev mode only)\ndeclare let devModuleCache: Record<ModuleId, any> | undefined\n\n/**\n * Flag indicating which module object type to create when a module is merged. Set to `true`\n * by each runtime that uses ModuleWithDirection (browser dev-base.ts, nodejs dev-base.ts,\n * nodejs build-base.ts). Browser production (build-base.ts) leaves it as `false` since it\n * uses plain Module objects.\n */\nlet createModuleWithDirectionFlag = false\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    if (createModuleWithDirectionFlag) {\n      // set in development modes for hmr support\n      module = createModuleWithDirection(id)\n    } else {\n      module = createModuleObject(id)\n    }\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\nfunction createModuleWithDirection(id: ModuleId): ModuleWithDirection {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n    parents: [],\n    children: [],\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n\n    // Install the factory for each module ID that doesn't already have one.\n    // When some IDs in this group already have a factory, reuse that existing\n    // group factory for the missing IDs to keep all IDs in the group consistent.\n    // Otherwise, install the factory from this chunk.\n    const moduleFactoryFn = chunkModules[end] as Function\n    let existingGroupFactory: Function | undefined = undefined\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      const existingFactory = moduleFactories.get(id)\n      if (existingFactory) {\n        existingGroupFactory = existingFactory\n        break\n      }\n    }\n    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn\n\n    let didInstallFactory = false\n    for (let j = i; j < end; j++) {\n      const id = chunkModules[j] as ModuleId\n      if (!moduleFactories.has(id)) {\n        if (!didInstallFactory) {\n          if (factoryToInstall === moduleFactoryFn) {\n            applyModuleFactoryName(moduleFactoryFn)\n          }\n          didInstallFactory = true\n        }\n        moduleFactories.set(id, factoryToInstall)\n        newModuleId?.(id)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * Constructs an error message for when a module factory is not available.\n */\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason: string\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\nlet cachedAutomaticPublicPath: string | undefined\n\nfunction getAutomaticPublicPath(): string {\n  if (cachedAutomaticPublicPath !== undefined) {\n    return cachedAutomaticPublicPath\n  }\n\n  let scriptUrl: string | undefined\n  if (typeof document === 'object') {\n    const currentScript = document.currentScript as HTMLScriptElement | null\n    scriptUrl = currentScript?.src\n\n    if (!scriptUrl) {\n      const scripts = document.getElementsByTagName('script')\n      const script = scripts[scripts.length - 1]\n      scriptUrl = script?.src\n    }\n  }\n\n  if (\n    !scriptUrl &&\n    typeof (globalThis as any).importScripts === 'function' &&\n    (globalThis as any).location\n  ) {\n    scriptUrl = String((globalThis as any).location)\n  }\n\n  cachedAutomaticPublicPath = scriptUrl\n    ? scriptUrl\n        .replace(/^blob:/, '')\n        .replace(/#.*$/, '')\n        .replace(/\\?.*$/, '')\n        .replace(/\\/[^/]*$/, '/')\n    : ''\n\n  return cachedAutomaticPublicPath\n}\n\n/**\n * Gets the public path for runtime assets.\n * Checks globalThis.publicPath and falls back to \"/\".\n */\nfunction getPublicPath(mode?: 'auto'): string {\n  if (mode === 'auto') {\n    return getAutomaticPublicPath()\n  }\n\n  if (\n    typeof globalThis !== 'undefined' &&\n    typeof (globalThis as any).publicPath === 'string'\n  ) {\n    const publicPath = (globalThis as any).publicPath as string\n    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`\n  }\n  return '/'\n}\ncontextPrototype.p = getPublicPath\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["SourceType","createModuleWithDirectionFlag","REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleWithDirection","createModuleObject","error","undefined","namespaceObject","parents","children","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","moduleFactoryFn","existingGroupFactory","existingFactory","factoryToInstall","didInstallFactory","has","applyModuleFactoryName","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","factoryNotAvailableMessage","sourceType","sourceData","instantiationReason","requireStub","_moduleId","z","g","globalThis","cachedAutomaticPublicPath","getAutomaticPublicPath","scriptUrl","document","currentScript","src","scripts","getElementsByTagName","script","importScripts","location","String","getPublicPath","mode","publicPath","endsWith","p","factory"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 520, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_ASSET_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var ASSET_SUFFIX: string\ndeclare var CROSS_ORIGIN: 'anonymous' | 'use-credentials' | null\ndeclare var CHUNK_LOAD_RETRY_MAX_ATTEMPTS: number\ndeclare var CHUNK_LOAD_RETRY_BASE_DELAY_MS: number\ndeclare var CHUNK_LOAD_RETRY_MAX_JITTER_MS: number\n\n// Support runtime public path modes.\nfunction getRuntimeChunkBasePath(basePath: string = CHUNK_BASE_PATH): string {\n  if (basePath === '__RUNTIME_PUBLIC_PATH__') {\n    return contextPrototype.p()\n  }\n  if (basePath === '__AUTO_PUBLIC_PATH__') {\n    return contextPrototype.p('auto')\n  }\n  return basePath\n}\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistrationChunk =\n  | ChunkPath\n  | { getAttribute: (name: string) => string | null }\n  | undefined\n\ntype ChunkRegistration = [\n  chunkPath: ChunkRegistrationChunk,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkRegistrationChunk\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\ninterface RuntimeBackend {\n  registerChunk: (\n    chunkPath: ChunkPath | ChunkScript,\n    params?: RuntimeParams\n  ) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\nconst loadedScripts = new Map<string, Promise<void>>()\n\n/**\n * Load an external script by creating a <script> tag.\n * This is used for script externals that need to be loaded from CDN or other external sources.\n */\nfunction loadScript(\n  this: TurbopackBrowserBaseContext<Module>,\n  scriptUrl: string\n): Promise<void> {\n  // Return cached promise if script is already loading or loaded\n  let promise = loadedScripts.get(scriptUrl)\n  if (promise) {\n    return promise\n  }\n\n  promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script')\n    script.crossOrigin = CROSS_ORIGIN\n    script.src = scriptUrl\n    script.onload = () => resolve()\n    script.onerror = () =>\n      reject(new Error(`Failed to load script: ${scriptUrl}`))\n    document.head.appendChild(script)\n  })\n\n  loadedScripts.set(scriptUrl, promise)\n  return promise\n}\nbrowserContextPrototype.S = loadScript\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a placeholder `file://` URL for the given module path. The browser\n * runtime intentionally does not expose the real filesystem path. Path\n * segments are percent-encoded so the result is always a valid file URI.\n */\nfunction resolveFileUrl(modulePath?: string): string {\n  if (!modulePath) return 'file:///ROOT/'\n  return `file:///ROOT/${modulePath\n    .split('/')\n    .map(encodeURIComponent)\n    .join('/')}`\n}\nbrowserContextPrototype.F = resolveFileUrl\n\n/**\n * Exports a URL with the static suffix appended.\n */\nfunction exportUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  url: string,\n  id: ModuleId | undefined\n) {\n  exportValue.call(this, `${url}${ASSET_SUFFIX}`, id)\n}\nbrowserContextPrototype.q = exportUrl\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(\n  chunkPath: ChunkPath | ChunkListPath,\n  basePath: string = CHUNK_BASE_PATH\n): ChunkUrl {\n  return `${getRuntimeChunkBasePath(basePath)}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${ASSET_SUFFIX}` as ChunkUrl\n}\n\n// Shared runtime primitives consumed by the bundled `createWorker` helper,\n// exposed as `__turbopack_chunk_base_path__` and `__turbopack_chunk_asset_suffix__`.\nbrowserContextPrototype.b = CHUNK_BASE_PATH as ChunkBasePath\nbrowserContextPrototype.X = ASSET_SUFFIX as AssetSuffix\n\n// Shared runtime primitive: build a chunk's URL. Used by the bundled worker\n// helper and the WASM helper, exposed as `__turbopack_chunk_relative_url__`.\nbrowserContextPrototype.h = getChunkRelativeUrl\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl = chunkScript.src!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const runtimeBasePath = getRuntimeChunkBasePath()\n  let path = src.startsWith(runtimeBasePath)\n    ? src.slice(runtimeBasePath.length)\n    : src\n  if (path.startsWith('/')) {\n    path = path.slice(1)\n  }\n  return path as ChunkPath | ChunkListPath\n}\n\n/**\n * Return the ChunkUrl from a ChunkScript.\n */\nfunction getUrlFromScript(chunk: ChunkPath | ChunkScript): ChunkUrl {\n  if (typeof chunk === 'string') {\n    return getChunkRelativeUrl(chunk)\n  } else {\n    // This is already exactly what we want\n    return chunk.src! as ChunkUrl\n  }\n}\n\n/**\n * Determine the chunk to register. Note that this function has side-effects!\n */\nfunction getChunkFromRegistration(\n  chunk: ChunkRegistrationChunk\n): ChunkPath | CurrentScript {\n  if (typeof chunk === 'string') {\n    return chunk\n  } else if (!chunk) {\n    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined') {\n      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript\n    } else {\n      throw new Error('chunk path empty but not in a worker')\n    }\n  } else {\n    return { src: chunk.getAttribute('src')! } as CurrentScript\n  }\n}\n\n/**\n * Checks if a given path/URL ends with the given extension,\n * optionally followed by ?query or #fragment.\n */\nfunction endsWithExtension(\n  chunkUrlOrPath: ChunkUrl | ChunkPath,\n  ext: string\n): boolean {\n  // Find where the path ends (before query or fragment)\n  const q = chunkUrlOrPath.indexOf('?')\n  let end: number\n  if (q !== -1) {\n    end = q\n  } else {\n    const h = chunkUrlOrPath.indexOf('#')\n    end = h !== -1 ? h : chunkUrlOrPath.length\n  }\n  // Check if the path portion ends with the extension\n  return end >= ext.length && chunkUrlOrPath.startsWith(ext, end - ext.length)\n}\n\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return endsWithExtension(chunkUrlOrPath, '.js')\n}\n\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return endsWithExtension(chunkUrl, '.css')\n}\n"],"names":["getRuntimeChunkBasePath","basePath","CHUNK_BASE_PATH","contextPrototype","p","browserContextPrototype","Context","prototype","moduleFactories","Map","M","availableModules","availableModuleChunks","loadChunk","chunkData","loadChunkInternal","SourceType","Parent","m","id","l","loadInitialChunk","chunkPath","Runtime","sourceType","sourceData","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","loadedScripts","loadScript","scriptUrl","reject","script","document","createElement","crossOrigin","CROSS_ORIGIN","src","onload","onerror","Error","head","appendChild","S","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","Update","invariant","error","name","url","getChunkRelativeUrl","resolvePathFromModule","moduleId","exported","r","default","R","resolveAbsolutePath","modulePath","P","resolveFileUrl","split","encodeURIComponent","join","F","exportUrl","exportValue","call","ASSET_SUFFIX","q","instantiateRuntimeModule","instantiateModule","b","X","h","getPathFromScript","chunkScript","decodeURIComponent","replace","runtimeBasePath","startsWith","slice","getUrlFromScript","chunk","getChunkFromRegistration","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","endsWithExtension","chunkUrlOrPath","ext","indexOf","end","isJs","isCss"],"mappings":"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","ignoreList":[0]}},
     {"offset": {"line": 784, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunk = getChunkFromRegistration(registration[0]) as\n    | ChunkScript\n    | ChunkPath\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunk, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","chunk","getChunkFromRegistration","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,MAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,MAAMO,mCAEF,CAACC,IAAIC;IACP,MAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,MAAMV,SAAiBgB,mBAAmBV;IAC1C,MAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,MAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,MAAMC,QAAQC,yBAAyBF,YAAY,CAAC,EAAE;IAGtD,IAAIG;IACJ,8GAA8G;IAC9G,IAAIH,aAAaI,MAAM,KAAK,GAAG;QAC7BD,gBAAgBH,YAAY,CAAC,EAAE;IACjC,OAAO;QACLG,gBAAgBE;QAChBC,iCACEN,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOkB,QAAQR,aAAa,CAACE,OAAOE;AACtC","ignoreList":[0]}},
-    {"offset": {"line": 855, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"AAAA;;;;CAIC,GAED,oDAAoD,GAEpD,sEAAsE;AACtE,mEAAmE;AAEnE,SAASA;IACP,+CAA+C;IAC/C,IAAIC,KAAKC,sBAAsB,IAAI,MAAM,OAAOD,KAAKC,sBAAsB;IAC3E,MAAMC,MAAMC,UAAUC,eAAeC,eAAe,UAAU;IAC9D,MAAMC,KAAKJ,IAAIK,OAAO,CAAC;IACvB,OAAOD,MAAM,IAAIJ,IAAIM,KAAK,CAACF,MAAM;AACnC;AAWA,IAAIG;AAEJ;;CAEC,GACD,MAAMC,iBAA+C,IAAIC;AAExD,CAAC;IACAF,UAAU;QACR,MAAMG,eAAcC,KAAK,EAAEC,MAAM;YAC/B,IAAIC,YAAYC,kBAAkBH;YAClC,IAAII,WAAWC,iBAAiBH;YAEhC,MAAMI,WAAWC,oBAAoBH;YACrCE,SAASE,OAAO;YAEhB,IAAIP,UAAU,MAAM;gBAClB;YACF;YAEA,KAAK,MAAMQ,kBAAkBR,OAAOS,WAAW,CAAE;gBAC/C,MAAMC,iBAAiBC,aAAaH;gBACpC,MAAMI,gBAAgBC,oBAAoBH;gBAE1C,iFAAiF;gBACjFJ,oBAAoBM;YACtB;YAEA,kFAAkF;YAClF,MAAME,QAAQC,GAAG,CACff,OAAOS,WAAW,CAACO,GAAG,CAAC,CAACR,iBACtBS,iBAAiBhB,WAAWO;YAIhC,IAAIR,OAAOkB,gBAAgB,CAACC,MAAM,GAAG,GAAG;gBACtC,KAAK,MAAMC,YAAYpB,OAAOkB,gBAAgB,CAAE;oBAC9CG,8BAA8BpB,WAAWmB;gBAC3C;YACF;QACF;QAEA;;;KAGC,GACDE,iBAAgBC,UAAsB,EAAEpB,QAAkB;YACxD,OAAOqB,YAAYD,YAAYpB;QACjC;IACF;IAEA,SAASG,oBAAoBH,QAAkB;QAC7C,IAAIE,WAAWT,eAAe6B,GAAG,CAACtB;QAClC,IAAI,CAACE,UAAU;YACb,IAAIE;YACJ,IAAImB;YACJ,MAAMC,UAAU,IAAIb,QAAc,CAACc,cAAcC;gBAC/CtB,UAAUqB;gBACVF,SAASG;YACX;YACAxB,WAAW;gBACTyB,UAAU;gBACVC,gBAAgB;gBAChBC,eAAe;gBACfL;gBACApB,SAAS;oBACPF,SAAUyB,QAAQ,GAAG;oBACrBvB;gBACF;gBACAmB,QAAQA;YACV;YACA9B,eAAeqC,GAAG,CAAC9B,UAAUE;QAC/B;QACA,OAAOA;IACT;IAEA;;;;GAIC,GACD,SAAS6B,oBACP/B,QAAkB,EAClBE,QAAuB,EACvB8B,KAAa;QAEb,IAAIvC,eAAe6B,GAAG,CAACtB,cAAcE,UAAU;YAC7CT,eAAewC,MAAM,CAACjC;QACxB;QACAE,SAASqB,MAAM,CAACS;IAClB;IAEA,SAASE;QACP,MAAMC,SAASC,KAAKC,KAAK,CACvBD,KAAKE,MAAM,KAAK,CAACC,iCAAiC,CAAC;QAErD,OAAOC,iCAAiCL;IAC1C;IAEA,SAASM,0BAA0BT,KAAa;QAC9C,OACEA,SAAS,QACRA,iBAAiBU,gBAAgBV,MAAMW,IAAI,KAAK;IAErD;IAEA;;GAEC,GACD,SAASC,iBACPxB,UAAsB,EACtBpB,QAAkB,EAClBE,QAAuB,EACvB8B,KAAa,EACba,MAAmB;QAEnB,IACE,CAACJ,0BAA0BT,UAC3B9B,SAAS2B,aAAa,IAAIiB,iCAC1BrD,eAAe6B,GAAG,CAACtB,cAAcE,UACjC;YACA6B,oBAAoB/B,UAAUE,UAAU8B;YACxC;QACF;QAEA9B,SAAS2B,aAAa;QACtBkB,WAAW;YACT,kEAAkE;YAClE,4DAA4D;YAC5D,6CAA6C;YAC7C,IAAI7C,SAASyB,QAAQ,IAAIlC,eAAe6B,GAAG,CAACtB,cAAcE,UAAU;gBAClE;YACF;YACA,IAAI2C,QAAQ;gBACVA;YACF,OAAO;gBACL3C,SAAS0B,cAAc,GAAG;gBAC1BP,YAAYD,YAAYpB;YAC1B;QACF,GAAGkC;IACL;IAEA;;;GAGC,GACD,SAASb,YAAYD,UAAsB,EAAEpB,QAAkB;QAC7D,MAAME,WAAWC,oBAAoBH;QACrC,IAAIE,SAAS0B,cAAc,EAAE;YAC3B,OAAO1B,SAASsB,OAAO;QACzB;QAEA,IAAIJ,eAAe4B,WAAWC,OAAO,EAAE;YACrC,uEAAuE;YACvE,oBAAoB;YACpB/C,SAAS0B,cAAc,GAAG;YAE1B,IAAIsB,MAAMlD,WAAW;gBACnB,IAAI,OAAOmD,kBAAkB,YAAY;oBACvC,MAAMC,kBAAkBC,UAAUrD;oBAClC,MAAMsD,gBAAgBpE,SAASqE,gBAAgB,CAC7C,CAAC,2BAA2B,EAAEvD,SAAS,+BAA+B,EAAEA,SAAS,+BAA+B,EAAEoD,gBAAgB,+BAA+B,EAAEA,gBAAgB,GAAG,CAAC;oBAGzL,IAAIE,cAActC,MAAM,KAAK,GAAG;wBAC9B,MAAMwC,OAAOtE,SAASuE,aAAa,CAAC;wBACpCD,KAAKE,GAAG,GAAG;wBACXF,KAAKG,WAAW,GAAGC;wBACnBJ,KAAKK,IAAI,GAAG7D;wBACZwD,KAAKM,OAAO,GAAG;4BACb5D,SAASqB,MAAM;wBACjB;wBACAiC,KAAKO,MAAM,GAAG;4BACZ7D,SAASE,OAAO;wBAClB;wBACAlB,SAAS8E,IAAI,CAACC,WAAW,CAACT;wBAC1B,OAAOtD,SAASsB,OAAO;oBACzB;gBACF;gBAEAtB,SAASE,OAAO;gBAChB,OAAOF,SAASsB,OAAO;YACzB;YAEA,mEAAmE;YACnE,gBAAgB;YAChB,IAAI,OAAO2B,kBAAkB,YAAY;gBACvC,MAAMC,kBAAkBC,UAAUrD;gBAClC,MAAMkE,kBAAkBhF,SAASqE,gBAAgB,CAC/C,CAAC,YAAY,EAAEvD,SAAS,gBAAgB,EAAEA,SAAS,gBAAgB,EAAEoD,gBAAgB,gBAAgB,EAAEA,gBAAgB,GAAG,CAAC;gBAE7H,IAAIc,gBAAgBlD,MAAM,GAAG,GAAG;oBAC9B,KAAK,MAAMmD,UAAUC,MAAMC,IAAI,CAACH,iBAAkB;wBAChDC,OAAOG,gBAAgB,CAAC,SAAS;4BAC/BpE,SAASqB,MAAM;wBACjB;oBACF;oBACA,OAAOrB,SAASsB,OAAO;gBACzB;YACF;QACA,8DAA8D;QAChE;QAEA,IAAI,OAAO2B,kBAAkB,YAAY;YACvC,wBAAwB;YACxB,IAAID,MAAMlD,WAAW;YACnB,SAAS;YACX,OAAO,IAAIuE,KAAKvE,WAAW;gBACzBjB,KAAKyF,yBAAyB,CAAEC,IAAI,CAACzE;gBACrC,IAAI;oBACFmD,cAAcnD;gBAChB,EAAE,OAAOgC,OAAO;oBACdY,iBAAiBxB,YAAYpB,UAAUE,UAAU8B;gBACnD;YACF,OAAO;gBACL,MAAM,IAAI0C,MACR,CAAC,mCAAmC,EAAE1E,SAAS,UAAU,CAAC;YAE9D;QACF,OAAO;YACL,gFAAgF;YAChF,MAAMoD,kBAAkBC,UAAUrD;YAElC,IAAIkD,MAAMlD,WAAW;gBACnB,MAAMsD,gBAAgBpE,SAASqE,gBAAgB,CAC7C,CAAC,2BAA2B,EAAEvD,SAAS,+BAA+B,EAAEA,SAAS,+BAA+B,EAAEoD,gBAAgB,+BAA+B,EAAEA,gBAAgB,GAAG,CAAC;gBAEzL,IAAIE,cAActC,MAAM,GAAG,GAAG;oBAC5B,uEAAuE;oBACvE,oBAAoB;oBACpBd,SAASE,OAAO;gBAClB,OAAO;oBACL,MAAMuE,aAAa;wBACjB,MAAMnB,OAAOtE,SAASuE,aAAa,CAAC;wBACpCD,KAAKE,GAAG,GAAG;wBACXF,KAAKG,WAAW,GAAGC;wBACnBJ,KAAKK,IAAI,GAAG7D;wBACZwD,KAAKM,OAAO,GAAG;4BACb,kEAAkE;4BAClE,iBAAiB;4BACjB,MAAMc,SAAS1F,SAAS2F,aAAa,CAAC;4BACtCrB,KAAKsB,WAAW,CAACF;4BACjBhC,iBAAiBxB,YAAYpB,UAAUE,UAAU6E,WAAW,IAC1DH,OAAOE,WAAW,CAACH;wBAEvB;wBACAnB,KAAKO,MAAM,GAAG;4BACZ,uEAAuE;4BACvE,oBAAoB;4BACpB7D,SAASE,OAAO;wBAClB;wBACA,OAAOoD;oBACT;oBACA,kDAAkD;oBAClDtE,SAAS8E,IAAI,CAACC,WAAW,CAACU;gBAC5B;YACF,OAAO,IAAIJ,KAAKvE,WAAW;gBACzB,MAAMkE,kBAAkBhF,SAASqE,gBAAgB,CAC/C,CAAC,YAAY,EAAEvD,SAAS,gBAAgB,EAAEA,SAAS,gBAAgB,EAAEoD,gBAAgB,gBAAgB,EAAEA,gBAAgB,GAAG,CAAC;gBAE7H,IAAIc,gBAAgBlD,MAAM,GAAG,GAAG;oBAC9B,KAAK,MAAMmD,UAAUC,MAAMC,IAAI,CAACH,iBAAkB;wBAChDC,OAAOG,gBAAgB,CACrB,SACA;4BACE,wDAAwD;4BACxDH,OAAOa,MAAM;4BACbpC,iBAAiBxB,YAAYpB,UAAUE;wBACzC,GACA;4BAAE+E,MAAM;wBAAK;oBAEjB;gBACF,OAAO;oBACL,MAAMd,SAASjF,SAASuE,aAAa,CAAC;oBACtCU,OAAOR,WAAW,GAAGC;oBACrBO,OAAOlF,GAAG,GAAGe;oBACb,yEAAyE;oBACzE,wEAAwE;oBACxE,eAAe;oBACfmE,OAAOL,OAAO,GAAG;wBACf,wDAAwD;wBACxDK,OAAOa,MAAM;wBACbpC,iBAAiBxB,YAAYpB,UAAUE;oBACzC;oBACA,kDAAkD;oBAClDhB,SAAS8E,IAAI,CAACC,WAAW,CAACE;gBAC5B;YACF,OAAO;gBACL,MAAM,IAAIO,MAAM,CAAC,mCAAmC,EAAE1E,UAAU;YAClE;QACF;QAEAE,SAAS0B,cAAc,GAAG;QAC1B,OAAO1B,SAASsB,OAAO;IACzB;AACF,CAAC","ignoreList":[0]}}]
+    {"offset": {"line": 855, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime/runtime-types.d.ts\" />\n\nfunction getAssetSuffixFromScriptSrc() {\n  // TURBOPACK_ASSET_SUFFIX is set in web workers\n  if (self.TURBOPACK_ASSET_SUFFIX != null) return self.TURBOPACK_ASSET_SUFFIX\n  const src = document?.currentScript?.getAttribute?.('src') ?? ''\n  const qi = src.indexOf('?')\n  return qi >= 0 ? src.slice(qi) : ''\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  retryAttempts: number\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunk, params) {\n      let chunkPath = getPathFromScript(chunk)\n      let chunkUrl = getUrlFromScript(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      const exactChunkUrl = getUrlFromScript(chunk)\n      if (exactChunkUrl !== chunkUrl && /[?&]hmr=/.test(exactChunkUrl)) {\n        getOrCreateResolver(exactChunkUrl).resolve()\n      }\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        retryAttempts: 0,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Rejects a chunk resolver and drops it from the cache.\n   * We don't want to cache failed chunk loads: a later\n   * request for the same chunk should try again.\n   */\n  function rejectChunkResolver(\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error\n  ) {\n    if (chunkResolvers.get(chunkUrl) === resolver) {\n      chunkResolvers.delete(chunkUrl)\n    }\n    resolver.reject(error)\n  }\n\n  function getChunkLoadRetryDelayMs() {\n    const jitter = Math.floor(\n      Math.random() * (CHUNK_LOAD_RETRY_MAX_JITTER_MS + 1)\n    )\n    return CHUNK_LOAD_RETRY_BASE_DELAY_MS + jitter\n  }\n\n  function isRetryableChunkLoadError(error?: Error): boolean {\n    return (\n      error == null ||\n      (error instanceof DOMException && error.name === 'NetworkError')\n    )\n  }\n\n  /**\n   * Handles a failed chunk load: retries the load once after a short delay.\n   */\n  function onChunkLoadError(\n    sourceType: SourceType,\n    chunkUrl: ChunkUrl,\n    resolver: ChunkResolver,\n    error?: Error,\n    reload?: () => void\n  ) {\n    if (\n      !isRetryableChunkLoadError(error) ||\n      resolver.retryAttempts >= CHUNK_LOAD_RETRY_MAX_ATTEMPTS ||\n      chunkResolvers.get(chunkUrl) !== resolver\n    ) {\n      rejectChunkResolver(chunkUrl, resolver, error)\n      return\n    }\n\n    resolver.retryAttempts++\n    setTimeout(() => {\n      // if this chunk is being fetched multiple times, and one of those\n      // attempts succeeds. or, if this chunk has another resolver\n      // mapped to it - it's safe to skip retrying.\n      if (resolver.resolved || chunkResolvers.get(chunkUrl) !== resolver) {\n        return\n      }\n      if (reload) {\n        reload()\n      } else {\n        resolver.loadingStarted = false\n        doLoadChunk(sourceType, chunkUrl)\n      }\n    }, getChunkLoadRetryDelayMs())\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // CSS chunks do not register themselves, and as such must be marked as\n      // loaded instantly.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        if (typeof importScripts !== 'function') {\n          const decodedChunkUrl = decodeURI(chunkUrl)\n          const previousLinks = document.querySelectorAll(\n            `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n          )\n\n          if (previousLinks.length === 0) {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              resolver.reject()\n            }\n            link.onload = () => {\n              resolver.resolve()\n            }\n            document.head.appendChild(link)\n            return resolver.promise\n          }\n        }\n\n        resolver.resolve()\n        return resolver.promise\n      }\n\n      // Runtime JS chunks are expected to be present in the DOM already.\n      // Load it first\n      if (typeof importScripts !== 'function') {\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n          return resolver.promise\n        }\n      }\n      // If it wasn't present in the DOM, fallback to loading logic.\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        try {\n          importScripts(chunkUrl)\n        } catch (error) {\n          onChunkLoadError(sourceType, chunkUrl, resolver, error as Error)\n        }\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const createLink = () => {\n            const link = document.createElement('link')\n            link.rel = 'stylesheet'\n            link.crossOrigin = CROSS_ORIGIN\n            link.href = chunkUrl\n            link.onerror = () => {\n              // Re-insert a fresh tag at the same position on retry to preserve\n              // cascade order.\n              const anchor = document.createComment('')\n              link.replaceWith(anchor)\n              onChunkLoadError(sourceType, chunkUrl, resolver, undefined, () =>\n                anchor.replaceWith(createLink())\n              )\n            }\n            link.onload = () => {\n              // CSS chunks do not register themselves, and as such must be marked as\n              // loaded instantly.\n              resolver.resolve()\n            }\n            return link\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(createLink())\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener(\n              'error',\n              () => {\n                // Drop the failed tag so a retry can re-add it cleanly.\n                script.remove()\n                onChunkLoadError(sourceType, chunkUrl, resolver)\n              },\n              { once: true }\n            )\n          }\n        } else {\n          const script = document.createElement('script')\n          script.crossOrigin = CROSS_ORIGIN\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            // Drop the failed tag so a retry can re-add it cleanly.\n            script.remove()\n            onChunkLoadError(sourceType, chunkUrl, resolver)\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n})()\n"],"names":["getAssetSuffixFromScriptSrc","self","TURBOPACK_ASSET_SUFFIX","src","document","currentScript","getAttribute","qi","indexOf","slice","BACKEND","chunkResolvers","Map","registerChunk","chunk","params","chunkPath","getPathFromScript","chunkUrl","getUrlFromScript","resolver","getOrCreateResolver","resolve","exactChunkUrl","test","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","getChunkRelativeUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","retryAttempts","set","rejectChunkResolver","error","delete","getChunkLoadRetryDelayMs","jitter","Math","floor","random","CHUNK_LOAD_RETRY_MAX_JITTER_MS","CHUNK_LOAD_RETRY_BASE_DELAY_MS","isRetryableChunkLoadError","DOMException","name","onChunkLoadError","reload","CHUNK_LOAD_RETRY_MAX_ATTEMPTS","setTimeout","SourceType","Runtime","isCss","importScripts","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","crossOrigin","CROSS_ORIGIN","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","createLink","anchor","createComment","replaceWith","undefined","remove","once"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file