@forgeroute/ui 0.4.78 → 0.4.79

package/fesm2022/forgeroute-ui-offline.mjs

@@ -0,0 +1,3036 @@
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, ElementRef, Injectable, InjectionToken, computed, effect, inject, input, makeEnvironmentProviders, output, provideAppInitializer, signal, untracked, viewChild } from "@angular/core";
+import { DOCUMENT } from "@angular/common";
+import { Subject, defer, firstValueFrom, from, of, throwError, timer } from "rxjs";
+import { ConfirmService, SidePanelComponent, ToastService, UiLabelsService, uiText } from "@forgeroute/ui";
+import { HttpClient, HttpContextToken, HttpErrorResponse, HttpHeaders, HttpParams, HttpResponse } from "@angular/common/http";
+import { catchError, finalize, retry, switchMap, tap, timeout } from "rxjs/operators";
+const OFFLINE_SUPPORT_CONFIG = new InjectionToken("OFFLINE_SUPPORT_CONFIG");
+const OFFLINE_REPLAY_HEADER = "X-Offline-Replay";
+const IDEMPOTENCY_HEADER = "Idempotency-Key";
+const FROM_CACHE_HEADER = "X-From-Offline-Cache";
+function usableId(v) {
+	if (typeof v === "string") return v.trim() === "" ? void 0 : v;
+	if (typeof v === "number" && Number.isFinite(v)) return v;
+}
+function defaultCreatedId(body) {
+	if (body === null || typeof body !== "object") return void 0;
+	const b = body;
+	const direct = usableId(b.id);
+	if (direct !== void 0) return direct;
+	const data = b.data;
+	return data !== null && typeof data === "object" ? usableId(data.id) : void 0;
+}
+function safeCreatedId(fn) {
+	return (body, row) => {
+		try {
+			return usableId(fn(body, row));
+		} catch {
+			return;
+		}
+	};
+}
+const DEFAULT_LIST_TTL_MS = 6e5;
+const DEFAULT_DETAIL_TTL_MS = 18e5;
+function positive(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function resolveConfig(cfg) {
+	return {
+		apiPrefix: cfg.apiPrefix || "/api/",
+		skip: cfg.skip ?? [],
+		getUserId: cfg.getUserId,
+		allowQueue: cfg.allowQueue ?? null,
+		blockOffline: cfg.blockOffline ?? [],
+		neverCache: cfg.neverCache ?? [],
+		replayHeaders: cfg.replayHeaders ?? [],
+		probe: cfg.probe && cfg.probe.url ? {
+			url: cfg.probe.url,
+			intervalMs: positive(cfg.probe.intervalMs, 15e3)
+		} : null,
+		timeouts: {
+			read: positive(cfg.timeouts?.read, 3e4),
+			write: positive(cfg.timeouts?.write, 6e4),
+			long: positive(cfg.timeouts?.long, 18e4)
+		},
+		longRequests: cfg.longRequests ?? [],
+		slow: {
+			slowMs: positive(cfg.slow?.slowMs, 5e3),
+			slowCount: positive(cfg.slow?.slowCount, 2),
+			windowMs: positive(cfg.slow?.windowMs, 6e4),
+			stuckMs: positive(cfg.slow?.stuckMs, 8e3),
+			quietMs: positive(cfg.slow?.quietMs, 3e4)
+		},
+		dbName: cfg.dbName || "forgeroute-offline",
+		cacheTtl: cfg.cacheTtl ?? null,
+		maxQueue: positive(cfg.maxQueue, 500),
+		maxAttempts: positive(cfg.maxAttempts, 5),
+		createdId: cfg.createdId ? safeCreatedId(cfg.createdId) : defaultCreatedId
+	};
+}
+function pathAndQuery(url) {
+	const m = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]+(.*)$/i.exec(url);
+	const noHash = (m ? m[1] : url).split("#")[0];
+	return noHash === "" ? "/" : noHash;
+}
+function pathOnly(url) {
+	return pathAndQuery(url).split("?")[0];
+}
+function matchesUrl(url, matcher) {
+	const target = pathAndQuery(url);
+	if (typeof matcher === "string") return matcher !== "" && target.includes(matcher);
+	matcher.lastIndex = 0;
+	const hit = matcher.test(target);
+	matcher.lastIndex = 0;
+	return hit;
+}
+function matchesAny(url, matchers) {
+	return matchers.some((m) => matchesUrl(url, m));
+}
+function isMutationMethod(method) {
+	const m = method.toUpperCase();
+	return m === "POST" || m === "PUT" || m === "PATCH" || m === "DELETE";
+}
+const ID_SEGMENT = /^(?:\d+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+function deriveEntity(url) {
+	const segments = pathOnly(url).split("/").filter(Boolean);
+	for (let i = 1; i < segments.length; i++) if (ID_SEGMENT.test(segments[i])) return {
+		entityType: segments[i - 1],
+		entityId: segments[i]
+	};
+	return {};
+}
+function invalidationPrefix(url) {
+	const segments = pathOnly(url).split("/").filter(Boolean);
+	while (segments.length > 1 && ID_SEGMENT.test(segments[segments.length - 1])) segments.pop();
+	return "/" + segments.join("/");
+}
+const resolvedCache = /* @__PURE__ */ new WeakMap();
+function resolveConfigCached(cfg) {
+	let resolved = resolvedCache.get(cfg);
+	if (!resolved) {
+		resolved = resolveConfig(cfg);
+		resolvedCache.set(cfg, resolved);
+	}
+	return resolved;
+}
+function isInScope(url, cfg) {
+	return url.includes(cfg.apiPrefix) && !matchesAny(url, cfg.skip);
+}
+function lastSegmentIsId(url) {
+	const segments = pathOnly(url).split("/").filter(Boolean);
+	return segments.length > 0 && ID_SEGMENT.test(segments[segments.length - 1]);
+}
+function generateUuid() {
+	const c = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+	if (c && typeof c.randomUUID === "function") try {
+		return c.randomUUID();
+	} catch {}
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	if (c && typeof c.getRandomValues === "function") c.getRandomValues(bytes);
+	else for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+	return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+const ONLINE_DEBOUNCE_MS = 300;
+const PROBE_TIMEOUT_MS = 5e3;
+var ConnectionStateService = class ConnectionStateService {
+	constructor() {
+		this.cfg = resolveConfig(inject(OFFLINE_SUPPORT_CONFIG, { optional: true }) ?? { getUserId: () => null });
+		this.win = inject(DOCUMENT).defaultView;
+		this.browserOnline = signal(this.readNavigatorOnline(), ...ngDevMode ? [{ debugName: "browserOnline" }] : /* istanbul ignore next */ []);
+		this.unreachable = signal(false, ...ngDevMode ? [{ debugName: "unreachable" }] : /* istanbul ignore next */ []);
+		this.slowFlag = signal(false, ...ngDevMode ? [{ debugName: "slowFlag" }] : /* istanbul ignore next */ []);
+		this._slowRequestActive = signal(false, ...ngDevMode ? [{ debugName: "_slowRequestActive" }] : /* istanbul ignore next */ []);
+		this._inFlightCount = signal(0, ...ngDevMode ? [{ debugName: "_inFlightCount" }] : /* istanbul ignore next */ []);
+		this._state = signal(this.browserOnline() ? "online" : "offline", ...ngDevMode ? [{ debugName: "_state" }] : /* istanbul ignore next */ []);
+		this._lastChangeAt = signal(Date.now(), ...ngDevMode ? [{ debugName: "_lastChangeAt" }] : /* istanbul ignore next */ []);
+		this.state = this._state.asReadonly();
+		this.isOnline = computed(() => this._state() === "online" || this._state() === "slow", ...ngDevMode ? [{ debugName: "isOnline" }] : /* istanbul ignore next */ []);
+		this.isOffline = computed(() => this._state() === "offline" || this._state() === "unreachable", ...ngDevMode ? [{ debugName: "isOffline" }] : /* istanbul ignore next */ []);
+		this.slowRequestActive = this._slowRequestActive.asReadonly();
+		this.inFlightCount = this._inFlightCount.asReadonly();
+		this.lastChangeAt = this._lastChangeAt.asReadonly();
+		this.slowRequestHint = computed(() => this._slowRequestActive() || this._state() === "slow", ...ngDevMode ? [{ debugName: "slowRequestHint" }] : /* istanbul ignore next */ []);
+		this.recovered$ = new Subject();
+		this.failures = [];
+		this.slowTimes = [];
+		this.quietTimer = null;
+		this.onlineTimer = null;
+		this.probeTimer = null;
+		this.optimisticTimer = null;
+		this.probeInFlight = null;
+		this.inFlight = /* @__PURE__ */ new Map();
+		this.nextRequestId = 0;
+		this.onWindowOnline = () => this.scheduleOnline();
+		this.onWindowOffline = () => {
+			this.cancelOnlineTimer();
+			this.setBrowserOnline(false);
+		};
+		this.onFocus = () => this.syncFromNavigator();
+		const win = this.win;
+		if (win) {
+			win.addEventListener("online", this.onWindowOnline);
+			win.addEventListener("offline", this.onWindowOffline);
+			win.addEventListener("focus", this.onFocus);
+			win.document?.addEventListener("visibilitychange", this.onFocus);
+		}
+		inject(DestroyRef).onDestroy(() => this.teardown());
+	}
+	recordRequest(info) {
+		const now = Date.now();
+		if (info.timedOut || info.status === 0) {
+			this.handleFailure(now);
+			return;
+		}
+		this.failures = [];
+		if (this.unreachable()) this.clearUnreachable("online");
+		if (info.long) return;
+		if (info.durationMs >= this.cfg.slow.slowMs) {
+			this.slowTimes = this.slowTimes.filter((t) => now - t <= this.cfg.slow.windowMs);
+			this.slowTimes.push(now);
+			if (this.slowTimes.length >= this.cfg.slow.slowCount || this.slowFlag()) this.markSlow();
+		}
+	}
+	beginRequest(options = {}) {
+		const id = ++this.nextRequestId;
+		const entry = {
+			start: Date.now(),
+			stuck: false,
+			timer: null
+		};
+		this.inFlight.set(id, entry);
+		this._inFlightCount.set(this.inFlight.size);
+		if (!options.long) entry.timer = setTimeout(() => {
+			entry.timer = null;
+			if (!this.inFlight.has(id)) return;
+			entry.stuck = true;
+			this._slowRequestActive.set(true);
+			this.markSlow();
+		}, this.cfg.slow.stuckMs);
+		return () => {
+			const current = this.inFlight.get(id);
+			if (!current) return;
+			if (current.timer) clearTimeout(current.timer);
+			this.inFlight.delete(id);
+			this._inFlightCount.set(this.inFlight.size);
+			this._slowRequestActive.set([...this.inFlight.values()].some((e) => e.stuck));
+			this.recompute();
+		};
+	}
+	probeNow() {
+		const probe = this.cfg.probe;
+		if (!probe) return Promise.resolve(this.browserOnline());
+		if (this.probeInFlight) return this.probeInFlight;
+		const run = this.runProbe(probe.url).then((ok) => {
+			if (ok) this.onProbeSuccess();
+			return ok;
+		}).finally(() => {
+			this.probeInFlight = null;
+		});
+		this.probeInFlight = run;
+		return run;
+	}
+	async runProbe(url) {
+		const win = this.win;
+		if (!win || typeof win.fetch !== "function") return false;
+		const controller = typeof AbortController === "function" ? new AbortController() : null;
+		const timer = controller ? setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS) : null;
+		try {
+			await win.fetch(url, {
+				method: "GET",
+				cache: "no-store",
+				credentials: "same-origin",
+				signal: controller?.signal
+			});
+			return true;
+		} catch {
+			return false;
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	onProbeSuccess() {
+		this.failures = [];
+		if (this.unreachable()) this.clearUnreachable("probe");
+	}
+	handleFailure(now) {
+		if (!this.browserOnline()) return;
+		this.failures = this.failures.filter((t) => now - t <= this.cfg.slow.windowMs);
+		this.failures.push(now);
+		if (this.failures.length >= 2) {
+			this.setUnreachable();
+			return;
+		}
+		if (this.cfg.probe) this.probeNow().then((ok) => {
+			if (!ok && this.browserOnline() && this.failures.length > 0) this.setUnreachable();
+		});
+	}
+	setUnreachable() {
+		if (this.unreachable()) return;
+		this.unreachable.set(true);
+		this.recompute();
+		if (this.cfg.probe) this.probeTimer = setInterval(() => {
+			this.probeNow();
+		}, this.cfg.probe.intervalMs);
+		else this.optimisticTimer = setTimeout(() => {
+			this.optimisticTimer = null;
+			if (this.unreachable()) this.clearUnreachable("online");
+		}, 15e3);
+	}
+	clearUnreachable(trigger) {
+		if (!this.unreachable()) return;
+		this.unreachable.set(false);
+		this.stopRecoveryTimers();
+		this.recompute();
+		if (this.browserOnline()) this.recovered$.next(trigger);
+	}
+	stopRecoveryTimers() {
+		if (this.probeTimer) {
+			clearInterval(this.probeTimer);
+			this.probeTimer = null;
+		}
+		if (this.optimisticTimer) {
+			clearTimeout(this.optimisticTimer);
+			this.optimisticTimer = null;
+		}
+	}
+	markSlow() {
+		this.slowFlag.set(true);
+		if (this.quietTimer) clearTimeout(this.quietTimer);
+		this.quietTimer = setTimeout(() => {
+			this.quietTimer = null;
+			this.slowFlag.set(false);
+			this.slowTimes = [];
+			this.recompute();
+		}, this.cfg.slow.quietMs);
+		this.recompute();
+	}
+	scheduleOnline() {
+		this.cancelOnlineTimer();
+		this.onlineTimer = setTimeout(() => {
+			this.onlineTimer = null;
+			this.setBrowserOnline(true);
+		}, 300);
+	}
+	cancelOnlineTimer() {
+		if (this.onlineTimer) {
+			clearTimeout(this.onlineTimer);
+			this.onlineTimer = null;
+		}
+	}
+	setBrowserOnline(value) {
+		if (this.browserOnline() === value) return;
+		this.browserOnline.set(value);
+		if (value) {
+			this.failures = [];
+			if (this.unreachable()) {
+				this.unreachable.set(false);
+				this.stopRecoveryTimers();
+			}
+			this.recompute();
+			this.recovered$.next("online");
+		} else this.recompute();
+	}
+	syncFromNavigator() {
+		if (!this.readNavigatorOnline()) {
+			this.cancelOnlineTimer();
+			this.setBrowserOnline(false);
+		} else if (!this.browserOnline()) this.scheduleOnline();
+	}
+	readNavigatorOnline() {
+		try {
+			return this.win?.navigator?.onLine !== false;
+		} catch {
+			return true;
+		}
+	}
+	recompute() {
+		const next = !this.browserOnline() ? "offline" : this.unreachable() ? "unreachable" : this.slowFlag() || this._slowRequestActive() ? "slow" : "online";
+		if (next === this._state()) return;
+		this._state.set(next);
+		this._lastChangeAt.set(Date.now());
+	}
+	teardown() {
+		const win = this.win;
+		if (win) {
+			win.removeEventListener("online", this.onWindowOnline);
+			win.removeEventListener("offline", this.onWindowOffline);
+			win.removeEventListener("focus", this.onFocus);
+			win.document?.removeEventListener("visibilitychange", this.onFocus);
+		}
+		this.cancelOnlineTimer();
+		this.stopRecoveryTimers();
+		if (this.quietTimer) {
+			clearTimeout(this.quietTimer);
+			this.quietTimer = null;
+		}
+		for (const e of this.inFlight.values()) if (e.timer) clearTimeout(e.timer);
+		this.inFlight.clear();
+		this.recovered$.complete();
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: ConnectionStateService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: ConnectionStateService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: ConnectionStateService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}],
+	ctorParameters: () => []
+});
+const DEFAULT_KEY = "*";
+var StaleDataService = class StaleDataService {
+	constructor() {
+		this._staleAt = signal(null, ...ngDevMode ? [{ debugName: "_staleAt" }] : /* istanbul ignore next */ []);
+		this.entries = /* @__PURE__ */ new Map();
+		this.staleAt = this._staleAt.asReadonly();
+	}
+	markStale(cachedAt, key = DEFAULT_KEY) {
+		this.entries.set(key, cachedAt);
+		this.publish();
+	}
+	clearKey(key) {
+		if (this.entries.delete(key)) this.publish();
+	}
+	clear() {
+		if (this.entries.size === 0) return;
+		this.entries.clear();
+		this.publish();
+	}
+	publish() {
+		let latest = null;
+		for (const v of this.entries.values()) if (latest === null || v > latest) latest = v;
+		this._staleAt.set(latest);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StaleDataService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StaleDataService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: StaleDataService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+const IDMAP_TTL_MS = 6048e5;
+const STALE_CLAIM_MS = 6e4;
+const DB_VERSION = 2;
+const OPEN_TIMEOUT_MS = 1e4;
+const MAX_CACHE_ENTRIES = 500;
+const EVICT_COUNT = 50;
+const MUTATIONS = "mutations";
+const RESPONSES = "responses";
+const META = "meta";
+const IDMAP = "idmap";
+const OFFLINE_IDB_FACTORY = new InjectionToken("OFFLINE_IDB_FACTORY", {
+	providedIn: "root",
+	factory: () => {
+		try {
+			return typeof indexedDB !== "undefined" ? indexedDB : null;
+		} catch {
+			return null;
+		}
+	}
+});
+var StorageUnavailableError = class StorageUnavailableError extends Error {
+	constructor(message = uiText("connection.storageNotAvailable")) {
+		super(message);
+		this.name = "StorageUnavailableError";
+		Object.setPrototypeOf(this, StorageUnavailableError.prototype);
+	}
+};
+var QueueFullError = class QueueFullError extends Error {
+	constructor(limit) {
+		super(uiText("connection.queueFull", { limit }));
+		this.limit = limit;
+		this.name = "QueueFullError";
+		Object.setPrototypeOf(this, QueueFullError.prototype);
+	}
+};
+function isQuotaError(e) {
+	const x = e;
+	return !!x && (x.name === "QuotaExceededError" || x.name === "NS_ERROR_DOM_QUOTA_REACHED" || x.code === 22 || x.code === 1014);
+}
+function isInvalidState(e) {
+	const x = e;
+	return !!x && (x.name === "InvalidStateError" || x.name === "TransactionInactiveError");
+}
+const RETRYABLE_FAILURES = [
+	"server",
+	"network",
+	"timeout"
+];
+function isClaimable(row, now) {
+	if (row.status === "pending") return true;
+	if (row.status === "failed") return !!row.lastError && RETRYABLE_FAILURES.includes(row.lastError.kind);
+	if (row.status === "syncing") return now - (row.claimAt ?? 0) > STALE_CLAIM_MS;
+	return false;
+}
+var OfflineStore = class OfflineStore {
+	constructor() {
+		this.cfg = resolveConfig(inject(OFFLINE_SUPPORT_CONFIG, { optional: true }) ?? { getUserId: () => null });
+		this.factory = inject(OFFLINE_IDB_FACTORY);
+		this.mutated$ = new Subject();
+		this.db = null;
+		this.opening = null;
+		this.initPromise = null;
+		this.ready = false;
+	}
+	available() {
+		return this.ready;
+	}
+	init() {
+		if (!this.initPromise) this.initPromise = this.doInit().then(() => {
+			if (!this.ready) this.initPromise = null;
+		});
+		return this.initPromise;
+	}
+	async doInit() {
+		if (!this.factory) {
+			this.ready = false;
+			return;
+		}
+		try {
+			await this.getDb();
+			this.ready = true;
+		} catch {
+			this.ready = false;
+			return;
+		}
+		try {
+			await this.purgeExpired();
+		} catch {}
+		try {
+			await this.purgeExpiredIdMap();
+		} catch {}
+	}
+	async addMutation(row) {
+		await this.init();
+		if (!this.ready) throw new StorageUnavailableError();
+		const limit = this.cfg.maxQueue;
+		const saved = await this.runTx([MUTATIONS, META], "readwrite", (s, resolveWith, abortWith) => {
+			const existing = s[MUTATIONS].index("userId").getAll(row.userId);
+			existing.onsuccess = () => {
+				const rows = existing.result;
+				const dup = rows.find((r) => r.key === row.key);
+				if (dup) {
+					resolveWith(dup);
+					return;
+				}
+				if (rows.length >= limit) {
+					abortWith(new QueueFullError(limit));
+					return;
+				}
+				const seqReq = s[META].get("seq");
+				seqReq.onsuccess = () => {
+					const seq = (seqReq.result?.value ?? 0) + 1;
+					const full = {
+						...row,
+						seq
+					};
+					s[META].put({
+						id: "seq",
+						value: seq
+					});
+					s[MUTATIONS].add(full);
+					resolveWith(full);
+				};
+			};
+		});
+		this.mutated$.next();
+		return saved;
+	}
+	async claim(id, owner, now = Date.now()) {
+		const claimed = await this.runTx([MUTATIONS], "readwrite", (s, resolveWith) => {
+			resolveWith(null);
+			const req = s[MUTATIONS].get(id);
+			req.onsuccess = () => {
+				const row = req.result;
+				if (!row || !isClaimable(row, now)) return;
+				const next = {
+					...row,
+					status: "syncing",
+					claimOwner: owner,
+					claimAt: now
+				};
+				s[MUTATIONS].put(next);
+				resolveWith(next);
+			};
+		});
+		if (claimed) this.mutated$.next();
+		return claimed;
+	}
+	async update(id, patch, opts = {}) {
+		const updated = await this.runTx([MUTATIONS], "readwrite", (s, resolveWith) => {
+			resolveWith(null);
+			const req = s[MUTATIONS].get(id);
+			req.onsuccess = () => {
+				const row = req.result;
+				if (!row) return;
+				if (opts.ifOwner !== void 0 && row.claimOwner !== opts.ifOwner) return;
+				const merged = {
+					...row,
+					...patch,
+					id: row.id,
+					userId: row.userId
+				};
+				const loose = merged;
+				for (const k of Object.keys(loose)) if (loose[k] === void 0) delete loose[k];
+				s[MUTATIONS].put(merged);
+				resolveWith(merged);
+			};
+		});
+		if (updated) this.mutated$.next();
+		return updated;
+	}
+	async resetForRetry(id, userId, now = Date.now()) {
+		if (!await this.ensureReady()) return null;
+		const reset = await this.runTx([MUTATIONS], "readwrite", (s, resolveWith) => {
+			resolveWith(null);
+			const req = s[MUTATIONS].get(id);
+			req.onsuccess = () => {
+				const row = req.result;
+				if (!row || row.userId !== userId) return;
+				if (row.status === "syncing" && now - (row.claimAt ?? 0) <= 6e4) return;
+				const next = {
+					...row,
+					status: "pending",
+					attempts: 0
+				};
+				delete next.nextAttemptAt;
+				delete next.lastError;
+				delete next.claimOwner;
+				delete next.claimAt;
+				s[MUTATIONS].put(next);
+				resolveWith(next);
+			};
+		});
+		if (reset) this.mutated$.next();
+		return reset;
+	}
+	async get(id) {
+		if (!await this.ensureReady()) return null;
+		return this.runTx([MUTATIONS], "readonly", (s, resolveWith) => {
+			resolveWith(null);
+			const req = s[MUTATIONS].get(id);
+			req.onsuccess = () => resolveWith(req.result ?? null);
+		});
+	}
+	async delete(id, opts = {}) {
+		const deleted = await this.runTx([MUTATIONS], "readwrite", (s, resolveWith) => {
+			resolveWith(false);
+			const req = s[MUTATIONS].get(id);
+			req.onsuccess = () => {
+				const row = req.result;
+				if (!row) return;
+				if (opts.ifOwner !== void 0 && row.claimOwner !== opts.ifOwner) return;
+				s[MUTATIONS].delete(id);
+				resolveWith(true);
+			};
+		});
+		if (deleted) this.mutated$.next();
+		return deleted;
+	}
+	async list(userId) {
+		if (!await this.ensureReady()) return [];
+		return (await this.runTx([MUTATIONS], "readonly", (s, resolveWith) => {
+			resolveWith([]);
+			const req = s[MUTATIONS].index("userId").getAll(userId);
+			req.onsuccess = () => resolveWith(req.result);
+		})).filter((r) => r.userId === userId).sort((a, b) => a.seq - b.seq || a.createdAt - b.createdAt);
+	}
+	async count(userId) {
+		return (await this.list(userId)).length;
+	}
+	async countsByStatus(userId) {
+		const counts = {
+			pending: 0,
+			syncing: 0,
+			failed: 0,
+			conflict: 0
+		};
+		for (const r of await this.list(userId)) counts[r.status]++;
+		return counts;
+	}
+	async deleteMutations(userId) {
+		if (!await this.ensureReady()) return 0;
+		const removed = await this.runTx([MUTATIONS], "readwrite", (s, resolveWith) => {
+			resolveWith(0);
+			const req = s[MUTATIONS].index("userId").getAll(userId);
+			req.onsuccess = () => {
+				const rows = req.result.filter((r) => r.userId === userId);
+				for (const r of rows) s[MUTATIONS].delete(r.id);
+				resolveWith(rows.length);
+			};
+		});
+		if (removed > 0) this.mutated$.next();
+		return removed;
+	}
+	async clearUser(userId) {
+		if (!await this.ensureReady()) return;
+		await this.deleteMutations(userId);
+		await this.clearCache(userId);
+		await this.deleteIdMap(userId);
+	}
+	async clearAll() {
+		if (!await this.ensureReady()) return;
+		await this.runTx([
+			MUTATIONS,
+			RESPONSES,
+			IDMAP
+		], "readwrite", (s) => {
+			s[MUTATIONS].clear();
+			s[RESPONSES].clear();
+			s[IDMAP].clear();
+		});
+		this.mutated$.next();
+	}
+	async putIdMapping(userId, tempId, realId, now = Date.now()) {
+		await this.init();
+		if (!this.ready) throw new StorageUnavailableError();
+		const entry = {
+			key: `${userId}:${tempId}`,
+			userId,
+			tempId,
+			realId: String(realId),
+			createdAt: now,
+			expiresAt: now + IDMAP_TTL_MS,
+			...typeof realId === "number" ? { numeric: true } : {}
+		};
+		await this.runTx([IDMAP], "readwrite", (s) => {
+			s[IDMAP].put(entry);
+		});
+		return entry;
+	}
+	async getIdMapping(userId, tempId, now = Date.now()) {
+		if (!await this.ensureReady()) return null;
+		const entry = await this.runTx([IDMAP], "readonly", (s, resolveWith) => {
+			resolveWith(null);
+			const req = s[IDMAP].get(`${userId}:${tempId}`);
+			req.onsuccess = () => resolveWith(req.result ?? null);
+		});
+		return entry && entry.userId === userId && entry.expiresAt > now ? entry : null;
+	}
+	async listIdMap(userId, now = Date.now()) {
+		if (!await this.ensureReady()) return [];
+		return (await this.runTx([IDMAP], "readonly", (s, resolveWith) => {
+			resolveWith([]);
+			const req = s[IDMAP].index("userId").getAll(userId);
+			req.onsuccess = () => resolveWith(req.result);
+		})).filter((e) => e.userId === userId && e.expiresAt > now);
+	}
+	async deleteIdMap(userId) {
+		if (!await this.ensureReady()) return 0;
+		return this.runTx([IDMAP], "readwrite", (s, resolveWith) => {
+			resolveWith(0);
+			const req = s[IDMAP].index("userId").getAll(userId);
+			req.onsuccess = () => {
+				const mine = req.result.filter((e) => e.userId === userId);
+				for (const e of mine) s[IDMAP].delete(e.key);
+				resolveWith(mine.length);
+			};
+		});
+	}
+	async purgeExpiredIdMap(now = Date.now()) {
+		return this.runTx([IDMAP], "readwrite", (s, resolveWith) => {
+			resolveWith(0);
+			const req = s[IDMAP].getAll();
+			req.onsuccess = () => {
+				const old = req.result.filter((e) => e.expiresAt <= now);
+				for (const e of old) s[IDMAP].delete(e.key);
+				resolveWith(old.length);
+			};
+		});
+	}
+	async cacheResponse(key, userId, data, ttlMs, now = Date.now()) {
+		if (!await this.ensureReady()) return false;
+		const entry = {
+			key: `${userId}::${key}`,
+			urlKey: key,
+			userId,
+			data,
+			cachedAt: now,
+			expiresAt: now + ttlMs
+		};
+		const put = () => this.runTx([RESPONSES], "readwrite", (s) => {
+			s[RESPONSES].put(entry);
+		});
+		try {
+			await put();
+		} catch (e) {
+			if (!isQuotaError(e)) return false;
+			try {
+				await this.evictOldest(EVICT_COUNT, now);
+				await put();
+			} catch {
+				return false;
+			}
+		}
+		this.enforceCacheLimit().catch(() => void 0);
+		return true;
+	}
+	async getCached(key, userId, now = Date.now()) {
+		if (!await this.ensureReady()) return null;
+		const composite = `${userId}::${key}`;
+		const entry = await this.runTx([RESPONSES], "readonly", (s, resolveWith) => {
+			resolveWith(null);
+			const req = s[RESPONSES].get(composite);
+			req.onsuccess = () => resolveWith(req.result ?? null);
+		}).catch(() => null);
+		if (!entry || entry.userId !== userId) return null;
+		if (entry.expiresAt <= now) {
+			this.runTx([RESPONSES], "readwrite", (s) => {
+				s[RESPONSES].delete(composite);
+			}).catch(() => void 0);
+			return null;
+		}
+		return entry;
+	}
+	async invalidatePrefix(prefix, userId) {
+		if (!await this.ensureReady()) return 0;
+		return this.runTx([RESPONSES], "readwrite", (s, resolveWith) => {
+			resolveWith(0);
+			const req = s[RESPONSES].index("userId").getAll(userId);
+			req.onsuccess = () => {
+				const hits = req.result.filter((e) => e.userId === userId && e.urlKey.startsWith(prefix));
+				for (const e of hits) s[RESPONSES].delete(e.key);
+				resolveWith(hits.length);
+			};
+		}).catch(() => 0);
+	}
+	async clearCache(userId) {
+		if (!await this.ensureReady()) return;
+		await this.runTx([RESPONSES], "readwrite", (s) => {
+			if (userId === void 0) {
+				s[RESPONSES].clear();
+				return;
+			}
+			const req = s[RESPONSES].index("userId").getAll(userId);
+			req.onsuccess = () => {
+				for (const e of req.result) if (e.userId === userId) s[RESPONSES].delete(e.key);
+			};
+		});
+	}
+	async purgeExpired(now = Date.now()) {
+		return this.runTx([RESPONSES], "readwrite", (s, resolveWith) => {
+			resolveWith(0);
+			const req = s[RESPONSES].getAll();
+			req.onsuccess = () => {
+				const old = req.result.filter((e) => e.expiresAt <= now);
+				for (const e of old) s[RESPONSES].delete(e.key);
+				resolveWith(old.length);
+			};
+		});
+	}
+	async evictOldest(count, now) {
+		await this.runTx([RESPONSES], "readwrite", (s) => {
+			const req = s[RESPONSES].getAll();
+			req.onsuccess = () => {
+				const sorted = [...req.result].sort((a, b) => (a.expiresAt <= now ? 0 : 1) - (b.expiresAt <= now ? 0 : 1) || a.cachedAt - b.cachedAt);
+				for (const e of sorted.slice(0, count)) s[RESPONSES].delete(e.key);
+			};
+		});
+	}
+	async enforceCacheLimit() {
+		if (await this.runTx([RESPONSES], "readonly", (s, resolveWith) => {
+			resolveWith(0);
+			const req = s[RESPONSES].count();
+			req.onsuccess = () => resolveWith(req.result);
+		}) > MAX_CACHE_ENTRIES) await this.evictOldest(EVICT_COUNT, Date.now());
+	}
+	async ensureReady() {
+		await this.init();
+		return this.ready;
+	}
+	getDb() {
+		if (this.db) return Promise.resolve(this.db);
+		if (this.opening) return this.opening;
+		const opening = this.openWithRetry().then((db) => {
+			this.db = db;
+			this.opening = null;
+			return db;
+		}, (err) => {
+			this.opening = null;
+			throw err;
+		});
+		this.opening = opening;
+		return opening;
+	}
+	async openWithRetry() {
+		try {
+			return await this.openOnce();
+		} catch (first) {
+			if (first instanceof StorageUnavailableError || first?.name === "SecurityError") throw first;
+			return this.openOnce();
+		}
+	}
+	openOnce() {
+		const factory = this.factory;
+		return new Promise((resolve, reject) => {
+			if (!factory) {
+				reject(new StorageUnavailableError());
+				return;
+			}
+			let req;
+			try {
+				req = factory.open(this.cfg.dbName, DB_VERSION);
+			} catch (e) {
+				reject(e);
+				return;
+			}
+			const timer = setTimeout(() => reject(new StorageUnavailableError(uiText("connection.storageTimeout"))), OPEN_TIMEOUT_MS);
+			req.onupgradeneeded = () => {
+				const db = req.result;
+				if (!db.objectStoreNames.contains(MUTATIONS)) {
+					const m = db.createObjectStore(MUTATIONS, { keyPath: "id" });
+					m.createIndex("userId", "userId");
+					m.createIndex("status", "status");
+					m.createIndex("createdAt", "createdAt");
+				}
+				if (!db.objectStoreNames.contains(RESPONSES)) {
+					const r = db.createObjectStore(RESPONSES, { keyPath: "key" });
+					r.createIndex("userId", "userId");
+					r.createIndex("expiresAt", "expiresAt");
+				}
+				if (!db.objectStoreNames.contains(META)) db.createObjectStore(META, { keyPath: "id" });
+				if (!db.objectStoreNames.contains(IDMAP)) {
+					const i = db.createObjectStore(IDMAP, { keyPath: "key" });
+					i.createIndex("userId", "userId");
+					i.createIndex("expiresAt", "expiresAt");
+				}
+			};
+			req.onsuccess = () => {
+				clearTimeout(timer);
+				const db = req.result;
+				db.onversionchange = () => {
+					db.close();
+					if (this.db === db) this.db = null;
+				};
+				db.onclose = () => {
+					if (this.db === db) this.db = null;
+				};
+				resolve(db);
+			};
+			req.onerror = () => {
+				clearTimeout(timer);
+				reject(req.error ?? new StorageUnavailableError());
+			};
+			req.onblocked = () => {};
+		});
+	}
+	async runTx(names, mode, work, retried = false) {
+		const db = await this.getDb();
+		let tx;
+		try {
+			tx = db.transaction(names, mode);
+		} catch (e) {
+			if (!retried && isInvalidState(e)) {
+				if (this.db === db) this.db = null;
+				return this.runTx(names, mode, work, true);
+			}
+			throw e;
+		}
+		return new Promise((resolve, reject) => {
+			let result;
+			let failure;
+			let failed = false;
+			const abortWith = (e) => {
+				failed = true;
+				failure = e;
+				try {
+					tx.abort();
+				} catch {}
+			};
+			tx.oncomplete = () => resolve(result);
+			tx.onabort = () => reject(failed ? failure : tx.error ?? new Error(uiText("connection.transactionAborted")));
+			const stores = {};
+			try {
+				for (const n of names) stores[n] = tx.objectStore(n);
+				work(stores, (v) => {
+					result = v;
+				}, abortWith);
+			} catch (e) {
+				abortWith(e);
+			}
+		});
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: OfflineStore,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: OfflineStore,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: OfflineStore,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+var OfflineBlockedError = class OfflineBlockedError extends Error {
+	constructor(message, reason = "blocked") {
+		super(message);
+		this.offlineBlocked = true;
+		this.status = 0;
+		this.name = "OfflineBlockedError";
+		this.reason = reason;
+		Object.setPrototypeOf(this, OfflineBlockedError.prototype);
+	}
+};
+var RequestTimeoutError = class RequestTimeoutError extends Error {
+	constructor(message, method, url, outcomeUnknown) {
+		super(message);
+		this.timeout = true;
+		this.status = 0;
+		this.name = "RequestTimeoutError";
+		this.method = method;
+		this.url = url;
+		this.outcomeUnknown = outcomeUnknown;
+		Object.setPrototypeOf(this, RequestTimeoutError.prototype);
+	}
+};
+function isOfflineBlockedError(e) {
+	return e instanceof OfflineBlockedError || typeof e === "object" && e !== null && e.offlineBlocked === true;
+}
+function isRequestTimeoutError(e) {
+	return e instanceof RequestTimeoutError || typeof e === "object" && e !== null && e.timeout === true && e.status === 0;
+}
+function bodyHasOwnId(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return false;
+	const id = body["id"];
+	return id !== void 0 && id !== null;
+}
+function isTempIdCreate(method, url, body) {
+	return method.toUpperCase() === "POST" && !lastSegmentIsId(url) && !bodyHasOwnId(body);
+}
+function splitUrl(url) {
+	const h = url.indexOf("#");
+	const hash = h >= 0 ? url.slice(h) : "";
+	const noHash = h >= 0 ? url.slice(0, h) : url;
+	const q = noHash.indexOf("?");
+	return {
+		path: q >= 0 ? noHash.slice(0, q) : noHash,
+		query: q >= 0 ? noHash.slice(q + 1) : null,
+		hash
+	};
+}
+function decode(s) {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return s;
+	}
+}
+function walkStrings(value, visit) {
+	if (typeof value === "string") {
+		visit(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const v of value) walkStrings(v, visit);
+		return;
+	}
+	if (value !== null && typeof value === "object") for (const v of Object.values(value)) walkStrings(v, visit);
+}
+function referenceStrings(url, body) {
+	const out = [];
+	const parts = splitUrl(url);
+	for (const seg of parts.path.split("/")) if (seg !== "") out.push(decode(seg));
+	if (parts.query !== null) for (const pair of parts.query.split("&")) {
+		const eq = pair.indexOf("=");
+		if (eq >= 0) out.push(decode(pair.slice(eq + 1)));
+	}
+	walkStrings(body, (s) => out.push(s));
+	return out;
+}
+function findTempIds(url, body, candidates) {
+	const found = [];
+	if (candidates.size === 0) return found;
+	for (const s of referenceStrings(url, body)) if (candidates.has(s) && !found.includes(s)) found.push(s);
+	return found;
+}
+function rewriteValue(value, map) {
+	if (typeof value === "string") return map.has(value) ? map.get(value) : value;
+	if (Array.isArray(value)) return value.map((v) => rewriteValue(v, map));
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) Object.defineProperty(out, k, {
+			value: rewriteValue(v, map),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		return out;
+	}
+	return value;
+}
+function rewriteTempIds(url, body, map) {
+	if (map.size === 0) return {
+		url,
+		body
+	};
+	const parts = splitUrl(url);
+	const path = parts.path.split("/").map((seg) => {
+		const d = decode(seg);
+		return map.has(d) ? encodeURIComponent(String(map.get(d))) : seg;
+	}).join("/");
+	let query = parts.query;
+	if (query !== null) query = query.split("&").map((pair) => {
+		const eq = pair.indexOf("=");
+		if (eq < 0) return pair;
+		const d = decode(pair.slice(eq + 1));
+		return map.has(d) ? `${pair.slice(0, eq)}=${encodeURIComponent(String(map.get(d)))}` : pair;
+	}).join("&");
+	return {
+		url: path + (query !== null ? `?${query}` : "") + parts.hash,
+		body: rewriteValue(body, map)
+	};
+}
+const OFFLINE_LOCK_MANAGER = new InjectionToken("OFFLINE_LOCK_MANAGER", {
+	providedIn: "root",
+	factory: () => {
+		try {
+			return typeof navigator !== "undefined" && navigator.locks && typeof navigator.locks.request === "function" ? navigator.locks : null;
+		} catch {
+			return null;
+		}
+	}
+});
+const OFFLINE_LEASE_STORAGE = new InjectionToken("OFFLINE_LEASE_STORAGE", {
+	providedIn: "root",
+	factory: () => {
+		try {
+			return typeof localStorage !== "undefined" ? localStorage : null;
+		} catch {
+			return null;
+		}
+	}
+});
+const LEASE_TTL_MS = 3e4;
+const LEASE_REFRESH_MS = 1e4;
+const BACKOFF_BASE_MS = 2e3;
+const BACKOFF_CAP_MS = 3e5;
+function backoffMs(attempts) {
+	return Math.min(BACKOFF_BASE_MS * 2 ** Math.max(0, attempts - 1), BACKOFF_CAP_MS);
+}
+function classifyReplay(err) {
+	if (isRequestTimeoutError(err)) return {
+		action: "retry",
+		kind: "timeout",
+		status: 0
+	};
+	if (!(err instanceof HttpErrorResponse)) return {
+		action: "retry",
+		kind: "network",
+		status: 0
+	};
+	const s = err.status;
+	if (s >= 200 && s < 300) return { action: "ok" };
+	if (s === 0) return {
+		action: "retry",
+		kind: "network",
+		status: 0
+	};
+	if (s === 401 || s === 403) return {
+		action: "auth",
+		status: s
+	};
+	if (s === 409) return {
+		action: "conflict",
+		status: s
+	};
+	if (s === 408 || s === 429) return {
+		action: "retry",
+		kind: "server",
+		status: s
+	};
+	if (s >= 400 && s < 500) return {
+		action: "rejected",
+		status: s
+	};
+	return {
+		action: "retry",
+		kind: "server",
+		status: s
+	};
+}
+var OfflineReplayer = class OfflineReplayer {
+	constructor() {
+		this.cfg = resolveConfig(inject(OFFLINE_SUPPORT_CONFIG, { optional: true }) ?? { getUserId: () => null });
+		this.store = inject(OfflineStore);
+		this.http = inject(HttpClient);
+		this.connection = inject(ConnectionStateService);
+		this.toast = inject(ToastService);
+		this.labels = inject(UiLabelsService);
+		this.locks = inject(OFFLINE_LOCK_MANAGER);
+		this.leaseStorage = inject(OFFLINE_LEASE_STORAGE);
+		this.owner = generateUuid();
+		this.running = null;
+		this._syncing = signal(false, ...ngDevMode ? [{ debugName: "_syncing" }] : /* istanbul ignore next */ []);
+		this._pendingCount = signal(0, ...ngDevMode ? [{ debugName: "_pendingCount" }] : /* istanbul ignore next */ []);
+		this._failedCount = signal(0, ...ngDevMode ? [{ debugName: "_failedCount" }] : /* istanbul ignore next */ []);
+		this._conflictCount = signal(0, ...ngDevMode ? [{ debugName: "_conflictCount" }] : /* istanbul ignore next */ []);
+		this._lastSyncAt = signal(null, ...ngDevMode ? [{ debugName: "_lastSyncAt" }] : /* istanbul ignore next */ []);
+		this._syncTick = signal(0, ...ngDevMode ? [{ debugName: "_syncTick" }] : /* istanbul ignore next */ []);
+		this._authBlocked = signal(false, ...ngDevMode ? [{ debugName: "_authBlocked" }] : /* istanbul ignore next */ []);
+		this._lastResult = signal(null, ...ngDevMode ? [{ debugName: "_lastResult" }] : /* istanbul ignore next */ []);
+		this.syncing = this._syncing.asReadonly();
+		this.pendingCount = this._pendingCount.asReadonly();
+		this.failedCount = this._failedCount.asReadonly();
+		this.conflictCount = this._conflictCount.asReadonly();
+		this.lastSyncAt = this._lastSyncAt.asReadonly();
+		this.syncTick = this._syncTick.asReadonly();
+		this.authBlocked = this._authBlocked.asReadonly();
+		this.lastResult = this._lastResult.asReadonly();
+		this.runCompleted$ = new Subject();
+	}
+	replayAll(trigger) {
+		if (this.running) return this.running;
+		return this.start(() => this.run(trigger, null));
+	}
+	async retryOne(id) {
+		await this.store.init();
+		const userId = this.cfg.getUserId();
+		if (!userId) return null;
+		if (!await this.store.resetForRetry(id, userId)) return null;
+		if (this.running) await this.running;
+		return this.start(() => this.run("manual", id));
+	}
+	async discard(id) {
+		await this.store.init();
+		const userId = this.cfg.getUserId();
+		if (!userId) return;
+		const row = await this.store.get(id);
+		if (!row || row.userId !== userId) return;
+		await this.store.delete(id);
+		await this.refreshCounts();
+	}
+	async discardAll() {
+		await this.store.init();
+		const userId = this.cfg.getUserId();
+		if (!userId) return;
+		await this.store.deleteMutations(userId);
+		this._authBlocked.set(false);
+		await this.refreshCounts();
+	}
+	async refreshCounts() {
+		const userId = this.cfg.getUserId();
+		if (!userId || !this.store.available()) {
+			this._pendingCount.set(0);
+			this._failedCount.set(0);
+			this._conflictCount.set(0);
+			return;
+		}
+		const c = await this.store.countsByStatus(userId);
+		if (this.cfg.getUserId() !== userId) return;
+		this._pendingCount.set(c.pending + c.syncing);
+		this._failedCount.set(c.failed);
+		this._conflictCount.set(c.conflict);
+	}
+	clearAuthBlocked() {
+		this._authBlocked.set(false);
+	}
+	noteRemoteSync() {
+		this._syncTick.update((n) => n + 1);
+	}
+	resetView() {
+		this._pendingCount.set(0);
+		this._failedCount.set(0);
+		this._conflictCount.set(0);
+		this._lastResult.set(null);
+		this._authBlocked.set(false);
+	}
+	start(job) {
+		const p = this.exclusive(job).finally(() => {
+			if (this.running === p) this.running = null;
+		});
+		this.running = p;
+		return p;
+	}
+	async exclusive(job) {
+		const name = `forgeroute-offline-replay:${this.cfg.dbName}`;
+		if (this.locks) try {
+			return await this.locks.request(name, { ifAvailable: true }, async (lock) => lock ? job() : null);
+		} catch (e) {
+			if (!(e instanceof DOMException) || e.name !== "SecurityError" && e.name !== "NotSupportedError") throw e;
+		}
+		return this.withLease(job);
+	}
+	leaseKey() {
+		return `forgeroute-offline-lease:${this.cfg.dbName}`;
+	}
+	readLease() {
+		try {
+			const parsed = JSON.parse(this.leaseStorage?.getItem(this.leaseKey()) ?? "null");
+			return parsed && typeof parsed === "object" ? parsed : null;
+		} catch {
+			return null;
+		}
+	}
+	tryAcquireLease() {
+		const storage = this.leaseStorage;
+		if (!storage) return true;
+		try {
+			const now = Date.now();
+			const current = this.readLease();
+			if (current && current.owner !== this.owner && typeof current.until === "number" && current.until > now) return false;
+			storage.setItem(this.leaseKey(), JSON.stringify({
+				owner: this.owner,
+				until: now + LEASE_TTL_MS
+			}));
+			return this.readLease()?.owner === this.owner;
+		} catch {
+			return true;
+		}
+	}
+	releaseLease() {
+		const storage = this.leaseStorage;
+		if (!storage) return;
+		try {
+			if (this.readLease()?.owner === this.owner) storage.removeItem(this.leaseKey());
+		} catch {}
+	}
+	async withLease(job) {
+		if (!this.tryAcquireLease()) return null;
+		const heartbeat = this.leaseStorage ? setInterval(() => this.tryAcquireLease(), LEASE_REFRESH_MS) : null;
+		try {
+			return await job();
+		} finally {
+			if (heartbeat) clearInterval(heartbeat);
+			this.releaseLease();
+		}
+	}
+	async run(trigger, onlyId) {
+		await this.store.init();
+		const userId = this.cfg.getUserId();
+		if (!userId || !this.store.available()) return null;
+		if (trigger !== "manual" && this.connection.isOffline()) return null;
+		this._syncing.set(true);
+		const result = {
+			synced: 0,
+			failed: 0,
+			conflicts: 0,
+			blockedByAuth: false
+		};
+		let attempted = 0;
+		let changed = false;
+		try {
+			const all = await this.store.list(userId);
+			const rows = onlyId ? all.filter((r) => r.id === onlyId) : all;
+			const idMap = /* @__PURE__ */ new Map();
+			for (const e of await this.store.listIdMap(userId)) idMap.set(e.tempId, e);
+			const createsByTemp = /* @__PURE__ */ new Map();
+			for (const r of all) if (r.tempId) createsByTemp.set(r.tempId, r);
+			const blocked = /* @__PURE__ */ new Set();
+			const entityOf = (r) => r.entityType && r.entityId ? `${r.entityType}::${r.entityId}` : null;
+			if (!onlyId) for (const r of rows) {
+				const k = entityOf(r);
+				if (k && (r.status === "failed" || r.status === "conflict")) blocked.add(k);
+			}
+			for (const row of rows) {
+				if (this.cfg.getUserId() !== userId) break;
+				const ek = entityOf(row);
+				if (!onlyId) {
+					if (row.status === "failed" || row.status === "conflict") continue;
+					if (ek && blocked.has(ek)) continue;
+					if (row.status === "pending" && row.nextAttemptAt !== void 0 && row.nextAttemptAt > Date.now() && trigger !== "manual") {
+						if (ek) blocked.add(ek);
+						continue;
+					}
+				}
+				const dependency = await this.checkDependencies(row, userId, idMap, createsByTemp);
+				if (dependency === "hold") {
+					if (ek) blocked.add(ek);
+					continue;
+				}
+				const claimed = await this.store.claim(row.id, this.owner);
+				if (!claimed) {
+					if (ek) blocked.add(ek);
+					continue;
+				}
+				if (this.cfg.getUserId() !== userId) {
+					await this.store.update(claimed.id, {
+						status: "pending",
+						claimOwner: void 0,
+						claimAt: void 0
+					}, { ifOwner: this.owner });
+					break;
+				}
+				attempted++;
+				const outcome = dependency === "fail" ? { action: "dependency" } : await this.send(claimed, idMap);
+				const stop = await this.apply(claimed, outcome, result, idMap);
+				if (outcome.action === "ok") changed = true;
+				if (outcome.action !== "ok" && ek) blocked.add(ek);
+				if (stop) break;
+			}
+		} finally {
+			this._syncing.set(false);
+		}
+		await this.refreshCounts();
+		if (result.synced > 0 && !result.blockedByAuth) this._authBlocked.set(false);
+		if (attempted > 0) {
+			this._lastResult.set(result);
+			if (result.synced + result.failed + result.conflicts > 0) this._lastSyncAt.set(Date.now());
+		}
+		if (changed) this._syncTick.update((n) => n + 1);
+		this.announce(result);
+		if (attempted > 0) this.runCompleted$.next({
+			trigger,
+			result,
+			changed
+		});
+		return result;
+	}
+	async checkDependencies(row, userId, idMap, createsByTemp) {
+		const deps = /* @__PURE__ */ new Map();
+		(row.dependsOn ?? []).forEach((rowId, i) => {
+			const tempId = row.dependsOnTempIds?.[i] ?? [...createsByTemp.values()].find((c) => c.id === rowId)?.tempId;
+			deps.set(tempId ?? `\u0000${rowId}`, rowId);
+		});
+		for (const t of findTempIds(row.url, row.body, createsByTemp)) if (t !== row.tempId && !deps.has(t)) deps.set(t, createsByTemp.get(t)?.id);
+		let hold = false;
+		for (const [tempId, creatorId] of deps) {
+			if (idMap.has(tempId)) continue;
+			let creator = creatorId ? await this.store.get(creatorId) : null;
+			if (creator && creator.userId !== userId) creator = null;
+			if (creator) {
+				if (creator.status === "pending" || creator.status === "syncing") hold = true;
+				else return "fail";
+				continue;
+			}
+			const late = await this.store.getIdMapping(userId, tempId);
+			if (late) {
+				idMap.set(tempId, late);
+				continue;
+			}
+			return "fail";
+		}
+		return hold ? "hold" : "ok";
+	}
+	async send(row, idMap) {
+		try {
+			const real = /* @__PURE__ */ new Map();
+			for (const [tempId, e] of idMap) real.set(tempId, e.numeric && String(Number(e.realId)) === e.realId ? Number(e.realId) : e.realId);
+			const target = rewriteTempIds(row.url, row.body, real);
+			const response = await firstValueFrom(this.http.request(row.method, target.url, {
+				body: target.body,
+				headers: {
+					...row.headers ?? {},
+					[IDEMPOTENCY_HEADER]: row.key,
+					[OFFLINE_REPLAY_HEADER]: "1"
+				},
+				observe: "response",
+				responseType: "text"
+			}));
+			return {
+				action: "ok",
+				text: typeof response.body === "string" ? response.body : void 0
+			};
+		} catch (err) {
+			return classifyReplay(err);
+		}
+	}
+	async apply(row, outcome, result, idMap) {
+		const owner = { ifOwner: this.owner };
+		const release = {
+			claimOwner: void 0,
+			claimAt: void 0
+		};
+		const err = (kind, status, key) => ({
+			kind,
+			...status !== void 0 ? { status } : {},
+			message: this.labels.t(key)
+		});
+		switch (outcome.action) {
+			case "ok":
+				try {
+					if (row.tempId) {
+						const real = this.readCreatedId(row, outcome.text);
+						if (real !== void 0) idMap.set(row.tempId, await this.store.putIdMapping(row.userId, row.tempId, real));
+					}
+					await this.store.delete(row.id, owner);
+				} catch {
+					await this.store.update(row.id, {
+						status: "pending",
+						...release
+					}, owner).catch(() => null);
+					return true;
+				}
+				result.synced++;
+				this._authBlocked.set(false);
+				return false;
+			case "dependency":
+				await this.store.update(row.id, {
+					status: "failed",
+					...release,
+					nextAttemptAt: void 0,
+					lastError: err("dependency", void 0, "connection.error.dependency")
+				}, owner);
+				result.failed++;
+				return false;
+			case "conflict":
+				await this.store.update(row.id, {
+					status: "conflict",
+					...release,
+					attempts: row.attempts + 1,
+					lastError: err("conflict", outcome.status, "connection.error.conflict")
+				}, owner);
+				result.conflicts++;
+				return false;
+			case "rejected":
+				await this.store.update(row.id, {
+					status: "failed",
+					...release,
+					attempts: row.attempts + 1,
+					lastError: err("rejected", outcome.status, "connection.error.rejected")
+				}, owner);
+				result.failed++;
+				return false;
+			case "auth":
+				await this.store.update(row.id, {
+					status: "pending",
+					...release,
+					lastError: err("auth", outcome.status, "connection.authBlocked")
+				}, owner);
+				this._authBlocked.set(true);
+				result.blockedByAuth = true;
+				return true;
+			case "retry": {
+				const message = outcome.kind === "network" ? "connection.error.network" : outcome.kind === "timeout" ? "connection.error.timeout" : "connection.error.server";
+				const lastError = err(outcome.kind, outcome.status || void 0, message);
+				if (outcome.status === 0 && this.connection.isOffline()) {
+					await this.store.update(row.id, {
+						status: "pending",
+						...release,
+						lastError
+					}, owner);
+					return true;
+				}
+				const attempts = row.attempts + 1;
+				if (attempts >= this.cfg.maxAttempts) {
+					await this.store.update(row.id, {
+						status: "failed",
+						...release,
+						attempts,
+						nextAttemptAt: void 0,
+						lastError
+					}, owner);
+					result.failed++;
+				} else await this.store.update(row.id, {
+					status: "pending",
+					...release,
+					attempts,
+					nextAttemptAt: Date.now() + backoffMs(attempts),
+					lastError
+				}, owner);
+				return outcome.kind !== "server";
+			}
+		}
+	}
+	readCreatedId(row, text) {
+		let body;
+		try {
+			body = text ? JSON.parse(text) : void 0;
+		} catch {
+			body = void 0;
+		}
+		return this.cfg.createdId(body, row);
+	}
+	announce(result) {
+		const attention = result.failed + result.conflicts;
+		if (attention > 0) this.toast.warning(this.labels.t(attention === 1 ? "connection.needAttention.one" : "connection.needAttention.other", { count: attention }));
+		else if (result.synced > 0 && !result.blockedByAuth) this.toast.success(this.labels.t("connection.synced"));
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: OfflineReplayer,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: OfflineReplayer,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: OfflineReplayer,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+const REQUEST_TIMEOUT_MS = new HttpContextToken(() => null);
+const idempotencyInterceptor = (req, next) => {
+	const raw = inject(OFFLINE_SUPPORT_CONFIG, { optional: true });
+	if (!raw) return next(req);
+	const cfg = resolveConfigCached(raw);
+	if (!isMutationMethod(req.method)) return next(req);
+	if (req.headers.has("X-Offline-Replay")) return next(req);
+	if (!isInScope(req.url, cfg)) return next(req);
+	if (typeof FormData !== "undefined" && req.body instanceof FormData) return next(req);
+	if (req.headers.has("Idempotency-Key")) return next(req);
+	return next(req.clone({ setHeaders: { [IDEMPOTENCY_HEADER]: generateUuid() } }));
+};
+const READ_RETRY_DELAY_MS = 1e3;
+function isNetworkFailure(err) {
+	return isRequestTimeoutError(err) || err instanceof HttpErrorResponse && err.status === 0;
+}
+const connectionInterceptor = (req, next) => {
+	const raw = inject(OFFLINE_SUPPORT_CONFIG, { optional: true });
+	if (!raw) return next(req);
+	const cfg = resolveConfigCached(raw);
+	if (!isInScope(req.url, cfg)) return next(req);
+	const connection = inject(ConnectionStateService);
+	const labels = inject(UiLabelsService);
+	const method = req.method.toUpperCase();
+	const isRead = method === "GET" || method === "HEAD" || method === "OPTIONS";
+	const long = req.responseType === "blob" || req.responseType === "arraybuffer" || req.reportProgress || typeof FormData !== "undefined" && req.body instanceof FormData || matchesAny(req.url, cfg.longRequests);
+	const override = req.context.get(REQUEST_TIMEOUT_MS);
+	const timeoutMs = override !== null && override !== void 0 ? override : long ? cfg.timeouts.long : isRead ? cfg.timeouts.read : cfg.timeouts.write;
+	const outgoing = req.headers.has("X-Offline-Replay") ? req.clone({ headers: req.headers.delete(OFFLINE_REPLAY_HEADER) }) : req;
+	const attempt = () => defer(() => {
+		const end = connection.beginRequest({ long });
+		const started = Date.now();
+		let outcome = null;
+		let stream = next(outgoing);
+		if (timeoutMs > 0) stream = stream.pipe(timeout({
+			each: timeoutMs,
+			with: () => throwError(() => new RequestTimeoutError(labels.t(isRead ? "connection.timeout.read" : "connection.timeout.write"), method, req.urlWithParams, !isRead))
+		}));
+		return stream.pipe(tap({
+			next: (ev) => {
+				if (ev instanceof HttpResponse) outcome = {
+					status: ev.status,
+					ok: ev.ok,
+					timedOut: false
+				};
+			},
+			error: (err) => {
+				if (isRequestTimeoutError(err)) outcome = {
+					status: 0,
+					ok: false,
+					timedOut: true
+				};
+				else if (err instanceof HttpErrorResponse) outcome = {
+					status: err.status,
+					ok: false,
+					timedOut: false
+				};
+			}
+		}), finalize(() => {
+			end();
+			if (outcome) connection.recordRequest({
+				durationMs: Math.max(0, Date.now() - started),
+				ok: outcome.ok,
+				status: outcome.status,
+				timedOut: outcome.timedOut,
+				method,
+				long
+			});
+		}));
+	});
+	if (!isRead || long) return attempt();
+	return attempt().pipe(retry({
+		count: 1,
+		delay: (err) => isNetworkFailure(err) && connection.state() !== "offline" ? timer(READ_RETRY_DELAY_MS) : throwError(() => err)
+	}));
+};
+function createChannel(name) {
+	try {
+		return typeof BroadcastChannel === "function" ? new BroadcastChannel(name) : null;
+	} catch {
+		return null;
+	}
+}
+var OfflineSupportService = class OfflineSupportService {
+	constructor() {
+		this.cfg = resolveConfig(inject(OFFLINE_SUPPORT_CONFIG, { optional: true }) ?? { getUserId: () => null });
+		this.store = inject(OfflineStore);
+		this.replayer = inject(OfflineReplayer);
+		this.connection = inject(ConnectionStateService);
+		this.stale = inject(StaleDataService);
+		this.toast = inject(ToastService);
+		this.labels = inject(UiLabelsService);
+		this.doc = inject(DOCUMENT);
+		this.destroyRef = inject(DestroyRef);
+		this._rows = signal([], ...ngDevMode ? [{ debugName: "_rows" }] : /* istanbul ignore next */ []);
+		this._lastQueued = signal(null, ...ngDevMode ? [{ debugName: "_lastQueued" }] : /* istanbul ignore next */ []);
+		this._storageAvailable = signal(true, ...ngDevMode ? [{ debugName: "_storageAvailable" }] : /* istanbul ignore next */ []);
+		this.pendingCount = this.replayer.pendingCount;
+		this.failedCount = this.replayer.failedCount;
+		this.conflictCount = this.replayer.conflictCount;
+		this.syncing = this.replayer.syncing;
+		this.lastSyncAt = this.replayer.lastSyncAt;
+		this.syncTick = this.replayer.syncTick;
+		this.authBlocked = this.replayer.authBlocked;
+		this.lastResult = this.replayer.lastResult;
+		this.rows = this._rows.asReadonly();
+		this.lastQueued = this._lastQueued.asReadonly();
+		this.storageAvailable = this._storageAvailable.asReadonly();
+		this.started = false;
+		this.channel = null;
+		this.refreshing = null;
+		this.dirty = false;
+		this.lastKnownUserId = null;
+		this.cleanups = [];
+		this.retryTimer = null;
+		this.destroyed = false;
+	}
+	async start() {
+		if (this.started) return;
+		this.started = true;
+		await this.store.init();
+		this._storageAvailable.set(this.store.available());
+		this.channel = createChannel(`forgeroute-offline:${this.cfg.dbName}`);
+		if (this.channel) {
+			const channel = this.channel;
+			channel.onmessage = (ev) => this.onRemote(ev.data);
+			this.cleanups.push(() => {
+				channel.onmessage = null;
+				channel.close();
+			});
+		}
+		const win = this.doc.defaultView;
+		if (win) {
+			const poll = () => {
+				if (this.doc.visibilityState !== "hidden") this.refresh();
+			};
+			win.addEventListener("focus", poll);
+			this.doc.addEventListener("visibilitychange", poll);
+			this.cleanups.push(() => {
+				win.removeEventListener("focus", poll);
+				this.doc.removeEventListener("visibilitychange", poll);
+			});
+		}
+		const subs = [
+			this.connection.recovered$.subscribe((trigger) => this.replay(trigger)),
+			this.store.mutated$.subscribe(() => {
+				this.refresh();
+				this.post({ type: "changed" });
+			}),
+			this.replayer.runCompleted$.subscribe(({ changed }) => {
+				if (changed) this.post({ type: "synced" });
+			}),
+			this.replayer.runCompleted$.subscribe(() => {
+				this.refresh();
+			})
+		];
+		this.cleanups.push(() => subs.forEach((s) => s.unsubscribe()));
+		this.destroyRef.onDestroy(() => {
+			this.destroyed = true;
+			this.clearRetryTimer();
+			this.cleanups.forEach((c) => c());
+			this.cleanups = [];
+			this.channel = null;
+		});
+		await this.refresh();
+		if (this.connection.isOnline() && this.cfg.getUserId()) this.replay("start");
+	}
+	replay(trigger) {
+		this.replayer.replayAll(trigger).catch(() => void 0);
+	}
+	clearRetryTimer() {
+		if (this.retryTimer) {
+			clearTimeout(this.retryTimer);
+			this.retryTimer = null;
+		}
+	}
+	scheduleRetry() {
+		this.clearRetryTimer();
+		if (this.destroyed) return;
+		let earliest = null;
+		for (const r of this._rows()) if (r.status === "pending" && r.nextAttemptAt !== void 0 && (earliest === null || r.nextAttemptAt < earliest)) earliest = r.nextAttemptAt;
+		if (earliest === null) return;
+		this.retryTimer = setTimeout(() => {
+			this.retryTimer = null;
+			if (this.cfg.getUserId() && this.connection.isOnline()) this.replay("online");
+		}, Math.max(0, earliest - Date.now()) + 50);
+	}
+	post(msg) {
+		try {
+			this.channel?.postMessage(msg);
+		} catch {}
+	}
+	onRemote(msg) {
+		if (!msg) return;
+		if (msg.type === "synced") this.replayer.noteRemoteSync();
+		this.refresh();
+	}
+	onQueued(row) {
+		this.lastKnownUserId = row.userId;
+		this._lastQueued.set({
+			label: row.label,
+			at: Date.now()
+		});
+		this.toast.info(this.labels.t("connection.savedOnDevice"));
+		this.refresh();
+	}
+	refresh() {
+		if (this.refreshing) {
+			this.dirty = true;
+			return this.refreshing;
+		}
+		const p = this.doRefresh().finally(() => {
+			this.refreshing = null;
+		});
+		this.refreshing = p;
+		return p;
+	}
+	async doRefresh() {
+		do {
+			this.dirty = false;
+			const userId = this.cfg.getUserId();
+			if (!userId) this._rows.set([]);
+			else {
+				this.lastKnownUserId = userId;
+				await this.store.init();
+				const rows = await this.store.list(userId);
+				if (this.cfg.getUserId() !== userId) {
+					this.dirty = true;
+					continue;
+				}
+				this._rows.set(rows);
+			}
+			await this.replayer.refreshCounts();
+		} while (this.dirty);
+		this.scheduleRetry();
+	}
+	async syncNow() {
+		const result = await this.replayer.replayAll("manual");
+		await this.refresh();
+		return result;
+	}
+	async retry(id) {
+		await this.replayer.retryOne(id);
+		await this.refresh();
+	}
+	async discard(id) {
+		await this.replayer.discard(id);
+		await this.refresh();
+	}
+	async discardAll() {
+		await this.replayer.discardAll();
+		await this.refresh();
+	}
+	async beforeSessionEnd() {
+		const userId = this.cfg.getUserId() ?? this.lastKnownUserId;
+		if (!userId) return {
+			pending: 0,
+			failed: 0
+		};
+		await this.store.init();
+		if (!this.store.available()) return {
+			pending: 0,
+			failed: 0
+		};
+		const c = await this.store.countsByStatus(userId);
+		return {
+			pending: c.pending + c.syncing,
+			failed: c.failed + c.conflict
+		};
+	}
+	async onSessionStart(userId) {
+		this.lastKnownUserId = userId;
+		this.replayer.resetView();
+		this._lastQueued.set(null);
+		this.stale.clear();
+		await this.refresh();
+		if (this.cfg.getUserId() === userId) this.replay("start");
+	}
+	ensureScope() {
+		const current = this.cfg.getUserId();
+		if (current === this.lastKnownUserId) return;
+		if (this.lastKnownUserId === null) {
+			this.lastKnownUserId = current;
+			this.refresh();
+			return;
+		}
+		this.replayer.resetView();
+		this._rows.set([]);
+		this._lastQueued.set(null);
+		this.stale.clear();
+		this.lastKnownUserId = current;
+		this.refresh();
+	}
+	async endSession(options) {
+		const userId = options.userId ?? this.lastKnownUserId ?? this.cfg.getUserId();
+		if (options.discardPending && userId) await this.store.clearUser(userId);
+		this._rows.set([]);
+		this._lastQueued.set(null);
+		this.replayer.resetView();
+		this.stale.clear();
+	}
+	async clearAll(options = {}) {
+		if (options.discardPending) await this.store.clearAll();
+		else await this.store.clearCache();
+		this._rows.set([]);
+		this._lastQueued.set(null);
+		this.replayer.resetView();
+		this.stale.clear();
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: OfflineSupportService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: OfflineSupportService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: OfflineSupportService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+const FORM_CONTENT_TYPE = "application/x-www-form-urlencoded;charset=UTF-8";
+const NEVER_STORED_HEADERS = [
+	"authorization",
+	"cookie",
+	"proxy-authorization"
+];
+function isUploadBody(body) {
+	return typeof FormData !== "undefined" && body instanceof FormData || typeof Blob !== "undefined" && body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+function isFormBody(body) {
+	return body instanceof HttpParams || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams;
+}
+function storableBody(body) {
+	if (body === null || body === void 0) return {
+		ok: true,
+		value: null
+	};
+	if (isFormBody(body)) return {
+		ok: true,
+		value: body.toString()
+	};
+	if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") return {
+		ok: true,
+		value: body
+	};
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(JSON.stringify(body))
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+function defaultLabel(labels, method, url) {
+	const key = method === "POST" ? "connection.defaultLabel.add" : method === "DELETE" ? "connection.defaultLabel.delete" : "connection.defaultLabel.update";
+	const segments = pathOnly(url).split("/").filter(Boolean);
+	const entity = deriveEntity(url).entityType ?? segments[segments.length - 1] ?? labels.t("connection.entityFallback");
+	return labels.t(key, { entity });
+}
+function findRule(rules, req) {
+	const target = pathAndQuery(req.urlWithParams);
+	const method = req.method.toUpperCase();
+	return rules.find((r) => {
+		r.pattern.lastIndex = 0;
+		const hit = r.pattern.test(target);
+		r.pattern.lastIndex = 0;
+		return hit && r.methods.some((m) => m.toUpperCase() === method);
+	});
+}
+function safeHeaders(req, cfg, formBody) {
+	const out = {};
+	const contentType = req.headers.get("Content-Type");
+	if (contentType && !/^application\/json/i.test(contentType)) out["Content-Type"] = contentType;
+	else if (formBody) out["Content-Type"] = FORM_CONTENT_TYPE;
+	for (const name of cfg.replayHeaders) {
+		if (NEVER_STORED_HEADERS.includes(name.toLowerCase())) continue;
+		const value = req.headers.get(name);
+		if (value !== null) out[name] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+const offlineInterceptor = (req, next) => {
+	const raw = inject(OFFLINE_SUPPORT_CONFIG, { optional: true });
+	if (!raw) return next(req);
+	const cfg = resolveConfigCached(raw);
+	if (req.headers.has("X-Offline-Replay") || !isInScope(req.url, cfg)) return next(req);
+	inject(OfflineSupportService).ensureScope();
+	if (req.method === "GET") return handleRead(req, next, cfg);
+	if (isMutationMethod(req.method)) return handleWrite(req, next, cfg);
+	return next(req);
+};
+function cachedResponse(req, data, cachedAt) {
+	return new HttpResponse({
+		body: data,
+		status: 200,
+		statusText: "OK",
+		url: req.urlWithParams,
+		headers: new HttpHeaders({ [FROM_CACHE_HEADER]: String(cachedAt) })
+	});
+}
+function handleRead(req, next, cfg) {
+	const userId = cfg.getUserId();
+	if (userId === null || req.responseType !== "json" || matchesAny(req.url, cfg.neverCache)) return next(req);
+	const connection = inject(ConnectionStateService);
+	const store = inject(OfflineStore);
+	const stale = inject(StaleDataService);
+	const key = pathAndQuery(req.urlWithParams);
+	const ttl = cfg.cacheTtl ? cfg.cacheTtl(req.url) : lastSegmentIsId(req.url) ? DEFAULT_DETAIL_TTL_MS : DEFAULT_LIST_TTL_MS;
+	const live = () => next(req).pipe(tap((ev) => {
+		if (!(ev instanceof HttpResponse) || ev.status !== 200) return;
+		stale.clearKey(key);
+		if (!(ev.headers.get("Cache-Control") ?? "").toLowerCase().includes("no-store") && ev.body !== null && ev.body !== void 0) store.cacheResponse(key, userId, ev.body, ttl).catch(() => void 0);
+	}));
+	const serveCopyOr = (otherwise) => from(store.getCached(key, userId)).pipe(switchMap((entry) => {
+		if (!entry) return otherwise();
+		stale.markStale(entry.cachedAt, key);
+		return of(cachedResponse(req, entry.data, entry.cachedAt));
+	}));
+	if (connection.isOffline()) return serveCopyOr(() => connection.state() === "unreachable" ? live() : throwError(() => new HttpErrorResponse({
+		url: req.urlWithParams,
+		status: 0,
+		statusText: "Offline",
+		error: uiText("connection.noCopy")
+	})));
+	return live().pipe(catchError((err) => isNetworkFailure(err) ? serveCopyOr(() => throwError(() => err)) : throwError(() => err)));
+}
+function handleWrite(req, next, cfg) {
+	const connection = inject(ConnectionStateService);
+	const userId = cfg.getUserId();
+	if (!connection.isOffline() || userId === null) {
+		if (userId === null) return next(req);
+		const store = inject(OfflineStore);
+		return next(req).pipe(tap((ev) => {
+			if (ev instanceof HttpResponse && ev.ok) store.invalidatePrefix(invalidationPrefix(req.url), userId).catch(() => void 0);
+		}));
+	}
+	const labels = inject(UiLabelsService);
+	const block = cfg.blockOffline.find((b) => matchesUrl(req.urlWithParams, b.pattern));
+	if (block) return throwError(() => new OfflineBlockedError(block.message ?? labels.t("connection.blocked", { action: labels.t("connection.thisAction") }), "blocked"));
+	if (isUploadBody(req.body)) return throwError(() => new OfflineBlockedError(labels.t("connection.uploadBlocked"), "upload"));
+	let rule;
+	if (cfg.allowQueue) {
+		rule = findRule(cfg.allowQueue, req);
+		if (!rule) return throwError(() => new OfflineBlockedError(labels.t("connection.blocked", { action: labels.t("connection.thisAction") }), "not-allowed"));
+	}
+	const body = storableBody(req.body);
+	if (!body.ok) return throwError(() => new OfflineBlockedError(labels.t("connection.storageUnavailable"), "storage"));
+	const store = inject(OfflineStore);
+	const support = inject(OfflineSupportService);
+	const method = req.method.toUpperCase();
+	const url = req.urlWithParams;
+	const derived = deriveEntity(url);
+	const row = {
+		id: generateUuid(),
+		userId,
+		key: req.headers.get("Idempotency-Key") ?? generateUuid(),
+		method,
+		url,
+		body: body.value,
+		headers: safeHeaders(req, cfg, isFormBody(req.body)),
+		label: rule?.label?.(method, url, req.body) ?? defaultLabel(labels, method, url),
+		entityType: rule?.entityType?.(url) ?? derived.entityType,
+		entityId: derived.entityId,
+		createdAt: Date.now(),
+		status: "pending",
+		attempts: 0
+	};
+	const tempId = isTempIdCreate(method, url, body.value) ? row.id : void 0;
+	return from(store.list(userId).catch(() => [])).pipe(switchMap((existing) => {
+		const creates = /* @__PURE__ */ new Map();
+		for (const r of existing) if (r.tempId) creates.set(r.tempId, r.id);
+		const refs = findTempIds(url, body.value, creates);
+		return store.addMutation({
+			...row,
+			...tempId ? { tempId } : {},
+			...refs.length > 0 ? {
+				dependsOn: refs.map((t) => creates.get(t)),
+				dependsOnTempIds: refs
+			} : {}
+		});
+	}), catchError(() => throwError(() => new OfflineBlockedError(labels.t("connection.storageUnavailable"), "storage"))), switchMap((saved) => {
+		if (saved.status === "failed" || saved.status === "conflict") return throwError(() => new OfflineBlockedError(labels.t("connection.blocked", { action: labels.t("connection.thisAction") }), "not-allowed"));
+		support.onQueued(saved);
+		return of(saved);
+	}), switchMap((saved) => {
+		const base = body.value !== null && typeof body.value === "object" && !Array.isArray(body.value) ? body.value : {};
+		return of(new HttpResponse({
+			status: 202,
+			statusText: "Accepted",
+			url,
+			body: {
+				...base,
+				id: base["id"] ?? saved.tempId ?? saved.id,
+				_offline: true
+			}
+		}));
+	}));
+}
+const offlineHttpInterceptors = [
+	idempotencyInterceptor,
+	offlineInterceptor,
+	connectionInterceptor
+];
+function provideOfflineSupport(config) {
+	return makeEnvironmentProviders([{
+		provide: OFFLINE_SUPPORT_CONFIG,
+		useValue: config
+	}, provideAppInitializer(() => {
+		const store = inject(OfflineStore);
+		const support = inject(OfflineSupportService);
+		inject(ConnectionStateService);
+		return store.init().then(() => {
+			support.start().catch(() => void 0);
+		});
+	})]);
+}
+const SYNCED_FLASH_MS = 3e3;
+let nextId = 0;
+var ConnectionBannerComponent = class ConnectionBannerComponent {
+	count(base, n) {
+		return this.labels.t(`${base}.${n === 1 ? "one" : "other"}`, { count: n });
+	}
+	constructor() {
+		this.labels = inject(UiLabelsService);
+		this.connection = inject(ConnectionStateService);
+		this.support = inject(OfflineSupportService);
+		this.cdr = inject(ChangeDetectorRef);
+		this.infoOffline = input(null, ...ngDevMode ? [{ debugName: "infoOffline" }] : /* istanbul ignore next */ []);
+		this.infoNeedsConnection = input(null, ...ngDevMode ? [{ debugName: "infoNeedsConnection" }] : /* istanbul ignore next */ []);
+		this.viewChanges = output();
+		this.panelId = `ui-cb-info-${++nextId}`;
+		this.infoOpen = signal(false, ...ngDevMode ? [{ debugName: "infoOpen" }] : /* istanbul ignore next */ []);
+		this.infoToggleRef = viewChild("infoToggle", ...ngDevMode ? [{ debugName: "infoToggleRef" }] : /* istanbul ignore next */ []);
+		this.infoHideRef = viewChild("infoHide", ...ngDevMode ? [{ debugName: "infoHideRef" }] : /* istanbul ignore next */ []);
+		this.syncTotal = signal(0, ...ngDevMode ? [{ debugName: "syncTotal" }] : /* istanbul ignore next */ []);
+		this.showSynced = signal(false, ...ngDevMode ? [{ debugName: "showSynced" }] : /* istanbul ignore next */ []);
+		this.syncedTimer = null;
+		this.seenTick = this.support.syncTick();
+		this.flashPending = false;
+		this.wasSyncing = false;
+		this.canDoItems = computed(() => this.infoOffline() ?? [this.labels.t("connection.info.canDo1"), this.labels.t("connection.info.canDo2")], ...ngDevMode ? [{ debugName: "canDoItems" }] : /* istanbul ignore next */ []);
+		this.needsItems = computed(() => this.infoNeedsConnection() ?? [this.labels.t("connection.info.needs1")], ...ngDevMode ? [{ debugName: "needsItems" }] : /* istanbul ignore next */ []);
+		this.view = computed(() => {
+			const state = this.connection.state();
+			const pending = this.support.pendingCount();
+			const attention = this.support.failedCount() + this.support.conflictCount();
+			const l = this.labels;
+			let v = null;
+			if (this.support.authBlocked()) v = {
+				kind: "auth",
+				title: l.t("connection.authBlocked"),
+				message: "",
+				detail: ""
+			};
+			else if (state === "offline") v = {
+				kind: "offline",
+				title: l.t("connection.offline.title"),
+				message: l.t("connection.offline.message"),
+				detail: pending > 0 ? this.count("connection.pending", pending) : ""
+			};
+			else if (state === "unreachable") v = {
+				kind: "unreachable",
+				title: l.t("connection.unreachable.title"),
+				message: l.t("connection.unreachable.message"),
+				detail: pending > 0 ? this.count("connection.pending", pending) : ""
+			};
+			else if (this.support.syncing() && Math.max(this.syncTotal(), pending) > 0) v = {
+				kind: "syncing",
+				title: this.count("connection.syncing", Math.max(this.syncTotal(), pending)),
+				message: "",
+				detail: ""
+			};
+			else if (attention > 0) v = {
+				kind: "attention",
+				title: this.count("connection.needAttention", attention),
+				message: "",
+				detail: ""
+			};
+			else if (state === "slow") v = {
+				kind: "slow",
+				title: l.t("connection.slow.title"),
+				message: l.t("connection.slow.message"),
+				detail: ""
+			};
+			else if (this.showSynced()) v = {
+				kind: "synced",
+				title: l.t("connection.synced"),
+				message: "",
+				detail: ""
+			};
+			if (!v) return null;
+			const sentence = (s) => /[.…!?]$/.test(s) ? s : s + ".";
+			return {
+				...v,
+				announcement: [
+					v.title,
+					v.message,
+					v.detail
+				].filter(Boolean).map(sentence).join(" ")
+			};
+		}, ...ngDevMode ? [{ debugName: "view" }] : /* istanbul ignore next */ []);
+		this.actionFailure = signal("", ...ngDevMode ? [{ debugName: "actionFailure" }] : /* istanbul ignore next */ []);
+		this.politeText = computed(() => {
+			const v = this.view();
+			return [v && v.kind !== "auth" ? v.announcement : "", this.actionFailure()].filter(Boolean).join(" ");
+		}, ...ngDevMode ? [{ debugName: "politeText" }] : /* istanbul ignore next */ []);
+		this.alertText = computed(() => {
+			const v = this.view();
+			return v && v.kind === "auth" ? v.announcement : "";
+		}, ...ngDevMode ? [{ debugName: "alertText" }] : /* istanbul ignore next */ []);
+		this.infoAllowed = computed(() => {
+			const k = this.view()?.kind;
+			return k === "offline" || k === "unreachable";
+		}, ...ngDevMode ? [{ debugName: "infoAllowed" }] : /* istanbul ignore next */ []);
+		this.showSyncNow = computed(() => {
+			const k = this.view()?.kind;
+			return (k === "unreachable" || k === "slow" || k === "attention") && this.support.pendingCount() > 0 && !this.support.syncing();
+		}, ...ngDevMode ? [{ debugName: "showSyncNow" }] : /* istanbul ignore next */ []);
+		this.showView = computed(() => {
+			const k = this.view()?.kind;
+			if (!k || k === "synced") return false;
+			return this.rowsTotal() > 0 || k === "auth";
+		}, ...ngDevMode ? [{ debugName: "showView" }] : /* istanbul ignore next */ []);
+		this.rowsTotal = computed(() => this.support.pendingCount() + this.support.failedCount() + this.support.conflictCount(), ...ngDevMode ? [{ debugName: "rowsTotal" }] : /* istanbul ignore next */ []);
+		effect(() => {
+			const syncing = this.support.syncing();
+			const tick = this.support.syncTick();
+			untracked(() => {
+				if (tick !== this.seenTick) {
+					this.seenTick = tick;
+					this.flashPending = true;
+				}
+				if (syncing && !this.wasSyncing) this.syncTotal.set(Math.max(this.support.pendingCount(), 0));
+				if (!syncing) this.syncTotal.set(0);
+				this.wasSyncing = syncing;
+				if (!syncing && this.flashPending) {
+					this.flashPending = false;
+					this.flashSynced();
+				}
+			});
+		});
+		effect(() => {
+			if (!this.infoAllowed()) this.infoOpen.set(false);
+		});
+		inject(DestroyRef).onDestroy(() => {
+			if (this.syncedTimer) clearTimeout(this.syncedTimer);
+		});
+	}
+	flashSynced() {
+		if (this.syncedTimer) clearTimeout(this.syncedTimer);
+		this.showSynced.set(true);
+		this.syncedTimer = setTimeout(() => {
+			this.syncedTimer = null;
+			this.showSynced.set(false);
+		}, SYNCED_FLASH_MS);
+	}
+	syncNow() {
+		this.actionFailure.set("");
+		let call;
+		try {
+			call = Promise.resolve(this.support.syncNow());
+		} catch {
+			call = Promise.reject(/* @__PURE__ */ new Error("syncNow"));
+		}
+		call.catch(() => this.actionFailure.set(this.labels.t("connection.error.unknown")));
+	}
+	toggleInfo() {
+		if (this.infoOpen()) {
+			this.closeInfo(true);
+			return;
+		}
+		this.infoOpen.set(true);
+		this.cdr.detectChanges();
+		this.infoHideRef()?.nativeElement.focus();
+	}
+	closeInfo(returnFocus) {
+		this.infoOpen.set(false);
+		this.cdr.detectChanges();
+		if (returnFocus) this.infoToggleRef()?.nativeElement.focus();
+	}
+	onEscape(event) {
+		if (!this.infoOpen()) return;
+		event.stopPropagation();
+		this.closeInfo(true);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: ConnectionBannerComponent,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.0.0",
+			version: "22.2.2",
+			type: ConnectionBannerComponent,
+			isStandalone: true,
+			selector: "ui-connection-banner",
+			inputs: {
+				infoOffline: {
+					classPropertyName: "infoOffline",
+					publicName: "infoOffline",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				infoNeedsConnection: {
+					classPropertyName: "infoNeedsConnection",
+					publicName: "infoNeedsConnection",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				}
+			},
+			outputs: { viewChanges: "viewChanges" },
+			viewQueries: [{
+				propertyName: "infoToggleRef",
+				first: true,
+				predicate: ["infoToggle"],
+				descendants: true,
+				isSignal: true
+			}, {
+				propertyName: "infoHideRef",
+				first: true,
+				predicate: ["infoHide"],
+				descendants: true,
+				isSignal: true
+			}],
+			ngImport: i0,
+			template: `
+    <div class="cb-live" role="status" aria-live="polite" aria-atomic="true" data-testid="connection-banner-live">{{ politeText() }}</div>
+    <div class="cb-live" role="alert" aria-live="assertive" aria-atomic="true" data-testid="connection-banner-live-alert">{{ alertText() }}</div>
+    @if (view(); as v) {
+      <div class="cb-bar" [class]="'cb-bar cb-' + v.kind" role="group" [attr.aria-label]="labels.t('connection.region')"
+           data-testid="connection-banner" [attr.data-state]="v.kind" (keydown.escape)="onEscape($event)">
+        <div class="cb-text">
+          <strong class="cb-title" data-testid="connection-banner-title">{{ v.title }}</strong>
+          @if (v.message) { <span class="cb-msg" data-testid="connection-banner-message"> {{ v.message }}</span> }
+          @if (v.detail) { <span class="cb-detail" data-testid="connection-banner-detail"> {{ v.detail }}</span> }
+        </div>
+        @if (showSyncNow() || showView() || infoAllowed()) {
+          <div class="cb-actions">
+            @if (showSyncNow()) {
+              <button type="button" class="cb-btn" data-testid="connection-banner-sync-now" (click)="syncNow()">{{ labels.t('connection.syncNow') }}</button>
+            }
+            @if (showView()) {
+              <button type="button" class="cb-btn" data-testid="connection-banner-view" (click)="viewChanges.emit()">{{ labels.t('connection.viewChanges') }}</button>
+            }
+            @if (infoAllowed()) {
+              <button #infoToggle type="button" class="cb-btn cb-btn-ghost" data-testid="connection-banner-info-toggle"
+                      [attr.aria-expanded]="infoOpen()" [attr.aria-controls]="panelId" (click)="toggleInfo()">{{ labels.t('connection.whatCanIDo') }}</button>
+            }
+          </div>
+        }
+        @if (infoAllowed() && infoOpen()) {
+          <div class="cb-info" [id]="panelId" role="region" tabindex="-1" [attr.aria-label]="labels.t('connection.info.panelLabel')" data-testid="connection-banner-info-panel">
+            <p class="cb-info-h">{{ labels.t('connection.info.canDoTitle') }}</p>
+            <ul class="cb-list">@for (item of canDoItems(); track $index) { <li>{{ item }}</li> }</ul>
+            <p class="cb-info-h">{{ labels.t('connection.info.needsTitle') }}</p>
+            <ul class="cb-list">@for (item of needsItems(); track $index) { <li>{{ item }}</li> }</ul>
+            <button #infoHide type="button" class="cb-btn" data-testid="connection-banner-info-hide" (click)="closeInfo(true)">{{ labels.t('connection.hide') }}</button>
+          </div>
+        }
+      </div>
+    }
+  `,
+			isInline: true,
+			styles: [":host{display:block;position:-webkit-sticky;position:sticky;top:0;z-index:50}.cb-live{position:absolute;inline-size:1px;block-size:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap}.cb-bar{display:flex;flex-wrap:wrap;align-items:center;gap:8px 16px;padding:10px 16px;font-size:.875rem;line-height:1.4;border-block-end:1px solid;border-inline-start:6px solid;box-sizing:border-box}.cb-text{flex:1 1 280px;min-inline-size:0;overflow-wrap:anywhere}.cb-actions{display:flex;flex-wrap:wrap;gap:8px}.cb-btn{min-block-size:44px;min-inline-size:44px;padding:0 14px;border-radius:8px;border:1px solid currentColor;background:#fff;color:inherit;font:inherit;font-weight:600;cursor:pointer;-webkit-appearance:none;appearance:none}.cb-btn-ghost{background:transparent}.cb-btn:focus{outline:3px solid #1d4ed8;outline-offset:2px}.cb-btn:focus:not(:focus-visible){outline:none}.cb-info{flex:1 1 100%;padding:12px 14px;border-radius:8px;background:#ffffffb3;border:1px solid currentColor}.cb-info:focus{outline:none}.cb-info-h{margin:0 0 4px;font-weight:700}.cb-list{margin:0 0 12px;padding-inline-start:20px}.cb-offline,.cb-slow,.cb-attention{background:#fef3c7;color:#78350f;border-color:#b45309}.cb-unreachable,.cb-auth{background:#fee2e2;color:#7f1d1d;border-color:#b91c1c}.cb-syncing{background:#dbeafe;color:#1e3a8a;border-color:#1d4ed8}.cb-synced{background:#dcfce7;color:#14532d;border-color:#15803d}@media(prefers-reduced-motion:no-preference){.cb-bar{animation:cb-in .16s ease-out}}@keyframes cb-in{0%{opacity:0}to{opacity:1}}@media(max-width:480px){.cb-actions{flex-direction:column;inline-size:100%}.cb-btn{inline-size:100%}}@media(forced-colors:active){.cb-bar,.cb-info{border:2px solid CanvasText;background:Canvas;color:CanvasText}.cb-btn{border-color:ButtonText;background:ButtonFace;color:ButtonText}}\n"],
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: ConnectionBannerComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "ui-connection-banner",
+			standalone: true,
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    <div class="cb-live" role="status" aria-live="polite" aria-atomic="true" data-testid="connection-banner-live">{{ politeText() }}</div>
+    <div class="cb-live" role="alert" aria-live="assertive" aria-atomic="true" data-testid="connection-banner-live-alert">{{ alertText() }}</div>
+    @if (view(); as v) {
+      <div class="cb-bar" [class]="'cb-bar cb-' + v.kind" role="group" [attr.aria-label]="labels.t('connection.region')"
+           data-testid="connection-banner" [attr.data-state]="v.kind" (keydown.escape)="onEscape($event)">
+        <div class="cb-text">
+          <strong class="cb-title" data-testid="connection-banner-title">{{ v.title }}</strong>
+          @if (v.message) { <span class="cb-msg" data-testid="connection-banner-message"> {{ v.message }}</span> }
+          @if (v.detail) { <span class="cb-detail" data-testid="connection-banner-detail"> {{ v.detail }}</span> }
+        </div>
+        @if (showSyncNow() || showView() || infoAllowed()) {
+          <div class="cb-actions">
+            @if (showSyncNow()) {
+              <button type="button" class="cb-btn" data-testid="connection-banner-sync-now" (click)="syncNow()">{{ labels.t('connection.syncNow') }}</button>
+            }
+            @if (showView()) {
+              <button type="button" class="cb-btn" data-testid="connection-banner-view" (click)="viewChanges.emit()">{{ labels.t('connection.viewChanges') }}</button>
+            }
+            @if (infoAllowed()) {
+              <button #infoToggle type="button" class="cb-btn cb-btn-ghost" data-testid="connection-banner-info-toggle"
+                      [attr.aria-expanded]="infoOpen()" [attr.aria-controls]="panelId" (click)="toggleInfo()">{{ labels.t('connection.whatCanIDo') }}</button>
+            }
+          </div>
+        }
+        @if (infoAllowed() && infoOpen()) {
+          <div class="cb-info" [id]="panelId" role="region" tabindex="-1" [attr.aria-label]="labels.t('connection.info.panelLabel')" data-testid="connection-banner-info-panel">
+            <p class="cb-info-h">{{ labels.t('connection.info.canDoTitle') }}</p>
+            <ul class="cb-list">@for (item of canDoItems(); track $index) { <li>{{ item }}</li> }</ul>
+            <p class="cb-info-h">{{ labels.t('connection.info.needsTitle') }}</p>
+            <ul class="cb-list">@for (item of needsItems(); track $index) { <li>{{ item }}</li> }</ul>
+            <button #infoHide type="button" class="cb-btn" data-testid="connection-banner-info-hide" (click)="closeInfo(true)">{{ labels.t('connection.hide') }}</button>
+          </div>
+        }
+      </div>
+    }
+  `,
+			styles: [":host{display:block;position:-webkit-sticky;position:sticky;top:0;z-index:50}.cb-live{position:absolute;inline-size:1px;block-size:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap}.cb-bar{display:flex;flex-wrap:wrap;align-items:center;gap:8px 16px;padding:10px 16px;font-size:.875rem;line-height:1.4;border-block-end:1px solid;border-inline-start:6px solid;box-sizing:border-box}.cb-text{flex:1 1 280px;min-inline-size:0;overflow-wrap:anywhere}.cb-actions{display:flex;flex-wrap:wrap;gap:8px}.cb-btn{min-block-size:44px;min-inline-size:44px;padding:0 14px;border-radius:8px;border:1px solid currentColor;background:#fff;color:inherit;font:inherit;font-weight:600;cursor:pointer;-webkit-appearance:none;appearance:none}.cb-btn-ghost{background:transparent}.cb-btn:focus{outline:3px solid #1d4ed8;outline-offset:2px}.cb-btn:focus:not(:focus-visible){outline:none}.cb-info{flex:1 1 100%;padding:12px 14px;border-radius:8px;background:#ffffffb3;border:1px solid currentColor}.cb-info:focus{outline:none}.cb-info-h{margin:0 0 4px;font-weight:700}.cb-list{margin:0 0 12px;padding-inline-start:20px}.cb-offline,.cb-slow,.cb-attention{background:#fef3c7;color:#78350f;border-color:#b45309}.cb-unreachable,.cb-auth{background:#fee2e2;color:#7f1d1d;border-color:#b91c1c}.cb-syncing{background:#dbeafe;color:#1e3a8a;border-color:#1d4ed8}.cb-synced{background:#dcfce7;color:#14532d;border-color:#15803d}@media(prefers-reduced-motion:no-preference){.cb-bar{animation:cb-in .16s ease-out}}@keyframes cb-in{0%{opacity:0}to{opacity:1}}@media(max-width:480px){.cb-actions{flex-direction:column;inline-size:100%}.cb-btn{inline-size:100%}}@media(forced-colors:active){.cb-bar,.cb-info{border:2px solid CanvasText;background:Canvas;color:CanvasText}.cb-btn{border-color:ButtonText;background:ButtonFace;color:ButtonText}}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		infoOffline: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "infoOffline",
+				required: false
+			}]
+		}],
+		infoNeedsConnection: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "infoNeedsConnection",
+				required: false
+			}]
+		}],
+		viewChanges: [{
+			type: i0.Output,
+			args: ["viewChanges"]
+		}],
+		infoToggleRef: [{
+			type: i0.ViewChild,
+			args: ["infoToggle", { isSignal: true }]
+		}],
+		infoHideRef: [{
+			type: i0.ViewChild,
+			args: ["infoHide", { isSignal: true }]
+		}]
+	}
+});
+function formatRelativeTime(then, now, justNowText, locale) {
+	const diffSec = Math.round((now - then) / 1e3);
+	if (diffSec < 45) return justNowText;
+	const rtfCtor = globalThis.Intl?.RelativeTimeFormat;
+	const minutes = Math.round(diffSec / 60);
+	const hours = Math.round(diffSec / 3600);
+	const days = Math.round(diffSec / 86400);
+	if (rtfCtor) {
+		let rtf;
+		try {
+			rtf = new rtfCtor(locale, { numeric: "auto" });
+		} catch {
+			rtf = new rtfCtor(void 0, { numeric: "auto" });
+		}
+		if (minutes < 60) return rtf.format(-minutes, "minute");
+		if (hours < 24) return rtf.format(-hours, "hour");
+		if (days <= 30) return rtf.format(-days, "day");
+	}
+	return absoluteTime(then, locale);
+}
+function absoluteTime(at, locale) {
+	try {
+		return new Date(at).toLocaleString(locale);
+	} catch {
+		return new Date(at).toLocaleString();
+	}
+}
+function pageLocale(doc, labelsLocale) {
+	if (labelsLocale) return labelsLocale;
+	return doc.documentElement?.lang || void 0;
+}
+const ERROR_KEYS = {
+	conflict: "connection.error.conflict",
+	rejected: "connection.error.rejected",
+	auth: "connection.error.auth",
+	server: "connection.error.server",
+	network: "connection.error.network",
+	timeout: "connection.error.timeout",
+	dependency: "connection.error.dependency"
+};
+var PendingChangesDrawerComponent = class PendingChangesDrawerComponent {
+	constructor() {
+		this.labels = inject(UiLabelsService);
+		this.support = inject(OfflineSupportService);
+		this.confirmService = inject(ConfirmService);
+		this.cdr = inject(ChangeDetectorRef);
+		this.host = inject(ElementRef);
+		this.doc = inject(DOCUMENT);
+		this.open = input(false, ...ngDevMode ? [{ debugName: "open" }] : /* istanbul ignore next */ []);
+		this.closed = output();
+		this.rows = computed(() => this.support.rows(), ...ngDevMode ? [{ debugName: "rows" }] : /* istanbul ignore next */ []);
+		this.announcement = signal("", ...ngDevMode ? [{ debugName: "announcement" }] : /* istanbul ignore next */ []);
+		this.now = signal(Date.now(), ...ngDevMode ? [{ debugName: "now" }] : /* istanbul ignore next */ []);
+		const timer = setInterval(() => this.now.set(Date.now()), 3e4);
+		inject(DestroyRef).onDestroy(() => clearInterval(timer));
+	}
+	statusText(row) {
+		switch (row.status) {
+			case "syncing": return this.labels.t("connection.status.syncing");
+			case "failed": return this.labels.t("connection.status.failed");
+			case "conflict": return this.labels.t("connection.status.conflict");
+			default: return this.labels.t("connection.status.pending");
+		}
+	}
+	errorText(row) {
+		const kind = row.lastError?.kind ?? (row.status === "conflict" ? "conflict" : void 0);
+		if (kind && kind in ERROR_KEYS) return this.labels.t(ERROR_KEYS[kind]);
+		if (row.status === "failed" || row.lastError) return this.labels.t("connection.error.unknown");
+		return "";
+	}
+	canRetry(row) {
+		return row.status === "failed" || row.status === "conflict" || row.status === "pending" && !!row.lastError;
+	}
+	iso(row) {
+		return new Date(row.createdAt).toISOString();
+	}
+	absolute(row) {
+		return absoluteTime(row.createdAt, pageLocale(this.doc, this.labels.locale()));
+	}
+	savedText(row) {
+		const time = formatRelativeTime(row.createdAt, this.now(), this.labels.t("connection.time.justNow"), pageLocale(this.doc, this.labels.locale()));
+		return this.labels.t("connection.savedAt", { time });
+	}
+	async retry(row) {
+		this.announcement.set(this.labels.t("connection.result.retrying", { label: row.label }));
+		try {
+			await this.support.retry(row.id);
+		} catch {
+			this.announceFailure();
+		}
+	}
+	async syncAll() {
+		this.announcement.set(this.labels.t("connection.result.syncStarted"));
+		try {
+			await this.support.syncNow();
+		} catch {
+			this.announceFailure();
+		}
+	}
+	async discard(row) {
+		const index = this.rows().findIndex((r) => r.id === row.id);
+		const all = this.rows();
+		const dependentIds = /* @__PURE__ */ new Set();
+		const pending = [row.id];
+		while (pending.length > 0) {
+			const current = pending.pop();
+			for (const r of all) if (r.id !== row.id && !dependentIds.has(r.id) && (r.dependsOn ?? []).includes(current)) {
+				dependentIds.add(r.id);
+				pending.push(r.id);
+			}
+		}
+		const dependents = dependentIds.size;
+		const message = dependents === 0 ? this.labels.t("connection.discard.message", { label: row.label }) : dependents === 1 ? this.labels.t("connection.discard.dependents.one", { label: row.label }) : this.labels.t("connection.discard.dependents.other", {
+			label: row.label,
+			count: dependents
+		});
+		if (!await this.confirmService.confirm({
+			title: this.labels.t("connection.discard.title"),
+			message,
+			confirmLabel: this.labels.t("connection.discard"),
+			cancelLabel: this.labels.t("toolbar.cancel"),
+			variant: "danger"
+		})) return;
+		try {
+			await this.support.discard(row.id);
+		} catch {
+			this.announceFailure();
+			return;
+		}
+		this.announcement.set(this.labels.t("connection.result.discarded", { label: row.label }));
+		this.cdr.detectChanges();
+		this.focusAfterRemoval(index);
+	}
+	async discardAll() {
+		const count = this.rows().length;
+		if (count === 0) return;
+		if (!await this.confirmService.confirm({
+			title: this.labels.t("connection.discardAll.title"),
+			message: this.labels.t(count === 1 ? "connection.discardAll.message.one" : "connection.discardAll.message.other", { count }),
+			confirmLabel: this.labels.t("connection.discardAll"),
+			cancelLabel: this.labels.t("toolbar.cancel"),
+			variant: "danger"
+		})) return;
+		try {
+			await this.support.discardAll();
+		} catch {
+			this.announceFailure();
+			return;
+		}
+		this.announcement.set(this.labels.t("connection.result.discardedAll"));
+		this.cdr.detectChanges();
+		this.focusAfterRemoval(0);
+	}
+	announceFailure() {
+		this.announcement.set(this.labels.t("connection.error.unknown"));
+	}
+	focusAfterRemoval(index) {
+		const root = this.host.nativeElement;
+		const rowEls = Array.from(root.querySelectorAll("li.pcd-row"));
+		(rowEls[Math.min(index, rowEls.length - 1)]?.querySelector("button:not([disabled])") ?? root.querySelector(".pcd-empty"))?.focus();
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: PendingChangesDrawerComponent,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.0.0",
+			version: "22.2.2",
+			type: PendingChangesDrawerComponent,
+			isStandalone: true,
+			selector: "ui-pending-changes-drawer",
+			inputs: { open: {
+				classPropertyName: "open",
+				publicName: "open",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			outputs: { closed: "closed" },
+			ngImport: i0,
+			template: `
+    <div class="pcd-live" role="status" aria-live="polite" aria-atomic="true" data-testid="pending-drawer-live">{{ announcement() }}</div>
+    <ui-side-panel
+      [open]="open()"
+      [title]="labels.t('connection.drawer.title')"
+      [cancelLabel]="labels.t('connection.drawer.close')"
+      [primaryLabel]="labels.t('connection.syncAll')"
+      [primaryDisabled]="rows().length === 0 || support.syncing()"
+      [primaryLoading]="support.syncing()"
+      primaryTestId="pending-drawer-sync-all"
+      (closed)="closed.emit()"
+      (primaryClick)="syncAll()">
+      @if (support.authBlocked()) {
+        <p class="pcd-auth" data-testid="pending-drawer-auth">{{ labels.t('connection.authBlocked') }}</p>
+      }
+      @if (rows().length === 0) {
+        <p class="pcd-empty" tabindex="-1" data-testid="pending-drawer-empty">{{ support.storageAvailable() ? labels.t('connection.drawer.empty') : labels.t('connection.storageUnavailable') }}</p>
+      } @else {
+        <ul class="pcd-list" [attr.aria-label]="labels.t('connection.drawer.list')" data-testid="pending-drawer-list">
+          @for (row of rows(); track row.id) {
+            <li class="pcd-row" [attr.data-testid]="'pending-row-' + row.id" [attr.data-status]="row.status">
+              <div class="pcd-main">
+                <span class="pcd-label">{{ row.label }}</span>
+                <span class="pcd-status" [attr.data-testid]="'pending-row-status-' + row.id">{{ statusText(row) }}</span>
+              </div>
+              <time class="pcd-time" [attr.datetime]="iso(row)" [attr.title]="absolute(row)" [attr.data-testid]="'pending-row-time-' + row.id">{{ savedText(row) }}</time>
+              @if (errorText(row); as err) {
+                <p class="pcd-error" [attr.data-testid]="'pending-row-error-' + row.id">{{ err }}</p>
+              }
+              <div class="pcd-actions">
+                @if (canRetry(row)) {
+                  <button type="button" class="pcd-btn" [attr.data-testid]="'pending-row-retry-' + row.id"
+                          [attr.aria-label]="labels.t('connection.retryNamed', { label: row.label })" (click)="retry(row)">{{ labels.t('connection.retry') }}</button>
+                }
+                <button type="button" class="pcd-btn pcd-btn-danger" [attr.data-testid]="'pending-row-discard-' + row.id" [disabled]="row.status === 'syncing'"
+                        [attr.aria-label]="labels.t('connection.discardNamed', { label: row.label })" (click)="discard(row)">{{ labels.t('connection.discard') }}</button>
+              </div>
+            </li>
+          }
+        </ul>
+      }
+      <button panel-footer-extra type="button" class="pcd-btn pcd-btn-danger" data-testid="pending-drawer-discard-all"
+              [disabled]="rows().length === 0 || support.syncing()" (click)="discardAll()">{{ labels.t('connection.discardAll') }}</button>
+    </ui-side-panel>
+  `,
+			isInline: true,
+			styles: [":host{display:contents}.pcd-live{position:absolute;inline-size:1px;block-size:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap}.pcd-auth{margin:0 0 16px;padding:12px 14px;border-radius:8px;border:1px solid #b91c1c;background:#fee2e2;color:#7f1d1d;font-size:.875rem}.pcd-empty{margin:0;padding:24px 0;color:#475569;font-size:.9375rem;text-align:center}.pcd-empty:focus{outline:none}.pcd-list{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:12px}.pcd-row{padding:12px 14px;border:1px solid #e2e8f0;border-radius:10px;background:#fff;display:flex;flex-direction:column;gap:6px}.pcd-main{display:flex;flex-wrap:wrap;justify-content:space-between;gap:4px 12px}.pcd-label{font-weight:600;color:#0f172a;overflow-wrap:anywhere;min-inline-size:0}.pcd-status{font-size:.8125rem;color:#334155}.pcd-time{font-size:.8125rem;color:#475569}.pcd-error{margin:0;font-size:.875rem;color:#7f1d1d}.pcd-row[data-status=conflict] .pcd-error,.pcd-row[data-status=failed] .pcd-error{color:#78350f}.pcd-actions{display:flex;flex-wrap:wrap;gap:8px;margin-block-start:4px}.pcd-btn{min-block-size:44px;min-inline-size:44px;padding:0 16px;border-radius:8px;border:1px solid #334155;background:#fff;color:#0f172a;font:inherit;font-size:.875rem;font-weight:600;cursor:pointer;-webkit-appearance:none;appearance:none}.pcd-btn-danger{border-color:#b91c1c;color:#b91c1c}.pcd-btn:disabled{opacity:.5;cursor:not-allowed}.pcd-btn:focus{outline:3px solid #1d4ed8;outline-offset:2px}.pcd-btn:focus:not(:focus-visible){outline:none}@media(max-width:480px){.pcd-actions{flex-direction:column}.pcd-btn{inline-size:100%}}@media(forced-colors:active){.pcd-row,.pcd-auth,.pcd-btn{border:1px solid CanvasText;background:Canvas;color:CanvasText}}\n"],
+			dependencies: [{
+				kind: "component",
+				type: SidePanelComponent,
+				selector: "ui-side-panel",
+				inputs: [
+					"open",
+					"title",
+					"subtitle",
+					"wide",
+					"extraWide",
+					"cancelLabel",
+					"primaryLabel",
+					"primaryVariant",
+					"primaryLoading",
+					"primaryDisabled",
+					"cancelTestId",
+					"primaryTestId",
+					"returnFocusTo"
+				],
+				outputs: ["closed", "primaryClick"]
+			}],
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: PendingChangesDrawerComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "ui-pending-changes-drawer",
+			standalone: true,
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			imports: [SidePanelComponent],
+			template: `
+    <div class="pcd-live" role="status" aria-live="polite" aria-atomic="true" data-testid="pending-drawer-live">{{ announcement() }}</div>
+    <ui-side-panel
+      [open]="open()"
+      [title]="labels.t('connection.drawer.title')"
+      [cancelLabel]="labels.t('connection.drawer.close')"
+      [primaryLabel]="labels.t('connection.syncAll')"
+      [primaryDisabled]="rows().length === 0 || support.syncing()"
+      [primaryLoading]="support.syncing()"
+      primaryTestId="pending-drawer-sync-all"
+      (closed)="closed.emit()"
+      (primaryClick)="syncAll()">
+      @if (support.authBlocked()) {
+        <p class="pcd-auth" data-testid="pending-drawer-auth">{{ labels.t('connection.authBlocked') }}</p>
+      }
+      @if (rows().length === 0) {
+        <p class="pcd-empty" tabindex="-1" data-testid="pending-drawer-empty">{{ support.storageAvailable() ? labels.t('connection.drawer.empty') : labels.t('connection.storageUnavailable') }}</p>
+      } @else {
+        <ul class="pcd-list" [attr.aria-label]="labels.t('connection.drawer.list')" data-testid="pending-drawer-list">
+          @for (row of rows(); track row.id) {
+            <li class="pcd-row" [attr.data-testid]="'pending-row-' + row.id" [attr.data-status]="row.status">
+              <div class="pcd-main">
+                <span class="pcd-label">{{ row.label }}</span>
+                <span class="pcd-status" [attr.data-testid]="'pending-row-status-' + row.id">{{ statusText(row) }}</span>
+              </div>
+              <time class="pcd-time" [attr.datetime]="iso(row)" [attr.title]="absolute(row)" [attr.data-testid]="'pending-row-time-' + row.id">{{ savedText(row) }}</time>
+              @if (errorText(row); as err) {
+                <p class="pcd-error" [attr.data-testid]="'pending-row-error-' + row.id">{{ err }}</p>
+              }
+              <div class="pcd-actions">
+                @if (canRetry(row)) {
+                  <button type="button" class="pcd-btn" [attr.data-testid]="'pending-row-retry-' + row.id"
+                          [attr.aria-label]="labels.t('connection.retryNamed', { label: row.label })" (click)="retry(row)">{{ labels.t('connection.retry') }}</button>
+                }
+                <button type="button" class="pcd-btn pcd-btn-danger" [attr.data-testid]="'pending-row-discard-' + row.id" [disabled]="row.status === 'syncing'"
+                        [attr.aria-label]="labels.t('connection.discardNamed', { label: row.label })" (click)="discard(row)">{{ labels.t('connection.discard') }}</button>
+              </div>
+            </li>
+          }
+        </ul>
+      }
+      <button panel-footer-extra type="button" class="pcd-btn pcd-btn-danger" data-testid="pending-drawer-discard-all"
+              [disabled]="rows().length === 0 || support.syncing()" (click)="discardAll()">{{ labels.t('connection.discardAll') }}</button>
+    </ui-side-panel>
+  `,
+			styles: [":host{display:contents}.pcd-live{position:absolute;inline-size:1px;block-size:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap}.pcd-auth{margin:0 0 16px;padding:12px 14px;border-radius:8px;border:1px solid #b91c1c;background:#fee2e2;color:#7f1d1d;font-size:.875rem}.pcd-empty{margin:0;padding:24px 0;color:#475569;font-size:.9375rem;text-align:center}.pcd-empty:focus{outline:none}.pcd-list{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:12px}.pcd-row{padding:12px 14px;border:1px solid #e2e8f0;border-radius:10px;background:#fff;display:flex;flex-direction:column;gap:6px}.pcd-main{display:flex;flex-wrap:wrap;justify-content:space-between;gap:4px 12px}.pcd-label{font-weight:600;color:#0f172a;overflow-wrap:anywhere;min-inline-size:0}.pcd-status{font-size:.8125rem;color:#334155}.pcd-time{font-size:.8125rem;color:#475569}.pcd-error{margin:0;font-size:.875rem;color:#7f1d1d}.pcd-row[data-status=conflict] .pcd-error,.pcd-row[data-status=failed] .pcd-error{color:#78350f}.pcd-actions{display:flex;flex-wrap:wrap;gap:8px;margin-block-start:4px}.pcd-btn{min-block-size:44px;min-inline-size:44px;padding:0 16px;border-radius:8px;border:1px solid #334155;background:#fff;color:#0f172a;font:inherit;font-size:.875rem;font-weight:600;cursor:pointer;-webkit-appearance:none;appearance:none}.pcd-btn-danger{border-color:#b91c1c;color:#b91c1c}.pcd-btn:disabled{opacity:.5;cursor:not-allowed}.pcd-btn:focus{outline:3px solid #1d4ed8;outline-offset:2px}.pcd-btn:focus:not(:focus-visible){outline:none}@media(max-width:480px){.pcd-actions{flex-direction:column}.pcd-btn{inline-size:100%}}@media(forced-colors:active){.pcd-row,.pcd-auth,.pcd-btn{border:1px solid CanvasText;background:Canvas;color:CanvasText}}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		open: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "open",
+				required: false
+			}]
+		}],
+		closed: [{
+			type: i0.Output,
+			args: ["closed"]
+		}]
+	}
+});
+const TIME_MARK = "
";
+var StaleDataChipComponent = class StaleDataChipComponent {
+	constructor() {
+		this.labels = inject(UiLabelsService);
+		this.stale = inject(StaleDataService);
+		this.doc = inject(DOCUMENT);
+		this.refresh = output();
+		this.now = signal(Date.now(), ...ngDevMode ? [{ debugName: "now" }] : /* istanbul ignore next */ []);
+		this.parts = computed(() => {
+			const at = this.stale.staleAt();
+			if (at == null) return null;
+			const locale = pageLocale(this.doc, this.labels.locale());
+			const relative = formatRelativeTime(at, this.now(), this.labels.t("connection.time.justNow"), locale);
+			const text = this.labels.t("connection.stale", { time: TIME_MARK });
+			const at0 = text.indexOf(TIME_MARK);
+			return {
+				before: at0 < 0 ? `${text} ` : text.slice(0, at0),
+				after: at0 < 0 ? "" : text.slice(at0 + 1),
+				relative,
+				iso: new Date(at).toISOString(),
+				absolute: absoluteTime(at, locale)
+			};
+		}, ...ngDevMode ? [{ debugName: "parts" }] : /* istanbul ignore next */ []);
+		this.announcement = computed(() => {
+			const p = this.parts();
+			return p ? `${p.before}${p.relative}${p.after}` : "";
+		}, ...ngDevMode ? [{ debugName: "announcement" }] : /* istanbul ignore next */ []);
+		const timer = setInterval(() => this.now.set(Date.now()), 3e4);
+		inject(DestroyRef).onDestroy(() => clearInterval(timer));
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StaleDataChipComponent,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.0.0",
+			version: "22.2.2",
+			type: StaleDataChipComponent,
+			isStandalone: true,
+			selector: "ui-stale-data-chip",
+			outputs: { refresh: "refresh" },
+			ngImport: i0,
+			template: `
+    <div class="sdc-live" role="status" aria-live="polite" aria-atomic="true" data-testid="stale-data-chip-live">{{ announcement() }}</div>
+    @if (parts(); as p) {
+      <div class="sdc" data-testid="stale-data-chip">
+        <span class="sdc-text">{{ p.before }}<time [attr.datetime]="p.iso" [attr.title]="p.absolute" data-testid="stale-data-chip-time">{{ p.relative }}</time>{{ p.after }}</span>
+        <button type="button" class="sdc-btn" data-testid="stale-data-chip-refresh" [attr.aria-label]="labels.t('connection.refreshAria')" (click)="refresh.emit()">{{ labels.t('connection.refresh') }}</button>
+      </div>
+    }
+  `,
+			isInline: true,
+			styles: [":host{display:block;position:relative}.sdc-live{position:absolute;inline-size:1px;block-size:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap}.sdc{display:flex;flex-wrap:wrap;align-items:center;gap:4px 12px;padding:6px 8px 6px 14px;border-radius:999px;border:1px solid #b45309;background:#fef3c7;color:#78350f;font-size:.8125rem;line-height:1.4;max-inline-size:100%;box-sizing:border-box}.sdc-text{min-inline-size:0;overflow-wrap:anywhere}.sdc-btn{min-block-size:44px;min-inline-size:44px;padding:0 14px;border-radius:999px;border:1px solid currentColor;background:#fff;color:inherit;font:inherit;font-weight:600;cursor:pointer;-webkit-appearance:none;appearance:none}.sdc-btn:focus{outline:3px solid #1d4ed8;outline-offset:2px}.sdc-btn:focus:not(:focus-visible){outline:none}@media(max-width:480px){.sdc{border-radius:12px}.sdc-btn{inline-size:100%}}@media(forced-colors:active){.sdc,.sdc-btn{border:1px solid CanvasText;background:Canvas;color:CanvasText}}\n"],
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: StaleDataChipComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "ui-stale-data-chip",
+			standalone: true,
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    <div class="sdc-live" role="status" aria-live="polite" aria-atomic="true" data-testid="stale-data-chip-live">{{ announcement() }}</div>
+    @if (parts(); as p) {
+      <div class="sdc" data-testid="stale-data-chip">
+        <span class="sdc-text">{{ p.before }}<time [attr.datetime]="p.iso" [attr.title]="p.absolute" data-testid="stale-data-chip-time">{{ p.relative }}</time>{{ p.after }}</span>
+        <button type="button" class="sdc-btn" data-testid="stale-data-chip-refresh" [attr.aria-label]="labels.t('connection.refreshAria')" (click)="refresh.emit()">{{ labels.t('connection.refresh') }}</button>
+      </div>
+    }
+  `,
+			styles: [":host{display:block;position:relative}.sdc-live{position:absolute;inline-size:1px;block-size:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap}.sdc{display:flex;flex-wrap:wrap;align-items:center;gap:4px 12px;padding:6px 8px 6px 14px;border-radius:999px;border:1px solid #b45309;background:#fef3c7;color:#78350f;font-size:.8125rem;line-height:1.4;max-inline-size:100%;box-sizing:border-box}.sdc-text{min-inline-size:0;overflow-wrap:anywhere}.sdc-btn{min-block-size:44px;min-inline-size:44px;padding:0 14px;border-radius:999px;border:1px solid currentColor;background:#fff;color:inherit;font:inherit;font-weight:600;cursor:pointer;-webkit-appearance:none;appearance:none}.sdc-btn:focus{outline:3px solid #1d4ed8;outline-offset:2px}.sdc-btn:focus:not(:focus-visible){outline:none}@media(max-width:480px){.sdc{border-radius:12px}.sdc-btn{inline-size:100%}}@media(forced-colors:active){.sdc,.sdc-btn{border:1px solid CanvasText;background:Canvas;color:CanvasText}}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { refresh: [{
+		type: i0.Output,
+		args: ["refresh"]
+	}] }
+});
+var StillWorkingComponent = class StillWorkingComponent {
+	constructor() {
+		this.labels = inject(UiLabelsService);
+		this.active = input(false, ...ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []);
+		this.delayMs = input(4e3, ...ngDevMode ? [{ debugName: "delayMs" }] : /* istanbul ignore next */ []);
+		this.elapsed = signal(false, ...ngDevMode ? [{ debugName: "elapsed" }] : /* istanbul ignore next */ []);
+		this.text = computed(() => this.active() && this.elapsed() ? this.labels.t("connection.stillWorking") : "", ...ngDevMode ? [{ debugName: "text" }] : /* istanbul ignore next */ []);
+		effect((onCleanup) => {
+			const active = this.active();
+			const delay = this.delayMs();
+			untracked(() => this.elapsed.set(false));
+			if (!active) return;
+			const timer = setTimeout(() => this.elapsed.set(true), Math.max(0, delay));
+			onCleanup(() => clearTimeout(timer));
+		});
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StillWorkingComponent,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.1.0",
+			version: "22.2.2",
+			type: StillWorkingComponent,
+			isStandalone: true,
+			selector: "ui-still-working",
+			inputs: {
+				active: {
+					classPropertyName: "active",
+					publicName: "active",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				delayMs: {
+					classPropertyName: "delayMs",
+					publicName: "delayMs",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				}
+			},
+			ngImport: i0,
+			template: `<div class="sw" role="status" aria-live="polite" aria-atomic="true" data-testid="still-working">{{ text() }}</div>`,
+			isInline: true,
+			styles: [":host{display:block}.sw{color:#475569;font-size:.8125rem;line-height:1.4}.sw:empty{min-block-size:0;margin:0;padding:0}@media(forced-colors:active){.sw{color:CanvasText}}\n"],
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: StillWorkingComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "ui-still-working",
+			standalone: true,
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `<div class="sw" role="status" aria-live="polite" aria-atomic="true" data-testid="still-working">{{ text() }}</div>`,
+			styles: [":host{display:block}.sw{color:#475569;font-size:.8125rem;line-height:1.4}.sw:empty{min-block-size:0;margin:0;padding:0}@media(forced-colors:active){.sw{color:CanvasText}}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		active: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "active",
+				required: false
+			}]
+		}],
+		delayMs: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "delayMs",
+				required: false
+			}]
+		}]
+	}
+});
+export { ConnectionBannerComponent, ConnectionStateService, DEFAULT_DETAIL_TTL_MS, DEFAULT_LIST_TTL_MS, FROM_CACHE_HEADER, IDEMPOTENCY_HEADER, IDMAP_TTL_MS, LEASE_TTL_MS, OFFLINE_IDB_FACTORY, OFFLINE_LEASE_STORAGE, OFFLINE_LOCK_MANAGER, OFFLINE_REPLAY_HEADER, OFFLINE_SUPPORT_CONFIG, ONLINE_DEBOUNCE_MS, OfflineBlockedError, OfflineReplayer, OfflineStore, OfflineSupportService, PendingChangesDrawerComponent, QueueFullError, REQUEST_TIMEOUT_MS, RequestTimeoutError, STALE_CLAIM_MS, SYNCED_FLASH_MS, StaleDataChipComponent, StaleDataService, StillWorkingComponent, StorageUnavailableError, backoffMs, classifyReplay, connectionInterceptor, createChannel, defaultCreatedId, deriveEntity, generateUuid, idempotencyInterceptor, invalidationPrefix, isClaimable, isInScope, isMutationMethod, isOfflineBlockedError, isQuotaError, isRequestTimeoutError, lastSegmentIsId, matchesAny, matchesUrl, offlineHttpInterceptors, offlineInterceptor, pathAndQuery, pathOnly, provideOfflineSupport, resolveConfig, resolveConfigCached };
+
+//# sourceMappingURL=forgeroute-ui-offline.mjs.map