@kepler.gl/mcp 0.0.0-stage → 3.3.0-alpha.19

package/dist/esm/commands/layer-creation-command.js

@@ -0,0 +1,527 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { z } from 'zod';
+import { GEOJSON_FIELDS } from '@kepler.gl/constants';
+import { LayerClasses } from '@kepler.gl/layers';
+import { findDefaultLayer, findMapBounds } from '@kepler.gl/reducers';
+import { addLayer as addLayerAction, fitBounds } from '@kepler.gl/actions';
+/**
+ * Unique layer id. Date.now()-based ids can collide when multiple layers are
+ * created within the same millisecond (rapid successive tool calls), producing
+ * duplicate layer ids and unpredictable reducer behavior. Append a random
+ * suffix — the same Math.random().toString(36) trick kepler's generateHashId
+ * uses — so ids stay unique.
+ */
+function uniqueLayerId() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'layer';
+  return "".concat(prefix, "_").concat(Date.now(), "_").concat(Math.random().toString(36).slice(2, 8));
+}
+export function guessDefaultLayer(dataset, layerType, options) {
+  if (layerType === 'heatmap') {
+    if (dataset.fieldPairs && dataset.fieldPairs.length > 0) {
+      var props = dataset.fieldPairs.map(function (fieldPair) {
+        return {
+          isVisible: true,
+          label: 'Heatmap',
+          columns: fieldPair.pair
+        };
+      });
+      var _layer = new LayerClasses.heatmap(props[0]);
+      return _layer;
+    }
+  } else if (layerType === 'hexagon') {
+    if (dataset.fieldPairs && dataset.fieldPairs.length > 0) {
+      var _props = dataset.fieldPairs.map(function (fieldPair) {
+        return {
+          isVisible: true,
+          label: 'Hexbin',
+          columns: fieldPair.pair
+        };
+      });
+      var _layer2 = new LayerClasses.hexagon(_props[0]);
+      return _layer2;
+    }
+  } else if (layerType === 'cluster') {
+    if (dataset.fieldPairs && dataset.fieldPairs.length > 0) {
+      var _props2 = dataset.fieldPairs.map(function (fieldPair) {
+        return {
+          isVisible: true,
+          label: 'Cluster',
+          columns: fieldPair.pair
+        };
+      });
+      var _layer3 = new LayerClasses.cluster(_props2[0]);
+      return _layer3;
+    }
+  } else if (layerType === 'trip') {
+    var layers = findDefaultLayer(dataset, [LayerClasses.trip]);
+    var _layer4 = layers.find(function (l) {
+      return l.type === layerType;
+    });
+    if (_layer4) return _layer4;
+    throw new Error("Failed to create a trip layer. Trip layer requires id, lat, lng, and timestamp columns.");
+  } else if (layerType === 'flow') {
+    // Flow layers are never auto-detected (findDefaultLayerProps returns
+    // {props: []}), so build one explicitly from the first two point lat/lng
+    // field pairs — the same source/target pair logic the default arc layer
+    // uses: pair[0] = origin (lat0/lng0), pair[1] = destination (lat1/lng1).
+    // The count column (flow magnitude) is optional; without it every flow
+    // renders at weight 1.
+    var pairs = dataset.fieldPairs || [];
+    if (pairs.length < 2) {
+      throw new Error("Failed to create a flow layer. Flow layer requires two point lat/lng pairs " + "(origin + destination), e.g. origin_lat/origin_lng and dest_lat/dest_lng.");
+    }
+    var columns = {
+      lat0: pairs[0].pair.lat,
+      lng0: pairs[0].pair.lng,
+      lat1: pairs[1].pair.lat,
+      lng1: pairs[1].pair.lng
+    };
+    if (options !== null && options !== void 0 && options.countColumn && dataset.getColumnFieldIdx(options.countColumn) >= 0) {
+      columns.count = {
+        value: options.countColumn,
+        fieldIdx: dataset.getColumnFieldIdx(options.countColumn)
+      };
+    }
+    // LayerClasses' computed keys (keyMirror) aren't statically named, so
+    // access flow like the trip branch accesses trip: through an `as any` cast.
+    var _layer5 = new LayerClasses.flow({
+      isVisible: true,
+      label: "".concat(pairs[0].defaultName, " -> ").concat(pairs[1].defaultName, " flow"),
+      columns: columns
+    });
+    return _layer5;
+  }
+  var defaultLayers = findDefaultLayer(dataset, LayerClasses);
+  var layer = defaultLayers.find(function (l) {
+    return l.type === layerType;
+  });
+  // Return null (not a fallback to the first default layer) when the requested
+  // type can't be created — silently substituting a different layer type (e.g.
+  // requesting "h3" and getting a point layer) violates the command contract
+  // and makes failures hard to diagnose. The caller errors clearly on null.
+  return layer || null;
+}
+
+/** Column names the flow field layer resolves when the caller doesn't name them. */
+var FLOW_FIELD_ALTITUDE_COLUMNS = ['altitude', 'alt', 'elevation', 'elev', 'elv', 'height', 'z'];
+var FLOW_FIELD_MODES = ['UV', 'SPEED_DIR', 'ELEVATION'];
+/**
+ * Flow Field is a vector/streamline layer: each row is a sample point carrying
+ * a position plus a direction — u/v components, speed/direction, or an altitude
+ * whose downhill gradient supplies the direction. Unlike the origin→destination
+ * `flow` layer it needs no second point pair, and unlike `trip` it animates
+ * itself, so no time filter belongs on it.
+ */
+function buildFlowFieldLayer(dataset, position) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var hasColumn = function hasColumn(name) {
+    return !!name && dataset.getColumnFieldIdx(name) >= 0;
+  };
+  var columnRef = function columnRef(name) {
+    var fieldIdx = dataset.getColumnFieldIdx(name);
+    if (fieldIdx < 0) {
+      var _dataset$fields$map$j, _dataset$fields;
+      var available = (_dataset$fields$map$j = (_dataset$fields = dataset.fields) === null || _dataset$fields === void 0 ? void 0 : _dataset$fields.map(function (f) {
+        return f.name;
+      }).join(', ')) !== null && _dataset$fields$map$j !== void 0 ? _dataset$fields$map$j : '';
+      throw new Error("Column \"".concat(name, "\" not found in dataset \"").concat(dataset.label, "\". Available columns: ").concat(available));
+    }
+    return {
+      value: name,
+      fieldIdx: fieldIdx
+    };
+  };
+
+  // Position: explicit lat/lng, else the dataset's first detected point pair,
+  // else a GeoJSON geometry column (one position per feature).
+  var positionColumns = null;
+  if (position.latitudeColumn && position.longitudeColumn) {
+    positionColumns = {
+      lat: columnRef(position.latitudeColumn),
+      lng: columnRef(position.longitudeColumn)
+    };
+  } else {
+    var _dataset$fieldPairs;
+    var pair = (_dataset$fieldPairs = dataset.fieldPairs) === null || _dataset$fieldPairs === void 0 || (_dataset$fieldPairs = _dataset$fieldPairs[0]) === null || _dataset$fieldPairs === void 0 ? void 0 : _dataset$fieldPairs.pair;
+    if (pair !== null && pair !== void 0 && pair.lat && pair !== null && pair !== void 0 && pair.lng) {
+      positionColumns = {
+        lat: pair.lat,
+        lng: pair.lng
+      };
+    } else {
+      var _dataset$fields2;
+      var geoField = (_dataset$fields2 = dataset.fields) === null || _dataset$fields2 === void 0 ? void 0 : _dataset$fields2.find(function (f) {
+        return f.type === 'geojson' || GEOJSON_FIELDS.geojson.includes(f.name);
+      });
+      if (geoField) {
+        positionColumns = {
+          geojson: {
+            value: geoField.name,
+            fieldIdx: geoField.fieldIdx
+          }
+        };
+      }
+    }
+  }
+  if (!positionColumns) {
+    throw new Error('A flow field layer needs a position: lat/lng columns (auto-detected, or pass ' + 'latitudeColumn/longitudeColumn) or a GeoJSON geometry column.');
+  }
+  var altitudeName = options.altitudeColumn || FLOW_FIELD_ALTITUDE_COLUMNS.find(function (name) {
+    return hasColumn(name);
+  }) || null;
+  var mode = options.mode || (options.uColumn || options.vColumn || hasColumn('u') && hasColumn('v') ? 'UV' : options.speedColumn || options.directionColumn || hasColumn('speed') && hasColumn('direction') ? 'SPEED_DIR' : altitudeName ? 'ELEVATION' : null);
+  if (!mode) {
+    throw new Error('A flow field layer needs a vector: u/v columns, speed/direction columns, or an ' + 'altitude column (pass flowField.uColumn/vColumn/speedColumn/directionColumn/' + 'altitudeColumn when the names differ).');
+  }
+  var flowColumns;
+  if (mode === 'UV') {
+    flowColumns = {
+      u: columnRef(options.uColumn || 'u'),
+      v: columnRef(options.vColumn || 'v')
+    };
+  } else if (mode === 'SPEED_DIR') {
+    flowColumns = {
+      speed: columnRef(options.speedColumn || 'speed'),
+      direction: columnRef(options.directionColumn || 'direction')
+    };
+  } else {
+    if (!altitudeName) {
+      throw new Error('A flow field layer in ELEVATION mode needs an altitude column (pass flowField.altitudeColumn).');
+    }
+    flowColumns = {
+      altitude: columnRef(altitudeName)
+    };
+  }
+
+  // UV and SPEED_DIR may also carry an altitude, which lifts the streamlines.
+  var altitudeColumn = mode === 'ELEVATION' || !altitudeName ? {} : {
+    altitude: columnRef(altitudeName)
+  };
+  var layer = new LayerClasses.flowField({
+    isVisible: true,
+    label: 'Flow Field',
+    color: [255, 255, 255],
+    columnMode: mode,
+    columns: _objectSpread(_objectSpread(_objectSpread({}, positionColumns), flowColumns), altitudeColumn)
+  });
+  if (options.colorBySpeed) {
+    layer.config.visConfig = _objectSpread(_objectSpread({}, layer.config.visConfig), {}, {
+      colorBySpeed: true
+    });
+  }
+  return layer;
+}
+function buildLayerConfig(layer, datasetId, layerName, sourceName, layerType) {
+  var _layer$config, _layer$config2;
+  var layerId = layer.id || uniqueLayerId();
+  var columns = ((_layer$config = layer.config) === null || _layer$config === void 0 ? void 0 : _layer$config.columns) || {};
+  return {
+    id: layerId,
+    type: layer.type,
+    config: _objectSpread(_objectSpread({}, layer.config), {}, {
+      dataId: datasetId,
+      isVisible: true,
+      label: layerName || "".concat(sourceName, "-").concat(layerType),
+      columns: Object.keys(columns).reduce(function (acc, key) {
+        var column = columns[key];
+        if (column) {
+          acc[key] = column.value;
+        }
+        return acc;
+      }, {}),
+      visConfig: _objectSpread({}, (_layer$config2 = layer.config) === null || _layer$config2 === void 0 ? void 0 : _layer$config2.visConfig)
+    })
+  };
+}
+function applyColorConfig(newLayer, dataset, args) {
+  if (args.simpleColor) {
+    var color = args.simpleColor.replace(/[^\d,]/g, '').split(',').map(Number);
+    if (color.length === 3) {
+      newLayer.config.color = color;
+    }
+  }
+  var colorBy = args.colorBy,
+    colorType = args.colorType,
+    providedColorMap = args.colorMap;
+  if (colorBy) {
+    var colorField = dataset.fields.find(function (f) {
+      return f.name === colorBy;
+    });
+    if (!colorField) {
+      throw new Error("Field ".concat(colorBy, " not found."));
+    }
+
+    // For categorical (customOrdinal) color maps, every value becomes the scale
+    // domain, so it must be a real value present in the data. The agent must not
+    // invent category labels — get them via geoda.analysis (analysis: 'classify',
+    // method: 'unique values'). Rejecting here turns a silent wrong render into a
+    // recoverable error. Only run this when colorType is explicitly 'unique':
+    // an omitted colorType defaults to a continuous (breaks) scale, whose
+    // colorMap values are break boundaries, not data values.
+    if (colorType === 'unique' && providedColorMap) {
+      // Validate without materializing the whole column: scan rows, deleting
+      // matches from a small `wanted` set (early-exit when all are found),
+      // while collecting a small sample of actual values for the error message.
+      // Scan ALL rows — a bounded sample (prefix OR fixed-stride) can
+      // systematically miss a category that exists later in the data and
+      // falsely report it as "not found". The early-exit keeps the common case
+      // (all categories found early) fast; only a genuinely missing category
+      // costs a full scan, which is the price of an accurate error.
+      var wanted = new Set(providedColorMap.map(function (c) {
+        return c.value;
+      }));
+      var sample = [];
+      var seen = new Set();
+      for (var i = 0; i < dataset.length && wanted.size > 0; i++) {
+        var v = dataset.getValue(colorBy, i);
+        if (wanted.has(v)) {
+          wanted["delete"](v);
+        } else if (!seen.has(v) && sample.length < 20) {
+          seen.add(v);
+          sample.push(v);
+        }
+      }
+      if (wanted.size > 0) {
+        var missing = _toConsumableArray(wanted);
+        throw new Error("colorMap value(s) ".concat(missing.map(function (v) {
+          return JSON.stringify(v);
+        }).join(', '), " not found in field \"").concat(colorBy, "\". ") + "Actual unique values: ".concat(sample.map(function (v) {
+          return JSON.stringify(v);
+        }).join(', ')).concat(sample.length >= 20 ? ', …' : '', ". ") + "Call geoda.analysis (analysis: 'classify', method: 'unique values') to get the real values.");
+      }
+    }
+
+    // colorType is optional; when omitted, default to a continuous (breaks)
+    // scale so numeric fields colored via colorBy aren't mis-colored as
+    // categorical. Only an explicit 'unique' selects the categorical scale.
+    var colorScale = colorType === 'unique' ? 'customOrdinal' : 'custom';
+
+    // Only force a custom palette when the caller provided an explicit
+    // colorMap. A synthetic single-entry colorMap ({value: null, color:
+    // '#333333'}) would route through kepler's custom colorMap scale path and
+    // render everything as the no-value/unknown color; without an explicit
+    // colorMap, bind the color field and let kepler.gl's default color range
+    // apply.
+    var colorRange = providedColorMap ? {
+      name: 'color.customPalette',
+      type: 'custom',
+      category: 'Custom',
+      colors: providedColorMap.map(function (c) {
+        return c.color;
+      }),
+      colorMap: providedColorMap.map(function (c) {
+        return [c.value, c.color];
+      })
+    } : null;
+    if (newLayer.type === 'heatmap') {
+      if (colorRange && providedColorMap && providedColorMap.length > 1) {
+        newLayer.config.visConfig['colorRange'] = _objectSpread({}, colorRange);
+      }
+    } else {
+      newLayer.config['colorScale'] = colorScale;
+      newLayer.config['colorField'] = colorField;
+      newLayer.config['strokeColorScale'] = colorScale;
+      newLayer.config['strokeColorField'] = colorField;
+      newLayer.config.visConfig['filled'] = true;
+      if (colorRange) {
+        newLayer.config.visConfig['colorRange'] = colorRange;
+        newLayer.config.visConfig['strokeColorRange'] = colorRange;
+      }
+    }
+  }
+}
+export var addLayerCommandId = 'map.add-layer';
+export function getAddLayerCommand(ctx) {
+  return {
+    id: addLayerCommandId,
+    name: 'Add map layer',
+    group: 'Map',
+    description: "Add a kepler.gl map layer from a dataset.\nIMPORTANT: generated layer names must be unique.\n\nLAYER TYPES:\n- point: Point markers (requires lat/lng columns)\n- flow: Origin->destination flow map (requires two point lat/lng pairs, auto-detected)\n- flowField: Animated streamlines over a vector field (u/v, speed/direction, or altitude)\n- h3: H3 hexagon cells (requires hexId column)\n- geojson: Polygon/geometry features (uses geometry column, usually auto-detected)\n- hexagon: Hexagonal binning of points\n- heatmap: Heat map visualization\n- cluster: Clustered point visualization\n- arc/line: Arc or line connections between points\n- grid: Grid binning\n- trip: Animated trip (flights, deliveries, vessels)\n- s2: S2 geometry cells\n\nFLOW MAPS (layerType 'flow'):\nFor origin->destination flows use layerType 'flow' \u2014 a dedicated flow layer that draws\nlocations and weighted flows between them. It needs TWO point lat/lng pairs in the\ndataset (source pair + destination pair), which are auto-detected. Prefer 'flow' over\n'arc' for O-D flows; 'arc' draws straight great-circle lines without location clustering\nor flow aggregation. To weight the flows by a value column (flow magnitude), pass\ncountColumn with the column name \u2014 omit it to render all flows at weight 1.\n\nFLOW FIELD (layerType 'flowField'):\nAnimated streamlines over a vector field \u2014 wind, currents, or downhill flow. It is NOT\nthe origin->destination 'flow' layer: 'flow' joins two point pairs, 'flowField' draws\nmany short lines through a field of vectors, one row per sample point.\nThe direction comes from one of three column sets, auto-detected in this order:\n- u/v components (default mode 'UV'), optionally with an altitude column\n- speed + direction (mode 'SPEED_DIR')\n- altitude only (mode 'ELEVATION'): the downhill gradient gives the direction\nPosition is lat/lng (auto-detected, or latitudeColumn/longitudeColumn) or a GeoJSON\ngeometry column. When the dataset names the columns differently, pass flowField.mode\nplus flowField.uColumn/vColumn/speedColumn/directionColumn/altitudeColumn.\nSet flowField.colorBySpeed true to color lines by local speed; otherwise simpleColor\napplies. colorBy/colorMap do not apply to this layer. Do NOT add a time filter \u2014 the\nflow field animates itself.\n\nBASIC MAP:\n- Use datasetName, latitudeColumn/longitudeColumn (for point maps), and layerType\n- Omit color-related parameters for simple visualization, use simpleColor instead.\n\nCOLOR MAPPING:\n- If user requests color visualization, use available columns in the dataset\n- Use geoda.analysis (analysis: 'classify') to classify data into bins or unique values when needed\n- For continuous data (colorType 'breaks'):\n  [{value: 0, color: '#fee5d9'}, {value: 50, color: '#fcae91'}, {value: 100, color: '#fb6a4a'}, {value: null, color: '#de2d26'}]\n  The last entry with value: null represents the color for the highest values\n- For categorical data (colorType 'unique'):\n  [{value: 'category1', color: '#1f77b4'}, {value: 'category2', color: '#ff7f0e'}]\n  HARD RULE: the colorMap values MUST be the actual unique values present in the data.\n  Call geoda.analysis (analysis: 'classify', method: 'unique values') first and use the\n  returned uniqueValues verbatim. NEVER invent category labels from the field name \u2014\n  the command rejects values that do not exist in the data.\n- If the user doesn't specify colors, omit colorBy/colorMap \u2014 kepler.gl applies its default color range automatically\n\nFor geojson datasets:\n- Use geometryColumn: '_geojson' and layerType: 'geojson' even for point collections\n",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'medium',
+      idempotent: false
+    },
+    inputSchema: z.object({
+      datasetName: z.string().describe('The name (label) or id of the dataset. Prefer the label when known.'),
+      latitudeColumn: z.string().optional(),
+      longitudeColumn: z.string().optional(),
+      layerName: z.string().optional().describe('Generate a unique name for the layer based on the context.'),
+      layerType: z["enum"](['point', 'flow', 'flowField', 'arc', 'line', 'grid', 'hexagon', 'geojson', 'cluster', 'heatmap', 'h3', 'trip', 's2']),
+      flowField: z.object({
+        mode: z["enum"](FLOW_FIELD_MODES).optional(),
+        uColumn: z.string().optional(),
+        vColumn: z.string().optional(),
+        speedColumn: z.string().optional(),
+        directionColumn: z.string().optional(),
+        altitudeColumn: z.string().optional(),
+        colorBySpeed: z["boolean"]().optional()
+      }).optional().describe('For layerType "flowField" only: how the vector field is encoded. The mode is ' + 'inferred from the columns (u/v, speed/direction, otherwise altitude); the ' + '*Column fields name the columns when they differ from those defaults.'),
+      simpleColor: z.string().optional().describe('The color of the layer e.g. [255, 0, 0]. Only used for simple map visualization (no colorBy, colorType, colorMap).'),
+      colorBy: z.string().optional(),
+      colorType: z["enum"](['breaks', 'unique']).optional(),
+      countColumn: z.string().optional().describe('For layerType "flow" (and only flow): a numeric column whose value weights each flow (flow magnitude). Omit to render all flows at weight 1.'),
+      colorMap: z.array(z.object({
+        value: z.union([z.string(), z.number(), z["null"]()]),
+        color: z.string()
+      })).optional()
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var args, datasetName, layerName, latitudeColumn, longitudeColumn, layerType, simpleColor, colorBy, colorType, colorMap, countColumn, flowField, _dataset$fields4, VALID_LAYER_TYPES, visState, datasets, datasetId, dataset, layer, latIdx, lngIdx, _dataset$fields$map$j2, _dataset$fields3, missing, available, newLayer, addedLayer, bounds, temporalFields, hasTemporalFields;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              args = input !== null && input !== void 0 ? input : {};
+              datasetName = args.datasetName, layerName = args.layerName, latitudeColumn = args.latitudeColumn, longitudeColumn = args.longitudeColumn, layerType = args.layerType, simpleColor = args.simpleColor, colorBy = args.colorBy, colorType = args.colorType, colorMap = args.colorMap, countColumn = args.countColumn, flowField = args.flowField;
+              _context.prev = 2;
+              // Runtime guard: the bridge/webMCP call execute without zod parsing, so
+              // a missing/invalid layerType must not fall through to
+              // guessDefaultLayer's first-default-layer fallback (layerType is
+              // required by the command contract).
+              VALID_LAYER_TYPES = ['point', 'flow', 'flowField', 'arc', 'line', 'grid', 'hexagon', 'geojson', 'cluster', 'heatmap', 'h3', 'trip', 's2'];
+              if (!(!layerType || !VALID_LAYER_TYPES.includes(layerType))) {
+                _context.next = 6;
+                break;
+              }
+              throw new Error("Invalid layerType \"".concat(String(layerType), "\". Must be one of: ").concat(VALID_LAYER_TYPES.join(', '), "."));
+            case 6:
+              visState = ctx.getVisState();
+              datasets = visState.datasets;
+              datasetId = Object.keys(datasets).find(function (dataId) {
+                return datasets[dataId].label === datasetName || dataId === datasetName;
+              });
+              if (datasetId) {
+                _context.next = 11;
+                break;
+              }
+              throw new Error("Dataset ".concat(datasetName, " not found."));
+            case 11:
+              dataset = datasets[datasetId]; // The flow field layer resolves its own columns (position + vector, in
+              // one of three modes), so it does not go through guessDefaultLayer —
+              // that path only auto-detects the u/v case and would ignore explicit
+              // column names.
+              layer = layerType === 'flowField' ? buildFlowFieldLayer(dataset, {
+                latitudeColumn: latitudeColumn,
+                longitudeColumn: longitudeColumn
+              }, flowField) : guessDefaultLayer(dataset, layerType, {
+                countColumn: countColumn
+              });
+              if (layer) {
+                _context.next = 22;
+                break;
+              }
+              if (!(layerType === 'point' && latitudeColumn && longitudeColumn)) {
+                _context.next = 22;
+                break;
+              }
+              // Validate both columns exist before building the config —
+              // getColumnFieldIdx returns -1 for a missing column, and an
+              // invalid fieldIdx would dispatch a broken layer config (empty
+              // render / confusing runtime errors).
+              latIdx = dataset.getColumnFieldIdx(latitudeColumn);
+              lngIdx = dataset.getColumnFieldIdx(longitudeColumn);
+              if (!(latIdx < 0 || lngIdx < 0)) {
+                _context.next = 21;
+                break;
+              }
+              missing = latIdx < 0 ? latitudeColumn : longitudeColumn;
+              available = (_dataset$fields$map$j2 = (_dataset$fields3 = dataset.fields) === null || _dataset$fields3 === void 0 ? void 0 : _dataset$fields3.map(function (f) {
+                return f.name;
+              }).join(', ')) !== null && _dataset$fields$map$j2 !== void 0 ? _dataset$fields$map$j2 : '';
+              throw new Error("Column \"".concat(missing, "\" not found in dataset \"").concat(datasetName, "\". Available columns: ").concat(available));
+            case 21:
+              layer = {
+                id: uniqueLayerId(),
+                type: 'point',
+                config: {
+                  dataId: datasetId,
+                  label: layerName || "".concat(datasetName, "-").concat(layerType),
+                  columns: {
+                    lat: {
+                      value: latitudeColumn,
+                      fieldIdx: latIdx
+                    },
+                    lng: {
+                      value: longitudeColumn,
+                      fieldIdx: lngIdx
+                    }
+                  },
+                  visConfig: {}
+                }
+              };
+            case 22:
+              if (layer) {
+                _context.next = 24;
+                break;
+              }
+              throw new Error("Could not create ".concat(layerType, " layer. Check that the dataset has the required columns."));
+            case 24:
+              newLayer = buildLayerConfig(layer, datasetId, layerName, datasetName, layerType);
+              applyColorConfig(newLayer, dataset, {
+                simpleColor: simpleColor,
+                colorBy: colorBy,
+                colorType: colorType,
+                colorMap: colorMap
+              });
+              ctx.dispatch(addLayerAction(newLayer, datasetId));
+
+              // Center the map on the new layer's data bounds. `addDataToMap` with
+              // `autoCreateLayers: false` (used by `map.load-data`) never fits bounds
+              // because no layer exists at load time, and `addLayerUpdater` does not
+              // center either — so fit here explicitly.
+              addedLayer = ctx.getVisState().layers.find(function (l) {
+                return l.id === newLayer.id;
+              });
+              bounds = addedLayer ? findMapBounds([addedLayer]) : null;
+              if (bounds) {
+                ctx.dispatch(fitBounds(bounds));
+              }
+              temporalFields = (_dataset$fields4 = dataset.fields) === null || _dataset$fields4 === void 0 ? void 0 : _dataset$fields4.filter(function (f) {
+                return f.type === 'timestamp' || f.type === 'date';
+              }).map(function (f) {
+                return f.name;
+              });
+              hasTemporalFields = temporalFields && temporalFields.length > 0;
+              return _context.abrupt("return", {
+                success: true,
+                commandId: addLayerCommandId,
+                data: {
+                  details: "Map layer ".concat(newLayer.id, " has been added to the map."),
+                  dateTimeColumns: hasTemporalFields ? temporalFields : undefined,
+                  dateTimeHint: hasTemporalFields ? "DateTime columns detected: ".concat(temporalFields.join(', '), ". You can call addTimeFilter with one of these columns to enable time-range animation on the map.") : undefined
+                }
+              });
+            case 35:
+              _context.prev = 35;
+              _context.t0 = _context["catch"](2);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: addLayerCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Try to fix the error. If the error persists, ask the user to try with different parameters.'
+                }
+              });
+            case 38:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[2, 35]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["z","GEOJSON_FIELDS","LayerClasses","findDefaultLayer","findMapBounds","addLayer","addLayerAction","fitBounds","uniqueLayerId","prefix","arguments","length","undefined","concat","Date","now","Math","random","toString","slice","guessDefaultLayer","dataset","layerType","options","fieldPairs","props","map","fieldPair","isVisible","label","columns","pair","layer","heatmap","hexagon","cluster","layers","trip","find","l","type","Error","pairs","lat0","lat","lng0","lng","lat1","lng1","countColumn","getColumnFieldIdx","count","value","fieldIdx","flow","defaultName","defaultLayers","FLOW_FIELD_ALTITUDE_COLUMNS","FLOW_FIELD_MODES","buildFlowFieldLayer","position","hasColumn","name","columnRef","_dataset$fields$map$j","_dataset$fields","available","fields","f","join","positionColumns","latitudeColumn","longitudeColumn","_dataset$fieldPairs","_dataset$fields2","geoField","geojson","includes","altitudeName","altitudeColumn","mode","uColumn","vColumn","speedColumn","directionColumn","flowColumns","u","v","speed","direction","altitude","flowField","color","columnMode","_objectSpread","colorBySpeed","config","visConfig","buildLayerConfig","datasetId","layerName","sourceName","_layer$config","_layer$config2","layerId","id","dataId","Object","keys","reduce","acc","key","column","applyColorConfig","newLayer","args","simpleColor","replace","split","Number","colorBy","colorType","providedColorMap","colorMap","colorField","wanted","Set","c","sample","seen","i","size","getValue","has","add","push","missing","_toConsumableArray","JSON","stringify","colorScale","colorRange","category","colors","addLayerCommandId","getAddLayerCommand","ctx","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","object","datasetName","string","describe","optional","array","union","number","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_dataset$fields4","VALID_LAYER_TYPES","visState","datasets","latIdx","lngIdx","_dataset$fields$map$j2","_dataset$fields3","addedLayer","bounds","temporalFields","hasTemporalFields","wrap","_callee$","_context","prev","next","String","getVisState","dispatch","filter","abrupt","success","commandId","data","details","dateTimeColumns","dateTimeHint","t0","error","message","instruction","stop","_x","_x2","apply"],"sources":["../../../src/commands/layer-creation-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {GEOJSON_FIELDS} from '@kepler.gl/constants';\nimport {LayerClasses} from '@kepler.gl/layers';\nimport type KeplerTable from '@kepler.gl/table';\nimport type {Datasets} from '@kepler.gl/table';\nimport {findDefaultLayer, findMapBounds} from '@kepler.gl/reducers';\nimport {addLayer as addLayerAction, fitBounds} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\n\n/**\n * Unique layer id. Date.now()-based ids can collide when multiple layers are\n * created within the same millisecond (rapid successive tool calls), producing\n * duplicate layer ids and unpredictable reducer behavior. Append a random\n * suffix — the same Math.random().toString(36) trick kepler's generateHashId\n * uses — so ids stay unique.\n */\nfunction uniqueLayerId(prefix = 'layer'): string {\n  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;\n}\n\nexport function guessDefaultLayer(\n  dataset: KeplerTable,\n  layerType: string,\n  options?: {countColumn?: string}\n) {\n  if (layerType === 'heatmap') {\n    if (dataset.fieldPairs && dataset.fieldPairs.length > 0) {\n      const props = dataset.fieldPairs.map(fieldPair => ({\n        isVisible: true,\n        label: 'Heatmap',\n        columns: fieldPair.pair\n      }));\n      const layer = new LayerClasses.heatmap(props[0]);\n      return layer;\n    }\n  } else if (layerType === 'hexagon') {\n    if (dataset.fieldPairs && dataset.fieldPairs.length > 0) {\n      const props = dataset.fieldPairs.map(fieldPair => ({\n        isVisible: true,\n        label: 'Hexbin',\n        columns: fieldPair.pair\n      }));\n      const layer = new LayerClasses.hexagon(props[0]);\n      return layer;\n    }\n  } else if (layerType === 'cluster') {\n    if (dataset.fieldPairs && dataset.fieldPairs.length > 0) {\n      const props = dataset.fieldPairs.map(fieldPair => ({\n        isVisible: true,\n        label: 'Cluster',\n        columns: fieldPair.pair\n      }));\n      const layer = new LayerClasses.cluster(props[0]);\n      return layer;\n    }\n  } else if (layerType === 'trip') {\n    const layers = findDefaultLayer(dataset, [LayerClasses.trip] as any);\n    const layer = layers.find(l => l.type === layerType);\n    if (layer) return layer;\n    throw new Error(\n      `Failed to create a trip layer. Trip layer requires id, lat, lng, and timestamp columns.`\n    );\n  } else if (layerType === 'flow') {\n    // Flow layers are never auto-detected (findDefaultLayerProps returns\n    // {props: []}), so build one explicitly from the first two point lat/lng\n    // field pairs — the same source/target pair logic the default arc layer\n    // uses: pair[0] = origin (lat0/lng0), pair[1] = destination (lat1/lng1).\n    // The count column (flow magnitude) is optional; without it every flow\n    // renders at weight 1.\n    const pairs = dataset.fieldPairs || [];\n    if (pairs.length < 2) {\n      throw new Error(\n        `Failed to create a flow layer. Flow layer requires two point lat/lng pairs ` +\n          `(origin + destination), e.g. origin_lat/origin_lng and dest_lat/dest_lng.`\n      );\n    }\n    const columns: any = {\n      lat0: pairs[0].pair.lat,\n      lng0: pairs[0].pair.lng,\n      lat1: pairs[1].pair.lat,\n      lng1: pairs[1].pair.lng\n    };\n    if (options?.countColumn && dataset.getColumnFieldIdx(options.countColumn) >= 0) {\n      columns.count = {\n        value: options.countColumn,\n        fieldIdx: dataset.getColumnFieldIdx(options.countColumn)\n      };\n    }\n    // LayerClasses' computed keys (keyMirror) aren't statically named, so\n    // access flow like the trip branch accesses trip: through an `as any` cast.\n    const layer = new (LayerClasses as any).flow({\n      isVisible: true,\n      label: `${pairs[0].defaultName} -> ${pairs[1].defaultName} flow`,\n      columns\n    });\n    return layer;\n  }\n  const defaultLayers = findDefaultLayer(dataset, LayerClasses as any);\n  const layer = defaultLayers.find(l => l.type === layerType);\n  // Return null (not a fallback to the first default layer) when the requested\n  // type can't be created — silently substituting a different layer type (e.g.\n  // requesting \"h3\" and getting a point layer) violates the command contract\n  // and makes failures hard to diagnose. The caller errors clearly on null.\n  return layer || null;\n}\n\n/** Column names the flow field layer resolves when the caller doesn't name them. */\nconst FLOW_FIELD_ALTITUDE_COLUMNS = ['altitude', 'alt', 'elevation', 'elev', 'elv', 'height', 'z'];\nconst FLOW_FIELD_MODES = ['UV', 'SPEED_DIR', 'ELEVATION'] as const;\ntype FlowFieldMode = (typeof FLOW_FIELD_MODES)[number];\n\ntype FlowFieldOptions = {\n  mode?: FlowFieldMode;\n  uColumn?: string;\n  vColumn?: string;\n  speedColumn?: string;\n  directionColumn?: string;\n  altitudeColumn?: string;\n  colorBySpeed?: boolean;\n};\n\n/**\n * Flow Field is a vector/streamline layer: each row is a sample point carrying\n * a position plus a direction — u/v components, speed/direction, or an altitude\n * whose downhill gradient supplies the direction. Unlike the origin→destination\n * `flow` layer it needs no second point pair, and unlike `trip` it animates\n * itself, so no time filter belongs on it.\n */\nfunction buildFlowFieldLayer(\n  dataset: KeplerTable,\n  position: {latitudeColumn?: string; longitudeColumn?: string},\n  options: FlowFieldOptions = {}\n) {\n  const hasColumn = (name?: string) => !!name && dataset.getColumnFieldIdx(name) >= 0;\n  const columnRef = (name: string) => {\n    const fieldIdx = dataset.getColumnFieldIdx(name);\n    if (fieldIdx < 0) {\n      const available = dataset.fields?.map((f: any) => f.name).join(', ') ?? '';\n      throw new Error(\n        `Column \"${name}\" not found in dataset \"${dataset.label}\". Available columns: ${available}`\n      );\n    }\n    return {value: name, fieldIdx};\n  };\n\n  // Position: explicit lat/lng, else the dataset's first detected point pair,\n  // else a GeoJSON geometry column (one position per feature).\n  let positionColumns: Record<string, any> | null = null;\n  if (position.latitudeColumn && position.longitudeColumn) {\n    positionColumns = {\n      lat: columnRef(position.latitudeColumn),\n      lng: columnRef(position.longitudeColumn)\n    };\n  } else {\n    const pair = dataset.fieldPairs?.[0]?.pair;\n    if (pair?.lat && pair?.lng) {\n      positionColumns = {lat: pair.lat, lng: pair.lng};\n    } else {\n      const geoField = dataset.fields?.find(\n        (f: any) => f.type === 'geojson' || GEOJSON_FIELDS.geojson.includes(f.name)\n      );\n      if (geoField) {\n        positionColumns = {geojson: {value: geoField.name, fieldIdx: geoField.fieldIdx}};\n      }\n    }\n  }\n  if (!positionColumns) {\n    throw new Error(\n      'A flow field layer needs a position: lat/lng columns (auto-detected, or pass ' +\n        'latitudeColumn/longitudeColumn) or a GeoJSON geometry column.'\n    );\n  }\n\n  const altitudeName =\n    options.altitudeColumn || FLOW_FIELD_ALTITUDE_COLUMNS.find(name => hasColumn(name)) || null;\n\n  const mode: FlowFieldMode | null =\n    options.mode ||\n    (options.uColumn || options.vColumn || (hasColumn('u') && hasColumn('v'))\n      ? 'UV'\n      : options.speedColumn ||\n        options.directionColumn ||\n        (hasColumn('speed') && hasColumn('direction'))\n      ? 'SPEED_DIR'\n      : altitudeName\n      ? 'ELEVATION'\n      : null);\n  if (!mode) {\n    throw new Error(\n      'A flow field layer needs a vector: u/v columns, speed/direction columns, or an ' +\n        'altitude column (pass flowField.uColumn/vColumn/speedColumn/directionColumn/' +\n        'altitudeColumn when the names differ).'\n    );\n  }\n\n  let flowColumns: Record<string, any>;\n  if (mode === 'UV') {\n    flowColumns = {\n      u: columnRef(options.uColumn || 'u'),\n      v: columnRef(options.vColumn || 'v')\n    };\n  } else if (mode === 'SPEED_DIR') {\n    flowColumns = {\n      speed: columnRef(options.speedColumn || 'speed'),\n      direction: columnRef(options.directionColumn || 'direction')\n    };\n  } else {\n    if (!altitudeName) {\n      throw new Error(\n        'A flow field layer in ELEVATION mode needs an altitude column (pass flowField.altitudeColumn).'\n      );\n    }\n    flowColumns = {altitude: columnRef(altitudeName)};\n  }\n\n  // UV and SPEED_DIR may also carry an altitude, which lifts the streamlines.\n  const altitudeColumn =\n    mode === 'ELEVATION' || !altitudeName ? {} : {altitude: columnRef(altitudeName)};\n\n  const layer = new (LayerClasses as any).flowField({\n    isVisible: true,\n    label: 'Flow Field',\n    color: [255, 255, 255],\n    columnMode: mode,\n    columns: {...positionColumns, ...flowColumns, ...altitudeColumn}\n  });\n  if (options.colorBySpeed) {\n    layer.config.visConfig = {...layer.config.visConfig, colorBySpeed: true};\n  }\n  return layer;\n}\n\nfunction buildLayerConfig(\n  layer: any,\n  datasetId: string,\n  layerName: string | undefined,\n  sourceName: string,\n  layerType: string\n) {\n  const layerId = layer.id || uniqueLayerId();\n  const columns = layer.config?.columns || {};\n\n  return {\n    id: layerId,\n    type: layer.type,\n    config: {\n      ...layer.config,\n      dataId: datasetId,\n      isVisible: true,\n      label: layerName || `${sourceName}-${layerType}`,\n      columns: Object.keys(columns).reduce<Record<string, any>>((acc, key) => {\n        const column = columns[key];\n        if (column) {\n          acc[key] = column.value;\n        }\n        return acc;\n      }, {}),\n      visConfig: {\n        ...layer.config?.visConfig\n      }\n    }\n  };\n}\n\nfunction applyColorConfig(\n  newLayer: any,\n  dataset: KeplerTable,\n  args: {\n    simpleColor?: string;\n    colorBy?: string;\n    colorType?: 'breaks' | 'unique';\n    colorMap?: Array<{value: string | number | null; color: string}>;\n  }\n) {\n  if (args.simpleColor) {\n    const color = args.simpleColor\n      .replace(/[^\\d,]/g, '')\n      .split(',')\n      .map(Number);\n    if (color.length === 3) {\n      newLayer.config.color = color;\n    }\n  }\n\n  const {colorBy, colorType, colorMap: providedColorMap} = args;\n\n  if (colorBy) {\n    const colorField = dataset.fields.find(f => f.name === colorBy);\n    if (!colorField) {\n      throw new Error(`Field ${colorBy} not found.`);\n    }\n\n    // For categorical (customOrdinal) color maps, every value becomes the scale\n    // domain, so it must be a real value present in the data. The agent must not\n    // invent category labels — get them via geoda.analysis (analysis: 'classify',\n    // method: 'unique values'). Rejecting here turns a silent wrong render into a\n    // recoverable error. Only run this when colorType is explicitly 'unique':\n    // an omitted colorType defaults to a continuous (breaks) scale, whose\n    // colorMap values are break boundaries, not data values.\n    if (colorType === 'unique' && providedColorMap) {\n      // Validate without materializing the whole column: scan rows, deleting\n      // matches from a small `wanted` set (early-exit when all are found),\n      // while collecting a small sample of actual values for the error message.\n      // Scan ALL rows — a bounded sample (prefix OR fixed-stride) can\n      // systematically miss a category that exists later in the data and\n      // falsely report it as \"not found\". The early-exit keeps the common case\n      // (all categories found early) fast; only a genuinely missing category\n      // costs a full scan, which is the price of an accurate error.\n      const wanted = new Set(providedColorMap.map(c => c.value));\n      const sample: unknown[] = [];\n      const seen = new Set<unknown>();\n      for (let i = 0; i < dataset.length && wanted.size > 0; i++) {\n        const v = dataset.getValue(colorBy, i);\n        if (wanted.has(v)) {\n          wanted.delete(v);\n        } else if (!seen.has(v) && sample.length < 20) {\n          seen.add(v);\n          sample.push(v);\n        }\n      }\n      if (wanted.size > 0) {\n        const missing = [...wanted];\n        throw new Error(\n          `colorMap value(s) ${missing\n            .map(v => JSON.stringify(v))\n            .join(', ')} not found in field \"${colorBy}\". ` +\n            `Actual unique values: ${sample.map(v => JSON.stringify(v)).join(', ')}${\n              sample.length >= 20 ? ', …' : ''\n            }. ` +\n            `Call geoda.analysis (analysis: 'classify', method: 'unique values') to get the real values.`\n        );\n      }\n    }\n\n    // colorType is optional; when omitted, default to a continuous (breaks)\n    // scale so numeric fields colored via colorBy aren't mis-colored as\n    // categorical. Only an explicit 'unique' selects the categorical scale.\n    const colorScale = colorType === 'unique' ? 'customOrdinal' : 'custom';\n\n    // Only force a custom palette when the caller provided an explicit\n    // colorMap. A synthetic single-entry colorMap ({value: null, color:\n    // '#333333'}) would route through kepler's custom colorMap scale path and\n    // render everything as the no-value/unknown color; without an explicit\n    // colorMap, bind the color field and let kepler.gl's default color range\n    // apply.\n    const colorRange = providedColorMap\n      ? ({\n          name: 'color.customPalette',\n          type: 'custom',\n          category: 'Custom',\n          colors: providedColorMap.map(c => c.color),\n          colorMap: providedColorMap.map(c => [c.value, c.color])\n        } as const)\n      : null;\n\n    if (newLayer.type === 'heatmap') {\n      if (colorRange && providedColorMap && providedColorMap.length > 1) {\n        newLayer.config.visConfig['colorRange'] = {...colorRange};\n      }\n    } else {\n      newLayer.config['colorScale'] = colorScale;\n      newLayer.config['colorField'] = colorField;\n      newLayer.config['strokeColorScale'] = colorScale;\n      newLayer.config['strokeColorField'] = colorField;\n      newLayer.config.visConfig['filled'] = true;\n      if (colorRange) {\n        newLayer.config.visConfig['colorRange'] = colorRange;\n        newLayer.config.visConfig['strokeColorRange'] = colorRange;\n      }\n    }\n  }\n}\n\nexport const addLayerCommandId = 'map.add-layer' as const;\n\nexport function getAddLayerCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: addLayerCommandId,\n    name: 'Add map layer',\n    group: 'Map',\n    description: `Add a kepler.gl map layer from a dataset.\nIMPORTANT: generated layer names must be unique.\n\nLAYER TYPES:\n- point: Point markers (requires lat/lng columns)\n- flow: Origin->destination flow map (requires two point lat/lng pairs, auto-detected)\n- flowField: Animated streamlines over a vector field (u/v, speed/direction, or altitude)\n- h3: H3 hexagon cells (requires hexId column)\n- geojson: Polygon/geometry features (uses geometry column, usually auto-detected)\n- hexagon: Hexagonal binning of points\n- heatmap: Heat map visualization\n- cluster: Clustered point visualization\n- arc/line: Arc or line connections between points\n- grid: Grid binning\n- trip: Animated trip (flights, deliveries, vessels)\n- s2: S2 geometry cells\n\nFLOW MAPS (layerType 'flow'):\nFor origin->destination flows use layerType 'flow' — a dedicated flow layer that draws\nlocations and weighted flows between them. It needs TWO point lat/lng pairs in the\ndataset (source pair + destination pair), which are auto-detected. Prefer 'flow' over\n'arc' for O-D flows; 'arc' draws straight great-circle lines without location clustering\nor flow aggregation. To weight the flows by a value column (flow magnitude), pass\ncountColumn with the column name — omit it to render all flows at weight 1.\n\nFLOW FIELD (layerType 'flowField'):\nAnimated streamlines over a vector field — wind, currents, or downhill flow. It is NOT\nthe origin->destination 'flow' layer: 'flow' joins two point pairs, 'flowField' draws\nmany short lines through a field of vectors, one row per sample point.\nThe direction comes from one of three column sets, auto-detected in this order:\n- u/v components (default mode 'UV'), optionally with an altitude column\n- speed + direction (mode 'SPEED_DIR')\n- altitude only (mode 'ELEVATION'): the downhill gradient gives the direction\nPosition is lat/lng (auto-detected, or latitudeColumn/longitudeColumn) or a GeoJSON\ngeometry column. When the dataset names the columns differently, pass flowField.mode\nplus flowField.uColumn/vColumn/speedColumn/directionColumn/altitudeColumn.\nSet flowField.colorBySpeed true to color lines by local speed; otherwise simpleColor\napplies. colorBy/colorMap do not apply to this layer. Do NOT add a time filter — the\nflow field animates itself.\n\nBASIC MAP:\n- Use datasetName, latitudeColumn/longitudeColumn (for point maps), and layerType\n- Omit color-related parameters for simple visualization, use simpleColor instead.\n\nCOLOR MAPPING:\n- If user requests color visualization, use available columns in the dataset\n- Use geoda.analysis (analysis: 'classify') to classify data into bins or unique values when needed\n- For continuous data (colorType 'breaks'):\n  [{value: 0, color: '#fee5d9'}, {value: 50, color: '#fcae91'}, {value: 100, color: '#fb6a4a'}, {value: null, color: '#de2d26'}]\n  The last entry with value: null represents the color for the highest values\n- For categorical data (colorType 'unique'):\n  [{value: 'category1', color: '#1f77b4'}, {value: 'category2', color: '#ff7f0e'}]\n  HARD RULE: the colorMap values MUST be the actual unique values present in the data.\n  Call geoda.analysis (analysis: 'classify', method: 'unique values') first and use the\n  returned uniqueValues verbatim. NEVER invent category labels from the field name —\n  the command rejects values that do not exist in the data.\n- If the user doesn't specify colors, omit colorBy/colorMap — kepler.gl applies its default color range automatically\n\nFor geojson datasets:\n- Use geometryColumn: '_geojson' and layerType: 'geojson' even for point collections\n`,\n    metadata: {readOnly: false, riskLevel: 'medium', idempotent: false},\n    inputSchema: z.object({\n      datasetName: z\n        .string()\n        .describe('The name (label) or id of the dataset. Prefer the label when known.'),\n      latitudeColumn: z.string().optional(),\n      longitudeColumn: z.string().optional(),\n      layerName: z\n        .string()\n        .optional()\n        .describe('Generate a unique name for the layer based on the context.'),\n      layerType: z.enum([\n        'point',\n        'flow',\n        'flowField',\n        'arc',\n        'line',\n        'grid',\n        'hexagon',\n        'geojson',\n        'cluster',\n        'heatmap',\n        'h3',\n        'trip',\n        's2'\n      ]),\n      flowField: z\n        .object({\n          mode: z.enum(FLOW_FIELD_MODES).optional(),\n          uColumn: z.string().optional(),\n          vColumn: z.string().optional(),\n          speedColumn: z.string().optional(),\n          directionColumn: z.string().optional(),\n          altitudeColumn: z.string().optional(),\n          colorBySpeed: z.boolean().optional()\n        })\n        .optional()\n        .describe(\n          'For layerType \"flowField\" only: how the vector field is encoded. The mode is ' +\n            'inferred from the columns (u/v, speed/direction, otherwise altitude); the ' +\n            '*Column fields name the columns when they differ from those defaults.'\n        ),\n      simpleColor: z\n        .string()\n        .optional()\n        .describe(\n          'The color of the layer e.g. [255, 0, 0]. Only used for simple map visualization (no colorBy, colorType, colorMap).'\n        ),\n      colorBy: z.string().optional(),\n      colorType: z.enum(['breaks', 'unique']).optional(),\n      countColumn: z\n        .string()\n        .optional()\n        .describe(\n          'For layerType \"flow\" (and only flow): a numeric column whose value weights each flow (flow magnitude). Omit to render all flows at weight 1.'\n        ),\n      colorMap: z\n        .array(\n          z.object({\n            value: z.union([z.string(), z.number(), z.null()]),\n            color: z.string()\n          })\n        )\n        .optional()\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const args = (input ?? {}) as {\n        datasetName: string;\n        layerName?: string;\n        latitudeColumn?: string;\n        longitudeColumn?: string;\n        layerType: string;\n        simpleColor?: string;\n        colorBy?: string;\n        colorType?: 'breaks' | 'unique';\n        colorMap?: Array<{value: string | number | null; color: string}>;\n        countColumn?: string;\n        flowField?: FlowFieldOptions;\n      };\n      const {\n        datasetName,\n        layerName,\n        latitudeColumn,\n        longitudeColumn,\n        layerType,\n        simpleColor,\n        colorBy,\n        colorType,\n        colorMap,\n        countColumn,\n        flowField\n      } = args;\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // a missing/invalid layerType must not fall through to\n        // guessDefaultLayer's first-default-layer fallback (layerType is\n        // required by the command contract).\n        const VALID_LAYER_TYPES = [\n          'point',\n          'flow',\n          'flowField',\n          'arc',\n          'line',\n          'grid',\n          'hexagon',\n          'geojson',\n          'cluster',\n          'heatmap',\n          'h3',\n          'trip',\n          's2'\n        ];\n        if (!layerType || !VALID_LAYER_TYPES.includes(layerType)) {\n          throw new Error(\n            `Invalid layerType \"${String(layerType)}\". Must be one of: ${VALID_LAYER_TYPES.join(\n              ', '\n            )}.`\n          );\n        }\n\n        const visState = ctx.getVisState();\n        const datasets: Datasets = visState.datasets;\n\n        const datasetId = Object.keys(datasets).find(\n          dataId => datasets[dataId].label === datasetName || dataId === datasetName\n        );\n        if (!datasetId) {\n          throw new Error(`Dataset ${datasetName} not found.`);\n        }\n\n        const dataset = datasets[datasetId];\n        // The flow field layer resolves its own columns (position + vector, in\n        // one of three modes), so it does not go through guessDefaultLayer —\n        // that path only auto-detects the u/v case and would ignore explicit\n        // column names.\n        let layer =\n          layerType === 'flowField'\n            ? buildFlowFieldLayer(dataset, {latitudeColumn, longitudeColumn}, flowField)\n            : guessDefaultLayer(dataset, layerType, {countColumn});\n\n        if (!layer) {\n          if (layerType === 'point' && latitudeColumn && longitudeColumn) {\n            // Validate both columns exist before building the config —\n            // getColumnFieldIdx returns -1 for a missing column, and an\n            // invalid fieldIdx would dispatch a broken layer config (empty\n            // render / confusing runtime errors).\n            const latIdx = dataset.getColumnFieldIdx(latitudeColumn);\n            const lngIdx = dataset.getColumnFieldIdx(longitudeColumn);\n            if (latIdx < 0 || lngIdx < 0) {\n              const missing = latIdx < 0 ? latitudeColumn : longitudeColumn;\n              const available = dataset.fields?.map((f: any) => f.name).join(', ') ?? '';\n              throw new Error(\n                `Column \"${missing}\" not found in dataset \"${datasetName}\". Available columns: ${available}`\n              );\n            }\n            layer = {\n              id: uniqueLayerId(),\n              type: 'point',\n              config: {\n                dataId: datasetId,\n                label: layerName || `${datasetName}-${layerType}`,\n                columns: {\n                  lat: {value: latitudeColumn, fieldIdx: latIdx},\n                  lng: {value: longitudeColumn, fieldIdx: lngIdx}\n                },\n                visConfig: {}\n              }\n            } as any;\n          }\n        }\n        if (!layer) {\n          throw new Error(\n            `Could not create ${layerType} layer. Check that the dataset has the required columns.`\n          );\n        }\n\n        const newLayer = buildLayerConfig(layer, datasetId, layerName, datasetName, layerType);\n        applyColorConfig(newLayer, dataset, {simpleColor, colorBy, colorType, colorMap});\n\n        ctx.dispatch(addLayerAction(newLayer, datasetId));\n\n        // Center the map on the new layer's data bounds. `addDataToMap` with\n        // `autoCreateLayers: false` (used by `map.load-data`) never fits bounds\n        // because no layer exists at load time, and `addLayerUpdater` does not\n        // center either — so fit here explicitly.\n        const addedLayer = ctx.getVisState().layers.find(l => l.id === newLayer.id);\n        const bounds = addedLayer ? findMapBounds([addedLayer]) : null;\n        if (bounds) {\n          ctx.dispatch(fitBounds(bounds));\n        }\n\n        const temporalFields = dataset.fields\n          ?.filter((f: any) => f.type === 'timestamp' || f.type === 'date')\n          .map((f: any) => f.name);\n        const hasTemporalFields = temporalFields && temporalFields.length > 0;\n\n        return {\n          success: true,\n          commandId: addLayerCommandId,\n          data: {\n            details: `Map layer ${newLayer.id} has been added to the map.`,\n            dateTimeColumns: hasTemporalFields ? temporalFields : undefined,\n            dateTimeHint: hasTemporalFields\n              ? `DateTime columns detected: ${temporalFields.join(\n                  ', '\n                )}. You can call addTimeFilter with one of these columns to enable time-range animation on the map.`\n              : undefined\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: addLayerCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Try to fix the error. If the error persists, ask the user to try with different parameters.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}