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

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

@@ -50,6 +50,7 @@ type AngularHmrApi = {
 	applyUpdate: (id: string, newCtor: unknown) => boolean;
 	getRegistry?: () => Map<string, unknown>;
 	refresh: () => void;
+	hasPageExportsChanged?: (sourceId: string) => boolean;
 };
 
 type ViewTransitionDocument = Document & {
@@ -383,6 +384,19 @@ const attemptFastPatch = async (
 	try {
 		const newModule = await import(`${indexPath}?t=${Date.now()}`);
 
+		// Page-level `routes` / `providers` changed? Those values are read
+		// once during `bootstrapApplication`; an in-place component patch
+		// won't re-wire the running router or root injector. The chunk
+		// records its current fingerprint each time it evaluates (initial
+		// bootstrap + every fast-patch import), so a change between the
+		// previous and current evaluation means we need to fall back to a
+		// full re-bootstrap.
+		if (hmr.hasPageExportsChanged?.(sourceFile)) {
+			console.warn = origWarn;
+
+			return false;
+		}
+
 		// NG0912 warnings fire during `applyUpdate` (Angular re-registers
 		// the new component class while the old one is still live). Keep
 		// the suppression active through the patch, restore right before
@@ -679,6 +693,13 @@ const handleFullUpdate = async (message: HMRMessage) => {
 	if (!indexPath) return;
 
 	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.
+		captureHmrPreservedInstanceStates();
 		destroyAngularApp();
 		await bootstrapAngularModule(indexPath, rootSelector, rootContainer);
 		restoreComponentState(componentState);
@@ -689,3 +710,72 @@ const handleFullUpdate = async (message: HMRMessage) => {
 
 	await runWithViewTransition(doUpdate);
 };
+
+/* Snapshot every WeakRef-tracked instance's *preservable* own
+   properties into the shared cache. The runtime helper
+   `preserveAcrossHmr(this)` from `@absolutejs/absolute/angular`
+   populates the tracker, and on the constructor of the next-bootstrapped
+   instance reads back from the cache. We talk to the same `globalThis`-
+   anchored Map/Set as that helper rather than importing it directly so
+   this dev-client bundle doesn't pull in the Angular runtime.
+
+   Only primitives, plain `{}` objects, and arrays of those are
+   preserved. Class instances (HttpClient, BehaviorSubject, etc.) are
+   *not* preserved because the new instance must get those from its own
+   injector — restoring an OLD-injector reference onto a NEW instance
+   would corrupt the new app. */
+type HmrPreserveScope = typeof globalThis & {
+	__ABS_HMR_INSTANCE_STATE__?: Map<string, Record<string, unknown>>;
+	__ABS_HMR_TRACKED_INSTANCES__?: Set<WeakRef<object>>;
+};
+
+const isPreservableValue = (value: unknown, depth = 0): boolean => {
+	if (depth > 8) return false;
+	if (value === null || value === undefined) return true;
+	const t = typeof value;
+	if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint')
+		return true;
+	if (t === 'function' || t === 'symbol') return false;
+	if (Array.isArray(value)) {
+		return value.every((item) => isPreservableValue(item, depth + 1));
+	}
+	if (t === 'object') {
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) return false;
+
+		return Object.values(value as object).every((v) =>
+			isPreservableValue(v, depth + 1)
+		);
+	}
+
+	return false;
+};
+
+const captureHmrPreservedInstanceStates = () => {
+	const scope = globalThis as HmrPreserveScope;
+	const tracker = scope.__ABS_HMR_TRACKED_INSTANCES__;
+	if (!tracker || tracker.size === 0) return;
+
+	const cache = (scope.__ABS_HMR_INSTANCE_STATE__ ??= new Map());
+	const dead: WeakRef<object>[] = [];
+
+	for (const ref of tracker) {
+		const instance = ref.deref();
+		if (!instance) {
+			dead.push(ref);
+			continue;
+		}
+
+		const key = instance.constructor?.name;
+		if (!key || key === 'Object') continue;
+
+		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);
+	}
+
+	dead.forEach((ref) => tracker.delete(ref));
+};

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

@@ -238,11 +238,89 @@ const angularHmrStats: AngularHmrStats = {
 
 const getAngularHmrStats = () => angularHmrStats;
 
+/* Page-level export fingerprints — detect when `routes` or `providers`
+   change in a page file so the HMR fast-patch can fall back to a full
+   re-bootstrap. Without this, a component-level fast-patch silently
+   succeeds while the route/provider change is left dangling — the
+   running router/injector still uses the values from the initial
+   bootstrap. The page chunk template calls `recordPageExports` on every
+   evaluation (initial bootstrap and HMR re-imports); the fast-patch
+   handler then checks `hasPageExportsChanged` to decide whether to
+   force a full re-bootstrap.
+   Function references are treated as opaque — they change on every
+   module reload but the static config (`path`, `pathMatch`, provider
+   token, useValue, etc.) is what we care about. */
+
+type PageFingerprint = {
+	routes: string | null;
+	providers: string | null;
+};
+
+type PageExportRecord = {
+	current: PageFingerprint;
+	previous: PageFingerprint | null;
+};
+
+const pageExportRecords = ((
+	globalThis as { __ABS_HMR_PAGE_EXPORTS__?: Map<string, PageExportRecord> }
+).__ABS_HMR_PAGE_EXPORTS__ ??= new Map<string, PageExportRecord>());
+
+const fingerprint = (value: unknown, depth = 0): string => {
+	if (depth > 6) return '~deep~';
+	if (value === null) return 'null';
+	if (value === undefined) return 'undef';
+	if (typeof value === 'function') return 'fn';
+	if (typeof value === 'symbol') return value.toString();
+	if (Array.isArray(value)) {
+		return (
+			'[' + value.map((v) => fingerprint(v, depth + 1)).join(',') + ']'
+		);
+	}
+	if (typeof value === 'object') {
+		const obj = value as Record<string, unknown>;
+		const entries = Object.entries(obj)
+			.map(([k, v]): [string, string] => [k, fingerprint(v, depth + 1)])
+			.sort(([a], [b]) => a.localeCompare(b));
+
+		return '{' + entries.map(([k, v]) => `${k}:${v}`).join(',') + '}';
+	}
+
+	return JSON.stringify(value);
+};
+
+const recordPageExports = (
+	sourceId: string,
+	routes: unknown,
+	providers: unknown
+) => {
+	const next: PageFingerprint = {
+		routes: routes === undefined ? null : fingerprint(routes),
+		providers: providers === undefined ? null : fingerprint(providers)
+	};
+	const existing = pageExportRecords.get(sourceId);
+	pageExportRecords.set(sourceId, {
+		current: next,
+		previous: existing?.current ?? null
+	});
+};
+
+const hasPageExportsChanged = (sourceId: string): boolean => {
+	const record = pageExportRecords.get(sourceId);
+	if (!record || !record.previous) return false;
+
+	return (
+		record.previous.routes !== record.current.routes ||
+		record.previous.providers !== record.current.providers
+	);
+};
+
 export const installAngularHMRRuntime = () => {
 	if (typeof window === 'undefined') return;
 	window.__ANGULAR_HMR__ = {
 		applyUpdate,
 		getStats: getAngularHmrStats,
+		hasPageExportsChanged,
+		recordPageExports,
 		refresh,
 		register,
 		getRegistry: () => componentRegistry

package/dist/index.js

@@ -44594,6 +44594,17 @@ var absoluteHttpTransferCacheOptions = {
 // classes without needing a separate build artifact.
 export * from '${normalizedImportPath}';
 
+// Record this evaluation's \`routes\` and \`providers\` exports for the
+// HMR fast-patch to compare against on the next reload. If they change
+// (a new route was added, a provider was edited), fast-patch falls back
+// to a full re-bootstrap because those values are consumed once at
+// bootstrap and won't propagate to the running router/injector via an
+// in-place component patch.
+if (typeof window !== 'undefined' && window.__ANGULAR_HMR__ && typeof window.__ANGULAR_HMR__.recordPageExports === 'function') {
+    var __abs_hmr_routes = Reflect.get(pageModule, 'routes');
+    window.__ANGULAR_HMR__.recordPageExports('${resolvedEntry}', __abs_hmr_routes, maybePageProviders);
+}
+
 // Re-Bootstrap HMR with View Transitions API.
 // Skipped during fast-patch: the HMR client sets
 // window.__ANGULAR_HMR_FAST_PATCH__ = true before \`import()\`-ing this
@@ -58549,5 +58560,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=3B8AFA4EC6C4DEFD64756E2164756E21
+//# debugId=101D5DB96668BF8564756E2164756E21
 //# sourceMappingURL=index.js.map