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

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

@@ -0,0 +1,534 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addLayerCommandId = void 0;
+exports.getAddLayerCommand = getAddLayerCommand;
+exports.guessDefaultLayer = guessDefaultLayer;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _zod = require("zod");
+var _constants = require("@kepler.gl/constants");
+var _layers = require("@kepler.gl/layers");
+var _reducers = require("@kepler.gl/reducers");
+var _actions = require("@kepler.gl/actions");
+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) { (0, _defineProperty2["default"])(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
+/**
+ * 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));
+}
+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 _layers.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 _layers.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 _layers.LayerClasses.cluster(_props2[0]);
+      return _layer3;
+    }
+  } else if (layerType === 'trip') {
+    var layers = (0, _reducers.findDefaultLayer)(dataset, [_layers.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 _layers.LayerClasses.flow({
+      isVisible: true,
+      label: "".concat(pairs[0].defaultName, " -> ").concat(pairs[1].defaultName, " flow"),
+      columns: columns
+    });
+    return _layer5;
+  }
+  var defaultLayers = (0, _reducers.findDefaultLayer)(dataset, _layers.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' || _constants.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 _layers.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 = (0, _toConsumableArray2["default"])(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;
+      }
+    }
+  }
+}
+var addLayerCommandId = exports.addLayerCommandId = 'map.add-layer';
+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: _zod.z.object({
+      datasetName: _zod.z.string().describe('The name (label) or id of the dataset. Prefer the label when known.'),
+      latitudeColumn: _zod.z.string().optional(),
+      longitudeColumn: _zod.z.string().optional(),
+      layerName: _zod.z.string().optional().describe('Generate a unique name for the layer based on the context.'),
+      layerType: _zod.z["enum"](['point', 'flow', 'flowField', 'arc', 'line', 'grid', 'hexagon', 'geojson', 'cluster', 'heatmap', 'h3', 'trip', 's2']),
+      flowField: _zod.z.object({
+        mode: _zod.z["enum"](FLOW_FIELD_MODES).optional(),
+        uColumn: _zod.z.string().optional(),
+        vColumn: _zod.z.string().optional(),
+        speedColumn: _zod.z.string().optional(),
+        directionColumn: _zod.z.string().optional(),
+        altitudeColumn: _zod.z.string().optional(),
+        colorBySpeed: _zod.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: _zod.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: _zod.z.string().optional(),
+      colorType: _zod.z["enum"](['breaks', 'unique']).optional(),
+      countColumn: _zod.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: _zod.z.array(_zod.z.object({
+        value: _zod.z.union([_zod.z.string(), _zod.z.number(), _zod.z["null"]()]),
+        color: _zod.z.string()
+      })).optional()
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].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 _regenerator["default"].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((0, _actions.addLayer)(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 ? (0, _reducers.findMapBounds)([addedLayer]) : null;
+              if (bounds) {
+                ctx.dispatch((0, _actions.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":["_zod","require","_constants","_layers","_reducers","_actions","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","uniqueLayerId","prefix","undefined","concat","Date","now","Math","random","toString","slice","guessDefaultLayer","dataset","layerType","options","fieldPairs","props","map","fieldPair","isVisible","label","columns","pair","layer","LayerClasses","heatmap","hexagon","cluster","layers","findDefaultLayer","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_FIELDS","geojson","includes","altitudeName","altitudeColumn","mode","uColumn","vColumn","speedColumn","directionColumn","flowColumns","u","v","speed","direction","altitude","flowField","color","columnMode","colorBySpeed","config","visConfig","buildLayerConfig","datasetId","layerName","sourceName","_layer$config","_layer$config2","layerId","id","dataId","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","missing","_toConsumableArray2","JSON","stringify","colorScale","colorRange","category","colors","addLayerCommandId","exports","getAddLayerCommand","ctx","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","z","object","datasetName","string","describe","optional","array","union","number","execute","_execute","_asyncToGenerator2","_regenerator","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","addLayerAction","findMapBounds","fitBounds","abrupt","success","commandId","data","details","dateTimeColumns","dateTimeHint","t0","error","message","instruction","stop","_x","_x2"],"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":[]}