diff --git a/.changeset/assetupdater-reinit-bypass.md b/.changeset/assetupdater-reinit-bypass.md
new file mode 100644
index 0000000..1c7f360
--- /dev/null
+++ b/.changeset/assetupdater-reinit-bypass.md
@@ -0,0 +1,5 @@
+---
+"@axistaylor/nextpress": patch
+---
+
+AssetUpdater now re-executes WordPress view scripts on client-side navigation, so scripts using the standard `document.readyState` / `DOMContentLoaded` ready-check re-initialize for the new page's content without any SPA-specific code. Adds a `reinitBypassHandles` prop to opt non-idempotent scripts (e.g. `wc-order-attribution`, whose `customElements.define()` throws on a second run) out of re-running — those load once and are skipped on subsequent navigations.
diff --git a/docs/api/asset-updater.md b/docs/api/asset-updater.md
index 4ebd4ec..0d52794 100644
--- a/docs/api/asset-updater.md
+++ b/docs/api/asset-updater.md
@@ -15,18 +15,19 @@ Because route-group `layout.tsx` files do **not** re-render on client-side navig
 
 ```tsx
 // components/AssetUpdater.tsx
-'use client';
+"use client";
 
-import { usePathname } from 'next/navigation';
+import { usePathname } from "next/navigation";
 import {
   AssetUpdater as BaseAssetUpdater,
   AssetData,
-} from '@axistaylor/nextpress/client';
+} from "@axistaylor/nextpress/client";
 
 export interface AssetUpdaterProps {
   fetchAssets: (uri: string) => Promise<AssetData>;
   instance?: string;
   bypassDomains?: string[];
+  reinitBypassHandles?: string[];
 }
 
 export function AssetUpdater(props: AssetUpdaterProps) {
@@ -36,6 +37,7 @@ export function AssetUpdater(props: AssetUpdaterProps) {
       fetchAssets={props.fetchAssets}
       instance={props.instance}
       bypassDomains={props.bypassDomains}
+      reinitBypassHandles={props.reinitBypassHandles}
       pathname={pathname}
     />
   );
@@ -46,13 +48,13 @@ Then use the wrapper in your WordPress layout:
 
 ```tsx
 // app/(wordpress-pages)/layout.tsx
-import { WPHead, WPFooter } from '@axistaylor/nextpress';
-import { AssetUpdater } from '@/components/AssetUpdater';
-import { fetchAssets } from '@/actions/fetchAssets';
-import { headers } from 'next/headers';
+import { WPHead, WPFooter } from "@axistaylor/nextpress";
+import { AssetUpdater } from "@/components/AssetUpdater";
+import { fetchAssets } from "@/actions/fetchAssets";
+import { headers } from "next/headers";
 
 export default async function WordPressLayout({ children }) {
-  const uri = (await headers()).get('x-uri') || '/';
+  const uri = (await headers()).get("x-uri") || "/";
   // …fetch stylesheets, scripts, importMap, globalStyles for initial SSR…
 
   return (
@@ -79,10 +81,10 @@ export default async function WordPressLayout({ children }) {
 
 ```ts
 // actions/fetchAssets.ts
-'use server';
+"use server";
 
-import type { AssetData } from '@axistaylor/nextpress/client';
-import { fetchStylesAndScriptsByUri, fetchGlobalStyles } from '@/lib/wordpress';
+import type { AssetData } from "@axistaylor/nextpress/client";
+import { fetchStylesAndScriptsByUri, fetchGlobalStyles } from "@/lib/wordpress";
 
 export async function fetchAssets(uri: string): Promise<AssetData> {
   const [{ stylesheets, scripts }, globalStyles] = await Promise.all([
@@ -99,12 +101,13 @@ export async function fetchAssets(uri: string): Promise<AssetData> {
 
 ## Props
 
-| Prop | Type | Required | Description |
-|------|------|----------|-------------|
-| `pathname` | `string` | Yes | The current pathname being rendered (usually sourced from `headers().get('x-uri')`) |
-| `fetchAssets` | `(uri: string) => Promise<AssetData>` | Yes | Server action that returns fresh stylesheets, scripts, and global styles for a URI |
-| `instance` | `string` | No | WordPress instance slug used for proxy URL rewriting (default: `'default'`) |
-| `bypassDomains` | `string[]` | No | Domains whose scripts/stylesheets load directly from their original URL instead of being proxied — e.g. `['js.stripe.com', 'fonts.googleapis.com']`. Matched by hostname; a root domain covers its subdomains (`stripe.com` covers `js.stripe.com`). Default: `[]` |
+| Prop                  | Type                                  | Required | Description                                                                                                                                                                                                                                                        |
+| --------------------- | ------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `pathname`            | `string`                              | Yes      | The current pathname being rendered (usually sourced from `headers().get('x-uri')`)                                                                                                                                                                                |
+| `fetchAssets`         | `(uri: string) => Promise<AssetData>` | Yes      | Server action that returns fresh stylesheets, scripts, and global styles for a URI                                                                                                                                                                                 |
+| `instance`            | `string`                              | No       | WordPress instance slug used for proxy URL rewriting (default: `'default'`)                                                                                                                                                                                        |
+| `bypassDomains`       | `string[]`                            | No       | Domains whose scripts/stylesheets load directly from their original URL instead of being proxied — e.g. `['js.stripe.com', 'fonts.googleapis.com']`. Matched by hostname; a root domain covers its subdomains (`stripe.com` covers `js.stripe.com`). Default: `[]` |
+| `reinitBypassHandles` | `string[]`                            | No       | Script handles to load once and **skip re-running** on client-side navigation. See [Script re-execution on navigation](#script-re-execution-on-navigation). Default: `[]`                                                                                          |
 
 ### `AssetData`
 
@@ -120,11 +123,11 @@ type AssetData = {
 
 `AssetUpdater` relies on marker tags emitted by the server components:
 
-| Markers | Owner |
-|---------|-------|
-| `nextpress-stylesheets-start` / `nextpress-stylesheets-end` | `<Stylesheets>` |
-| `nextpress-head-scripts-start` / `nextpress-head-scripts-end` | `<WPHead>` |
-| `nextpress-body-scripts-start` / `nextpress-body-scripts-end` | `<WPFooter>` |
+| Markers                                                       | Owner           |
+| ------------------------------------------------------------- | --------------- |
+| `nextpress-stylesheets-start` / `nextpress-stylesheets-end`   | `<Stylesheets>` |
+| `nextpress-head-scripts-start` / `nextpress-head-scripts-end` | `<WPHead>`      |
+| `nextpress-body-scripts-start` / `nextpress-body-scripts-end` | `<WPFooter>`    |
 
 On initial mount the effect is skipped (the server already rendered those assets). On every subsequent navigation the effect:
 
@@ -143,13 +146,13 @@ Pass `bypassDomains` to keep those assets on their original URL:
 ```tsx
 <AssetUpdater
   fetchAssets={fetchAssets}
-  bypassDomains={['js.stripe.com', 'fonts.googleapis.com', 'fonts.gstatic.com']}
+  bypassDomains={["js.stripe.com", "fonts.googleapis.com", "fonts.gstatic.com"]}
 />
 ```
 
 Matching is by **hostname** (scheme- and port-agnostic), and a root domain covers its subdomains — `stripe.com` matches both `stripe.com` and `js.stripe.com`.
 
-Keep this list aligned with the external origins your server-side asset rendering already emits directly: the server marks non-WordPress origins as external and renders their raw URLs, and `bypassDomains` is how the client reproduces that decision on navigation. When they agree, the initial SSR markup and the navigation-time markup match — including the external-script dedupe key — so third-party scripts aren't re-run.
+Keep this list aligned with the external origins your server-side asset rendering already emits directly: the server marks non-WordPress origins as external and renders their raw URLs, and `bypassDomains` is how the client reproduces that decision on navigation. When they agree, the initial SSR markup and the navigation-time markup match. `bypassDomains` only controls the asset _URL_; whether a script re-runs on navigation is governed separately by [`reinitBypassHandles`](#script-re-execution-on-navigation) — add a third-party handle there too if its IIFE is non-idempotent.
 
 ## Inline Script Synchronization
 
@@ -159,21 +162,50 @@ The built-in follow-up is for WooCommerce:
 
 - After the `wc-settings-js-before` inline script runs (which defines `window.wcSettings` for the new page), `processWcSettings(instance)` is invoked to resolve the `__NEXTPRESS_PROXY__` / `__NEXTPRESS_ASSETS__` placeholders inside the freshly-loaded settings object. Without this, cart and checkout blocks can get stuck in their skeleton state on client-side navigation because their Store API URLs still point at raw `__NEXTPRESS_*__` placeholders.
 
+## Script re-execution on navigation
+
+On each navigation `AssetUpdater` re-inserts the page's `<script>` elements, so every script **re-executes** for the new content. This is deliberate: WordPress view scripts conventionally initialize with the standard ready-check
+
+```js
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", init);
+} else {
+  init();
+}
+```
+
+On a fresh load `init()` runs on `DOMContentLoaded`. On a client-side navigation the document is already `complete`, so a re-evaluated script takes the `else` branch and re-runs `init()` against the new DOM — no SPA-specific code in the block. (`AssetUpdater` also fires synthetic `DOMContentLoaded`, `load`, and `nextpress:page-change` events for scripts that instead attach a listener.) Authors get correct behavior on navigation for free, whichever convention they use.
+
+### `reinitBypassHandles`
+
+Re-execution is unsafe for scripts whose top-level code isn't idempotent. The canonical case is `customElements.define()`, which throws `NotSupportedError` on a second call for the same tag name and aborts the rest of that script — e.g. WooCommerce's `wc-order-attribution`.
+
+List such handles in `reinitBypassHandles`; they load once and are skipped on every later navigation:
+
+```tsx
+<AssetUpdater
+  fetchAssets={fetchAssets}
+  reinitBypassHandles={["wc-order-attribution"]}
+/>
+```
+
+NextPress ships no handles in this list by default — it never branches on handle names itself; each app declares the scripts it knows to be non-idempotent.
+
 ## Navigation Behavior
 
-| Mount state | Effect runs? | Notes |
-|-------------|--------------|-------|
-| Initial SSR hydration | No | The server already rendered the markup |
-| Navigating to a new URI | Yes | Full refresh |
-| Revisiting the initial URI | Yes | Assets re-fetched — stays in sync with any backend changes |
+| Mount state                | Effect runs? | Notes                                                      |
+| -------------------------- | ------------ | ---------------------------------------------------------- |
+| Initial SSR hydration      | No           | The server already rendered the markup                     |
+| Navigating to a new URI    | Yes          | Full refresh                                               |
+| Revisiting the initial URI | Yes          | Assets re-fetched — stays in sync with any backend changes |
 
 ## Client Component
 
 `AssetUpdater` is a React Client Component. Import it from the client entrypoint if you need the explicit client path (otherwise it's re-exported from `@axistaylor/nextpress` directly):
 
 ```tsx
-import { AssetUpdater } from '@axistaylor/nextpress/client';
-import type { AssetData } from '@axistaylor/nextpress/client';
+import { AssetUpdater } from "@axistaylor/nextpress/client";
+import type { AssetData } from "@axistaylor/nextpress/client";
 ```
 
 ## Related
diff --git a/packages/js/src/AssetUpdater/AssetUpdater.tsx b/packages/js/src/AssetUpdater/AssetUpdater.tsx
index 6c7a78a..8cf6376 100644
--- a/packages/js/src/AssetUpdater/AssetUpdater.tsx
+++ b/packages/js/src/AssetUpdater/AssetUpdater.tsx
@@ -1,12 +1,21 @@
-import { useEffect, useRef } from 'react';
-import { EnqueuedScript, EnqueuedStylesheet, GlobalStylesType, ScriptLoadingGroupEnum, ScriptTypeEnum } from '@/types';
-import { WPImport } from '@/ImportMap';
-import { scopeInlineStyles } from '@/utils/scopeStyles';
-import { transformAssetUrl, isBypassedHost } from '@/utils/url';
-import { firePageEvents } from '@/hooks/usePageEvents';
-import { joinScriptContent } from '@/utils/content';
-import { replaceProxyPlaceholders, processWcSettings } from '@/compatibility/woocommerce';
-import { startPlaceholderObserver } from './placeholderObserver';
+import { useEffect, useRef } from "react";
+import {
+  EnqueuedScript,
+  EnqueuedStylesheet,
+  GlobalStylesType,
+  ScriptLoadingGroupEnum,
+  ScriptTypeEnum,
+} from "@/types";
+import { WPImport } from "@/ImportMap";
+import { scopeInlineStyles } from "@/utils/scopeStyles";
+import { transformAssetUrl, isBypassedHost } from "@/utils/url";
+import { firePageEvents } from "@/hooks/usePageEvents";
+import { joinScriptContent } from "@/utils/content";
+import {
+  replaceProxyPlaceholders,
+  processWcSettings,
+} from "@/compatibility/woocommerce";
+import { startPlaceholderObserver } from "./placeholderObserver";
 
 export interface AssetData {
   stylesheets: EnqueuedStylesheet[];
@@ -15,31 +24,24 @@ export interface AssetData {
   importMap?: WPImport[] | null;
 }
 
-/**
- * External script srcs already loaded in this browser session. Removing
- * a `<script>` element from the DOM does NOT undo its side effects — any
- * globals it defined and any `customElements.define()` calls it made
- * persist. Re-inserting the same external src on the next navigation
- * therefore re-runs the IIFE and breaks anything non-idempotent
- * (e.g. wc-order-attribution throws `NotSupportedError: the name
- * "wc-order-attribution-inputs" has already been used`).
- *
- * Session-scoped (lives for the lifetime of the page) so navigation
- * between many WP-instance pages doesn't accumulate forever in practice.
- * Cleared automatically on full page reload.
- */
-const loadedExternalSrcs = new Set<string>();
+/** Resolved srcs of `reinitBypassHandles` scripts already loaded this session. */
+const loadedBypassedSrcs = new Set<string>();
 
 /**
  * Resolves an asset src to load: assets whose host is (or is a subdomain of)
  * a bypassed domain keep their original external URL; everything else is
  * routed through the instance asset proxy.
  */
-function resolveAssetSrc(src: string, instance: string, bypassDomains: string[]): string {
-  return isBypassedHost(src, bypassDomains) ? src : transformAssetUrl(src, instance);
+function resolveAssetSrc(
+  src: string,
+  instance: string,
+  bypassDomains: string[]
+): string {
+  return isBypassedHost(src, bypassDomains)
+    ? src
+    : transformAssetUrl(src, instance);
 }
 
-
 export interface AssetUpdaterProps {
   /**
    * The current pathname being rendered.
@@ -63,6 +65,11 @@ export interface AssetUpdaterProps {
    * root domains covering subdomains (`stripe.com` covers `js.stripe.com`).
    */
   bypassDomains?: string[];
+  /**
+   * Script handles to load once and skip re-running on client navigation.
+   * See docs/api/asset-updater.md ("Script re-execution on navigation").
+   */
+  reinitBypassHandles?: string[];
 }
 
 /**
@@ -71,7 +78,7 @@ export interface AssetUpdaterProps {
  */
 function clearBetweenMarkers(
   startId: string,
-  endId: string,
+  endId: string
 ): { parent: HTMLElement; endMarker: HTMLElement } | null {
   const startMarker = document.getElementById(startId);
   const endMarker = document.getElementById(endId);
@@ -98,7 +105,7 @@ function clearBetweenMarkers(
  * Creates a <style> element with the given id and CSS content.
  */
 function createStyleElement(id: string, css: string): HTMLStyleElement {
-  const el = document.createElement('style');
+  const el = document.createElement("style");
   el.id = id;
   el.textContent = css;
   return el;
@@ -108,9 +115,9 @@ function createStyleElement(id: string, css: string): HTMLStyleElement {
  * Creates a <link rel="stylesheet"> element with the given id and href.
  */
 function createLinkElement(id: string, href: string): HTMLLinkElement {
-  const el = document.createElement('link');
+  const el = document.createElement("link");
   el.id = id;
-  el.rel = 'stylesheet';
+  el.rel = "stylesheet";
   el.href = href;
   return el;
 }
@@ -124,13 +131,13 @@ function createLinkElement(id: string, href: string): HTMLLinkElement {
  */
 function createScriptElement(
   id: string,
-  options: { src?: string; content?: string; isModule?: boolean },
+  options: { src?: string; content?: string; isModule?: boolean }
 ): { el: HTMLScriptElement; loaded: Promise<void> } {
-  const el = document.createElement('script');
+  const el = document.createElement("script");
   el.id = id;
 
   if (options.isModule) {
-    el.type = 'module';
+    el.type = "module";
   }
 
   let loaded: Promise<void>;
@@ -141,8 +148,8 @@ function createScriptElement(
       el.async = false;
     }
     loaded = new Promise<void>((resolve) => {
-      el.addEventListener('load', () => resolve(), { once: true });
-      el.addEventListener('error', () => resolve(), { once: true });
+      el.addEventListener("load", () => resolve(), { once: true });
+      el.addEventListener("error", () => resolve(), { once: true });
     });
     el.src = options.src;
   } else if (options.content) {
@@ -158,10 +165,14 @@ function createScriptElement(
 /**
  * Replaces the stylesheet list between the nextpress-stylesheets-start/end markers.
  */
-function updateStylesheets(stylesheets: EnqueuedStylesheet[], instance: string, bypassDomains: string[]): void {
+function updateStylesheets(
+  stylesheets: EnqueuedStylesheet[],
+  instance: string,
+  bypassDomains: string[]
+): void {
   const range = clearBetweenMarkers(
-    'nextpress-stylesheets-start',
-    'nextpress-stylesheets-end',
+    "nextpress-stylesheets-start",
+    "nextpress-stylesheets-end"
   );
   if (!range) return;
 
@@ -175,16 +186,19 @@ function updateStylesheets(stylesheets: EnqueuedStylesheet[], instance: string,
       parent.insertBefore(
         createStyleElement(
           `${handle}-before`,
-          scopeInlineStyles(joinScriptContent(stylesheet.before)),
+          scopeInlineStyles(joinScriptContent(stylesheet.before))
         ),
-        endMarker,
+        endMarker
       );
     }
 
     if (stylesheet.src) {
       parent.insertBefore(
-        createLinkElement(handle, resolveAssetSrc(stylesheet.src, instance, bypassDomains)),
-        endMarker,
+        createLinkElement(
+          handle,
+          resolveAssetSrc(stylesheet.src, instance, bypassDomains)
+        ),
+        endMarker
       );
     }
 
@@ -192,9 +206,9 @@ function updateStylesheets(stylesheets: EnqueuedStylesheet[], instance: string,
       parent.insertBefore(
         createStyleElement(
           `${handle}-inline-css`,
-          scopeInlineStyles(joinScriptContent(stylesheet.after)),
+          scopeInlineStyles(joinScriptContent(stylesheet.after))
         ),
-        endMarker,
+        endMarker
       );
     }
   });
@@ -211,22 +225,19 @@ async function updateScripts(
   instance: string,
   pathname: string,
   bypassDomains: string[],
+  reinitBypassHandles: string[]
 ): Promise<void> {
-  // Seed the dedupe set from scripts currently between the markers
-  // before clearing. Server-rendered scripts (initial page load) and
-  // scripts inserted by a previous AssetUpdater run have both already
-  // executed — their side effects are in JS land regardless of whether
-  // their <script> element still exists in the DOM. Comparing on the
-  // raw src attribute matches how we insert new scripts below.
+  // Seed from scripts already in the DOM so bypassed handles rendered on the
+  // initial page are recognized as loaded on the first navigation.
   const startSeed = document.getElementById(startId);
   const endSeed = document.getElementById(endId);
   if (startSeed && endSeed) {
     let node: ChildNode | null = startSeed.nextSibling;
     while (node && node !== endSeed) {
       if (node instanceof HTMLScriptElement) {
-        const seedSrc = node.getAttribute('src');
+        const seedSrc = node.getAttribute("src");
         if (seedSrc) {
-          loadedExternalSrcs.add(seedSrc);
+          loadedBypassedSrcs.add(seedSrc);
         }
       }
       node = node.nextSibling;
@@ -245,7 +256,7 @@ async function updateScripts(
   // defined by previous external scripts.
   const insert = async (
     id: string,
-    options: { src?: string; content?: string; isModule?: boolean },
+    options: { src?: string; content?: string; isModule?: boolean }
   ): Promise<void> => {
     const { el, loaded } = createScriptElement(id, options);
     parent.insertBefore(el, endMarker);
@@ -262,10 +273,12 @@ async function updateScripts(
   const insertInlineAndAwait = async (
     id: string,
     content: string,
-    onExecuted?: () => void,
+    onExecuted?: () => void
   ): Promise<void> => {
     const eventName = `nextpress:inline-executed:${id}`;
-    const instrumented = `${content}\n;document.dispatchEvent(new CustomEvent(${JSON.stringify(eventName)}));`;
+    const instrumented = `${content}\n;document.dispatchEvent(new CustomEvent(${JSON.stringify(
+      eventName
+    )}));`;
     const executed = new Promise<void>((resolve) => {
       document.addEventListener(eventName, () => resolve(), { once: true });
     });
@@ -283,15 +296,24 @@ async function updateScripts(
     if (!handle) continue;
 
     const isModule = String(script.type) === ScriptTypeEnum.MODULE;
+    const resolvedSrc = script.src
+      ? resolveAssetSrc(script.src, instance, bypassDomains)
+      : "";
+
+    // Bypassed handles load once and are skipped on later navigations.
+    if (reinitBypassHandles.includes(String(handle))) {
+      if (resolvedSrc && loadedBypassedSrcs.has(resolvedSrc)) {
+        continue;
+      }
+      if (resolvedSrc) {
+        loadedBypassedSrcs.add(resolvedSrc);
+      }
+    }
 
     // ES modules don't have inline extra/before/after scripts — just load the src.
     if (isModule) {
-      if (script.src) {
-        const src = resolveAssetSrc(script.src, instance, bypassDomains);
-        if (!loadedExternalSrcs.has(src)) {
-          loadedExternalSrcs.add(src);
-          await insert(handle, { src, isModule: true });
-        }
+      if (resolvedSrc) {
+        await insert(handle, { src: resolvedSrc, isModule: true });
       }
       continue;
     }
@@ -309,18 +331,12 @@ async function updateScripts(
       await insertInlineAndAwait(
         `${handle}-js-before`,
         beforeScript,
-        handle === 'wc-settings'
-          ? () => processWcSettings(instance)
-          : undefined,
+        handle === "wc-settings" ? () => processWcSettings(instance) : undefined
       );
     }
 
-    if (script.src) {
-      const src = resolveAssetSrc(script.src, instance, bypassDomains);
-      if (!loadedExternalSrcs.has(src)) {
-        loadedExternalSrcs.add(src);
-        await insert(handle, { src });
-      }
+    if (resolvedSrc) {
+      await insert(handle, { src: resolvedSrc });
     }
 
     const afterScript = joinScriptContent(script.after);
@@ -336,7 +352,7 @@ async function updateScripts(
 function updateGlobalStyles(
   globalStyles: GlobalStylesType | null | undefined,
   instance: string,
-  pathname: string,
+  pathname: string
 ): void {
   const existing = document.querySelectorAll('[data-nextpress="global"]');
   existing.forEach((el) => el.parentElement?.removeChild(el));
@@ -348,41 +364,44 @@ function updateGlobalStyles(
   // Re-register the wp-theme layer on every navigation so theme.json
   // globalStyles stay below proxied CSS and unlayered author rules in
   // the cascade after the previous declaration is torn down.
-  const layerOrder = createStyleElement('nextpress-layer-order', '@layer wp-theme;');
-  layerOrder.setAttribute('data-nextpress', 'global');
+  const layerOrder = createStyleElement(
+    "nextpress-layer-order",
+    "@layer wp-theme;"
+  );
+  layerOrder.setAttribute("data-nextpress", "global");
   head.appendChild(layerOrder);
 
   if (globalStyles.renderedFontFaces) {
     const fontFaceCss = replaceProxyPlaceholders(
       globalStyles.renderedFontFaces
-        .replace(/<style[^>]*>/gi, '')
-        .replace(/<\/style>/gi, '')
+        .replace(/<style[^>]*>/gi, "")
+        .replace(/<\/style>/gi, "")
         .trim(),
       instance,
-      pathname,
+      pathname
     );
     if (fontFaceCss) {
-      const el = createStyleElement('nextpress-font-faces', fontFaceCss);
-      el.setAttribute('data-nextpress', 'global');
+      const el = createStyleElement("nextpress-font-faces", fontFaceCss);
+      el.setAttribute("data-nextpress", "global");
       head.appendChild(el);
     }
   }
 
   if (globalStyles.stylesheet) {
     const el = createStyleElement(
-      'nextpress-global-styles',
-      scopeInlineStyles(globalStyles.stylesheet, { layer: 'wp-theme' }),
+      "nextpress-global-styles",
+      scopeInlineStyles(globalStyles.stylesheet, { layer: "wp-theme" })
     );
-    el.setAttribute('data-nextpress', 'global');
+    el.setAttribute("data-nextpress", "global");
     head.appendChild(el);
   }
 
   if (globalStyles.customCss) {
     const el = createStyleElement(
-      'nextpress-custom-css',
-      scopeInlineStyles(globalStyles.customCss, { layer: 'wp-theme' }),
+      "nextpress-custom-css",
+      scopeInlineStyles(globalStyles.customCss, { layer: "wp-theme" })
     );
-    el.setAttribute('data-nextpress', 'global');
+    el.setAttribute("data-nextpress", "global");
     head.appendChild(el);
   }
 }
@@ -395,9 +414,9 @@ function updateGlobalStyles(
 function updateImportMap(
   imports: WPImport[] | null | undefined,
   instance: string,
-  pathname: string,
+  pathname: string
 ): void {
-  const existing = document.getElementById('wp-importmap');
+  const existing = document.getElementById("wp-importmap");
   if (existing) {
     existing.parentElement?.removeChild(existing);
   }
@@ -410,14 +429,13 @@ function updateImportMap(
     map[entry.name] = transformAssetUrl(entry.path, instance);
   }
 
-  const el = document.createElement('script');
-  el.type = 'importmap';
-  el.id = 'wp-importmap';
+  const el = document.createElement("script");
+  el.type = "importmap";
+  el.id = "wp-importmap";
   el.textContent = JSON.stringify({ imports: map });
   document.head.appendChild(el);
 }
 
-
 /**
  * Client component that refreshes NextPress server-rendered assets
  * (stylesheets, scripts, global styles) on client-side navigation.
@@ -429,9 +447,10 @@ function updateImportMap(
  */
 export function AssetUpdater({
   pathname,
-  instance = 'default',
+  instance = "default",
   fetchAssets,
   bypassDomains = [],
+  reinitBypassHandles = [],
 }: AssetUpdaterProps) {
   // Watch the DOM for `__NEXTPRESS_*` placeholders in element attribute
   // values and rewrite them to proxy values on every mutation. Lives in
@@ -472,29 +491,31 @@ export function AssetUpdater({
         await updateScripts(
           assets.scripts,
           ScriptLoadingGroupEnum.HEADER,
-          'nextpress-head-scripts-start',
-          'nextpress-head-scripts-end',
+          "nextpress-head-scripts-start",
+          "nextpress-head-scripts-end",
           instance,
           pathname,
           bypassDomains,
+          reinitBypassHandles
         );
         if (cancelled) return;
 
         await updateScripts(
           assets.scripts,
           ScriptLoadingGroupEnum.FOOTER,
-          'nextpress-body-scripts-start',
-          'nextpress-body-scripts-end',
+          "nextpress-body-scripts-start",
+          "nextpress-body-scripts-end",
           instance,
           pathname,
           bypassDomains,
+          reinitBypassHandles
         );
         if (cancelled) return;
 
         firePageEvents();
       } catch (error) {
         // eslint-disable-next-line no-console
-        console.error('[AssetUpdater] Failed to update assets:', error);
+        console.error("[AssetUpdater] Failed to update assets:", error);
       }
     })();