@absolutejs/absolute 0.19.0-beta.749 → 0.19.0-beta.750

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

@@ -694,18 +694,33 @@ const handleFullUpdate = async (message: HMRMessage) => {
 
 	const doUpdate = async () => {
 		// Snapshot every instance that opted into `preserveAcrossHmr(this)`
-		// before destroying the app. The new instances created during
-		// bootstrap will read these values back via the same helper, so
-		// service state (auth tokens, cached data, subscriptions held by
-		// reference) survives a full re-bootstrap. Generic by class name
-		// — no per-app configuration here.
+		// before destroying the app, and flip the reboot-in-progress flag
+		// on. The new instances created during bootstrap will read cached
+		// state back via the same helper while the flag is on.
 		captureHmrPreservedInstanceStates();
-		destroyAngularApp();
-		await bootstrapAngularModule(indexPath, rootSelector, rootContainer);
-		restoreComponentState(componentState);
-		tickAngularApp();
-		restoreFormState(formState);
-		restoreScrollState(scrollState);
+		try {
+			destroyAngularApp();
+			await bootstrapAngularModule(
+				indexPath,
+				rootSelector,
+				rootContainer
+			);
+			restoreComponentState(componentState);
+			tickAngularApp();
+			restoreFormState(formState);
+			restoreScrollState(scrollState);
+		} finally {
+			// Lazy-loaded child route components construct AFTER
+			// `bootstrapAngularModule` returns — the route activation
+			// chain (loadComponent → dynamic import → instantiate) runs
+			// asynchronously after the root app reports bootstrapped.
+			// Keep the flag on for a brief grace window so those lazy
+			// components also restore from cache. 750ms is generous
+			// enough for typical chunk loads (~50-200ms cold) and short
+			// enough that a user can't navigate within the window —
+			// preventing stale-state on subsequent navigations.
+			setTimeout(endHmrPreservedReboot, 750);
+		}
 	};
 
 	await runWithViewTransition(doUpdate);
@@ -727,6 +742,8 @@ const handleFullUpdate = async (message: HMRMessage) => {
 type HmrPreserveScope = typeof globalThis & {
 	__ABS_HMR_INSTANCE_STATE__?: Map<string, Record<string, unknown>>;
 	__ABS_HMR_TRACKED_INSTANCES__?: Set<WeakRef<object>>;
+	__ABS_HMR_INSTANCE_KEYS__?: WeakMap<object, string>;
+	__ABS_HMR_REBOOT_IN_PROGRESS__?: { value: boolean };
 };
 
 const isPreservableValue = (value: unknown, depth = 0): boolean => {
@@ -754,10 +771,25 @@ const isPreservableValue = (value: unknown, depth = 0): boolean => {
 const captureHmrPreservedInstanceStates = () => {
 	const scope = globalThis as HmrPreserveScope;
 	const tracker = scope.__ABS_HMR_TRACKED_INSTANCES__;
-	if (!tracker || tracker.size === 0) return;
+
+	const flag = (scope.__ABS_HMR_REBOOT_IN_PROGRESS__ ??= { value: false });
+
+	if (!tracker || tracker.size === 0) {
+		// Nothing tracked, but still flip the flag so any service/component
+		// that registers DURING the reboot (`preserveAcrossHmr` in
+		// constructor) knows it's in a reboot context — even though there's
+		// nothing to restore from.
+		flag.value = true;
+
+		return;
+	}
 
 	const cache = (scope.__ABS_HMR_INSTANCE_STATE__ ??= new Map());
+	const keyMap = scope.__ABS_HMR_INSTANCE_KEYS__;
 	const dead: WeakRef<object>[] = [];
+	const seen = new Set<string>();
+
+	cache.clear();
 
 	for (const ref of tracker) {
 		const instance = ref.deref();
@@ -766,16 +798,32 @@ const captureHmrPreservedInstanceStates = () => {
 			continue;
 		}
 
-		const key = instance.constructor?.name;
-		if (!key || key === 'Object') continue;
+		const className = instance.constructor?.name;
+		if (!className || className === 'Object') continue;
+		const fullKey = keyMap?.get(instance) ?? `${className}:`;
+
+		if (seen.has(fullKey)) {
+			console.warn(
+				`[HMR] preserveAcrossHmr collision on "${fullKey}". Two instances would use the same cache slot — the later one will overwrite the earlier one's state on full re-bootstrap. Pass a unique \`key\` argument (e.g. an @Input id) to differentiate.`
+			);
+		}
+		seen.add(fullKey);
 
 		const props: Record<string, unknown> = {};
 		for (const prop of Object.keys(instance)) {
 			const value = (instance as Record<string, unknown>)[prop];
 			if (isPreservableValue(value)) props[prop] = value;
 		}
-		cache.set(key, props);
+		cache.set(fullKey, props);
 	}
 
 	dead.forEach((ref) => tracker.delete(ref));
+
+	flag.value = true;
+};
+
+const endHmrPreservedReboot = () => {
+	const scope = globalThis as HmrPreserveScope;
+	const flag = scope.__ABS_HMR_REBOOT_IN_PROGRESS__;
+	if (flag) flag.value = false;
 };

package/dist/src/angular/preserveAcrossHmr.d.ts

@@ -1,10 +1,25 @@
-/** Mark a service instance for state preservation across full Angular HMR
- *  re-bootstraps. Call once from the constructor. Safe in production
- *  (no-op outside dev mode). */
-export declare const preserveAcrossHmr: (instance: object) => void;
+/** Mark a service or component instance for state preservation across
+ *  full Angular HMR re-bootstraps. Call once from the constructor or
+ *  `ngOnInit`. Safe in production (no-op outside dev mode).
+ *
+ *  @param instance Usually `this`. The class name is used as part of
+ *      the cache key.
+ *  @param key Optional discriminator when multiple instances of the
+ *      same class can be alive at once (rows, tabs, etc). Coerced
+ *      to string. Use `ngOnInit` to call this when the key depends
+ *      on `@Input` values, since Angular sets inputs between
+ *      constructor and ngOnInit. */
+export declare const preserveAcrossHmr: (instance: object, key?: string | number) => void;
 /** Snapshot every tracked instance's preservable own properties into
- *  the cache. Called by the HMR client right before `destroyAngularApp()`.
- *  Properties that aren't preservable (Angular-injected services,
- *  Subjects, class instances) are skipped — the new instance gets fresh
- *  ones from its new injector, just like at first bootstrap. */
+ *  the cache and flip the reboot flag on. Called by the HMR client
+ *  right before `destroyAngularApp()`. Properties that aren't
+ *  preservable (Angular-injected services, Subjects, class instances)
+ *  are skipped — the new instance gets fresh ones from its new
+ *  injector, just like at first bootstrap. */
 export declare const captureTrackedInstanceStates: () => void;
+/** Clear the active-reboot flag. Called by the HMR client after the
+ *  new app has finished bootstrapping (success or failure — wrap in
+ *  `try/finally`). After this, `preserveAcrossHmr` calls will track
+ *  but won't restore — so navigating to a route after HMR doesn't
+ *  resurrect stale state from the last reboot. */
+export declare const endHmrReboot: () => void;

package/package.json

@@ -349,5 +349,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.749"
+	"version": "0.19.0-beta.750"
 }