@dataemergencia/emergency 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2557 @@
+import { createRoot } from "react-dom/client";
+import axios, { isAxiosError } from "axios";
+import Pusher from "pusher-js";
+import { createStore } from "zustand/vanilla";
+import { createContext, useCallback, useContext, useEffect, useId, useRef } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useStore } from "zustand";
+
+// src/core/types.ts
+const EMERGENCY_ERROR_CODES = [
+	"configuration",
+	"network",
+	"cancelled",
+	"invalid_response",
+	"invalid_transition",
+	"destroyed",
+	"geolocation_denied",
+	"geolocation_unavailable",
+	"geolocation_timeout",
+	"geolocation_unsupported",
+	"validation_failed",
+	"invalid_code",
+	"inactive_code",
+	"unauthenticated",
+	"csrf_failed",
+	"cross_origin_denied",
+	"rate_limited",
+	"not_found",
+	"method_not_allowed",
+	"emergency_already_active",
+	"emergency_forbidden",
+	"emergency_not_found",
+	"missing_emergency_contacts",
+	"missing_medical_profile",
+	"whatsapp_delivery_failed",
+	"upstream_error",
+	"internal_error",
+	"emergency_error",
+	"unknown"
+];
+
+// src/core/guards.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isBoolean(value) {
+	return typeof value === "boolean";
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isArrayOf(value, guard) {
+	return Array.isArray(value) && value.every(guard);
+}
+function isRealtimeConfig(value) {
+	if (!isRecord(value) || value["mode"] !== "public" || !isRecord(value["pusher"])) return false;
+	const pusher = value["pusher"];
+	return isString(pusher["key"]) && isString(pusher["cluster"]) && isString(pusher["channel_pattern"]);
+}
+function isConfigResponse(value) {
+	return isRecord(value) && isString(value["route_prefix"]) && isString(value["csrf_token"]) && isRealtimeConfig(value["realtime"]);
+}
+function isSessionResponse(value) {
+	return isRecord(value) && isString(value["code"]) && isString(value["csrf_token"]) && isFiniteNumber(value["expires_in"]);
+}
+function isResponderPayload(value) {
+	if (!isRecord(value)) return false;
+	return isString(value["phone"]) && isString(value["name"]) && isBoolean(value["sent"]) && isBoolean(value["delivered"]) && isBoolean(value["read"]) && isBoolean(value["failed"]) && (value["message_id"] === null || isString(value["message_id"]));
+}
+function isFailurePayload(value) {
+	if (!isRecord(value)) return false;
+	return isString(value["phone"]) && isString(value["message"]) && (value["status"] === void 0 || value["status"] === null || isFiniteNumber(value["status"]));
+}
+function isEmergencyResultPayload(value) {
+	if (!isRecord(value)) return false;
+	return (value["emergency_id"] === null || isString(value["emergency_id"])) && isBoolean(value["simulated"]) && isArrayOf(value["responders"], isResponderPayload) && isArrayOf(value["failures"], isFailurePayload);
+}
+function isCurrentResponse(value) {
+	if (!isRecord(value) || !isBoolean(value["active"]) || !isRealtimeConfig(value["realtime"])) return false;
+	return value["emergency"] === null || isRecord(value["emergency"]) && !Array.isArray(value["emergency"]);
+}
+function isRefreshResponse(value) {
+	return isRecord(value) && isRecord(value["emergency"]) && isArrayOf(value["responders"], isResponderPayload);
+}
+function isAbortResponse(value) {
+	return isEmergencyResultPayload(value) && isRecord(value) && isBoolean(value["deleted"]);
+}
+function isErrorEnvelope(value) {
+	if (!isRecord(value) || !isRecord(value["error"])) return false;
+	const error = value["error"];
+	return isString(error["code"]) && isString(error["message"]) && (error["details"] === void 0 || error["details"] === null || isRecord(error["details"]) || Array.isArray(error["details"])) && (error["request_id"] === void 0 || isString(error["request_id"]));
+}
+
+// src/core/errors.ts
+function isEmergencyErrorCode(value) {
+	return typeof value === "string" && EMERGENCY_ERROR_CODES.some((code) => code === value);
+}
+function createEmergencyError(code, message, options = {}) {
+	return {
+		code,
+		message,
+		status: options.status ?? null,
+		requestId: options.requestId ?? null,
+		details: options.details ?? null,
+		cause: options.cause ?? null
+	};
+}
+function isEmergencyError(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["code"] === "string" && typeof value["message"] === "string" && "status" in value && "requestId" in value;
+}
+function toEmergencyError(value, fallbackCode = "unknown") {
+	if (isEmergencyError(value)) return value;
+	if (value instanceof Error) return createEmergencyError(fallbackCode, value.message, { cause: value });
+	return createEmergencyError(fallbackCode, "An unexpected error occurred.", { cause: value });
+}
+/**
+* Error object accepted by host integrations that prefer `throw`/`catch` while
+* the library still exposes the typed error through `.error`.
+*/
+var EmergencyClientError = class extends Error {
+	error;
+	constructor(error) {
+		super(error.message);
+		this.name = "EmergencyClientError";
+		this.error = error;
+	}
+};
+
+// src/core/bff-client.ts
+function createMemoryCsrfStrategy() {
+	let token = null;
+	return {
+		headerName: "X-CSRF-Token",
+		read: () => token,
+		setToken: (next) => {
+			token = next;
+		}
+	};
+}
+/**
+* Laravel-compatible adapter. The core never assumes Laravel; a host that uses
+* the `XSRF-TOKEN` cookie opts in by passing this strategy.
+*/
+function createCookieCsrfStrategy(cookieName = "XSRF-TOKEN") {
+	return {
+		headerName: "X-XSRF-TOKEN",
+		read: () => {
+			if (typeof document === "undefined" || document.cookie === "") return null;
+			const prefix = `${cookieName}=`;
+			for (const entry of document.cookie.split(";")) {
+				const trimmed = entry.trim();
+				if (trimmed.startsWith(prefix)) return decodeURIComponent(trimmed.slice(prefix.length));
+			}
+			return null;
+		}
+	};
+}
+function defaultIdempotencyKey() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+		const bytes = /* @__PURE__ */ new Uint8Array(16);
+		crypto.getRandomValues(bytes);
+		return `de-${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+	}
+	return `de-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+const MAX_DETAILS_DEPTH = 2;
+const MAX_DETAILS_ITEMS = 20;
+const MAX_DETAILS_NODES = 500;
+const MAX_DETAILS_STRING = 200;
+/**
+* Error `details` may carry the whole upstream payload, including responder
+* phone numbers. Hosts forward errors to logging and telemetry, so keep only a
+* shallow, bounded copy.
+*
+* Arrays are collections, not structure: their entries are processed at the
+* array's depth so a list of records stays readable. A node budget keeps
+* pathological nesting bounded even without a depth increment per array.
+*/
+function redactDetails(value) {
+	return redactValue(value, 0, { remaining: MAX_DETAILS_NODES });
+}
+function redactValue(value, depth, budget) {
+	if (budget.remaining <= 0) return "…";
+	budget.remaining -= 1;
+	if (value === null || typeof value === "boolean") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "string") return value.length > MAX_DETAILS_STRING ? `${value.slice(0, MAX_DETAILS_STRING)}…` : value;
+	if (Array.isArray(value)) return value.slice(0, MAX_DETAILS_ITEMS).map((entry) => redactValue(entry, depth, budget));
+	if (isRecord(value)) {
+		if (depth >= MAX_DETAILS_DEPTH) return "{…}";
+		const result = {};
+		for (const [key, entry] of Object.entries(value).slice(0, MAX_DETAILS_ITEMS)) result[key] = redactValue(entry, depth + 1, budget);
+		return result;
+	}
+	return null;
+}
+function normalizeAxiosError(error) {
+	if (isAxiosError(error)) {
+		if (error.code === "ERR_CANCELED" || error.name === "CanceledError") return createEmergencyError("cancelled", "The request was cancelled.", { cause: error });
+		const status = error.response?.status ?? null;
+		const data = error.response?.data;
+		const headerRequestId = readHeader(error.response?.headers, "x-request-id");
+		if (isErrorEnvelope(data)) {
+			const code = isEmergencyErrorCode(data.error.code) ? data.error.code : "upstream_error";
+			return createEmergencyError(code, data.error.message, {
+				status,
+				requestId: data.error.request_id ?? headerRequestId,
+				details: redactDetails(data.error.details),
+				cause: error
+			});
+		}
+		if (status === null) return createEmergencyError("network", "The emergency service could not be reached.", { cause: error });
+		return createEmergencyError(status >= 500 ? "upstream_error" : "unknown", error.message || "The emergency service returned an error.", {
+			status,
+			requestId: headerRequestId,
+			cause: error
+		});
+	}
+	if (error instanceof Error) {
+		if (error.name === "AbortError") return createEmergencyError("cancelled", "The request was cancelled.", { cause: error });
+		return createEmergencyError("network", error.message, { cause: error });
+	}
+	return createEmergencyError("unknown", "The emergency service returned an error.", { cause: error });
+}
+function readHeader(headers, name) {
+	if (!isRecord(headers)) return null;
+	const direct = headers[name] ?? headers[name.toLowerCase()];
+	if (typeof direct === "string" && direct !== "") return direct;
+	const getter = headers["get"];
+	if (typeof getter === "function") {
+		const value = getter.call(headers, name);
+		return typeof value === "string" && value !== "" ? value : null;
+	}
+	return typeof direct === "string" && direct !== "" ? direct : null;
+}
+function createBffAxiosInstance(options) {
+	return axios.create({
+		baseURL: options.bffBaseUrl.replace(/\/+$/, ""),
+		timeout: options.timeoutMs ?? 15e3,
+		withCredentials: options.withCredentials ?? true,
+		maxRedirects: options.maxRedirects ?? 0,
+		headers: {
+			Accept: "application/json",
+			"X-Requested-With": "XMLHttpRequest"
+		}
+	});
+}
+function createBffClient(options) {
+	const csrf = options.csrf ?? createMemoryCsrfStrategy();
+	const controllers = /* @__PURE__ */ new Set();
+	let destroyed = false;
+	let csrfToken = csrf.read();
+	const instance = options.axiosInstance ?? createBffAxiosInstance(options);
+	function captureCsrf(payload) {
+		if (typeof payload.csrf_token === "string" && payload.csrf_token !== "") {
+			csrfToken = payload.csrf_token;
+			if ("setToken" in csrf && typeof csrf.setToken === "function") csrf.setToken(csrfToken);
+		}
+	}
+	async function execute(config, guard, externalSignal) {
+		if (destroyed) throw createEmergencyError("destroyed", "The emergency client has been destroyed.");
+		const controller = new AbortController();
+		controllers.add(controller);
+		const abortFromExternal = () => {
+			controller.abort();
+		};
+		if (externalSignal) {
+			if (externalSignal.aborted) controller.abort();
+			else externalSignal.addEventListener("abort", abortFromExternal, { once: true });
+		}
+		const token = csrf.read() ?? csrfToken;
+		const headers = {};
+		if (isRecord(config.headers)) {
+			for (const [key, entry] of Object.entries(config.headers)) if (typeof entry === "string") headers[key] = entry;
+		}
+		if (token) headers[csrf.headerName] = token;
+		try {
+			const response = await instance.request({
+				...config,
+				headers,
+				signal: controller.signal
+			});
+			if (!guard(response.data)) throw createEmergencyError("invalid_response", "The emergency service returned an unexpected response.", {
+				status: response.status,
+				details: redactDetails(response.data)
+			});
+			return response.data;
+		} catch (error) {
+			if (isAxiosError(error) || error instanceof Error) throw normalizeAxiosError(error);
+			throw error;
+		} finally {
+			controllers.delete(controller);
+			externalSignal?.removeEventListener("abort", abortFromExternal);
+		}
+	}
+	function idempotencyKey(provided) {
+		return provided ?? (options.generateIdempotencyKey ?? defaultIdempotencyKey)();
+	}
+	return {
+		async config(signal) {
+			const payload = await execute({
+				method: "GET",
+				url: "/config"
+			}, isConfigResponse, signal);
+			captureCsrf(payload);
+			return payload;
+		},
+		async session(code, signal) {
+			const payload = await execute({
+				method: "POST",
+				url: "/session",
+				data: { code }
+			}, isSessionResponse, signal);
+			captureCsrf(payload);
+			return payload;
+		},
+		async current(signal) {
+			return execute({
+				method: "GET",
+				url: "/current"
+			}, isCurrentResponse, signal);
+		},
+		async activate(request, signal, key) {
+			return execute({
+				method: "POST",
+				url: "/activate",
+				data: request,
+				headers: { "Idempotency-Key": idempotencyKey(key) }
+			}, isEmergencyResultPayload, signal);
+		},
+		async simulacrum(signal, key) {
+			return execute({
+				method: "POST",
+				url: "/simulacrum",
+				headers: { "Idempotency-Key": idempotencyKey(key) }
+			}, isEmergencyResultPayload, signal);
+		},
+		async refresh(emergencyId, signal) {
+			return execute({
+				method: "POST",
+				url: `/${encodeURIComponent(emergencyId)}/refresh`
+			}, isRefreshResponse, signal);
+		},
+		async abort(emergencyId, signal) {
+			return execute({
+				method: "DELETE",
+				url: `/${encodeURIComponent(emergencyId)}`
+			}, isAbortResponse, signal);
+		},
+		destroy() {
+			destroyed = true;
+			for (const controller of controllers) controller.abort();
+			controllers.clear();
+		}
+	};
+}
+
+// src/core/copy.ts
+/**
+* Visible UI copy in Spanish. `locale` controls date and number formatting.
+*/
+const copy = {
+	panelLabel: "Panel de emergencia",
+	close: "Cerrar panel de emergencia",
+	question: "¿Tiene usted una emergencia?",
+	illustrationAlt: "Ícono paramédico",
+	emergency: "Emergencia",
+	emergencyAria: "Botón de emergencia",
+	test: "Prueba",
+	testAria: "Botón de simulación de emergencia",
+	statusTitle: "Estado de Respuestas de Emergencia",
+	responderColumn: "Respondedor",
+	sentColumn: "Enviado",
+	deliveredColumn: "Recibido",
+	readColumn: "Leído",
+	refresh: "Actualizar",
+	refreshing: "Actualizando...",
+	loading: "Cargando…",
+	statusPrefix: "Estado:",
+	statusPending: "Pendiente",
+	statusSent: "Enviado",
+	statusDelivered: "Recibido",
+	statusRead: "Leído",
+	statusFailed: "Fallido",
+	abort: "Abortar Aviso de Emergencia",
+	abortConfirmTitle: "Confirmar aborto de emergencia",
+	abortConfirmText: "Estas apunto de abortar la emergencia, esta acción es irreversible ¿Desea continuar?",
+	abortConfirm: "Si, abortar",
+	abortCancel: "No, continuar",
+	abortResultOk: "Emergencia abortada con éxito, tus contactos han sido notificados",
+	abortResultFail: "No se pudo abortar la emergencia. Inténtalo de nuevo.",
+	abortSuccessTitle: "¡Emergencia Abortada Con Éxito!",
+	abortSuccessDetails: "Tus contactos han sido notificados",
+	simulate: "Prueba",
+	simulateConfirmTitle: "Enviar mensaje de prueba",
+	simulateConfirmText: "Se enviará un mensaje de prueba a tus contactos. No se crea una emergencia real.",
+	simulateConfirm: "Sí, enviar prueba",
+	simulateCancel: "Cancelar",
+	simulateResultOk: "¡Prueba de simulación iniciada con éxito!",
+	simulateResultFail: "No se pudo enviar el mensaje de prueba.",
+	simulateSuccessTitle: "¡Éxito!",
+	simulateSuccessDetails: "Mensajes enviados",
+	simulateSuccessCompleted: "Proceso completado",
+	feedbackDismiss: "Entendido",
+	errorTitle: "Ha ocurrido un error",
+	errorText: "Ha ocurrido un error inesperado.",
+	errorDetailInfo: "Revisa la información requerida",
+	errorDetailRetry: "Intenta nuevamente",
+	retry: "Reintentar",
+	geolocationTitle: "No pudimos obtener tu ubicación",
+	geolocationDenied: "Permiso de ubicación denegado. Habilita el acceso a la ubicación en tu navegador e inténtalo de nuevo.",
+	geolocationUnavailable: "Tu ubicación no está disponible en este momento. Verifica que el GPS esté activado e inténtalo de nuevo.",
+	geolocationTimeout: "La ubicación tardó demasiado. Muévete a un lugar con mejor señal e inténtalo de nuevo.",
+	geolocationUnsupported: "Este dispositivo no permite compartir la ubicación. Inténtalo desde otro navegador o dispositivo.",
+	resumeTitle: "Emergencia Activa Detectada",
+	resumeDescription: "Se ha detectado una emergencia activa en el sistema. Por favor, revisa el estado de la emergencia inmediatamente.",
+	resumeAction: "Abrir Panel de Emergencia",
+	partialFailure: "Algunos contactos no pudieron ser notificados. Revisa la lista.",
+	simulatedBanner: "Mensaje de prueba: no hay una emergencia real activa.",
+	activeBanner: "Emergencia activa. Tus contactos fueron notificados.",
+	emergencyActiveError: "Ya tienes una emergencia activa. Revisa el estado antes de continuar.",
+	respondersEmpty: "Aún no hay contactos notificados."
+};
+
+// src/core/events.ts
+/**
+* Typed, dependency-free event bus used by the controller and by `mount()`.
+* DOM custom events are not used so the core stays framework agnostic.
+*/
+const EMERGENCY_EVENT_NAMES = [
+	"session:ready",
+	"emergency:activated",
+	"emergency:simulated",
+	"emergency:resumed",
+	"emergency:updated",
+	"emergency:aborted",
+	"emergency:failed",
+	"emergency:fallback",
+	"panel:opened",
+	"panel:closed"
+];
+var EmergencyEventEmitter = class {
+	handlers = /* @__PURE__ */ new Map();
+	on(event, handler) {
+		const set = this.handlers.get(event) ?? /* @__PURE__ */ new Set();
+		set.add(handler);
+		this.handlers.set(event, set);
+		return () => {
+			this.off(event, handler);
+		};
+	}
+	off(event, handler) {
+		const set = this.handlers.get(event);
+		if (!set) return;
+		set.delete(handler);
+		if (set.size === 0) this.handlers.delete(event);
+	}
+	emit(event, payload) {
+		const set = this.handlers.get(event);
+		if (!set) return;
+		for (const handler of set) try {
+			handler(payload);
+		} catch {}
+	}
+	clear() {
+		this.handlers.clear();
+	}
+};
+function createEventEmitter() {
+	return new EmergencyEventEmitter();
+}
+
+// src/core/geolocation.ts
+function mapFailure(error) {
+	const mapped = createEmergencyError(error.code === 1 ? "geolocation_denied" : error.code === 3 ? "geolocation_timeout" : "geolocation_unavailable", error.message ?? "The current position could not be determined.");
+	return Object.assign(new Error(mapped.message), { emergencyError: mapped });
+}
+function createBrowserGeolocationProvider() {
+	return { getCurrentPosition(timeoutMs) {
+		return new Promise((resolve, reject) => {
+			if (typeof navigator === "undefined" || typeof navigator.geolocation === "undefined" || typeof navigator.geolocation.getCurrentPosition !== "function") {
+				reject(Object.assign(/* @__PURE__ */ new Error("Geolocation is not supported in this environment."), { emergencyError: createEmergencyError("geolocation_unsupported", "Geolocation is not supported in this environment.") }));
+				return;
+			}
+			navigator.geolocation.getCurrentPosition((position) => {
+				resolve({
+					latitude: position.coords.latitude,
+					longitude: position.coords.longitude,
+					accuracy: position.coords.accuracy
+				});
+			}, (error) => {
+				reject(mapFailure(error));
+			}, {
+				enableHighAccuracy: true,
+				timeout: timeoutMs
+			});
+		});
+	} };
+}
+
+// src/core/mappers.ts
+function responderStatus(payload) {
+	if (payload.failed) return "failed";
+	if (payload.read) return "read";
+	if (payload.delivered) return "delivered";
+	if (payload.sent) return "sent";
+	return "pending";
+}
+function toResponder(payload) {
+	const last = payload.last_messages?.at(-1) ?? null;
+	return {
+		phone: payload.phone,
+		name: payload.name,
+		status: responderStatus(payload),
+		sent: payload.sent,
+		delivered: payload.delivered,
+		read: payload.read,
+		failed: payload.failed,
+		messageId: payload.message_id,
+		sentAt: payload.sent_at ?? null,
+		deliveredAt: payload.delivered_at ?? null,
+		readAt: payload.read_at ?? null,
+		lastMessage: last ? {
+			content: last.content ?? "",
+			sentAt: last.sent_at ?? null
+		} : null
+	};
+}
+function toFailure(payload) {
+	return {
+		phone: payload.phone,
+		message: payload.message,
+		status: payload.status ?? null
+	};
+}
+function resultToSnapshot(result, code) {
+	return {
+		emergencyId: result.emergency_id ?? "",
+		code,
+		active: true,
+		simulated: result.simulated,
+		responders: result.responders.map(toResponder),
+		createdAt: null,
+		updatedAt: null,
+		raw: { ...result }
+	};
+}
+function readString(raw, keys) {
+	for (const key of keys) {
+		const value = raw[key];
+		if (typeof value === "string" && value !== "") return value;
+	}
+	return null;
+}
+function readBoolean(raw, keys) {
+	for (const key of keys) {
+		const value = raw[key];
+		if (typeof value === "boolean") return value;
+	}
+	return null;
+}
+/**
+* Maps the upstream emergency payload (proxied by the BFF) into the snapshot the
+* UI renders. Unknown fields survive in `raw`, so the client never loses data
+* the BFF adds later.
+*/
+function payloadToSnapshot(raw, options = {}) {
+	const respondersValue = raw["responders"];
+	const responders = Array.isArray(respondersValue) ? respondersValue.filter(isResponderPayloadLike).map(toResponder) : [];
+	return {
+		emergencyId: readString(raw, ["emergency_id", "id"]) ?? "",
+		code: options.code ?? readString(raw, ["initiator_id", "code"]),
+		active: readBoolean(raw, ["is_active", "active"]) ?? true,
+		simulated: options.simulated ?? readBoolean(raw, ["is_simulated", "simulated"]) ?? false,
+		responders,
+		createdAt: readString(raw, ["created_at", "createdAt"]),
+		updatedAt: readString(raw, ["updated_at", "updatedAt"]),
+		raw
+	};
+}
+function isResponderPayloadLike(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["phone"] === "string" && typeof value["name"] === "string";
+}
+function themeToCssVariables(theme) {
+	if (!theme) return {};
+	const variables = {};
+	for (const [key, variable] of [
+		["accent", "--de-emergency-red"],
+		["accentContrast", "--de-emergency-on-red"],
+		["surface", "--de-emergency-white"],
+		["text", "--de-emergency-text"],
+		["muted", "--de-emergency-text-secondary"],
+		["radius", "--de-emergency-radius"]
+	]) {
+		const value = theme[key];
+		if (value) variables[variable] = value;
+	}
+	return variables;
+}
+
+// src/core/realtime.ts
+function channelForPhone(pattern, phone) {
+	return pattern.replace("{phone}", phone.replace(/^\+/, ""));
+}
+function toStatus(state) {
+	switch (state) {
+		case "connected": return "connected";
+		case "connecting":
+		case "initialized": return "connecting";
+		case "unavailable":
+		case "failed": return "unavailable";
+		case "disconnected": return "disconnected";
+		default: return "idle";
+	}
+}
+function createPusherRealtimeProvider() {
+	return { subscribe(config, phones, handlers) {
+		if (typeof window === "undefined" || !config.pusher.key || !config.pusher.cluster) return null;
+		let pusher;
+		try {
+			pusher = new Pusher(config.pusher.key, {
+				cluster: config.pusher.cluster,
+				forceTLS: true
+			});
+		} catch {
+			handlers.onStatus("unavailable");
+			return null;
+		}
+		handlers.onStatus("connecting");
+		pusher.connection.bind("state_change", (change) => {
+			handlers.onStatus(toStatus(change.current));
+		});
+		const channels = [...new Set(phones.filter((phone) => phone !== ""))].map((phone) => {
+			const channelName = channelForPhone(config.pusher.channel_pattern, phone);
+			pusher.subscribe(channelName).bind_global((eventName, data) => {
+				handlers.onEvent(channelName, eventName, data);
+			});
+			return channelName;
+		});
+		return { disconnect() {
+			for (const channelName of channels) pusher.unsubscribe(channelName);
+			pusher.disconnect();
+		} };
+	} };
+}
+
+// src/core/state-machine.ts
+const EMERGENCY_PHASE_NAMES = [
+	"idle",
+	"initializing",
+	"ready",
+	"activating",
+	"simulating",
+	"active",
+	"refreshing",
+	"aborting",
+	"error"
+];
+/**
+* Every allowed transition. `idle` is reachable from every phase so `destroy()`
+* and a hard reset always leave the store in a known state.
+*/
+const EMERGENCY_TRANSITIONS = {
+	idle: ["initializing"],
+	initializing: [
+		"idle",
+		"ready",
+		"active",
+		"error"
+	],
+	ready: [
+		"idle",
+		"initializing",
+		"activating",
+		"simulating",
+		"active",
+		"refreshing",
+		"error"
+	],
+	activating: [
+		"idle",
+		"ready",
+		"active",
+		"error"
+	],
+	simulating: [
+		"idle",
+		"ready",
+		"error"
+	],
+	active: [
+		"idle",
+		"ready",
+		"refreshing",
+		"aborting",
+		"error"
+	],
+	refreshing: [
+		"idle",
+		"active",
+		"error"
+	],
+	aborting: [
+		"idle",
+		"ready",
+		"active",
+		"error"
+	],
+	error: [
+		"idle",
+		"initializing",
+		"ready"
+	]
+};
+function canTransition(from, to) {
+	return EMERGENCY_TRANSITIONS[from].includes(to);
+}
+
+// src/core/store.ts
+function createEmergencyStore(config) {
+	return createStore(() => ({
+		config,
+		phase: { kind: "idle" },
+		panelOpen: false,
+		sessionReady: false,
+		resumeAvailable: false,
+		snapshot: null,
+		responders: [],
+		failures: [],
+		messages: [],
+		lastError: null,
+		geolocation: null,
+		geolocationError: null,
+		realtimeStatus: "idle",
+		abortResult: null,
+		simulationResult: null,
+		abortConfirmation: false,
+		simulationConfirmation: false,
+		destroyed: false
+	}));
+}
+
+// src/core/controller.ts
+const RECONCILE_THROTTLE_MS = 1500;
+function geolocationFailure(error) {
+	const attached = isRecord(error) ? error["emergencyError"] : void 0;
+	if (attached) return toEmergencyError(attached, "geolocation_unavailable");
+	return toEmergencyError(error, "geolocation_unavailable");
+}
+function createEmergencyController(deps) {
+	const config = deps.config;
+	const bff = deps.bff ?? createBffClient({
+		bffBaseUrl: config.bffBaseUrl,
+		timeoutMs: config.requestTimeoutMs
+	});
+	const geolocation = deps.geolocation ?? createBrowserGeolocationProvider();
+	const realtimeProvider = deps.realtime ?? createPusherRealtimeProvider();
+	const events = deps.events ?? createEventEmitter();
+	const store = createEmergencyStore(config);
+	let sessionPromise = null;
+	let refreshing = false;
+	let realtimeSubscription = null;
+	let realtimeConfig = null;
+	let subscribedPhones = [];
+	let messageSequence = 0;
+	let lastReconcileAt = 0;
+	let reconcileTimer = null;
+	const get = () => store.getState();
+	function patch(partial) {
+		store.setState(partial);
+	}
+	function transition(next) {
+		const current = get().phase;
+		if (current.kind === next.kind) {
+			patch({ phase: next });
+			return true;
+		}
+		if (!canTransition(current.kind, next.kind)) {
+			events.emit("emergency:failed", {
+				error: createEmergencyError("invalid_transition", `Cannot move from ${current.kind} to ${next.kind}.`),
+				operation: "mount"
+			});
+			return false;
+		}
+		patch({ phase: next });
+		return true;
+	}
+	function pushMessage(kind, text) {
+		messageSequence += 1;
+		const message = {
+			id: `${Date.now()}-${messageSequence}`,
+			kind,
+			text,
+			createdAt: Date.now()
+		};
+		patch({ messages: [...get().messages, message].slice(-20) });
+	}
+	function fail(error, operation, options = {}) {
+		patch({ lastError: error });
+		if (options.message !== null) pushMessage("error", options.message ?? error.message);
+		if (options.phase !== null) transition(options.phase ?? {
+			kind: "error",
+			error
+		});
+		events.emit("emergency:failed", {
+			error,
+			operation
+		});
+	}
+	function emitFallback(error) {
+		events.emit("emergency:fallback", {
+			error,
+			fallback: config.fallback ?? null
+		});
+	}
+	function stopRealtime() {
+		realtimeSubscription?.disconnect();
+		realtimeSubscription = null;
+		subscribedPhones = [];
+	}
+	function startRealtime(realtime, responders) {
+		if (!realtime) return;
+		realtimeConfig = realtime;
+		const phones = [...new Set(responders.map((responder) => responder.phone))];
+		if (realtimeSubscription && phones.length === subscribedPhones.length && phones.every((phone, index) => phone === subscribedPhones[index])) return;
+		realtimeSubscription?.disconnect();
+		subscribedPhones = phones;
+		if (phones.length === 0) {
+			patch({ realtimeStatus: "unavailable" });
+			return;
+		}
+		realtimeSubscription = realtimeProvider.subscribe(realtime, phones, {
+			onStatus(status) {
+				const previous = get().realtimeStatus;
+				patch({ realtimeStatus: status });
+				if (status === "connected" && previous !== "connected") scheduleReconcile();
+			},
+			onEvent() {
+				scheduleReconcile();
+			}
+		});
+		if (!realtimeSubscription) patch({ realtimeStatus: "unavailable" });
+	}
+	function scheduleReconcile() {
+		if (reconcileTimer !== null) return;
+		const wait = Math.max(0, RECONCILE_THROTTLE_MS - (Date.now() - lastReconcileAt));
+		reconcileTimer = setTimeout(() => {
+			reconcileTimer = null;
+			lastReconcileAt = Date.now();
+			refresh(true);
+		}, wait);
+	}
+	async function performSession() {
+		const phase = get().phase.kind;
+		if (phase === "idle" || phase === "error") transition({ kind: "initializing" });
+		try {
+			realtimeConfig = (await bff.config()).realtime;
+			const session = await bff.session(config.code);
+			patch({
+				sessionReady: true,
+				lastError: null
+			});
+			if (get().phase.kind === "initializing") transition({ kind: "ready" });
+			events.emit("session:ready", {
+				code: session.code,
+				expiresIn: session.expires_in
+			});
+		} catch (error) {
+			const normalized = toEmergencyError(error, "network");
+			patch({ sessionReady: false });
+			fail(normalized, "session", { phase: {
+				kind: "error",
+				error: normalized
+			} });
+		}
+	}
+	async function ensureSession() {
+		if (get().destroyed || get().sessionReady) return;
+		if (!sessionPromise) sessionPromise = performSession().finally(() => {
+			sessionPromise = null;
+		});
+		return sessionPromise;
+	}
+	async function hydrateCurrent() {
+		try {
+			const current = await bff.current();
+			realtimeConfig = current.realtime;
+			if (current.active && current.emergency) {
+				const snapshot = payloadToSnapshot(current.emergency, { code: config.code });
+				patch({
+					snapshot,
+					responders: snapshot.responders,
+					resumeAvailable: !get().panelOpen,
+					failures: [],
+					lastError: null,
+					geolocationError: null
+				});
+				transition({
+					kind: "active",
+					emergencyId: snapshot.emergencyId,
+					simulated: snapshot.simulated
+				});
+				startRealtime(current.realtime, snapshot.responders);
+				events.emit("emergency:resumed", { snapshot });
+				return;
+			}
+			patch({
+				resumeAvailable: false,
+				snapshot: null,
+				responders: []
+			});
+			if (get().phase.kind !== "ready") transition({ kind: "ready" });
+		} catch (error) {
+			const normalized = toEmergencyError(error, "network");
+			patch({ resumeAvailable: false });
+			if (normalized.code === "unauthenticated") return;
+			fail(normalized, "resume", { phase: get().phase.kind === "active" ? null : {
+				kind: "error",
+				error: normalized
+			} });
+		}
+	}
+	async function resume() {
+		if (get().destroyed) return;
+		await ensureSession();
+		if (!get().sessionReady) return;
+		await hydrateCurrent();
+	}
+	async function activate() {
+		if (get().destroyed) return;
+		const phase = get().phase.kind;
+		if (phase === "activating" || phase === "active") {
+			open("activate");
+			return;
+		}
+		open("activate");
+		await ensureSession();
+		if (!get().sessionReady || !transition({ kind: "activating" })) return;
+		patch({
+			lastError: null,
+			geolocationError: null,
+			abortResult: null
+		});
+		let position;
+		try {
+			position = await geolocation.getCurrentPosition(config.geolocationTimeoutMs ?? 8e3);
+			patch({ geolocation: position });
+		} catch (error) {
+			const normalized = geolocationFailure(error);
+			patch({
+				geolocation: null,
+				geolocationError: normalized
+			});
+			transition({ kind: "ready" });
+			events.emit("emergency:failed", {
+				error: normalized,
+				operation: "geolocation"
+			});
+			emitFallback(normalized);
+			return;
+		}
+		try {
+			const result = await bff.activate({ geolocation: position });
+			const snapshot = resultToSnapshot(result, config.code);
+			const responders = result.responders.map(toResponder);
+			const failures = result.failures.map(toFailure);
+			const hydrated = {
+				...snapshot,
+				responders
+			};
+			patch({
+				snapshot: hydrated,
+				responders,
+				failures,
+				resumeAvailable: false,
+				lastError: null
+			});
+			transition({
+				kind: "active",
+				emergencyId: hydrated.emergencyId,
+				simulated: result.simulated
+			});
+			pushMessage(failures.length > 0 ? "warning" : "success", failures.length > 0 ? copy.partialFailure : copy.activeBanner);
+			events.emit("emergency:activated", { snapshot: hydrated });
+			startRealtime(realtimeConfig, responders);
+		} catch (error) {
+			const normalized = toEmergencyError(error, "network");
+			if (normalized.code === "emergency_already_active") {
+				pushMessage("info", copy.emergencyActiveError);
+				await hydrateCurrent();
+				return;
+			}
+			fail(normalized, "activate", { phase: { kind: "ready" } });
+			emitFallback(normalized);
+		}
+	}
+	async function simulate() {
+		if (get().destroyed) return;
+		const snapshot = get().snapshot;
+		if (snapshot?.active && !snapshot.simulated) {
+			pushMessage("warning", copy.emergencyActiveError);
+			return;
+		}
+		if ([
+			"simulating",
+			"activating",
+			"aborting"
+		].includes(get().phase.kind)) return;
+		await ensureSession();
+		if (!get().sessionReady || !transition({ kind: "simulating" })) return;
+		patch({
+			lastError: null,
+			simulationResult: null
+		});
+		try {
+			const result = await bff.simulacrum();
+			const responders = result.responders.map(toResponder);
+			const failures = result.failures.map(toFailure);
+			const simulationResult = {
+				ok: true,
+				message: failures.length > 0 ? copy.partialFailure : copy.simulateResultOk,
+				at: Date.now()
+			};
+			patch({
+				responders,
+				failures,
+				simulationResult,
+				simulationConfirmation: false
+			});
+			transition({ kind: "ready" });
+			pushMessage(failures.length > 0 ? "warning" : "success", simulationResult.message);
+			events.emit("emergency:simulated", {
+				responders,
+				failures
+			});
+		} catch (error) {
+			const normalized = toEmergencyError(error, "network");
+			patch({ simulationResult: {
+				ok: false,
+				message: copy.simulateResultFail,
+				at: Date.now()
+			} });
+			transition({ kind: "ready" });
+			fail(normalized, "simulate", { phase: null });
+		}
+	}
+	async function refresh(silent = false) {
+		const snapshot = get().snapshot;
+		if (get().destroyed || !snapshot || snapshot.simulated || snapshot.emergencyId === "") return;
+		if (refreshing) return;
+		refreshing = true;
+		if (!silent) transition({
+			kind: "refreshing",
+			emergencyId: snapshot.emergencyId
+		});
+		try {
+			const result = await bff.refresh(snapshot.emergencyId);
+			const next = payloadToSnapshot(result.emergency, {
+				code: config.code,
+				simulated: snapshot.simulated
+			});
+			const responders = result.responders.length > 0 ? result.responders.map(toResponder) : next.responders.length > 0 ? next.responders : get().responders;
+			const updated = {
+				...next,
+				responders
+			};
+			patch({
+				snapshot: updated,
+				responders,
+				lastError: null
+			});
+			if (get().phase.kind === "refreshing") transition({
+				kind: "active",
+				emergencyId: updated.emergencyId,
+				simulated: updated.simulated
+			});
+			startRealtime(realtimeConfig, responders);
+			events.emit("emergency:updated", { snapshot: updated });
+		} catch (error) {
+			const normalized = toEmergencyError(error, "network");
+			if (get().phase.kind === "refreshing") transition({
+				kind: "active",
+				emergencyId: snapshot.emergencyId,
+				simulated: snapshot.simulated
+			});
+			fail(normalized, "refresh", {
+				phase: null,
+				message: silent ? null : void 0
+			});
+		} finally {
+			refreshing = false;
+		}
+	}
+	async function abort() {
+		if (get().destroyed) return;
+		const snapshot = get().snapshot;
+		if (get().phase.kind !== "active" || !snapshot) return;
+		if (!get().abortConfirmation) {
+			patch({ abortConfirmation: true });
+			return;
+		}
+		if (snapshot.simulated || snapshot.emergencyId === "") {
+			patch({
+				snapshot: null,
+				responders: [],
+				resumeAvailable: false,
+				abortConfirmation: false
+			});
+			transition({ kind: "ready" });
+			pushMessage("info", "No hay una emergencia real activa.");
+			return;
+		}
+		if (!transition({
+			kind: "aborting",
+			emergencyId: snapshot.emergencyId
+		})) return;
+		patch({
+			lastError: null,
+			abortResult: null
+		});
+		try {
+			const result = await bff.abort(snapshot.emergencyId);
+			const responders = result.responders.map(toResponder);
+			const abortResult = {
+				ok: true,
+				message: copy.abortResultOk,
+				at: Date.now()
+			};
+			patch({
+				abortResult,
+				responders,
+				failures: result.failures.map(toFailure),
+				abortConfirmation: false,
+				snapshot: null,
+				resumeAvailable: false
+			});
+			stopRealtime();
+			transition({ kind: "ready" });
+			pushMessage("success", abortResult.message);
+			events.emit("emergency:aborted", {
+				emergencyId: snapshot.emergencyId,
+				responders
+			});
+		} catch (error) {
+			const normalized = toEmergencyError(error, "network");
+			patch({
+				abortResult: {
+					ok: false,
+					message: copy.abortResultFail,
+					at: Date.now()
+				},
+				abortConfirmation: false
+			});
+			transition({
+				kind: "active",
+				emergencyId: snapshot.emergencyId,
+				simulated: snapshot.simulated
+			});
+			fail(normalized, "abort", { phase: null });
+		}
+	}
+	function open(reason = "manual") {
+		if (get().destroyed) return;
+		patch({
+			panelOpen: true,
+			resumeAvailable: false
+		});
+		events.emit("panel:opened", { reason });
+	}
+	function close(reason = "close") {
+		if (!get().panelOpen) return;
+		patch({
+			panelOpen: false,
+			abortConfirmation: false,
+			simulationConfirmation: false
+		});
+		events.emit("panel:closed", { reason });
+	}
+	function reconcileNow() {
+		const snapshot = get().snapshot;
+		if (!snapshot || snapshot.simulated || snapshot.emergencyId === "") return;
+		lastReconcileAt = Date.now();
+		refresh(true);
+	}
+	function onVisibilityChange() {
+		if (typeof document !== "undefined" && document.visibilityState === "visible") scheduleReconcile();
+	}
+	function registerReconcileListeners() {
+		if (typeof window === "undefined") return () => void 0;
+		window.addEventListener("focus", scheduleReconcile);
+		window.addEventListener("online", reconcileNow);
+		if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisibilityChange);
+		return () => {
+			window.removeEventListener("focus", scheduleReconcile);
+			window.removeEventListener("online", reconcileNow);
+			if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisibilityChange);
+		};
+	}
+	const removeReconcileListeners = registerReconcileListeners();
+	function destroy() {
+		if (get().destroyed) return;
+		removeReconcileListeners();
+		if (reconcileTimer !== null) {
+			clearTimeout(reconcileTimer);
+			reconcileTimer = null;
+		}
+		bff.destroy();
+		realtimeSubscription?.disconnect();
+		realtimeSubscription = null;
+		realtimeConfig = null;
+		subscribedPhones = [];
+		patch({
+			destroyed: true,
+			phase: { kind: "idle" },
+			panelOpen: false,
+			sessionReady: false,
+			resumeAvailable: false,
+			snapshot: null,
+			responders: [],
+			failures: [],
+			messages: [],
+			lastError: null,
+			geolocation: null,
+			geolocationError: null,
+			realtimeStatus: "idle",
+			abortResult: null,
+			simulationResult: null,
+			abortConfirmation: false,
+			simulationConfirmation: false
+		});
+		events.emit("panel:closed", { reason: "destroy" });
+		events.clear();
+	}
+	return {
+		client: {
+			open,
+			close,
+			destroy,
+			getState: get,
+			subscribe: (listener) => store.subscribe(listener),
+			on: (event, handler) => events.on(event, handler),
+			off: (event, handler) => events.off(event, handler),
+			ensureSession,
+			resume,
+			dismissResume: () => patch({ resumeAvailable: false }),
+			activate,
+			simulate,
+			refresh: () => refresh(false),
+			abort,
+			requestAbortConfirmation: () => {
+				if (get().phase.kind === "active") patch({ abortConfirmation: true });
+			},
+			cancelAbortConfirmation: () => patch({ abortConfirmation: false }),
+			requestSimulationConfirmation: () => {
+				if (!get().snapshot?.active) patch({ simulationConfirmation: true });
+			},
+			cancelSimulationConfirmation: () => patch({ simulationConfirmation: false }),
+			dismissFeedback: () => {
+				const state = get();
+				patch({
+					abortResult: null,
+					simulationResult: null,
+					geolocationError: null,
+					...state.geolocationError !== null || state.abortResult?.ok === false || state.simulationResult?.ok === false || state.phase.kind === "ready" && state.lastError !== null ? { lastError: null } : {}
+				});
+			}
+		},
+		store,
+		events
+	};
+}
+
+// src/core/fonts.ts
+/**
+* The exact Google Fonts query segment for each family. Family order matters:
+* with every family enabled the generated href is the documented stylesheet
+* URL, byte for byte.
+*/
+const FONT_FAMILY_PARAMS = {
+	googleSans: "family=Google+Sans:ital,opsz,wght@0,17..18,400..700;1,17..18,400..700",
+	montserrat: "family=Montserrat:ital,wght@0,100..900;1,100..900",
+	poppins: "family=Poppins:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,100;1,200;1,300;1,400;1,500;1,600;1,700;1,800;1,900"
+};
+const FONT_FAMILY_ORDER = [
+	"googleSans",
+	"montserrat",
+	"poppins"
+];
+const FONT_STYLESHEET_BASE = "https://fonts.googleapis.com/css2";
+const FONT_ORIGIN = "https://fonts.googleapis.com";
+const FONT_STATIC_ORIGIN = "https://fonts.gstatic.com";
+/** Marks every link the client injects so repeated mounts stay idempotent. */
+const FONT_LINK_ATTRIBUTE = "data-de-emergency-fonts";
+function normalizeFontLoading(input) {
+	const flags = input?.fonts ?? {};
+	return {
+		load: input?.load ?? true,
+		fonts: {
+			googleSans: flags.googleSans ?? true,
+			montserrat: flags.montserrat ?? true,
+			poppins: flags.poppins ?? true
+		}
+	};
+}
+/**
+* Builds the stylesheet URL for the enabled families, or `null` when the
+* master switch is off or no family is enabled. A disabled family is left out
+* of the request entirely.
+*/
+function buildFontStylesheetHref(input) {
+	const { load, fonts } = normalizeFontLoading(input);
+	if (!load) return null;
+	const params = FONT_FAMILY_ORDER.filter((family) => fonts[family]).map((family) => FONT_FAMILY_PARAMS[family]);
+	if (params.length === 0) return null;
+	return `${FONT_STYLESHEET_BASE}?${params.join("&")}&display=swap`;
+}
+function createFontLink(rel, href, crossorigin = false) {
+	const link = document.createElement("link");
+	link.rel = rel;
+	link.href = href;
+	if (crossorigin) link.crossOrigin = "anonymous";
+	link.setAttribute(FONT_LINK_ATTRIBUTE, "");
+	return link;
+}
+/**
+* Injects the preconnect and stylesheet links the panel needs, once per page.
+* The first successful mount wins: later mounts, including mounts from a
+* duplicated copy of the library, reuse the links already present. The links
+* are page-level assets and are intentionally not removed on `destroy()`.
+*/
+function installEmergencyFonts(input) {
+	if (typeof document === "undefined") return;
+	const href = buildFontStylesheetHref(input);
+	if (href === null) return;
+	if (document.querySelector(`link[${"data-de-emergency-fonts"}]`)) return;
+	(document.head ?? document.documentElement).append(createFontLink("preconnect", FONT_ORIGIN), createFontLink("preconnect", FONT_STATIC_ORIGIN, true), createFontLink("stylesheet", href));
+}
+
+// src/core/config.ts
+const EMERGENCY_CODE_PATTERN = /^[A-Za-z][A-Za-z0-9]{5}$/;
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+function isValidEmergencyCode(code) {
+	return EMERGENCY_CODE_PATTERN.test(code);
+}
+function isValidFallback(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["phone"] === "string" && value["phone"].trim() !== "" && typeof value["label"] === "string" && value["label"].trim() !== "";
+}
+function normalizeBaseUrl(baseUrl) {
+	return baseUrl.trim().replace(/\/+$/, "");
+}
+/**
+* Requests are sent with credentials and the CSRF token, so a plaintext or
+* attacker-controlled base URL would leak both. Same-origin paths (`/prefix`)
+* and HTTPS are accepted; plain HTTP is only accepted for loopback hosts.
+*/
+function validateBaseUrl(baseUrl) {
+	if (baseUrl.startsWith("/")) {
+		if (baseUrl.startsWith("//")) return "The BFF base URL must not be protocol-relative.";
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = new URL(baseUrl);
+	} catch {
+		return "The BFF base URL must be an absolute URL or a same-origin path.";
+	}
+	if (parsed.username !== "" || parsed.password !== "") return "The BFF base URL must not embed credentials.";
+	if (parsed.protocol === "https:") return null;
+	if (parsed.protocol === "http:" && (LOOPBACK_HOSTS.has(parsed.hostname) || parsed.hostname.endsWith(".localhost"))) return null;
+	return "The BFF base URL must use https: (http: is only allowed for localhost).";
+}
+function validateConfig(config) {
+	const bffBaseUrl = typeof config.bffBaseUrl === "string" ? normalizeBaseUrl(config.bffBaseUrl) : "";
+	const code = typeof config.code === "string" ? config.code.trim() : "";
+	if (bffBaseUrl === "") return {
+		ok: false,
+		config: null,
+		error: createEmergencyError("configuration", "A BFF base URL is required to mount the emergency client.")
+	};
+	const baseUrlError = validateBaseUrl(bffBaseUrl);
+	if (baseUrlError !== null) return {
+		ok: false,
+		config: null,
+		error: createEmergencyError("configuration", baseUrlError)
+	};
+	if (!isValidEmergencyCode(code)) return {
+		ok: false,
+		config: null,
+		error: createEmergencyError("configuration", "The identity code must be 6 characters and start with a letter.", { details: { code } })
+	};
+	if (config.fallback !== void 0 && !isValidFallback(config.fallback)) return {
+		ok: false,
+		config: null,
+		error: createEmergencyError("configuration", "The fallback requires a non-empty phone and label.")
+	};
+	return {
+		ok: true,
+		error: null,
+		config: {
+			...config,
+			bffBaseUrl,
+			code,
+			locale: config.locale ?? "es",
+			geolocationTimeoutMs: config.geolocationTimeoutMs ?? 8e3,
+			requestTimeoutMs: config.requestTimeoutMs ?? 15e3,
+			fontLoading: normalizeFontLoading(config.fontLoading)
+		}
+	};
+}
+
+// src/react/components/icons/paramedical-mark.tsx
+/**
+* Neutral inline illustration used by the idle panel.
+*/
+function ParamedicalMark({ className, title }) {
+	return /* @__PURE__ */ jsxs("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		version: "1.0",
+		viewBox: "0 0 192 192",
+		width: "192",
+		height: "192",
+		id: "Star of life",
+		className,
+		"aria-label": title,
+		children: [
+			/* @__PURE__ */ jsx("defs", { id: "defs2886" }),
+			/* @__PURE__ */ jsxs("g", {
+				id: "cross",
+				children: [/* @__PURE__ */ jsx("path", {
+					d: "m 74,133 0,52 44,0 0,-52 44,26 22,-38 L 140,96 184,70 162,32 117,58 117,7 74,7 74,58 30,32 8,70 52,96 8,121 30,159 z",
+					id: "outline",
+					style: {
+						fill: "none",
+						stroke: "#3333bb",
+						strokeWidth: 6
+					}
+				}), /* @__PURE__ */ jsx("path", {
+					d: "m 74,133 0,52 44,0 0,-52 44,26 22,-38 L 140,96 184,70 162,32 117,58 117,7 74,7 74,58 30,32 8,70 52,96 8,121 30,159 z",
+					id: "inner",
+					style: {
+						fill: "#0000bb",
+						fillRule: "evenodd",
+						stroke: "#ffffff",
+						strokeWidth: 2
+					}
+				})]
+			}),
+			/* @__PURE__ */ jsxs("g", {
+				id: "symbols",
+				style: {
+					fill: "#ffffff",
+					fillRule: "evenodd",
+					stroke: "#3333bb",
+					strokeWidth: 2
+				},
+				children: [/* @__PURE__ */ jsx("path", {
+					d: "m 93,166 c 0,7 6,7 6,0 l 3,-138 c 0,-8 -12,-8 -12,0 l 3,135 0,3 z",
+					id: "rod"
+				}), /* @__PURE__ */ jsxs("g", {
+					id: "snake",
+					children: [/* @__PURE__ */ jsx("path", {
+						d: "m 100,153 c 7,4 3,15 -3,15 2,-5 3,-9 3,-15 z m 1,-40 c 10,9 4,22 -3,26 -6,3 -6,7 -6,15 -9,-10 -4,-19 4,-24 5,-4 5,-10 5,-17 z m 1,-30 c 0,11 -17,14 -17,22 0,3 1,9 6,12 0,-11 9,-12 15,-18 7,-7 7,-19 -4,-28 0,4 0,8 0,12 z M 90,77 C 80,69 76,55 80,46 c 3,-10 20,-11 20,-3 0,8 -20,3 -13,16 l 3,5 0,13 z",
+						id: "body"
+					}), /* @__PURE__ */ jsx("path", {
+						d: "m 95,43 c 7,-3 -7,-3 0,0 z",
+						id: "eye",
+						style: {
+							fill: "#3333bb",
+							fillRule: "evenodd",
+							stroke: "none"
+						}
+					})]
+				})]
+			})
+		]
+	});
+}
+
+// src/react/components/Icon/index.tsx
+/** Icons whose artwork does not fit the default 24x24 grid need their own canvas. */
+const viewBoxes = { emergency: "0 0 640 640" };
+/** Icons rendered as a solid shape instead of a stroked outline. */
+const filledIcons = /* @__PURE__ */ new Set(["emergency"]);
+const paths = {
+	close: /* @__PURE__ */ jsx("path", { d: "M6 6l12 12M18 6L6 18" }),
+	"alert-triangle": /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("path", { d: "M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0Z" }),
+		/* @__PURE__ */ jsx("path", { d: "M12 9v4" }),
+		/* @__PURE__ */ jsx("path", { d: "M12 17h.01" })
+	] }),
+	"check-circle": /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "9"
+	}), /* @__PURE__ */ jsx("path", { d: "m8.5 12.5 2.5 2.5 4.5-5" })] }),
+	"x-circle": /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "9"
+	}), /* @__PURE__ */ jsx("path", { d: "m9 9 6 6M15 9l-6 6" })] }),
+	"exclamation-circle": /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("circle", {
+			cx: "12",
+			cy: "12",
+			r: "9"
+		}),
+		/* @__PURE__ */ jsx("path", { d: "M12 7v6" }),
+		/* @__PURE__ */ jsx("path", { d: "M12 17h.01" })
+	] }),
+	flag: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M5 3v18" }), /* @__PURE__ */ jsx("path", { d: "M5 4h12l-2.5 4L17 12H5" })] }),
+	"double-check": /* @__PURE__ */ jsx("path", { d: "m2 13 4 4 8-9M11 16l1 1 9-10" }),
+	rotate: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M21 12a9 9 0 1 1-2.64-6.36" }), /* @__PURE__ */ jsx("path", { d: "M21 3v6h-6" })] }),
+	"list-check": /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M10 6h10M10 12h10M10 18h10" }), /* @__PURE__ */ jsx("path", { d: "m3 6 1.5 1.5L7 5M3 12l1.5 1.5L7 11M3 18l1.5 1.5L7 17" })] }),
+	eye: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M2 12s3.5-6 10-6 10 6 10 6-3.5 6-10 6S2 12 2 12Z" }), /* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "2.5"
+	})] }),
+	message: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M21 12a8 8 0 0 1-8 8H7l-4 3V12a8 8 0 0 1 8-8h2a8 8 0 0 1 8 8Z" }), /* @__PURE__ */ jsx("path", { d: "M8 10h8M8 14h5" })] }),
+	clock: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "9"
+	}), /* @__PURE__ */ jsx("path", { d: "M12 7v5l3 2" })] }),
+	info: /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("circle", {
+			cx: "12",
+			cy: "12",
+			r: "9"
+		}),
+		/* @__PURE__ */ jsx("path", { d: "M12 11v6" }),
+		/* @__PURE__ */ jsx("path", { d: "M12 7h.01" })
+	] }),
+	"arrow-left": /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M19 12H5" }), /* @__PURE__ */ jsx("path", { d: "m12 19-7-7 7-7" })] }),
+	emergency: /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("path", { d: "M272.5 96C272.5 78.3 286.8 64 304.5 64L336.5 64C354.2 64 368.5 78.3 368.5 96L368.5 236.9L490.5 166.5C505.8 157.7 525.4 162.9 534.2 178.2L550.2 205.9C559 221.2 553.8 240.8 538.5 249.6L416.5 320L538.5 390.4C553.8 399.2 559.1 418.8 550.2 434.1L534.2 461.8C525.4 477.1 505.8 482.4 490.5 473.5L368.5 403.1L368.5 544C368.5 561.7 354.2 576 336.5 576L304.5 576C286.8 576 272.5 561.7 272.5 544L272.5 403.1L150.5 473.5C135.2 482.3 115.6 477.1 106.8 461.8L90.8 434.1C82 418.8 87.2 399.2 102.5 390.4L224.5 320L102.5 249.6C87.2 240.8 82 221.2 90.8 205.9L106.8 178.2C115.6 162.9 135.2 157.7 150.5 166.5L272.5 236.9L272.5 96z" }) })
+};
+function Icon({ name, className, title }) {
+	const stroked = !filledIcons.has(name);
+	return /* @__PURE__ */ jsxs("svg", {
+		className,
+		viewBox: viewBoxes[name] ?? "0 0 24 24",
+		width: "1rem",
+		height: "1rem",
+		fill: stroked ? "none" : "currentColor",
+		stroke: stroked ? "currentColor" : "none",
+		strokeWidth: stroked ? 2 : void 0,
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		"aria-hidden": title ? void 0 : "true",
+		role: title ? "img" : void 0,
+		focusable: "false",
+		children: [title ? /* @__PURE__ */ jsx("title", { children: title }) : null, paths[name]]
+	});
+}
+
+// src/styles/panel.module.css
+var panel_module_default = {
+	"de-emergency-fade-in": "de-emergency-de-emergency-fade-in-kMlO0G",
+	"de-emergency-pulse": "de-emergency-de-emergency-pulse-kMlO0G",
+	"de-emergency-pulse-error": "de-emergency-de-emergency-pulse-error-kMlO0G",
+	"de-emergency-slide-in": "de-emergency-de-emergency-slide-in-kMlO0G",
+	"de-emergency-slide-up": "de-emergency-de-emergency-slide-up-kMlO0G",
+	"de-emergency-spin": "de-emergency-de-emergency-spin-kMlO0G",
+	"emergency-confirmation": "de-emergency-emergency-confirmation-kMlO0G",
+	"emergency-confirmation__body": "de-emergency-emergency-confirmation__body-kMlO0G",
+	"emergency-confirmation__button": "de-emergency-emergency-confirmation__button-kMlO0G",
+	"emergency-confirmation__button--cancel": "de-emergency-emergency-confirmation__button--cancel-kMlO0G",
+	"emergency-confirmation__button--confirm": "de-emergency-emergency-confirmation__button--confirm-kMlO0G",
+	"emergency-confirmation__button--danger": "de-emergency-emergency-confirmation__button--danger-kMlO0G",
+	"emergency-confirmation__card": "de-emergency-emergency-confirmation__card-kMlO0G",
+	"emergency-confirmation__footer": "de-emergency-emergency-confirmation__footer-kMlO0G",
+	"emergency-confirmation__icon": "de-emergency-emergency-confirmation__icon-kMlO0G",
+	"emergency-confirmation__icon--danger": "de-emergency-emergency-confirmation__icon--danger-kMlO0G",
+	"emergency-confirmation__icon--information": "de-emergency-emergency-confirmation__icon--information-kMlO0G",
+	"emergency-confirmation__text": "de-emergency-emergency-confirmation__text-kMlO0G",
+	"emergency-confirmation__title": "de-emergency-emergency-confirmation__title-kMlO0G",
+	"emergency-error-message": "de-emergency-emergency-error-message-kMlO0G",
+	"emergency-error-message__container": "de-emergency-emergency-error-message__container-kMlO0G",
+	"emergency-error-message__content": "de-emergency-emergency-error-message__content-kMlO0G",
+	"emergency-error-message__detail": "de-emergency-emergency-error-message__detail-kMlO0G",
+	"emergency-error-message__details": "de-emergency-emergency-error-message__details-kMlO0G",
+	"emergency-error-message__icon": "de-emergency-emergency-error-message__icon-kMlO0G",
+	"emergency-error-message__text": "de-emergency-emergency-error-message__text-kMlO0G",
+	"emergency-error-message__title": "de-emergency-emergency-error-message__title-kMlO0G",
+	"emergency-feedback": "de-emergency-emergency-feedback-kMlO0G",
+	"emergency-feedback__dismiss": "de-emergency-emergency-feedback__dismiss-kMlO0G",
+	"emergency-panel": "de-emergency-emergency-panel-kMlO0G",
+	"emergency-panel__body": "de-emergency-emergency-panel__body-kMlO0G",
+	"emergency-panel__body-title": "de-emergency-emergency-panel__body-title-kMlO0G",
+	"emergency-panel__body-title-container": "de-emergency-emergency-panel__body-title-container-kMlO0G",
+	"emergency-panel__button": "de-emergency-emergency-panel__button-kMlO0G",
+	"emergency-panel__button--emergency": "de-emergency-emergency-panel__button--emergency-kMlO0G",
+	"emergency-panel__button--simulation": "de-emergency-emergency-panel__button--simulation-kMlO0G",
+	"emergency-panel__close-button": "de-emergency-emergency-panel__close-button-kMlO0G",
+	"emergency-panel__close-icon": "de-emergency-emergency-panel__close-icon-kMlO0G",
+	"emergency-panel__footer": "de-emergency-emergency-panel__footer-kMlO0G",
+	"emergency-panel__header": "de-emergency-emergency-panel__header-kMlO0G",
+	"emergency-panel__title": "de-emergency-emergency-panel__title-kMlO0G",
+	"emergency-panel--hidden": "de-emergency-emergency-panel--hidden-kMlO0G",
+	"emergency-resume-notification-button": "de-emergency-emergency-resume-notification-button-kMlO0G",
+	"emergency-resume-notification-card": "de-emergency-emergency-resume-notification-card-kMlO0G",
+	"emergency-resume-notification-icon": "de-emergency-emergency-resume-notification-icon-kMlO0G",
+	"emergency-resume-notification-message": "de-emergency-emergency-resume-notification-message-kMlO0G",
+	"emergency-resume-notification-overlay": "de-emergency-emergency-resume-notification-overlay-kMlO0G",
+	"emergency-resume-notification-title": "de-emergency-emergency-resume-notification-title-kMlO0G",
+	"emergency-status__abort-btn": "de-emergency-emergency-status__abort-btn-kMlO0G",
+	"emergency-status__body": "de-emergency-emergency-status__body-kMlO0G",
+	"emergency-status__cell": "de-emergency-emergency-status__cell-kMlO0G",
+	"emergency-status__cell-icon": "de-emergency-emergency-status__cell-icon-kMlO0G",
+	"emergency-status__cell-text": "de-emergency-emergency-status__cell-text-kMlO0G",
+	"emergency-status__cell-time": "de-emergency-emergency-status__cell-time-kMlO0G",
+	"emergency-status__grid": "de-emergency-emergency-status__grid-kMlO0G",
+	"emergency-status__header": "de-emergency-emergency-status__header-kMlO0G",
+	"emergency-status__loading": "de-emergency-emergency-status__loading-kMlO0G",
+	"emergency-status__loading-text": "de-emergency-emergency-status__loading-text-kMlO0G",
+	"emergency-status__panel": "de-emergency-emergency-status__panel-kMlO0G",
+	"emergency-status__row": "de-emergency-emergency-status__row-kMlO0G",
+	"emergency-status__row-container": "de-emergency-emergency-status__row-container-kMlO0G",
+	"emergency-status__spinner": "de-emergency-emergency-status__spinner-kMlO0G",
+	"emergency-status-panel__header": "de-emergency-emergency-status-panel__header-kMlO0G",
+	"emergency-status-panel__refresh-btn": "de-emergency-emergency-status-panel__refresh-btn-kMlO0G",
+	"emergency-status-panel__refresh-btn-container": "de-emergency-emergency-status-panel__refresh-btn-container-kMlO0G",
+	"emergency-status-panel__refresh-icon": "de-emergency-emergency-status-panel__refresh-icon-kMlO0G",
+	"emergency-status-panel__title": "de-emergency-emergency-status-panel__title-kMlO0G",
+	"responder-name": "de-emergency-responder-name-kMlO0G",
+	"simulacrum-success-message": "de-emergency-simulacrum-success-message-kMlO0G",
+	"simulacrum-success-message__container": "de-emergency-simulacrum-success-message__container-kMlO0G",
+	"simulacrum-success-message__content": "de-emergency-simulacrum-success-message__content-kMlO0G",
+	"simulacrum-success-message__detail": "de-emergency-simulacrum-success-message__detail-kMlO0G",
+	"simulacrum-success-message__details": "de-emergency-simulacrum-success-message__details-kMlO0G",
+	"simulacrum-success-message__icon": "de-emergency-simulacrum-success-message__icon-kMlO0G",
+	"simulacrum-success-message__text": "de-emergency-simulacrum-success-message__text-kMlO0G",
+	"simulacrum-success-message__title": "de-emergency-simulacrum-success-message__title-kMlO0G",
+	"sos-img": "de-emergency-sos-img-kMlO0G",
+	"sos-img__container": "de-emergency-sos-img__container-kMlO0G",
+	"status-icon": "de-emergency-status-icon-kMlO0G",
+	"status-icon--checked": "de-emergency-status-icon--checked-kMlO0G",
+	"status-icon--failed": "de-emergency-status-icon--failed-kMlO0G",
+	"status-icon--unchecked": "de-emergency-status-icon--unchecked-kMlO0G"
+};
+
+// src/react/classnames.ts
+/**
+* Joins local CSS Module class names, omitting names that are not in the
+* module.
+*/
+function cls(...names) {
+	return names.filter((name) => Boolean(name)).map((name) => panel_module_default[name] ?? "").filter(Boolean).join(" ");
+}
+
+// src/react/components/MessageSurface/index.tsx
+function MessageSurface(props) {
+	const { variant, icon, title, text, details, className, children } = props;
+	const prefix = variant === "success" ? "simulacrum-success-message" : "emergency-error-message";
+	const success = variant === "success";
+	return /* @__PURE__ */ jsxs("div", {
+		className: [cls(prefix), className].filter(Boolean).join(" "),
+		role: success ? "status" : "alert",
+		"aria-live": success ? "polite" : "assertive",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: cls(`${prefix}__container`),
+			children: [/* @__PURE__ */ jsx("div", {
+				className: cls(`${prefix}__icon`),
+				children: /* @__PURE__ */ jsx(Icon, {
+					name: icon,
+					className: "status-icon"
+				})
+			}), /* @__PURE__ */ jsxs("div", {
+				className: cls(`${prefix}__content`),
+				children: [
+					/* @__PURE__ */ jsx("h3", {
+						className: cls(`${prefix}__title`),
+						children: title
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: cls(`${prefix}__text`),
+						children: text
+					}),
+					/* @__PURE__ */ jsx("div", {
+						className: cls(`${prefix}__details`),
+						children: details.map((detail) => /* @__PURE__ */ jsxs("span", {
+							className: cls(`${prefix}__detail`),
+							children: [/* @__PURE__ */ jsx(Icon, { name: detail.icon }), detail.text]
+						}, detail.text))
+					})
+				]
+			})]
+		}), children]
+	});
+}
+
+// src/react/components/EmergencyError/index.tsx
+function EmergencyError({ error, onRetry }) {
+	return /* @__PURE__ */ jsx(MessageSurface, {
+		variant: "error",
+		icon: "exclamation-circle",
+		title: copy.errorTitle,
+		text: error.message || copy.errorText,
+		details: [{
+			icon: "info",
+			text: copy.errorDetailInfo
+		}, {
+			icon: "arrow-left",
+			text: copy.errorDetailRetry
+		}],
+		children: /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: cls("emergency-feedback__dismiss"),
+			onClick: onRetry,
+			children: copy.retry
+		})
+	});
+}
+
+// src/react/components/EmergencyFeedback/index.tsx
+/** Time the feedback stays on screen before dismissing itself. */
+const FEEDBACK_AUTO_DISMISS_MS = 3e3;
+/** Time the geolocation feedback stays on screen before dismissing itself. */
+const GEOLOCATION_FEEDBACK_AUTO_DISMISS_MS = 5e3;
+function geolocationText(error) {
+	switch (error.code) {
+		case "geolocation_denied": return copy.geolocationDenied;
+		case "geolocation_timeout": return copy.geolocationTimeout;
+		case "geolocation_unsupported": return copy.geolocationUnsupported;
+		default: return copy.geolocationUnavailable;
+	}
+}
+function EmergencyFeedback({ abortResult, simulationResult, geolocationError, activationError, onDismiss }) {
+	const result = abortResult ?? simulationResult;
+	const feedbackActivationError = result ? null : activationError ?? null;
+	const feedbackGeolocationError = result || feedbackActivationError ? null : geolocationError;
+	if (!result && !feedbackActivationError && !feedbackGeolocationError) return null;
+	return /* @__PURE__ */ jsx(FeedbackSurface, {
+		result,
+		aborting: abortResult !== null,
+		geolocationError: feedbackGeolocationError,
+		activationError: feedbackActivationError,
+		onDismiss
+	});
+}
+function FeedbackSurface({ result, aborting, geolocationError, activationError, onDismiss }) {
+	const dismissRef = useRef(onDismiss);
+	useEffect(() => {
+		dismissRef.current = onDismiss;
+	}, [onDismiss]);
+	useEffect(() => {
+		const timeout = setTimeout(() => dismissRef.current(), geolocationError || activationError ? GEOLOCATION_FEEDBACK_AUTO_DISMISS_MS : FEEDBACK_AUTO_DISMISS_MS);
+		return () => clearTimeout(timeout);
+	}, [
+		result?.at,
+		geolocationError,
+		activationError
+	]);
+	const success = result?.ok === true;
+	const title = success ? aborting ? copy.abortSuccessTitle : copy.simulateSuccessTitle : copy.errorTitle;
+	const text = success ? result?.message ?? "" : geolocationError ? geolocationText(geolocationError) : activationError ? activationError.message || copy.errorText : result?.message ?? copy.errorText;
+	const details = success ? aborting ? [{
+		icon: "message",
+		text: copy.abortSuccessDetails
+	}] : [{
+		icon: "message",
+		text: copy.simulateSuccessDetails
+	}, {
+		icon: "clock",
+		text: copy.simulateSuccessCompleted
+	}] : [{
+		icon: "info",
+		text: copy.errorDetailInfo
+	}, {
+		icon: "arrow-left",
+		text: copy.errorDetailRetry
+	}];
+	return /* @__PURE__ */ jsx(MessageSurface, {
+		variant: success ? "success" : "error",
+		icon: success ? "check-circle" : "alert-triangle",
+		title,
+		text,
+		details,
+		className: cls("emergency-feedback"),
+		children: /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: cls("emergency-feedback__dismiss"),
+			onClick: onDismiss,
+			children: copy.feedbackDismiss
+		})
+	});
+}
+
+// src/react/components/EmergencyLoading/index.tsx
+function EmergencyLoading() {
+	return /* @__PURE__ */ jsxs("div", {
+		className: cls("emergency-status__loading"),
+		role: "status",
+		"aria-live": "polite",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: cls("emergency-status__spinner"),
+			"aria-hidden": "true"
+		}), /* @__PURE__ */ jsx("span", {
+			className: cls("emergency-status__loading-text"),
+			children: copy.loading
+		})]
+	});
+}
+
+// src/core/date.ts
+/**
+* Formats a timestamp as `h:mmam` or `h:mmpm` in local time, without a space
+* or leading zero.
+*/
+function formatShortTime(value, locale = "es") {
+	if (value === null) return "";
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) return "";
+	const parts = new Intl.DateTimeFormat(locale, {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true
+	}).formatToParts(date);
+	const hour = parts.find((part) => part.type === "hour")?.value;
+	const minute = parts.find((part) => part.type === "minute")?.value;
+	const dayPeriod = parts.find((part) => part.type === "dayPeriod")?.value;
+	if (!hour || !minute) return "";
+	return `${hour}:${minute}${normalizePeriod(dayPeriod)}`;
+}
+function normalizePeriod(dayPeriod) {
+	if (!dayPeriod) return "";
+	if (/^p/i.test(dayPeriod)) return "pm";
+	return /^a/i.test(dayPeriod) ? "am" : "";
+}
+
+// src/react/components/StatusIcon/index.tsx
+/**
+* Explicit responder state model:
+* - `failed`: the send operation failed (red alert in the "Sent" cell only).
+* - `confirmed`: checked circle.
+* - otherwise: unchecked circle.
+*/
+function StatusIcon({ confirmed, failed = false }) {
+	return /* @__PURE__ */ jsx(Icon, {
+		name: failed ? "exclamation-circle" : confirmed ? "check-circle" : "x-circle",
+		className: cls("status-icon", failed ? "status-icon--failed" : confirmed ? "status-icon--checked" : "status-icon--unchecked")
+	});
+}
+
+// src/react/components/StatusCell/index.tsx
+function StatusCell({ confirmed, timestamp, failed = false, isFailedIcon = false, locale }) {
+	const showTime = !failed && timestamp !== null && timestamp !== "";
+	const showIcon = failed ? isFailedIcon : true;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cls("emergency-status__cell"),
+		children: [/* @__PURE__ */ jsx("p", {
+			className: cls("emergency-status__cell-icon"),
+			children: showIcon ? /* @__PURE__ */ jsx(StatusIcon, {
+				confirmed,
+				failed
+			}) : null
+		}), showTime ? /* @__PURE__ */ jsx("p", {
+			className: cls("emergency-status__cell-time"),
+			children: formatShortTime(timestamp, locale)
+		}) : null]
+	});
+}
+
+// src/react/components/ResponderRow/index.tsx
+function ResponderRow({ responder, locale }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cls("emergency-status__row-container"),
+		"data-responder-id": responder.phone,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: cls("emergency-status__row"),
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: cls("emergency-status__cell", "responder-name"),
+					children: /* @__PURE__ */ jsx("p", {
+						className: cls("emergency-status__cell-text"),
+						children: responder.name
+					})
+				}),
+				/* @__PURE__ */ jsx(StatusCell, {
+					confirmed: responder.sent,
+					timestamp: responder.sentAt,
+					failed: responder.failed,
+					isFailedIcon: true,
+					locale
+				}),
+				/* @__PURE__ */ jsx(StatusCell, {
+					confirmed: responder.delivered,
+					timestamp: responder.deliveredAt,
+					failed: responder.failed,
+					locale
+				}),
+				/* @__PURE__ */ jsx(StatusCell, {
+					confirmed: responder.read,
+					timestamp: responder.readAt,
+					failed: responder.failed,
+					locale
+				})
+			]
+		})
+	});
+}
+
+// src/react/components/EmergencyStatusPanel/index.tsx
+function EmergencyStatusPanel({ responders, refreshing, locale, onRefresh }) {
+	const columns = [
+		copy.responderColumn,
+		copy.sentColumn,
+		copy.deliveredColumn,
+		copy.readColumn
+	];
+	return /* @__PURE__ */ jsxs("div", {
+		className: cls("emergency-status__panel"),
+		children: [/* @__PURE__ */ jsx("div", {
+			className: cls("emergency-status-panel__header"),
+			children: /* @__PURE__ */ jsx("h3", {
+				className: cls("emergency-status-panel__title"),
+				children: copy.statusTitle
+			})
+		}), /* @__PURE__ */ jsxs("div", {
+			className: cls("emergency-status__grid"),
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: cls("emergency-status__header"),
+					children: columns.map((column) => /* @__PURE__ */ jsx("div", {
+						className: cls("emergency-status__cell"),
+						children: /* @__PURE__ */ jsx("p", {
+							className: cls("emergency-status__cell-text"),
+							children: column
+						})
+					}, column))
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: cls("emergency-status__body"),
+					children: [responders.map((responder) => /* @__PURE__ */ jsx(ResponderRow, {
+						responder,
+						locale
+					}, `${responder.phone}-${responder.name}`)), responders.length === 0 ? /* @__PURE__ */ jsx("p", {
+						className: cls("emergency-status__cell-text"),
+						children: copy.respondersEmpty
+					}) : null]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: cls("emergency-status-panel__refresh-btn-container"),
+					children: [/* @__PURE__ */ jsxs("button", {
+						type: "button",
+						className: cls("emergency-status-panel__refresh-btn"),
+						"aria-label": copy.refresh,
+						disabled: refreshing,
+						onClick: onRefresh,
+						children: [/* @__PURE__ */ jsx(Icon, {
+							name: "rotate",
+							className: cls("emergency-status-panel__refresh-icon")
+						}), /* @__PURE__ */ jsx("span", {
+							className: cls("emergency-status-panel__refresh-text"),
+							children: refreshing ? copy.refreshing : copy.refresh
+						})]
+					}), refreshing ? /* @__PURE__ */ jsxs("div", {
+						className: cls("emergency-status__loading"),
+						role: "status",
+						"aria-live": "polite",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: cls("emergency-status__spinner"),
+							"aria-hidden": "true"
+						}), /* @__PURE__ */ jsx("span", {
+							className: cls("emergency-status__loading-text"),
+							children: copy.refreshing
+						})]
+					}) : null]
+				})
+			]
+		})]
+	});
+}
+
+// src/react/components/EmergencyBody/index.tsx
+function EmergencyBody(props) {
+	const { active, responders, refreshing, loading, locale, geolocationError, activationError, error, abortResult, simulationResult, onRefresh, onRetry, onDismissFeedback } = props;
+	const showingFeedback = geolocationError !== null || Boolean(activationError) || abortResult !== null || simulationResult !== null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		!loading && !showingFeedback ? /* @__PURE__ */ jsx("div", {
+			className: cls("sos-img__container"),
+			id: "sos-img__container",
+			children: /* @__PURE__ */ jsx(ParamedicalMark, {
+				className: cls("sos-img"),
+				title: copy.illustrationAlt
+			})
+		}) : null,
+		active || loading || showingFeedback ? null : /* @__PURE__ */ jsx("div", {
+			className: cls("emergency-panel__body-title-container"),
+			children: /* @__PURE__ */ jsx("h4", {
+				className: cls("emergency-panel__body-title"),
+				children: copy.question
+			})
+		}),
+		active && !showingFeedback ? /* @__PURE__ */ jsx(EmergencyStatusPanel, {
+			responders,
+			refreshing,
+			locale,
+			onRefresh
+		}) : null,
+		loading ? /* @__PURE__ */ jsx(EmergencyLoading, {}) : null,
+		error ? /* @__PURE__ */ jsx(EmergencyError, {
+			error,
+			onRetry
+		}) : null,
+		/* @__PURE__ */ jsx(EmergencyFeedback, {
+			abortResult,
+			simulationResult,
+			geolocationError,
+			activationError,
+			onDismiss: onDismissFeedback
+		})
+	] });
+}
+
+// src/react/components/EmergencyConfirmation/index.tsx
+function EmergencyConfirmation(props) {
+	const { abortConfirmation, simulationConfirmation, onCancelAbort, onCancelSimulation, onConfirmAbort, onConfirmSimulation } = props;
+	const cardRef = useRef(null);
+	const titleId = useId();
+	const danger = abortConfirmation;
+	const open = abortConfirmation || simulationConfirmation;
+	useEffect(() => {
+		if (open) cardRef.current?.querySelector("button")?.focus();
+	}, [open]);
+	if (!open) return null;
+	const title = danger ? copy.abortConfirmTitle : copy.simulateConfirmTitle;
+	const text = danger ? copy.abortConfirmText : copy.simulateConfirmText;
+	const tone = danger ? "danger" : "information";
+	return /* @__PURE__ */ jsx("div", {
+		className: cls("emergency-confirmation"),
+		role: "dialog",
+		"aria-modal": "true",
+		"aria-labelledby": titleId,
+		children: /* @__PURE__ */ jsxs("div", {
+			ref: cardRef,
+			className: cls("emergency-confirmation__card"),
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: cls("emergency-confirmation__body"),
+				children: [
+					/* @__PURE__ */ jsx("div", {
+						className: cls("emergency-confirmation__icon", `emergency-confirmation__icon--${tone}`),
+						children: /* @__PURE__ */ jsx(Icon, { name: danger ? "alert-triangle" : "info" })
+					}),
+					/* @__PURE__ */ jsx("h5", {
+						className: cls("emergency-confirmation__title"),
+						id: titleId,
+						children: title
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: cls("emergency-confirmation__text"),
+						children: text
+					})
+				]
+			}), /* @__PURE__ */ jsxs("div", {
+				className: cls("emergency-confirmation__footer"),
+				children: [/* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: cls("emergency-confirmation__button", "emergency-confirmation__button--cancel"),
+					onClick: danger ? onCancelAbort : onCancelSimulation,
+					children: danger ? copy.abortCancel : copy.simulateCancel
+				}), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: cls("emergency-confirmation__button", danger ? "emergency-confirmation__button--danger" : "emergency-confirmation__button--confirm"),
+					onClick: danger ? onConfirmAbort : onConfirmSimulation,
+					children: danger ? copy.abortConfirm : copy.simulateConfirm
+				})]
+			})]
+		})
+	});
+}
+
+// src/react/components/EmergencyFooter/index.tsx
+function EmergencyFooter(props) {
+	const { active, busy, aborting, feedbackVisible, onActivate, onRequestAbort, onRequestSimulation } = props;
+	if (active) return /* @__PURE__ */ jsx("footer", {
+		className: cls("emergency-panel__footer"),
+		children: /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: cls("emergency-status__abort-btn"),
+			"aria-label": copy.abort,
+			disabled: aborting || feedbackVisible,
+			onClick: onRequestAbort,
+			children: [copy.abort, /* @__PURE__ */ jsx(Icon, { name: "alert-triangle" })]
+		})
+	});
+	return /* @__PURE__ */ jsxs("footer", {
+		className: cls("emergency-panel__footer"),
+		children: [/* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: cls("emergency-panel__button", "emergency-panel__button--emergency"),
+			"aria-label": copy.emergencyAria,
+			disabled: busy || feedbackVisible,
+			onClick: onActivate,
+			children: [copy.emergency, /* @__PURE__ */ jsx(Icon, { name: "emergency" })]
+		}), /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: cls("emergency-panel__button", "emergency-panel__button--simulation"),
+			"aria-label": copy.testAria,
+			disabled: busy || feedbackVisible,
+			onClick: onRequestSimulation,
+			children: [copy.test, /* @__PURE__ */ jsx(Icon, { name: "list-check" })]
+		})]
+	});
+}
+
+// src/react/components/EmergencyHeader/index.tsx
+function EmergencyHeader({ titleId, onClose }) {
+	return /* @__PURE__ */ jsxs("header", {
+		className: cls("emergency-panel__header"),
+		children: [/* @__PURE__ */ jsx("h2", {
+			className: cls("emergency-panel__title"),
+			id: titleId,
+			children: copy.panelLabel
+		}), /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: cls("emergency-panel__close-button"),
+			"aria-label": copy.close,
+			onClick: onClose,
+			children: /* @__PURE__ */ jsx(Icon, {
+				name: "close",
+				className: cls("emergency-panel__close-icon")
+			})
+		})]
+	});
+}
+
+// src/react/hooks/useEscapeKey.ts
+function useEscapeKey(active, onEscape) {
+	useEffect(() => {
+		if (!active || typeof document === "undefined") return;
+		const handleKeyDown = (event) => {
+			if (event.key === "Escape") {
+				event.stopPropagation();
+				onEscape();
+			}
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => {
+			document.removeEventListener("keydown", handleKeyDown);
+		};
+	}, [active, onEscape]);
+}
+
+// src/react/hooks/useFocusTrap.ts
+const FOCUSABLE_SELECTOR = [
+	"a[href]",
+	"button:not([disabled])",
+	"input:not([disabled])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"[tabindex]:not([tabindex=\"-1\"])"
+].join(",");
+/**
+* Keeps keyboard focus inside the dialog while it is open and restores focus to
+* the element that opened it when it closes.
+*/
+function useFocusTrap(ref, active) {
+	useEffect(() => {
+		if (!active || typeof document === "undefined") return;
+		const container = ref.current;
+		if (!container) return;
+		const previouslyFocused = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+		const focusable = () => Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR)).filter((element) => !element.hasAttribute("hidden") && element.getAttribute("aria-hidden") !== "true");
+		(focusable()[0] ?? container).focus({ preventScroll: true });
+		const handleKeyDown = (event) => {
+			if (event.key !== "Tab") return;
+			const items = focusable();
+			if (items.length === 0) {
+				event.preventDefault();
+				container.focus({ preventScroll: true });
+				return;
+			}
+			const first = items[0];
+			const last = items[items.length - 1];
+			const current = document.activeElement;
+			if (event.shiftKey && (current === first || !container.contains(current))) {
+				event.preventDefault();
+				if (last) last.focus({ preventScroll: true });
+				return;
+			}
+			if (!event.shiftKey && current === last && first) {
+				event.preventDefault();
+				first.focus({ preventScroll: true });
+			}
+		};
+		document.addEventListener("keydown", handleKeyDown, true);
+		return () => {
+			document.removeEventListener("keydown", handleKeyDown, true);
+			if (previouslyFocused?.isConnected) previouslyFocused.focus({ preventScroll: true });
+		};
+	}, [active, ref]);
+}
+
+// src/react/components/EmergencyPanel/index.tsx
+function EmergencyPanel(props) {
+	const { open, theme, active, busy, aborting, loading, locale, responders, refreshing, geolocationError, activationError, error, abortResult, simulationResult, abortConfirmation, simulationConfirmation, onClose, onActivate, onRefresh, onRetry, onDismissFeedback, onRequestAbort, onRequestSimulation, onCancelAbort, onCancelSimulation, onConfirmAbort, onConfirmSimulation } = props;
+	const titleId = useId();
+	const dialogRef = useRef(null);
+	const feedbackVisible = geolocationError !== null || Boolean(activationError) || abortResult !== null || simulationResult !== null;
+	const closeOnEscape = useCallback(() => {
+		onClose("escape");
+	}, [onClose]);
+	useFocusTrap(dialogRef, open);
+	useEscapeKey(open, closeOnEscape);
+	return /* @__PURE__ */ jsxs("div", {
+		ref: dialogRef,
+		className: cls("emergency-panel", !open && "emergency-panel--hidden"),
+		style: themeToCssVariables(theme),
+		role: "dialog",
+		"aria-modal": "true",
+		"aria-labelledby": titleId,
+		"aria-hidden": !open,
+		inert: !open,
+		tabIndex: -1,
+		children: [
+			/* @__PURE__ */ jsx(EmergencyHeader, {
+				titleId,
+				onClose: () => onClose("close")
+			}),
+			/* @__PURE__ */ jsx("section", {
+				className: cls("emergency-panel__body"),
+				"aria-labelledby": titleId,
+				children: /* @__PURE__ */ jsx(EmergencyBody, {
+					active,
+					responders,
+					refreshing,
+					loading,
+					locale,
+					geolocationError,
+					activationError,
+					error,
+					abortResult,
+					simulationResult,
+					onRefresh,
+					onRetry,
+					onDismissFeedback
+				})
+			}),
+			/* @__PURE__ */ jsx(EmergencyFooter, {
+				active,
+				busy,
+				aborting,
+				feedbackVisible,
+				onActivate,
+				onRequestAbort,
+				onRequestSimulation
+			}),
+			/* @__PURE__ */ jsx(EmergencyConfirmation, {
+				abortConfirmation,
+				simulationConfirmation,
+				onCancelAbort,
+				onCancelSimulation,
+				onConfirmAbort,
+				onConfirmSimulation
+			})
+		]
+	});
+}
+
+// src/react/components/EmergencyResumeNotification/index.tsx
+function EmergencyResumeNotification(props) {
+	const { resumeAvailable, onOpen } = props;
+	const titleId = useId();
+	if (!resumeAvailable) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cls("emergency-resume-notification-overlay"),
+		role: "dialog",
+		"aria-modal": "true",
+		"aria-labelledby": titleId,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: cls("emergency-resume-notification-card"),
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: cls("emergency-resume-notification-icon"),
+					"aria-hidden": "true",
+					children: /* @__PURE__ */ jsx(Icon, { name: "alert-triangle" })
+				}),
+				/* @__PURE__ */ jsx("h2", {
+					className: cls("emergency-resume-notification-title"),
+					id: titleId,
+					children: copy.resumeTitle
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: cls("emergency-resume-notification-message"),
+					children: copy.resumeDescription
+				}),
+				/* @__PURE__ */ jsxs("button", {
+					type: "button",
+					className: cls("emergency-resume-notification-button"),
+					"aria-label": copy.resumeAction,
+					onClick: onOpen,
+					children: [/* @__PURE__ */ jsx(Icon, { name: "eye" }), copy.resumeAction]
+				})
+			]
+		})
+	});
+}
+
+// src/react/context.tsx
+const EmergencyContext = createContext(null);
+function EmergencyProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(EmergencyContext.Provider, {
+		value,
+		children
+	});
+}
+function useEmergencyContext() {
+	const value = useContext(EmergencyContext);
+	if (value === null) throw new Error("Emergency components must be rendered inside an emergency client.");
+	return value;
+}
+
+// src/react/hooks/useEmergencyController.ts
+function useEmergencyController() {
+	return useEmergencyContext().client;
+}
+
+// src/react/hooks/useEmergencyStore.ts
+function useEmergencyStore(selector) {
+	const { store } = useEmergencyContext();
+	return useStore(store, selector);
+}
+
+// src/react/components/EmergencyRoot/index.tsx
+const BUSY_PHASES = [
+	"initializing",
+	"activating",
+	"simulating",
+	"aborting"
+];
+function EmergencyRoot() {
+	const client = useEmergencyController();
+	const panelOpen = useEmergencyStore((state) => state.panelOpen);
+	const phase = useEmergencyStore((state) => state.phase);
+	const config = useEmergencyStore((state) => state.config);
+	const snapshot = useEmergencyStore((state) => state.snapshot);
+	const responders = useEmergencyStore((state) => state.responders);
+	const resumeAvailable = useEmergencyStore((state) => state.resumeAvailable);
+	const geolocationError = useEmergencyStore((state) => state.geolocationError);
+	const lastError = useEmergencyStore((state) => state.lastError);
+	const abortResult = useEmergencyStore((state) => state.abortResult);
+	const simulationResult = useEmergencyStore((state) => state.simulationResult);
+	const abortConfirmation = useEmergencyStore((state) => state.abortConfirmation);
+	const simulationConfirmation = useEmergencyStore((state) => state.simulationConfirmation);
+	const active = snapshot?.active === true;
+	const busy = BUSY_PHASES.includes(phase.kind);
+	const feedbackActive = geolocationError !== null || abortResult !== null || simulationResult !== null;
+	const activationError = phase.kind === "ready" && !feedbackActive ? lastError : null;
+	const showError = phase.kind === "error" || lastError !== null && !feedbackActive && activationError === null;
+	const error = phase.kind === "error" ? phase.error : lastError;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(EmergencyResumeNotification, {
+		resumeAvailable,
+		onOpen: () => client.open("resume")
+	}), /* @__PURE__ */ jsx(EmergencyPanel, {
+		open: panelOpen,
+		theme: config.theme,
+		active,
+		busy,
+		aborting: phase.kind === "aborting",
+		loading: phase.kind === "initializing" || phase.kind === "activating",
+		locale: config.locale ?? "es",
+		responders,
+		refreshing: phase.kind === "refreshing",
+		geolocationError,
+		activationError,
+		error: showError ? error : null,
+		abortResult,
+		simulationResult,
+		abortConfirmation,
+		simulationConfirmation,
+		onClose: (reason) => client.close(reason),
+		onActivate: () => {
+			client.activate();
+		},
+		onRefresh: () => {
+			client.refresh();
+		},
+		onRetry: () => {
+			client.activate();
+		},
+		onDismissFeedback: () => client.dismissFeedback(),
+		onRequestAbort: () => client.requestAbortConfirmation(),
+		onRequestSimulation: () => client.requestSimulationConfirmation(),
+		onCancelAbort: () => client.cancelAbortConfirmation(),
+		onCancelSimulation: () => client.cancelSimulationConfirmation(),
+		onConfirmAbort: () => {
+			client.abort();
+		},
+		onConfirmSimulation: () => {
+			client.simulate();
+		}
+	})] });
+}
+
+// src/mount.tsx
+function resolveRoot(root) {
+	if (typeof root === "string") {
+		if (typeof document === "undefined") return null;
+		return document.querySelector(root);
+	}
+	return root instanceof HTMLElement ? root : null;
+}
+function createFailedClient(error) {
+	const state = {
+		config: {
+			bffBaseUrl: "",
+			code: ""
+		},
+		phase: {
+			kind: "error",
+			error
+		},
+		panelOpen: false,
+		sessionReady: false,
+		resumeAvailable: false,
+		snapshot: null,
+		responders: [],
+		failures: [],
+		messages: [],
+		lastError: error,
+		geolocation: null,
+		geolocationError: null,
+		realtimeStatus: "idle",
+		abortResult: null,
+		simulationResult: null,
+		abortConfirmation: false,
+		simulationConfirmation: false,
+		destroyed: false
+	};
+	const noop = () => void 0;
+	const noopAsync = async () => void 0;
+	return {
+		open: noop,
+		close: noop,
+		destroy: noop,
+		getState: () => state,
+		subscribe: () => () => void 0,
+		on: () => () => void 0,
+		off: noop,
+		ensureSession: noopAsync,
+		resume: noopAsync,
+		dismissResume: noop,
+		activate: noopAsync,
+		simulate: noopAsync,
+		refresh: noopAsync,
+		abort: noopAsync,
+		requestAbortConfirmation: noop,
+		cancelAbortConfirmation: noop,
+		requestSimulationConfirmation: noop,
+		cancelSimulationConfirmation: noop,
+		dismissFeedback: noop
+	};
+}
+function attachTrigger(trigger, client) {
+	if (!trigger) return () => void 0;
+	if (typeof trigger === "function") {
+		const cleanup = trigger(() => client.open());
+		return typeof cleanup === "function" ? cleanup : () => void 0;
+	}
+	const element = typeof trigger === "string" ? typeof document === "undefined" ? null : document.querySelector(trigger) : trigger;
+	if (!element) return () => void 0;
+	const listener = (event) => {
+		event.preventDefault();
+		client.open();
+	};
+	element.addEventListener("click", listener);
+	return () => {
+		element.removeEventListener("click", listener);
+	};
+}
+function reportConfigurationError(error, options) {
+	if (typeof console !== "undefined" && typeof console.error === "function") console.error("[emergency]", error.message);
+	options.onEvent?.("emergency:failed", {
+		error,
+		operation: "mount"
+	});
+	return createFailedClient(error);
+}
+/**
+* Mounts the emergency client into a host element. Validation failures never
+* throw into the host page: they produce a typed configuration error, a console
+* message, and an inert client.
+*/
+function mount(options) {
+	if (typeof document === "undefined") return reportConfigurationError(createEmergencyError("configuration", "mount() requires a browser environment."), options);
+	const root = resolveRoot(options.root);
+	if (!root) return reportConfigurationError(createEmergencyError("configuration", `The mount root "${typeof options.root === "string" ? options.root : "element"}" was not found.`), options);
+	const validation = validateConfig(options);
+	if (!validation.ok || !validation.config) return reportConfigurationError(validation.error ?? createEmergencyError("configuration", "Invalid emergency configuration."), options);
+	const config = validation.config;
+	installEmergencyFonts(config.fontLoading);
+	const controller = createEmergencyController({ config });
+	const container = document.createElement("div");
+	container.setAttribute("data-de-emergency-container", "");
+	root.appendChild(container);
+	const reactRoot = createRoot(container);
+	reactRoot.render(/* @__PURE__ */ jsx(EmergencyProvider, {
+		value: {
+			store: controller.store,
+			client: controller.client,
+			config
+		},
+		children: /* @__PURE__ */ jsx(EmergencyRoot, {})
+	}));
+	const detachTrigger = attachTrigger(options.trigger, controller.client);
+	const unsubscribers = options.onEvent ? EMERGENCY_EVENT_NAMES.map((name) => controller.events.on(name, (payload) => {
+		options.onEvent?.(name, payload);
+	})) : [];
+	let destroyed = false;
+	controller.client.resume();
+	const destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		detachTrigger();
+		for (const unsubscribe of unsubscribers) unsubscribe();
+		controller.client.destroy();
+		container.remove();
+		queueMicrotask(() => reactRoot.unmount());
+	};
+	const client = controller.client;
+	return {
+		open: (reason) => client.open(reason ?? "manual"),
+		close: (reason) => client.close(reason ?? "manual"),
+		getState: () => client.getState(),
+		subscribe: (listener) => client.subscribe(listener),
+		on: (event, handler) => client.on(event, handler),
+		off: (event, handler) => client.off(event, handler),
+		ensureSession: () => client.ensureSession(),
+		resume: () => client.resume(),
+		dismissResume: () => client.dismissResume(),
+		activate: () => client.activate(),
+		simulate: () => client.simulate(),
+		refresh: () => client.refresh(),
+		abort: () => client.abort(),
+		requestAbortConfirmation: () => client.requestAbortConfirmation(),
+		cancelAbortConfirmation: () => client.cancelAbortConfirmation(),
+		requestSimulationConfirmation: () => client.requestSimulationConfirmation(),
+		cancelSimulationConfirmation: () => client.cancelSimulationConfirmation(),
+		dismissFeedback: () => client.dismissFeedback(),
+		destroy
+	};
+}
+
+export { EMERGENCY_CODE_PATTERN, EMERGENCY_EVENT_NAMES, EMERGENCY_PHASE_NAMES, EMERGENCY_TRANSITIONS, EmergencyClientError, canTransition, createBffClient, createBrowserGeolocationProvider, createCookieCsrfStrategy, createEmergencyController, createEmergencyError, createMemoryCsrfStrategy, createPusherRealtimeProvider, isEmergencyError, isValidEmergencyCode, mount, normalizeBaseUrl, themeToCssVariables, toEmergencyError, validateConfig };
+//# sourceMappingURL=index.js.map