zenit-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,4165 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ChevronLeft: () => import_lucide_react.ChevronLeft,
+  ChevronRight: () => import_lucide_react.ChevronRight,
+  DEFAULT_MAX_FEATURES_FULL_GEOJSON: () => DEFAULT_MAX_FEATURES_FULL_GEOJSON,
+  Eye: () => import_lucide_react.Eye,
+  EyeOff: () => import_lucide_react.EyeOff,
+  FilterEngine: () => FilterEngine,
+  FloatingChatBox: () => FloatingChatBox,
+  HttpClient: () => HttpClient,
+  Layers: () => import_lucide_react.Layers,
+  Upload: () => import_lucide_react.Upload,
+  X: () => import_lucide_react.X,
+  ZenitAuthClient: () => ZenitAuthClient,
+  ZenitCatalogNotSupportedError: () => ZenitCatalogNotSupportedError,
+  ZenitClient: () => ZenitClient,
+  ZenitFeatureFilterPanel: () => ZenitFeatureFilterPanel,
+  ZenitLayerManager: () => ZenitLayerManager,
+  ZenitLayersClient: () => ZenitLayersClient,
+  ZenitMap: () => ZenitMap,
+  ZenitMapsClient: () => ZenitMapsClient,
+  ZenitSdkAuthClient: () => ZenitSdkAuthClient,
+  ZoomIn: () => import_lucide_react.ZoomIn,
+  applyFilteredGeoJSONStrategy: () => applyFilteredGeoJSONStrategy,
+  applyLayerOverrides: () => applyLayerOverrides,
+  applyPrefiltersToFeatureCollection: () => applyPrefiltersToFeatureCollection,
+  buildAoiFromFeatureCollection: () => buildAoiFromFeatureCollection,
+  buildFilterMultipleParams: () => buildFilterMultipleParams,
+  buildLayerFilters: () => buildLayerFilters,
+  buildLimitedMessage: () => buildLimitedMessage,
+  centroidFromBBox: () => centroidFromBBox,
+  clampNumber: () => clampNumber,
+  clampOpacity: () => clampOpacity3,
+  computeBBoxFromFeature: () => computeBBoxFromFeature,
+  createChatService: () => createChatService,
+  decorateFeaturesWithLayerId: () => decorateFeaturesWithLayerId,
+  extractMapDto: () => extractMapDto,
+  filterEngine: () => filterEngine,
+  getAccentByLayerId: () => getAccentByLayerId,
+  getCatalogSupport: () => getCatalogSupport,
+  getEffectiveLayerOpacity: () => getEffectiveLayerOpacity,
+  getLayerColor: () => getLayerColor,
+  getLayerZoomOpacityFactor: () => getLayerZoomOpacityFactor,
+  getStyleByLayerId: () => getStyleByLayerId,
+  getZoomOpacityFactor: () => getZoomOpacityFactor,
+  initLayerStates: () => initLayerStates,
+  isPolygonLayer: () => isPolygonLayer,
+  normalizeBbox: () => normalizeBbox,
+  normalizeMapCenter: () => normalizeMapCenter,
+  normalizeMapLayers: () => normalizeMapLayers,
+  resetOverrides: () => resetOverrides,
+  resolveLayerAccent: () => resolveLayerAccent,
+  resolveLayerStrategy: () => resolveLayerStrategy,
+  sendMessage: () => sendMessage,
+  sendMessageStream: () => sendMessageStream,
+  shouldSkipGeojsonDownload: () => shouldSkipGeojsonDownload,
+  shouldUseFilterMultiple: () => shouldUseFilterMultiple,
+  useSendMessage: () => useSendMessage,
+  useSendMessageStream: () => useSendMessageStream
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/http/HttpClient.ts
+var HttpClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.resolveTokens = options.resolveTokens;
+    this.resolveAuthorizationHeader = options.resolveAuthorizationHeader ?? (() => ({}));
+  }
+  async get(path, options = {}) {
+    const headers = {
+      ...options.headers,
+      ...this.resolveAuthorizationHeader()
+    };
+    return this.request(path, { ...options, method: "GET", headers });
+  }
+  async post(path, body, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers,
+      ...this.resolveAuthorizationHeader()
+    };
+    return this.request(path, {
+      ...options,
+      method: "POST",
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers,
+      ...this.resolveAuthorizationHeader()
+    };
+    return this.request(path, {
+      ...options,
+      method: "PUT",
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async patch(path, body, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers,
+      ...this.resolveAuthorizationHeader()
+    };
+    return this.request(path, {
+      ...options,
+      method: "PATCH",
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path, options = {}) {
+    const headers = {
+      ...options.headers,
+      ...this.resolveAuthorizationHeader()
+    };
+    return this.request(path, { ...options, method: "DELETE", headers });
+  }
+  async request(path, options) {
+    const url = `${this.baseUrl}${path}`;
+    const tokenState = this.resolveTokens?.();
+    const headers = {
+      ...options.headers
+    };
+    if (!headers["Authorization"] && tokenState?.accessToken) {
+      headers["Authorization"] = `Bearer ${tokenState.accessToken}`;
+    }
+    if (tokenState?.sdkToken) {
+      headers["X-SDK-Token"] = tokenState.sdkToken;
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    const payload = isJson ? await response.json() : await response.text();
+    if (!response.ok) {
+      const normalizedError = {
+        success: false,
+        statusCode: response.status,
+        message: typeof payload === "string" ? payload : payload?.message || "Unknown error",
+        timestamp: typeof payload === "object" ? payload.timestamp : void 0,
+        path: typeof payload === "object" ? payload.path : void 0,
+        method: typeof payload === "object" ? payload.method : void 0,
+        error: typeof payload === "object" ? payload.error : void 0
+      };
+      throw normalizedError;
+    }
+    return payload;
+  }
+};
+
+// src/auth/ZenitAuthClient.ts
+var ZenitAuthClient = class {
+  constructor(http, updateTokens, config) {
+    this.http = http;
+    this.updateTokens = updateTokens;
+    this.config = config;
+  }
+  async login(credentials) {
+    try {
+      const response = await this.http.post("/auth/login", credentials);
+      const accessToken = response?.accessToken ?? response?.data?.accessToken;
+      const refreshToken = response?.refreshToken ?? response?.data?.refreshToken;
+      this.updateTokens({ accessToken, refreshToken });
+      return response;
+    } catch (error) {
+      this.config.onAuthError?.(error);
+      throw error;
+    }
+  }
+  async refresh(refreshToken) {
+    const tokenToUse = refreshToken || this.config.refreshToken;
+    const headers = tokenToUse ? { Authorization: `Bearer ${tokenToUse}` } : void 0;
+    const response = await this.http.post("/auth/refresh", void 0, { headers });
+    const accessToken = response?.accessToken ?? response?.data?.accessToken;
+    const nextRefreshToken = response?.refreshToken ?? response?.data?.refreshToken;
+    this.updateTokens({ accessToken, refreshToken: nextRefreshToken });
+    return response;
+  }
+  async me() {
+    return this.http.get("/auth/me");
+  }
+  async validate() {
+    return this.http.get("/auth/validate");
+  }
+};
+
+// src/sdkAuth/ZenitSdkAuthClient.ts
+var ZenitSdkAuthClient = class {
+  constructor(http, updateAccessToken, config) {
+    this.http = http;
+    this.updateAccessToken = updateAccessToken;
+    this.config = config;
+  }
+  /**
+   * Validate an SDK token. If no token argument is provided, it falls back to config.sdkToken.
+   */
+  async validateSdkToken(token) {
+    const sdkToken = token || this.config.sdkToken;
+    return this.http.post("/sdk-auth/validate", { token: sdkToken });
+  }
+  /**
+   * Exchange an SDK token for an access token. Token can come from method args or config.sdkToken.
+   */
+  async exchangeSdkToken(token) {
+    const sdkToken = token || this.config.sdkToken;
+    const response = await this.http.post("/sdk-auth/exchange", { token: sdkToken });
+    const accessToken = response?.accessToken ?? response?.data?.accessToken;
+    this.updateAccessToken(accessToken);
+    return response;
+  }
+};
+
+// src/maps/ZenitMapsClient.ts
+var ZenitMapsClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async getMap(mapId, includeLayers = true) {
+    const include = includeLayers ? "?includeLayers=true" : "";
+    return this.httpClient.get(`/maps/${mapId}${include}`);
+  }
+};
+
+// src/layers/catalogSupport.ts
+function isPolygonLike(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.toLowerCase();
+  return normalized === "polygon" || normalized === "multipolygon";
+}
+function getCatalogSupport(args) {
+  const { layerType, geometryType } = args;
+  if (layerType !== void 0) {
+    const supported = isPolygonLike(layerType);
+    return {
+      supported,
+      reason: supported ? "supported" : "unsupported-geometry",
+      layerType,
+      geometryType
+    };
+  }
+  if (geometryType !== void 0) {
+    const supported = isPolygonLike(geometryType);
+    return {
+      supported,
+      reason: supported ? "supported" : "unsupported-geometry",
+      geometryType
+    };
+  }
+  return {
+    supported: false,
+    reason: "unknown-geometry"
+  };
+}
+var ZenitCatalogNotSupportedError = class extends Error {
+  constructor(support, message) {
+    super(message ?? "Catalog is not supported for this layer geometry");
+    this.name = "ZenitCatalogNotSupportedError";
+    this.support = support;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/engine/PrefilterEngine.ts
+var normalizeString = (value) => value.trim().toLowerCase();
+var isPrefilterValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var matchesPrefilterValue = (candidate, expected) => {
+  if (typeof expected === "string") {
+    if (candidate === null || candidate === void 0) return false;
+    return normalizeString(String(candidate)) === normalizeString(expected);
+  }
+  return candidate === expected;
+};
+var shouldApplyPrefilters = (prefilters) => !!prefilters && Object.keys(prefilters).length > 0;
+var featureMatchesPrefilters = (feature, prefilters) => {
+  const properties = feature.properties ?? {};
+  return Object.entries(prefilters).every(([key, expected]) => {
+    if (!isPrefilterValue(expected)) return true;
+    return matchesPrefilterValue(properties[key], expected);
+  });
+};
+var applyPrefiltersToFeatureCollection = (featureCollection, prefilters) => {
+  if (!shouldApplyPrefilters(prefilters)) return featureCollection;
+  const nextFeatures = featureCollection.features.filter(
+    (feature) => featureMatchesPrefilters(feature, prefilters)
+  );
+  return {
+    ...featureCollection,
+    features: nextFeatures
+  };
+};
+var decorateFeaturesWithLayerId = (featureCollection, layerId) => {
+  let shouldClone = false;
+  featureCollection.features.forEach((feature) => {
+    const existing = feature.properties?.__zenit_layerId;
+    if (existing !== layerId) {
+      shouldClone = true;
+    }
+  });
+  if (!shouldClone) {
+    return featureCollection;
+  }
+  return {
+    ...featureCollection,
+    features: featureCollection.features.map((feature) => ({
+      ...feature,
+      properties: {
+        ...feature.properties ?? {},
+        __zenit_layerId: layerId
+      }
+    }))
+  };
+};
+
+// src/layers/ZenitLayersClient.ts
+function parseQueryParams(options = {}) {
+  const params = new URLSearchParams();
+  if (options.maxFeatures !== void 0) {
+    params.set("maxFeatures", String(options.maxFeatures));
+  }
+  if (options.simplify !== void 0) {
+    params.set("simplify", String(options.simplify));
+  }
+  return params;
+}
+function serializeFilterValue(value) {
+  if (Array.isArray(value)) {
+    const serialized2 = value.map(String).filter((item) => item.trim().length > 0).join(",");
+    return serialized2.length > 0 ? serialized2 : void 0;
+  }
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const serialized = String(value);
+  return serialized.trim().length > 0 ? serialized : void 0;
+}
+function buildLayerFilters(filters) {
+  const query = new URLSearchParams();
+  if (!filters) {
+    return query;
+  }
+  Object.entries(filters).forEach(([key, value]) => {
+    const serialized = serializeFilterValue(value);
+    if (serialized !== void 0) {
+      query.set(key, serialized);
+    }
+  });
+  return query;
+}
+function buildFilterMultipleParams(params) {
+  const query = buildLayerFilters(params.filters);
+  if (!Array.isArray(params.layerIds) || params.layerIds.length === 0) {
+    throw new Error("layerIds is required and cannot be empty");
+  }
+  query.set("layerIds", params.layerIds.map((id) => String(id)).join(","));
+  return query;
+}
+function asOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function createEmptyFeatureCollection() {
+  return { type: "FeatureCollection", features: [] };
+}
+function hasFilters(filters) {
+  return buildLayerFilters(filters).size > 0;
+}
+function mergeLayerFilters(base, extra) {
+  if (!base && !extra) return void 0;
+  const merged = { ...base ?? {}, ...extra ?? {} };
+  return hasFilters(merged) ? merged : void 0;
+}
+var DEFAULT_MAX_FEATURES_FULL_GEOJSON = 5e4;
+function normalizeLayerType(layerType) {
+  return typeof layerType === "string" ? layerType.toLowerCase() : void 0;
+}
+function shouldUseFilterMultiple(layerType) {
+  return normalizeLayerType(layerType) === "multipolygon";
+}
+function shouldSkipGeojsonDownload(layerType, totalFeatures, thresholds = {
+  maxFeatures: DEFAULT_MAX_FEATURES_FULL_GEOJSON
+}) {
+  if (thresholds.allowLargeGeojson) {
+    return false;
+  }
+  const normalizedType = normalizeLayerType(layerType);
+  if (normalizedType === "mixed") {
+    return true;
+  }
+  if (typeof totalFeatures === "number" && totalFeatures > thresholds.maxFeatures) {
+    return true;
+  }
+  return false;
+}
+function parseBbox(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const candidate = value;
+  if (typeof candidate.minLon === "number" && typeof candidate.minLat === "number" && typeof candidate.maxLon === "number" && typeof candidate.maxLat === "number") {
+    return {
+      minLon: candidate.minLon,
+      minLat: candidate.minLat,
+      maxLon: candidate.maxLon,
+      maxLat: candidate.maxLat
+    };
+  }
+  if (Array.isArray(value) && value.length === 4) {
+    const [minLon, minLat, maxLon, maxLat] = value;
+    if (typeof minLon === "number" && typeof minLat === "number" && typeof maxLon === "number" && typeof maxLat === "number") {
+      return { minLon, minLat, maxLon, maxLat };
+    }
+  }
+  return void 0;
+}
+function buildBboxFromFeatureCollection(featureCollection) {
+  const coords = [];
+  const collect = (candidate) => {
+    if (!Array.isArray(candidate)) return;
+    if (candidate.length === 2 && typeof candidate[0] === "number" && typeof candidate[1] === "number" && Number.isFinite(candidate[0]) && Number.isFinite(candidate[1])) {
+      coords.push([candidate[0], candidate[1]]);
+      return;
+    }
+    candidate.forEach((item) => collect(item));
+  };
+  featureCollection.features.forEach((feature) => {
+    collect(feature.geometry?.coordinates);
+  });
+  if (coords.length === 0) return void 0;
+  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 buildGeometryCollectionFromFeatureCollection(featureCollection) {
+  return {
+    type: "GeometryCollection",
+    geometries: featureCollection.features.map((feature) => feature.geometry).filter((geometry) => geometry !== void 0 && geometry !== null)
+  };
+}
+function buildAoiFromFeatureCollection(featureCollection, metadata) {
+  const metadataBbox = parseBbox(metadata?.bbox);
+  const derivedBbox = metadataBbox ?? buildBboxFromFeatureCollection(featureCollection);
+  const hasFeatures = featureCollection.features.length > 0;
+  const geometry = hasFeatures ? buildGeometryCollectionFromFeatureCollection(featureCollection) : void 0;
+  if (!derivedBbox && !geometry) {
+    return null;
+  }
+  return { bbox: derivedBbox, geometry };
+}
+function splitFeatureCollectionByLayerId(featureCollection, layerIds) {
+  const grouped = {};
+  layerIds.forEach((layerId) => {
+    grouped[String(layerId)] = createEmptyFeatureCollection();
+  });
+  featureCollection.features.forEach((feature) => {
+    const properties = feature.properties;
+    const layerId = properties?.layerId ?? properties?.layer_id ?? properties?.__zenit_layerId;
+    if (layerId === void 0 || layerId === null) {
+      return;
+    }
+    const key = String(layerId);
+    if (!grouped[key]) {
+      grouped[key] = createEmptyFeatureCollection();
+    }
+    grouped[key] = {
+      ...grouped[key],
+      features: [...grouped[key].features, feature]
+    };
+  });
+  return grouped;
+}
+function resolveLayerStrategy(params) {
+  const {
+    layerDetail,
+    bbox,
+    filterBBox,
+    filteredGeoJSON,
+    isVisible = true,
+    maxFeaturesFullGeojson,
+    allowLargeGeojson
+  } = params;
+  if (!isVisible) {
+    return { strategy: "geojson", effectiveBBox: bbox };
+  }
+  if (filteredGeoJSON && layerDetail.layerType !== "multipolygon") {
+    return {
+      strategy: "intersect",
+      intersectionGeometry: buildGeometryCollectionFromFeatureCollection(filteredGeoJSON)
+    };
+  }
+  const shouldSkipGeojson = shouldSkipGeojsonDownload(layerDetail.layerType, layerDetail.totalFeatures, {
+    maxFeatures: maxFeaturesFullGeojson ?? DEFAULT_MAX_FEATURES_FULL_GEOJSON,
+    allowLargeGeojson
+  });
+  if (shouldSkipGeojson && (filterBBox ?? bbox)) {
+    return { strategy: "bbox", effectiveBBox: filterBBox ?? bbox };
+  }
+  if ((layerDetail.totalFeatures ?? 0) > 5e3 && (filterBBox ?? bbox)) {
+    return { strategy: "bbox", effectiveBBox: filterBBox ?? bbox };
+  }
+  return { strategy: "geojson", effectiveBBox: bbox };
+}
+function buildLimitedMessage(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  const explicit = metadata.limitedMessage;
+  if (typeof explicit === "string" && explicit.trim().length > 0) {
+    return explicit;
+  }
+  const limit = typeof metadata.limit === "number" ? metadata.limit : void 0;
+  const total = typeof metadata.totalFeatures === "number" ? metadata.totalFeatures : void 0;
+  if (limit !== void 0 && total !== void 0 && total > limit) {
+    return `Mostrando ${limit.toLocaleString()} de ${total.toLocaleString()} elementos por l\xEDmite de capa.`;
+  }
+  if (metadata.limited && limit !== void 0) {
+    return `Mostrando un m\xE1ximo de ${limit.toLocaleString()} elementos por l\xEDmite de capa.`;
+  }
+  return void 0;
+}
+var ZenitLayersClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async getLayer(layerId) {
+    const response = await this.httpClient.get(
+      `/layers/${layerId}`
+    );
+    return this.unwrapResponse(response);
+  }
+  async getLayerGeoJson(layerId, options = {}) {
+    const params = parseQueryParams(options);
+    const suffix = params.size > 0 ? `?${params.toString()}` : "";
+    const response = await this.httpClient.get(
+      `/layers/${layerId}/geojson${suffix}`
+    );
+    return this.unwrapResponse(response);
+  }
+  async getLayerFeaturesCatalog(layerId, options) {
+    if (options?.strict) {
+      const support = getCatalogSupport({
+        layerType: options.layerType,
+        geometryType: options.geometryType
+      });
+      if (!support.supported) {
+        throw new ZenitCatalogNotSupportedError(
+          support,
+          support.reason === "unknown-geometry" ? "Catalog support cannot be determined without a geometry type" : "Catalog is only supported for polygon or multipolygon geometries"
+        );
+      }
+    }
+    const response = await this.httpClient.get(
+      `/layers/${layerId}/features/catalog`
+    );
+    return this.unwrapResponse(response);
+  }
+  async getLayerFeatures(layerId, featureIds) {
+    if (!Array.isArray(featureIds) || featureIds.length === 0) {
+      throw new Error("featureIds is required and cannot be empty");
+    }
+    const query = featureIds.map(String).join(",");
+    const response = await this.httpClient.get(
+      `/layers/${layerId}/features?featureIds=${encodeURIComponent(query)}`
+    );
+    return this.unwrapResponse(response);
+  }
+  async filterLayerFeatures(layerId, filters) {
+    const query = buildLayerFilters(filters);
+    const suffix = query.toString();
+    const response = await this.httpClient.get(
+      `/layers/${layerId}/features/filter${suffix ? `?${suffix}` : ""}`
+    );
+    return this.unwrapResponse(response);
+  }
+  async filterMultipleLayersFeatures(params) {
+    const query = buildFilterMultipleParams(params);
+    const suffix = query.toString();
+    const response = await this.httpClient.get(`/layers/features/filter-multiple${suffix ? `?${suffix}` : ""}`);
+    return this.unwrapResponse(response);
+  }
+  async filterMultiple(params) {
+    return this.filterMultipleLayersFeatures(params);
+  }
+  /**
+   * Resilient filter-multiple helper:
+   * - Usa filter-multiple SOLO en capas multipolygon.
+   * - Para otras capas aplica filterLayerFeatures o getLayerGeoJson según haya filtros.
+   * - Nunca falla toda la operación por una capa inválida.
+   *
+   * Para mejor detección de layerType, pasa layerMetas con el layerType de cada capa.
+   */
+  async filterMultipleWithFallback(params) {
+    const layerIds = params.layerIds ?? [];
+    const perLayer = {};
+    const warnings = [];
+    const hasLayerMetas = (params.layerMetas ?? []).length > 0;
+    const maxFeaturesFullGeojson = params.maxFeaturesFullGeojson ?? DEFAULT_MAX_FEATURES_FULL_GEOJSON;
+    const allowLargeGeojson = params.allowLargeGeojson ?? false;
+    layerIds.forEach((layerId) => {
+      perLayer[String(layerId)] = createEmptyFeatureCollection();
+    });
+    if (layerIds.length === 0) {
+      return { perLayer };
+    }
+    const globalFilters = hasFilters(params.filters) ? params.filters : void 0;
+    const metaIndex = /* @__PURE__ */ new Map();
+    (params.layerMetas ?? []).forEach((meta) => {
+      metaIndex.set(String(meta.layerId), meta);
+    });
+    let multipolygonIds = [];
+    let otherIds = [];
+    const layerIdsWithData = /* @__PURE__ */ new Set();
+    let aoi = null;
+    const pushWarning = (message) => {
+      warnings.push(message);
+      console.warn(message);
+    };
+    const buildSkipWarning = (layerId, layerType, totalFeatures, reason) => {
+      const typeLabel = layerType ?? "unknown";
+      const totalLabel = typeof totalFeatures === "number" ? ` totalFeatures=${totalFeatures}` : "";
+      const reasonLabel = reason ? ` ${reason}` : "";
+      return `Layer ${layerId} skipped: layerType=${typeLabel}${totalLabel}${reasonLabel}`;
+    };
+    if (hasLayerMetas) {
+      layerIds.forEach((layerId) => {
+        const meta = metaIndex.get(String(layerId));
+        if (shouldUseFilterMultiple(meta?.layerType)) {
+          multipolygonIds.push(layerId);
+        } else {
+          otherIds.push(layerId);
+        }
+      });
+    } else {
+      multipolygonIds = [...layerIds];
+    }
+    let metadata;
+    if (multipolygonIds.length > 0) {
+      try {
+        const response = await this.filterMultipleLayersFeatures({
+          layerIds: multipolygonIds,
+          filters: globalFilters
+        });
+        metadata = response.metadata;
+        const geojson = response.data ?? createEmptyFeatureCollection();
+        if (globalFilters) {
+          aoi = buildAoiFromFeatureCollection(geojson, metadata);
+        }
+        const perLayerFromMultiple = splitFeatureCollectionByLayerId(geojson, layerIds);
+        Object.entries(perLayerFromMultiple).forEach(([layerKey, collection]) => {
+          if (collection.features.length === 0) {
+            return;
+          }
+          perLayer[layerKey] = decorateFeaturesWithLayerId(collection, layerKey);
+          layerIdsWithData.add(layerKey);
+        });
+      } catch {
+        if (hasLayerMetas) {
+          otherIds = [.../* @__PURE__ */ new Set([...otherIds, ...multipolygonIds])];
+        } else {
+          otherIds = [...layerIds];
+        }
+        multipolygonIds = [];
+      }
+    }
+    if (otherIds.length > 0) {
+      const pendingIds = otherIds.filter(
+        (layerId) => !layerIdsWithData.has(String(layerId))
+      );
+      const resolved = await Promise.all(
+        pendingIds.map(async (layerId) => {
+          const meta = metaIndex.get(String(layerId));
+          const layerType = meta?.layerType;
+          const totalFeatures = meta?.totalFeatures;
+          const layerFilters = mergeLayerFilters(globalFilters, meta?.prefilters);
+          const canUseIntersect = !!globalFilters && !shouldUseFilterMultiple(layerType) && !!aoi?.geometry;
+          if (canUseIntersect) {
+            const intersectionGeometry = aoi?.geometry;
+            if (!intersectionGeometry) {
+              pushWarning(
+                buildSkipWarning(
+                  layerId,
+                  layerType,
+                  totalFeatures,
+                  "no AOI geometry available"
+                )
+              );
+              return { layerId, geojson: createEmptyFeatureCollection() };
+            }
+            try {
+              const response = await this.getLayerGeoJsonIntersect({
+                id: layerId,
+                geometry: intersectionGeometry
+              });
+              if (aoi?.bbox) {
+                console.debug(
+                  `Layer ${layerId} fetched by intersect using AOI bbox=${JSON.stringify(
+                    aoi.bbox
+                  )}`
+                );
+              } else {
+                console.debug(`Layer ${layerId} fetched by intersect using AOI geometry`);
+              }
+              const geojson = response.data ?? createEmptyFeatureCollection();
+              return {
+                layerId,
+                geojson: decorateFeaturesWithLayerId(geojson, layerId)
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : "Unknown error";
+              pushWarning(
+                buildSkipWarning(
+                  layerId,
+                  layerType,
+                  totalFeatures,
+                  `intersect failed: ${message}`
+                )
+              );
+              return { layerId, geojson: createEmptyFeatureCollection() };
+            }
+          }
+          if (layerFilters && (hasLayerMetas ? shouldUseFilterMultiple(layerType) : true)) {
+            try {
+              const response = await this.filterLayerFeatures(layerId, layerFilters);
+              const geojson = response.data ?? createEmptyFeatureCollection();
+              return {
+                layerId,
+                geojson: decorateFeaturesWithLayerId(geojson, layerId)
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : "Unknown error";
+              pushWarning(
+                `Layer ${layerId} filter failed: ${message}`
+              );
+              return { layerId, geojson: createEmptyFeatureCollection() };
+            }
+          }
+          if (shouldSkipGeojsonDownload(layerType, totalFeatures, {
+            maxFeatures: maxFeaturesFullGeojson,
+            allowLargeGeojson
+          })) {
+            pushWarning(
+              buildSkipWarning(
+                layerId,
+                layerType,
+                totalFeatures,
+                "not supported by filter endpoint and too large for /geojson; use intersect with AOI"
+              )
+            );
+            return { layerId, geojson: createEmptyFeatureCollection() };
+          }
+          try {
+            const response = await this.getLayerGeoJson(layerId);
+            const geojson = response.data ?? createEmptyFeatureCollection();
+            return {
+              layerId,
+              geojson: decorateFeaturesWithLayerId(geojson, layerId)
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            pushWarning(
+              buildSkipWarning(layerId, layerType, totalFeatures, `error=${message}`)
+            );
+            return { layerId, geojson: createEmptyFeatureCollection() };
+          }
+        })
+      );
+      resolved.forEach(({ layerId, geojson }) => {
+        perLayer[String(layerId)] = geojson;
+      });
+    }
+    const mergedMetadata = warnings.length > 0 ? {
+      ...metadata ?? {},
+      warnings: [...metadata?.warnings ?? [], ...warnings]
+    } : metadata;
+    return { perLayer, metadata: mergedMetadata, aoi };
+  }
+  async getLayerGeoJsonBBox(request) {
+    const params = new URLSearchParams({
+      minLon: String(request.bbox.minLon),
+      minLat: String(request.bbox.minLat),
+      maxLon: String(request.bbox.maxLon),
+      maxLat: String(request.bbox.maxLat)
+    });
+    parseQueryParams(request).forEach((value, key) => params.set(key, value));
+    const response = await this.httpClient.get(
+      `/layers/${request.id}/geojson/bbox?${params.toString()}`
+    );
+    return this.unwrapResponse(response);
+  }
+  async getLayerGeoJsonIntersect(request) {
+    const params = parseQueryParams(request);
+    const suffix = params.size > 0 ? `?${params.toString()}` : "";
+    const response = await this.httpClient.post(
+      `/layers/${request.id}/geojson/intersects${suffix}`,
+      { geometry: request.geometry }
+    );
+    return this.unwrapResponse(response);
+  }
+  async getLayerTileTemplate(layerId) {
+    const response = await this.httpClient.get(
+      `/layers/${layerId}/tiles/template`
+    );
+    const unwrapped = this.unwrapResponse(response);
+    if (typeof unwrapped.data === "string") {
+      return unwrapped.data;
+    }
+    if (unwrapped.data && typeof unwrapped.data.template === "string") {
+      return unwrapped.data.template;
+    }
+    throw new Error("Invalid tile template response");
+  }
+  async loadLayerData(params) {
+    const { id, layerDetail, bbox, filterBBox, filteredGeoJSON, isVisible = true, ...options } = params;
+    const resolution = resolveLayerStrategy({
+      layerDetail,
+      bbox,
+      filterBBox,
+      filteredGeoJSON,
+      isVisible,
+      maxFeaturesFullGeojson: params.maxFeaturesFullGeojson,
+      allowLargeGeojson: params.allowLargeGeojson
+    });
+    const response = await this.fetchByStrategy(id, resolution, options);
+    const totalFeatures = asOptionalNumber(response.totalFeatures) ?? asOptionalNumber(response.metadata?.totalFeatures) ?? asOptionalNumber(layerDetail.totalFeatures);
+    const limitedMessage = response.limitedMessage ?? buildLimitedMessage(response.metadata);
+    return {
+      geojson: response.data,
+      strategy: resolution.strategy,
+      limitedMessage,
+      totalFeatures,
+      metadata: response.metadata
+    };
+  }
+  async loadFilteredFeatures(params) {
+    const response = await this.filterMultipleLayersFeatures(params);
+    return {
+      geojson: response.data,
+      metadata: response.metadata,
+      totalFeatures: response.metadata?.totalFeatures ?? response.totalFeatures
+    };
+  }
+  async fetchByStrategy(layerId, resolution, options) {
+    switch (resolution.strategy) {
+      case "bbox": {
+        if (!resolution.effectiveBBox) {
+          throw new Error("Bounding box is required for bbox strategy");
+        }
+        return this.getLayerGeoJsonBBox({ id: layerId, bbox: resolution.effectiveBBox, ...options });
+      }
+      case "intersect": {
+        if (!resolution.intersectionGeometry) {
+          throw new Error("Geometry is required for intersect strategy");
+        }
+        return this.getLayerGeoJsonIntersect({
+          id: layerId,
+          geometry: resolution.intersectionGeometry,
+          ...options
+        });
+      }
+      case "geojson":
+      default:
+        return this.getLayerGeoJson(layerId, options);
+    }
+  }
+  unwrapResponse(response) {
+    if (!response || typeof response !== "object" || !("data" in response)) {
+      throw new Error("Invalid API response: missing data field");
+    }
+    if ("success" in response && response.success === false) {
+      throw new Error(response.message ?? "Request was not successful");
+    }
+    return response;
+  }
+};
+
+// src/config/ZenitSdkConfig.ts
+var ZenitClient = class {
+  constructor(config) {
+    this.config = config;
+    this.accessToken = config.accessToken;
+    this.refreshToken = config.refreshToken;
+    this.sdkToken = config.sdkToken;
+    this.httpClient = new HttpClient({
+      baseUrl: config.baseUrl,
+      resolveTokens: () => ({ accessToken: this.accessToken, sdkToken: this.sdkToken }),
+      resolveAuthorizationHeader: this.getAuthorizationHeader.bind(this)
+    });
+    this.auth = new ZenitAuthClient(this.httpClient, this.updateTokens.bind(this), config);
+    this.sdkAuth = new ZenitSdkAuthClient(
+      this.httpClient,
+      this.updateAccessTokenFromSdkExchange.bind(this),
+      config
+    );
+    this.maps = new ZenitMapsClient(this.httpClient);
+    this.layers = new ZenitLayersClient(this.httpClient);
+  }
+  /**
+   * Update tokens in memory and propagate to config callbacks.
+   */
+  updateTokens(tokens) {
+    if (tokens.accessToken) {
+      this.setAccessToken(tokens.accessToken);
+    }
+    if (tokens.refreshToken) {
+      this.setRefreshToken(tokens.refreshToken);
+    }
+    this.config.onTokenRefreshed?.({
+      accessToken: this.accessToken || "",
+      refreshToken: this.refreshToken
+    });
+  }
+  // Se usa cuando /sdk-auth/exchange devuelve un accessToken; pasa a ser el accessToken principal del SDK.
+  updateAccessTokenFromSdkExchange(token) {
+    if (token) {
+      this.setAccessToken(token);
+    }
+  }
+  setAccessToken(token) {
+    this.accessToken = token;
+    this.config.accessToken = token;
+  }
+  setRefreshToken(token) {
+    this.refreshToken = token;
+    this.config.refreshToken = token;
+  }
+  getAuthorizationHeader() {
+    const header = {};
+    if (this.accessToken) {
+      header.Authorization = `Bearer ${this.accessToken}`;
+    }
+    return header;
+  }
+  getHttpClient() {
+    return this.httpClient;
+  }
+};
+
+// 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/FilterEngine.ts
+var FilterEngine = class {
+  decide(params) {
+    if (params.request) {
+      return { nextRequest: params.request };
+    }
+    if (params.filters && params.layerIds && params.layerIds.length > 1) {
+      return {
+        nextRequest: {
+          type: "filter-multiple",
+          layerIds: params.layerIds,
+          filters: params.filters
+        },
+        reason: "filters+layerIds"
+      };
+    }
+    if (params.filters && params.layerId !== void 0) {
+      return {
+        nextRequest: {
+          type: "filter-layer",
+          layerId: params.layerId,
+          filters: params.filters
+        },
+        reason: "filters+layerId"
+      };
+    }
+    if (params.bbox && params.layerId !== void 0) {
+      return {
+        nextRequest: {
+          type: "bbox",
+          layerId: params.layerId,
+          bbox: params.bbox,
+          options: params.options
+        },
+        reason: "bbox+layerId"
+      };
+    }
+    if (params.geometry && params.layerId !== void 0) {
+      return {
+        nextRequest: {
+          type: "intersect",
+          layerId: params.layerId,
+          geometry: params.geometry,
+          options: params.options
+        },
+        reason: "geometry+layerId"
+      };
+    }
+    if (params.layerId !== void 0) {
+      return {
+        nextRequest: {
+          type: "geojson",
+          layerId: params.layerId,
+          options: params.options
+        },
+        reason: "layerId"
+      };
+    }
+    throw new Error("FilterEngine could not resolve a next request");
+  }
+};
+var filterEngine = new FilterEngine();
+
+// 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/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/ai/normalize.ts
+function normalizeBbox(input) {
+  if (!input) return null;
+  if (Array.isArray(input)) {
+    if (input.length !== 4) {
+      console.warn("[normalizeBbox] Array must have exactly 4 elements, got:", input.length);
+      return null;
+    }
+    const [minLon, minLat, maxLon, maxLat] = input;
+    if (typeof minLon !== "number" || typeof minLat !== "number" || typeof maxLon !== "number" || typeof maxLat !== "number" || !Number.isFinite(minLon) || !Number.isFinite(minLat) || !Number.isFinite(maxLon) || !Number.isFinite(maxLat)) {
+      console.warn("[normalizeBbox] Array contains non-finite numbers:", input);
+      return null;
+    }
+    if (minLon >= maxLon || minLat >= maxLat) {
+      console.warn("[normalizeBbox] Invalid bbox: min must be < max", {
+        minLon,
+        maxLon,
+        minLat,
+        maxLat
+      });
+      return null;
+    }
+    return { minLon, minLat, maxLon, maxLat };
+  }
+  if (typeof input === "object") {
+    const candidate = input;
+    const { minLon, minLat, maxLon, maxLat } = candidate;
+    if (typeof minLon !== "number" || typeof minLat !== "number" || typeof maxLon !== "number" || typeof maxLat !== "number" || !Number.isFinite(minLon) || !Number.isFinite(minLat) || !Number.isFinite(maxLon) || !Number.isFinite(maxLat)) {
+      console.warn("[normalizeBbox] Object missing valid bbox keys or contains non-finite numbers:", input);
+      return null;
+    }
+    if (minLon >= maxLon || minLat >= maxLat) {
+      console.warn("[normalizeBbox] Invalid bbox: min must be < max", {
+        minLon,
+        maxLon,
+        minLat,
+        maxLat
+      });
+      return null;
+    }
+    return { minLon, minLat, maxLon, maxLat };
+  }
+  console.warn("[normalizeBbox] Unsupported bbox format:", typeof input);
+  return null;
+}
+
+// src/react/ZenitMap.tsx
+var import_react = require("react");
+var import_react_leaflet = require("react-leaflet");
+var import_leaflet = __toESM(require("leaflet"));
+
+// 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
+var import_jsx_runtime = require("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;");
+}
+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 layerName = properties.layerName ?? properties.layer_name ?? properties.name;
+  const descripcion = properties.descripcion ?? properties.description;
+  const reservedKeys = /* @__PURE__ */ new Set([
+    "_style",
+    "layerId",
+    "layer_id",
+    "__zenit_layerId",
+    "layerName",
+    "layer_name",
+    "name",
+    "descripcion",
+    "description"
+  ]);
+  const extraEntries = Object.entries(properties).filter(([key, value]) => {
+    if (reservedKeys.has(key)) return false;
+    return ["string", "number", "boolean"].includes(typeof value);
+  }).slice(0, 5);
+  if (!layerName && !descripcion && extraEntries.length === 0) return null;
+  const parts = [];
+  if (layerName) {
+    parts.push(`<div style="font-weight:600;margin-bottom:4px;">${escapeHtml(layerName)}</div>`);
+  }
+  if (descripcion) {
+    parts.push(`<div style="margin-bottom:6px;">${escapeHtml(descripcion)}</div>`);
+  }
+  if (extraEntries.length > 0) {
+    const rows = extraEntries.map(([key, value]) => {
+      const label = escapeHtml(key.replace(/_/g, " "));
+      const val = escapeHtml(String(value));
+      return `<div><strong>${label}:</strong> ${val}</div>`;
+    }).join("");
+    parts.push(`<div style="font-size:12px;line-height:1.4;">${rows}</div>`);
+  }
+  return `<div>${parts.join("")}</div>`;
+}
+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 = (0, import_react_leaflet.useMap)();
+  const lastAppliedBBox = (0, import_react.useRef)(null);
+  (0, import_react.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 = (0, import_react_leaflet.useMap)();
+  const lastAutoBBoxApplied = (0, import_react.useRef)(null);
+  const lastUserInteracted = (0, import_react.useRef)(false);
+  (0, import_react.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]);
+  (0, import_react.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 = (0, import_react_leaflet.useMap)();
+  (0, import_react.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 = (0, import_react_leaflet.useMap)();
+  (0, import_react.useEffect)(() => {
+    onReady(mapInstance);
+  }, [mapInstance, onReady]);
+  return null;
+};
+var ZenitMap = (0, import_react.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] = (0, import_react.useState)(null);
+  const [layers, setLayers] = (0, import_react.useState)([]);
+  const [effectiveStates, setEffectiveStates] = (0, import_react.useState)([]);
+  const [loadingMap, setLoadingMap] = (0, import_react.useState)(false);
+  const [mapError, setMapError] = (0, import_react.useState)(null);
+  const [mapInstance, setMapInstance] = (0, import_react.useState)(null);
+  const [currentZoom, setCurrentZoom] = (0, import_react.useState)(initialZoom ?? DEFAULT_ZOOM);
+  const [isMobile, setIsMobile] = (0, import_react.useState)(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia("(max-width: 768px)").matches;
+  });
+  const normalizedLayers = (0, import_react.useMemo)(() => normalizeMapLayers(map), [map]);
+  (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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] = (0, import_react.useState)([]);
+  const [mapOverrides, setMapOverrides] = (0, import_react.useState)([]);
+  const [controlOverrides, setControlOverrides] = (0, import_react.useState)([]);
+  const [uiOverrides, setUiOverrides] = (0, import_react.useState)([]);
+  (0, import_react.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]);
+  (0, import_react.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]);
+  (0, import_react.useEffect)(() => {
+    if (!layerControls) {
+      setControlOverrides([]);
+      return;
+    }
+    const overrides = layerControls.map((entry) => ({
+      layerId: entry.layerId,
+      overrideVisible: entry.visible,
+      overrideOpacity: entry.opacity
+    }));
+    setControlOverrides(overrides);
+  }, [layerControls]);
+  (0, import_react.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]);
+  (0, import_react.useEffect)(() => {
+    if (layerStates) {
+      setEffectiveStates(layerStates);
+    }
+  }, [layerStates]);
+  (0, import_react.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]);
+  (0, import_react.useEffect)(() => {
+    if (!Array.isArray(layerControls) || layerControls.length > 0) return;
+    setUiOverrides([]);
+  }, [layerControls]);
+  (0, import_react.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 = (0, import_react.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 = (0, import_react.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;
+  (0, import_react.useEffect)(() => {
+    setCurrentZoom(zoom);
+  }, [zoom]);
+  const decoratedLayers = (0, import_react.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 = (0, import_react.useMemo)(() => {
+    return [...decoratedLayers].filter((layer) => layer.effective?.visible && layer.data).sort((a, b) => a.displayOrder - b.displayOrder);
+  }, [decoratedLayers]);
+  const explicitZoomBBox = (0, import_react.useMemo)(() => {
+    if (zoomToBbox) return zoomToBbox;
+    if (zoomToGeojson) return computeBBoxFromGeojson(zoomToGeojson);
+    return null;
+  }, [zoomToBbox, zoomToGeojson]);
+  const autoZoomBBox = (0, import_react.useMemo)(() => {
+    if (explicitZoomBBox) return null;
+    const visibleBBoxes = orderedLayers.map((layer) => computeBBoxFromGeojson(layer.data));
+    return mergeBBoxes(visibleBBoxes);
+  }, [explicitZoomBBox, orderedLayers]);
+  const resolveLayerStyle = (0, import_react.useCallback)(
+    (layerId) => {
+      return getStyleByLayerId(layerId, mapLayers) ?? layerStyleIndex.get(String(layerId)) ?? null;
+    },
+    [layerStyleIndex, mapLayers]
+  );
+  const labelMarkers = (0, import_react.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 = (0, import_react.useCallback)(
+    (targetMap, targetLayers) => {
+      const baseZIndex = 400;
+      targetLayers.forEach((layer) => {
+        const paneName = `zenit-layer-${layer.layerId}`;
+        const pane = targetMap.getPane(paneName) ?? targetMap.createPane(paneName);
+        const order = Number.isFinite(layer.displayOrder) ? layer.displayOrder : 0;
+        pane.style.zIndex = String(baseZIndex + order);
+      });
+    },
+    []
+  );
+  const handleMapReady = (0, import_react.useCallback)(
+    (instance) => {
+      setMapInstance(instance);
+      onMapReady?.(instance);
+    },
+    [onMapReady]
+  );
+  (0, import_react.useEffect)(() => {
+    if (!mapInstance) {
+      return;
+    }
+    if (orderedLayers.length === 0) {
+      return;
+    }
+    const layerTargets = orderedLayers.map((layer) => ({
+      layerId: layer.mapLayer.layerId,
+      displayOrder: layer.displayOrder
+    }));
+    ensureLayerPanes(mapInstance, layerTargets);
+  }, [mapInstance, orderedLayers, ensureLayerPanes]);
+  const overlayOnEachFeature = (0, import_react.useMemo)(() => {
+    return (feature, layer) => {
+      const layerId = getFeatureLayerId(feature) ?? void 0;
+      const geometryType = feature?.geometry?.type;
+      const isPointFeature = geometryType === "Point" || geometryType === "MultiPoint" || layer instanceof import_leaflet.default.CircleMarker;
+      const originalStyle = layer instanceof import_leaflet.default.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 import_leaflet.default.CircleMarker ? layer.getRadius() : null;
+      if (featureInfoMode === "popup") {
+        const content = buildFeaturePopupHtml(feature);
+        if (content) {
+          layer.bindPopup(content, { maxWidth: 320 });
+        }
+      }
+      if (isPointFeature && layer.bindTooltip) {
+        layer.bindTooltip("Click para ver detalle", {
+          sticky: true,
+          direction: "top",
+          opacity: 0.9,
+          className: "zenit-map-tooltip"
+        });
+      }
+      layer.on("click", () => onFeatureClick?.(feature, layerId));
+      layer.on("mouseover", () => {
+        if (layer instanceof import_leaflet.default.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 import_leaflet.default.CircleMarker && typeof originalRadius === "number") {
+          layer.setRadius(originalRadius + 1);
+        }
+        onFeatureHover?.(feature, layerId);
+      });
+      layer.on("mouseout", () => {
+        if (layer instanceof import_leaflet.default.Path && originalStyle) {
+          layer.setStyle(originalStyle);
+        }
+        if (layer instanceof import_leaflet.default.CircleMarker && typeof originalRadius === "number") {
+          layer.setRadius(originalRadius);
+        }
+      });
+    };
+  }, [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 = (0, import_react.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 import_leaflet.default.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>
+      `
+    });
+  }, []);
+  (0, import_react.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__ */ (0, import_jsx_runtime.jsx)("div", { style: { padding: 16, height, width }, children: "Cargando mapa..." });
+  }
+  if (mapError) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      style: {
+        display: "flex",
+        height,
+        width,
+        border: "1px solid #e2e8f0",
+        borderRadius: 4,
+        overflow: "hidden",
+        boxSizing: "border-box"
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { flex: 1, position: "relative" }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          import_react_leaflet.MapContainer,
+          {
+            center,
+            zoom,
+            style: { height: "100%", width: "100%" },
+            scrollWheelZoom: true,
+            zoomControl: false,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                import_react_leaflet.TileLayer,
+                {
+                  url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+                  attribution: "\xA9 OpenStreetMap contributors"
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_leaflet.ZoomControl, { position: "topright" }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MapInstanceBridge, { onReady: handleMapReady }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FitToBounds, { bbox: explicitZoomBBox ?? void 0 }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AutoFitToBounds, { bbox: autoZoomBBox ?? void 0, enabled: !explicitZoomBBox }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ZoomBasedOpacityHandler, { onZoomChange: handleZoomChange }),
+              orderedLayers.map((layerState) => {
+                const baseOpacity = layerState.effective?.baseOpacity ?? layerState.effective?.opacity ?? 1;
+                const paneName = `zenit-layer-${layerState.mapLayer.layerId}`;
+                const layerType = layerState.layer?.layerType ?? layerState.mapLayer.layerType ?? void 0;
+                return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  import_react_leaflet.GeoJSON,
+                  {
+                    data: layerState.data,
+                    pane: mapInstance?.getPane(paneName) ? paneName : void 0,
+                    style: (feature) => buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType),
+                    pointToLayer: (feature, latlng) => import_leaflet.default.circleMarker(latlng, {
+                      radius: isMobile ? 8 : 6,
+                      ...buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType)
+                    }),
+                    onEachFeature: overlayOnEachFeature
+                  },
+                  layerState.mapLayer.layerId.toString()
+                );
+              }),
+              overlayGeojson && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                import_react_leaflet.GeoJSON,
+                {
+                  data: overlayGeojson,
+                  style: overlayStyleFunction,
+                  onEachFeature: overlayOnEachFeature
+                },
+                "zenit-overlay-geojson"
+              ),
+              labelMarkers.map((marker) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                import_react_leaflet.Marker,
+                {
+                  position: marker.position,
+                  icon: buildLabelIcon(marker.label, marker.opacity, marker.color),
+                  interactive: false
+                },
+                marker.key
+              ))
+            ]
+          },
+          String(mapId)
+        ) }),
+        showLayerPanel && decoratedLayers.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsxs)(
+                "div",
+                {
+                  style: {
+                    border: "1px solid #bfdbfe",
+                    background: "#eff6ff",
+                    color: "#1e40af",
+                    padding: "8px 10px",
+                    borderRadius: 8,
+                    marginBottom: 12
+                  },
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { fontWeight: 600, marginBottom: 4 }, children: "Overlay activo" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { fontSize: 13 }, children: [
+                      "GeoJSON externo con ",
+                      (overlayGeojson.features?.length ?? 0).toLocaleString(),
+                      " elementos."
+                    ] })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { fontWeight: 600, marginBottom: 12 }, children: "Capas" }),
+              decoratedLayers.map((layerState) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+                "div",
+                {
+                  style: { borderBottom: "1px solid #e5e7eb", paddingBottom: 10, marginBottom: 10 },
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { style: { display: "flex", gap: 8, alignItems: "center" }, children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                        "input",
+                        {
+                          type: "checkbox",
+                          checked: layerState.effective?.visible ?? false,
+                          onChange: (e) => {
+                            const visible = e.target.checked;
+                            upsertUiOverride(layerState.mapLayer.layerId, { overrideVisible: visible });
+                          }
+                        }
+                      ),
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: layerState.layer?.name ?? `Capa ${layerState.mapLayer.layerId}` })
+                    ] }),
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { marginTop: 8 }, children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", justifyContent: "space-between", marginBottom: 4 }, children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { color: "#4a5568" }, children: "Opacidad" }),
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+                          Math.round((layerState.effective?.opacity ?? 1) * 100),
+                          "%"
+                        ] })
+                      ] }),
+                      /* @__PURE__ */ (0, import_jsx_runtime.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
+var import_react2 = __toESM(require("react"));
+
+// src/react/icons.tsx
+var import_lucide_react = require("lucide-react");
+
+// src/react/ZenitLayerManager.tsx
+var import_jsx_runtime2 = require("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] = (0, import_react2.useState)(null);
+  const [loadingMap, setLoadingMap] = (0, import_react2.useState)(false);
+  const [mapError, setMapError] = (0, import_react2.useState)(null);
+  const [layers, setLayers] = (0, import_react2.useState)([]);
+  const [activeTab, setActiveTab] = (0, import_react2.useState)("layers");
+  const [panelVisible, setPanelVisible] = (0, import_react2.useState)(true);
+  const lastEmittedStatesRef = (0, import_react2.useRef)(null);
+  const isControlled = Array.isArray(layerStates) && typeof onLayerStatesChange === "function";
+  const baseStates = (0, import_react2.useMemo)(
+    () => initLayerStates(
+      layers.map((entry) => ({
+        ...entry.mapLayer,
+        layerId: entry.mapLayer.layerId,
+        isVisible: entry.visible,
+        opacity: entry.opacity
+      }))
+    ),
+    [layers]
+  );
+  const overrideStates = (0, import_react2.useMemo)(
+    () => layers.map(
+      (entry) => ({
+        layerId: entry.mapLayer.layerId,
+        overrideVisible: entry.visible,
+        overrideOpacity: entry.opacity
+      })
+    ),
+    [layers]
+  );
+  const effectiveStates = (0, import_react2.useMemo)(
+    () => layerStates ?? applyLayerOverrides(baseStates, overrideStates),
+    [baseStates, layerStates, overrideStates]
+  );
+  const layerMetaIndex = (0, import_react2.useMemo)(() => {
+    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 = import_react2.default.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 = import_react2.default.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 = (0, import_react2.useMemo)(() => {
+    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]);
+  (0, import_react2.useEffect)(() => {
+    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]);
+  (0, import_react2.useEffect)(() => {
+    if (!showUploadTab && activeTab === "upload") {
+      setActiveTab("layers");
+    }
+  }, [activeTab, showUploadTab]);
+  (0, import_react2.useEffect)(() => {
+    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 = import_react2.default.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 = import_react2.default.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 = import_react2.default.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 = (0, import_react2.useMemo)(() => {
+    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 = import_react2.default.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__ */ (0, import_jsx_runtime2.jsx)("div", { className, style: panelStyle, children: "Cargando capas\u2026" });
+  }
+  if (mapError) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("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__ */ (0, import_jsx_runtime2.jsx)("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__ */ (0, import_jsx_runtime2.jsxs)(
+        "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__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", justifyContent: "space-between", gap: 12 }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", gap: 10, alignItems: "flex-start", minWidth: 0, flex: 1 }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  "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__ */ (0, import_jsx_runtime2.jsx)(
+                  "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__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Eye, { size: 16 }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.EyeOff, { size: 16 })
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { minWidth: 0, flex: 1 }, children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "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__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { color: muted ? "#94a3b8" : "#64748b", fontSize: 12 }, children: [
+                    "ID ",
+                    layerId
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex", alignItems: "flex-start", gap: 6, flexShrink: 0 }, children: typeof featureCount === "number" && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "zlm-badge", children: [
+                featureCount.toLocaleString(),
+                " features"
+              ] }) })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex", gap: 10, alignItems: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { flex: 1 }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", justifyContent: "space-between", marginBottom: 6, color: "#64748b", fontSize: 12 }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: "Opacidad" }),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { children: [
+                  opacityPercent,
+                  "%"
+                ] })
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                "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__ */ (0, import_jsx_runtime2.jsxs)("div", { className: ["zenit-layer-manager", className].filter(Boolean).join(" "), style: panelStyle, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("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__ */ (0, import_jsx_runtime2.jsxs)("div", { style: headerStyle, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontWeight: 800, fontSize: 16, color: "#0f172a" }, children: "Gesti\xF3n de Capas" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { color: "#64748b", fontSize: 12 }, children: [
+            "Mapa #",
+            map.id
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+          "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__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Eye, { size: 16 }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.EyeOff, { size: 16 }),
+              panelVisible ? "Ocultar" : "Mostrar"
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+        "div",
+        {
+          style: {
+            display: "flex",
+            gap: 6,
+            marginTop: 12,
+            padding: 4,
+            border: "1px solid #e2e8f0",
+            borderRadius: 12,
+            background: "#f1f5f9"
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+              "button",
+              {
+                type: "button",
+                className: `zlm-tab${activeTab === "layers" ? " is-active" : ""}`,
+                onClick: () => setActiveTab("layers"),
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Layers, { size: 16 }),
+                  "Capas"
+                ]
+              }
+            ),
+            showUploadTab && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+              "button",
+              {
+                type: "button",
+                className: `zlm-tab${activeTab === "upload" ? " is-active" : ""}`,
+                onClick: () => setActiveTab("upload"),
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Upload, { size: 16 }),
+                  "Subir"
+                ]
+              }
+            )
+          ]
+        }
+      )
+    ] }),
+    panelVisible && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { padding: "12px 10px 18px", overflowY: "auto", flex: 1, minHeight: 0 }, children: [
+      activeTab === "layers" && renderLayerCards(),
+      showUploadTab && activeTab === "upload" && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { color: "#475569", fontSize: 13 }, children: "Pr\xF3ximamente podr\xE1s subir capas desde este panel." })
+    ] })
+  ] });
+};
+
+// src/react/ZenitFeatureFilterPanel.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var ZenitFeatureFilterPanel = ({
+  title = "Filtros",
+  description,
+  className,
+  style,
+  children
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "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__ */ (0, import_jsx_runtime3.jsxs)("header", { style: { marginBottom: 12 }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h3", { style: { margin: 0, fontSize: 16 }, children: title }),
+          description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: { margin: "6px 0 0", color: "#475569", fontSize: 13 }, children: description })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { children })
+      ]
+    }
+  );
+};
+
+// src/react/ai/FloatingChatBox.tsx
+var import_react4 = require("react");
+var import_react_dom = require("react-dom");
+
+// src/react/hooks/use-chat.ts
+var import_react3 = require("react");
+var useSendMessage = (config) => {
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const send = (0, import_react3.useCallback)(
+    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] = (0, import_react3.useState)(false);
+  const [streamingText, setStreamingText] = (0, import_react3.useState)("");
+  const [completeResponse, setCompleteResponse] = (0, import_react3.useState)(null);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const requestIdRef = (0, import_react3.useRef)(0);
+  const reset = (0, import_react3.useCallback)(() => {
+    setIsStreaming(false);
+    setStreamingText("");
+    setCompleteResponse(null);
+    setError(null);
+  }, []);
+  const send = (0, import_react3.useCallback)(
+    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
+var import_react_markdown = __toESM(require("react-markdown"));
+var import_remark_gfm = __toESM(require("remark-gfm"));
+var import_jsx_runtime4 = require("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__ */ (0, import_jsx_runtime4.jsx)("div", { className, style: { wordBreak: "break-word" }, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    import_react_markdown.default,
+    {
+      remarkPlugins: [import_remark_gfm.default],
+      components: {
+        // Headings with proper spacing
+        h1: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h1", { style: { fontSize: "1.5em", fontWeight: 700, marginTop: "1em", marginBottom: "0.5em" }, ...props, children }),
+        h2: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h2", { style: { fontSize: "1.3em", fontWeight: 700, marginTop: "0.9em", marginBottom: "0.45em" }, ...props, children }),
+        h3: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h3", { style: { fontSize: "1.15em", fontWeight: 600, marginTop: "0.75em", marginBottom: "0.4em" }, ...props, children }),
+        h4: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h4", { style: { fontSize: "1.05em", fontWeight: 600, marginTop: "0.6em", marginBottom: "0.35em" }, ...props, children }),
+        h5: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h5", { style: { fontSize: "1em", fontWeight: 600, marginTop: "0.5em", marginBottom: "0.3em" }, ...props, children }),
+        h6: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h6", { style: { fontSize: "0.95em", fontWeight: 600, marginTop: "0.5em", marginBottom: "0.3em" }, ...props, children }),
+        // Paragraphs with comfortable line height
+        p: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { style: { marginTop: "0.5em", marginBottom: "0.5em", lineHeight: 1.6 }, ...props, children }),
+        // Lists with proper indentation
+        ul: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("ul", { style: { paddingLeft: "1.5em", marginTop: "0.5em", marginBottom: "0.5em" }, ...props, children }),
+        ol: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("ol", { style: { paddingLeft: "1.5em", marginTop: "0.5em", marginBottom: "0.5em" }, ...props, children }),
+        li: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("li", { style: { marginTop: "0.25em", marginBottom: "0.25em" }, ...props, children }),
+        // Code blocks
+        code: ({ inline, children, ...props }) => {
+          if (inline) {
+            return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              "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__ */ (0, import_jsx_runtime4.jsx)(
+            "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__ */ (0, import_jsx_runtime4.jsx)("pre", { style: { margin: 0 }, ...props, children }),
+        // Blockquotes
+        blockquote: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "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__ */ (0, import_jsx_runtime4.jsx)("strong", { style: { fontWeight: 600 }, ...props, children }),
+        // Emphasis/italic
+        em: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("em", { style: { fontStyle: "italic" }, ...props, children }),
+        // Horizontal rule
+        hr: (props) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "hr",
+          {
+            style: {
+              border: "none",
+              borderTop: "1px solid rgba(0, 0, 0, 0.1)",
+              marginTop: "1em",
+              marginBottom: "1em"
+            },
+            ...props
+          }
+        ),
+        // Tables (GFM)
+        table: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { overflowX: "auto", marginTop: "0.5em", marginBottom: "0.5em" }, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "table",
+          {
+            style: {
+              borderCollapse: "collapse",
+              width: "100%",
+              fontSize: "0.9em"
+            },
+            ...props,
+            children
+          }
+        ) }),
+        th: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "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__ */ (0, import_jsx_runtime4.jsx)(
+          "td",
+          {
+            style: {
+              border: "1px solid rgba(0, 0, 0, 0.2)",
+              padding: "0.5em"
+            },
+            ...props,
+            children
+          }
+        )
+      },
+      children: normalizedContent
+    }
+  ) });
+};
+
+// src/react/ai/FloatingChatBox.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var ChatIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("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__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+] });
+var ExpandIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polyline", { points: "15 3 21 3 21 9" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polyline", { points: "9 21 3 21 3 15" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "21", y1: "3", x2: "14", y2: "10" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "3", y1: "21", x2: "10", y2: "14" })
+] });
+var CollapseIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polyline", { points: "4 14 10 14 10 20" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polyline", { points: "20 10 14 10 14 4" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "14", y1: "10", x2: "21", y2: "3" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "3", y1: "21", x2: "10", y2: "14" })
+] });
+var SendIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", { x1: "22", y1: "2", x2: "11", y2: "13" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polygon", { points: "22 2 15 22 11 13 2 9 22 2" })
+] });
+var LayersIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polygon", { points: "12 2 2 7 12 12 22 7 12 2" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("polyline", { points: "2 17 12 22 22 17" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("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
+  },
+  // 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
+}) => {
+  const [open, setOpen] = (0, import_react4.useState)(false);
+  const [expanded, setExpanded] = (0, import_react4.useState)(false);
+  const [messages, setMessages] = (0, import_react4.useState)([]);
+  const [inputValue, setInputValue] = (0, import_react4.useState)("");
+  const [conversationId, setConversationId] = (0, import_react4.useState)();
+  const [errorMessage, setErrorMessage] = (0, import_react4.useState)(null);
+  const [isFocused, setIsFocused] = (0, import_react4.useState)(false);
+  const [isMobile, setIsMobile] = (0, import_react4.useState)(false);
+  const messagesEndRef = (0, import_react4.useRef)(null);
+  const messagesContainerRef = (0, import_react4.useRef)(null);
+  const chatBoxRef = (0, import_react4.useRef)(null);
+  const chatConfig = (0, import_react4.useMemo)(() => {
+    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;
+  const scrollToBottom = (0, import_react4.useCallback)(() => {
+    if (messagesEndRef.current) {
+      messagesEndRef.current.scrollIntoView({ behavior: "smooth" });
+    }
+  }, []);
+  (0, import_react4.useEffect)(() => {
+    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]);
+  (0, import_react4.useEffect)(() => {
+    scrollToBottom();
+  }, [messages, streamingText, scrollToBottom]);
+  (0, import_react4.useEffect)(() => {
+    if (!open) return;
+    const handleClickOutside = (event) => {
+      if (open && chatBoxRef.current && !chatBoxRef.current.contains(event.target)) {
+        setOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [open]);
+  (0, import_react4.useEffect)(() => {
+    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);
+      }
+    };
+  }, []);
+  (0, import_react4.useEffect)(() => {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const mediaQuery = window.matchMedia("(max-width: 768px)");
+    const originalOverflow = document.body.style.overflow;
+    const updateOverflow = () => {
+      if (open && expanded && mediaQuery.matches) {
+        document.body.style.overflow = "hidden";
+      } else {
+        document.body.style.overflow = originalOverflow;
+      }
+    };
+    updateOverflow();
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", updateOverflow);
+    } else {
+      mediaQuery.addListener(updateOverflow);
+    }
+    return () => {
+      if (mediaQuery.removeEventListener) {
+        mediaQuery.removeEventListener("change", updateOverflow);
+      } else {
+        mediaQuery.removeListener(updateOverflow);
+      }
+      document.body.style.overflow = originalOverflow;
+    };
+  }, [open, expanded]);
+  const addMessage = (0, import_react4.useCallback)((message) => {
+    setMessages((prev) => [...prev, message]);
+  }, []);
+  const handleSend = (0, import_react4.useCallback)(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 = (0, import_react4.useCallback)(
+    (event) => {
+      if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        if (canSend) {
+          void handleSend();
+        }
+      }
+    },
+    [canSend, handleSend]
+  );
+  const handleFollowUpClick = (0, import_react4.useCallback)((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__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.metadataSection, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.metadataTitle, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayersIcon, {}),
+        "Capas Analizadas"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("ul", { style: styles.metadataList, children: referencedLayers.map((layer, index) => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("li", { style: styles.metadataItem, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("strong", { children: layer.layerName }),
+        " (",
+        layer.featureCount,
+        " ",
+        layer.featureCount === 1 ? "elemento" : "elementos",
+        ")"
+      ] }, index)) })
+    ] });
+  };
+  const renderActions = (response) => {
+    if (!response?.suggestedActions?.length) return null;
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.actionsSection, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: styles.sectionLabel, children: "Acciones Sugeridas" }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: styles.actionsGrid, children: response.suggestedActions.map((action, index) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        "button",
+        {
+          type: "button",
+          style: {
+            ...styles.actionButton,
+            opacity: isStreaming ? 0.5 : 1,
+            cursor: isStreaming ? "not-allowed" : "pointer"
+          },
+          onClick: () => !isStreaming && onActionClick?.(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__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.actionsSection, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: styles.sectionLabel, children: "Preguntas Relacionadas" }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: response.followUpQuestions.map((question, index) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        "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__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.root, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("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: 3000 !important;
+            padding-top: env(safe-area-inset-top);
+            padding-bottom: env(safe-area-inset-bottom);
+          }
+          .zenit-chat-panel.zenit-chat-panel--fullscreen .zenit-ai-body {
+            flex: 1;
+            overflow: auto;
+          }
+          .zenit-ai-button.zenit-ai-button--hidden-mobile {
+            display: none !important;
+          }
+        }
+      ` }),
+    open && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+      "div",
+      {
+        ref: chatBoxRef,
+        className: `zenit-chat-panel${expanded ? " zenit-chat-panel--expanded" : ""}${expanded && isMobile ? " zenit-chat-panel--fullscreen" : ""}`,
+        style: {
+          ...styles.panel,
+          ...expanded ? styles.panelExpanded : styles.panelNormal
+        },
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("header", { style: styles.header, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("h3", { style: styles.title, children: "Asistente Zenit AI" }),
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.headerButtons, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+                "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__ */ (0, import_jsx_runtime5.jsx)(CollapseIcon, {}) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ExpandIcon, {})
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+                "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__ */ (0, import_jsx_runtime5.jsx)(CloseIcon, {})
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { ref: messagesContainerRef, className: "zenit-ai-body", style: styles.messages, children: [
+            messages.map((message) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+              "div",
+              {
+                style: {
+                  ...styles.messageWrapper,
+                  alignItems: message.role === "user" ? "flex-end" : "flex-start"
+                },
+                children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+                  "div",
+                  {
+                    style: {
+                      ...styles.messageBubble,
+                      ...message.role === "user" ? styles.userMessage : styles.assistantMessage
+                    },
+                    children: [
+                      message.role === "assistant" ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(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__ */ (0, import_jsx_runtime5.jsx)(
+              "div",
+              {
+                style: {
+                  ...styles.messageWrapper,
+                  alignItems: "flex-start"
+                },
+                children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+                  "div",
+                  {
+                    style: {
+                      ...styles.messageBubble,
+                      ...styles.assistantMessage
+                    },
+                    children: streamingText ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(MarkdownRenderer, { content: streamingText }),
+                      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { style: styles.cursor })
+                    ] }) : /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.thinkingText, children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { children: "Analizando" }),
+                      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.typingIndicator, children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "zenit-typing-dot", style: styles.typingDot }),
+                        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "zenit-typing-dot", style: styles.typingDot }),
+                        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "zenit-typing-dot", style: styles.typingDot })
+                      ] })
+                    ] })
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { ref: messagesEndRef })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: styles.inputWrapper, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+              "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__ */ (0, import_jsx_runtime5.jsx)(
+              "button",
+              {
+                type: "button",
+                className: "zenit-send-button",
+                style: styles.sendButton,
+                onClick: () => void handleSend(),
+                disabled: !canSend,
+                "aria-label": "Enviar mensaje",
+                children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SendIcon, {})
+              }
+            )
+          ] }),
+          errorMessage && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: styles.errorText, children: errorMessage }),
+          !mapId && !errorMessage && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: styles.statusNote, children: "Selecciona un mapa para usar el asistente" }),
+          !baseUrl && !errorMessage && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: styles.statusNote, children: "Configura la baseUrl del SDK" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "button",
+      {
+        type: "button",
+        className: `zenit-ai-button ${open ? "open" : ""}${open && expanded && isMobile ? " zenit-ai-button--hidden-mobile" : ""}`,
+        style: {
+          ...styles.floatingButton,
+          ...open ? styles.floatingButtonOpen : styles.floatingButtonClosed
+        },
+        onClick: () => setOpen((prev) => !prev),
+        "aria-label": open ? "Cerrar asistente" : "Abrir asistente Zenit AI",
+        children: open ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(CloseIcon, {}) : /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ChatIcon, {}),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { children: "Asistente IA" })
+        ] })
+      }
+    )
+  ] });
+  if (typeof document !== "undefined") {
+    return (0, import_react_dom.createPortal)(chatContent, document.body);
+  }
+  return chatContent;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChevronLeft,
+  ChevronRight,
+  DEFAULT_MAX_FEATURES_FULL_GEOJSON,
+  Eye,
+  EyeOff,
+  FilterEngine,
+  FloatingChatBox,
+  HttpClient,
+  Layers,
+  Upload,
+  X,
+  ZenitAuthClient,
+  ZenitCatalogNotSupportedError,
+  ZenitClient,
+  ZenitFeatureFilterPanel,
+  ZenitLayerManager,
+  ZenitLayersClient,
+  ZenitMap,
+  ZenitMapsClient,
+  ZenitSdkAuthClient,
+  ZoomIn,
+  applyFilteredGeoJSONStrategy,
+  applyLayerOverrides,
+  applyPrefiltersToFeatureCollection,
+  buildAoiFromFeatureCollection,
+  buildFilterMultipleParams,
+  buildLayerFilters,
+  buildLimitedMessage,
+  centroidFromBBox,
+  clampNumber,
+  clampOpacity,
+  computeBBoxFromFeature,
+  createChatService,
+  decorateFeaturesWithLayerId,
+  extractMapDto,
+  filterEngine,
+  getAccentByLayerId,
+  getCatalogSupport,
+  getEffectiveLayerOpacity,
+  getLayerColor,
+  getLayerZoomOpacityFactor,
+  getStyleByLayerId,
+  getZoomOpacityFactor,
+  initLayerStates,
+  isPolygonLayer,
+  normalizeBbox,
+  normalizeMapCenter,
+  normalizeMapLayers,
+  resetOverrides,
+  resolveLayerAccent,
+  resolveLayerStrategy,
+  sendMessage,
+  sendMessageStream,
+  shouldSkipGeojsonDownload,
+  shouldUseFilterMultiple,
+  useSendMessage,
+  useSendMessageStream
+});
+//# sourceMappingURL=index.js.map