zenit-sdk 0.0.2 → 0.0.5

package/dist/chunk-LX2N2BXV.mjs

@@ -0,0 +1,3258 @@
+// src/react/ZenitMap.tsx
+import React, { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState, forwardRef } from "react";
+import { GeoJSON, MapContainer, Marker, TileLayer, ZoomControl, useMap } from "react-leaflet";
+import L from "leaflet";
+
+// src/maps/helpers.ts
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function clampOpacity(value) {
+  if (!Number.isFinite(value ?? NaN)) {
+    return 1;
+  }
+  return Math.min(1, Math.max(0, value ?? 1));
+}
+function resolveLayerId(mapLayer) {
+  if (mapLayer.layerId !== void 0 && mapLayer.layerId !== null) {
+    return mapLayer.layerId;
+  }
+  const embedded = mapLayer.layer;
+  return embedded?.id;
+}
+function extractMapDto(map) {
+  if (map && typeof map === "object" && "data" in map) {
+    const data = map.data;
+    return data ?? null;
+  }
+  if (map && typeof map === "object") {
+    return map;
+  }
+  return null;
+}
+function normalizeMapCenter(map) {
+  const center = map.settings?.center;
+  if (Array.isArray(center) && center.length >= 2) {
+    const [lon, lat] = center;
+    return {
+      ...map,
+      settings: {
+        ...map.settings,
+        center: { lon, lat }
+      }
+    };
+  }
+  return map;
+}
+function normalizeMapLayers(mapOrResponse) {
+  const map = extractMapDto(mapOrResponse);
+  if (!map?.mapLayers) {
+    return [];
+  }
+  const normalized = [];
+  map.mapLayers.forEach((mapLayer, index) => {
+    const layerId = resolveLayerId(mapLayer);
+    if (layerId === void 0) {
+      return;
+    }
+    const embeddedLayer = mapLayer.layer;
+    const visible = mapLayer.isVisible !== false;
+    const opacity = clampOpacity(toNumber(mapLayer.opacity) ?? 1);
+    const layerType = embeddedLayer?.layerType ?? mapLayer.layerType;
+    const geometryType = embeddedLayer?.geometryType ?? mapLayer.geometryType;
+    const layerName = embeddedLayer?.name ?? mapLayer.name;
+    const orderCandidate = toNumber(mapLayer.displayOrder) ?? toNumber(mapLayer.order) ?? toNumber(embeddedLayer?.displayOrder) ?? index;
+    normalized.push({
+      layerId,
+      displayOrder: orderCandidate ?? index,
+      isVisible: visible,
+      opacity,
+      layer: embeddedLayer,
+      layerType,
+      geometryType,
+      layerName,
+      mapLayer
+    });
+  });
+  return normalized.sort((a, b) => a.displayOrder - b.displayOrder);
+}
+function computeBBoxFromFeature(feature) {
+  if (!feature || typeof feature !== "object") return null;
+  const geometry = feature.geometry;
+  if (!geometry || !("coordinates" in geometry)) return null;
+  const coords = [];
+  const collect = (candidate) => {
+    if (!Array.isArray(candidate)) return;
+    if (candidate.length === 2 && typeof candidate[0] === "number" && typeof candidate[1] === "number") {
+      coords.push([candidate[0], candidate[1]]);
+      return;
+    }
+    candidate.forEach((entry) => collect(entry));
+  };
+  collect(geometry.coordinates);
+  if (coords.length === 0) return null;
+  const [firstLon, firstLat] = coords[0];
+  const bbox = { minLon: firstLon, minLat: firstLat, maxLon: firstLon, maxLat: firstLat };
+  coords.forEach(([lon, lat]) => {
+    bbox.minLon = Math.min(bbox.minLon, lon);
+    bbox.minLat = Math.min(bbox.minLat, lat);
+    bbox.maxLon = Math.max(bbox.maxLon, lon);
+    bbox.maxLat = Math.max(bbox.maxLat, lat);
+  });
+  return bbox;
+}
+function centroidFromBBox(bbox) {
+  return [(bbox.minLat + bbox.maxLat) / 2, (bbox.minLon + bbox.maxLon) / 2];
+}
+function applyFilteredGeoJSONStrategy(options) {
+  const layerControls = options.normalizedLayers.map((entry) => ({
+    layerId: entry.layerId,
+    visible: entry.isVisible,
+    opacity: entry.opacity
+  }));
+  return {
+    overlay: options.filteredGeojson,
+    metadata: options.metadata,
+    layerControls
+  };
+}
+
+// src/engine/LayerStateEngine.ts
+function clampOpacity2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.min(1, Math.max(0, value));
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (Number.isFinite(parsed)) {
+      return Math.min(1, Math.max(0, parsed));
+    }
+  }
+  return 1;
+}
+var resolveBaseVisibility = (_layer) => false;
+function resolveBaseOpacity(layer) {
+  if ("opacity" in layer) {
+    return clampOpacity2(layer.opacity);
+  }
+  return 1;
+}
+function toEffectiveState(base, override) {
+  const overrideVisible = override?.overrideVisible ?? void 0;
+  const overrideOpacity = override?.overrideOpacity ?? void 0;
+  const opacitySource = overrideOpacity !== void 0 && overrideOpacity !== null ? overrideOpacity : base.baseOpacity;
+  return {
+    layerId: base.layerId,
+    baseVisible: base.baseVisible,
+    baseOpacity: base.baseOpacity,
+    overrideVisible,
+    overrideOpacity,
+    visible: overrideVisible ?? base.baseVisible,
+    opacity: clampOpacity2(opacitySource)
+  };
+}
+function initLayerStates(mapLayers) {
+  const bases = mapLayers.filter((layer) => layer.layerId !== void 0).map((layer) => ({
+    layerId: layer.layerId,
+    baseVisible: resolveBaseVisibility(layer),
+    baseOpacity: resolveBaseOpacity(layer)
+  }));
+  return bases.map((base) => toEffectiveState(base));
+}
+function applyLayerOverrides(states, overrides) {
+  const overrideMap = /* @__PURE__ */ new Map();
+  overrides.forEach((entry) => overrideMap.set(entry.layerId, entry));
+  return states.map((state) => {
+    const nextOverride = overrideMap.get(state.layerId);
+    const mergedOverrideVisible = nextOverride && "overrideVisible" in nextOverride && nextOverride.overrideVisible !== void 0 ? nextOverride.overrideVisible : state.overrideVisible;
+    const mergedOverrideOpacity = nextOverride && "overrideOpacity" in nextOverride && nextOverride.overrideOpacity !== void 0 ? nextOverride.overrideOpacity : state.overrideOpacity;
+    return toEffectiveState(state, {
+      layerId: state.layerId,
+      overrideVisible: mergedOverrideVisible ?? void 0,
+      overrideOpacity: mergedOverrideOpacity ?? void 0
+    });
+  });
+}
+function resetOverrides(states) {
+  return states.map((state) => toEffectiveState(state));
+}
+
+// src/react/layerStyleHelpers.ts
+function resolveLayerAccent(style) {
+  if (!style) return null;
+  return style.fillColor ?? style.color ?? null;
+}
+function getLayerColor(style, fallback = "#94a3b8") {
+  return resolveLayerAccent(style) ?? fallback;
+}
+function getStyleByLayerId(layerId, mapLayers) {
+  if (!mapLayers) return null;
+  const match = mapLayers.find((ml) => String(ml.layerId) === String(layerId));
+  return match?.style ?? null;
+}
+function getAccentByLayerId(layerId, mapLayers) {
+  const style = getStyleByLayerId(layerId, mapLayers);
+  return resolveLayerAccent(style);
+}
+
+// src/react/zoomOpacity.ts
+var DEFAULT_OPTIONS = {
+  minZoom: 10,
+  maxZoom: 17,
+  minFactor: 0.6,
+  maxFactor: 1,
+  minOpacity: 0.1,
+  maxOpacity: 0.92
+};
+function clampNumber(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function clampOpacity3(value) {
+  return clampNumber(value, 0, 1);
+}
+function isPolygonLayer(layerType, geometryType) {
+  const candidate = (layerType ?? geometryType ?? "").toLowerCase();
+  return candidate === "polygon" || candidate === "multipolygon";
+}
+function getZoomOpacityFactor(zoom, options) {
+  const settings = { ...DEFAULT_OPTIONS, ...options };
+  const { minZoom, maxZoom, minFactor, maxFactor } = settings;
+  if (maxZoom <= minZoom) return clampNumber(maxFactor, minFactor, maxFactor);
+  const t = clampNumber((zoom - minZoom) / (maxZoom - minZoom), 0, 1);
+  const factor = maxFactor + (minFactor - maxFactor) * t;
+  return clampNumber(factor, minFactor, maxFactor);
+}
+function getLayerZoomOpacityFactor(zoom, layerType, geometryType, options) {
+  if (!isPolygonLayer(layerType, geometryType)) return 1;
+  return getZoomOpacityFactor(zoom, options);
+}
+function getEffectiveLayerOpacity(baseOpacity, zoom, layerType, geometryType, options) {
+  if (!isPolygonLayer(layerType, geometryType)) {
+    return clampOpacity3(baseOpacity);
+  }
+  const settings = { ...DEFAULT_OPTIONS, ...options };
+  const factor = getZoomOpacityFactor(zoom, options);
+  const effective = clampOpacity3(baseOpacity) * factor;
+  return clampNumber(effective, settings.minOpacity, settings.maxOpacity);
+}
+
+// src/react/ZenitMap.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_CENTER = [0, 0];
+var DEFAULT_ZOOM = 3;
+function computeBBoxFromGeojson(geojson) {
+  if (!geojson) return null;
+  if (!Array.isArray(geojson.features) || geojson.features.length === 0) return null;
+  const coords = [];
+  const collect = (candidate) => {
+    if (!Array.isArray(candidate)) return;
+    if (candidate.length === 2 && typeof candidate[0] === "number" && typeof candidate[1] === "number") {
+      coords.push([candidate[0], candidate[1]]);
+      return;
+    }
+    candidate.forEach((entry) => collect(entry));
+  };
+  geojson.features.forEach((feature) => {
+    collect(feature.geometry?.coordinates);
+  });
+  if (coords.length === 0) return null;
+  const [firstLon, firstLat] = coords[0];
+  const bbox = { minLon: firstLon, minLat: firstLat, maxLon: firstLon, maxLat: firstLat };
+  coords.forEach(([lon, lat]) => {
+    bbox.minLon = Math.min(bbox.minLon, lon);
+    bbox.minLat = Math.min(bbox.minLat, lat);
+    bbox.maxLon = Math.max(bbox.maxLon, lon);
+    bbox.maxLat = Math.max(bbox.maxLat, lat);
+  });
+  return bbox;
+}
+function mergeBBoxes(bboxes) {
+  const valid = bboxes.filter((bbox) => !!bbox);
+  if (valid.length === 0) return null;
+  const first = valid[0];
+  return valid.slice(1).reduce(
+    (acc, bbox) => ({
+      minLon: Math.min(acc.minLon, bbox.minLon),
+      minLat: Math.min(acc.minLat, bbox.minLat),
+      maxLon: Math.max(acc.maxLon, bbox.maxLon),
+      maxLat: Math.max(acc.maxLat, bbox.maxLat)
+    }),
+    { ...first }
+  );
+}
+function getFeatureLayerId(feature) {
+  const layerId = feature?.properties?.__zenit_layerId ?? feature?.properties?.layerId ?? feature?.properties?.layer_id;
+  if (layerId === void 0 || layerId === null) return null;
+  return layerId;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var DESCRIPTION_KEYS = /* @__PURE__ */ new Set(["descripcion", "description"]);
+function normalizeDescriptionValue(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return null;
+}
+function extractDescriptionValue(properties) {
+  if (!properties) return null;
+  const matches = Object.entries(properties).find(
+    ([key]) => DESCRIPTION_KEYS.has(key.toLowerCase())
+  );
+  if (!matches) return null;
+  return normalizeDescriptionValue(matches[1]);
+}
+function safeJsonStringify(value) {
+  try {
+    const json = JSON.stringify(value, null, 2);
+    if (json !== void 0) return json;
+  } catch {
+  }
+  return String(value);
+}
+function renderPropertyValue(value) {
+  if (value === null || value === void 0) {
+    return '<span class="prop-empty">\u2014</span>';
+  }
+  if (typeof value === "object") {
+    const json = safeJsonStringify(value);
+    return `<pre class="prop-json">${escapeHtml(json)}</pre>`;
+  }
+  return `<span class="prop-text">${escapeHtml(String(value))}</span>`;
+}
+var POPUP_TITLE_KEYS = ["name", "title", "nombre", "label", "id"];
+var POPUP_CHIP_KEYS = /* @__PURE__ */ new Set(["churn", "color", "sector"]);
+function isChipValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function getSanitizedChipColor(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (/^#([0-9a-fA-F]{3}){1,2}$/.test(trimmed)) {
+    return trimmed;
+  }
+  if (/^rgb\((\s*\d+\s*,){2}\s*\d+\s*\)$/.test(trimmed)) {
+    return trimmed;
+  }
+  if (/^rgba\((\s*\d+\s*,){3}\s*(0|1|0?\.\d+)\s*\)$/.test(trimmed)) {
+    return trimmed;
+  }
+  return null;
+}
+function getPopupTitle(entries) {
+  for (const candidate of POPUP_TITLE_KEYS) {
+    const match = entries.find((entry) => entry.normalized === candidate);
+    if (!match || match.value === null || match.value === void 0) continue;
+    const value = String(match.value).trim();
+    if (!value) continue;
+    return { title: value, key: match.key };
+  }
+  return null;
+}
+function renderProperties(properties) {
+  const description = extractDescriptionValue(properties);
+  const entries = Object.entries(properties).filter(([key]) => !DESCRIPTION_KEYS.has(key.toLowerCase())).map(([key, value]) => ({
+    key,
+    value,
+    normalized: key.trim().toLowerCase()
+  }));
+  if (!description && entries.length === 0) return "";
+  const titleEntry = getPopupTitle(entries);
+  const titleText = titleEntry?.title ?? "Detalle del elemento";
+  const chipEntries = entries.filter(
+    (entry) => POPUP_CHIP_KEYS.has(entry.normalized) && isChipValue(entry.value)
+  );
+  const listEntries = entries.filter((entry) => {
+    if (titleEntry && entry.key === titleEntry.key) return false;
+    if (chipEntries.find((chip) => chip.key === entry.key)) return false;
+    return true;
+  });
+  const descriptionHtml = description ? `<div class="popup-description">${escapeHtml(description)}</div>` : "";
+  const chipsHtml = chipEntries.length ? `<div class="popup-chip-row">${chipEntries.map((entry) => {
+    const label = escapeHtml(entry.key.replace(/_/g, " "));
+    const value = escapeHtml(String(entry.value));
+    const color = getSanitizedChipColor(entry.value);
+    const colorStyle = color ? ` style="--chip-color: ${color}"` : "";
+    return `<span class="popup-chip"${colorStyle}><span class="popup-chip-label">${label}</span><span class="popup-chip-value">${value}</span></span>`;
+  }).join("")}</div>` : "";
+  const rowsHtml = listEntries.map((entry) => {
+    const label = escapeHtml(entry.key.replace(/_/g, " "));
+    const valueHtml = renderPropertyValue(entry.value);
+    return `<div class="prop-key">${label}</div><div class="prop-value">${valueHtml}</div>`;
+  }).join("");
+  const listHtml = rowsHtml ? `<div class="prop-list">${rowsHtml}</div>` : "";
+  return `
+    <div class="feature-popup">
+      <div class="feature-popup-card">
+        <div class="feature-popup-header">
+          <p class="popup-eyebrow">Informaci\xF3n</p>
+          <h3 class="popup-title">${escapeHtml(titleText)}</h3>
+        </div>
+        <div class="feature-popup-body">
+          ${descriptionHtml}
+          ${chipsHtml}
+          ${listHtml}
+        </div>
+      </div>
+    </div>
+  `;
+}
+function withAlpha(color, alpha) {
+  const trimmed = color.trim();
+  if (trimmed.startsWith("#")) {
+    const hex = trimmed.replace("#", "");
+    const expanded = hex.length === 3 ? hex.split("").map((char) => `${char}${char}`).join("") : hex;
+    if (expanded.length === 6) {
+      const r = parseInt(expanded.slice(0, 2), 16);
+      const g = parseInt(expanded.slice(2, 4), 16);
+      const b = parseInt(expanded.slice(4, 6), 16);
+      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+    }
+  }
+  if (trimmed.startsWith("rgb(")) {
+    const inner = trimmed.slice(4, -1);
+    return `rgba(${inner}, ${alpha})`;
+  }
+  if (trimmed.startsWith("rgba(")) {
+    const inner = trimmed.slice(5, -1).split(",").slice(0, 3).map((value) => value.trim());
+    return `rgba(${inner.join(", ")}, ${alpha})`;
+  }
+  return color;
+}
+function getRgbFromColor(color) {
+  const trimmed = color.trim();
+  if (trimmed.startsWith("#")) {
+    const hex = trimmed.replace("#", "");
+    const expanded = hex.length === 3 ? hex.split("").map((char) => `${char}${char}`).join("") : hex;
+    if (expanded.length === 6) {
+      const r = parseInt(expanded.slice(0, 2), 16);
+      const g = parseInt(expanded.slice(2, 4), 16);
+      const b = parseInt(expanded.slice(4, 6), 16);
+      return { r, g, b };
+    }
+  }
+  const rgbMatch = trimmed.match(/rgba?\(([^)]+)\)/i);
+  if (rgbMatch) {
+    const [r, g, b] = rgbMatch[1].split(",").map((value) => parseFloat(value.trim())).slice(0, 3);
+    if ([r, g, b].every((value) => Number.isFinite(value))) {
+      return { r, g, b };
+    }
+  }
+  return null;
+}
+function getLabelTextStyles(color) {
+  const rgb = getRgbFromColor(color);
+  if (!rgb) {
+    return { color: "#0f172a", shadow: "0 1px 2px rgba(255, 255, 255, 0.6)" };
+  }
+  const luminance = (0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b) / 255;
+  if (luminance > 0.6) {
+    return { color: "#0f172a", shadow: "0 1px 2px rgba(255, 255, 255, 0.7)" };
+  }
+  return { color: "#ffffff", shadow: "0 1px 2px rgba(0, 0, 0, 0.4)" };
+}
+function getFeatureStyleOverrides(feature) {
+  const candidate = feature?.properties?._style;
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return null;
+  const styleCandidate = candidate;
+  return {
+    color: styleCandidate.color,
+    weight: styleCandidate.weight,
+    fillColor: styleCandidate.fillColor,
+    fillOpacity: styleCandidate.fillOpacity
+  };
+}
+function buildFeaturePopupHtml(feature) {
+  const properties = feature?.properties;
+  if (!properties) return null;
+  const rendered = renderProperties(properties);
+  return rendered ? rendered : null;
+}
+var POINT_GEOMETRY_TYPES = /* @__PURE__ */ new Set(["Point", "MultiPoint"]);
+function getGeometryType(feature) {
+  const t = feature?.geometry?.type;
+  return typeof t === "string" ? t : null;
+}
+function isPointGeometry(feature) {
+  const geometryType = getGeometryType(feature);
+  return geometryType !== null && POINT_GEOMETRY_TYPES.has(geometryType);
+}
+function isNonPointGeometry(feature) {
+  const geometryType = getGeometryType(feature);
+  return geometryType !== null && !POINT_GEOMETRY_TYPES.has(geometryType);
+}
+function buildFeatureCollection(features) {
+  return {
+    type: "FeatureCollection",
+    features
+  };
+}
+function pickIntersectFeature(baseFeature, candidates) {
+  if (!Array.isArray(candidates) || candidates.length === 0) return null;
+  const baseId = baseFeature?.id;
+  if (baseId !== void 0 && baseId !== null) {
+    const matchById = candidates.find((candidate) => candidate?.id === baseId);
+    if (matchById) return matchById;
+  }
+  const matchWithDescription = candidates.find(
+    (candidate) => extractDescriptionValue(candidate?.properties)
+  );
+  return matchWithDescription ?? candidates[0];
+}
+function normalizeCenterTuple(center) {
+  if (!center) return null;
+  if (Array.isArray(center) && center.length >= 2) {
+    const lat = center[0];
+    const lon = center[1];
+    if (typeof lat === "number" && typeof lon === "number") return [lat, lon];
+    return null;
+  }
+  const maybeObj = center;
+  if (typeof maybeObj.lat === "number" && typeof maybeObj.lon === "number") {
+    return [maybeObj.lat, maybeObj.lon];
+  }
+  return null;
+}
+var FitToBounds = ({ bbox }) => {
+  const mapInstance = useMap();
+  const lastAppliedBBox = useRef(null);
+  useEffect(() => {
+    const targetBBox = bbox;
+    if (!targetBBox) return;
+    const serialized = JSON.stringify(targetBBox);
+    if (lastAppliedBBox.current === serialized) return;
+    const bounds = [
+      [targetBBox.minLat, targetBBox.minLon],
+      [targetBBox.maxLat, targetBBox.maxLon]
+    ];
+    mapInstance.fitBounds(bounds, { padding: [12, 12] });
+    lastAppliedBBox.current = serialized;
+  }, [bbox, mapInstance]);
+  return null;
+};
+var AutoFitToBounds = ({
+  bbox,
+  enabled = true
+}) => {
+  const mapInstance = useMap();
+  const lastAutoBBoxApplied = useRef(null);
+  const lastUserInteracted = useRef(false);
+  useEffect(() => {
+    if (!enabled) return;
+    const handleInteraction = () => {
+      lastUserInteracted.current = true;
+    };
+    mapInstance.on("dragstart", handleInteraction);
+    mapInstance.on("zoomstart", handleInteraction);
+    return () => {
+      mapInstance.off("dragstart", handleInteraction);
+      mapInstance.off("zoomstart", handleInteraction);
+    };
+  }, [enabled, mapInstance]);
+  useEffect(() => {
+    if (!enabled) return;
+    if (!bbox) return;
+    const serialized = JSON.stringify(bbox);
+    if (lastAutoBBoxApplied.current === serialized) return;
+    if (lastUserInteracted.current) {
+      lastUserInteracted.current = false;
+    }
+    const bounds = [
+      [bbox.minLat, bbox.minLon],
+      [bbox.maxLat, bbox.maxLon]
+    ];
+    mapInstance.fitBounds(bounds, { padding: [12, 12] });
+    lastAutoBBoxApplied.current = serialized;
+  }, [bbox, enabled, mapInstance]);
+  return null;
+};
+var ZoomBasedOpacityHandler = ({ onZoomChange }) => {
+  const mapInstance = useMap();
+  useEffect(() => {
+    const handleZoom = () => {
+      onZoomChange(mapInstance.getZoom());
+    };
+    mapInstance.on("zoomend", handleZoom);
+    handleZoom();
+    return () => {
+      mapInstance.off("zoomend", handleZoom);
+    };
+  }, [mapInstance, onZoomChange]);
+  return null;
+};
+var MapInstanceBridge = ({ onReady }) => {
+  const mapInstance = useMap();
+  useEffect(() => {
+    onReady(mapInstance);
+  }, [mapInstance, onReady]);
+  return null;
+};
+var ZenitMap = forwardRef(({
+  client,
+  mapId,
+  height = "500px",
+  width = "100%",
+  initialZoom,
+  initialCenter,
+  showLayerPanel = true,
+  overlayGeojson,
+  overlayStyle,
+  layerControls,
+  layerStates,
+  layerGeojson,
+  onLayerStateChange,
+  onError,
+  onLoadingChange,
+  onFeatureClick,
+  onFeatureHover,
+  featureInfoMode = "popup",
+  mapLayers,
+  zoomToBbox,
+  zoomToGeojson,
+  onZoomChange,
+  onMapReady
+}, ref) => {
+  const [map, setMap] = useState(null);
+  const [layers, setLayers] = useState([]);
+  const [effectiveStates, setEffectiveStates] = useState([]);
+  const [loadingMap, setLoadingMap] = useState(false);
+  const [mapError, setMapError] = useState(null);
+  const [mapInstance, setMapInstance] = useState(null);
+  const [panesReady, setPanesReady] = useState(false);
+  const [currentZoom, setCurrentZoom] = useState(initialZoom ?? DEFAULT_ZOOM);
+  const [isMobile, setIsMobile] = useState(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia("(max-width: 768px)").matches;
+  });
+  const normalizedLayers = useMemo(() => normalizeMapLayers(map), [map]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mql = window.matchMedia("(max-width: 768px)");
+    const onChange = (e) => {
+      setIsMobile(e.matches);
+    };
+    setIsMobile(mql.matches);
+    if (typeof mql.addEventListener === "function") {
+      mql.addEventListener("change", onChange);
+      return () => mql.removeEventListener("change", onChange);
+    }
+    const legacy = mql;
+    if (typeof legacy.addListener === "function") {
+      legacy.addListener(onChange);
+      return () => legacy.removeListener(onChange);
+    }
+    return;
+  }, []);
+  const layerStyleIndex = useMemo(() => {
+    const index = /* @__PURE__ */ new Map();
+    (map?.mapLayers ?? []).forEach((entry) => {
+      const layerStyle = entry.layer?.style ?? entry.mapLayer?.layer?.style ?? entry.style ?? null;
+      const layerId = entry.layerId ?? entry.mapLayer?.layerId ?? entry.mapLayer?.layer?.id ?? entry.layer?.id;
+      if (layerId !== void 0 && layerId !== null && layerStyle) {
+        index.set(String(layerId), layerStyle);
+      }
+    });
+    return index;
+  }, [map]);
+  const labelKeyIndex = useMemo(() => {
+    const index = /* @__PURE__ */ new Map();
+    normalizedLayers.forEach((entry) => {
+      const label = entry.layer?.label ?? entry.mapLayer?.label ?? entry.mapLayer.layerConfig?.label;
+      if (typeof label === "string" && label.trim().length > 0) {
+        index.set(String(entry.layerId), label);
+      }
+    });
+    return index;
+  }, [normalizedLayers]);
+  const layerMetaIndex = useMemo(() => {
+    const index = /* @__PURE__ */ new Map();
+    normalizedLayers.forEach((entry) => {
+      index.set(String(entry.layerId), {
+        layerType: typeof entry.layer?.layerType === "string" ? entry.layer.layerType : typeof entry.mapLayer.layerType === "string" ? entry.mapLayer.layerType : void 0,
+        geometryType: typeof entry.layer?.geometryType === "string" ? entry.layer.geometryType : typeof entry.mapLayer.layerConfig?.geometryType === "string" ? entry.mapLayer.layerConfig.geometryType : void 0
+      });
+    });
+    return index;
+  }, [normalizedLayers]);
+  const overlayStyleFunction = useMemo(() => {
+    return (feature) => {
+      const featureLayerId = getFeatureLayerId(feature);
+      const featureStyleOverrides = getFeatureStyleOverrides(feature);
+      let style = null;
+      if (featureLayerId !== null) {
+        style = getStyleByLayerId(featureLayerId, mapLayers) ?? layerStyleIndex.get(String(featureLayerId)) ?? null;
+      }
+      const resolvedStyle = featureStyleOverrides ? { ...style ?? {}, ...featureStyleOverrides } : style;
+      const defaultOptions = {
+        color: resolvedStyle?.color ?? resolvedStyle?.fillColor ?? "#2563eb",
+        weight: resolvedStyle?.weight ?? 2,
+        fillColor: resolvedStyle?.fillColor ?? resolvedStyle?.color ?? "#2563eb",
+        fillOpacity: resolvedStyle?.fillOpacity ?? 0.15,
+        ...overlayStyle ?? {}
+      };
+      return defaultOptions;
+    };
+  }, [layerStyleIndex, mapLayers, overlayStyle]);
+  const [baseStates, setBaseStates] = useState([]);
+  const [mapOverrides, setMapOverrides] = useState([]);
+  const [controlOverrides, setControlOverrides] = useState([]);
+  const [uiOverrides, setUiOverrides] = useState([]);
+  useEffect(() => {
+    let isMounted = true;
+    setLoadingMap(true);
+    setMapError(null);
+    onLoadingChange?.("map", true);
+    client.maps.getMap(mapId, true).then((mapResponse) => {
+      if (!isMounted) return;
+      const extracted = extractMapDto(mapResponse);
+      const resolved = extracted ? normalizeMapCenter(extracted) : null;
+      setMap(resolved);
+    }).catch((err) => {
+      if (!isMounted) return;
+      setMapError(err instanceof Error ? err.message : "No se pudo obtener el mapa");
+      onError?.(err, "map");
+    }).finally(() => {
+      if (!isMounted) return;
+      setLoadingMap(false);
+      onLoadingChange?.("map", false);
+    });
+    return () => {
+      isMounted = false;
+    };
+  }, [client.maps, mapId, onError, onLoadingChange]);
+  useEffect(() => {
+    if (normalizedLayers.length === 0) {
+      setLayers([]);
+      setBaseStates([]);
+      setMapOverrides([]);
+      setUiOverrides([]);
+      return;
+    }
+    const nextLayers = normalizedLayers.map((entry) => ({
+      mapLayer: { ...entry.mapLayer, layerId: entry.layerId },
+      layer: entry.layer,
+      displayOrder: entry.displayOrder
+    }));
+    const base = initLayerStates(
+      normalizedLayers.map((entry) => ({
+        ...entry.mapLayer,
+        layerId: entry.layerId,
+        opacity: entry.opacity,
+        isVisible: entry.isVisible
+      }))
+    );
+    const initialOverrides = normalizedLayers.map((entry) => ({
+      layerId: entry.layerId,
+      overrideVisible: entry.isVisible,
+      overrideOpacity: entry.opacity
+    }));
+    setLayers(nextLayers);
+    setBaseStates(base);
+    setMapOverrides(initialOverrides);
+    setUiOverrides([]);
+  }, [normalizedLayers]);
+  useEffect(() => {
+    if (!layerControls) {
+      setControlOverrides([]);
+      return;
+    }
+    const overrides = layerControls.map((entry) => ({
+      layerId: entry.layerId,
+      overrideVisible: entry.visible,
+      overrideOpacity: entry.opacity
+    }));
+    setControlOverrides(overrides);
+  }, [layerControls]);
+  useEffect(() => {
+    if (layerStates) {
+      return;
+    }
+    if (Array.isArray(layerControls) && layerControls.length === 0 && effectiveStates.length > 0) {
+      const reset = resetOverrides(baseStates);
+      setEffectiveStates(reset);
+      onLayerStateChange?.(reset);
+    }
+  }, [baseStates, effectiveStates.length, layerControls, layerStates, onLayerStateChange]);
+  useEffect(() => {
+    if (layerStates) {
+      setEffectiveStates(layerStates);
+    }
+  }, [layerStates]);
+  useEffect(() => {
+    if (layerStates) {
+      return;
+    }
+    if (mapOverrides.length === 0 && controlOverrides.length === 0 && uiOverrides.length === 0) {
+      setEffectiveStates(baseStates);
+      return;
+    }
+    const combined = [...mapOverrides, ...controlOverrides, ...uiOverrides];
+    const next = applyLayerOverrides(baseStates, combined);
+    setEffectiveStates(next);
+    onLayerStateChange?.(next);
+  }, [baseStates, controlOverrides, layerStates, mapOverrides, onLayerStateChange, uiOverrides]);
+  useEffect(() => {
+    if (!Array.isArray(layerControls) || layerControls.length > 0) return;
+    setUiOverrides([]);
+  }, [layerControls]);
+  useEffect(() => {
+    if (layerStates) {
+      return;
+    }
+    if (!Array.isArray(layerControls) && effectiveStates.length > 0 && baseStates.length > 0) {
+      const next = resetOverrides(baseStates);
+      setEffectiveStates(next);
+      onLayerStateChange?.(next);
+    }
+  }, [baseStates, effectiveStates.length, layerControls, layerStates, onLayerStateChange]);
+  const upsertUiOverride = (layerId, patch) => {
+    setUiOverrides((prev) => {
+      const filtered = prev.filter((entry) => entry.layerId !== layerId);
+      const nextEntry = {
+        layerId,
+        ...patch
+      };
+      return [...filtered, nextEntry];
+    });
+  };
+  const updateOpacityFromUi = useCallback(
+    (layerId, uiOpacity) => {
+      const meta = layerMetaIndex.get(String(layerId));
+      const zoomFactor = getLayerZoomOpacityFactor(
+        currentZoom,
+        meta?.layerType,
+        meta?.geometryType
+      );
+      const baseOpacity = clampOpacity3(uiOpacity / zoomFactor);
+      const effectiveOpacity = getEffectiveLayerOpacity(
+        baseOpacity,
+        currentZoom,
+        meta?.layerType,
+        meta?.geometryType
+      );
+      if (layerStates && onLayerStateChange) {
+        const next = effectiveStates.map(
+          (state) => state.layerId === layerId ? {
+            ...state,
+            baseOpacity,
+            opacity: effectiveOpacity,
+            overrideOpacity: uiOpacity
+          } : state
+        );
+        onLayerStateChange(next);
+        return;
+      }
+      setBaseStates(
+        (prev) => prev.map((state) => state.layerId === layerId ? { ...state, baseOpacity } : state)
+      );
+      setUiOverrides((prev) => {
+        const existing = prev.find((entry) => entry.layerId === layerId);
+        const filtered = prev.filter((entry) => entry.layerId !== layerId);
+        if (existing && existing.overrideVisible !== void 0) {
+          return [
+            ...filtered,
+            { layerId, overrideVisible: existing.overrideVisible }
+          ];
+        }
+        return filtered;
+      });
+    },
+    [currentZoom, effectiveStates, layerMetaIndex, layerStates, onLayerStateChange]
+  );
+  const center = useMemo(() => {
+    if (initialCenter) {
+      return initialCenter;
+    }
+    const normalized = normalizeCenterTuple(map?.settings?.center);
+    if (normalized) {
+      return normalized;
+    }
+    return DEFAULT_CENTER;
+  }, [initialCenter, map?.settings?.center]);
+  const zoom = initialZoom ?? map?.settings?.zoom ?? DEFAULT_ZOOM;
+  useEffect(() => {
+    setCurrentZoom(zoom);
+  }, [zoom]);
+  const decoratedLayers = useMemo(() => {
+    return layers.map((layer) => ({
+      ...layer,
+      effective: effectiveStates.find((state) => state.layerId === layer.mapLayer.layerId),
+      data: layerGeojson?.[layer.mapLayer.layerId] ?? layerGeojson?.[String(layer.mapLayer.layerId)] ?? null
+    }));
+  }, [effectiveStates, layerGeojson, layers]);
+  const orderedLayers = useMemo(() => {
+    return [...decoratedLayers].filter((layer) => layer.effective?.visible && layer.data).sort((a, b) => a.displayOrder - b.displayOrder);
+  }, [decoratedLayers]);
+  const explicitZoomBBox = useMemo(() => {
+    if (zoomToBbox) return zoomToBbox;
+    if (zoomToGeojson) return computeBBoxFromGeojson(zoomToGeojson);
+    return null;
+  }, [zoomToBbox, zoomToGeojson]);
+  const autoZoomBBox = useMemo(() => {
+    if (explicitZoomBBox) return null;
+    const visibleBBoxes = orderedLayers.map((layer) => computeBBoxFromGeojson(layer.data));
+    return mergeBBoxes(visibleBBoxes);
+  }, [explicitZoomBBox, orderedLayers]);
+  const resolveLayerStyle = useCallback(
+    (layerId) => {
+      return getStyleByLayerId(layerId, mapLayers) ?? layerStyleIndex.get(String(layerId)) ?? null;
+    },
+    [layerStyleIndex, mapLayers]
+  );
+  const labelMarkers = useMemo(() => {
+    const markers = [];
+    decoratedLayers.forEach((layerState) => {
+      if (!layerState.effective?.visible) return;
+      const labelKey = labelKeyIndex.get(String(layerState.mapLayer.layerId));
+      if (!labelKey) return;
+      const data = layerState.data;
+      if (!data) return;
+      const resolvedStyle = resolveLayerStyle(layerState.mapLayer.layerId);
+      const layerColor = resolvedStyle?.fillColor ?? resolvedStyle?.color ?? "rgba(37, 99, 235, 1)";
+      const opacity = layerState.effective?.opacity ?? 1;
+      data.features.forEach((feature, index) => {
+        const properties = feature.properties;
+        const value = properties?.[labelKey];
+        if (value === void 0 || value === null || value === "") return;
+        const bbox = computeBBoxFromFeature(feature);
+        if (!bbox) return;
+        const [lat, lng] = centroidFromBBox(bbox);
+        markers.push({
+          key: `${layerState.mapLayer.layerId}-label-${index}`,
+          position: [lat, lng],
+          label: String(value),
+          opacity,
+          layerId: layerState.mapLayer.layerId,
+          color: layerColor
+        });
+      });
+    });
+    return markers;
+  }, [decoratedLayers, labelKeyIndex, resolveLayerStyle]);
+  const ensureLayerPanes = useCallback(
+    (targetMap, targetLayers) => {
+      const baseZIndex = 400;
+      targetLayers.forEach((layer) => {
+        const order = Number.isFinite(layer.displayOrder) ? layer.displayOrder : 0;
+        const fillPaneName = `zenit-layer-${layer.layerId}-fill`;
+        const pointPaneName = `zenit-layer-${layer.layerId}-points`;
+        const labelPaneName = `zenit-layer-${layer.layerId}-labels`;
+        const fillPane = targetMap.getPane(fillPaneName) ?? targetMap.createPane(fillPaneName);
+        const pointPane = targetMap.getPane(pointPaneName) ?? targetMap.createPane(pointPaneName);
+        const labelPane = targetMap.getPane(labelPaneName) ?? targetMap.createPane(labelPaneName);
+        fillPane.style.zIndex = String(baseZIndex + order);
+        pointPane.style.zIndex = String(baseZIndex + order + 1e3);
+        labelPane.style.zIndex = String(baseZIndex + order + 2e3);
+      });
+    },
+    []
+  );
+  const handleMapReady = useCallback(
+    (instance) => {
+      setPanesReady(false);
+      setMapInstance(instance);
+      onMapReady?.(instance);
+    },
+    [onMapReady]
+  );
+  useEffect(() => {
+    if (!mapInstance) {
+      setPanesReady(false);
+      return;
+    }
+    if (orderedLayers.length === 0) {
+      return;
+    }
+    const layerTargets = orderedLayers.map((layer) => ({
+      layerId: layer.mapLayer.layerId,
+      displayOrder: layer.displayOrder
+    }));
+    ensureLayerPanes(mapInstance, layerTargets);
+    const first = layerTargets[0];
+    const testPane = mapInstance.getPane(`zenit-layer-${first.layerId}-labels`);
+    if (testPane) {
+      setPanesReady(true);
+    }
+  }, [mapInstance, orderedLayers, ensureLayerPanes]);
+  const overlayOnEachFeature = useMemo(() => {
+    return (feature, layer) => {
+      const layerId = getFeatureLayerId(feature) ?? void 0;
+      const geometryType = feature?.geometry?.type;
+      const isPointFeature = geometryType === "Point" || geometryType === "MultiPoint" || layer instanceof L.CircleMarker;
+      const originalStyle = layer instanceof L.Path ? {
+        color: layer.options.color,
+        weight: layer.options.weight,
+        fillColor: layer.options.fillColor,
+        opacity: layer.options.opacity,
+        fillOpacity: layer.options.fillOpacity
+      } : null;
+      const originalRadius = layer instanceof L.CircleMarker ? layer.getRadius() : null;
+      if (featureInfoMode === "popup") {
+        const content = buildFeaturePopupHtml(feature);
+        if (content) {
+          layer.bindPopup(content, {
+            maxWidth: 420,
+            minWidth: 280,
+            className: "zenit-feature-popup-shell",
+            autoPan: true,
+            closeButton: true,
+            offset: L.point(0, -24)
+          });
+        }
+      }
+      if (isPointFeature && layer.bindTooltip) {
+        layer.bindTooltip("Click para ver detalle", {
+          sticky: true,
+          direction: "top",
+          opacity: 0.9,
+          className: "zenit-map-tooltip"
+        });
+      }
+      layer.on("click", () => {
+        if (featureInfoMode === "popup" && client && layerId !== void 0 && !extractDescriptionValue(feature?.properties) && feature?.geometry) {
+          const trackedFeature = feature;
+          if (!trackedFeature.__zenit_popup_loaded) {
+            trackedFeature.__zenit_popup_loaded = true;
+            client.layers.getLayerGeoJsonIntersect({
+              id: layerId,
+              geometry: feature.geometry
+            }).then((response) => {
+              const candidates = response.data?.features ?? [];
+              const resolved = pickIntersectFeature(feature, candidates);
+              if (!resolved?.properties) return;
+              const mergedProperties = {
+                ...trackedFeature.properties ?? {},
+                ...resolved.properties
+              };
+              trackedFeature.properties = mergedProperties;
+              const updatedHtml = buildFeaturePopupHtml({
+                ...feature,
+                properties: mergedProperties
+              });
+              if (updatedHtml && layer.setPopupContent) {
+                layer.setPopupContent(updatedHtml);
+              }
+            }).catch(() => {
+              trackedFeature.__zenit_popup_loaded = false;
+            });
+          }
+        }
+        onFeatureClick?.(feature, layerId);
+      });
+      layer.on("mouseover", () => {
+        if (layer instanceof L.Path && originalStyle) {
+          layer.setStyle({
+            ...originalStyle,
+            weight: (originalStyle.weight ?? 2) + 1,
+            opacity: Math.min(1, (originalStyle.opacity ?? 1) + 0.2),
+            fillOpacity: Math.min(1, (originalStyle.fillOpacity ?? 0.8) + 0.1)
+          });
+        }
+        if (layer instanceof L.CircleMarker && typeof originalRadius === "number") {
+          layer.setRadius(originalRadius + 1);
+        }
+        onFeatureHover?.(feature, layerId);
+      });
+      layer.on("mouseout", () => {
+        if (layer instanceof L.Path && originalStyle) {
+          layer.setStyle(originalStyle);
+        }
+        if (layer instanceof L.CircleMarker && typeof originalRadius === "number") {
+          layer.setRadius(originalRadius);
+        }
+      });
+    };
+  }, [client, featureInfoMode, onFeatureClick, onFeatureHover]);
+  const buildLayerStyle = (layerId, baseOpacity, feature, layerType) => {
+    const style = resolveLayerStyle(layerId);
+    const featureStyleOverrides = getFeatureStyleOverrides(feature);
+    const resolvedStyle = featureStyleOverrides ? { ...style ?? {}, ...featureStyleOverrides } : style;
+    const geometryType = feature?.geometry?.type;
+    const resolvedLayerType = layerType ?? geometryType;
+    const sanitizedBaseOpacity = clampOpacity3(baseOpacity);
+    const normalizedStyleFill = typeof resolvedStyle?.fillOpacity === "number" ? clampOpacity3(resolvedStyle.fillOpacity) : 0.8;
+    const effectiveOpacity = getEffectiveLayerOpacity(
+      sanitizedBaseOpacity,
+      currentZoom,
+      resolvedLayerType,
+      geometryType
+    );
+    const fillOpacity = clampOpacity3(effectiveOpacity * normalizedStyleFill);
+    const strokeOpacity = clampOpacity3(Math.max(0.35, effectiveOpacity * 0.9));
+    return {
+      color: resolvedStyle?.color ?? resolvedStyle?.fillColor ?? "#2563eb",
+      weight: resolvedStyle?.weight ?? 2,
+      fillColor: resolvedStyle?.fillColor ?? resolvedStyle?.color ?? "#2563eb",
+      opacity: strokeOpacity,
+      fillOpacity
+    };
+  };
+  const buildLabelIcon = useCallback((label, opacity, color) => {
+    const size = 60;
+    const innerSize = 44;
+    const textStyles = getLabelTextStyles(color);
+    const safeLabel = escapeHtml(label);
+    const clampedOpacity = Math.min(1, Math.max(0.92, opacity));
+    const innerBackground = withAlpha(color, 0.9);
+    return L.divIcon({
+      className: "zenit-label-marker",
+      iconSize: [size, size],
+      iconAnchor: [size / 2, size / 2],
+      html: `
+        <div
+          title="${safeLabel}"
+          style="
+            width:${size}px;
+            height:${size}px;
+            border-radius:9999px;
+            background:rgba(255, 255, 255, 0.95);
+            border:3px solid rgba(255, 255, 255, 1);
+            display:flex;
+            align-items:center;
+            justify-content:center;
+            opacity:${clampedOpacity};
+            box-shadow:0 2px 6px rgba(0, 0, 0, 0.25);
+            pointer-events:none;
+          "
+        >
+          <div
+            style="
+              width:${innerSize}px;
+              height:${innerSize}px;
+              border-radius:9999px;
+              background:${innerBackground};
+              display:flex;
+              align-items:center;
+              justify-content:center;
+              box-shadow:inset 0 0 0 1px rgba(15, 23, 42, 0.12);
+            "
+          >
+            <span
+              style="
+                color:${textStyles.color};
+                font-size:20px;
+                font-weight:800;
+                text-shadow:${textStyles.shadow};
+              "
+            >
+              ${safeLabel}
+            </span>
+          </div>
+        </div>
+      `
+    });
+  }, []);
+  useImperativeHandle(ref, () => ({
+    setLayerOpacity: (layerId, opacity) => {
+      upsertUiOverride(layerId, { overrideOpacity: opacity });
+    },
+    setLayerVisibility: (layerId, visible) => {
+      upsertUiOverride(layerId, { overrideVisible: visible });
+    },
+    fitBounds: (bbox, options) => {
+      if (!mapInstance) return;
+      if (typeof bbox.minLat !== "number" || typeof bbox.minLon !== "number" || typeof bbox.maxLat !== "number" || typeof bbox.maxLon !== "number" || !Number.isFinite(bbox.minLat) || !Number.isFinite(bbox.minLon) || !Number.isFinite(bbox.maxLat) || !Number.isFinite(bbox.maxLon)) {
+        console.warn("[ZenitMap.fitBounds] Invalid bbox: missing or non-finite coordinates", bbox);
+        return;
+      }
+      const bounds = [
+        [bbox.minLat, bbox.minLon],
+        [bbox.maxLat, bbox.maxLon]
+      ];
+      const fitOptions = {
+        padding: options?.padding ?? [12, 12],
+        animate: options?.animate ?? true
+      };
+      mapInstance.fitBounds(bounds, fitOptions);
+    },
+    setView: (coordinates, zoom2) => {
+      if (!mapInstance) return;
+      mapInstance.setView([coordinates.lat, coordinates.lon], zoom2 ?? mapInstance.getZoom(), {
+        animate: true
+      });
+    },
+    getLayerSnapshot: () => {
+      return effectiveStates.map((state) => ({
+        layerId: state.layerId,
+        visible: state.visible,
+        opacity: state.opacity
+      }));
+    },
+    restoreLayerSnapshot: (snapshot) => {
+      const overrides = snapshot.map((s) => ({
+        layerId: s.layerId,
+        overrideVisible: s.visible,
+        overrideOpacity: s.opacity
+      }));
+      setUiOverrides(overrides);
+    },
+    highlightFeature: (layerId, featureId) => {
+      upsertUiOverride(layerId, { overrideVisible: true, overrideOpacity: 1 });
+    },
+    getMapInstance: () => mapInstance
+  }), [effectiveStates, mapInstance]);
+  if (loadingMap) {
+    return /* @__PURE__ */ jsx("div", { style: { padding: 16, height, width }, children: "Cargando mapa..." });
+  }
+  if (mapError) {
+    return /* @__PURE__ */ jsxs("div", { style: { padding: 16, height, width, color: "red" }, children: [
+      "Error al cargar mapa: ",
+      mapError
+    ] });
+  }
+  if (!map) {
+    return null;
+  }
+  const handleZoomChange = (zoomValue) => {
+    setCurrentZoom(zoomValue);
+    onZoomChange?.(zoomValue);
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        height,
+        width,
+        border: "1px solid #e2e8f0",
+        borderRadius: 4,
+        overflow: "hidden",
+        boxSizing: "border-box"
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { style: { flex: 1, position: "relative" }, children: /* @__PURE__ */ jsxs(
+          MapContainer,
+          {
+            center,
+            zoom,
+            style: { height: "100%", width: "100%" },
+            scrollWheelZoom: true,
+            zoomControl: false,
+            children: [
+              /* @__PURE__ */ jsx(
+                TileLayer,
+                {
+                  url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+                  attribution: "\xA9 OpenStreetMap contributors"
+                }
+              ),
+              /* @__PURE__ */ jsx(ZoomControl, { position: "topright" }),
+              /* @__PURE__ */ jsx(MapInstanceBridge, { onReady: handleMapReady }),
+              /* @__PURE__ */ jsx(FitToBounds, { bbox: explicitZoomBBox ?? void 0 }),
+              /* @__PURE__ */ jsx(AutoFitToBounds, { bbox: autoZoomBBox ?? void 0, enabled: !explicitZoomBBox }),
+              /* @__PURE__ */ jsx(ZoomBasedOpacityHandler, { onZoomChange: handleZoomChange }),
+              orderedLayers.map((layerState) => {
+                const baseOpacity = layerState.effective?.baseOpacity ?? layerState.effective?.opacity ?? 1;
+                const fillPaneName = `zenit-layer-${layerState.mapLayer.layerId}-fill`;
+                const pointsPaneName = `zenit-layer-${layerState.mapLayer.layerId}-points`;
+                const labelPaneName = `zenit-layer-${layerState.mapLayer.layerId}-labels`;
+                const layerType = layerState.layer?.layerType ?? layerState.mapLayer.layerType ?? void 0;
+                const data = layerState.data?.features ?? [];
+                const fillFeatures = data.filter(isNonPointGeometry);
+                const pointFeatures = data.filter(isPointGeometry);
+                const fillData = fillFeatures.length > 0 ? buildFeatureCollection(fillFeatures) : null;
+                const pointsData = pointFeatures.length > 0 ? buildFeatureCollection(pointFeatures) : null;
+                return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+                  fillData && /* @__PURE__ */ jsx(
+                    GeoJSON,
+                    {
+                      data: fillData,
+                      pane: panesReady && mapInstance?.getPane(fillPaneName) ? fillPaneName : void 0,
+                      style: (feature) => buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType),
+                      onEachFeature: overlayOnEachFeature
+                    }
+                  ),
+                  pointsData && /* @__PURE__ */ jsx(
+                    GeoJSON,
+                    {
+                      data: pointsData,
+                      pane: panesReady && mapInstance?.getPane(pointsPaneName) ? pointsPaneName : void 0,
+                      pointToLayer: (feature, latlng) => L.circleMarker(latlng, {
+                        radius: isMobile ? 8 : 6,
+                        ...buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType)
+                      }),
+                      onEachFeature: overlayOnEachFeature
+                    }
+                  ),
+                  panesReady && mapInstance?.getPane(labelPaneName) ? labelMarkers.filter(
+                    (marker) => String(marker.layerId) === String(layerState.mapLayer.layerId)
+                  ).map((marker) => /* @__PURE__ */ jsx(
+                    Marker,
+                    {
+                      position: marker.position,
+                      icon: buildLabelIcon(marker.label, marker.opacity, marker.color),
+                      interactive: false,
+                      pane: labelPaneName
+                    },
+                    marker.key
+                  )) : null
+                ] }, layerState.mapLayer.layerId.toString());
+              }),
+              overlayGeojson && /* @__PURE__ */ jsx(
+                GeoJSON,
+                {
+                  data: overlayGeojson,
+                  style: overlayStyleFunction,
+                  onEachFeature: overlayOnEachFeature
+                },
+                "zenit-overlay-geojson"
+              )
+            ]
+          },
+          String(mapId)
+        ) }),
+        showLayerPanel && decoratedLayers.length > 0 && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              width: 260,
+              borderLeft: "1px solid #e2e8f0",
+              padding: "12px 16px",
+              background: "#fafafa",
+              fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+              fontSize: 14,
+              overflowY: "auto"
+            },
+            children: [
+              overlayGeojson && /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    border: "1px solid #bfdbfe",
+                    background: "#eff6ff",
+                    color: "#1e40af",
+                    padding: "8px 10px",
+                    borderRadius: 8,
+                    marginBottom: 12
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx("div", { style: { fontWeight: 600, marginBottom: 4 }, children: "Overlay activo" }),
+                    /* @__PURE__ */ jsxs("div", { style: { fontSize: 13 }, children: [
+                      "GeoJSON externo con ",
+                      (overlayGeojson.features?.length ?? 0).toLocaleString(),
+                      " elementos."
+                    ] })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx("div", { style: { fontWeight: 600, marginBottom: 12 }, children: "Capas" }),
+              decoratedLayers.map((layerState) => /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: { borderBottom: "1px solid #e5e7eb", paddingBottom: 10, marginBottom: 10 },
+                  children: [
+                    /* @__PURE__ */ jsxs("label", { style: { display: "flex", gap: 8, alignItems: "center" }, children: [
+                      /* @__PURE__ */ jsx(
+                        "input",
+                        {
+                          type: "checkbox",
+                          checked: layerState.effective?.visible ?? false,
+                          onChange: (e) => {
+                            const visible = e.target.checked;
+                            upsertUiOverride(layerState.mapLayer.layerId, { overrideVisible: visible });
+                          }
+                        }
+                      ),
+                      /* @__PURE__ */ jsx("span", { children: layerState.layer?.name ?? `Capa ${layerState.mapLayer.layerId}` })
+                    ] }),
+                    /* @__PURE__ */ jsxs("div", { style: { marginTop: 8 }, children: [
+                      /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", marginBottom: 4 }, children: [
+                        /* @__PURE__ */ jsx("span", { style: { color: "#4a5568" }, children: "Opacidad" }),
+                        /* @__PURE__ */ jsxs("span", { children: [
+                          Math.round((layerState.effective?.opacity ?? 1) * 100),
+                          "%"
+                        ] })
+                      ] }),
+                      /* @__PURE__ */ jsx(
+                        "input",
+                        {
+                          type: "range",
+                          min: 0,
+                          max: 1,
+                          step: 0.05,
+                          value: layerState.effective?.opacity ?? 1,
+                          onChange: (e) => {
+                            const value = Number(e.target.value);
+                            updateOpacityFromUi(layerState.mapLayer.layerId, value);
+                          },
+                          style: { width: "100%" }
+                        }
+                      )
+                    ] })
+                  ]
+                },
+                layerState.mapLayer.layerId.toString()
+              ))
+            ]
+          }
+        )
+      ]
+    }
+  );
+});
+ZenitMap.displayName = "ZenitMap";
+
+// src/react/ZenitLayerManager.tsx
+import React2, { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/react/icons.tsx
+import { Eye, EyeOff, ChevronLeft, ChevronRight, Layers, Upload, X, ZoomIn } from "lucide-react";
+
+// src/react/ZenitLayerManager.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FLOAT_TOLERANCE = 1e-3;
+function areEffectiveStatesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((state, index) => {
+    const other = b[index];
+    if (!other) return false;
+    const opacityDiff = Math.abs((state.opacity ?? 1) - (other.opacity ?? 1));
+    return String(state.layerId) === String(other.layerId) && (state.visible ?? false) === (other.visible ?? false) && opacityDiff <= FLOAT_TOLERANCE;
+  });
+}
+function getLayerColor2(style) {
+  if (!style) return "#94a3b8";
+  return style.fillColor ?? style.color ?? "#94a3b8";
+}
+function resolveDisplayOrder(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+var ZenitLayerManager = ({
+  client,
+  mapId,
+  side = "right",
+  className,
+  style,
+  height,
+  layerStates,
+  onLayerStatesChange,
+  mapZoom,
+  autoOpacityOnZoom = false,
+  autoOpacityConfig,
+  showUploadTab = true,
+  showLayerVisibilityIcon = true,
+  layerFeatureCounts,
+  mapLayers
+}) => {
+  const [map, setMap] = useState2(null);
+  const [loadingMap, setLoadingMap] = useState2(false);
+  const [mapError, setMapError] = useState2(null);
+  const [layers, setLayers] = useState2([]);
+  const [activeTab, setActiveTab] = useState2("layers");
+  const [panelVisible, setPanelVisible] = useState2(true);
+  const lastEmittedStatesRef = useRef2(null);
+  const isControlled = Array.isArray(layerStates) && typeof onLayerStatesChange === "function";
+  const baseStates = useMemo2(
+    () => initLayerStates(
+      layers.map((entry) => ({
+        ...entry.mapLayer,
+        layerId: entry.mapLayer.layerId,
+        isVisible: entry.visible,
+        opacity: entry.opacity
+      }))
+    ),
+    [layers]
+  );
+  const overrideStates = useMemo2(
+    () => layers.map(
+      (entry) => ({
+        layerId: entry.mapLayer.layerId,
+        overrideVisible: entry.visible,
+        overrideOpacity: entry.opacity
+      })
+    ),
+    [layers]
+  );
+  const effectiveStates = useMemo2(
+    () => layerStates ?? applyLayerOverrides(baseStates, overrideStates),
+    [baseStates, layerStates, overrideStates]
+  );
+  const layerMetaIndex = useMemo2(() => {
+    const index = /* @__PURE__ */ new Map();
+    mapLayers?.forEach((entry) => {
+      const key = String(entry.layerId);
+      index.set(key, { layerType: entry.layerType ?? void 0, geometryType: entry.geometryType ?? void 0 });
+    });
+    map?.mapLayers?.forEach((entry) => {
+      const key = String(entry.layerId);
+      if (!index.has(key)) {
+        index.set(key, { layerType: entry.layerType ?? void 0, geometryType: entry.geometryType ?? void 0 });
+      }
+    });
+    return index;
+  }, [map, mapLayers]);
+  const resolveUserOpacity = React2.useCallback((state) => {
+    if (typeof state.overrideOpacity === "number") return state.overrideOpacity;
+    if (typeof state.overrideOpacity === "string") {
+      const parsed = Number.parseFloat(state.overrideOpacity);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+    return state.opacity ?? 1;
+  }, []);
+  const resolveEffectiveOpacity = React2.useCallback(
+    (layerId, userOpacity) => {
+      if (!autoOpacityOnZoom || typeof mapZoom !== "number") {
+        return userOpacity;
+      }
+      const meta = layerMetaIndex.get(String(layerId));
+      return getEffectiveLayerOpacity(
+        userOpacity,
+        mapZoom,
+        meta?.layerType,
+        meta?.geometryType,
+        autoOpacityConfig
+      );
+    },
+    [autoOpacityConfig, autoOpacityOnZoom, layerMetaIndex, mapZoom]
+  );
+  const effectiveStatesWithZoom = useMemo2(() => {
+    if (!autoOpacityOnZoom || typeof mapZoom !== "number") {
+      return effectiveStates;
+    }
+    return effectiveStates.map((state) => {
+      const userOpacity = resolveUserOpacity(state);
+      const adjustedOpacity = resolveEffectiveOpacity(state.layerId, userOpacity);
+      return {
+        ...state,
+        opacity: adjustedOpacity,
+        overrideOpacity: userOpacity
+      };
+    });
+  }, [autoOpacityOnZoom, effectiveStates, mapZoom, resolveEffectiveOpacity, resolveUserOpacity]);
+  useEffect2(() => {
+    let cancelled = false;
+    setLoadingMap(true);
+    setMapError(null);
+    setLayers([]);
+    client.maps.getMap(mapId, true).then((mapResponse) => {
+      if (cancelled) return;
+      const extractedMap = extractMapDto(mapResponse);
+      const resolvedMap = extractedMap ? normalizeMapCenter(extractedMap) : null;
+      setMap(resolvedMap);
+      const normalizedLayers = normalizeMapLayers(resolvedMap);
+      setLayers(
+        normalizedLayers.map((entry, index) => ({
+          mapLayer: { ...entry.mapLayer, layerId: entry.layerId },
+          layer: entry.layer,
+          visible: entry.isVisible,
+          opacity: entry.opacity,
+          displayOrder: entry.displayOrder,
+          initialIndex: index
+        }))
+      );
+    }).catch((err) => {
+      if (cancelled) return;
+      const message = err instanceof Error ? err.message : "No se pudo cargar el mapa";
+      setMapError(message);
+    }).finally(() => {
+      if (!cancelled) setLoadingMap(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client.maps, mapId]);
+  useEffect2(() => {
+    if (!showUploadTab && activeTab === "upload") {
+      setActiveTab("layers");
+    }
+  }, [activeTab, showUploadTab]);
+  useEffect2(() => {
+    if (isControlled) return;
+    if (!onLayerStatesChange) return;
+    const emitStates = autoOpacityOnZoom && typeof mapZoom === "number" ? effectiveStatesWithZoom : effectiveStates;
+    const previous = lastEmittedStatesRef.current;
+    if (previous && areEffectiveStatesEqual(previous, emitStates)) {
+      return;
+    }
+    lastEmittedStatesRef.current = emitStates;
+    onLayerStatesChange(emitStates);
+  }, [
+    autoOpacityOnZoom,
+    effectiveStates,
+    effectiveStatesWithZoom,
+    isControlled,
+    mapZoom,
+    onLayerStatesChange
+  ]);
+  const updateLayerVisible = React2.useCallback(
+    (layerId, visible) => {
+      if (!onLayerStatesChange) return;
+      const next = effectiveStates.map(
+        (state) => state.layerId === layerId ? { ...state, visible, overrideVisible: visible } : state
+      );
+      onLayerStatesChange(next);
+    },
+    [effectiveStates, onLayerStatesChange]
+  );
+  const updateLayerOpacity = React2.useCallback(
+    (layerId, opacity) => {
+      if (!onLayerStatesChange) return;
+      const adjustedOpacity = resolveEffectiveOpacity(layerId, opacity);
+      const next = effectiveStates.map(
+        (state) => state.layerId === layerId ? { ...state, opacity: adjustedOpacity, overrideOpacity: opacity } : state
+      );
+      onLayerStatesChange(next);
+    },
+    [effectiveStates, onLayerStatesChange, resolveEffectiveOpacity]
+  );
+  const resolveFeatureCount = React2.useCallback(
+    (layerId, layer) => {
+      const resolvedFeatureCount = layerFeatureCounts?.[layerId] ?? layerFeatureCounts?.[String(layerId)];
+      if (typeof resolvedFeatureCount === "number") return resolvedFeatureCount;
+      const featureCount = layer?.featuresCount ?? layer?.featureCount ?? layer?.totalFeatures;
+      return typeof featureCount === "number" ? featureCount : null;
+    },
+    [layerFeatureCounts]
+  );
+  const decoratedLayers = useMemo2(() => {
+    return layers.map((entry) => ({
+      ...entry,
+      effective: effectiveStates.find((state) => state.layerId === entry.mapLayer.layerId),
+      featureCount: resolveFeatureCount(entry.mapLayer.layerId, entry.layer),
+      layerName: entry.layer?.name ?? entry.mapLayer.name ?? `Capa ${entry.mapLayer.layerId}`
+    })).sort((a, b) => {
+      const aOrder = resolveDisplayOrder(
+        a.displayOrder ?? a.mapLayer.displayOrder ?? a.mapLayer.order
+      );
+      const bOrder = resolveDisplayOrder(
+        b.displayOrder ?? b.mapLayer.displayOrder ?? b.mapLayer.order
+      );
+      const aHasOrder = a.displayOrder ?? a.mapLayer.displayOrder ?? a.mapLayer.order ?? null;
+      const bHasOrder = b.displayOrder ?? b.mapLayer.displayOrder ?? b.mapLayer.order ?? null;
+      if (aHasOrder !== null && bHasOrder !== null) {
+        const orderCompare = aOrder - bOrder;
+        if (orderCompare !== 0) return orderCompare;
+      }
+      const aInitial = a.initialIndex ?? 0;
+      const bInitial = b.initialIndex ?? 0;
+      if (aInitial !== bInitial) return aInitial - bInitial;
+      const aName = a.layerName ?? String(a.mapLayer.layerId);
+      const bName = b.layerName ?? String(b.mapLayer.layerId);
+      const nameCompare = aName.localeCompare(bName, void 0, { sensitivity: "base" });
+      if (nameCompare !== 0) return nameCompare;
+      return String(a.mapLayer.layerId).localeCompare(String(b.mapLayer.layerId));
+    });
+  }, [effectiveStates, layers, resolveFeatureCount]);
+  const resolveLayerStyle = React2.useCallback(
+    (layerId) => {
+      const layerKey = String(layerId);
+      const fromProp = mapLayers?.find((entry) => String(entry.layerId) === layerKey)?.style;
+      if (fromProp) return fromProp;
+      const fromMapDto = map?.mapLayers?.find((entry) => String(entry.layerId) === layerKey);
+      if (fromMapDto?.layer) {
+        const layer = fromMapDto.layer;
+        if (layer.style) return layer.style;
+      }
+      return void 0;
+    },
+    [map, mapLayers]
+  );
+  const panelStyle = {
+    width: 360,
+    borderLeft: side === "right" ? "1px solid #e2e8f0" : void 0,
+    borderRight: side === "left" ? "1px solid #e2e8f0" : void 0,
+    background: "#f1f5f9",
+    fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+    fontSize: 14,
+    boxSizing: "border-box",
+    height: height ?? "100%",
+    display: "flex",
+    flexDirection: "column",
+    boxShadow: "0 12px 28px rgba(15, 23, 42, 0.08)",
+    ...style,
+    ...height ? { height } : {}
+  };
+  if (loadingMap) {
+    return /* @__PURE__ */ jsx2("div", { className, style: panelStyle, children: "Cargando capas\u2026" });
+  }
+  if (mapError) {
+    return /* @__PURE__ */ jsxs2("div", { className, style: { ...panelStyle, color: "#c53030" }, children: [
+      "Error al cargar mapa: ",
+      mapError
+    ] });
+  }
+  if (!map) {
+    return null;
+  }
+  const headerStyle = {
+    padding: "14px 16px",
+    borderBottom: "1px solid #e2e8f0",
+    background: "#fff",
+    position: "sticky",
+    top: 0,
+    zIndex: 2,
+    boxShadow: "0 1px 0 rgba(148, 163, 184, 0.25)"
+  };
+  const renderLayerCards = () => {
+    return /* @__PURE__ */ jsx2("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: decoratedLayers.map((layerState) => {
+      const layerId = layerState.mapLayer.layerId;
+      const layerName = layerState.layerName ?? `Capa ${layerId}`;
+      const visible = layerState.effective?.visible ?? false;
+      const userOpacity = layerState.effective ? resolveUserOpacity(layerState.effective) : 1;
+      const featureCount = layerState.featureCount;
+      const layerColor = getLayerColor2(resolveLayerStyle(layerId));
+      const muted = !visible;
+      const opacityPercent = Math.round(userOpacity * 100);
+      const sliderBackground = `linear-gradient(to right, ${layerColor} 0%, ${layerColor} ${opacityPercent}%, #e5e7eb ${opacityPercent}%, #e5e7eb 100%)`;
+      return /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          className: `zlm-card${muted ? " is-muted" : ""}`,
+          style: {
+            border: "1px solid #e2e8f0",
+            borderRadius: 12,
+            padding: 12,
+            background: "#fff",
+            display: "flex",
+            flexDirection: "column",
+            gap: 10,
+            width: "100%"
+          },
+          children: [
+            /* @__PURE__ */ jsxs2("div", { style: { display: "flex", justifyContent: "space-between", gap: 12 }, children: [
+              /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: 10, alignItems: "flex-start", minWidth: 0, flex: 1 }, children: [
+                /* @__PURE__ */ jsx2(
+                  "div",
+                  {
+                    style: {
+                      width: 14,
+                      height: 14,
+                      borderRadius: "50%",
+                      backgroundColor: layerColor,
+                      border: "2px solid #e2e8f0",
+                      flexShrink: 0,
+                      marginTop: 4
+                    },
+                    title: "Color de la capa"
+                  }
+                ),
+                showLayerVisibilityIcon && /* @__PURE__ */ jsx2(
+                  "button",
+                  {
+                    type: "button",
+                    className: `zlm-icon-button${visible ? " is-active" : ""}`,
+                    onClick: () => isControlled ? updateLayerVisible(layerId, !visible) : setLayers(
+                      (prev) => prev.map(
+                        (entry) => entry.mapLayer.layerId === layerId ? { ...entry, visible: !visible } : entry
+                      )
+                    ),
+                    "aria-label": visible ? "Ocultar capa" : "Mostrar capa",
+                    children: visible ? /* @__PURE__ */ jsx2(Eye, { size: 16 }) : /* @__PURE__ */ jsx2(EyeOff, { size: 16 })
+                  }
+                ),
+                /* @__PURE__ */ jsxs2("div", { style: { minWidth: 0, flex: 1 }, children: [
+                  /* @__PURE__ */ jsx2(
+                    "div",
+                    {
+                      className: "zlm-layer-name",
+                      style: {
+                        fontWeight: 700,
+                        display: "-webkit-box",
+                        WebkitLineClamp: 2,
+                        WebkitBoxOrient: "vertical",
+                        overflow: "hidden",
+                        overflowWrap: "anywhere",
+                        lineHeight: 1.2,
+                        color: muted ? "#64748b" : "#0f172a"
+                      },
+                      title: layerName,
+                      children: layerName
+                    }
+                  ),
+                  /* @__PURE__ */ jsxs2("div", { style: { color: muted ? "#94a3b8" : "#64748b", fontSize: 12 }, children: [
+                    "ID ",
+                    layerId
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsx2("div", { style: { display: "flex", alignItems: "flex-start", gap: 6, flexShrink: 0 }, children: typeof featureCount === "number" && /* @__PURE__ */ jsxs2("span", { className: "zlm-badge", children: [
+                featureCount.toLocaleString(),
+                " features"
+              ] }) })
+            ] }),
+            /* @__PURE__ */ jsx2("div", { style: { display: "flex", gap: 10, alignItems: "center" }, children: /* @__PURE__ */ jsxs2("div", { style: { flex: 1 }, children: [
+              /* @__PURE__ */ jsxs2("div", { style: { display: "flex", justifyContent: "space-between", marginBottom: 6, color: "#64748b", fontSize: 12 }, children: [
+                /* @__PURE__ */ jsx2("span", { children: "Opacidad" }),
+                /* @__PURE__ */ jsxs2("span", { children: [
+                  opacityPercent,
+                  "%"
+                ] })
+              ] }),
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  className: "zlm-range",
+                  type: "range",
+                  min: 0,
+                  max: 1,
+                  step: 0.05,
+                  value: userOpacity,
+                  style: {
+                    width: "100%",
+                    accentColor: layerColor,
+                    background: sliderBackground,
+                    height: 6,
+                    borderRadius: 999
+                  },
+                  onChange: (e) => {
+                    const value = Number(e.target.value);
+                    if (isControlled) {
+                      updateLayerOpacity(layerId, value);
+                      return;
+                    }
+                    setLayers(
+                      (prev) => prev.map(
+                        (entry) => entry.mapLayer.layerId === layerId ? { ...entry, opacity: value } : entry
+                      )
+                    );
+                  },
+                  "aria-label": `Opacidad de la capa ${layerName}`
+                }
+              )
+            ] }) })
+          ]
+        },
+        layerId.toString()
+      );
+    }) });
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: ["zenit-layer-manager", className].filter(Boolean).join(" "), style: panelStyle, children: [
+    /* @__PURE__ */ jsx2("style", { children: `
+          .zenit-layer-manager .zlm-card {
+            transition: box-shadow 0.2s ease, transform 0.2s ease, opacity 0.2s ease;
+            box-shadow: 0 6px 16px rgba(15, 23, 42, 0.08);
+          }
+          .zenit-layer-manager .zlm-card.is-muted {
+            opacity: 0.7;
+          }
+          .zenit-layer-manager .zlm-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+            margin-top: 6px;
+            padding: 2px 8px;
+            border-radius: 999px;
+            background: #f1f5f9;
+            color: #475569;
+            font-size: 11px;
+            font-weight: 600;
+          }
+          .zenit-layer-manager .zlm-icon-button {
+            border: 1px solid #e2e8f0;
+            background: #f8fafc;
+            color: #475569;
+            border-radius: 8px;
+            width: 34px;
+            height: 34px;
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            transition: all 0.15s ease;
+          }
+          .zenit-layer-manager .zlm-icon-button.is-active {
+            background: #0f172a;
+            color: #fff;
+            border-color: #0f172a;
+          }
+          .zenit-layer-manager .zlm-icon-button:hover {
+            box-shadow: 0 4px 10px rgba(15, 23, 42, 0.12);
+          }
+          .zenit-layer-manager .zlm-icon-button:focus-visible {
+            outline: 2px solid #60a5fa;
+            outline-offset: 2px;
+          }
+          .zenit-layer-manager .zlm-range {
+            width: 100%;
+            accent-color: #0f172a;
+          }
+          .zenit-layer-manager .zlm-tab {
+            flex: 1;
+            padding: 8px 12px;
+            border: none;
+            background: transparent;
+            color: #475569;
+            font-weight: 600;
+            cursor: pointer;
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            gap: 6px;
+            font-size: 13px;
+          }
+          .zenit-layer-manager .zlm-tab.is-active {
+            background: #fff;
+            color: #0f172a;
+            box-shadow: 0 4px 10px rgba(15, 23, 42, 0.08);
+            border-radius: 10px;
+          }
+          .zenit-layer-manager .zlm-tab:focus-visible {
+            outline: 2px solid #60a5fa;
+            outline-offset: 2px;
+          }
+          .zenit-layer-manager .zlm-panel-toggle {
+            border: 1px solid #e2e8f0;
+            background: #fff;
+            color: #0f172a;
+            border-radius: 10px;
+            padding: 6px 10px;
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            font-size: 12px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.15s ease;
+          }
+          .zenit-layer-manager .zlm-panel-toggle:hover {
+            box-shadow: 0 4px 10px rgba(15, 23, 42, 0.12);
+          }
+          .zenit-layer-manager .zlm-panel-toggle:focus-visible {
+            outline: 2px solid #60a5fa;
+            outline-offset: 2px;
+          }
+        ` }),
+    /* @__PURE__ */ jsxs2("div", { style: headerStyle, children: [
+      /* @__PURE__ */ jsxs2("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center" }, children: [
+        /* @__PURE__ */ jsxs2("div", { children: [
+          /* @__PURE__ */ jsx2("div", { style: { fontWeight: 800, fontSize: 16, color: "#0f172a" }, children: "Gesti\xF3n de Capas" }),
+          /* @__PURE__ */ jsxs2("div", { style: { color: "#64748b", fontSize: 12 }, children: [
+            "Mapa #",
+            map.id
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2(
+          "button",
+          {
+            type: "button",
+            onClick: () => setPanelVisible((prev) => !prev),
+            className: "zlm-panel-toggle",
+            "aria-label": panelVisible ? "Ocultar panel de capas" : "Mostrar panel de capas",
+            children: [
+              panelVisible ? /* @__PURE__ */ jsx2(Eye, { size: 16 }) : /* @__PURE__ */ jsx2(EyeOff, { size: 16 }),
+              panelVisible ? "Ocultar" : "Mostrar"
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          style: {
+            display: "flex",
+            gap: 6,
+            marginTop: 12,
+            padding: 4,
+            border: "1px solid #e2e8f0",
+            borderRadius: 12,
+            background: "#f1f5f9"
+          },
+          children: [
+            /* @__PURE__ */ jsxs2(
+              "button",
+              {
+                type: "button",
+                className: `zlm-tab${activeTab === "layers" ? " is-active" : ""}`,
+                onClick: () => setActiveTab("layers"),
+                children: [
+                  /* @__PURE__ */ jsx2(Layers, { size: 16 }),
+                  "Capas"
+                ]
+              }
+            ),
+            showUploadTab && /* @__PURE__ */ jsxs2(
+              "button",
+              {
+                type: "button",
+                className: `zlm-tab${activeTab === "upload" ? " is-active" : ""}`,
+                onClick: () => setActiveTab("upload"),
+                children: [
+                  /* @__PURE__ */ jsx2(Upload, { size: 16 }),
+                  "Subir"
+                ]
+              }
+            )
+          ]
+        }
+      )
+    ] }),
+    panelVisible && /* @__PURE__ */ jsxs2("div", { style: { padding: "12px 10px 18px", overflowY: "auto", flex: 1, minHeight: 0 }, children: [
+      activeTab === "layers" && renderLayerCards(),
+      showUploadTab && activeTab === "upload" && /* @__PURE__ */ jsx2("div", { style: { color: "#475569", fontSize: 13 }, children: "Pr\xF3ximamente podr\xE1s subir capas desde este panel." })
+    ] })
+  ] });
+};
+
+// src/react/ZenitFeatureFilterPanel.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ZenitFeatureFilterPanel = ({
+  title = "Filtros",
+  description,
+  className,
+  style,
+  children
+}) => {
+  return /* @__PURE__ */ jsxs3(
+    "section",
+    {
+      className,
+      style: {
+        border: "1px solid #e2e8f0",
+        borderRadius: 12,
+        padding: 16,
+        background: "#fff",
+        fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsxs3("header", { style: { marginBottom: 12 }, children: [
+          /* @__PURE__ */ jsx3("h3", { style: { margin: 0, fontSize: 16 }, children: title }),
+          description && /* @__PURE__ */ jsx3("p", { style: { margin: "6px 0 0", color: "#475569", fontSize: 13 }, children: description })
+        ] }),
+        /* @__PURE__ */ jsx3("div", { children })
+      ]
+    }
+  );
+};
+
+// src/react/ai/FloatingChatBox.tsx
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef4, useState as useState4 } from "react";
+import { createPortal } from "react-dom";
+
+// src/react/hooks/use-chat.ts
+import { useCallback as useCallback2, useRef as useRef3, useState as useState3 } from "react";
+
+// src/ai/chat.service.ts
+var DEFAULT_ERROR_MESSAGE = "No fue posible completar la solicitud al asistente.";
+var normalizeBaseUrl = (baseUrl) => baseUrl.replace(/\/$/, "");
+var resolveBaseUrl = (config, options) => {
+  const baseUrl = options?.baseUrl ?? config?.baseUrl;
+  if (!baseUrl) {
+    throw new Error("baseUrl es requerido para usar el chat de Zenit AI.");
+  }
+  return normalizeBaseUrl(baseUrl);
+};
+var resolveAccessToken = async (config, options) => {
+  if (options?.accessToken) return options.accessToken;
+  if (config?.accessToken) return config.accessToken;
+  if (options?.getAccessToken) return await options.getAccessToken();
+  if (config?.getAccessToken) return await config.getAccessToken();
+  return void 0;
+};
+var buildAuthHeaders = (token) => {
+  if (!token) return {};
+  return { Authorization: `Bearer ${token}` };
+};
+var parseError = async (response) => {
+  try {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const payload = await response.json();
+      const message = payload?.message ?? DEFAULT_ERROR_MESSAGE;
+      return new Error(message);
+    }
+    const text = await response.text();
+    return new Error(text || DEFAULT_ERROR_MESSAGE);
+  } catch (error) {
+    return error instanceof Error ? error : new Error(DEFAULT_ERROR_MESSAGE);
+  }
+};
+var sendMessage = async (mapId, request, options, config) => {
+  const baseUrl = resolveBaseUrl(config, options);
+  const token = await resolveAccessToken(config, options);
+  const response = await fetch(`${baseUrl}/ai/maps/chat/${mapId}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...buildAuthHeaders(token)
+    },
+    body: JSON.stringify(request),
+    signal: options?.signal
+  });
+  if (!response.ok) {
+    throw await parseError(response);
+  }
+  return await response.json();
+};
+var mergeResponse = (previous, chunk, aggregatedAnswer) => ({
+  ...previous ?? chunk,
+  ...chunk,
+  answer: aggregatedAnswer
+});
+var resolveAggregatedAnswer = (current, incoming) => {
+  if (!incoming) return current;
+  if (incoming.startsWith(current)) return incoming;
+  return current + incoming;
+};
+var sendMessageStream = async (mapId, request, callbacks = {}, options, config) => {
+  const baseUrl = resolveBaseUrl(config, options);
+  const token = await resolveAccessToken(config, options);
+  const response = await fetch(`${baseUrl}/ai/maps/chat/${mapId}/stream`, {
+    method: "POST",
+    headers: {
+      Accept: "text/event-stream",
+      "Content-Type": "application/json",
+      ...buildAuthHeaders(token)
+    },
+    body: JSON.stringify(request),
+    signal: options?.signal
+  });
+  if (!response.ok) {
+    const error = await parseError(response);
+    callbacks.onError?.(error);
+    throw error;
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const error = new Error("No se pudo iniciar el streaming de Zenit AI.");
+    callbacks.onError?.(error);
+    throw error;
+  }
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let aggregated = "";
+  let latestResponse = null;
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("event:")) continue;
+        if (!trimmed.startsWith("data:")) continue;
+        const payload = trimmed.replace(/^data:\s*/, "");
+        if (!payload || payload === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(payload);
+          aggregated = resolveAggregatedAnswer(aggregated, parsed.answer ?? "");
+          latestResponse = mergeResponse(latestResponse, parsed, aggregated);
+          if (latestResponse) {
+            callbacks.onChunk?.(latestResponse, aggregated);
+          }
+        } catch (error) {
+          callbacks.onError?.(error);
+        }
+      }
+    }
+  } catch (error) {
+    callbacks.onError?.(error);
+    throw error;
+  }
+  if (!latestResponse) {
+    const error = new Error(DEFAULT_ERROR_MESSAGE);
+    callbacks.onError?.(error);
+    throw error;
+  }
+  callbacks.onComplete?.(latestResponse);
+  return latestResponse;
+};
+var createChatService = (config) => ({
+  sendMessage: (mapId, request, options) => sendMessage(mapId, request, options, config),
+  sendMessageStream: (mapId, request, callbacks, options) => sendMessageStream(mapId, request, callbacks, options, config)
+});
+
+// src/react/hooks/use-chat.ts
+var useSendMessage = (config) => {
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const send = useCallback2(
+    async (mapId, request, options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        return await sendMessage(mapId, request, options, config);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [config]
+  );
+  return { sendMessage: send, isLoading, error };
+};
+var useSendMessageStream = (config) => {
+  const [isStreaming, setIsStreaming] = useState3(false);
+  const [streamingText, setStreamingText] = useState3("");
+  const [completeResponse, setCompleteResponse] = useState3(null);
+  const [error, setError] = useState3(null);
+  const requestIdRef = useRef3(0);
+  const reset = useCallback2(() => {
+    setIsStreaming(false);
+    setStreamingText("");
+    setCompleteResponse(null);
+    setError(null);
+  }, []);
+  const send = useCallback2(
+    async (mapId, request, options) => {
+      const requestId = requestIdRef.current + 1;
+      requestIdRef.current = requestId;
+      setIsStreaming(true);
+      setStreamingText("");
+      setCompleteResponse(null);
+      setError(null);
+      try {
+        const response = await sendMessageStream(
+          mapId,
+          request,
+          {
+            onChunk: (_chunk, aggregated) => {
+              if (requestIdRef.current !== requestId) return;
+              setStreamingText(aggregated);
+            },
+            onError: (err) => {
+              if (requestIdRef.current !== requestId) return;
+              setError(err);
+            },
+            onComplete: (finalResponse) => {
+              if (requestIdRef.current !== requestId) return;
+              setCompleteResponse(finalResponse);
+            }
+          },
+          options,
+          config
+        );
+        return response;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        if (requestIdRef.current === requestId) {
+          setIsStreaming(false);
+        }
+      }
+    },
+    [config]
+  );
+  return {
+    sendMessage: send,
+    isStreaming,
+    streamingText,
+    completeResponse,
+    error,
+    reset
+  };
+};
+
+// src/react/components/MarkdownRenderer.tsx
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function normalizeAssistantMarkdown(text) {
+  if (!text || typeof text !== "string") return "";
+  let normalized = text;
+  normalized = normalized.replace(/\r\n/g, "\n");
+  normalized = normalized.replace(/^\s*#{1,6}\s*$/gm, "");
+  normalized = normalized.replace(/\n{3,}/g, "\n\n");
+  normalized = normalized.split("\n").map((line) => line.trimEnd()).join("\n");
+  normalized = normalized.trim();
+  return normalized;
+}
+var MarkdownRenderer = ({ content, className }) => {
+  const normalizedContent = normalizeAssistantMarkdown(content);
+  if (!normalizedContent) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx4("div", { className, style: { wordBreak: "break-word" }, children: /* @__PURE__ */ jsx4(
+    ReactMarkdown,
+    {
+      remarkPlugins: [remarkGfm],
+      components: {
+        // Headings with proper spacing
+        h1: ({ children, ...props }) => /* @__PURE__ */ jsx4("h1", { style: { fontSize: "1.5em", fontWeight: 700, marginTop: "1em", marginBottom: "0.5em" }, ...props, children }),
+        h2: ({ children, ...props }) => /* @__PURE__ */ jsx4("h2", { style: { fontSize: "1.3em", fontWeight: 700, marginTop: "0.9em", marginBottom: "0.45em" }, ...props, children }),
+        h3: ({ children, ...props }) => /* @__PURE__ */ jsx4("h3", { style: { fontSize: "1.15em", fontWeight: 600, marginTop: "0.75em", marginBottom: "0.4em" }, ...props, children }),
+        h4: ({ children, ...props }) => /* @__PURE__ */ jsx4("h4", { style: { fontSize: "1.05em", fontWeight: 600, marginTop: "0.6em", marginBottom: "0.35em" }, ...props, children }),
+        h5: ({ children, ...props }) => /* @__PURE__ */ jsx4("h5", { style: { fontSize: "1em", fontWeight: 600, marginTop: "0.5em", marginBottom: "0.3em" }, ...props, children }),
+        h6: ({ children, ...props }) => /* @__PURE__ */ jsx4("h6", { style: { fontSize: "0.95em", fontWeight: 600, marginTop: "0.5em", marginBottom: "0.3em" }, ...props, children }),
+        // Paragraphs with comfortable line height
+        p: ({ children, ...props }) => /* @__PURE__ */ jsx4("p", { style: { marginTop: "0.5em", marginBottom: "0.5em", lineHeight: 1.6 }, ...props, children }),
+        // Lists with proper indentation
+        ul: ({ children, ...props }) => /* @__PURE__ */ jsx4("ul", { style: { paddingLeft: "1.5em", marginTop: "0.5em", marginBottom: "0.5em" }, ...props, children }),
+        ol: ({ children, ...props }) => /* @__PURE__ */ jsx4("ol", { style: { paddingLeft: "1.5em", marginTop: "0.5em", marginBottom: "0.5em" }, ...props, children }),
+        li: ({ children, ...props }) => /* @__PURE__ */ jsx4("li", { style: { marginTop: "0.25em", marginBottom: "0.25em" }, ...props, children }),
+        // Code blocks
+        code: ({ inline, children, ...props }) => {
+          if (inline) {
+            return /* @__PURE__ */ jsx4(
+              "code",
+              {
+                style: {
+                  backgroundColor: "rgba(0, 0, 0, 0.08)",
+                  padding: "0.15em 0.4em",
+                  borderRadius: "4px",
+                  fontSize: "0.9em",
+                  fontFamily: "monospace"
+                },
+                ...props,
+                children
+              }
+            );
+          }
+          return /* @__PURE__ */ jsx4(
+            "code",
+            {
+              style: {
+                display: "block",
+                backgroundColor: "rgba(0, 0, 0, 0.08)",
+                padding: "0.75em",
+                borderRadius: "6px",
+                fontSize: "0.9em",
+                fontFamily: "monospace",
+                overflowX: "auto",
+                marginTop: "0.5em",
+                marginBottom: "0.5em"
+              },
+              ...props,
+              children
+            }
+          );
+        },
+        // Pre (code block wrapper)
+        pre: ({ children, ...props }) => /* @__PURE__ */ jsx4("pre", { style: { margin: 0 }, ...props, children }),
+        // Blockquotes
+        blockquote: ({ children, ...props }) => /* @__PURE__ */ jsx4(
+          "blockquote",
+          {
+            style: {
+              borderLeft: "4px solid rgba(0, 0, 0, 0.2)",
+              paddingLeft: "1em",
+              marginLeft: 0,
+              marginTop: "0.5em",
+              marginBottom: "0.5em",
+              color: "rgba(0, 0, 0, 0.7)"
+            },
+            ...props,
+            children
+          }
+        ),
+        // Strong/bold
+        strong: ({ children, ...props }) => /* @__PURE__ */ jsx4("strong", { style: { fontWeight: 600 }, ...props, children }),
+        // Emphasis/italic
+        em: ({ children, ...props }) => /* @__PURE__ */ jsx4("em", { style: { fontStyle: "italic" }, ...props, children }),
+        // Horizontal rule
+        hr: (props) => /* @__PURE__ */ jsx4(
+          "hr",
+          {
+            style: {
+              border: "none",
+              borderTop: "1px solid rgba(0, 0, 0, 0.1)",
+              marginTop: "1em",
+              marginBottom: "1em"
+            },
+            ...props
+          }
+        ),
+        // Tables (GFM)
+        table: ({ children, ...props }) => /* @__PURE__ */ jsx4("div", { style: { overflowX: "auto", marginTop: "0.5em", marginBottom: "0.5em" }, children: /* @__PURE__ */ jsx4(
+          "table",
+          {
+            style: {
+              borderCollapse: "collapse",
+              width: "100%",
+              fontSize: "0.9em"
+            },
+            ...props,
+            children
+          }
+        ) }),
+        th: ({ children, ...props }) => /* @__PURE__ */ jsx4(
+          "th",
+          {
+            style: {
+              border: "1px solid rgba(0, 0, 0, 0.2)",
+              padding: "0.5em",
+              backgroundColor: "rgba(0, 0, 0, 0.05)",
+              fontWeight: 600,
+              textAlign: "left"
+            },
+            ...props,
+            children
+          }
+        ),
+        td: ({ children, ...props }) => /* @__PURE__ */ jsx4(
+          "td",
+          {
+            style: {
+              border: "1px solid rgba(0, 0, 0, 0.2)",
+              padding: "0.5em"
+            },
+            ...props,
+            children
+          }
+        )
+      },
+      children: normalizedContent
+    }
+  ) });
+};
+
+// src/react/ai/FloatingChatBox.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var ChatIcon = () => /* @__PURE__ */ jsx5("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx5("path", { d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" }) });
+var CloseIcon = () => /* @__PURE__ */ jsxs4("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ jsx5("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+  /* @__PURE__ */ jsx5("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+] });
+var ExpandIcon = () => /* @__PURE__ */ jsxs4("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ jsx5("polyline", { points: "15 3 21 3 21 9" }),
+  /* @__PURE__ */ jsx5("polyline", { points: "9 21 3 21 3 15" }),
+  /* @__PURE__ */ jsx5("line", { x1: "21", y1: "3", x2: "14", y2: "10" }),
+  /* @__PURE__ */ jsx5("line", { x1: "3", y1: "21", x2: "10", y2: "14" })
+] });
+var CollapseIcon = () => /* @__PURE__ */ jsxs4("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ jsx5("polyline", { points: "4 14 10 14 10 20" }),
+  /* @__PURE__ */ jsx5("polyline", { points: "20 10 14 10 14 4" }),
+  /* @__PURE__ */ jsx5("line", { x1: "14", y1: "10", x2: "21", y2: "3" }),
+  /* @__PURE__ */ jsx5("line", { x1: "3", y1: "21", x2: "10", y2: "14" })
+] });
+var SendIcon = () => /* @__PURE__ */ jsxs4("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ jsx5("line", { x1: "22", y1: "2", x2: "11", y2: "13" }),
+  /* @__PURE__ */ jsx5("polygon", { points: "22 2 15 22 11 13 2 9 22 2" })
+] });
+var LayersIcon = () => /* @__PURE__ */ jsxs4("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ jsx5("polygon", { points: "12 2 2 7 12 12 22 7 12 2" }),
+  /* @__PURE__ */ jsx5("polyline", { points: "2 17 12 22 22 17" }),
+  /* @__PURE__ */ jsx5("polyline", { points: "2 12 12 17 22 12" })
+] });
+var styles = {
+  root: {
+    fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'
+  },
+  // Floating button (closed state - wide with text, open state - circular with X)
+  floatingButton: {
+    position: "fixed",
+    bottom: 24,
+    right: 24,
+    borderRadius: "999px",
+    border: "none",
+    cursor: "pointer",
+    background: "linear-gradient(135deg, #10b981, #059669)",
+    color: "#fff",
+    boxShadow: "0 12px 28px rgba(16, 185, 129, 0.4)",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    fontSize: 15,
+    fontWeight: 600,
+    zIndex: 99999,
+    transition: "all 0.3s cubic-bezier(0.4, 0, 0.2, 1)"
+  },
+  floatingButtonClosed: {
+    padding: "14px 24px",
+    gap: 8
+  },
+  floatingButtonOpen: {
+    width: 56,
+    height: 56,
+    padding: 0
+  },
+  floatingButtonMobile: {
+    width: 56,
+    height: 56,
+    padding: 0
+  },
+  // Panel (expandable)
+  panel: {
+    position: "fixed",
+    bottom: 92,
+    right: 24,
+    background: "#fff",
+    borderRadius: 16,
+    boxShadow: "0 20px 60px rgba(15, 23, 42, 0.3), 0 0 0 1px rgba(15, 23, 42, 0.05)",
+    display: "flex",
+    flexDirection: "column",
+    overflow: "hidden",
+    zIndex: 99999,
+    transition: "all 0.3s cubic-bezier(0.4, 0, 0.2, 1)"
+  },
+  panelNormal: {
+    width: 400,
+    height: 550
+  },
+  panelExpanded: {
+    width: 520,
+    height: 700
+  },
+  // Header with green gradient
+  header: {
+    padding: "16px 18px",
+    background: "linear-gradient(135deg, #10b981, #059669)",
+    color: "#fff",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between"
+  },
+  title: {
+    margin: 0,
+    fontSize: 16,
+    fontWeight: 600,
+    letterSpacing: "-0.01em"
+  },
+  headerButtons: {
+    display: "flex",
+    alignItems: "center",
+    gap: 8
+  },
+  headerButton: {
+    border: "none",
+    background: "rgba(255, 255, 255, 0.15)",
+    color: "#fff",
+    width: 32,
+    height: 32,
+    borderRadius: 8,
+    cursor: "pointer",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    transition: "background 0.2s"
+  },
+  // Messages area
+  messages: {
+    flex: 1,
+    padding: "20px 18px",
+    overflowY: "auto",
+    background: "#f8fafc",
+    display: "flex",
+    flexDirection: "column",
+    gap: 16
+  },
+  // Message bubbles
+  messageWrapper: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 8
+  },
+  messageBubble: {
+    maxWidth: "85%",
+    padding: "12px 14px",
+    borderRadius: 16,
+    lineHeight: 1.5,
+    fontSize: 14,
+    whiteSpace: "pre-wrap",
+    wordBreak: "break-word"
+  },
+  userMessage: {
+    alignSelf: "flex-end",
+    background: "linear-gradient(135deg, #10b981, #059669)",
+    color: "#fff",
+    borderBottomRightRadius: 4
+  },
+  assistantMessage: {
+    alignSelf: "flex-start",
+    background: "#e2e8f0",
+    color: "#0f172a",
+    borderBottomLeftRadius: 4
+  },
+  // Streaming cursor
+  cursor: {
+    display: "inline-block",
+    width: 2,
+    height: 16,
+    background: "#0f172a",
+    marginLeft: 2,
+    animation: "zenitBlink 1s infinite",
+    verticalAlign: "text-bottom"
+  },
+  thinkingText: {
+    fontStyle: "italic",
+    opacity: 0.7,
+    display: "flex",
+    alignItems: "center",
+    gap: 8
+  },
+  typingIndicator: {
+    display: "flex",
+    gap: 4,
+    alignItems: "center"
+  },
+  typingDot: {
+    width: 8,
+    height: 8,
+    borderRadius: "50%",
+    backgroundColor: "#059669",
+    animation: "typingDotBounce 1.4s infinite ease-in-out"
+  },
+  // Metadata section (Referenced Layers)
+  metadataSection: {
+    marginTop: 12,
+    padding: "10px 12px",
+    background: "rgba(255, 255, 255, 0.5)",
+    borderRadius: 10,
+    fontSize: 12
+  },
+  metadataTitle: {
+    fontWeight: 600,
+    color: "#059669",
+    marginBottom: 6,
+    display: "flex",
+    alignItems: "center",
+    gap: 6
+  },
+  metadataList: {
+    margin: 0,
+    paddingLeft: 18,
+    color: "#475569"
+  },
+  metadataItem: {
+    marginBottom: 2
+  },
+  // Suggested actions
+  actionsSection: {
+    marginTop: 12
+  },
+  sectionLabel: {
+    fontSize: 11,
+    fontWeight: 600,
+    color: "#64748b",
+    marginBottom: 8,
+    textTransform: "uppercase",
+    letterSpacing: "0.05em"
+  },
+  actionsGrid: {
+    display: "flex",
+    flexWrap: "wrap",
+    gap: 6
+  },
+  actionButton: {
+    border: "1px solid #d1fae5",
+    background: "#d1fae5",
+    color: "#065f46",
+    borderRadius: 999,
+    padding: "6px 12px",
+    fontSize: 12,
+    fontWeight: 500,
+    cursor: "pointer",
+    transition: "all 0.2s"
+  },
+  // Follow-up questions
+  followUpButton: {
+    border: "1px solid #cbd5e1",
+    background: "#fff",
+    color: "#475569",
+    borderRadius: 10,
+    padding: "8px 12px",
+    fontSize: 12,
+    fontWeight: 500,
+    cursor: "pointer",
+    textAlign: "left",
+    width: "100%",
+    transition: "all 0.2s"
+  },
+  // Input area
+  inputWrapper: {
+    borderTop: "1px solid #e2e8f0",
+    padding: "14px 16px",
+    display: "flex",
+    gap: 10,
+    alignItems: "flex-end",
+    background: "#fff"
+  },
+  textarea: {
+    flex: 1,
+    resize: "none",
+    borderRadius: 12,
+    border: "1.5px solid #cbd5e1",
+    padding: "10px 12px",
+    fontSize: 14,
+    fontFamily: "inherit",
+    lineHeight: 1.4,
+    transition: "border-color 0.2s"
+  },
+  textareaFocus: {
+    borderColor: "#10b981",
+    outline: "none"
+  },
+  sendButton: {
+    borderRadius: 12,
+    border: "none",
+    padding: "10px 14px",
+    background: "linear-gradient(135deg, #10b981, #059669)",
+    color: "#fff",
+    cursor: "pointer",
+    fontSize: 14,
+    fontWeight: 600,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    transition: "opacity 0.2s, transform 0.2s",
+    minWidth: 44,
+    height: 44
+  },
+  // Status messages
+  statusNote: {
+    padding: "0 16px 14px",
+    fontSize: 12,
+    color: "#64748b",
+    textAlign: "center"
+  },
+  errorText: {
+    padding: "0 16px 14px",
+    fontSize: 12,
+    color: "#dc2626",
+    textAlign: "center"
+  }
+};
+var FloatingChatBox = ({
+  mapId,
+  filteredLayerIds,
+  filters,
+  userId,
+  baseUrl,
+  accessToken,
+  getAccessToken,
+  onActionClick,
+  onOpenChange,
+  hideButton,
+  open: openProp
+}) => {
+  const isControlled = openProp !== void 0;
+  const [internalOpen, setInternalOpen] = useState4(false);
+  const open = isControlled ? openProp : internalOpen;
+  const setOpen = useCallback3((value) => {
+    const newValue = typeof value === "function" ? value(open) : value;
+    if (!isControlled) {
+      setInternalOpen(newValue);
+    }
+    onOpenChange?.(newValue);
+  }, [isControlled, open, onOpenChange]);
+  const [expanded, setExpanded] = useState4(false);
+  const [messages, setMessages] = useState4([]);
+  const [inputValue, setInputValue] = useState4("");
+  const [conversationId, setConversationId] = useState4();
+  const [errorMessage, setErrorMessage] = useState4(null);
+  const [isFocused, setIsFocused] = useState4(false);
+  const [isMobile, setIsMobile] = useState4(false);
+  const messagesEndRef = useRef4(null);
+  const messagesContainerRef = useRef4(null);
+  const chatBoxRef = useRef4(null);
+  const chatConfig = useMemo3(() => {
+    if (!baseUrl) return void 0;
+    return { baseUrl, accessToken, getAccessToken };
+  }, [accessToken, baseUrl, getAccessToken]);
+  const { sendMessage: sendMessage2, isStreaming, streamingText, completeResponse } = useSendMessageStream(chatConfig);
+  const canSend = Boolean(mapId) && Boolean(baseUrl) && inputValue.trim().length > 0 && !isStreaming;
+  useEffect3(() => {
+    if (open && isMobile) {
+      setExpanded(true);
+    }
+  }, [open, isMobile]);
+  const scrollToBottom = useCallback3(() => {
+    if (messagesEndRef.current) {
+      messagesEndRef.current.scrollIntoView({ behavior: "smooth" });
+    }
+  }, []);
+  useEffect3(() => {
+    if (open && messages.length === 0) {
+      setMessages([
+        {
+          id: "welcome",
+          role: "assistant",
+          content: "Hola, soy el asistente de IA de ZENIT. Estoy aqu\xED para ayudarte a analizar tu mapa y responder tus preguntas sobre las capas y datos. \xBFEn qu\xE9 puedo ayudarte hoy?"
+        }
+      ]);
+    }
+  }, [open, messages.length]);
+  useEffect3(() => {
+    scrollToBottom();
+  }, [messages, streamingText, scrollToBottom]);
+  useEffect3(() => {
+    if (!open) return;
+    if (isMobile && expanded) return;
+    const handleClickOutside = (event) => {
+      if (chatBoxRef.current && !chatBoxRef.current.contains(event.target)) {
+        setOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [open, isMobile, expanded]);
+  useEffect3(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia("(max-width: 768px)");
+    const updateMobile = () => setIsMobile(mediaQuery.matches);
+    updateMobile();
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", updateMobile);
+    } else {
+      mediaQuery.addListener(updateMobile);
+    }
+    return () => {
+      if (mediaQuery.removeEventListener) {
+        mediaQuery.removeEventListener("change", updateMobile);
+      } else {
+        mediaQuery.removeListener(updateMobile);
+      }
+    };
+  }, []);
+  useEffect3(() => {
+    if (typeof document === "undefined") return;
+    if (!open || !isMobile) return;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = "";
+    };
+  }, [open, isMobile]);
+  const addMessage = useCallback3((message) => {
+    setMessages((prev) => [...prev, message]);
+  }, []);
+  const handleSend = useCallback3(async () => {
+    if (!mapId) {
+      setErrorMessage("Selecciona un mapa para usar el asistente.");
+      return;
+    }
+    if (!baseUrl) {
+      setErrorMessage("Configura la baseUrl del SDK para usar Zenit AI.");
+      return;
+    }
+    if (!inputValue.trim()) return;
+    const messageText = inputValue.trim();
+    setInputValue("");
+    setErrorMessage(null);
+    addMessage({
+      id: `user-${Date.now()}`,
+      role: "user",
+      content: messageText
+    });
+    const request = {
+      message: messageText,
+      conversationId,
+      filteredLayerIds,
+      filters,
+      userId
+    };
+    try {
+      const response = await sendMessage2(mapId, request);
+      setConversationId(response.conversationId ?? conversationId);
+      addMessage({
+        id: `assistant-${Date.now()}`,
+        role: "assistant",
+        content: response.answer,
+        response
+      });
+    } catch (error) {
+      setErrorMessage(error instanceof Error ? error.message : "Ocurri\xF3 un error inesperado.");
+      addMessage({
+        id: `error-${Date.now()}`,
+        role: "assistant",
+        content: `\u274C Error: ${error instanceof Error ? error.message : "Ocurri\xF3 un error inesperado."}`
+      });
+    }
+  }, [
+    addMessage,
+    baseUrl,
+    conversationId,
+    filteredLayerIds,
+    filters,
+    inputValue,
+    mapId,
+    sendMessage2,
+    userId
+  ]);
+  const handleKeyDown = useCallback3(
+    (event) => {
+      if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        if (canSend) {
+          void handleSend();
+        }
+      }
+    },
+    [canSend, handleSend]
+  );
+  const handleFollowUpClick = useCallback3((question) => {
+    setInputValue(question);
+  }, []);
+  const renderMetadata = (response) => {
+    if (!response?.metadata) return null;
+    const referencedLayers = response.metadata.referencedLayers;
+    if (!referencedLayers || referencedLayers.length === 0) return null;
+    return /* @__PURE__ */ jsxs4("div", { style: styles.metadataSection, children: [
+      /* @__PURE__ */ jsxs4("div", { style: styles.metadataTitle, children: [
+        /* @__PURE__ */ jsx5(LayersIcon, {}),
+        "Capas Analizadas"
+      ] }),
+      /* @__PURE__ */ jsx5("ul", { style: styles.metadataList, children: referencedLayers.map((layer, index) => /* @__PURE__ */ jsxs4("li", { style: styles.metadataItem, children: [
+        /* @__PURE__ */ jsx5("strong", { children: layer.layerName }),
+        " (",
+        layer.featureCount,
+        " ",
+        layer.featureCount === 1 ? "elemento" : "elementos",
+        ")"
+      ] }, index)) })
+    ] });
+  };
+  const handleActionClick = useCallback3((action) => {
+    if (isStreaming) return;
+    setOpen(false);
+    requestAnimationFrame(() => {
+      onActionClick?.(action);
+    });
+  }, [isStreaming, setOpen, onActionClick]);
+  const renderActions = (response) => {
+    if (!response?.suggestedActions?.length) return null;
+    return /* @__PURE__ */ jsxs4("div", { style: styles.actionsSection, children: [
+      /* @__PURE__ */ jsx5("div", { style: styles.sectionLabel, children: "Acciones Sugeridas" }),
+      /* @__PURE__ */ jsx5("div", { style: styles.actionsGrid, children: response.suggestedActions.map((action, index) => /* @__PURE__ */ jsx5(
+        "button",
+        {
+          type: "button",
+          style: {
+            ...styles.actionButton,
+            opacity: isStreaming ? 0.5 : 1,
+            cursor: isStreaming ? "not-allowed" : "pointer"
+          },
+          onClick: () => handleActionClick(action),
+          disabled: isStreaming,
+          onMouseEnter: (e) => {
+            if (!isStreaming) {
+              e.currentTarget.style.background = "#a7f3d0";
+              e.currentTarget.style.borderColor = "#a7f3d0";
+            }
+          },
+          onMouseLeave: (e) => {
+            if (!isStreaming) {
+              e.currentTarget.style.background = "#d1fae5";
+              e.currentTarget.style.borderColor = "#d1fae5";
+            }
+          },
+          children: action.label ?? action.action ?? "Acci\xF3n"
+        },
+        `${action.label ?? action.action ?? "action"}-${index}`
+      )) })
+    ] });
+  };
+  const renderFollowUps = (response) => {
+    if (!response?.followUpQuestions?.length) return null;
+    return /* @__PURE__ */ jsxs4("div", { style: styles.actionsSection, children: [
+      /* @__PURE__ */ jsx5("div", { style: styles.sectionLabel, children: "Preguntas Relacionadas" }),
+      /* @__PURE__ */ jsx5("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: response.followUpQuestions.map((question, index) => /* @__PURE__ */ jsx5(
+        "button",
+        {
+          type: "button",
+          style: {
+            ...styles.followUpButton,
+            opacity: isStreaming ? 0.5 : 1,
+            cursor: isStreaming ? "not-allowed" : "pointer"
+          },
+          onClick: () => !isStreaming && handleFollowUpClick(question),
+          disabled: isStreaming,
+          onMouseEnter: (e) => {
+            if (!isStreaming) {
+              e.currentTarget.style.background = "#f8fafc";
+              e.currentTarget.style.borderColor = "#10b981";
+            }
+          },
+          onMouseLeave: (e) => {
+            if (!isStreaming) {
+              e.currentTarget.style.background = "#fff";
+              e.currentTarget.style.borderColor = "#cbd5e1";
+            }
+          },
+          children: question
+        },
+        `followup-${index}`
+      )) })
+    ] });
+  };
+  const chatContent = /* @__PURE__ */ jsxs4("div", { style: styles.root, children: [
+    /* @__PURE__ */ jsx5("style", { children: `
+        @keyframes zenitBlink {
+          0%, 49% { opacity: 1; }
+          50%, 100% { opacity: 0; }
+        }
+        @keyframes zenitPulse {
+          0% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.7); }
+          70% { box-shadow: 0 0 0 14px rgba(16, 185, 129, 0); }
+          100% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0); }
+        }
+        @keyframes typingDotBounce {
+          0%, 60%, 100% { transform: translateY(0); }
+          30% { transform: translateY(-8px); }
+        }
+        .zenit-typing-dot:nth-child(1) { animation-delay: 0s; }
+        .zenit-typing-dot:nth-child(2) { animation-delay: 0.2s; }
+        .zenit-typing-dot:nth-child(3) { animation-delay: 0.4s; }
+        .zenit-ai-button:not(.open) {
+          animation: zenitPulse 2.5s infinite;
+        }
+        .zenit-ai-button:hover {
+          transform: scale(1.05);
+        }
+        .zenit-ai-button:active {
+          transform: scale(0.95);
+        }
+        .zenit-send-button:disabled {
+          opacity: 0.5;
+          cursor: not-allowed;
+        }
+        .zenit-send-button:not(:disabled):hover {
+          opacity: 0.9;
+          transform: translateY(-1px);
+        }
+        .zenit-send-button:not(:disabled):active {
+          transform: translateY(0);
+        }
+        .zenit-chat-panel {
+          box-sizing: border-box;
+        }
+        @media (max-width: 768px) {
+          .zenit-chat-panel.zenit-chat-panel--fullscreen {
+            position: fixed !important;
+            inset: 0 !important;
+            width: 100vw !important;
+            max-width: 100vw !important;
+            height: 100vh !important;
+            height: 100dvh !important;
+            border-radius: 0 !important;
+            display: flex !important;
+            flex-direction: column !important;
+            overflow: hidden !important;
+            z-index: 100000 !important;
+            padding-top: env(safe-area-inset-top);
+          }
+          .zenit-chat-panel.zenit-chat-panel--fullscreen .zenit-ai-body {
+            flex: 1;
+            min-height: 0;
+            overflow-y: auto;
+            -webkit-overflow-scrolling: touch;
+          }
+          .zenit-chat-panel.zenit-chat-panel--fullscreen .zenit-ai-input-area {
+            flex-shrink: 0;
+            padding-bottom: max(14px, env(safe-area-inset-bottom));
+          }
+          .zenit-ai-button.zenit-ai-button--hidden-mobile {
+            display: none !important;
+          }
+        }
+      ` }),
+    open && /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        ref: chatBoxRef,
+        className: `zenit-chat-panel${expanded ? " zenit-chat-panel--expanded" : ""}${isMobile ? " zenit-chat-panel--fullscreen" : ""}`,
+        style: {
+          ...styles.panel,
+          ...expanded ? styles.panelExpanded : styles.panelNormal
+        },
+        children: [
+          /* @__PURE__ */ jsxs4("header", { style: styles.header, children: [
+            /* @__PURE__ */ jsx5("h3", { style: styles.title, children: "Asistente Zenit AI" }),
+            /* @__PURE__ */ jsxs4("div", { style: styles.headerButtons, children: [
+              /* @__PURE__ */ jsx5(
+                "button",
+                {
+                  type: "button",
+                  style: styles.headerButton,
+                  onClick: () => setExpanded(!expanded),
+                  onMouseEnter: (e) => {
+                    e.currentTarget.style.background = "rgba(255, 255, 255, 0.25)";
+                  },
+                  onMouseLeave: (e) => {
+                    e.currentTarget.style.background = "rgba(255, 255, 255, 0.15)";
+                  },
+                  "aria-label": expanded ? "Contraer" : "Expandir",
+                  children: expanded ? /* @__PURE__ */ jsx5(CollapseIcon, {}) : /* @__PURE__ */ jsx5(ExpandIcon, {})
+                }
+              ),
+              /* @__PURE__ */ jsx5(
+                "button",
+                {
+                  type: "button",
+                  style: styles.headerButton,
+                  onClick: () => setOpen(false),
+                  onMouseEnter: (e) => {
+                    e.currentTarget.style.background = "rgba(255, 255, 255, 0.25)";
+                  },
+                  onMouseLeave: (e) => {
+                    e.currentTarget.style.background = "rgba(255, 255, 255, 0.15)";
+                  },
+                  "aria-label": "Cerrar",
+                  children: /* @__PURE__ */ jsx5(CloseIcon, {})
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs4("div", { ref: messagesContainerRef, className: "zenit-ai-body", style: styles.messages, children: [
+            messages.map((message) => /* @__PURE__ */ jsx5(
+              "div",
+              {
+                style: {
+                  ...styles.messageWrapper,
+                  alignItems: message.role === "user" ? "flex-end" : "flex-start"
+                },
+                children: /* @__PURE__ */ jsxs4(
+                  "div",
+                  {
+                    style: {
+                      ...styles.messageBubble,
+                      ...message.role === "user" ? styles.userMessage : styles.assistantMessage
+                    },
+                    children: [
+                      message.role === "assistant" ? /* @__PURE__ */ jsx5(MarkdownRenderer, { content: message.content }) : message.content,
+                      message.role === "assistant" && renderMetadata(message.response),
+                      message.role === "assistant" && renderActions(message.response),
+                      message.role === "assistant" && renderFollowUps(message.response)
+                    ]
+                  }
+                )
+              },
+              message.id
+            )),
+            isStreaming && /* @__PURE__ */ jsx5(
+              "div",
+              {
+                style: {
+                  ...styles.messageWrapper,
+                  alignItems: "flex-start"
+                },
+                children: /* @__PURE__ */ jsx5(
+                  "div",
+                  {
+                    style: {
+                      ...styles.messageBubble,
+                      ...styles.assistantMessage
+                    },
+                    children: streamingText ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+                      /* @__PURE__ */ jsx5(MarkdownRenderer, { content: streamingText }),
+                      /* @__PURE__ */ jsx5("span", { style: styles.cursor })
+                    ] }) : /* @__PURE__ */ jsxs4("div", { style: styles.thinkingText, children: [
+                      /* @__PURE__ */ jsx5("span", { children: "Analizando" }),
+                      /* @__PURE__ */ jsxs4("div", { style: styles.typingIndicator, children: [
+                        /* @__PURE__ */ jsx5("div", { className: "zenit-typing-dot", style: styles.typingDot }),
+                        /* @__PURE__ */ jsx5("div", { className: "zenit-typing-dot", style: styles.typingDot }),
+                        /* @__PURE__ */ jsx5("div", { className: "zenit-typing-dot", style: styles.typingDot })
+                      ] })
+                    ] })
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx5("div", { ref: messagesEndRef })
+          ] }),
+          /* @__PURE__ */ jsxs4("div", { className: "zenit-ai-input-area", style: styles.inputWrapper, children: [
+            /* @__PURE__ */ jsx5(
+              "textarea",
+              {
+                style: {
+                  ...styles.textarea,
+                  ...isFocused ? styles.textareaFocus : {}
+                },
+                rows: 2,
+                value: inputValue,
+                onChange: (event) => setInputValue(event.target.value),
+                onKeyDown: handleKeyDown,
+                onFocus: () => setIsFocused(true),
+                onBlur: () => setIsFocused(false),
+                placeholder: !mapId ? "Selecciona un mapa para comenzar" : isStreaming ? "Esperando respuesta..." : "Escribe tu pregunta...",
+                disabled: !mapId || !baseUrl || isStreaming
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              "button",
+              {
+                type: "button",
+                className: "zenit-send-button",
+                style: styles.sendButton,
+                onClick: () => void handleSend(),
+                disabled: !canSend,
+                "aria-label": "Enviar mensaje",
+                children: /* @__PURE__ */ jsx5(SendIcon, {})
+              }
+            )
+          ] }),
+          errorMessage && /* @__PURE__ */ jsx5("div", { style: styles.errorText, children: errorMessage }),
+          !mapId && !errorMessage && /* @__PURE__ */ jsx5("div", { style: styles.statusNote, children: "Selecciona un mapa para usar el asistente" }),
+          !baseUrl && !errorMessage && /* @__PURE__ */ jsx5("div", { style: styles.statusNote, children: "Configura la baseUrl del SDK" })
+        ]
+      }
+    ),
+    !(hideButton && !open) && /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: `zenit-ai-button ${open ? "open" : ""}${open && isMobile ? " zenit-ai-button--hidden-mobile" : ""}`,
+        style: {
+          ...styles.floatingButton,
+          ...open ? styles.floatingButtonOpen : isMobile ? styles.floatingButtonMobile : styles.floatingButtonClosed
+        },
+        onClick: () => setOpen((prev) => !prev),
+        "aria-label": open ? "Cerrar asistente" : "Abrir asistente Zenit AI",
+        children: open ? /* @__PURE__ */ jsx5(CloseIcon, {}) : /* @__PURE__ */ jsxs4(Fragment, { children: [
+          /* @__PURE__ */ jsx5(ChatIcon, {}),
+          !isMobile && /* @__PURE__ */ jsx5("span", { children: "Asistente IA" })
+        ] })
+      }
+    )
+  ] });
+  if (typeof document !== "undefined") {
+    return createPortal(chatContent, document.body);
+  }
+  return chatContent;
+};
+
+export {
+  extractMapDto,
+  normalizeMapCenter,
+  normalizeMapLayers,
+  computeBBoxFromFeature,
+  centroidFromBBox,
+  applyFilteredGeoJSONStrategy,
+  initLayerStates,
+  applyLayerOverrides,
+  resetOverrides,
+  sendMessage,
+  sendMessageStream,
+  createChatService,
+  resolveLayerAccent,
+  getLayerColor,
+  getStyleByLayerId,
+  getAccentByLayerId,
+  clampNumber,
+  clampOpacity3 as clampOpacity,
+  isPolygonLayer,
+  getZoomOpacityFactor,
+  getLayerZoomOpacityFactor,
+  getEffectiveLayerOpacity,
+  ZenitMap,
+  Eye,
+  EyeOff,
+  ChevronLeft,
+  ChevronRight,
+  Layers,
+  Upload,
+  X,
+  ZoomIn,
+  ZenitLayerManager,
+  ZenitFeatureFilterPanel,
+  useSendMessage,
+  useSendMessageStream,
+  FloatingChatBox
+};
+//# sourceMappingURL=chunk-LX2N2BXV.mjs.map