@braidlabs/angular-router 0.2.0 → 0.4.0

package/fesm2022/braidlabs-angular-router.mjs

@@ -1,490 +1,301 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, signal, Injectable, inject, DestroyRef, DOCUMENT, PLATFORM_ID, computed, makeEnvironmentProviders, provideEnvironmentInitializer } from '@angular/core';
-import { isSkewDisabled, createVersionProbe, moduleWasRemoved, setSkewDisabled } from '@braidlabs/skew';
-import { isPlatformBrowser } from '@angular/common';
-import { Router, NavigationError } from '@angular/router';
-
-const SKEW_RECOVERY_OPTIONS = new InjectionToken('SKEW_RECOVERY_OPTIONS');
+import * as i0 from "@angular/core";
+import { DOCUMENT, DestroyRef, Injectable, InjectionToken, PLATFORM_ID, computed, inject, makeEnvironmentProviders, provideEnvironmentInitializer, signal } from "@angular/core";
+import { createVersionProbe, isSkewDisabled, moduleWasRemoved, setSkewDisabled } from "@braidlabs/skew";
+import { isPlatformBrowser } from "@angular/common";
+import { NavigationError, Router } from "@angular/router";
+const SKEW_RECOVERY_OPTIONS = new InjectionToken("SKEW_RECOVERY_OPTIONS");
 function resolveOptions(options) {
-    return {
-        ...options,
-        onStaleChunk: options.onStaleChunk ?? 'reload-at-target',
-        retryAttempts: options.retryAttempts ?? 1,
-        retryDelayMs: options.retryDelayMs ?? 250,
-        maxRecoveries: options.maxRecoveries ?? 1,
-        fallbackRoute: options.fallbackRoute ?? '/',
-        respectUnsavedWork: options.respectUnsavedWork ?? true,
-    };
+	return {
+		...options,
+		onStaleChunk: options.onStaleChunk ?? "reload-at-target",
+		retryAttempts: options.retryAttempts ?? 1,
+		retryDelayMs: options.retryDelayMs ?? 250,
+		maxRecoveries: options.maxRecoveries ?? 1,
+		fallbackRoute: options.fallbackRoute ?? "/",
+		respectUnsavedWork: options.respectUnsavedWork ?? true
+	};
 }
-
-/**
- * Wrapping the dynamic import.
- *
- * Two problems are solved here, both before any Angular machinery is involved:
- *
- * 1. **Attribution.** By the time an import rejects, the runtime holds
- *    `chunk-ABC123.js` — not `./admin/routes`. Without a logical id there is no
- *    way to ask the new build's manifest whether that route still exists.
- * 2. **Transience.** A flaky network, a CDN edge miss, and a genuinely purged
- *    asset are indistinguishable from the error alone. A bounded retry resolves
- *    the first two without inflicting a page reload on anyone.
- *
- * Retry is therefore a *precondition* to recovery, not one of the strategies.
- */
-/** Defaults for `lazy()`, overridable globally by `provideSkewRecovery()`. */
 const lazyDefaults = {
-    retryAttempts: 1,
-    retryDelayMs: 250,
+	retryAttempts: 1,
+	retryDelayMs: 250
 };
-/** Restores defaults. Exposed for tests, which must not leak configuration. */
 function resetLazyDefaults() {
-    lazyDefaults.retryAttempts = 1;
-    lazyDefaults.retryDelayMs = 250;
-}
-/**
- * Thrown when a lazy load fails after its retries are exhausted.
- *
- * Angular surfaces this through `NavigationError`, where the recovery service
- * recognises it. Carrying the module id across that boundary is the whole
- * reason this error type exists.
- */
-class ChunkLoadFailure extends Error {
-    moduleId;
-    cause;
-    attempts;
-    name = 'ChunkLoadFailure';
-    constructor(moduleId, cause, attempts) {
-        super(`[skew] failed to load ${moduleId ? `"${moduleId}"` : 'a lazy chunk'} ` +
-            `after ${attempts} attempt${attempts === 1 ? '' : 's'}`);
-        this.moduleId = moduleId;
-        this.cause = cause;
-        this.attempts = attempts;
-    }
+	lazyDefaults.retryAttempts = 1;
+	lazyDefaults.retryDelayMs = 250;
 }
+var ChunkLoadFailure = class extends Error {
+	moduleId;
+	cause;
+	attempts;
+	name = "ChunkLoadFailure";
+	constructor(moduleId, cause, attempts) {
+		super(`[skew] failed to load ${moduleId ? `"${moduleId}"` : "a lazy chunk"} after ${attempts} attempt${attempts === 1 ? "" : "s"}`);
+		this.moduleId = moduleId;
+		this.cause = cause;
+		this.attempts = attempts;
+	}
+};
 function isChunkLoadFailure(value) {
-    return value instanceof ChunkLoadFailure;
+	return value instanceof ChunkLoadFailure;
 }
-/**
- * Heuristic for "this looks like a module that failed to load" rather than an
- * error thrown *by* the module once it ran.
- *
- * Deliberately broad: bundlers and browsers disagree on the shape here
- * (`ChunkLoadError`, a bare `TypeError`, a CSP violation), and a false positive
- * costs one wasted retry while a false negative costs the user their session.
- */
 function looksLikeChunkError(error) {
-    if (!error)
-        return false;
-    const name = error.name ?? '';
-    const message = error.message ?? '';
-    return (name === 'ChunkLoadError' ||
-        /loading (chunk|css chunk)/i.test(message) ||
-        /failed to fetch dynamically imported module/i.test(message) ||
-        /error loading dynamically imported module/i.test(message) ||
-        /importing a module script failed/i.test(message));
+	if (!error) return false;
+	const name = error.name ?? "";
+	const message = error.message ?? "";
+	return name === "ChunkLoadError" || /loading (chunk|css chunk)/i.test(message) || /failed to fetch dynamically imported module/i.test(message) || /error loading dynamically imported module/i.test(message) || /importing a module script failed/i.test(message);
 }
 function lazy(moduleIdOrLoader, loaderOrOptions, maybeOptions) {
-    const hasId = typeof moduleIdOrLoader === 'string';
-    const moduleId = hasId ? moduleIdOrLoader : undefined;
-    const loader = (hasId ? loaderOrOptions : moduleIdOrLoader);
-    const options = (hasId ? maybeOptions : loaderOrOptions) ?? {};
-    if (typeof loader !== 'function') {
-        throw new TypeError('[skew] lazy() requires a loader function');
-    }
-    return async () => {
-        // Not public API — see `disabled.ts` in @braidlabs/skew. A bare dynamic import
-        // with no retry and no attribution: the rejection propagates exactly as the
-        // bundler produced it, and nothing downstream knows which module it was.
-        if (isSkewDisabled())
-            return loader();
-        const attempts = Math.max(0, options.retryAttempts ?? lazyDefaults.retryAttempts) + 1;
-        const delay = options.retryDelayMs ?? lazyDefaults.retryDelayMs;
-        let lastError;
-        for (let attempt = 1; attempt <= attempts; attempt++) {
-            try {
-                return await loader();
-            }
-            catch (error) {
-                lastError = error;
-                // An error thrown by module *evaluation* is a bug in the module, not a
-                // transport failure. Retrying it just runs the bug again.
-                if (!looksLikeChunkError(error))
-                    throw error;
-                if (attempt < attempts && delay > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, delay * attempt));
-                }
-            }
-        }
-        throw new ChunkLoadFailure(moduleId, lastError, attempts);
-    };
+	const hasId = typeof moduleIdOrLoader === "string";
+	const moduleId = hasId ? moduleIdOrLoader : void 0;
+	const loader = hasId ? loaderOrOptions : moduleIdOrLoader;
+	const options = (hasId ? maybeOptions : loaderOrOptions) ?? {};
+	if (typeof loader !== "function") throw new TypeError("[skew] lazy() requires a loader function");
+	return async () => {
+		if (isSkewDisabled()) return loader();
+		const attempts = Math.max(0, options.retryAttempts ?? lazyDefaults.retryAttempts) + 1;
+		const delay = options.retryDelayMs ?? lazyDefaults.retryDelayMs;
+		let lastError;
+		for (let attempt = 1; attempt <= attempts; attempt++) try {
+			return await loader();
+		} catch (error) {
+			lastError = error;
+			if (!looksLikeChunkError(error)) throw error;
+			if (attempt < attempts && delay > 0) await new Promise((resolve) => setTimeout(resolve, delay * attempt));
+		}
+		throw new ChunkLoadFailure(moduleId, lastError, attempts);
+	};
 }
-
-/**
- * Unsaved-work tracking.
- *
- * A hard reload destroys in-memory state, so recovery must know whether that
- * matters. Angular already has a declaration for exactly this — `CanDeactivate`
- * — but the router exposes no way to ask "would a guard block here?", so a
- * library cannot reuse it.
- *
- * This registry is the workaround: components declare dirtiness explicitly and
- * the recovery service consults it. If Angular ever exposes guard
- * introspection, this whole file becomes deletable.
- */
-class UnsavedWorkRegistry {
-    sources = signal([], /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "sources" }] : /* istanbul ignore next */ []));
-    /** Registers a predicate. Returns a disposer. */
-    register(isDirty) {
-        this.sources.update((current) => [...current, isDirty]);
-        return () => {
-            this.sources.update((current) => current.filter((entry) => entry !== isDirty));
-        };
-    }
-    /**
-     * True when any registered source reports unsaved work.
-     *
-     * A throwing predicate is treated as *clean* rather than dirty: a broken
-     * dirty-check should not permanently block recovery and strand the user.
-     */
-    isDirty() {
-        return this.sources().some((isDirty) => {
-            try {
-                return isDirty();
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    /** Count of registered sources. Diagnostics only. */
-    get size() {
-        return this.sources().length;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UnsavedWorkRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UnsavedWorkRegistry, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UnsavedWorkRegistry, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-/**
- * Declares that this component holds unsaved work, so automatic recovery will
- * not discard it. Unregisters automatically on destroy.
- *
- * ```ts
- * export class BulletinEditor {
- *   protected readonly form = …;
- *   constructor() {
- *     trackUnsavedWork(() => this.form.dirty);
- *   }
- * }
- * ```
- *
- * Must be called in an injection context.
- */
+var UnsavedWorkRegistry = class UnsavedWorkRegistry {
+	sources = signal([], ...ngDevMode ? [{ debugName: "sources" }] : /* istanbul ignore next */ []);
+	register(isDirty) {
+		this.sources.update((current) => [...current, isDirty]);
+		return () => {
+			this.sources.update((current) => current.filter((entry) => entry !== isDirty));
+		};
+	}
+	isDirty() {
+		return this.sources().some((isDirty) => {
+			try {
+				return isDirty();
+			} catch {
+				return false;
+			}
+		});
+	}
+	get size() {
+		return this.sources().length;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: UnsavedWorkRegistry,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: UnsavedWorkRegistry,
+		providedIn: "root"
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: UnsavedWorkRegistry,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
 function trackUnsavedWork(isDirty) {
-    const registry = inject(UnsavedWorkRegistry);
-    const destroyRef = inject(DestroyRef);
-    const dispose = registry.register(isDirty);
-    destroyRef.onDestroy(dispose);
+	const registry = inject(UnsavedWorkRegistry);
+	const destroyRef = inject(DestroyRef);
+	const dispose = registry.register(isDirty);
+	destroyRef.onDestroy(dispose);
 }
-
-const LOOP_GUARD_KEY = 'skew:recoveries';
-/**
- * Orchestrates recovery from a failed lazy load.
- *
- * Wiring is via router events rather than a global registry: `lazy()` throws a
- * {@link ChunkLoadFailure}, Angular surfaces it as `NavigationError`, and this
- * service recognises it there. That keeps `lazy()` dependency-free and usable
- * in route definitions, which are evaluated long before DI exists.
- *
- * Zoneless-safe and SSR-safe: no `NgZone`, and every `location` /
- * `sessionStorage` touch is guarded.
- */
-class SkewRecoveryService {
-    options = inject(SKEW_RECOVERY_OPTIONS);
-    router = inject(Router);
-    document = inject(DOCUMENT);
-    unsavedWork = inject(UnsavedWorkRegistry);
-    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
-    probe;
-    pendingSignal = signal(null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "pendingSignal" }] : /* istanbul ignore next */ []));
-    statusSignal = signal(null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "statusSignal" }] : /* istanbul ignore next */ []));
-    /** A recovery the application has been asked to complete itself. */
-    pending = this.pendingSignal.asReadonly();
-    /** Last known comparison against the origin. */
-    status = this.statusSignal.asReadonly();
-    /** True when a newer deployment is known to exist. */
-    updateAvailable = computed(() => this.statusSignal()?.kind === 'staleClient', /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "updateAvailable" }] : /* istanbul ignore next */ []));
-    constructor() {
-        this.probe = this.options.manifestUrl
-            ? createVersionProbe({
-                identity: this.options.identity,
-                manifestUrl: this.options.manifestUrl,
-            })
-            : null;
-        if (this.isBrowser)
-            this.listen();
-    }
-    listen() {
-        this.router.events.subscribe((event) => {
-            if (event instanceof NavigationError && isChunkLoadFailure(event.error)) {
-                // Not public API — see `disabled.ts` in @braidlabs/skew. The NavigationError
-                // is left to propagate untouched: no retry, no manifest probe, no
-                // classification, no decision. Whatever the application does next is
-                // whatever it would have done without this package installed.
-                if (isSkewDisabled())
-                    return;
-                void this.handle(event.error, event.url);
-            }
-        });
-    }
-    /** Re-checks the origin. Safe to call from a "check for updates" control. */
-    async check() {
-        if (!this.probe)
-            return null;
-        const status = await this.probe.check();
-        this.statusSignal.set(status);
-        return status;
-    }
-    /** Completes a deferred recovery — what a "Reload" button calls. */
-    recover() {
-        const pending = this.pendingSignal();
-        if (!pending)
-            return;
-        this.pendingSignal.set(null);
-        this.assign(pending.targetUrl);
-    }
-    /** Dismisses a pending recovery without acting on it. */
-    dismiss() {
-        this.pendingSignal.set(null);
-    }
-    async handle(failure, targetUrl) {
-        const context = await this.classify(failure, targetUrl);
-        const action = await this.chooseAction(context);
-        this.dispatch(action, context);
-    }
-    async classify(failure, targetUrl) {
-        const status = await this.check();
-        const serverBuildId = status?.kind === 'current'
-            ? status.buildId
-            : status && 'remote' in status
-                ? status.remote
-                : undefined;
-        // Absent a module map we must assume the route still exists. Claiming it
-        // was deleted would redirect users away from a route that merely moved —
-        // a worse failure than the one being recovered from.
-        const manifest = this.probe?.lastManifest() ?? null;
-        const moduleStillExists = failure.moduleId === undefined ||
-            manifest === null ||
-            !moduleWasRemoved(manifest, failure.moduleId);
-        return {
-            targetUrl,
-            currentUrl: this.router.url,
-            moduleId: failure.moduleId,
-            error: failure,
-            attempt: this.recoveryCount(),
-            isOnline: this.isOnline(),
-            clientBuildId: this.options.identity.buildId,
-            serverBuildId,
-            moduleStillExists,
-            entryDocumentStale: status?.kind === 'staleOrigin',
-            newAssetsReachable: status?.kind === 'staleClient',
-            hasUnsavedWork: this.options.respectUnsavedWork && this.unsavedWork.isDirty(),
-        };
-    }
-    async chooseAction(context) {
-        // Guard rails run before any application policy, because each of these is a
-        // case where reloading is actively harmful rather than merely unhelpful.
-        if (!context.isOnline)
-            return 'notify';
-        if (context.entryDocumentStale)
-            return 'notify'; // reloading would loop
-        if (context.attempt >= this.options.maxRecoveries)
-            return 'notify';
-        if (context.hasUnsavedWork)
-            return 'notify';
-        if (!context.moduleStillExists)
-            return 'redirect-to-fallback';
-        const strategy = this.options.onStaleChunk;
-        if (typeof strategy === 'function') {
-            try {
-                return await strategy(context);
-            }
-            catch {
-                // A throwing policy must not strand the user with nothing.
-                return 'notify';
-            }
-        }
-        return strategy;
-    }
-    dispatch(action, context) {
-        switch (action) {
-            case 'reload-at-target':
-                this.countRecovery();
-                this.assign(context.targetUrl);
-                return;
-            case 'reload-in-place':
-                this.countRecovery();
-                this.reload();
-                return;
-            case 'redirect-to-fallback':
-                void this.router.navigateByUrl(this.options.fallbackRoute);
-                return;
-            case 'ignore':
-                return;
-            case 'notify':
-                this.pendingSignal.set({
-                    targetUrl: context.targetUrl,
-                    moduleId: context.moduleId,
-                    serverBuildId: context.serverBuildId,
-                    reason: !context.isOnline
-                        ? 'offline'
-                        : context.entryDocumentStale
-                            ? 'loop-detected'
-                            : context.attempt >= this.options.maxRecoveries
-                                ? 'exhausted'
-                                : 'notify',
-                    context,
-                });
-                return;
-        }
-    }
-    // --- environment access, all browser-guarded ---------------------------
-    isOnline() {
-        if (!this.isBrowser)
-            return true;
-        const nav = this.document.defaultView?.navigator;
-        return nav?.onLine ?? true;
-    }
-    assign(url) {
-        if (!this.isBrowser)
-            return;
-        this.document.defaultView?.location.assign(url);
-    }
-    reload() {
-        if (!this.isBrowser)
-            return;
-        this.document.defaultView?.location.reload();
-    }
-    /**
-     * Recoveries already attempted, kept in `sessionStorage` so it survives the
-     * very reload it is counting. Without this, an origin serving a stale entry
-     * document turns one failure into an infinite reload loop.
-     */
-    recoveryCount() {
-        if (!this.isBrowser)
-            return 0;
-        try {
-            const raw = this.document.defaultView?.sessionStorage.getItem(LOOP_GUARD_KEY);
-            const parsed = raw ? JSON.parse(raw) : null;
-            // Scoped to a build: a genuinely new deployment gets a fresh budget.
-            return parsed?.buildId === this.options.identity.buildId ? (parsed.count ?? 0) : 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-    countRecovery() {
-        if (!this.isBrowser)
-            return;
-        try {
-            this.document.defaultView?.sessionStorage.setItem(LOOP_GUARD_KEY, JSON.stringify({ buildId: this.options.identity.buildId, count: this.recoveryCount() + 1 }));
-        }
-        catch {
-            // Private mode. The manifest probe remains as the precise loop guard.
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SkewRecoveryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SkewRecoveryService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SkewRecoveryService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-
-/**
- * Enables skew recovery.
- *
- * ```ts
- * bootstrapApplication(App, {
- *   providers: [
- *     provideRouter(routes),
- *     provideSkewRecovery({
- *       identity: BUILD_IDENTITY,          // from @braidlabs/build
- *       manifestUrl: '/skew-manifest.json',
- *     }),
- *   ],
- * });
- * ```
- *
- * Deliberately *not* a `RouterFeature`: Angular's feature factory is internal,
- * so third parties cannot construct one. This composes alongside
- * `provideRouter` instead, and works with any router configuration.
- *
- * The service is instantiated eagerly — it subscribes to router events, and a
- * lazily-created recovery service would miss the very first failure.
- */
+const LOOP_GUARD_KEY = "skew:recoveries";
+var SkewRecoveryService = class SkewRecoveryService {
+	options = inject(SKEW_RECOVERY_OPTIONS);
+	router = inject(Router);
+	document = inject(DOCUMENT);
+	unsavedWork = inject(UnsavedWorkRegistry);
+	isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+	probe;
+	pendingSignal = signal(null, ...ngDevMode ? [{ debugName: "pendingSignal" }] : /* istanbul ignore next */ []);
+	statusSignal = signal(null, ...ngDevMode ? [{ debugName: "statusSignal" }] : /* istanbul ignore next */ []);
+	pending = this.pendingSignal.asReadonly();
+	status = this.statusSignal.asReadonly();
+	updateAvailable = computed(() => this.statusSignal()?.kind === "staleClient", ...ngDevMode ? [{ debugName: "updateAvailable" }] : /* istanbul ignore next */ []);
+	constructor() {
+		this.probe = this.options.manifestUrl ? createVersionProbe({
+			identity: this.options.identity,
+			manifestUrl: this.options.manifestUrl
+		}) : null;
+		if (this.isBrowser) this.listen();
+	}
+	listen() {
+		this.router.events.subscribe((event) => {
+			if (event instanceof NavigationError && isChunkLoadFailure(event.error)) {
+				if (isSkewDisabled()) return;
+				this.handle(event.error, event.url);
+			}
+		});
+	}
+	async check() {
+		if (!this.probe) return null;
+		const status = await this.probe.check();
+		this.statusSignal.set(status);
+		return status;
+	}
+	recover() {
+		const pending = this.pendingSignal();
+		if (!pending) return;
+		this.pendingSignal.set(null);
+		this.assign(pending.targetUrl);
+	}
+	dismiss() {
+		this.pendingSignal.set(null);
+	}
+	async handle(failure, targetUrl) {
+		const context = await this.classify(failure, targetUrl);
+		const action = await this.chooseAction(context);
+		this.dispatch(action, context);
+	}
+	async classify(failure, targetUrl) {
+		const status = await this.check();
+		const serverBuildId = status?.kind === "current" ? status.buildId : status && "remote" in status ? status.remote : void 0;
+		const manifest = this.probe?.lastManifest() ?? null;
+		const moduleStillExists = failure.moduleId === void 0 || manifest === null || !moduleWasRemoved(manifest, failure.moduleId);
+		return {
+			targetUrl,
+			currentUrl: this.router.url,
+			moduleId: failure.moduleId,
+			error: failure,
+			attempt: this.recoveryCount(),
+			isOnline: this.isOnline(),
+			clientBuildId: this.options.identity.buildId,
+			serverBuildId,
+			moduleStillExists,
+			entryDocumentStale: status?.kind === "staleOrigin",
+			newAssetsReachable: status?.kind === "staleClient",
+			hasUnsavedWork: this.options.respectUnsavedWork && this.unsavedWork.isDirty()
+		};
+	}
+	async chooseAction(context) {
+		if (!context.isOnline) return "notify";
+		if (context.entryDocumentStale) return "notify";
+		if (context.attempt >= this.options.maxRecoveries) return "notify";
+		if (context.hasUnsavedWork) return "notify";
+		if (!context.moduleStillExists) return "redirect-to-fallback";
+		const strategy = this.options.onStaleChunk;
+		if (typeof strategy === "function") try {
+			return await strategy(context);
+		} catch {
+			return "notify";
+		}
+		return strategy;
+	}
+	dispatch(action, context) {
+		switch (action) {
+			case "reload-at-target":
+				this.countRecovery();
+				this.assign(context.targetUrl);
+				return;
+			case "reload-in-place":
+				this.countRecovery();
+				this.reload();
+				return;
+			case "redirect-to-fallback":
+				this.router.navigateByUrl(this.options.fallbackRoute);
+				return;
+			case "ignore": return;
+			case "notify":
+				this.pendingSignal.set({
+					targetUrl: context.targetUrl,
+					moduleId: context.moduleId,
+					serverBuildId: context.serverBuildId,
+					reason: !context.isOnline ? "offline" : context.entryDocumentStale ? "loop-detected" : context.attempt >= this.options.maxRecoveries ? "exhausted" : "notify",
+					context
+				});
+				return;
+		}
+	}
+	isOnline() {
+		if (!this.isBrowser) return true;
+		return (this.document.defaultView?.navigator)?.onLine ?? true;
+	}
+	assign(url) {
+		if (!this.isBrowser) return;
+		this.document.defaultView?.location.assign(url);
+	}
+	reload() {
+		if (!this.isBrowser) return;
+		this.document.defaultView?.location.reload();
+	}
+	recoveryCount() {
+		if (!this.isBrowser) return 0;
+		try {
+			const raw = this.document.defaultView?.sessionStorage.getItem(LOOP_GUARD_KEY);
+			const parsed = raw ? JSON.parse(raw) : null;
+			return parsed?.buildId === this.options.identity.buildId ? parsed.count ?? 0 : 0;
+		} catch {
+			return 0;
+		}
+	}
+	countRecovery() {
+		if (!this.isBrowser) return;
+		try {
+			this.document.defaultView?.sessionStorage.setItem(LOOP_GUARD_KEY, JSON.stringify({
+				buildId: this.options.identity.buildId,
+				count: this.recoveryCount() + 1
+			}));
+		} catch {}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: SkewRecoveryService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: SkewRecoveryService,
+		providedIn: "root"
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: SkewRecoveryService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}],
+	ctorParameters: () => []
+});
 function provideSkewRecovery(options) {
-    const resolved = resolveOptions(options);
-    return makeEnvironmentProviders([
-        { provide: SKEW_RECOVERY_OPTIONS, useValue: resolved },
-        provideEnvironmentInitializer(() => {
-            // Route definitions are evaluated before DI exists, so `lazy()` cannot
-            // inject its retry policy. Publishing the resolved values here keeps a
-            // single source of configuration without making `lazy()` DI-aware.
-            lazyDefaults.retryAttempts = resolved.retryAttempts;
-            lazyDefaults.retryDelayMs = resolved.retryDelayMs;
-            inject(SkewRecoveryService);
-        }),
-    ]);
+	const resolved = resolveOptions(options);
+	return makeEnvironmentProviders([{
+		provide: SKEW_RECOVERY_OPTIONS,
+		useValue: resolved
+	}, provideEnvironmentInitializer(() => {
+		lazyDefaults.retryAttempts = resolved.retryAttempts;
+		lazyDefaults.retryDelayMs = resolved.retryDelayMs;
+		inject(SkewRecoveryService);
+	})]);
 }
-
-/**
- * ⚠️ NOT PUBLIC API. Undocumented on purpose. Do not use in an application.
- *
- * Angular-shaped wrapper around `setSkewDisabled()` from `@braidlabs/skew`. Read the
- * module comment in `@braidlabs/skew`'s `disabled.ts` first — it explains what this
- * turns off, why it exists, and why it is deliberately absent from the README,
- * the package docs, and every example.
- *
- * ```ts
- * // demo apps only
- * providers: [provideSkewRecovery({ … }), provideSkewDisabled()]
- * ```
- *
- * Two things worth knowing before using it anyway:
- *
- * **It is not scoped to this injector.** The flag lives in a module-level
- * variable in `@braidlabs/skew`, because core is framework-agnostic and has no
- * injector to read from. Calling this affects every `@braidlabs` package sharing
- * that instance of core — including any other Angular application on the page.
- * It is `provide*`-shaped for familiarity, not because it is scoped.
- *
- * **It applies at bootstrap.** For a control that flips at runtime — which is
- * what a before/after demo actually wants — call `setSkewDisabled()` directly.
- * Every check reads the flag at the moment it runs, so a later toggle takes
- * effect on the next read, navigation or write with no reload.
- *
- * This lives in `@braidlabs/angular-router` for want of a shared Angular package;
- * it belongs in `@braidlabs/angular-core` once that lands, since it governs all of
- * them and nothing here is router-specific.
- *
- * @internal
- */
 function provideSkewDisabled(disabled = true) {
-    return makeEnvironmentProviders([
-        provideEnvironmentInitializer(() => setSkewDisabled(disabled)),
-    ]);
+	return makeEnvironmentProviders([provideEnvironmentInitializer(() => setSkewDisabled(disabled))]);
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { ChunkLoadFailure, SKEW_RECOVERY_OPTIONS, SkewRecoveryService, UnsavedWorkRegistry, isChunkLoadFailure, lazy, lazyDefaults, looksLikeChunkError, provideSkewDisabled, provideSkewRecovery, resetLazyDefaults, resolveOptions, trackUnsavedWork };
-//# sourceMappingURL=braidlabs-angular-router.mjs.map
+
+//# sourceMappingURL=braidlabs-angular-router.mjs.map