sagadeck 1.7.1 → 1.8.0

package/src/map-routing.js

@@ -0,0 +1,82 @@
+// Rotas pelas ruas e endereço de um ponto, para o editor do mapa (entrega 3) e as análises (entrega 5). Passam por
+// callService (src/map-services.js): identificação do sagadeck e "uma tentativa e para".
+//  - rota: OpenRouteService quando configurado com chave (a pé, de carro, de bicicleta; também isócronas) ou OSRM
+//    (padrão público; o servidor de demonstração só tem carro de forma garantida);
+//  - endereço de um ponto: Nominatim /reverse (ou compatível).
+import { loadMapConfig, mapaFile } from "./map-config.js";
+import { callService } from "./map-services.js";
+
+export const MODOS = { pe: "a pé", carro: "de carro", bicicleta: "de bicicleta" };
+const ORS_PROFILE = { pe: "foot-walking", carro: "driving-car", bicicleta: "cycling-regular" };
+const OSRM_PROFILE = { pe: "foot", carro: "driving", bicicleta: "bike" };
+
+const isORS = (r) => r && (r.provedor === "openrouteservice" || /openrouteservice/i.test(r.url || ""));
+
+// pontos: [[lat, lon], …] (2 ou mais). Devolve { coords: [[lon, lat], …], distancia (m), duracao (s), modo }
+export async function route(pontos, { modo = "pe", cfg = loadMapConfig(mapaFile()) } = {}) {
+  if (!Array.isArray(pontos) || pontos.length < 2) throw new Error("Rota: preciso de pelo menos dois pontos.");
+  const pts = pontos.map(([lat, lon]) => [Number(lat), Number(lon)]);
+  if (pts.some(([a, b]) => !Number.isFinite(a) || !Number.isFinite(b))) throw new Error("Rota: ponto sem coordenada.");
+  const r = cfg.rotas;
+  const m = MODOS[modo] ? modo : "pe";
+  if (isORS(r) && r.key) {
+    const base = (r.url || "https://api.openrouteservice.org").replace(/\/+$/, "");
+    const res = await callService("rotas", `${base}/v2/directions/${ORS_PROFILE[m]}/geojson`, {
+      method: "POST", cfg, headers: { Authorization: r.key, "Content-Type": "application/json", Accept: "application/json, application/geo+json" },
+      body: JSON.stringify({ coordinates: pts.map(([lat, lon]) => [lon, lat]) }),
+    });
+    const j = await res.json();
+    const f = j.features?.[0];
+    if (!f) throw new Error("Rota: o serviço não achou caminho entre os pontos.");
+    return { coords: f.geometry.coordinates, distancia: f.properties?.summary?.distance ?? 0, duracao: f.properties?.summary?.duration ?? 0, modo: m };
+  }
+  const base = (r?.url || "https://router.project-osrm.org").replace(/\/+$/, "");
+  const res = await callService("rotas", `${base}/route/v1/${OSRM_PROFILE[m]}/${pts.map(([lat, lon]) => `${lon},${lat}`).join(";")}?overview=full&geometries=geojson`, { cfg });
+  const j = await res.json();
+  const rt = j.routes?.[0];
+  if (!rt) throw new Error("Rota: o serviço não achou caminho entre os pontos.");
+  return { coords: rt.geometry.coordinates, distancia: rt.distance, duracao: rt.duration, modo: m };
+}
+
+// área alcançável em X minutos a partir de um ponto (só OpenRouteService): GeoJSON Polygon
+export async function isochrone([lat, lon], minutos, { modo = "pe", cfg = loadMapConfig(mapaFile()) } = {}) {
+  const r = cfg.rotas;
+  if (!isORS(r) || !r.key) throw new Error("Área alcançável precisa do OpenRouteService com chave (Configurar mapa).");
+  const base = (r.url || "https://api.openrouteservice.org").replace(/\/+$/, "");
+  const res = await callService("rotas", `${base}/v2/isochrones/${ORS_PROFILE[MODOS[modo] ? modo : "pe"]}`, {
+    method: "POST", cfg, headers: { Authorization: r.key, "Content-Type": "application/json", Accept: "application/json, application/geo+json" },
+    body: JSON.stringify({ locations: [[Number(lon), Number(lat)]], range: [Math.round(Number(minutos) * 60)], range_type: "time" }),
+  });
+  const j = await res.json();
+  const f = j.features?.[0];
+  if (!f) throw new Error("Área alcançável: o serviço não devolveu a área.");
+  return f.geometry;
+}
+
+// rastro de GPS tremido -> o caminho pelas ruas por onde passou (OSRM /match; com o OpenRouteService configurado
+// para rotas, o encaixe usa o OSRM público). pontos: [[lat, lon], …] (até 100). Devolve [[lon, lat], …]
+export async function matchTrace(pontos, { modo = "pe", cfg = loadMapConfig(mapaFile()) } = {}) {
+  const pts = pontos.slice(0, 100).map(([lat, lon]) => [Number(lat), Number(lon)]).filter(([a, b]) => Number.isFinite(a) && Number.isFinite(b));
+  if (pts.length < 2) throw new Error("Encaixar nas ruas: o rastro precisa de pelo menos dois pontos.");
+  const base = (!isORS(cfg.rotas) && cfg.rotas?.url ? cfg.rotas.url : "https://router.project-osrm.org").replace(/\/+$/, "");
+  const res = await callService("rotas", `${base}/match/v1/${OSRM_PROFILE[MODOS[modo] ? modo : "pe"]}/${pts.map(([lat, lon]) => `${lon},${lat}`).join(";")}?overview=full&geometries=geojson`, { cfg });
+  const j = await res.json();
+  const coords = (j.matchings || []).flatMap((m) => m.geometry?.coordinates || []);
+  if (coords.length < 2) throw new Error("Encaixar nas ruas: o serviço não achou as ruas desse rastro.");
+  return coords;
+}
+
+// endereço de um ponto (para preencher a coluna de endereço de um ponto novo)
+export async function reverseGeocode(lat, lon, { cfg = loadMapConfig(mapaFile()) } = {}) {
+  const g = cfg.geocoder;
+  const res = await callService("geocoder", `${g.url.replace(/\/+$/, "")}/reverse?format=jsonv2&lat=${Number(lat)}&lon=${Number(lon)}${g.key ? `&key=${encodeURIComponent(g.key)}` : ""}`, { cfg });
+  const j = await res.json();
+  return j?.display_name || "";
+}
+
+// distância em metros entre dois pontos [lat, lon] (haversine): a régua e o "mais próximo" (entrega 5)
+export function distance([lat1, lon1], [lat2, lon2]) {
+  const R = 6371008.8, rad = Math.PI / 180;
+  const a = Math.sin(((lat2 - lat1) * rad) / 2) ** 2 + Math.cos(lat1 * rad) * Math.cos(lat2 * rad) * Math.sin(((lon2 - lon1) * rad) / 2) ** 2;
+  return 2 * R * Math.asin(Math.sqrt(a));
+}

package/src/map-services.js

@@ -0,0 +1,60 @@
+// Chamadas aos serviços do mapa (endereço↔coordenada, busca de lugares, rotas), feitas pelo servidor do Studio com a
+// identificação do sagadeck (as políticas de uso pedem). Regras:
+//  - uma tentativa e para: erro de autorização ou bloqueio (401, 403, 407, 429, recusa, certificado, tempo esgotado)
+//    marca o serviço indisponível nesta execução, e nenhum pedido sai até alguém pedir "Tentar de novo";
+//  - sem teste proativo: o estado começa "não usado" e só muda com uso de verdade;
+//  - o estado de cada serviço vai para a IA (ela decide o que chamar) e para a tela Configurar mapa.
+import { loadMapConfig, mapaFile } from "./map-config.js";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const VERSION = (() => { try { return require("../package.json").version; } catch { return "?"; } })();
+export const USER_AGENT = `sagadeck/${VERSION} (+https://github.com/naruminho/sagadeck)`;
+export const SERVICES = { geocoder: "Endereço e coordenada", busca: "Busca de lugares", rotas: "Rotas" };
+
+const state = new Map(); // serviço -> { status: "ok" | "bloqueado", motivo, quando }
+export const serviceState = () => Object.fromEntries(Object.keys(SERVICES).map((k) => [k, state.get(k) || { status: "não usado" }]));
+export const resetService = (k) => (k ? state.delete(k) : state.clear());
+
+export class ServiceBlocked extends Error {
+  constructor(service, motivo) { super(`${SERVICES[service] || service}: ${motivo}`); this.service = service; this.motivo = motivo; this.code = "MAP_SERVICE_BLOCKED"; }
+}
+
+const hhmm = () => new Date().toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
+const BLOCK = { 401: "recusou a autorização (401)", 403: "recusou o acesso (403)", 407: "o proxy da rede pediu autenticação (407)", 429: "pediu para diminuir o ritmo (429)" };
+
+// um pedido a um serviço; se ele estiver bloqueado, nem tenta
+export async function callService(service, url, { method = "GET", headers = {}, body, timeoutMs = 15000, cfg = loadMapConfig(mapaFile()) } = {}) {
+  const st = state.get(service);
+  if (st?.status === "bloqueado") throw new ServiceBlocked(service, `${st.motivo}; não tentei de novo`);
+  let res;
+  try {
+    res = await fetch(url, { method, body, headers: { "User-Agent": USER_AGENT, Accept: "application/json", ...headers }, signal: AbortSignal.timeout(timeoutMs) });
+  } catch (e) {
+    const motivo = e.name === "TimeoutError" ? "não respondeu a tempo" : /certificate|self[- ]signed|CERT/i.test(String(e.cause?.message || e.message)) ? "o certificado foi barrado pela rede" : "não foi possível conectar (a rede pode estar bloqueando)";
+    state.set(service, { status: "bloqueado", motivo: `${motivo} às ${hhmm()}`, quando: Date.now() });
+    throw new ServiceBlocked(service, motivo);
+  }
+  if (BLOCK[res.status]) {
+    state.set(service, { status: "bloqueado", motivo: `${BLOCK[res.status]} às ${hhmm()}`, quando: Date.now() });
+    throw new ServiceBlocked(service, BLOCK[res.status]);
+  }
+  if (!res.ok) throw new Error(`${SERVICES[service] || service}: HTTP ${res.status}`);
+  state.set(service, { status: "ok", quando: Date.now() });
+  return res;
+}
+
+// ---------------------------------------------------------------------------------------------- endereço -> ponto
+// Nominatim (padrão) ou outro compatível com /search?format=jsonv2. Um pedido por vez, no ritmo do serviço
+// (porSegundo; o Nominatim público aceita 1). O cache é de quem chama (o projeto guarda o seu).
+export async function geocodeOne(q, { cfg = loadMapConfig(mapaFile()), signal } = {}) {
+  const g = cfg.geocoder;
+  const url = `${g.url.replace(/\/+$/, "")}/search?format=jsonv2&limit=1&addressdetails=0&q=${encodeURIComponent(q)}${g.key ? `&key=${encodeURIComponent(g.key)}` : ""}`;
+  if (signal?.aborted) throw new Error("cancelado");
+  const res = await callService("geocoder", url, { cfg });
+  const list = await res.json();
+  const hit = Array.isArray(list) ? list[0] : null;
+  return hit ? { lat: Number(hit.lat), lon: Number(hit.lon), nome: hit.display_name || "" } : null;
+}
+
+export const geocodeInterval = (cfg = loadMapConfig(mapaFile())) => Math.max(1, Math.ceil(1000 / Math.max(0.1, Number(cfg.geocoder?.porSegundo) || 1)));

package/src/map.js

@@ -0,0 +1,261 @@
+// Slide de mapa (layout: map). A planilha é a fonte, o mapa é a vista: cada camada lê um arquivo do projeto (CSV,
+// GeoJSON, GPX, KML) ou valores por estado/país, e vira GeoJSON com o estilo já decidido (cor por categoria ou por
+// valor, tamanho, rótulo, campos do cartão). Os dados vão dentro do HTML; o mapa ao vivo (src/runtime/map.js) desenha
+// com o Leaflet, e uma prévia em SVG (sem fundo) serve às miniaturas e de reserva.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseCSV } from "./csv.js";
+import { toNum } from "./science.js";
+
+const VENDOR = path.join(path.dirname(fileURLToPath(import.meta.url)), "runtime", "vendor");
+let contornos;
+export const geoContornos = () => (contornos ||= JSON.parse(fs.readFileSync(path.join(VENDOR, "geo-contornos.json"), "utf8")));
+
+// cores das categorias: a paleta do tema (o runtime resolve --s1…), na ordem
+// cores das categorias: a paleta do tema (c1…c5, as mesmas da tabela e dos gráficos), depois destaque e alerta
+export const MAP_COLORS = ["c1", "c2", "c3", "c4", "c5", "em", "hi", "alert"];
+// token de cor -> CSS: hex, paleta do tema (--c-c1… com recuo no destaque), ou variável do tom (s1, em, hi, fg…)
+export const mapColorCSS = (c) => (/^#?[0-9a-f]{6}$/i.test(c) ? `#${String(c).replace("#", "")}` : /^(c\d|accent|alert|ink|paper)$/.test(c) ? `var(--c-${c},var(--em))` : `var(--${c})`);
+const BASEMAPS = ["ruas", "claro", "escuro", "satelite", "nenhum"];
+
+const norm = (s) => String(s ?? "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+const LAT = ["lat", "latitude", "y"], LON = ["lon", "lng", "long", "longitude", "x"], COORD = ["coordenadas", "coordenada", "coords", "latlon", "latlong", "posicao", "localizacao"];
+const findCol = (cols, want, names) => {
+  if (want) { const i = cols.findIndex((c) => norm(c) === norm(want)); return i; }
+  return cols.findIndex((c) => names.includes(norm(c)));
+};
+
+// ---------------------------------------------------------------------------------------------- leitura dos arquivos
+function readText(file, ctx, what) {
+  const full = path.resolve(ctx?.baseDir || process.cwd(), String(file).trim());
+  try { return fs.readFileSync(full, "utf8"); }
+  catch { ctx?.warnings?.push(`mapa: ${what} "${file}" não encontrado ao lado do deck`); return null; }
+}
+
+// coordenada não tem separador de milhar: "-46.702" é -46,702 (o leitor de números da planilha leria -46702) e
+// "-23,55" é -23,55 (vírgula decimal)
+export function coordNum(v) {
+  if (typeof v === "number") return v;
+  const s = String(v ?? "").trim().replace(/\s/g, "");
+  return /^[+-]?\d+([.,]\d+)?$/.test(s) ? Number(s.replace(",", ".")) : NaN;
+}
+// "lat, lon" numa coluna só: "-23.55, -46.63", "-23,55; -46,63", "-23.55 -46.63"
+export function splitCoords(v) {
+  const s = String(v ?? "").trim();
+  const parts = s.includes(";") ? s.split(";") : /,\s/.test(s) ? s.split(/,\s+/) : /\s/.test(s) ? s.split(/\s+/) : s.split(",");
+  return parts.length === 2 ? parts.map(coordNum) : [NaN, NaN];
+}
+
+// planilha (CSV) -> pontos. Colunas de posição reconhecidas pelo nome (lat/latitude, lon/longitude) ou indicadas.
+export function pointsFromRows(head, rows, layer = {}, warn = () => {}) {
+  const iLat = findCol(head, layer.lat, LAT), iLon = findCol(head, layer.lon, LON);
+  const iCoord = iLat < 0 || iLon < 0 ? findCol(head, layer.coords, COORD) : -1;
+  if ((iLat < 0 || iLon < 0) && iCoord < 0) {
+    warn(`mapa: a planilha não tem colunas de posição (latitude e longitude); colunas: ${head.join(", ")}`);
+    return { features: [], missing: rows.length };
+  }
+  const features = [];
+  let missing = 0;
+  rows.forEach((r, n) => {
+    if (!r.some((c) => String(c ?? "").trim())) return; // linha vazia não é ponto sem posição
+    let lat, lon;
+    if (iCoord >= 0) [lat, lon] = splitCoords(r[iCoord]);
+    else { lat = coordNum(r[iLat]); lon = coordNum(r[iLon]); }
+    if (!Number.isFinite(lat) || !Number.isFinite(lon) || Math.abs(lat) > 90 || Math.abs(lon) > 180) { missing++; return; }
+    // as colunas de posição não vão para o cartão (a posição já é o ponto no mapa)
+    const props = Object.fromEntries(head.map((h, i) => [h, r[i] ?? ""]).filter(([h], i) => h !== "" && i !== iLat && i !== iLon && i !== iCoord));
+    features.push({ type: "Feature", properties: { ...props, _linha: n + 2 }, geometry: { type: "Point", coordinates: [lon, lat] } });
+  });
+  if (missing) warn(`mapa: ${missing} linha${missing === 1 ? "" : "s"} da planilha sem posição válida ficaram de fora`);
+  return { features, missing };
+}
+
+const attr = (xml, name) => xml.match(new RegExp(`\\b${name}\\s*=\\s*"([^"]*)"`))?.[1];
+const tag = (xml, name) => xml.match(new RegExp(`<${name}\\b[^>]*>([\\s\\S]*?)</${name}>`))?.[1]?.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1").trim();
+const tags = (xml, name) => [...xml.matchAll(new RegExp(`<${name}\\b[^>]*?(?:/>|>([\\s\\S]*?)</${name}>)`, "g"))].map((m) => m[0]);
+
+// GPX: trilhas e rotas viram linhas; pontos marcados (wpt) viram pontos
+export function fromGPX(xml) {
+  const pt = (s) => [Number(attr(s, "lon")), Number(attr(s, "lat"))];
+  const features = [];
+  for (const t of [...tags(xml, "trk"), ...tags(xml, "rte")]) {
+    const segs = tags(t, "trkseg").length ? tags(t, "trkseg").map((s) => tags(s, "trkpt").map(pt)) : [tags(t, "rtept").map(pt)];
+    const lines = segs.filter((l) => l.length > 1);
+    if (!lines.length) continue;
+    features.push({ type: "Feature", properties: { nome: tag(t, "name") || "" }, geometry: lines.length === 1 ? { type: "LineString", coordinates: lines[0] } : { type: "MultiLineString", coordinates: lines } });
+  }
+  for (const w of tags(xml, "wpt")) features.push({ type: "Feature", properties: { nome: tag(w, "name") || "" }, geometry: { type: "Point", coordinates: pt(w) } });
+  return features;
+}
+
+// KML: cada Placemark com nome, descrição e dados (ExtendedData); ponto, linha ou polígono (inclusive MultiGeometry)
+export function fromKML(xml) {
+  const coords = (s) => String(s || "").trim().split(/\s+/).map((c) => c.split(",").slice(0, 2).map(Number)).filter((c) => c.length === 2 && c.every(Number.isFinite));
+  const features = [];
+  for (const pm of tags(xml, "Placemark")) {
+    const props = { nome: tag(pm, "name") || "" };
+    const desc = tag(pm, "description"); if (desc) props.descricao = desc.replace(/<[^>]+>/g, " ").trim();
+    for (const d of tags(pm, "Data")) props[attr(d, "name") || "campo"] = tag(d, "value") || "";
+    for (const d of tags(pm, "SimpleData")) props[attr(d, "name") || "campo"] = d.replace(/<[^>]+>/g, "").trim();
+    const geoms = [
+      ...tags(pm, "Point").map((p) => ({ type: "Point", coordinates: coords(tag(p, "coordinates"))[0] })),
+      ...tags(pm, "LineString").map((l) => ({ type: "LineString", coordinates: coords(tag(l, "coordinates")) })),
+      ...tags(pm, "Polygon").map((p) => ({ type: "Polygon", coordinates: [coords(tag(tag(p, "outerBoundaryIs") || p, "coordinates")), ...tags(p, "innerBoundaryIs").map((b) => coords(tag(b, "coordinates")))] })),
+    ].filter((g) => g.coordinates && (g.type !== "Point" || g.coordinates.length === 2));
+    for (const g of geoms) features.push({ type: "Feature", properties: props, geometry: g });
+  }
+  return features;
+}
+
+function fromGeoJSON(obj) {
+  if (!obj || typeof obj !== "object") return [];
+  if (obj.type === "FeatureCollection") return (obj.features || []).filter((f) => f && f.geometry);
+  if (obj.type === "Feature") return obj.geometry ? [obj] : [];
+  if (obj.type && obj.coordinates) return [{ type: "Feature", properties: {}, geometry: obj }];
+  return [];
+}
+
+// valores por estado (sigla) ou país (código de 2 letras): o contorno embutido, pintado pelo valor
+function fromAreas(values, warn) {
+  const g = geoContornos();
+  const features = [];
+  for (const [k, v] of Object.entries(values || {})) {
+    const code = String(k).trim().toUpperCase();
+    const uf = g.uf[code], pais = g.paises[code];
+    if (!uf && !pais) { warn(`mapa: "${k}" não é uma UF (SP, RJ…) nem um país (BR, PT…)`); continue; }
+    const poly = uf || pais.poly;
+    features.push({ type: "Feature", properties: { nome: uf ? code : pais.nome, valor: v }, geometry: { type: "MultiPolygon", coordinates: poly } });
+  }
+  return features;
+}
+
+// ---------------------------------------------------------------------------------------------- estilo das camadas
+// cor: uma coluna (categoria -> cores da paleta; número -> escala da cor de destaque), uma cor fixa, ou nada
+function styleOf(features, layer, warn) {
+  const style = { color: null, colorBy: null, categories: null, scale: null, sizeBy: null, sizeScale: null, label: layer.label || null, popup: null, icon: layer.icon || null };
+  const props = features.map((f) => f.properties || {});
+  const has = (col) => col && props.some((p) => Object.hasOwn(p, col));
+  const by = layer.color ?? (layer.areas ? "valor" : null);
+  if (by && !has(by)) {
+    if (/^(#?[0-9a-f]{6}|s[1-5]|c\d|em|hi|alert|accent|fg|muted)$/i.test(String(by))) style.color = String(by);
+    else warn(`mapa: a camada "${layer.name || ""}" pinta pela coluna "${by}", que não existe`);
+  } else if (by) {
+    style.colorBy = by;
+    const vals = props.map((p) => p[by]);
+    const nums = vals.map(toNum).filter((n) => n != null);
+    if (nums.length === vals.filter((v) => String(v ?? "").trim() !== "").length && nums.length && !layer.colors) {
+      style.scale = { min: Math.min(...nums), max: Math.max(...nums) };
+    } else {
+      const order = [...new Set(vals.map((v) => String(v ?? "").trim()).filter(Boolean))];
+      const given = layer.colors && typeof layer.colors === "object" ? layer.colors : {};
+      if (order.length > MAP_COLORS.length && !Object.keys(given).length) warn(`mapa: "${by}" tem ${order.length} categorias; as cores se repetem a partir da ${MAP_COLORS.length + 1}ª (agrupe ou dê colors:)`);
+      style.categories = order.map((v, i) => ({ value: v, color: String(given[v] ?? MAP_COLORS[i % MAP_COLORS.length]) }));
+    }
+  }
+  if (layer.size) {
+    if (!has(layer.size)) warn(`mapa: a camada "${layer.name || ""}" usa a coluna "${layer.size}" para o tamanho, que não existe`);
+    else {
+      const nums = props.map((p) => toNum(p[layer.size])).filter((n) => n != null);
+      if (nums.length) { style.sizeBy = layer.size; style.sizeScale = { min: Math.min(...nums), max: Math.max(...nums) }; }
+    }
+  }
+  if (style.label && !has(style.label)) { warn(`mapa: a coluna "${style.label}" do rótulo não existe`); style.label = null; }
+  const cols = [...new Set(props.flatMap((p) => Object.keys(p)))].filter((c) => !c.startsWith("_"));
+  style.popup = Array.isArray(layer.popup) ? layer.popup.filter((c) => cols.includes(c)) : layer.popup === false ? [] : cols.slice(0, 8);
+  return style;
+}
+
+// ---------------------------------------------------------------------------------------------- o slide inteiro
+function bboxOf(layers) {
+  let s = 90, w = 180, n = -90, e = -180, any = false;
+  const visit = (c) => {
+    if (typeof c[0] === "number") { const [lon, lat] = c; if (Number.isFinite(lat) && Number.isFinite(lon)) { any = true; s = Math.min(s, lat); n = Math.max(n, lat); w = Math.min(w, lon); e = Math.max(e, lon); } return; }
+    c.forEach(visit);
+  };
+  for (const l of layers) for (const f of l.data.features) if (f.geometry?.coordinates) visit(f.geometry.coordinates);
+  return any ? [[s, w], [n, e]] : null;
+}
+
+const viewOf = (v) => {
+  if (v === "fit" || v === true) return "fit";
+  if (v && Array.isArray(v.center) && v.center.length === 2 && v.center.every(Number.isFinite)) return { center: v.center, zoom: Number.isFinite(v.zoom) ? v.zoom : 13 };
+  return null;
+};
+
+export function mapModel(s, ctx) {
+  const warn = (m) => ctx?.warnings?.push(m);
+  const list = Array.isArray(s.layers) ? s.layers : s.layers ? [s.layers] : [];
+  const layers = [];
+  list.forEach((layer, i) => {
+    if (!layer || typeof layer !== "object") return;
+    let features = [], kind = "shapes";
+    if (layer.points != null) {
+      kind = "points";
+      if (typeof layer.points === "string") {
+        const text = readText(layer.points, ctx, "planilha");
+        if (text != null) {
+          // sem tirar as linhas vazias: _linha é o número da linha na planilha (a seleção liga linha e ponto)
+          const { rows } = parseCSV(text);
+          features = pointsFromRows((rows[0] || []).map((h) => String(h).trim()), rows.slice(1), layer, warn).features;
+        }
+      } else if (Array.isArray(layer.points)) {
+        const rows = layer.points.filter((p) => p && typeof p === "object");
+        const head = [...new Set(rows.flatMap((p) => Object.keys(p)))];
+        features = pointsFromRows(head, rows.map((p) => head.map((h) => p[h] ?? "")), layer, warn).features;
+      }
+    } else if (layer.geojson) {
+      const text = readText(layer.geojson, ctx, "GeoJSON");
+      try { features = text == null ? [] : fromGeoJSON(JSON.parse(text)); } catch { warn(`mapa: "${layer.geojson}" não é um GeoJSON válido`); }
+    } else if (layer.gpx) {
+      const text = readText(layer.gpx, ctx, "GPX"); features = text == null ? [] : fromGPX(text);
+    } else if (layer.kml) {
+      const text = readText(layer.kml, ctx, "KML"); features = text == null ? [] : fromKML(text);
+    } else if (layer.areas) {
+      kind = "areas"; features = fromAreas(layer.areas, warn);
+    } else { warn(`mapa: a camada ${i + 1} não diz de onde vêm os dados (points, geojson, gpx, kml ou areas)`); return; }
+    if (!features.length && layer.areas == null) warn(`mapa: a camada "${layer.name || i + 1}" ficou vazia`);
+    const step = layer.step ?? (s.build ? i + 1 : undefined);
+    layers.push({
+      name: layer.name || layer.title || `Camada ${i + 1}`, kind,
+      source: typeof layer.points === "string" ? layer.points.trim() : layer.geojson || layer.gpx || layer.kml || null, step: Number.isFinite(Number(step)) ? Number(step) : undefined,
+      view: viewOf(layer.view), legend: layer.legend || null, prefix: layer.prefix || "", suffix: layer.suffix || "",
+      style: styleOf(features, layer, warn), data: { type: "FeatureCollection", features },
+    });
+  });
+  const basemap = BASEMAPS.includes(s.basemap) ? s.basemap : "ruas";
+  if (s.basemap && !BASEMAPS.includes(s.basemap)) warn(`mapa: fundo "${s.basemap}" não existe (use ${BASEMAPS.join(", ")})`);
+  return { basemap, view: viewOf(s.view), bounds: bboxOf(layers), layers, tiles: ctx?.mapTiles || null };
+}
+
+// ---------------------------------------------------------------------------------------------- prévia sem fundo
+// SVG das camadas em Web Mercator, enquadradas: miniaturas do Studio (sem pedir tile nenhum) e reserva se o mapa ao
+// vivo não montar
+const merc = ([lon, lat]) => { const y = Math.log(Math.tan(Math.PI / 4 + (Math.max(-85, Math.min(85, lat)) * Math.PI) / 360)); return [lon / 360, -y / (2 * Math.PI)]; };
+export function mapPreviewSVG(model, w = 1600, h = 760) {
+  if (!model.bounds) return `<svg class="map-preview" viewBox="0 0 ${w} ${h}" aria-hidden="true"></svg>`;
+  const [[s, wst], [n, e]] = model.bounds;
+  const [x0, y1] = merc([wst, s]), [x1, y0] = merc([e, n]);
+  const pad = 0.08, bw = Math.max(x1 - x0, 1e-6), bh = Math.max(y1 - y0, 1e-6);
+  const k = Math.min(w / (bw * (1 + 2 * pad)), h / (bh * (1 + 2 * pad)));
+  const ox = w / 2 - ((x0 + x1) / 2) * k, oy = h / 2 - ((y0 + y1) / 2) * k;
+  const P = (c) => { const [x, y] = merc(c); return `${(x * k + ox).toFixed(1)},${(y * k + oy).toFixed(1)}`; };
+  const out = [];
+  const color = (layer, f) => {
+    const st = layer.style, v = st.colorBy ? f.properties?.[st.colorBy] : null;
+    const cat = st.categories?.find((c) => c.value === String(v ?? "").trim());
+    return mapColorCSS(cat?.color || st.color || "c1");
+  };
+  for (const layer of model.layers) for (const f of layer.data.features) {
+    const g = f.geometry, col = color(layer, f);
+    const lines = (cs) => cs.map((l) => `M${l.map(P).join("L")}`).join("");
+    if (g.type === "Point") { const [x, y] = P(g.coordinates).split(","); out.push(`<circle cx="${x}" cy="${y}" r="9" fill="${col}" stroke="var(--bg)" stroke-width="3"/>`); }
+    else if (g.type === "LineString") out.push(`<path d="${lines([g.coordinates])}" fill="none" stroke="${col}" stroke-width="5"/>`);
+    else if (g.type === "MultiLineString") out.push(`<path d="${lines(g.coordinates)}" fill="none" stroke="${col}" stroke-width="5"/>`);
+    else if (g.type === "Polygon") out.push(`<path d="${lines(g.coordinates)}Z" fill="${col}" fill-opacity=".35" stroke="${col}" stroke-width="2"/>`);
+    else if (g.type === "MultiPolygon") out.push(`<path d="${g.coordinates.map((p) => lines(p) + "Z").join("")}" fill="${col}" fill-opacity=".35" stroke="${col}" stroke-width="2"/>`);
+  }
+  return `<svg class="map-preview" viewBox="0 0 ${w} ${h}" preserveAspectRatio="xMidYMid meet" aria-hidden="true">${out.join("")}</svg>`;
+}
+
+export const mapSummary = (model) => model.layers.map((l) => `${l.name}: ${l.data.features.length}`).join(" · ");

package/src/runtime/base.css

@@ -1775,3 +1775,23 @@ html[data-orient="portrait"] .adaptive:is([data-item-count="1"],[data-item-count
 
 /* Figuras informativas dominam a composição; texto auxilia a leitura. */
 .L-split.sp-stacked{flex-direction:column;gap:20px}.sp-stacked>.hd{flex:0 0 auto}.sp-stacked>.hd .ttl{font-size:64px}.sp-stacked>.sp-fig{flex:1;min-height:0}.sp-stacked>.sp-summary{flex:0 0 auto;display:flex;gap:32px}.sp-summary>.t,.sp-summary>.list{flex:1;margin:0}.sp-stacked .sp-fig>.fig{min-height:0}
+/* mapa (layout: map; src/map.js e src/runtime/map.js): prévia SVG por baixo, o Leaflet por cima quando monta */
+.L-map{flex:1 0 auto;display:flex;flex-direction:column;gap:24px}.L-map>.hd,.L-map>.map-caption{flex:none}
+.map-box{position:relative;flex:1;min-height:420px;border-radius:var(--radius);overflow:hidden;background:color-mix(in srgb,var(--fg) 5%,var(--surface));border:1px solid var(--line)}
+.map-preview,.map-live{position:absolute;inset:0;width:100%;height:100%}
+.map-box[data-map-mounted="ready"] .map-preview{display:none}
+.map-live{background:transparent;font:inherit}.map-live .leaflet-container{font:inherit}
+.map-box[data-basemap="claro"] .leaflet-tile-pane{filter:grayscale(1) contrast(.92) brightness(1.06)}
+.map-box[data-basemap="escuro"] .leaflet-tile-pane{filter:invert(1) hue-rotate(180deg) grayscale(.55) brightness(.92) contrast(.9)}
+.map-legend{position:absolute;left:18px;bottom:18px;z-index:500;display:flex;flex-direction:column;gap:10px;max-width:46%;max-height:70%;overflow:auto;padding:14px 18px;border-radius:calc(var(--radius) * .6);background:color-mix(in srgb,var(--bg) 90%,transparent);color:var(--fg);font-size:20px;box-shadow:0 6px 24px rgb(0 0 0/.14)}
+.map-legend button{all:unset;cursor:pointer;display:inline-flex;align-items:center;gap:8px;margin:2px 14px 2px 0}.map-legend button.off,.map-leg-layer.off .map-leg-name{opacity:.38;text-decoration:line-through}
+.map-leg-name{font-weight:700}.map-leg-name small{font-weight:400;color:var(--muted)}.map-legend i{display:inline-block;width:16px;height:16px;border-radius:50%;flex:none}
+.map-leg-scale{display:flex;align-items:center;gap:8px;font-size:17px;color:var(--muted)}.map-leg-scale i{width:120px;height:10px;border-radius:5px}
+.map-notice{position:absolute;top:16px;left:50%;transform:translateX(-50%);z-index:600;display:flex;align-items:center;gap:12px;padding:8px 14px;border-radius:999px;background:var(--fg);color:var(--bg);font-size:17px;white-space:nowrap}
+.map-notice button{all:unset;cursor:pointer;text-decoration:underline}
+.map-label{font:600 22px/1.2 var(--font-body,inherit);background:color-mix(in srgb,var(--bg) 92%,transparent);color:var(--fg);border:0;box-shadow:0 2px 8px rgb(0 0 0/.18);padding:3px 8px}
+.map-label::before{display:none}
+.map-card .leaflet-popup-content-wrapper{border-radius:calc(var(--radius) * .6);background:var(--bg);color:var(--fg)}.map-card .leaflet-popup-tip{background:var(--bg)}
+.map-card-in{font-size:18px;line-height:1.35}.map-card-in b{display:block;font-size:21px;margin-bottom:6px}.map-card-in table{border-collapse:collapse}.map-card-in th{text-align:left;font-weight:600;color:var(--muted);padding:2px 12px 2px 0}.map-card-in td{padding:2px 0}
+.map-box .leaflet-control-attribution{font-size:13px;background:color-mix(in srgb,var(--bg) 82%,transparent);color:var(--muted)}.map-box .leaflet-control-attribution a{color:inherit}
+.export .map-box .leaflet-control-zoom,.export .map-notice button{display:none}