@absolutejs/absolute 0.19.0-beta.999 → 0.20.0-beta.1

package/dist/dev/client/handlers/html.ts

@@ -17,6 +17,7 @@ import { detectCurrentFramework } from '../frameworkDetect';
 import type { ScriptInfo } from '../../../types/client';
 import { restoreDOMChanges, snapshotDOMChanges } from '../domTracker';
 import { hmrState } from '../hmrState';
+import { sendAbsoluteHmrTiming } from '../hmrTiming';
 
 const parseHTMLMessage = (
 	html: string | { body?: string; head?: string } | null | undefined
@@ -57,11 +58,10 @@ const handleHTMLBodyWithHead = (
 
 	const cssResult = processCSSLinks(htmlHead);
 
-	const updateBodyAfterCSS = () => {
+	const updateBodyAfterCSS = () =>
 		updateHTMLBody(htmlBody, htmlDomState, document.body);
-	};
 
-	waitForCSSAndUpdate(cssResult, updateBodyAfterCSS);
+	return waitForCSSAndUpdate(cssResult, updateBodyAfterCSS);
 };
 
 const handleHTMLBodyWithoutHead = (
@@ -72,17 +72,21 @@ const handleHTMLBodyWithoutHead = (
 	if (!container) {
 		sessionStorage.removeItem('__HMR_ACTIVE__');
 
-		return;
+		return Promise.resolve();
 	}
 
-	updateHTMLBodyDirect(htmlBody, htmlDomState, container);
+	const updated = updateHTMLBodyDirect(htmlBody, htmlDomState, container);
 	restoreDOMState(container, htmlDomState);
+
+	return updated;
 };
 
 export const handleHTMLUpdate = (message: {
 	data: {
 		html?: string | { body?: string; head?: string } | null;
+		serverDuration?: number;
 	};
+	timestamp?: number;
 }) => {
 	const htmlFrameworkCheck = detectCurrentFramework();
 	if (htmlFrameworkCheck !== 'html') {
@@ -94,6 +98,7 @@ export const handleHTMLUpdate = (message: {
 	}
 
 	sessionStorage.setItem('__HMR_ACTIVE__', 'true');
+	const clientStart = performance.now();
 
 	const htmlDomState = saveDOMState(document.body);
 	const { body: htmlBody, head: htmlHead } = parseHTMLMessage(
@@ -102,18 +107,48 @@ export const handleHTMLUpdate = (message: {
 
 	if (!htmlBody) {
 		sessionStorage.removeItem('__HMR_ACTIVE__');
+		sendAbsoluteHmrTiming({
+			clientStart,
+			kind: 'html',
+			outcome: 'failed',
+			serverMs: message.data.serverDuration,
+			updateId: message.timestamp
+		});
 
 		return;
 	}
 
-	if (htmlHead) {
-		handleHTMLBodyWithHead(htmlBody, htmlHead, htmlDomState);
-	} else {
-		handleHTMLBodyWithoutHead(htmlBody, htmlDomState);
-	}
+	const update = htmlHead
+		? handleHTMLBodyWithHead(htmlBody, htmlHead, htmlDomState)
+		: handleHTMLBodyWithoutHead(htmlBody, htmlDomState);
+	void update.then(
+		() => {
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'html',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+		},
+		() => {
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'html',
+				outcome: 'reloaded',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+			window.location.reload();
+		}
+	);
 };
 export const handleScriptUpdate = (message: {
-	data: { framework?: string; scriptPath?: string };
+	data: {
+		framework?: string;
+		scriptPath?: string;
+		serverDuration?: number;
+	};
+	timestamp?: number;
 }) => {
 	const scriptFramework = message.data.framework;
 	const currentFw = detectCurrentFramework();
@@ -139,13 +174,30 @@ export const handleScriptUpdate = (message: {
 	});
 
 	const cacheBustedPath = `${scriptPath}?t=${Date.now()}`;
+	const clientStart = performance.now();
 	import(cacheBustedPath)
-		.then(() => true)
+		.then(() => {
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'script',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+
+			return true;
+		})
 		.catch((err: unknown) => {
 			console.error(
 				'[HMR] Script hot-reload failed, falling back to page reload:',
 				err
 			);
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'script',
+				outcome: 'reloaded',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
 			window.location.reload();
 		});
 };
@@ -172,21 +224,30 @@ const updateHTMLBody = (
 	container: HTMLElement
 ) => {
 	if (!container) {
-		return;
+		return Promise.resolve();
 	}
+	const { promise, resolve } = Promise.withResolvers<void>();
 
 	const savedState = saveHTMLState();
 	const domSnapshot = snapshotDOMChanges(container);
 
 	const existingScripts = collectScripts(container);
+	const oldInlineScripts = collectInlineScripts(container);
 	const hmrScript = container.querySelector('script[data-hmr-client]');
 	const tempDiv = document.createElement('div');
 	tempDiv.innerHTML = htmlBody;
 	const newScripts = collectScriptsFromElement(tempDiv);
+	const newInlineScripts = collectInlineScripts(tempDiv);
 
 	const htmlStructureChanged = didHTMLStructureChange(container, tempDiv);
+	const inlineScriptsChanged = didInlineScriptsChange(
+		oldInlineScripts,
+		newInlineScripts
+	);
+	const scriptsChanged =
+		didScriptsChange(existingScripts, newScripts) || inlineScriptsChanged;
 
-	if (htmlStructureChanged || didScriptsChange(existingScripts, newScripts)) {
+	if (htmlStructureChanged || scriptsChanged) {
 		patchDOMInPlace(container, htmlBody);
 		restoreDOMChanges(container, domSnapshot, htmlBody);
 	}
@@ -198,29 +259,27 @@ const updateHTMLBody = (
 		restoreFormState(savedState.forms);
 		restoreScrollState(savedState.scroll);
 
-		if (
-			didScriptsChange(existingScripts, newScripts) ||
-			htmlStructureChanged
-		) {
-			cloneInteractiveElements(container);
-			reExecuteScripts(container, newScripts);
+		// Only touch scripts/interactive elements when a script actually
+		// changed. A pure markup edit (e.g. a heading) leaves inline-script
+		// state and `addEventListener` handlers intact.
+		if (scriptsChanged) {
+			// Clone (which strips listeners via cloneNode) ONLY when an inline
+			// script changed: a changed inline script re-runs in place below
+			// and would otherwise double-bind on elements that still carry the
+			// old handler. Unchanged inline scripts are skipped on re-exec, and
+			// external modules are re-imported via `import()` whose module cache
+			// means an unchanged body never re-runs — cloning for those would
+			// orphan their listeners forever (the regression this fixes).
+			if (inlineScriptsChanged) {
+				cloneInteractiveElements(container);
+			}
+			reExecuteScripts(container, newScripts, oldInlineScripts);
 		}
+		sessionStorage.removeItem('__HMR_ACTIVE__');
+		resolve();
 	});
-	sessionStorage.removeItem('__HMR_ACTIVE__');
-};
 
-const cloneHmrListenerElements = (container: HTMLElement) => {
-	container
-		.querySelectorAll('[data-hmr-listeners-attached]')
-		.forEach((elem) => {
-			const cloned = elem.cloneNode(true);
-			if (elem.parentNode) {
-				elem.parentNode.replaceChild(cloned, elem);
-			}
-			if (cloned instanceof Element) {
-				cloned.removeAttribute('data-hmr-listeners-attached');
-			}
-		});
+	return promise;
 };
 
 const replaceInlineScript = (script: Element) => {
@@ -242,9 +301,11 @@ const updateHTMLBodyDirect = (
 	htmlDomState: ReturnType<typeof saveDOMState>,
 	container: HTMLElement
 ) => {
+	const { promise, resolve } = Promise.withResolvers<void>();
 	const savedState = saveHTMLState();
 	const domSnapshot = snapshotDOMChanges(container);
 
+	const oldInlineScripts = collectInlineScripts(container);
 	const tempDiv = document.createElement('div');
 	tempDiv.innerHTML = htmlBody;
 	const newScripts = collectScriptsFromElement(tempDiv);
@@ -260,7 +321,13 @@ const updateHTMLBodyDirect = (
 		restoreFormState(savedState.forms);
 		restoreScrollState(savedState.scroll);
 
-		cloneHmrListenerElements(container);
+		// Unlike `updateHTMLBody` (which re-imports externals as ES modules and
+		// must not clone unchanged ones), this path rebuilds EVERY external
+		// script below as a fresh `<script src?t=>` tag that always
+		// re-executes. So a single clone here is correct and necessary: it
+		// gives each re-running script a pristine element to bind once, with no
+		// double-binding.
+		cloneInteractiveElements(container);
 
 		removeOldScripts(container);
 		newScripts.forEach((scriptInfo) => {
@@ -271,10 +338,12 @@ const updateHTMLBodyDirect = (
 			container.appendChild(newScript);
 		});
 
-		const inlineScripts = container.querySelectorAll('script:not([src])');
-		inlineScripts.forEach(replaceInlineScript);
+		reExecuteInlineScripts(container, oldInlineScripts);
+		sessionStorage.removeItem('__HMR_ACTIVE__');
+		resolve();
 	});
-	sessionStorage.removeItem('__HMR_ACTIVE__');
+
+	return promise;
 };
 
 /* Shared helpers for HTML body updates */
@@ -291,6 +360,18 @@ const collectScriptsFromElement = (elem: HTMLElement) =>
 		type: script.getAttribute('type') || 'text/javascript'
 	}));
 
+/* Inline (non-src) scripts, excluding the HMR client. Captured by ordinal so
+ * an unchanged inline script can be skipped on re-execution — re-running it
+ * would reset its module/global state (e.g. `let count = 0`) on every edit. */
+const collectInlineScripts = (elem: HTMLElement) =>
+	Array.from(
+		elem.querySelectorAll('script:not([src]):not([data-hmr-client])')
+	).map((script) => script.textContent || '');
+
+const didInlineScriptsChange = (oldInline: string[], newInline: string[]) =>
+	oldInline.length !== newInline.length ||
+	oldInline.some((content, idx) => content !== newInline[idx]);
+
 const didScriptsChange = (oldScripts: ScriptInfo[], newScripts: ScriptInfo[]) =>
 	oldScripts.length !== newScripts.length ||
 	oldScripts.some((oldScript, idx) => {
@@ -348,7 +429,11 @@ const removeOldScripts = (container: HTMLElement) => {
 	});
 };
 
-const reExecuteScripts = (container: HTMLElement, newScripts: ScriptInfo[]) => {
+const reExecuteScripts = (
+	container: HTMLElement,
+	newScripts: ScriptInfo[],
+	oldInlineScripts: string[]
+) => {
 	removeOldScripts(container);
 
 	newScripts.forEach((scriptInfo) => {
@@ -359,6 +444,24 @@ const reExecuteScripts = (container: HTMLElement, newScripts: ScriptInfo[]) => {
 		container.appendChild(newScript);
 	});
 
-	const inlineScripts = container.querySelectorAll('script:not([src])');
-	inlineScripts.forEach(replaceInlineScript);
+	reExecuteInlineScripts(container, oldInlineScripts);
+};
+
+/* Re-execute inline scripts by replacing them with fresh nodes, but skip any
+ * whose textContent is byte-identical to its previous counterpart (matched by
+ * ordinal). Skipping leaves the original execution's global bindings intact,
+ * so unrelated edits don't reset inline-script state. */
+const reExecuteInlineScripts = (
+	container: HTMLElement,
+	oldInlineScripts: string[]
+) => {
+	const inlineScripts = container.querySelectorAll(
+		'script:not([src]):not([data-hmr-client])'
+	);
+	inlineScripts.forEach((script, idx) => {
+		if (oldInlineScripts[idx] === (script.textContent || '')) {
+			return;
+		}
+		replaceInlineScript(script);
+	});
 };

package/dist/dev/client/handlers/htmx.ts

@@ -16,6 +16,7 @@ import { patchHeadInPlace } from '../headPatch';
 import { detectCurrentFramework } from '../frameworkDetect';
 import { type HTMXSavedState, type ScriptInfo } from '../../../types/client';
 import { hmrState } from '../hmrState';
+import { sendAbsoluteHmrTiming } from '../hmrTiming';
 
 const parseHTMXMessage = (
 	html: string | { body?: string; head?: string } | null | undefined
@@ -52,23 +53,26 @@ const handleHTMXBodyUpdate = (
 	htmxHead: string | null,
 	htmxDomState: ReturnType<typeof saveDOMState>
 ) => {
-	const updateHTMXBodyAfterCSS = () => {
+	const updateHTMXBodyAfterCSS = () =>
 		updateHTMXBody(htmxBody, htmxDomState, document.body);
-	};
 
 	if (htmxHead) {
 		applyHeadPatch(htmxHead);
+
 		const cssResult = processCSSLinks(htmxHead);
-		waitForCSSAndUpdate(cssResult, updateHTMXBodyAfterCSS);
-	} else {
-		updateHTMXBodyAfterCSS();
+
+		return waitForCSSAndUpdate(cssResult, updateHTMXBodyAfterCSS);
 	}
+
+	return updateHTMXBodyAfterCSS();
 };
 
 export const handleHTMXUpdate = (message: {
 	data: {
 		html?: string | { body?: string; head?: string } | null;
+		serverDuration?: number;
 	};
+	timestamp?: number;
 }) => {
 	const htmxFrameworkCheck = detectCurrentFramework();
 	if (htmxFrameworkCheck !== 'htmx') return;
@@ -78,6 +82,7 @@ export const handleHTMXUpdate = (message: {
 	}
 
 	sessionStorage.setItem('__HMR_ACTIVE__', 'true');
+	const clientStart = performance.now();
 
 	const htmxDomState = saveDOMState(document.body);
 	const { body: htmxBody, head: htmxHead } = parseHTMXMessage(
@@ -86,11 +91,37 @@ export const handleHTMXUpdate = (message: {
 
 	if (!htmxBody) {
 		sessionStorage.removeItem('__HMR_ACTIVE__');
+		sendAbsoluteHmrTiming({
+			clientStart,
+			kind: 'htmx',
+			outcome: 'failed',
+			serverMs: message.data.serverDuration,
+			updateId: message.timestamp
+		});
 
 		return;
 	}
 
-	handleHTMXBodyUpdate(htmxBody, htmxHead, htmxDomState);
+	void handleHTMXBodyUpdate(htmxBody, htmxHead, htmxDomState).then(
+		() => {
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'htmx',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+		},
+		() => {
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'htmx',
+				outcome: 'reloaded',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+			window.location.reload();
+		}
+	);
 };
 
 const cloneHmrListenerElements = (container: HTMLElement) => {
@@ -169,7 +200,8 @@ const updateHTMXBody = (
 	htmxDomState: ReturnType<typeof saveDOMState>,
 	container: HTMLElement
 ) => {
-	if (!container) return;
+	if (!container) return Promise.resolve();
+	const { promise, resolve } = Promise.withResolvers<void>();
 
 	const countSpan = container.querySelector('#count');
 	const countValue = countSpan
@@ -218,8 +250,11 @@ const updateHTMXBody = (
 		if (window.htmx) {
 			window.htmx.process(container);
 		}
+		sessionStorage.removeItem('__HMR_ACTIVE__');
+		resolve();
 	});
-	sessionStorage.removeItem('__HMR_ACTIVE__');
+
+	return promise;
 };
 
 /* Shared helpers */

package/dist/dev/client/handlers/react.ts

@@ -6,9 +6,18 @@ import type {} from '../../../types/globals';
 
 import { hideErrorOverlay } from '../errorOverlay';
 import { detectCurrentFramework } from '../frameworkDetect';
+import { sendAbsoluteHmrTiming } from '../hmrTiming';
+import { swapCSSStylesheet } from '../cssUtils';
+
+const reloadReactPage = () => {
+	const url = new URL(window.location.href);
+	url.searchParams.set('__absolute_hmr', Date.now().toString());
+	window.location.replace(url.href);
+};
 
 export const handleReactUpdate = (message: {
 	data: {
+		fastRefreshSupported?: boolean;
 		hasCSSChanges?: boolean;
 		hasComponentChanges?: boolean;
 		manifest?: Record<string, string>;
@@ -16,6 +25,7 @@ export const handleReactUpdate = (message: {
 		primarySource?: string;
 		serverDuration?: number;
 	};
+	timestamp?: number;
 }) => {
 	const currentFramework = detectCurrentFramework();
 	if (currentFramework !== 'react') return;
@@ -24,52 +34,99 @@ export const handleReactUpdate = (message: {
 	const hasCSSChanges = message.data.hasCSSChanges === true;
 	const cssPath =
 		message.data.manifest && message.data.manifest.ReactExampleCSS;
-
 	if (!hasComponentChanges && hasCSSChanges && cssPath) {
-		reloadReactCSS(cssPath);
+		const clientStart = performance.now();
+		void reloadReactCSS(cssPath).then((applied) => {
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'css',
+				outcome: applied ? 'applied' : 'failed',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+		});
 
 		return;
 	}
+	if (message.data.fastRefreshSupported === false) {
+		const { pageModuleUrl } = message.data;
+		const remount = window.__ABS_REACT_REMOUNT__;
+		if (pageModuleUrl && remount) {
+			applyRemountImport(
+				pageModuleUrl,
+				remount,
+				message.data.serverDuration,
+				message.timestamp
+			);
+		} else {
+			const clientStart = performance.now();
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'component',
+				outcome: 'reloaded',
+				serverMs: message.data.serverDuration,
+				updateId: message.timestamp
+			});
+			reloadReactPage();
+		}
 
+		return;
+	}
 	const refreshRuntime = window.$RefreshRuntime$;
 	const { serverDuration } = message.data;
 	const { pageModuleUrl } = message.data;
 
 	if (pageModuleUrl && refreshRuntime) {
-		applyRefreshImport(pageModuleUrl, refreshRuntime, serverDuration);
+		applyRefreshImport(
+			pageModuleUrl,
+			refreshRuntime,
+			serverDuration,
+			message.timestamp
+		);
 
 		return;
 	}
 
 	// No module URL — shouldn't happen, but reload as safety fallback
+	const clientStart = performance.now();
+	sendAbsoluteHmrTiming({
+		clientStart,
+		kind: 'component',
+		outcome: 'reloaded',
+		serverMs: message.data.serverDuration,
+		updateId: message.timestamp
+	});
 	window.location.reload();
 };
 
-const sendTiming = (clientStart: number, serverDuration?: number) => {
-	if (window.__HMR_WS__) {
-		const clientMs = Math.round(performance.now() - clientStart);
-		const total = (serverDuration ?? 0) + clientMs;
-		window.__HMR_WS__.send(
-			JSON.stringify({ duration: total, type: 'hmr-timing' })
-		);
-	}
+const finishUpdate = (
+	clientStart: number,
+	serverDuration?: number,
+	updateId?: number
+) => {
+	sendAbsoluteHmrTiming({
+		clientStart,
+		kind: 'component',
+		serverMs: serverDuration,
+		updateId
+	});
 	if (window.__ERROR_BOUNDARY__) {
 		window.__ERROR_BOUNDARY__.reset();
-	} else {
-		hideErrorOverlay();
 	}
+	hideErrorOverlay();
 };
 
 const applyRefreshImport = (
 	moduleUrl: string,
 	refreshRuntime: { performReactRefresh: () => unknown },
-	serverDuration?: number
+	serverDuration?: number,
+	updateId?: number
 ) => {
 	const clientStart = performance.now();
 	import(`${moduleUrl}?t=${Date.now()}`)
 		.then(() => {
 			refreshRuntime.performReactRefresh();
-			sendTiming(clientStart, serverDuration);
+			finishUpdate(clientStart, serverDuration, updateId);
 
 			return undefined;
 		})
@@ -78,31 +135,56 @@ const applyRefreshImport = (
 				'[HMR] React Fast Refresh failed, falling back to reload:',
 				err
 			);
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'component',
+				outcome: 'reloaded',
+				serverMs: serverDuration,
+				updateId
+			});
 			window.location.reload();
 		});
 };
 
-const reloadReactCSS = (cssPath: string) => {
-	const existingCSSLinks = document.head.querySelectorAll<HTMLLinkElement>(
-		'link[rel="stylesheet"]'
-	);
-	existingCSSLinks.forEach((link) => {
-		const href = link.getAttribute('href');
-		if (!href) {
-			return;
-		}
+const applyRemountImport = (
+	moduleUrl: string,
+	remount: (module: Record<string, unknown>) => void,
+	serverDuration?: number,
+	updateId?: number
+) => {
+	const clientStart = performance.now();
+	import(`${moduleUrl}?t=${Date.now()}`)
+		.then((module) => {
+			remount(module);
+			finishUpdate(clientStart, serverDuration, updateId);
+
+			return undefined;
+		})
+		.catch((err) => {
+			console.warn(
+				'[HMR] React remount failed, falling back to reload:',
+				err
+			);
+			sendAbsoluteHmrTiming({
+				clientStart,
+				kind: 'component',
+				outcome: 'reloaded',
+				serverMs: serverDuration,
+				updateId
+			});
+			reloadReactPage();
+		});
+};
+
+const reloadReactCSS = (cssPath: string) =>
+	swapCSSStylesheet(cssPath, (href) => {
 		const hrefBase = (href.split('?')[0] ?? '').split('/').pop() ?? '';
 		const cssPathBase =
 			(cssPath.split('?')[0] ?? '').split('/').pop() ?? '';
-		if (
+
+		return (
 			hrefBase === cssPathBase ||
 			href.includes('react-example') ||
 			cssPathBase.includes(hrefBase)
-		) {
-			const newHref = `${
-				cssPath + (cssPath.includes('?') ? '&' : '?')
-			}t=${Date.now()}`;
-			link.href = newHref;
-		}
+		);
 	});
-};

package/dist/dev/client/handlers/rebuild.ts

@@ -7,8 +7,20 @@ import {
 	isRuntimeErrorOverlay,
 	showErrorOverlay
 } from '../errorOverlay';
+import { sendAbsoluteHmrTiming } from '../hmrTiming';
 
-export const handleFullReload = () => {
+export const handleFullReload = (message?: {
+	data: { serverDuration?: number };
+	timestamp?: number;
+}) => {
+	const clientStart = performance.now();
+	sendAbsoluteHmrTiming({
+		clientStart,
+		kind: 'full-reload',
+		outcome: 'reloaded',
+		serverMs: message?.data.serverDuration,
+		updateId: message?.timestamp
+	});
 	setTimeout(() => {
 		window.location.reload();
 	}, REBUILD_RELOAD_DELAY_MS);
@@ -33,7 +45,18 @@ export const handleManifest = (message: {
 	window.__HMR_MODULE_UPDATES__ = [];
 };
 
-const HMR_FRAMEWORKS = ['angular', 'react', 'vue', 'svelte', 'html', 'htmx'];
+const HMR_FRAMEWORKS = [
+	'angular',
+	'assets',
+	'ember',
+	'html',
+	'htmx',
+	'react',
+	'styles',
+	'svelte',
+	'tailwind',
+	'vue'
+];
 
 const mergeRecord = (
 	source: Record<string, string | number>,
@@ -115,12 +138,9 @@ export const handleRebuildComplete = (message: {
 
 	if (
 		message.data.affectedFrameworks &&
-		!message.data.affectedFrameworks.includes('angular') &&
-		!message.data.affectedFrameworks.includes('react') &&
-		!message.data.affectedFrameworks.includes('html') &&
-		!message.data.affectedFrameworks.includes('htmx') &&
-		!message.data.affectedFrameworks.includes('vue') &&
-		!message.data.affectedFrameworks.includes('svelte')
+		!message.data.affectedFrameworks.some((framework) =>
+			HMR_FRAMEWORKS.includes(framework)
+		)
 	) {
 		const url = new URL(window.location.href);
 		url.searchParams.set('_cb', Date.now().toString());