@dataemergencia/emergency 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,2489 @@
+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: "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. Activa el permiso o llama directamente.",
+	geolocationUnavailable: "Tu ubicación no está disponible en este momento. Llama directamente.",
+	geolocationTimeout: "La ubicación tardó demasiado. Inténtalo de nuevo o llama directamente.",
+	geolocationUnsupported: "Este dispositivo no permite compartir la ubicación. Llama directamente.",
+	fallbackTitle: "Llama directamente",
+	fallbackDescription: "Si no puedes completar la emergencia desde aquí, llama a este número.",
+	fallbackCall: "Llamar",
+	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" });
+			pushMessage("error", normalized.message);
+			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: () => patch({
+				abortResult: null,
+				simulationResult: null
+			})
+		},
+		store,
+		events
+	};
+}
+
+// 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
+		}
+	};
+}
+
+// src/styles/assets/paramedical-mark.tsx
+/**
+* Neutral inline illustration used by the idle panel.
+*/
+function ParamedicalMark({ className, title }) {
+	return /* @__PURE__ */ jsxs("svg", {
+		className,
+		viewBox: "0 0 96 96",
+		role: "img",
+		"aria-label": title,
+		xmlns: "http://www.w3.org/2000/svg",
+		children: [
+			/* @__PURE__ */ jsx("circle", {
+				cx: "48",
+				cy: "48",
+				r: "46",
+				fill: "#ff0000"
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				cx: "48",
+				cy: "48",
+				r: "37",
+				fill: "#fff"
+			}),
+			/* @__PURE__ */ jsx("path", {
+				d: "M42 26h12v16h16v12H54v16H42V54H26V42h16z",
+				fill: "#ff0000"
+			})
+		]
+	});
+}
+
+// src/react/components/Icon/index.tsx
+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__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M12 2v6M12 16v6M2 12h6M16 12h6" }), /* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "3"
+	})] })
+};
+function Icon({ name, className, title }) {
+	return /* @__PURE__ */ jsxs("svg", {
+		className,
+		viewBox: "0 0 24 24",
+		width: "1em",
+		height: "1em",
+		fill: "none",
+		stroke: "currentColor",
+		strokeWidth: "2",
+		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__actions": "de-emergency-emergency-confirmation__actions-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__card--danger": "de-emergency-emergency-confirmation__card--danger-kMlO0G",
+	"emergency-confirmation__icon": "de-emergency-emergency-confirmation__icon-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-fallback": "de-emergency-emergency-fallback-kMlO0G",
+	"emergency-fallback__phone": "de-emergency-emergency-fallback__phone-kMlO0G",
+	"emergency-fallback__text": "de-emergency-emergency-fallback__text-kMlO0G",
+	"emergency-fallback__title": "de-emergency-emergency-fallback__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__message-icon": "de-emergency-emergency-status__message-icon-kMlO0G",
+	"emergency-status__message-icon--failed": "de-emergency-emergency-status__message-icon--failed-kMlO0G",
+	"emergency-status__message-icon--success": "de-emergency-emergency-status__message-icon--success-kMlO0G",
+	"emergency-status__message-row": "de-emergency-emergency-status__message-row-kMlO0G",
+	"emergency-status__message-row--failed": "de-emergency-emergency-status__message-row--failed-kMlO0G",
+	"emergency-status__message-row--success": "de-emergency-emergency-status__message-row--success-kMlO0G",
+	"emergency-status__message-sent-at": "de-emergency-emergency-status__message-sent-at-kMlO0G",
+	"emergency-status__message-text": "de-emergency-emergency-status__message-text-kMlO0G",
+	"emergency-status__message-text-container": "de-emergency-emergency-status__message-text-container-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",
+	"sent-at--verified": "de-emergency-sent-at--verified-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 })
+			}), /* @__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/EmergencyFallback/index.tsx
+function errorCopy(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 EmergencyFallback({ fallback, error }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: cls("emergency-fallback"),
+		children: [
+			/* @__PURE__ */ jsx("h4", {
+				className: cls("emergency-fallback__title"),
+				children: copy.fallbackTitle
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: cls("emergency-fallback__text"),
+				children: errorCopy(error)
+			}),
+			fallback ? /* @__PURE__ */ jsxs("a", {
+				className: cls("emergency-fallback__phone"),
+				href: `tel:${fallback.phone.replace(/[^\d+]/g, "")}`,
+				children: [/* @__PURE__ */ jsx(Icon, { name: "message" }), fallback.label]
+			}) : null
+		]
+	});
+}
+
+// src/react/components/EmergencyFeedback/index.tsx
+function EmergencyFeedback({ abortResult, simulationResult, onDismiss }) {
+	const result = abortResult ?? simulationResult;
+	if (!result) return null;
+	const aborting = abortResult !== null;
+	const success = result.ok;
+	const title = success ? aborting ? copy.abortSuccessTitle : copy.simulateSuccessTitle : copy.errorTitle;
+	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: result.message,
+		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/EmergencyMessageRow/index.tsx
+/**
+* Renders one message row per responder.
+*/
+function EmergencyMessageRow({ responder, locale }) {
+	const message = responder.lastMessage;
+	const hasContent = Boolean(message?.content);
+	const modifier = hasContent ? "emergency-status__message-row--success" : "emergency-status__message-row--failed";
+	const iconModifier = hasContent ? "emergency-status__message-icon--success" : "emergency-status__message-icon--failed";
+	return /* @__PURE__ */ jsxs("div", {
+		className: cls("emergency-status__message-row", modifier),
+		children: [/* @__PURE__ */ jsxs("p", {
+			className: cls("emergency-status__message-text-container"),
+			children: [/* @__PURE__ */ jsx(Icon, {
+				name: "flag",
+				className: cls("emergency-status__message-icon", iconModifier)
+			}), /* @__PURE__ */ jsxs("span", {
+				className: cls("emergency-status__message-text"),
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: copy.statusPrefix }),
+					" ",
+					message?.content ?? ""
+				]
+			})]
+		}), message ? /* @__PURE__ */ jsxs("p", {
+			className: cls("emergency-status__message-text-container", "sent-at--verified"),
+			children: [/* @__PURE__ */ jsx(Icon, {
+				name: "double-check",
+				className: cls("emergency-status__message-icon")
+			}), message.sentAt ? /* @__PURE__ */ jsx("span", {
+				className: cls("emergency-status__message-sent-at"),
+				children: formatShortTime(message.sentAt, locale)
+			}) : null]
+		}) : null]
+	});
+}
+
+// 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__ */ jsxs("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
+				})
+			]
+		}), /* @__PURE__ */ jsx(EmergencyMessageRow, {
+			responder,
+			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, error, fallback, abortResult, simulationResult, onRefresh, onRetry, onDismissFeedback } = props;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("div", {
+			className: cls("sos-img__container"),
+			id: "sos-img__container",
+			children: /* @__PURE__ */ jsx(ParamedicalMark, {
+				className: cls("sos-img"),
+				title: copy.illustrationAlt
+			})
+		}),
+		active ? 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 ? /* @__PURE__ */ jsx(EmergencyStatusPanel, {
+			responders,
+			refreshing,
+			locale,
+			onRefresh
+		}) : null,
+		loading ? /* @__PURE__ */ jsx(EmergencyLoading, {}) : null,
+		geolocationError ? /* @__PURE__ */ jsx(EmergencyFallback, {
+			fallback,
+			error: geolocationError
+		}) : null,
+		error ? /* @__PURE__ */ jsx(EmergencyError, {
+			error,
+			onRetry
+		}) : null,
+		/* @__PURE__ */ jsx(EmergencyFeedback, {
+			abortResult,
+			simulationResult,
+			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;
+	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", danger && "emergency-confirmation__card--danger"),
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: cls("emergency-confirmation__icon"),
+					children: /* @__PURE__ */ jsx(Icon, { name: danger ? "alert-triangle" : "info" })
+				}),
+				/* @__PURE__ */ jsx("h3", {
+					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__actions"),
+					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, 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,
+			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,
+			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,
+			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, error, fallback, abortResult, simulationResult, abortConfirmation, simulationConfirmation, onClose, onActivate, onRefresh, onRetry, onDismissFeedback, onRequestAbort, onRequestSimulation, onCancelAbort, onCancelSimulation, onConfirmAbort, onConfirmSimulation } = props;
+	const titleId = useId();
+	const dialogRef = useRef(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,
+					error,
+					fallback,
+					abortResult,
+					simulationResult,
+					onRefresh,
+					onRetry,
+					onDismissFeedback
+				})
+			}),
+			/* @__PURE__ */ jsx(EmergencyFooter, {
+				active,
+				busy,
+				aborting,
+				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 showError = phase.kind === "error" || lastError !== null && geolocationError === null && abortResult === null && simulationResult === 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,
+		error: showError ? error : null,
+		fallback: config.fallback ?? 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;
+	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