@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1044

package/dist/angular/components/image.component.js

@@ -0,0 +1,202 @@
+import { Component, computed, input, signal } from '@angular/core';
+import { NgStyle } from '@angular/common';
+import { DEFAULT_QUALITY, buildOptimizedUrl, generateBlurSvg, generateSrcSet } from '@absolutejs/absolute/image';
+import * as i0 from "@angular/core";
+/** Resolve the blur background CSS value from placeholder config */
+const resolveBlurBg = (placeholderValue, blurDataUrl) => {
+    if (typeof placeholderValue === 'string' &&
+        placeholderValue !== 'blur' &&
+        placeholderValue.startsWith('data:')) {
+        return generateBlurSvg(placeholderValue);
+    }
+    if (blurDataUrl)
+        return generateBlurSvg(blurDataUrl);
+    return undefined;
+};
+export class ImageComponent {
+    constructor() {
+        // ── Inputs ──────────────────────────────────────────────────
+        this.alt = input.required(...(ngDevMode ? [{ debugName: "alt" }] : /* istanbul ignore next */ []));
+        this.blurDataURL = input(...(ngDevMode ? [undefined, { debugName: "blurDataURL" }] : /* istanbul ignore next */ []));
+        this.className = input(...(ngDevMode ? [undefined, { debugName: "className" }] : /* istanbul ignore next */ []));
+        this.crossOrigin = input(...(ngDevMode ? [undefined, { debugName: "crossOrigin" }] : /* istanbul ignore next */ []));
+        this.fetchPriority = input(...(ngDevMode ? [undefined, { debugName: "fetchPriority" }] : /* istanbul ignore next */ []));
+        this.fill = input(false, ...(ngDevMode ? [{ debugName: "fill" }] : /* istanbul ignore next */ []));
+        this.height = input(...(ngDevMode ? [undefined, { debugName: "height" }] : /* istanbul ignore next */ []));
+        this.loader = input(...(ngDevMode ? [undefined, { debugName: "loader" }] : /* istanbul ignore next */ []));
+        this.loading = input('lazy', ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+        this.onError = input(...(ngDevMode ? [undefined, { debugName: "onError" }] : /* istanbul ignore next */ []));
+        this.onLoad = input(...(ngDevMode ? [undefined, { debugName: "onLoad" }] : /* istanbul ignore next */ []));
+        this.overrideSrc = input(...(ngDevMode ? [undefined, { debugName: "overrideSrc" }] : /* istanbul ignore next */ []));
+        this.placeholder = input('empty', ...(ngDevMode ? [{ debugName: "placeholder" }] : /* istanbul ignore next */ []));
+        this.priority = input(false, ...(ngDevMode ? [{ debugName: "priority" }] : /* istanbul ignore next */ []));
+        this.quality = input(DEFAULT_QUALITY, ...(ngDevMode ? [{ debugName: "quality" }] : /* istanbul ignore next */ []));
+        this.referrerPolicy = input(...(ngDevMode ? [undefined, { debugName: "referrerPolicy" }] : /* istanbul ignore next */ []));
+        this.sizes = input(...(ngDevMode ? [undefined, { debugName: "sizes" }] : /* istanbul ignore next */ []));
+        this.src = input.required(...(ngDevMode ? [{ debugName: "src" }] : /* istanbul ignore next */ []));
+        this.style = input(...(ngDevMode ? [undefined, { debugName: "style" }] : /* istanbul ignore next */ []));
+        this.unoptimized = input(false, ...(ngDevMode ? [{ debugName: "unoptimized" }] : /* istanbul ignore next */ []));
+        this.width = input(...(ngDevMode ? [undefined, { debugName: "width" }] : /* istanbul ignore next */ []));
+        // ── Internal state ──────────────────────────────────────────
+        this.blurRemoved = signal(false, ...(ngDevMode ? [{ debugName: "blurRemoved" }] : /* istanbul ignore next */ []));
+        // ── Computed ────────────────────────────────────────────────
+        this.resolvedSrc = computed(() => {
+            const override = this.overrideSrc();
+            if (override)
+                return override;
+            if (this.unoptimized())
+                return this.src();
+            const loaderFn = this.loader();
+            if (loaderFn)
+                return loaderFn({
+                    quality: this.quality(),
+                    src: this.src(),
+                    width: this.width() ?? 0
+                });
+            const currentWidth = this.width();
+            if (!currentWidth)
+                return buildOptimizedUrl(this.src(), 0, this.quality());
+            return buildOptimizedUrl(this.src(), currentWidth, this.quality());
+        }, ...(ngDevMode ? [{ debugName: "resolvedSrc" }] : /* istanbul ignore next */ []));
+        this.srcSet = computed(() => this.unoptimized()
+            ? null
+            : (generateSrcSet(this.src(), this.width(), this.sizes(), undefined, this.loader() ?? undefined) ?? null), ...(ngDevMode ? [{ debugName: "srcSet" }] : /* istanbul ignore next */ []));
+        this.resolvedSrcSet = computed(() => this.srcSet() ?? null, ...(ngDevMode ? [{ debugName: "resolvedSrcSet" }] : /* istanbul ignore next */ []));
+        this.resolvedSizes = computed(() => this.sizes() ?? (this.fill() ? '100vw' : null), ...(ngDevMode ? [{ debugName: "resolvedSizes" }] : /* istanbul ignore next */ []));
+        this.resolvedCrossOrigin = computed(() => this.crossOrigin() ?? null, ...(ngDevMode ? [{ debugName: "resolvedCrossOrigin" }] : /* istanbul ignore next */ []));
+        this.resolvedReferrerPolicy = computed(() => this.referrerPolicy() ?? null, ...(ngDevMode ? [{ debugName: "resolvedReferrerPolicy" }] : /* istanbul ignore next */ []));
+        this.resolvedLoading = computed(() => this.priority() ? 'eager' : this.loading(), ...(ngDevMode ? [{ debugName: "resolvedLoading" }] : /* istanbul ignore next */ []));
+        this.resolvedFetchPriority = computed(() => this.priority() ? 'high' : (this.fetchPriority() ?? null), ...(ngDevMode ? [{ debugName: "resolvedFetchPriority" }] : /* istanbul ignore next */ []));
+        this.imgStyle = computed(() => {
+            const base = {
+                ...(this.style() ?? {}),
+                color: 'transparent'
+            };
+            const hasBlur = !this.blurRemoved() &&
+                (this.placeholder() === 'blur' ||
+                    (typeof this.placeholder() === 'string' &&
+                        this.placeholder() !== 'empty' &&
+                        (this.placeholder() ?? '').startsWith('data:')));
+            const blurValue = hasBlur
+                ? resolveBlurBg(this.placeholder(), this.blurDataURL())
+                : undefined;
+            if (blurValue) {
+                base['background-image'] = blurValue;
+                base['background-position'] = 'center';
+                base['background-repeat'] = 'no-repeat';
+                base['background-size'] = 'cover';
+            }
+            if (this.fill()) {
+                base.height = '100%';
+                base.inset = '0';
+                base['object-fit'] = 'cover';
+                base.position = 'absolute';
+                base.width = '100%';
+            }
+            return base;
+        }, ...(ngDevMode ? [{ debugName: "imgStyle" }] : /* istanbul ignore next */ []));
+    }
+    // ── Event handlers ──────────────────────────────────────────
+    handleLoad(event) {
+        this.blurRemoved.set(true);
+        const callback = this.onLoad();
+        if (callback)
+            callback(event);
+    }
+    handleError(event) {
+        const callback = this.onError();
+        if (callback)
+            callback(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: ImageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.6", type: ImageComponent, isStandalone: true, selector: "abs-image", inputs: { alt: { classPropertyName: "alt", publicName: "alt", isSignal: true, isRequired: true, transformFunction: null }, blurDataURL: { classPropertyName: "blurDataURL", publicName: "blurDataURL", isSignal: true, isRequired: false, transformFunction: null }, className: { classPropertyName: "className", publicName: "className", isSignal: true, isRequired: false, transformFunction: null }, crossOrigin: { classPropertyName: "crossOrigin", publicName: "crossOrigin", isSignal: true, isRequired: false, transformFunction: null }, fetchPriority: { classPropertyName: "fetchPriority", publicName: "fetchPriority", isSignal: true, isRequired: false, transformFunction: null }, fill: { classPropertyName: "fill", publicName: "fill", isSignal: true, isRequired: false, transformFunction: null }, height: { classPropertyName: "height", publicName: "height", isSignal: true, isRequired: false, transformFunction: null }, loader: { classPropertyName: "loader", publicName: "loader", isSignal: true, isRequired: false, transformFunction: null }, loading: { classPropertyName: "loading", publicName: "loading", isSignal: true, isRequired: false, transformFunction: null }, onError: { classPropertyName: "onError", publicName: "onError", isSignal: true, isRequired: false, transformFunction: null }, onLoad: { classPropertyName: "onLoad", publicName: "onLoad", isSignal: true, isRequired: false, transformFunction: null }, overrideSrc: { classPropertyName: "overrideSrc", publicName: "overrideSrc", isSignal: true, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, priority: { classPropertyName: "priority", publicName: "priority", isSignal: true, isRequired: false, transformFunction: null }, quality: { classPropertyName: "quality", publicName: "quality", isSignal: true, isRequired: false, transformFunction: null }, referrerPolicy: { classPropertyName: "referrerPolicy", publicName: "referrerPolicy", isSignal: true, isRequired: false, transformFunction: null }, sizes: { classPropertyName: "sizes", publicName: "sizes", isSignal: true, isRequired: false, transformFunction: null }, src: { classPropertyName: "src", publicName: "src", isSignal: true, isRequired: true, transformFunction: null }, style: { classPropertyName: "style", publicName: "style", isSignal: true, isRequired: false, transformFunction: null }, unoptimized: { classPropertyName: "unoptimized", publicName: "unoptimized", isSignal: true, isRequired: false, transformFunction: null }, width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		@if (fill()) {
+			<span
+				style="position:relative;overflow:hidden;display:block;width:100%;height:100%"
+			>
+				<img
+					[alt]="alt()"
+					[src]="resolvedSrc()"
+					[attr.srcset]="resolvedSrcSet()"
+					[attr.sizes]="resolvedSizes()"
+					[loading]="resolvedLoading()"
+					[class]="className()"
+					[ngStyle]="imgStyle()"
+					[attr.crossorigin]="resolvedCrossOrigin()"
+					[attr.referrerpolicy]="resolvedReferrerPolicy()"
+					[attr.fetchpriority]="resolvedFetchPriority()"
+					decoding="async"
+					(load)="handleLoad($event)"
+					(error)="handleError($event)"
+				/>
+			</span>
+		} @else {
+			<img
+				[alt]="alt()"
+				[src]="resolvedSrc()"
+				[attr.srcset]="resolvedSrcSet()"
+				[attr.sizes]="resolvedSizes()"
+				[width]="width()"
+				[height]="height()"
+				[loading]="resolvedLoading()"
+				[class]="className()"
+				[ngStyle]="imgStyle()"
+				[attr.crossorigin]="resolvedCrossOrigin()"
+				[attr.referrerpolicy]="resolvedReferrerPolicy()"
+				[attr.fetchpriority]="resolvedFetchPriority()"
+				decoding="async"
+				(load)="handleLoad($event)"
+				(error)="handleError($event)"
+			/>
+		}
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: ImageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    imports: [NgStyle],
+                    selector: 'abs-image',
+                    standalone: true,
+                    template: `
+		@if (fill()) {
+			<span
+				style="position:relative;overflow:hidden;display:block;width:100%;height:100%"
+			>
+				<img
+					[alt]="alt()"
+					[src]="resolvedSrc()"
+					[attr.srcset]="resolvedSrcSet()"
+					[attr.sizes]="resolvedSizes()"
+					[loading]="resolvedLoading()"
+					[class]="className()"
+					[ngStyle]="imgStyle()"
+					[attr.crossorigin]="resolvedCrossOrigin()"
+					[attr.referrerpolicy]="resolvedReferrerPolicy()"
+					[attr.fetchpriority]="resolvedFetchPriority()"
+					decoding="async"
+					(load)="handleLoad($event)"
+					(error)="handleError($event)"
+				/>
+			</span>
+		} @else {
+			<img
+				[alt]="alt()"
+				[src]="resolvedSrc()"
+				[attr.srcset]="resolvedSrcSet()"
+				[attr.sizes]="resolvedSizes()"
+				[width]="width()"
+				[height]="height()"
+				[loading]="resolvedLoading()"
+				[class]="className()"
+				[ngStyle]="imgStyle()"
+				[attr.crossorigin]="resolvedCrossOrigin()"
+				[attr.referrerpolicy]="resolvedReferrerPolicy()"
+				[attr.fetchpriority]="resolvedFetchPriority()"
+				decoding="async"
+				(load)="handleLoad($event)"
+				(error)="handleError($event)"
+			/>
+		}
+	`
+                }]
+        }], propDecorators: { alt: [{ type: i0.Input, args: [{ isSignal: true, alias: "alt", required: true }] }], blurDataURL: [{ type: i0.Input, args: [{ isSignal: true, alias: "blurDataURL", required: false }] }], className: [{ type: i0.Input, args: [{ isSignal: true, alias: "className", required: false }] }], crossOrigin: [{ type: i0.Input, args: [{ isSignal: true, alias: "crossOrigin", required: false }] }], fetchPriority: [{ type: i0.Input, args: [{ isSignal: true, alias: "fetchPriority", required: false }] }], fill: [{ type: i0.Input, args: [{ isSignal: true, alias: "fill", required: false }] }], height: [{ type: i0.Input, args: [{ isSignal: true, alias: "height", required: false }] }], loader: [{ type: i0.Input, args: [{ isSignal: true, alias: "loader", required: false }] }], loading: [{ type: i0.Input, args: [{ isSignal: true, alias: "loading", required: false }] }], onError: [{ type: i0.Input, args: [{ isSignal: true, alias: "onError", required: false }] }], onLoad: [{ type: i0.Input, args: [{ isSignal: true, alias: "onLoad", required: false }] }], overrideSrc: [{ type: i0.Input, args: [{ isSignal: true, alias: "overrideSrc", required: false }] }], placeholder: [{ type: i0.Input, args: [{ isSignal: true, alias: "placeholder", required: false }] }], priority: [{ type: i0.Input, args: [{ isSignal: true, alias: "priority", required: false }] }], quality: [{ type: i0.Input, args: [{ isSignal: true, alias: "quality", required: false }] }], referrerPolicy: [{ type: i0.Input, args: [{ isSignal: true, alias: "referrerPolicy", required: false }] }], sizes: [{ type: i0.Input, args: [{ isSignal: true, alias: "sizes", required: false }] }], src: [{ type: i0.Input, args: [{ isSignal: true, alias: "src", required: true }] }], style: [{ type: i0.Input, args: [{ isSignal: true, alias: "style", required: false }] }], unoptimized: [{ type: i0.Input, args: [{ isSignal: true, alias: "unoptimized", required: false }] }], width: [{ type: i0.Input, args: [{ isSignal: true, alias: "width", required: false }] }] } });

package/dist/angular/components/index.js

@@ -0,0 +1,4 @@
+export { DeferSlotComponent } from './defer-slot.component.js';
+export { DeferErrorTemplateDirective, DeferFallbackTemplateDirective, DeferResolvedTemplateDirective } from './defer-slot-templates.directive.js';
+export { ImageComponent } from './image.component.js';
+export { StreamSlotComponent } from './stream-slot.component.js';

package/dist/angular/components/stream-slot.component.js

@@ -0,0 +1,102 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, inject, signal } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { isStreamingSlotCollectionActive, registerStreamingSlot, warnMissingStreamingSlotCollector } from './core/streamingSlotRegistrar.js';
+import * as i0 from "@angular/core";
+const isObjectRecord = (value) => Boolean(value) && typeof value === 'object';
+const isHtmlPayload = (payload) => isObjectRecord(payload) && typeof payload.html === 'string';
+const resolvePayloadHtml = (payload) => {
+    if (isHtmlPayload(payload)) {
+        return payload.html;
+    }
+    return typeof payload === 'string' ? payload : '';
+};
+export class StreamSlotComponent {
+    constructor() {
+        this.cdr = inject(ChangeDetectorRef);
+        this.sanitizer = inject(DomSanitizer);
+        this.slotConsumer = (payload) => {
+            this.currentHtml.set(this.sanitizer.bypassSecurityTrustHtml(resolvePayloadHtml(payload)));
+            this.cdr.markForCheck();
+            return true;
+        };
+        this.fallbackHtml = '';
+        this.currentHtml = signal('', ...(ngDevMode ? [{ debugName: "currentHtml" }] : /* istanbul ignore next */ []));
+    }
+    ngOnInit() {
+        if (isStreamingSlotCollectionActive()) {
+            this.currentHtml.set(this.sanitizer.bypassSecurityTrustHtml(this.fallbackHtml));
+            registerStreamingSlot({
+                errorHtml: this.errorHtml,
+                fallbackHtml: this.fallbackHtml,
+                id: this.id,
+                resolve: this.resolve,
+                timeoutMs: this.timeoutMs
+            });
+            return;
+        }
+        warnMissingStreamingSlotCollector('StreamSlot');
+        if (typeof window === 'undefined') {
+            this.currentHtml.set(this.sanitizer.bypassSecurityTrustHtml(this.fallbackHtml));
+            return;
+        }
+        const absoluteWindow = window;
+        const consumers = (absoluteWindow.__ABS_SLOT_CONSUMERS__ =
+            absoluteWindow.__ABS_SLOT_CONSUMERS__ ?? {});
+        consumers[this.id] = this.slotConsumer;
+        this.currentHtml.set(this.sanitizer.bypassSecurityTrustHtml(this.fallbackHtml));
+        const pendingPayload = absoluteWindow.__ABS_SLOT_PENDING__?.[this.id];
+        if (pendingPayload !== undefined) {
+            this.slotConsumer(pendingPayload);
+            delete absoluteWindow.__ABS_SLOT_PENDING__?.[this.id];
+        }
+    }
+    ngOnDestroy() {
+        if (typeof window === 'undefined')
+            return;
+        const absoluteWindow = window;
+        if (absoluteWindow.__ABS_SLOT_CONSUMERS__) {
+            delete absoluteWindow.__ABS_SLOT_CONSUMERS__[this.id];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: StreamSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.6", type: StreamSlotComponent, isStandalone: true, selector: "abs-stream-slot", inputs: { className: "className", errorHtml: "errorHtml", fallbackHtml: "fallbackHtml", id: "id", resolve: "resolve", timeoutMs: "timeoutMs" }, ngImport: i0, template: `
+		<div
+			[attr.id]="id"
+			[attr.class]="className"
+			data-absolute-raw-slot="true"
+			data-absolute-slot="true"
+			[innerHTML]="currentHtml()"
+		></div>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: StreamSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    selector: 'abs-stream-slot',
+                    standalone: true,
+                    template: `
+		<div
+			[attr.id]="id"
+			[attr.class]="className"
+			data-absolute-raw-slot="true"
+			data-absolute-slot="true"
+			[innerHTML]="currentHtml()"
+		></div>
+	`
+                }]
+        }], propDecorators: { className: [{
+                type: Input
+            }], errorHtml: [{
+                type: Input
+            }], fallbackHtml: [{
+                type: Input
+            }], id: [{
+                type: Input,
+                args: [{ required: true }]
+            }], resolve: [{
+                type: Input,
+                args: [{ required: true }]
+            }], timeoutMs: [{
+                type: Input
+            }] } });

package/dist/angular/hmrPreserveCore.ts

@@ -0,0 +1,188 @@
+/* hmrPreserveCore — shared HMR preservation utilities, with no Angular
+   imports. Used by both `preserveAcrossHmr` (the user-facing helper that
+   adds OnPush `markForCheck` behavior on top) and the dev-client HMR
+   handler (which calls `captureTrackedInstanceStates` before destroying
+   the running app and `endHmrReboot` once the new app has stabilized).
+
+   Splitting these out lets the dev-client HMR handler — which has no
+   need for `@angular/core` — call into the same capture/restore logic
+   as the user-facing helper without forcing an Angular core import into
+   the dev-client bundle. The state itself lives on `globalThis`, so
+   both consumers see exactly the same tracker / cache / flag. */
+
+export type StateCache = Map<string, Record<string, unknown>>;
+export type InstanceTracker = Set<WeakRef<object>>;
+export type InstanceKeyMap = WeakMap<object, string>;
+export type RebootFlag = { value: boolean };
+export type RebootStats = { captured: number; restoredKeys: Set<string> };
+
+type PreserveScope = typeof globalThis & {
+	__ABS_HMR_INSTANCE_STATE__?: StateCache;
+	__ABS_HMR_TRACKED_INSTANCES__?: InstanceTracker;
+	__ABS_HMR_INSTANCE_KEYS__?: InstanceKeyMap;
+	__ABS_HMR_REBOOT_IN_PROGRESS__?: RebootFlag;
+	__ABS_HMR_REBOOT_STATS__?: RebootStats;
+};
+
+export const buildCacheKey = (
+	instance: object,
+	key?: unknown
+) => {
+	const className = instance.constructor?.name;
+	if (!className || className === 'Object') return null;
+	const suffix = key === undefined || key === null ? '' : String(key);
+
+	return `${className}:${suffix}`;
+};
+export const captureTrackedInstanceStates = () => {
+	if (!isHmrPreserveDev()) return;
+
+	const cache = getCache();
+	const tracker = getTracker();
+	const keyMap = getKeyMap();
+	const stats = getRebootStats();
+	const seen = new Set<string>();
+
+	cache.clear();
+	stats.restoredKeys.clear();
+	stats.captured = 0;
+
+	for (const ref of tracker) {
+		const instance = ref.deref();
+		// Skip already-GC'd refs. We don't bother bookkeeping a "dead"
+		// list because the entire tracker is cleared after this loop.
+		if (!instance) continue;
+
+		const fullKey = keyMap.get(instance) ?? buildCacheKey(instance);
+		if (fullKey === null) continue;
+
+		// Warn when two instances would collide on the same cache slot
+		// (same className with no key, or duplicate user-supplied keys).
+		// On collision the second instance's state silently overwrites
+		// the first — pass an explicit `key` to differentiate.
+		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 (isPreservable(value)) props[prop] = value;
+		}
+		cache.set(fullKey, props);
+		stats.captured++;
+	}
+
+	// Every instance just captured is about to die: `destroyAngularApp()`
+	// runs immediately after this. New instances from the next bootstrap
+	// repopulate the tracker via their own `preserveAcrossHmr(this)`
+	// calls. Leaving existing WeakRefs in place means the JS engine
+	// often won't have GC'd the old objects yet at the next capture —
+	// those zombies inflate the captured count and trigger spurious
+	// collision warnings against the new generation's instances.
+	tracker.clear();
+
+	getRebootFlag().value = true;
+};
+export const endHmrReboot = () => {
+	if (!isHmrPreserveDev()) return;
+	getRebootFlag().value = false;
+
+	const stats = getRebootStats();
+	if (stats.captured > 0) {
+		const restored = Array.from(stats.restoredKeys)
+			.map((k) => k.replace(/:$/, ''))
+			.sort();
+		console.info(
+			`[HMR] Full re-bootstrap: restored state for ${restored.length}/${stats.captured} tracked instance(s)${
+				restored.length > 0 ? ` — ${restored.join(', ')}` : ''
+			}. Components without preservation reset to defaults; opt in via \`preserveAcrossHmr(this)\`.`
+		);
+	}
+};
+export const getCache = () => {
+	const scope = globalThis as PreserveScope;
+
+	return (scope.__ABS_HMR_INSTANCE_STATE__ ??= new Map());
+};
+export const getKeyMap = () => {
+	const scope = globalThis as PreserveScope;
+
+	return (scope.__ABS_HMR_INSTANCE_KEYS__ ??= new WeakMap());
+};
+export const getRebootFlag = () => {
+	const scope = globalThis as PreserveScope;
+
+	return (scope.__ABS_HMR_REBOOT_IN_PROGRESS__ ??= { value: false });
+};
+export const getRebootStats = () => {
+	const scope = globalThis as PreserveScope;
+
+	return (scope.__ABS_HMR_REBOOT_STATS__ ??= {
+		captured: 0,
+		restoredKeys: new Set()
+	});
+};
+export const getTracker = () => {
+	const scope = globalThis as PreserveScope;
+
+	return (scope.__ABS_HMR_TRACKED_INSTANCES__ ??= new Set());
+};
+export const isHmrPreserveDev = () => {
+	// SSR safety: globalThis on the server is process-wide and shared
+	// across requests, so writing to the preservation cache during SSR
+	// would leak request state between users. Gate strictly on the
+	// presence of a browser `window` *and* a dev signal — neither is
+	// true in a production build, so this is a hard no-op there too.
+	if (typeof window === 'undefined') return false;
+	const scope = globalThis as { __DEV__?: unknown; ngDevMode?: unknown };
+
+	return Boolean(scope.__DEV__) || Boolean(scope.ngDevMode);
+};
+export const isPreservable = (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) => isPreservable(item, depth + 1));
+	}
+	if (t === 'object') {
+		const proto = Object.getPrototypeOf(value);
+		// Only POJOs — class instances (HttpClient, BehaviorSubject, Date,
+		// Map, etc.) carry runtime identity that the new instance must
+		// get from its own injector / construction.
+		if (proto !== Object.prototype && proto !== null) return false;
+
+		return Object.values(value as object).every((v) =>
+			isPreservable(v, depth + 1)
+		);
+	}
+
+	return false;
+};
+export const restoreFromCacheCore = (
+	instance: object,
+	key: string
+) => {
+	const cache = getCache();
+	const stored = cache.get(key);
+	if (!stored) return false;
+
+	for (const [prop, value] of Object.entries(stored)) {
+		try {
+			(instance as Record<string, unknown>)[prop] = value;
+		} catch {
+			/* property is non-writable / has a setter that threw — skip */
+		}
+	}
+
+	getRebootStats().restoredKeys.add(key);
+
+	return true;
+};