@absolutejs/absolute 0.19.0-beta.1068 → 0.19.0-beta.1069

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

@@ -187,9 +187,12 @@ const updateHTMLBody = (
 	const newInlineScripts = collectInlineScripts(tempDiv);
 
 	const htmlStructureChanged = didHTMLStructureChange(container, tempDiv);
+	const inlineScriptsChanged = didInlineScriptsChange(
+		oldInlineScripts,
+		newInlineScripts
+	);
 	const scriptsChanged =
-		didScriptsChange(existingScripts, newScripts) ||
-		didInlineScriptsChange(oldInlineScripts, newInlineScripts);
+		didScriptsChange(existingScripts, newScripts) || inlineScriptsChanged;
 
 	if (htmlStructureChanged || scriptsChanged) {
 		patchDOMInPlace(container, htmlBody);
@@ -207,27 +210,22 @@ const updateHTMLBody = (
 		// changed. A pure markup edit (e.g. a heading) leaves inline-script
 		// state and `addEventListener` handlers intact.
 		if (scriptsChanged) {
-			cloneInteractiveElements(container);
+			// 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__');
 };
 
-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');
-			}
-		});
-};
-
 const replaceInlineScript = (script: Element) => {
 	if (script.hasAttribute('data-hmr-client')) {
 		return;
@@ -266,7 +264,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) => {
@@ -304,10 +308,7 @@ const collectInlineScripts = (elem: HTMLElement) =>
 		elem.querySelectorAll('script:not([src]):not([data-hmr-client])')
 	).map((script) => script.textContent || '');
 
-const didInlineScriptsChange = (
-	oldInline: string[],
-	newInline: string[]
-) =>
+const didInlineScriptsChange = (oldInline: string[], newInline: string[]) =>
 	oldInline.length !== newInline.length ||
 	oldInline.some((content, idx) => content !== newInline[idx]);
 

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

@@ -273,13 +273,31 @@ export const handleSvelteUpdate = (message: {
 		const svelteWindow: SvelteHmrWindow = window;
 		const acceptRegistry = svelteWindow.__SVELTE_HMR_ACCEPT__;
 
-		// Save the OLD module's accept callback BEFORE importing.
-		const acceptFn = acceptRegistry?.[pageModuleUrl];
+		// Save the OLD module's accept callback BEFORE importing. The exact
+		// key is the broadcast `pageModuleUrl`; on the happy path it matches
+		// the key the module server registered. If it doesn't (the registry
+		// was repopulated under a slightly different URL key, or `bun --hot`
+		// re-evaluated the module and reset `__SVELTE_HMR_ACCEPT__`), fall back
+		// to a suffix/basename match so we still find the callback. Exact match
+		// always wins, so the happy path is unchanged.
+		let acceptFn = acceptRegistry?.[pageModuleUrl];
+		if (!acceptFn && acceptRegistry) {
+			const wantBase = pageModuleUrl.split('?')[0] ?? pageModuleUrl;
+			const hit = Object.keys(acceptRegistry).find(
+				(key) =>
+					key === wantBase ||
+					key.endsWith(wantBase) ||
+					wantBase.endsWith(key)
+			);
+			if (hit) acceptFn = acceptRegistry[hit];
+		}
 
 		import(modulePath)
 			.then((newModule) => {
+				let applied = false;
 				if (acceptFn) {
 					acceptFn(newModule);
+					applied = true;
 				}
 
 				/* $.hmr_accept swaps component code in place but re-runs
@@ -290,15 +308,35 @@ export const handleSvelteUpdate = (message: {
 				 * bootstrap — so that state carries across (issue #41). */
 				const preserved = window.__HMR_PRESERVED_STATE__;
 				const remount = window.__SVELTE_REMOUNT__;
-				if (
-					typeof remount === 'function' &&
-					preserved &&
-					Object.keys(preserved).length > 0
-				) {
+				const hasPreserved =
+					preserved && Object.keys(preserved).length > 0;
+
+				if (applied) {
+					if (typeof remount === 'function' && hasPreserved) {
+						remount({
+							...(window.__INITIAL_PROPS__ ?? {}),
+							...preserved
+						});
+					}
+				} else if (typeof remount === 'function') {
+					/* Resilience fallback: no accept callback was found, so
+					 * `$.hmr` never wired the freshly imported module in. The
+					 * import warmed the module cache; remount the page with
+					 * merged props to actually apply the new code instead of
+					 * silently doing nothing. */
 					remount({
 						...(window.__INITIAL_PROPS__ ?? {}),
-						...preserved
+						...(preserved ?? {})
 					});
+				} else {
+					/* Last resort: nothing can apply the update in place. */
+					console.warn(
+						'[HMR] Svelte accept callback missing and no remount available; reloading'
+					);
+					window.__HMR_PRESERVED_STATE__ = undefined;
+					window.location.reload();
+
+					return undefined;
 				}
 				window.__HMR_PRESERVED_STATE__ = undefined;