@caoguo/maplibre-pipeline 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2295 @@
+'use strict';
+
+// src/types/index.ts
+var PIPELINE_TYPES = [
+  "gas",
+  "water",
+  "drainage",
+  "heating",
+  "power",
+  "telecom"
+];
+
+// src/style/pipelineTheme.ts
+var PIPELINE_TYPE_COLORS = {
+  gas: "#f59e0b",
+  // 琥珀（燃气）
+  water: "#3b82f6",
+  // 蓝（供水）
+  drainage: "#6b7280",
+  // 灰（排水）
+  heating: "#ef4444",
+  // 红（供热）
+  power: "#8b5cf6",
+  // 紫（电力管沟）
+  telecom: "#10b981"
+  // 绿（通信管沟）
+};
+var PIPELINE_TYPE_LABELS = {
+  gas: "\u71C3\u6C14\u7BA1",
+  water: "\u4F9B\u6C34\u7BA1",
+  drainage: "\u6392\u6C34\u7BA1",
+  heating: "\u4F9B\u70ED\u7BA1",
+  power: "\u7535\u529B\u7BA1\u6C9F",
+  telecom: "\u901A\u4FE1\u7BA1\u6C9F"
+};
+var PIPELINE_TYPE_ICONS = {
+  gas: "\u{1F525}",
+  water: "\u{1F4A7}",
+  drainage: "\u{1F6B0}",
+  heating: "\u{1F534}",
+  power: "\u26A1",
+  telecom: "\u{1F4E1}"
+};
+var PIPE_STATUS_COLORS = {
+  normal: "#4ade80",
+  // 绿
+  aging: "#fbbf24",
+  // 黄
+  damaged: "#ef4444",
+  // 红
+  under_repair: "#8b5cf6",
+  // 紫
+  abandoned: "#4b5563",
+  // 深灰
+  unknown: "#6b7280"
+  // 灰
+};
+var PIPE_STATUS_META = {
+  normal: { label: "\u6B63\u5E38", animation: "none" },
+  aging: { label: "\u8001\u5316", animation: "none" },
+  damaged: { label: "\u635F\u574F", animation: "pulse" },
+  under_repair: { label: "\u7EF4\u4FEE\u4E2D", animation: "dashed" },
+  abandoned: { label: "\u5E9F\u5F03", animation: "none" },
+  unknown: { label: "\u672A\u77E5", animation: "none" }
+};
+var PIPE_MATERIAL_COLORS = {
+  cast_iron: "#94a3b8",
+  // 蓝灰（旧铸铁）
+  ductile_iron: "#0ea5e9",
+  // 天蓝（球墨铸铁）
+  steel: "#64748b",
+  // 钢蓝
+  pe: "#22c55e",
+  // 绿（PE 现代管材）
+  pvc: "#a78bfa",
+  // 紫（PVC）
+  concrete: "#a8a29e",
+  // 米灰（混凝土）
+  hdpe: "#16a34a",
+  // 深绿（HDPE）
+  copper: "#d97706",
+  // 橙（铜）
+  unknown: "#6b7280"
+};
+var NODE_KIND_ICONS = {
+  junction: "M -6 0 L 6 0 M 0 -6 L 0 6",
+  // 十字
+  valve: "M -8 -4 L 8 4 M 0 -4 L 0 4",
+  // X
+  pump: "M -6 0 A 6 6 0 1 0 6 0 A 6 6 0 1 0 -6 0",
+  // 圆
+  meter: "M -6 -6 L 6 -6 L 6 6 L -6 6 Z",
+  // 方
+  source: "M 0 -10 L 6 6 L -6 6 Z",
+  // 三角
+  tank: "M -8 -6 Q 0 -10 8 -6 L 8 6 L -8 6 Z",
+  // 圆角
+  junction_box: "M -7 -4 L 7 -4 L 7 4 L -7 4 Z"
+  // 小方
+};
+var NODE_KIND_COLORS = {
+  junction: "#94a3b8",
+  valve: "#ef4444",
+  // 阀门=红（控制关键）
+  pump: "#f59e0b",
+  meter: "#3b82f6",
+  source: "#22c55e",
+  tank: "#06b6d4",
+  junction_box: "#8b5cf6"
+};
+var HEALTH_LEVEL_COLORS = {
+  excellent: "#22c55e",
+  // 绿 80-100
+  good: "#3b82f6",
+  // 蓝 60-80
+  fair: "#eab308",
+  // 黄 40-60
+  poor: "#f97316",
+  // 橙 20-40
+  critical: "#ef4444"
+  // 红 0-20
+};
+var HEALTH_LEVEL_LABELS = {
+  excellent: "\u4F18",
+  good: "\u826F",
+  fair: "\u4E2D",
+  poor: "\u5DEE",
+  critical: "\u5371"
+};
+function healthLevel(score) {
+  if (score >= 80) return "excellent";
+  if (score >= 60) return "good";
+  if (score >= 40) return "fair";
+  if (score >= 20) return "poor";
+  return "critical";
+}
+function pipelineTypeColor(type) {
+  if (!type) return "#94a3b8";
+  return PIPELINE_TYPE_COLORS[type];
+}
+
+// src/style/paintRules.ts
+function paintPipeByType(types) {
+  if (!types || types.length === 0) {
+    return [
+      "match",
+      ["get", "pipelineType"],
+      ...Object.entries(PIPELINE_TYPE_COLORS).flatMap(([k, v]) => [k, v]),
+      "#94a3b8"
+    ];
+  }
+  return [
+    "match",
+    ["get", "pipelineType"],
+    ...types.flatMap((t) => [t, PIPELINE_TYPE_COLORS[t]]),
+    "#94a3b8"
+  ];
+}
+function paintPipeByDiameter() {
+  return [
+    "interpolate",
+    ["linear"],
+    ["coalesce", ["get", "diameter"], 0],
+    0,
+    "#4ade80",
+    // 极细管  绿
+    50,
+    "#4ade80",
+    // DN50 以下  绿（支管）
+    150,
+    "#60a5fa",
+    // DN150 蓝（配水管）
+    300,
+    "#f59e0b",
+    // DN300 黄（干管）
+    600,
+    "#ef4444",
+    // DN600+ 红（主管）
+    1500,
+    "#7f1d1d"
+    // 极大管  深红
+  ];
+}
+function paintPipeByStatus() {
+  return [
+    "match",
+    ["coalesce", ["get", "status"], "unknown"],
+    ...Object.entries(PIPE_STATUS_COLORS).flatMap(([k, v]) => [k, v]),
+    "#6b7280"
+  ];
+}
+function paintPipeByMaterial() {
+  return [
+    "match",
+    ["coalesce", ["get", "material"], "unknown"],
+    ...Object.entries(PIPE_MATERIAL_COLORS).flatMap(([k, v]) => [k, v]),
+    "#6b7280"
+  ];
+}
+function paintPipeByHealth() {
+  return [
+    "step",
+    ["coalesce", ["get", "healthScore"], 100],
+    HEALTH_LEVEL_COLORS.critical,
+    // <20
+    20,
+    HEALTH_LEVEL_COLORS.poor,
+    40,
+    HEALTH_LEVEL_COLORS.fair,
+    60,
+    HEALTH_LEVEL_COLORS.good,
+    80,
+    HEALTH_LEVEL_COLORS.excellent
+  ];
+}
+function paintPipeBy(mode, opts) {
+  switch (mode) {
+    case "type":
+      return paintPipeByType(opts?.types);
+    case "diameter":
+      return paintPipeByDiameter();
+    case "status":
+      return paintPipeByStatus();
+    case "material":
+      return paintPipeByMaterial();
+    case "health":
+      return paintPipeByHealth();
+    case "uniform":
+    default:
+      return "#60a5fa";
+  }
+}
+function paintNodeByKind() {
+  return [
+    "match",
+    ["get", "kind"],
+    "junction",
+    "#94a3b8",
+    "valve",
+    "#ef4444",
+    "pump",
+    "#f59e0b",
+    "meter",
+    "#3b82f6",
+    "source",
+    "#22c55e",
+    "tank",
+    "#06b6d4",
+    "junction_box",
+    "#8b5cf6",
+    "#cbd5e1"
+  ];
+}
+function paintPipeWidthByDiameter(minWidth = 1.5, maxWidth = 6) {
+  return [
+    "interpolate",
+    ["linear"],
+    ["coalesce", ["get", "diameter"], 100],
+    0,
+    minWidth,
+    1500,
+    maxWidth
+  ];
+}
+
+// src/style/legend.ts
+function legendByType() {
+  return {
+    title: "\u7BA1\u7EBF\u7C7B\u578B",
+    items: Object.keys(PIPELINE_TYPE_COLORS).map((k) => ({
+      label: PIPELINE_TYPE_LABELS[k],
+      color: PIPELINE_TYPE_COLORS[k]
+    }))
+  };
+}
+function legendByDiameter() {
+  return {
+    title: "\u7BA1\u5F84\uFF08mm\uFF09",
+    items: [
+      { label: "\u226450  \u652F\u7BA1", color: "#4ade80" },
+      { label: "50-150  \u914D\u6C34/\u914D\u6C14", color: "#60a5fa" },
+      { label: "150-300  \u5E72\u7BA1", color: "#f59e0b" },
+      { label: "300-600  \u4E3B\u7BA1", color: "#ef4444" },
+      { label: "\u2265600  \u4E3B\u5E72", color: "#7f1d1d" }
+    ]
+  };
+}
+function legendByStatus() {
+  return {
+    title: "\u7BA1\u6BB5\u72B6\u6001",
+    items: Object.keys(PIPE_STATUS_COLORS).map(
+      (k) => {
+        const meta = PIPE_STATUS_META[k];
+        return {
+          label: meta.label,
+          color: PIPE_STATUS_COLORS[k],
+          style: meta.animation === "dashed" ? "dashed" : "solid"
+        };
+      }
+    )
+  };
+}
+function legendByMaterial() {
+  return {
+    title: "\u7BA1\u6750",
+    items: Object.entries(PIPE_MATERIAL_COLORS).map(([k, v]) => ({
+      label: materialLabel(k),
+      color: v
+    }))
+  };
+}
+function legendByHealth() {
+  return {
+    title: "\u5065\u5EB7\u7B49\u7EA7",
+    items: Object.entries(HEALTH_LEVEL_COLORS).map(([k, v]) => ({
+      label: `${HEALTH_LEVEL_LABELS[k]}\uFF08${healthRangeLabel(k)}\uFF09`,
+      color: v
+    }))
+  };
+}
+function materialLabel(k) {
+  const map = {
+    cast_iron: "\u94F8\u94C1",
+    ductile_iron: "\u7403\u58A8\u94F8\u94C1",
+    steel: "\u94A2",
+    pe: "PE",
+    pvc: "PVC",
+    concrete: "\u6DF7\u51DD\u571F",
+    hdpe: "HDPE",
+    copper: "\u94DC",
+    unknown: "\u672A\u77E5"
+  };
+  return map[k] ?? k;
+}
+function healthRangeLabel(k) {
+  const map = {
+    excellent: "80-100",
+    good: "60-80",
+    fair: "40-60",
+    poor: "20-40",
+    critical: "0-20"
+  };
+  return map[k] ?? "";
+}
+function buildLegend(mode) {
+  switch (mode) {
+    case "type":
+      return legendByType();
+    case "diameter":
+      return legendByDiameter();
+    case "status":
+      return legendByStatus();
+    case "material":
+      return legendByMaterial();
+    case "health":
+      return legendByHealth();
+    default:
+      return legendByType();
+  }
+}
+
+// src/graph/adjacency.ts
+function buildAdjacency(dataset) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const node of dataset.nodes) {
+    if (!adj.has(node.id)) adj.set(node.id, []);
+  }
+  for (const pipe of dataset.pipes) {
+    const len = pipe.length ?? pipeLengthFromGeometry(pipe, dataset.nodes) ?? 0;
+    const fromList = adj.get(pipe.fromNode) ?? [];
+    fromList.push({
+      pipeId: pipe.id,
+      to: pipe.toNode,
+      length: len
+    });
+    adj.set(pipe.fromNode, fromList);
+    const toList = adj.get(pipe.toNode) ?? [];
+    toList.push({
+      pipeId: pipe.id,
+      to: pipe.fromNode,
+      length: len
+    });
+    adj.set(pipe.toNode, toList);
+  }
+  return adj;
+}
+function pipeLengthFromGeometry(pipe, nodes) {
+  if (pipe.length && pipe.length > 0) return pipe.length;
+  if (pipe.geometry && pipe.geometry.length >= 2) {
+    let total = 0;
+    for (let i = 1; i < pipe.geometry.length; i++) {
+      total += haversine(
+        pipe.geometry[i - 1][0],
+        pipe.geometry[i - 1][1],
+        pipe.geometry[i][0],
+        pipe.geometry[i][1]
+      );
+    }
+    return total;
+  }
+  const from = nodes.find((n) => n.id === pipe.fromNode);
+  const to = nodes.find((n) => n.id === pipe.toNode);
+  if (!from || !to) return 0;
+  return haversine(from.lng, from.lat, to.lng, to.lat);
+}
+function haversine(lng1, lat1, lng2, lat2) {
+  const R = 6371e3;
+  const toRad = (d) => d * Math.PI / 180;
+  const dLat = toRad(lat2 - lat1);
+  const dLng = toRad(lng2 - lng1);
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) ** 2;
+  return 2 * R * Math.asin(Math.sqrt(a));
+}
+function neighborIds(adj, nodeId) {
+  const list = adj.get(nodeId) ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of list) {
+    if (!seen.has(e.to)) {
+      seen.add(e.to);
+      out.push(e.to);
+    }
+  }
+  return out;
+}
+function edgesOf(adj, nodeId) {
+  return adj.get(nodeId) ?? [];
+}
+
+// src/graph/bfs.ts
+function bfs(adj, start, opts = {}) {
+  const visited = [];
+  const parents = /* @__PURE__ */ new Map();
+  const visitedSet = /* @__PURE__ */ new Set();
+  if (!adj.has(start)) {
+    parents.set(start, null);
+    return { visited, parents, start };
+  }
+  if (opts.allowStart && !opts.allowStart(start)) {
+    return { visited: [], parents, start };
+  }
+  const queue = [{ id: start, depth: 0 }];
+  parents.set(start, null);
+  visitedSet.add(start);
+  visited.push(start);
+  let foundEnd;
+  while (queue.length > 0) {
+    const { id, depth } = queue.shift();
+    if (opts.until && opts.until(id)) {
+      foundEnd = id;
+      break;
+    }
+    if (opts.maxDepth !== void 0 && depth >= opts.maxDepth) continue;
+    const edges = adj.get(id) ?? [];
+    for (const e of edges) {
+      if (opts.allowEdge && !opts.allowEdge(e, id, e.to)) continue;
+      if (visitedSet.has(e.to)) continue;
+      visitedSet.add(e.to);
+      parents.set(e.to, id);
+      visited.push(e.to);
+      queue.push({ id: e.to, depth: depth + 1 });
+    }
+  }
+  return { visited, parents, start, end: foundEnd };
+}
+function multiSourceBfs(adj, starts, opts = {}) {
+  const visited = [];
+  const parents = /* @__PURE__ */ new Map();
+  const sourceMap = /* @__PURE__ */ new Map();
+  const visitedSet = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const s of starts) {
+    if (!adj.has(s)) continue;
+    if (opts.allowStart && !opts.allowStart(s)) continue;
+    if (!visitedSet.has(s)) {
+      visitedSet.add(s);
+      parents.set(s, null);
+      sourceMap.set(s, s);
+      visited.push(s);
+      queue.push({ id: s, depth: 0 });
+    }
+  }
+  while (queue.length > 0) {
+    const { id, depth } = queue.shift();
+    if (opts.maxDepth !== void 0 && depth >= opts.maxDepth) continue;
+    const edges = adj.get(id) ?? [];
+    for (const e of edges) {
+      if (opts.allowEdge && !opts.allowEdge(e, id, e.to)) continue;
+      if (visitedSet.has(e.to)) continue;
+      visitedSet.add(e.to);
+      parents.set(e.to, id);
+      sourceMap.set(e.to, sourceMap.get(id));
+      visited.push(e.to);
+      queue.push({ id: e.to, depth: depth + 1 });
+    }
+  }
+  return { visited, parents, start: starts[0] ?? "", sourceMap };
+}
+function reconstructPath(parents, end) {
+  const path = [];
+  let cur = end;
+  while (cur) {
+    path.unshift(cur);
+    const p = parents.get(cur);
+    cur = p ?? null;
+    if (cur === null && p === null) {
+      if (parents.get(end) === null && path.length === 1) break;
+      break;
+    }
+  }
+  if (path[0] !== end) ;
+  return path;
+}
+
+// src/graph/dfs.ts
+function dfs(adj, start, opts = {}) {
+  const visited = [];
+  const parents = /* @__PURE__ */ new Map();
+  const visitedSet = /* @__PURE__ */ new Set();
+  let truncated = false;
+  if (!adj.has(start)) {
+    return { visited, parents, truncated };
+  }
+  if (opts.allowStart && !opts.allowStart(start)) {
+    return { visited, parents, truncated };
+  }
+  const stack = [{ id: start, depth: 0 }];
+  parents.set(start, null);
+  visitedSet.add(start);
+  while (stack.length > 0) {
+    const { id, depth } = stack.pop();
+    visited.push(id);
+    if (opts.maxDepth !== void 0 && depth >= opts.maxDepth) {
+      truncated = true;
+      continue;
+    }
+    const edges = adj.get(id) ?? [];
+    for (let i = edges.length - 1; i >= 0; i--) {
+      const e = edges[i];
+      if (opts.allowEdge && !opts.allowEdge(e, id, e.to)) continue;
+      if (visitedSet.has(e.to)) continue;
+      visitedSet.add(e.to);
+      parents.set(e.to, id);
+      stack.push({ id: e.to, depth: depth + 1 });
+    }
+  }
+  return { visited, parents, truncated };
+}
+function detectCycles(adj) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const node of adj.keys()) {
+    if (visited.has(node)) continue;
+    stack.push({
+      id: node,
+      iter: (adj.get(node) ?? [])[Symbol.iterator]()
+    });
+    onStack.add(node);
+    visited.add(node);
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      const next = top.iter.next();
+      if (next.done) {
+        onStack.delete(top.id);
+        stack.pop();
+        continue;
+      }
+      const nextId = next.value.to;
+      if (onStack.has(nextId)) {
+        const cycle = [nextId];
+        for (let i = stack.length - 1; i >= 0; i--) {
+          cycle.push(stack[i].id);
+          if (stack[i].id === nextId) break;
+        }
+        cycle.reverse();
+        if (new Set(cycle).size >= 3) cycles.push(cycle);
+      } else if (!visited.has(nextId)) {
+        visited.add(nextId);
+        onStack.add(nextId);
+        stack.push({
+          id: nextId,
+          iter: (adj.get(nextId) ?? [])[Symbol.iterator]()
+        });
+      }
+    }
+  }
+  return cycles;
+}
+
+// src/graph/connectivity.ts
+function findConnectedComponents(adj, nodes) {
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  const kindById = /* @__PURE__ */ new Map();
+  for (const n of nodes) kindById.set(n.id, n.kind);
+  for (const nodeId of adj.keys()) {
+    if (visited.has(nodeId)) continue;
+    const r = bfs(adj, nodeId);
+    let hasSource = false;
+    for (const id of r.visited) {
+      visited.add(id);
+      if (kindById.get(id) === "source") hasSource = true;
+    }
+    components.push({
+      nodes: r.visited,
+      size: r.visited.length,
+      hasSource
+    });
+  }
+  return components;
+}
+function findPaths(adj, start, end, opts = {}) {
+  const maxPaths = opts.maxPaths ?? 3;
+  const maxDepth = opts.maxDepth ?? 20;
+  const all = [];
+  const path = [];
+  const onPath = /* @__PURE__ */ new Set();
+  const dfsLocal = (cur) => {
+    if (all.length >= maxPaths) return;
+    if (cur === end) {
+      all.push([...path]);
+      return;
+    }
+    if (path.length >= maxDepth) return;
+    onPath.add(cur);
+    path.push(cur);
+    const edges = adj.get(cur) ?? [];
+    for (const e of edges) {
+      if (onPath.has(e.to)) continue;
+      dfsLocal(e.to);
+      if (all.length >= maxPaths) return;
+    }
+    path.pop();
+    onPath.delete(cur);
+  };
+  dfsLocal(start);
+  return all;
+}
+function findUpstreamNode(adj, startPipeId, dataset, predicate) {
+  const pipe = dataset.pipes.find((p) => p.id === startPipeId);
+  if (!pipe) return null;
+  const nodeById = new Map(dataset.nodes.map((n) => [n.id, n]));
+  const startId = pipe.fromNode;
+  const startNode = nodeById.get(startId);
+  if (!startNode) return null;
+  const allowEdge = (e, _from, to) => {
+    const targetPipe = dataset.pipes.find((p) => p.id === e.pipeId);
+    if (!targetPipe) return false;
+    return true;
+  };
+  const r = bfs(adj, startId, {
+    allowEdge,
+    until: (n) => {
+      const node = nodeById.get(n);
+      return node ? predicate(node) : false;
+    },
+    maxDepth: 50
+  });
+  if (!r.end) return null;
+  return nodeById.get(r.end) ?? null;
+}
+function highlightConnectivity(adj, start) {
+  const r = bfs(adj, start, { maxDepth: 64 });
+  const nodeIds = new Set(r.visited);
+  const edgeIds = /* @__PURE__ */ new Set();
+  for (const n of r.visited) {
+    const edges = adj.get(n) ?? [];
+    for (const e of edges) {
+      if (nodeIds.has(e.to)) edgeIds.add(e.pipeId);
+    }
+  }
+  return { nodeIds, edgeIds };
+}
+
+// src/graph/shortestPath.ts
+function dijkstra(adj, start, end, opts = {}) {
+  if (!adj.has(start) || !adj.has(end)) {
+    return { distance: Infinity, path: [], found: false };
+  }
+  const weight = opts.weight ?? ((e) => e.length || 1);
+  const dist = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const pq = [{ id: start, d: 0 }];
+  for (const n of adj.keys()) {
+    dist.set(n, Infinity);
+    parents.set(n, null);
+  }
+  dist.set(start, 0);
+  while (pq.length > 0) {
+    pq.sort((a, b) => a.d - b.d);
+    const cur2 = pq.shift();
+    if (visited.has(cur2.id)) continue;
+    visited.add(cur2.id);
+    if (cur2.id === end) break;
+    const edges = adj.get(cur2.id) ?? [];
+    for (const e of edges) {
+      if (visited.has(e.to)) continue;
+      const w = weight(e);
+      const alt = (dist.get(cur2.id) ?? Infinity) + w;
+      if (alt < (dist.get(e.to) ?? Infinity)) {
+        dist.set(e.to, alt);
+        parents.set(e.to, cur2.id);
+        pq.push({ id: e.to, d: alt });
+      }
+    }
+    if (opts.until && opts.until(cur2.id, cur2.d)) break;
+  }
+  if ((dist.get(end) ?? Infinity) === Infinity) {
+    return { distance: Infinity, path: [], found: false };
+  }
+  const path = [];
+  let cur = end;
+  while (cur) {
+    path.unshift(cur);
+    const p = parents.get(cur);
+    if (p === void 0) break;
+    cur = p;
+  }
+  return { distance: dist.get(end) ?? 0, path, found: true };
+}
+
+// src/topology/PipelineTopology.ts
+var PipelineTopology = class {
+  map;
+  dataset;
+  colorBy;
+  layerPrefix;
+  pipelineTypes;
+  layerIds = [];
+  nodeListeners = /* @__PURE__ */ new Set();
+  pipeListeners = /* @__PURE__ */ new Set();
+  drillListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.map = options.map;
+    this.dataset = options.dataset;
+    this.colorBy = options.colorBy ?? "type";
+    this.pipelineTypes = options.pipelineTypes;
+    this.layerPrefix = options.layerPrefix ?? "cg-topo";
+  }
+  /** 渲染管段+节点到地图 */
+  render() {
+    this.clear();
+    const mlMap = this.map.instance;
+    const prefix = this.layerPrefix;
+    const pipeGeoJSON = {
+      type: "FeatureCollection",
+      features: this.dataset.pipes.filter((p) => {
+        if (this.pipelineTypes?.length && !this.pipelineTypes.includes(p.pipelineType)) {
+          return false;
+        }
+        return true;
+      }).flatMap((p) => {
+        const from = this.dataset.nodes.find((n) => n.id === p.fromNode);
+        const to = this.dataset.nodes.find((n) => n.id === p.toNode);
+        if (!from || !to) return [];
+        const coords = p.geometry && p.geometry.length >= 2 ? p.geometry : [
+          [from.lng, from.lat],
+          [to.lng, to.lat]
+        ];
+        return [
+          {
+            type: "Feature",
+            geometry: { type: "LineString", coordinates: coords },
+            properties: {
+              pipeId: p.id,
+              pipelineType: p.pipelineType ?? "",
+              diameter: p.properties?.diameter ?? 0,
+              status: p.properties?.status ?? "unknown",
+              material: p.properties?.material ?? "unknown"
+            }
+          }
+        ];
+      })
+    };
+    const nodeGeoJSON = {
+      type: "FeatureCollection",
+      features: this.dataset.nodes.filter((n) => {
+        if (this.pipelineTypes?.length && !this.pipelineTypes.includes(n.pipelineType)) {
+          return false;
+        }
+        return true;
+      }).map((n) => ({
+        type: "Feature",
+        geometry: { type: "Point", coordinates: [n.lng, n.lat] },
+        properties: { nodeId: n.id, kind: n.kind, pipelineType: n.pipelineType ?? "" }
+      }))
+    };
+    mlMap.addSource(`${prefix}-pipes-src`, pipeGeoJSON);
+    mlMap.addSource(`${prefix}-nodes-src`, nodeGeoJSON);
+    mlMap.addLayer({
+      id: `${prefix}-pipes-line`,
+      type: "line",
+      source: `${prefix}-pipes-src`,
+      paint: {
+        "line-color": paintPipeBy(this.colorBy, { types: this.pipelineTypes }),
+        "line-width": 2,
+        "line-opacity": 0.85
+      }
+    });
+    mlMap.addLayer({
+      id: `${prefix}-nodes-pt`,
+      type: "circle",
+      source: `${prefix}-nodes-src`,
+      paint: {
+        "circle-radius": 4,
+        "circle-color": "#f59e0b",
+        "circle-stroke-width": 1.5,
+        "circle-stroke-color": "#ffffff"
+      }
+    });
+    this.layerIds.push(`${prefix}-pipes-line`, `${prefix}-nodes-pt`);
+  }
+  /** 切换着色模式 */
+  setColorBy(mode) {
+    this.colorBy = mode;
+    const mlMap = this.map.instance;
+    if (mlMap.setPaintProperty) {
+      try {
+        mlMap.setPaintProperty(
+          `${this.layerPrefix}-pipes-line`,
+          "line-color",
+          paintPipeBy(mode, { types: this.pipelineTypes })
+        );
+      } catch {
+      }
+    }
+  }
+  /** 清空所有图层 */
+  clear() {
+    for (const id of this.layerIds) {
+      this.map.removeLayer(id);
+    }
+    this.layerIds = [];
+  }
+  /** 销毁组件 */
+  destroy() {
+    this.clear();
+    this.nodeListeners.clear();
+    this.pipeListeners.clear();
+    this.drillListeners.clear();
+  }
+  /** 订阅节点点击事件 */
+  onNodeSelect(fn) {
+    this.nodeListeners.add(fn);
+    return () => this.nodeListeners.delete(fn);
+  }
+  /** 订阅管段点击事件 */
+  onPipeSelect(fn) {
+    this.pipeListeners.add(fn);
+    return () => this.pipeListeners.delete(fn);
+  }
+  /** 订阅钻取事件 */
+  onDrillDown(fn) {
+    this.drillListeners.add(fn);
+    return () => this.drillListeners.delete(fn);
+  }
+  /** 高亮连通路径（基于节点 ID） */
+  highlightConnectivity(centerId) {
+    const adj = /* @__PURE__ */ new Map();
+    for (const p of this.dataset.pipes) {
+      if (!adj.has(p.fromNode)) adj.set(p.fromNode, /* @__PURE__ */ new Set());
+      if (!adj.has(p.toNode)) adj.set(p.toNode, /* @__PURE__ */ new Set());
+      adj.get(p.fromNode).add(p.toNode);
+      adj.get(p.toNode).add(p.fromNode);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [centerId];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      if (visited.has(cur)) continue;
+      visited.add(cur);
+      const neighbors = adj.get(cur) ?? /* @__PURE__ */ new Set();
+      for (const n of neighbors) {
+        if (!visited.has(n)) stack.push(n);
+      }
+    }
+    return visited;
+  }
+};
+
+// src/burst/burstCore.ts
+function simulateBurst(dataset, pipeId, opts = {}) {
+  const t0 = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const scenario = opts.scenario ?? "gas";
+  const skipClosed = opts.skipClosedValves ?? true;
+  const maxAlt = opts.maxAlternatives ?? 2;
+  const pipe = dataset.pipes.find((p) => p.id === pipeId);
+  if (!pipe) {
+    throw new Error(`BurstSimulator: pipe '${pipeId}' not found in dataset`);
+  }
+  const nodeById = new Map(dataset.nodes.map((n) => [n.id, n]));
+  const adj = buildAdjacency(dataset);
+  const upstreamValves = findValvesFromEndpoint(adj, pipe, dataset, pipe.fromNode, skipClosed);
+  const downstreamValves = findValvesFromEndpoint(adj, pipe, dataset, pipe.toNode, skipClosed);
+  const candidateClose = mergeCandidateValves(upstreamValves, downstreamValves);
+  const closedSet = new Set(candidateClose.map((v) => v.id));
+  const downstream = bfs(adj, pipe.toNode, {
+    allowEdge: (_e, _f, to) => {
+      if (closedSet.has(to)) return false;
+      return true;
+    },
+    maxDepth: 1e3
+  });
+  const affectedSet = new Set(downstream.visited);
+  affectedSet.add(pipe.fromNode);
+  const affectedNodes = [];
+  for (const id of affectedSet) {
+    const n = nodeById.get(id);
+    if (n) affectedNodes.push(n);
+  }
+  const affectedPipes = dataset.pipes.filter(
+    (p) => affectedSet.has(p.fromNode) || affectedSet.has(p.toNode)
+  );
+  const users = dataset.users ?? [];
+  const affectedUsers = users.filter((u) => {
+    if (!u.nodeId) return false;
+    return affectedSet.has(u.nodeId);
+  });
+  const importantUsers = affectedUsers.filter((u) => u.kind === "important");
+  const impactArea = computeImpactArea(affectedNodes, affectedPipes);
+  const valvePlan = buildValvePlan(
+    adj,
+    dataset,
+    pipe,
+    candidateClose,
+    affectedNodes,
+    maxAlt,
+    scenario
+  );
+  const durationMs = (typeof performance !== "undefined" ? performance.now() : Date.now()) - t0;
+  return {
+    pipe,
+    affectedNodes,
+    affectedPipes,
+    affectedUsers,
+    affectedUserCount: affectedUsers.length,
+    importantUsers,
+    impactArea,
+    valvePlan,
+    durationMs
+  };
+}
+function findValvesFromEndpoint(adj, pipe, dataset, startId, skipClosed) {
+  const faultPipeId = pipe.id;
+  const nodeById = new Map(dataset.nodes.map((n) => [n.id, n]));
+  const out = [];
+  const endpoint = startId === pipe.fromNode ? "from" : "to";
+  const startNode = nodeById.get(startId);
+  if (!startNode) return [];
+  if (startNode.kind === "valve") {
+    if (!skipClosed || startNode.properties?.valveStatus !== "closed") {
+      out.push({ node: startNode, hops: 0, distance: 0, endpoint });
+    }
+    return out;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [
+    { id: startId, hops: 0, dist: 0 }
+  ];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    if (visited.has(cur.id)) continue;
+    visited.add(cur.id);
+    const n = nodeById.get(cur.id);
+    if (!n) continue;
+    if (n.kind === "valve" && (!skipClosed || n.properties?.valveStatus !== "closed")) {
+      out.push({ node: n, hops: cur.hops, distance: cur.dist, endpoint });
+      return out;
+    }
+    const edges = adj.get(cur.id) ?? [];
+    for (const e of edges) {
+      if (e.pipeId === faultPipeId) continue;
+      if (visited.has(e.to)) continue;
+      queue.push({
+        id: e.to,
+        hops: cur.hops + 1,
+        dist: cur.dist + (e.length || 0)
+      });
+    }
+  }
+  return out;
+}
+function mergeCandidateValves(upstream, downstream) {
+  const seen = /* @__PURE__ */ new Set();
+  const all = [...upstream, ...downstream].sort((a, b) => a.distance - b.distance);
+  const out = [];
+  for (const c of all) {
+    if (seen.has(c.node.id)) continue;
+    seen.add(c.node.id);
+    out.push(c.node);
+  }
+  return out;
+}
+function computeImpactArea(nodes, pipes) {
+  const features = [];
+  const nodeById = new Map(nodes.map((n) => [n.id, n]));
+  for (const n of nodes) {
+    features.push({
+      type: "Feature",
+      geometry: { type: "Point", coordinates: [n.lng, n.lat] },
+      properties: { kind: "node" }
+    });
+  }
+  for (const p of pipes) {
+    let coords = [];
+    if (p.geometry && p.geometry.length >= 2) {
+      coords = p.geometry;
+    } else {
+      const from = nodeById.get(p.fromNode);
+      const to = nodeById.get(p.toNode);
+      if (from && to) coords = [[from.lng, from.lat], [to.lng, to.lat]];
+    }
+    if (coords.length >= 2) {
+      features.push({
+        type: "Feature",
+        geometry: { type: "LineString", coordinates: coords },
+        properties: { kind: "pipe" }
+      });
+    }
+  }
+  const hull = convexHull(nodes.map((n) => [n.lng, n.lat]));
+  return { type: "FeatureCollection", features, hull };
+}
+function buildValvePlan(adj, dataset, pipe, closeValves, _affectedNodes, maxAlt, scenario) {
+  const closeSet = new Set(closeValves.map((v) => v.id));
+  const openValves = [];
+  for (const n of _affectedNodes) {
+    if (n.kind !== "valve") continue;
+    if (closeSet.has(n.id)) continue;
+    if (n.properties?.valveStatus !== "open") continue;
+    const from = dataset.nodes.find((m) => m.id === pipe.fromNode);
+    const to = dataset.nodes.find((m) => m.id === pipe.toNode);
+    if (!from || !to) continue;
+    const d1 = haversine(n.lng, n.lat, from.lng, from.lat);
+    const d2 = haversine(n.lng, n.lat, to.lng, to.lat);
+    if (Math.min(d1, d2) < 1e3) openValves.push(n);
+  }
+  const alternativePaths = [];
+  if (closeValves.length) {
+    const sources = dataset.nodes.filter((n) => n.kind === "source");
+    for (const s of sources) {
+      const r = dijkstra(adj, closeValves[0].id, s.id, {
+        weight: (e) => closeSet.has(e.to) ? Infinity : e.length || 1
+      });
+      if (r.found) {
+        const paths = findPaths(adj, closeValves[0].id, s.id, {
+          maxPaths: maxAlt,
+          maxDepth: 20
+        });
+        for (const p of paths) alternativePaths.push(p);
+        break;
+      }
+    }
+  }
+  const userCount = (dataset.users ?? []).filter(
+    (u) => _affectedNodes.some((n) => n.id === u.nodeId)
+  ).length;
+  const baseHours = userCount / 200;
+  const scenarioFactor = scenario === "water" ? 1.5 : scenario === "heating" ? 2 : 1;
+  const hours = Math.max(0.5, Math.min(8, baseHours * scenarioFactor));
+  const estimatedShutdownTime = hours >= 1 ? `${hours.toFixed(1)}h` : `${Math.round(hours * 60)}min`;
+  const summary = buildSummary(closeValves, openValves, userCount, scenario);
+  return {
+    closeValves,
+    openValves,
+    alternativePaths,
+    estimatedShutdownTime,
+    summary
+  };
+}
+function buildSummary(closeValves, openValves, userCount, scenario) {
+  const labels = {
+    gas: "\u505C\u6C14",
+    water: "\u505C\u6C34",
+    drainage: "\u6392\u6C34\u4E2D\u65AD",
+    heating: "\u505C\u70ED"
+  };
+  const label = labels[scenario] ?? "\u53D7\u5F71\u54CD";
+  const parts = [];
+  parts.push(`\u9884\u8BA1${label}${userCount}\u6237`);
+  if (closeValves.length) {
+    parts.push(`\u5173\u95ED\u9600\u95E8 ${closeValves.map((v) => v.properties?.code ?? v.id).join(", ")}`);
+  } else {
+    parts.push("\u672A\u627E\u5230\u4E0A\u6E38\u9694\u79BB\u9600\u95E8\uFF08\u5EFA\u8BAE\u4EBA\u5DE5\u6307\u5B9A\uFF09");
+  }
+  if (openValves.length) {
+    parts.push(`\u6253\u5F00\u9600\u95E8 ${openValves.map((v) => v.properties?.code ?? v.id).join(", ")}\uFF08\u6CC4\u538B\uFF09`);
+  }
+  return parts.join("\uFF1B");
+}
+function convexHull(points) {
+  if (points.length < 3) return [...points];
+  const pts = [...points];
+  pts.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+      lower.pop();
+    }
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  upper.pop();
+  lower.pop();
+  return lower.concat(upper);
+}
+function userSeverity(kind, scale = 1) {
+  const base = {
+    important: 100,
+    industrial: 50,
+    commercial: 20,
+    residential: 1
+  };
+  return (base[kind] ?? 1) * (scale ?? 1);
+}
+
+// src/burst/valvePlanner.ts
+function listCandidateValves(dataset, pipeId, filter) {
+  const pipe = dataset.pipes.find((p) => p.id === pipeId);
+  if (!pipe) return [];
+  const nodeById = new Map(dataset.nodes.map((n) => [n.id, n]));
+  const adj = buildAdjacency(dataset);
+  const visited = /* @__PURE__ */ new Set();
+  const valveCandidates = [];
+  for (const startId of [pipe.fromNode, pipe.toNode]) {
+    const queue = [{ id: startId, d: 0 }];
+    while (queue.length > 0) {
+      const { id, d } = queue.shift();
+      if (visited.has(id)) continue;
+      visited.add(id);
+      const n = nodeById.get(id);
+      if (!n) continue;
+      if (n.kind === "valve" && (!filter || filter(n))) {
+        valveCandidates.push({ n, dist: d });
+        if (d > 0) continue;
+      }
+      const edges = adj.get(id) ?? [];
+      for (const e of edges) {
+        if (e.pipeId === pipeId) continue;
+        if (visited.has(e.to)) continue;
+        queue.push({ id: e.to, d: d + 1 });
+      }
+    }
+  }
+  valveCandidates.sort((a, b) => a.dist - b.dist);
+  return valveCandidates.map((v) => v.n);
+}
+function evaluateValvePlan(dataset, pipeId, valvesToClose) {
+  const pipe = dataset.pipes.find((p) => p.id === pipeId);
+  if (!pipe) {
+    return {
+      valves: valvesToClose,
+      isolationCompleteness: Infinity,
+      impactUserCount: 0,
+      operationOrder: []
+    };
+  }
+  const adj = buildAdjacency(dataset);
+  const closedSet = new Set(valvesToClose.map((v) => v.id));
+  new Map(dataset.pipes.map((p) => [p.id, p]));
+  const affectedNodes = bfs(adj, pipe.toNode, {
+    allowEdge: (_e, _f, to) => !closedSet.has(to),
+    maxDepth: 1e3
+  }).visited;
+  const users = (dataset.users ?? []).filter((u) => {
+    if (!u.nodeId) return false;
+    return affectedNodes.includes(u.nodeId);
+  });
+  const sources = dataset.nodes.filter((n) => n.kind === "source");
+  let completeness = Infinity;
+  for (const s of sources) {
+    const rTo = dijkstra(adj, s.id, pipe.toNode, {
+      weight: (e) => closedSet.has(e.to) ? Infinity : e.length || 1
+    });
+    const rFrom = dijkstra(adj, s.id, pipe.fromNode, {
+      weight: (e) => closedSet.has(e.to) ? Infinity : e.length || 1
+    });
+    const reachable = rTo.found ? rTo.distance : Infinity;
+    const reachableFrom = rFrom.found ? rFrom.distance : Infinity;
+    const nearest = Math.min(reachable, reachableFrom);
+    if (nearest < completeness) completeness = nearest;
+  }
+  const order = valvesToClose.map((v) => v.properties?.code ?? v.id).sort();
+  return {
+    valves: valvesToClose,
+    isolationCompleteness: completeness,
+    impactUserCount: users.length,
+    operationOrder: order
+  };
+}
+
+// src/burst/impactArea.ts
+function toMapLayerData(result) {
+  const hull = result.impactArea.hull;
+  const hullPolygon = hull.length >= 3 ? {
+    type: "Feature",
+    geometry: { type: "Polygon", coordinates: [hull] },
+    properties: { score: 1, affected: result.affectedUserCount }
+  } : null;
+  const nodeCoords = /* @__PURE__ */ new Map();
+  for (const n of result.affectedNodes) nodeCoords.set(n.id, n);
+  const affectedPipes = {
+    type: "FeatureCollection",
+    features: result.affectedPipes.map((p) => ({
+      type: "Feature",
+      geometry: pipeToLineString(p, nodeCoords),
+      properties: { pipeId: p.id, scenario: "affected" }
+    })).filter((f) => f.geometry.coordinates.length >= 2)
+  };
+  const affectedNodes = {
+    type: "FeatureCollection",
+    features: result.affectedNodes.map((n) => ({
+      type: "Feature",
+      geometry: { type: "Point", coordinates: [n.lng, n.lat] },
+      properties: { nodeId: n.id, kind: n.kind }
+    }))
+  };
+  return { hullPolygon, affectedPipes, affectedNodes };
+}
+function pipeToLineString(p, nodes) {
+  if (p.geometry && p.geometry.length >= 2) {
+    return { type: "LineString", coordinates: p.geometry };
+  }
+  const from = nodes.get(p.fromNode);
+  const to = nodes.get(p.toNode);
+  if (from && to) {
+    return {
+      type: "LineString",
+      coordinates: [
+        [from.lng, from.lat],
+        [to.lng, to.lat]
+      ]
+    };
+  }
+  return { type: "LineString", coordinates: [] };
+}
+function impactAreaSquareMeters(hull) {
+  if (hull.length < 3) return 0;
+  const refLat = hull[0][1];
+  const mPerDegLat = 110540;
+  const mPerDegLng = 111320 * Math.cos(refLat * Math.PI / 180);
+  const pts = hull.map(([lng, lat]) => [
+    (lng - hull[0][0]) * mPerDegLng,
+    (lat - hull[0][1]) * mPerDegLat
+  ]);
+  let sum = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const [x1, y1] = pts[i];
+    const [x2, y2] = pts[(i + 1) % pts.length];
+    sum += x1 * y2 - x2 * y1;
+  }
+  return Math.abs(sum) / 2;
+}
+function impactCenter(nodes) {
+  if (!nodes.length) return null;
+  let lng = 0;
+  let lat = 0;
+  for (const n of nodes) {
+    lng += n.lng;
+    lat += n.lat;
+  }
+  return [lng / nodes.length, lat / nodes.length];
+}
+function nearestNodeOnPipe(pipe, nodes, lng, lat) {
+  const a = nodes.find((n) => n.id === pipe.fromNode);
+  const b = nodes.find((n) => n.id === pipe.toNode);
+  if (!a || !b) return null;
+  const da = haversineApprox(a.lng, a.lat, lng, lat);
+  const db = haversineApprox(b.lng, b.lat, lng, lat);
+  return da < db ? a : b;
+}
+function haversineApprox(lng1, lat1, lng2, lat2) {
+  const dx = (lng2 - lng1) * 111320 * Math.cos(lat1 * Math.PI / 180);
+  const dy = (lat2 - lat1) * 110540;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+// src/burst/burstClass.ts
+var BurstSimulator = class {
+  map;
+  dataset;
+  scenario;
+  affectedPipePaint;
+  affectedNodePaint;
+  valvePaint;
+  hullPaint;
+  layerPrefix;
+  listeners = /* @__PURE__ */ new Set();
+  lastResult = null;
+  layerIds = [];
+  constructor(options) {
+    this.map = options.map;
+    this.dataset = options.dataset;
+    this.scenario = options.scenario ?? "gas";
+    this.affectedPipePaint = options.affectedPipePaint ?? {
+      "line-color": "#ef4444",
+      "line-width": 4,
+      "line-opacity": 0.85,
+      "line-blur": 1.5
+    };
+    this.affectedNodePaint = options.affectedNodePaint ?? {
+      "circle-radius": 6,
+      "circle-color": "#ef4444",
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#ffffff"
+    };
+    this.valvePaint = options.valvePaint ?? {
+      "circle-radius": 8,
+      "circle-color": "#fbbf24",
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#000000"
+    };
+    this.hullPaint = options.hullPaint ?? {
+      "fill-color": "#ef4444",
+      "fill-opacity": 0.15,
+      "fill-outline-color": "#ef4444"
+    };
+    this.layerPrefix = options.layerPrefix ?? "cg-burst";
+  }
+  /** 触发爆管推演 */
+  simulate(pipeId, overrideOpts) {
+    const result = simulateBurst(this.dataset, pipeId, {
+      scenario: overrideOpts?.scenario ?? this.scenario,
+      skipClosedValves: overrideOpts?.skipClosedValves ?? true,
+      maxAlternatives: overrideOpts?.maxAlternatives ?? 2
+    });
+    this.lastResult = result;
+    this.render(result);
+    for (const l of this.listeners) l(result);
+    return result;
+  }
+  /** 清空所有受影响区域图层 */
+  clear() {
+    for (const id of this.layerIds) {
+      this.map.removeLayer(id);
+    }
+    this.layerIds = [];
+  }
+  /** 销毁并清空所有资源 */
+  destroy() {
+    this.clear();
+    this.listeners.clear();
+    this.lastResult = null;
+  }
+  /** 订阅推演结果 */
+  onResult(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  /** 取最后一次结果 */
+  getLastResult() {
+    return this.lastResult;
+  }
+  // ------------------------------------------------------
+  // 内部：把结果渲染为 MapLibre 图层
+  // ------------------------------------------------------
+  render(result) {
+    this.clear();
+    const layerData = toMapLayerData(result);
+    const mlMap = this.map.instance;
+    const prefix = this.layerPrefix;
+    const sourcesToAdd = [];
+    const layersToAdd = [];
+    if (layerData.hullPolygon) {
+      sourcesToAdd.push({ id: `${prefix}-hull-src`, data: layerData.hullPolygon });
+      layersToAdd.push({
+        id: `${prefix}-hull-fill`,
+        type: "fill",
+        source: `${prefix}-hull-src`,
+        paint: this.hullPaint
+      });
+    }
+    sourcesToAdd.push({ id: `${prefix}-pipes-src`, data: layerData.affectedPipes });
+    layersToAdd.push({
+      id: `${prefix}-pipes-line`,
+      type: "line",
+      source: `${prefix}-pipes-src`,
+      paint: this.affectedPipePaint
+    });
+    sourcesToAdd.push({ id: `${prefix}-nodes-src`, data: layerData.affectedNodes });
+    layersToAdd.push({
+      id: `${prefix}-nodes-pt`,
+      type: "circle",
+      source: `${prefix}-nodes-src`,
+      paint: this.affectedNodePaint
+    });
+    for (const src of sourcesToAdd) {
+      if (!mlMap.getSource(src.id)) mlMap.addSource(src.id, src.data);
+    }
+    for (const layer of layersToAdd) {
+      try {
+        mlMap.addLayer(layer);
+        this.layerIds.push(layer.id);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/leakage/pasquillGifford.ts
+var TABLE_DAY = [
+  { wind: 2, cls: { strong: "A", moderate: "A", slight: "B" } },
+  { wind: 3, cls: { strong: "A", moderate: "B", slight: "C" } },
+  { wind: 5, cls: { strong: "B", moderate: "B", slight: "C" } },
+  { wind: 6, cls: { strong: "C", moderate: "C", slight: "D" } },
+  { wind: 7, cls: { strong: "C", moderate: "D", slight: "D" } },
+  { wind: 999, cls: { strong: "D", moderate: "D", slight: "D" } }
+];
+var TABLE_NIGHT = [
+  { wind: 2, cls: { overcast: "F", partly: "F", clear: "F" } },
+  { wind: 3, cls: { overcast: "E", partly: "F", clear: "F" } },
+  { wind: 5, cls: { overcast: "D", partly: "E", clear: "F" } },
+  { wind: 6, cls: { overcast: "D", partly: "D", clear: "E" } },
+  { wind: 999, cls: { overcast: "D", partly: "D", clear: "D" } }
+];
+function classifyStability(params) {
+  const table = params.isDaytime ? TABLE_DAY : TABLE_NIGHT;
+  const key = params.isDaytime ? params.daytimeInsolation ?? "moderate" : params.nightCloudCover ?? "partly";
+  for (const row of table) {
+    if (params.windSpeed < row.wind) return row.cls[key] ?? "D";
+  }
+  return "D";
+}
+function dispersionCoefficients(stability) {
+  const params = {
+    A: [0.22, 1e-4, 0.2, 0],
+    B: [0.16, 1e-4, 0.12, 0],
+    C: [0.11, 1e-4, 0.08, 2e-4],
+    D: [0.08, 1e-4, 0.06, 15e-4],
+    E: [0.06, 1e-4, 0.03, 3e-4],
+    F: [0.04, 1e-4, 0.016, 3e-4]
+  };
+  const [a, b, c, d] = params[stability];
+  return {
+    sigmaY: (xMeters) => {
+      const xKm = xMeters / 1e3;
+      return a * xKm / Math.sqrt(1 + b * xKm) * 1e3;
+    },
+    sigmaZ: (xMeters) => {
+      const xKm = xMeters / 1e3;
+      return c * xKm / Math.sqrt(1 + d * xKm) * 1e3;
+    }
+  };
+}
+
+// src/leakage/gaussianPlume.ts
+function gaussianPlume(source, params) {
+  const stability = params.stability ?? "D";
+  const { sigmaY, sigmaZ } = dispersionCoefficients(stability);
+  const thresholds = params.thresholds ?? [1e-3, 5e-3, 0.01];
+  const step = params.gridStep ?? 50;
+  const range = params.range ?? 5e3;
+  const contourList = thresholds.map((t) => ({
+    threshold: t,
+    polygon: [],
+    closed: false
+  }));
+  const Q = params.leakRate;
+  const u = params.windSpeed;
+  const H = params.releaseHeight;
+  let maxDownwindDistance = 0;
+  for (const c of contourList) {
+    for (let r = step; r <= range; r += step) {
+      const sy = sigmaY(r);
+      const sz = sigmaZ(r);
+      if (sy <= 0 || sz <= 0) continue;
+      const concCenter = Q / (2 * Math.PI * sy * sz * u);
+      const zTerm = 2 * Math.exp(-(H * H) / (2 * sz * sz));
+      const cMax = concCenter * zTerm;
+      if (cMax >= c.threshold) {
+        if (r > maxDownwindDistance) maxDownwindDistance = r;
+      }
+    }
+    const poly = [];
+    for (let r = step; r <= range; r += step) {
+      const sy = sigmaY(r);
+      if (sy <= 0) continue;
+      const syy = Q / (2 * Math.PI * sy * sigmaZ(r) * u) * 2;
+      if (syy < c.threshold) continue;
+      const ratio = c.threshold * Math.PI * sy * sigmaZ(r) * u / Q;
+      if (ratio >= 1) continue;
+      const yMax = sy * Math.sqrt(-2 * Math.log(ratio));
+      poly.push([r, yMax]);
+      poly.unshift([r, -yMax]);
+    }
+    c.polygon = polyToLngLat(source, params.windDirection, poly);
+    c.closed = poly.length >= 3;
+  }
+  return {
+    source,
+    windDirection: params.windDirection,
+    windSpeed: params.windSpeed,
+    stability,
+    contours: contourList,
+    maxDownwindDistance
+  };
+}
+function polyToLngLat(source, windDir, poly) {
+  return poly.map(([r, y]) => {
+    const cosW = Math.cos(windDir);
+    const sinW = Math.sin(windDir);
+    const dx = r * cosW + y * -sinW;
+    const dy = r * sinW + y * cosW;
+    const dLat = dy / 110540;
+    const dLng = dx / (111320 * Math.cos(source.lat * Math.PI / 180));
+    return [source.lng + dLng, source.lat + dLat];
+  });
+}
+function classifyFromMeteo(opts) {
+  return classifyStability(opts);
+}
+
+// src/leakage/floodFill.ts
+function simulateFlood(dem, params) {
+  const sourceIdx = lngLatToIndex(dem, params.sourceLng, params.sourceLat);
+  if (sourceIdx.row < 0 || sourceIdx.row >= dem.rows || sourceIdx.col < 0 || sourceIdx.col >= dem.cols) {
+    return {
+      source: { lng: params.sourceLng, lat: params.sourceLat },
+      floodArea: 0,
+      affectedCells: [],
+      hull: [],
+      maxDepth: 0
+    };
+  }
+  const sourceElev = dem.elevations[sourceIdx.row * dem.cols + sourceIdx.col] ?? 0;
+  (params.duration ?? 30 * 60) / 60;
+  params.flowRate ?? 50;
+  const initialLevel = params.initialWaterLevel ?? sourceElev + 0.05;
+  const visited = /* @__PURE__ */ new Set();
+  const affected = [];
+  const queue = [];
+  queue.push({ row: sourceIdx.row, col: sourceIdx.col, level: initialLevel });
+  let maxDepth = 0;
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    const idx = cur.row * dem.cols + cur.col;
+    if (visited.has(idx)) continue;
+    visited.add(idx);
+    if (cur.row < 0 || cur.row >= dem.rows) continue;
+    if (cur.col < 0 || cur.col >= dem.cols) continue;
+    const elev = dem.elevations[idx] ?? 0;
+    const depth = cur.level - elev;
+    if (depth <= 0) continue;
+    if (depth > maxDepth) maxDepth = depth;
+    const lng = dem.west + cur.col * dem.cellSize + dem.cellSize / 2;
+    const lat = dem.south + cur.row * dem.cellSize + dem.cellSize / 2;
+    affected.push({ lng, lat, elevation: elev, waterDepth: depth });
+    const nextLevel = cur.level - 0.01;
+    for (const [dr, dc] of [
+      [0, 1],
+      [0, -1],
+      [1, 0],
+      [-1, 0]
+    ]) {
+      queue.push({ row: cur.row + dr, col: cur.col + dc, level: nextLevel });
+    }
+  }
+  const cellArea = dem.cellSize * 111320 * (dem.cellSize * 110540);
+  const floodArea = affected.length * cellArea;
+  const hull = convexHullLocal(affected.map((c) => [c.lng, c.lat]));
+  return {
+    source: { lng: params.sourceLng, lat: params.sourceLat },
+    floodArea,
+    affectedCells: affected,
+    hull,
+    maxDepth
+  };
+}
+function lngLatToIndex(dem, lng, lat) {
+  const col = Math.floor((lng - dem.west) / dem.cellSize);
+  const row = Math.floor((lat - dem.south) / dem.cellSize);
+  return { row, col };
+}
+function convexHullLocal(points) {
+  if (points.length < 3) return [...points];
+  const pts = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) lower.pop();
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) upper.pop();
+    upper.push(p);
+  }
+  upper.pop();
+  lower.pop();
+  return lower.concat(upper);
+}
+
+// src/leakage/LeakagePlume.ts
+var LeakagePlume = class {
+  map;
+  thresholds;
+  layerPrefix;
+  fillColor;
+  layerIds = [];
+  listeners = /* @__PURE__ */ new Set();
+  lastResult = null;
+  constructor(options) {
+    this.map = options.map;
+    this.thresholds = options.thresholds ?? [1e-3, 5e-3, 0.01];
+    this.layerPrefix = options.layerPrefix ?? "cg-leakage";
+    this.fillColor = options.fillColor ?? "#fb923c";
+  }
+  /** 燃气泄漏扩散模拟 */
+  simulateGas(source, params) {
+    const result = gaussianPlume(source, { ...params, thresholds: this.thresholds });
+    this.lastResult = result;
+    this.renderGas(result);
+    for (const l of this.listeners) l(result);
+    return result;
+  }
+  /** 供水爆管淹没模拟 */
+  simulateFlood(dem, params) {
+    const result = simulateFlood(dem, params);
+    this.lastResult = result;
+    this.renderFlood(result);
+    for (const l of this.listeners) l(result);
+    return result;
+  }
+  /** 清空图层 */
+  clear() {
+    for (const id of this.layerIds) {
+      this.map.removeLayer(id);
+    }
+    this.layerIds = [];
+  }
+  /** 销毁组件 */
+  destroy() {
+    this.clear();
+    this.listeners.clear();
+    this.lastResult = null;
+  }
+  /** 订阅结果 */
+  onResult(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  /** 取最后一次结果 */
+  getLastResult() {
+    return this.lastResult;
+  }
+  // --------------------------------------------------
+  // 内部渲染（GeoJSON 多边形叠加）
+  // --------------------------------------------------
+  renderGas(result) {
+    this.renderContours(
+      result.contours.map((c) => ({
+        polygon: c.polygon,
+        threshold: c.threshold
+      })),
+      result.source
+    );
+  }
+  renderFlood(result) {
+    if (result.hull.length < 3) return;
+    const mlMap = this.map.instance;
+    const data = {
+      type: "Feature",
+      geometry: { type: "Polygon", coordinates: [result.hull] },
+      properties: { threshold: 0 }
+    };
+    const id = `${this.layerPrefix}-flood-fill`;
+    if (!mlMap.getSource(id)) mlMap.addSource(id, data);
+    try {
+      mlMap.addLayer({
+        id,
+        type: "fill",
+        source: id,
+        paint: {
+          "fill-color": "#3b82f6",
+          "fill-opacity": 0.3,
+          "fill-outline-color": "#1e40af"
+        }
+      });
+      this.layerIds.push(id);
+    } catch {
+    }
+  }
+  renderContours(contours, source) {
+    const mlMap = this.map.instance;
+    const data = {
+      type: "FeatureCollection",
+      features: contours.filter((c) => c.polygon.length >= 3).map((c) => ({
+        type: "Feature",
+        geometry: { type: "Polygon", coordinates: [c.polygon] },
+        properties: { threshold: c.threshold }
+      }))
+    };
+    const sourceId = `${this.layerPrefix}-gas-src`;
+    const layerId = `${this.layerPrefix}-gas-fill`;
+    if (!mlMap.getSource(sourceId)) mlMap.addSource(sourceId, data);
+    try {
+      mlMap.addLayer({
+        id: layerId,
+        type: "fill",
+        source: sourceId,
+        paint: {
+          "fill-color": [
+            "step",
+            ["get", "threshold"],
+            this.fillColor,
+            5e-3,
+            "#f97316",
+            0.01,
+            "#ef4444"
+          ],
+          "fill-opacity": 0.35,
+          "fill-outline-color": this.fillColor
+        }
+      });
+      this.layerIds.push(layerId);
+    } catch {
+    }
+    const ptId = `${this.layerPrefix}-source`;
+    mlMap.addSource(ptId, {
+      type: "FeatureCollection",
+      features: [
+        {
+          type: "Feature",
+          geometry: { type: "Point", coordinates: [source.lng, source.lat] },
+          properties: {}
+        }
+      ]
+    });
+    try {
+      mlMap.addLayer({
+        id: ptId,
+        type: "circle",
+        source: ptId,
+        paint: {
+          "circle-radius": 10,
+          "circle-color": "#fbbf24",
+          "circle-stroke-width": 3,
+          "circle-stroke-color": "#000"
+        }
+      });
+      this.layerIds.push(ptId);
+    } catch {
+    }
+  }
+};
+
+// src/health/healthScorer.ts
+var DEFAULT_WEIGHTS = {
+  age: 0.25,
+  material: 0.2,
+  soil: 0.15,
+  history: 0.2,
+  pressure: 0.1,
+  protection: 0.1
+};
+var MATERIAL_RISK = {
+  cast_iron: 0.85,
+  // 铸铁 = 高风险（旧管网）
+  ductile_iron: 0.2,
+  // 球墨铸铁
+  steel: 0.4,
+  pe: 0.1,
+  pvc: 0.15,
+  concrete: 0.3,
+  hdpe: 0.05,
+  copper: 0.1,
+  unknown: 0.5
+};
+function scorePipeHealth(input, weights = DEFAULT_WEIGHTS) {
+  const dims = {
+    age: scoreAge(input, weights.age),
+    material: scoreMaterial(input, weights.material),
+    soil: scoreSoil(input, weights.soil),
+    history: scoreHistory(input, weights.history),
+    pressure: scorePressure(input, weights.pressure),
+    protection: scoreProtection(input, weights.protection)
+  };
+  const total = dims.age.score * dims.age.weight + dims.material.score * dims.material.weight + dims.soil.score * dims.soil.weight + dims.history.score * dims.history.weight + dims.pressure.score * dims.pressure.weight + dims.protection.score * dims.protection.weight;
+  let final = total;
+  if (input.status === "damaged") final *= 0.5;
+  else if (input.status === "under_repair") final *= 0.7;
+  else if (input.status === "abandoned") final = 0;
+  return {
+    score: Math.round(final),
+    level: toLevel(final),
+    dimensions: dims
+  };
+}
+function toLevel(score) {
+  if (score >= 80) return "excellent";
+  if (score >= 60) return "good";
+  if (score >= 40) return "fair";
+  if (score >= 20) return "poor";
+  return "critical";
+}
+function scoreAge(input, weight) {
+  if (!input.installDate) {
+    return { score: 50, weight, reason: "\u672A\u77E5\u5B89\u88C5\u65E5\u671F\uFF0C\u6309\u4E2D\u7B49\u8BA1" };
+  }
+  const ageYears = (Date.now() - new Date(input.installDate).getTime()) / (365.25 * 24 * 3600 * 1e3);
+  if (ageYears < 0) return { score: 100, weight, reason: "\u672A\u6765\u65E5\u671F\uFF0C\u89C6\u4E3A\u4F18\u79C0" };
+  if (ageYears < 5) return { score: 100, weight, reason: "\u65B0\u5EFA\u7BA1\u7EBF (<5\u5E74)" };
+  if (ageYears < 15) return { score: 85, weight, reason: "\u8F83\u65B0 (5-15\u5E74)" };
+  if (ageYears < 25) return { score: 65, weight, reason: "\u4E2D\u9F84 (15-25\u5E74)" };
+  if (ageYears < 40) return { score: 40, weight, reason: "\u8001\u9F84 (25-40\u5E74)" };
+  if (ageYears < 60) return { score: 20, weight, reason: "\u8D85\u671F (>40\u5E74)" };
+  return { score: 5, weight, reason: "\u8D85\u671F (>60\u5E74)" };
+}
+function scoreMaterial(input, weight) {
+  if (!input.material) {
+    return { score: 50, weight, reason: "\u672A\u77E5\u6750\u8D28\uFF0C\u6309\u4E2D\u7B49\u8BA1" };
+  }
+  const risk = MATERIAL_RISK[input.material] ?? 0.5;
+  const score = Math.round((1 - risk) * 100);
+  const labels = {
+    cast_iron: "\u94F8\u94C1\uFF08\u9AD8\u98CE\u9669\uFF09",
+    ductile_iron: "\u7403\u58A8\u94F8\u94C1",
+    steel: "\u94A2",
+    pe: "PE\uFF08\u4F4E\u98CE\u9669\uFF09",
+    pvc: "PVC",
+    concrete: "\u6DF7\u51DD\u571F",
+    hdpe: "HDPE\uFF08\u6700\u4F73\uFF09",
+    copper: "\u94DC",
+    unknown: "\u672A\u77E5"
+  };
+  return {
+    score,
+    weight,
+    reason: labels[input.material] ?? input.material
+  };
+}
+function scoreSoil(input, weight) {
+  const c = input.soilCorrosion ?? 0.5;
+  const score = Math.round((1 - c) * 100);
+  return {
+    score,
+    weight,
+    reason: c === 0.5 && !input.soilCorrosion ? "\u65E0\u571F\u58E4\u6570\u636E\uFF0C\u6309\u5E73\u5747\u8BA1" : `\u571F\u58E4\u8150\u8680\u6307\u6570 ${c.toFixed(2)}`
+  };
+}
+function scoreHistory(input, weight) {
+  const fail = input.failureCount ?? 0;
+  if (fail === 0) return { score: 100, weight, reason: "\u5386\u53F2\u65E0\u6545\u969C" };
+  if (fail === 1) return { score: 75, weight, reason: "\u5386\u53F2 1 \u6B21\u6545\u969C" };
+  if (fail === 2) return { score: 50, weight, reason: "\u5386\u53F2 2 \u6B21\u6545\u969C" };
+  if (fail === 3) return { score: 25, weight, reason: "\u5386\u53F2 3 \u6B21\u6545\u969C" };
+  return { score: 0, weight, reason: `\u5386\u53F2 \u2265${fail} \u6B21\u6545\u969C` };
+}
+function scorePressure(input, weight) {
+  if (!input.pressure) {
+    return { score: 75, weight, reason: "\u65E0\u538B\u529B\u6570\u636E\uFF0C\u6309\u4E2D\u7B49\u504F\u597D\u8BA1" };
+  }
+  if (!input.ratedPressure) {
+    return { score: 75, weight, reason: "\u4EC5\u77E5\u5F53\u524D\u538B\u529B" };
+  }
+  const ratio = input.pressure / input.ratedPressure;
+  if (ratio < 0.5) return { score: 60, weight, reason: "\u538B\u529B\u504F\u4F4E (\u4F7F\u7528\u7387 <50%)" };
+  if (ratio < 0.8) return { score: 90, weight, reason: "\u538B\u529B\u6B63\u5E38 (\u4F7F\u7528\u7387 50-80%)" };
+  if (ratio < 1) return { score: 75, weight, reason: "\u538B\u529B\u504F\u9AD8 (\u4F7F\u7528\u7387 80-100%)" };
+  if (ratio < 1.2) return { score: 30, weight, reason: "\u538B\u529B\u8D85\u9650 (100-120%)" };
+  return { score: 0, weight, reason: "\u538B\u529B\u4E25\u91CD\u8D85\u9650 (>120%)" };
+}
+function scoreProtection(input, weight) {
+  if (input.hasCathodicProtection === true) {
+    return { score: 90, weight, reason: "\u6709\u9634\u6781\u4FDD\u62A4" };
+  }
+  if (input.hasCathodicProtection === false) {
+    return { score: 30, weight, reason: "\u65E0\u9634\u6781\u4FDD\u62A4" };
+  }
+  return { score: 50, weight, reason: "\u9634\u4FDD\u72B6\u6001\u672A\u77E5" };
+}
+function scorePipes(inputs, weights = DEFAULT_WEIGHTS) {
+  return inputs.map((i) => scorePipeHealth(i, weights));
+}
+
+// src/health/riskHeatmap.ts
+function aggregateHeatmap(points, options = {}) {
+  const cell = options.cellSize ?? 500;
+  const agg = options.aggregation ?? "average";
+  if (points.length === 0) return [];
+  const refLat = points[0].lat;
+  const refLng = points[0].lng;
+  const mPerDegLat = 110540;
+  const mPerDegLng = 111320 * Math.cos(refLat * Math.PI / 180);
+  const grid = /* @__PURE__ */ new Map();
+  for (const p of points) {
+    const x = (p.lng - refLng) * mPerDegLng;
+    const y = (p.lat - refLat) * mPerDegLat;
+    const cx = Math.floor(x / cell);
+    const cy = Math.floor(y / cell);
+    const key = `${cx}:${cy}`;
+    const cur = grid.get(key);
+    if (!cur) {
+      grid.set(key, {
+        acc: p.healthScore,
+        count: 1,
+        minS: p.healthScore,
+        maxS: p.healthScore,
+        lng: p.lng,
+        lat: p.lat
+      });
+    } else {
+      cur.acc += p.healthScore;
+      cur.count += 1;
+      if (p.healthScore < cur.minS) cur.minS = p.healthScore;
+      if (p.healthScore > cur.maxS) cur.maxS = p.healthScore;
+      cur.lng = (cur.lng * (cur.count - 1) + p.lng) / cur.count;
+      cur.lat = (cur.lat * (cur.count - 1) + p.lat) / cur.count;
+    }
+  }
+  const cells = [];
+  for (const v of grid.values()) {
+    let score;
+    if (agg === "min") score = v.minS;
+    else if (agg === "max") score = v.maxS;
+    else score = v.acc / v.count;
+    cells.push({
+      lng: v.lng,
+      lat: v.lat,
+      healthScore: Math.round(score),
+      pipeCount: v.count
+    });
+  }
+  return cells;
+}
+function heatmapToGeoJSON(cells) {
+  return {
+    type: "FeatureCollection",
+    features: cells.map((c) => ({
+      type: "Feature",
+      geometry: { type: "Point", coordinates: [c.lng, c.lat] },
+      properties: {
+        healthScore: c.healthScore,
+        pipeCount: c.pipeCount
+      }
+    }))
+  };
+}
+function prioritizeMaintenance(pipes, topN = 10) {
+  return [...pipes].sort((a, b) => a.healthScore - b.healthScore).slice(0, topN);
+}
+
+// src/health/PipelineHealth.ts
+var PipelineHealth = class {
+  map;
+  dataset;
+  cellSize;
+  layerPrefix;
+  listeners = /* @__PURE__ */ new Set();
+  lastResult = null;
+  layerIds = [];
+  constructor(options) {
+    this.map = options.map;
+    this.dataset = options.dataset;
+    this.cellSize = options.cellSize ?? 500;
+    this.layerPrefix = options.layerPrefix ?? "cg-health";
+  }
+  /** 评估全网管线健康度 */
+  evaluate(weights = DEFAULT_WEIGHTS) {
+    const t0 = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const nodeById = new Map(this.dataset.nodes.map((n) => [n.id, n]));
+    const scores = this.dataset.pipes.map((p) => {
+      const input = {
+        installDate: p.properties?.installDate,
+        material: p.properties?.material,
+        failureCount: void 0,
+        pressure: p.properties?.pressure,
+        ratedPressure: p.properties?.ratedPressure,
+        hasCathodicProtection: void 0,
+        status: p.properties?.status
+      };
+      return { pipeId: p.id, score: scorePipeHealth(input, weights) };
+    });
+    const points = scores.flatMap((s, i) => {
+      const pipe = this.dataset.pipes[i];
+      const from = nodeById.get(pipe.fromNode);
+      const to = nodeById.get(pipe.toNode);
+      if (!from || !to) return [];
+      return [
+        {
+          lng: (from.lng + to.lng) / 2,
+          lat: (from.lat + to.lat) / 2,
+          healthScore: s.score.score
+        }
+      ];
+    });
+    const heatmap = aggregateHeatmap(points, { cellSize: this.cellSize });
+    const maintenance = prioritizeMaintenance(
+      scores.flatMap((s, i) => {
+        const pipe = this.dataset.pipes[i];
+        const from = nodeById.get(pipe.fromNode);
+        const to = nodeById.get(pipe.toNode);
+        if (!from || !to) return [];
+        return [
+          {
+            id: pipe.id,
+            healthScore: s.score.score,
+            lng: (from.lng + to.lng) / 2,
+            lat: (from.lat + to.lat) / 2,
+            label: pipe.id
+          }
+        ];
+      })
+    );
+    const durationMs = (typeof performance !== "undefined" ? performance.now() : Date.now()) - t0;
+    const result = { scores, heatmap, maintenance, durationMs };
+    this.lastResult = result;
+    this.renderHeatmap(result);
+    for (const l of this.listeners) l(result);
+    return result;
+  }
+  /** 清空图层 */
+  clear() {
+    for (const id of this.layerIds) {
+      this.map.removeLayer(id);
+    }
+    this.layerIds = [];
+  }
+  /** 销毁 */
+  destroy() {
+    this.clear();
+    this.listeners.clear();
+    this.lastResult = null;
+  }
+  /** 订阅结果 */
+  onResult(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  /** 取最后一次结果 */
+  getLastResult() {
+    return this.lastResult;
+  }
+  renderHeatmap(result) {
+    this.clear();
+    const mlMap = this.map.instance;
+    const data = heatmapToGeoJSON(result.heatmap);
+    const sourceId = `${this.layerPrefix}-heat-src`;
+    const layerId = `${this.layerPrefix}-heat-point`;
+    if (!mlMap.getSource(sourceId)) mlMap.addSource(sourceId, data);
+    try {
+      mlMap.addLayer({
+        id: layerId,
+        type: "heatmap",
+        source: sourceId,
+        paint: {
+          "heatmap-weight": [
+            "interpolate",
+            ["linear"],
+            ["get", "healthScore"],
+            0,
+            1,
+            50,
+            0.5,
+            100,
+            0
+          ],
+          "heatmap-intensity": 1,
+          "heatmap-color": [
+            "interpolate",
+            ["linear"],
+            ["heatmap-density"],
+            0,
+            "rgba(34,197,94,0)",
+            0.2,
+            "rgba(34,197,94,0.5)",
+            0.5,
+            "rgba(245,158,11,0.7)",
+            0.8,
+            "rgba(239,68,68,0.8)",
+            1,
+            "rgba(127,29,29,0.9)"
+          ],
+          "heatmap-radius": 25,
+          "heatmap-opacity": 0.7
+        }
+      });
+      this.layerIds.push(layerId);
+    } catch {
+    }
+  }
+};
+
+// src/nlpg/pipelineNlp.ts
+var PATTERNS = [
+  { intent: "burst", re: /(爆管|破裂|泄漏|故障|事故|爆裂)/, confidence: 0.95 },
+  { intent: "valve", re: /(阀门|闸).*?(关闭|关|合)|(?:关闭|关|合).*?(阀门|闸)/, confidence: 0.9 },
+  { intent: "material_age", re: /(\d+)\s*年.*?(铸铁|钢|PE|PVC|铜)/, confidence: 0.85 },
+  { intent: "material_age", re: /(铸铁|钢|PE|PVC|铜).*?(\d+)\s*年/, confidence: 0.85 },
+  { intent: "pressure", re: /压力.*?(低于|高于|小于|大于|<|>|>=|<=|低|高)\s*(\d+\.?\d*)/, confidence: 0.85 },
+  { intent: "nearby", re: /(\d+)\s*(米|m|公里|km).*?(学校|医院|工厂|消防|政府|小区)/, confidence: 0.85 },
+  { intent: "alarm_cluster", re: /报警|告警/, confidence: 0.8 }
+];
+var TYPE_REGEX = [
+  { type: "gas", re: /燃气|煤气|天然气/ },
+  { type: "water", re: /供水|自来水|水管/ },
+  { type: "drainage", re: /排水|污水|雨水/ },
+  { type: "heating", re: /供热|暖气|热力/ },
+  { type: "power", re: /电力|电缆|高压/ },
+  { type: "telecom", re: /通信|光纤|光缆/ }
+];
+var MATERIAL_REGEX = [
+  { key: "cast_iron", cname: "\u94F8\u94C1", re: /铸铁/ },
+  { key: "ductile_iron", cname: "\u7403\u58A8\u94F8\u94C1", re: /球墨/ },
+  { key: "steel", cname: "\u94A2", re: /钢/ },
+  { key: "pe", cname: "PE", re: /PE/ },
+  { key: "pvc", cname: "PVC", re: /PVC/ },
+  { key: "concrete", cname: "\u6DF7\u51DD\u571F", re: /混凝土/ },
+  { key: "hdpe", cname: "HDPE", re: /HDPE/ },
+  { key: "copper", cname: "\u94DC", re: /铜/ }
+];
+var REGION_REGEX = /(朝阳区|海淀区|江岸区|江汉区|硚口区|汉阳区|武昌区|青山区|洪山区|东西湖区|黄陂区|新洲区|江夏区|蔡甸区|汉南区)/;
+function parsePipelineQuery(query) {
+  let best = { intent: "unknown", confidence: 0 };
+  for (const p of PATTERNS) {
+    const m = query.match(p.re);
+    if (m) {
+      const c = p.confidence * (1 + 0.05 * (m[0].length / query.length));
+      if (c > best.confidence) best = { intent: p.intent, confidence: Math.min(c, 1) };
+    }
+  }
+  const filters = {};
+  for (const t of TYPE_REGEX) {
+    if (t.re.test(query)) {
+      filters.pipelineType = t.type;
+      break;
+    }
+  }
+  for (const m of MATERIAL_REGEX) {
+    if (m.re.test(query)) {
+      filters.material = m.key;
+      break;
+    }
+  }
+  const ageMatch = query.match(/(\d+)\s*年/);
+  if (ageMatch) {
+    const years = parseInt(ageMatch[1]);
+    if (best.intent === "material_age") {
+      if (/超[过于]/.test(query) || /[以]?上/.test(query)) filters.minAgeYears = years;
+      else if (/内|以下|不超/.test(query)) filters.maxAgeYears = years;
+      else filters.minAgeYears = years;
+    } else {
+      filters.minAgeYears = years;
+    }
+  }
+  const pressureMatch = query.match(/(\d+\.?\d*)\s*(MPa|mpa)/);
+  if (pressureMatch) {
+    const v = parseFloat(pressureMatch[1]);
+    if (/低|小于|小于等于|</.test(query)) filters.maxPressure = v;
+    else if (/高|大于|大于等于|>/.test(query)) filters.minPressure = v;
+    else filters.maxPressure = v;
+  } else if (/压力/.test(query)) {
+    filters.maxPressure = 0.2;
+  }
+  const distMatch = query.match(/(\d+)\s*(公里|km|千米|米|m)/);
+  if (distMatch) {
+    let d = parseInt(distMatch[1]);
+    const unit = distMatch[2];
+    if (/公里|km|千米/.test(unit)) d *= 1e3;
+    filters.radius = d;
+  }
+  if (/昨天/.test(query)) filters.timeWindow = "1d";
+  else if (/今天/.test(query)) filters.timeWindow = "1d";
+  else if (/最近一周|过去一周|7\s*天/.test(query)) filters.timeWindow = "7d";
+  else if (/最近一个月/.test(query)) filters.timeWindow = "30d";
+  const regionMatch = query.match(REGION_REGEX);
+  if (regionMatch) filters.region = regionMatch[1];
+  return {
+    intent: best.intent,
+    filters,
+    description: buildDescription(best.intent, filters),
+    confidence: best.confidence
+  };
+}
+function buildDescription(intent, f) {
+  const desc = [];
+  if (intent === "burst") desc.push("\u89E6\u53D1\u7206\u7BA1\u63A8\u6F14");
+  else if (intent === "valve") desc.push("\u67E5\u8BE2\u9600\u95E8\u5173\u95ED\u5F71\u54CD");
+  else if (intent === "material_age") {
+    const matName = MATERIAL_REGEX.find((m) => m.key === f.material)?.cname ?? f.material ?? "";
+    desc.push(`\u7B5B\u9009${matName}\u7BA1${f.minAgeYears ?? "?"}\u5E74\u4EE5\u4E0A`);
+  } else if (intent === "pressure") desc.push(`\u7B5B\u9009\u538B\u529B${f.maxPressure ?? ""}MPa\u4EE5\u4E0B`);
+  else if (intent === "nearby") desc.push(`${f.radius}m\u5185\u67E5\u627EPOI`);
+  else if (intent === "alarm_cluster") desc.push(`\u67E5\u8BE2${f.timeWindow ?? "1d"}\u5185\u62A5\u8B66\u805A\u96C6`);
+  if (f.pipelineType) desc.push(`[${f.pipelineType}]`);
+  if (f.region) desc.push(`\u533A\u57DF:${f.region}`);
+  return desc.join(" ");
+}
+
+// src/nlpg/pipelineNlpClass.ts
+var PipelineNlp = class {
+  burstSimulator;
+  onIntent;
+  constructor(options = {}) {
+    this.burstSimulator = options.burstSimulator;
+    this.onIntent = options.onIntent;
+  }
+  /** 解析并按意图触发动作 */
+  query(text) {
+    const result = parsePipelineQuery(text);
+    if (this.onIntent) this.onIntent(result.intent, result);
+    return result;
+  }
+  /** 仅解析不触发动作 */
+  parse(text) {
+    return parsePipelineQuery(text);
+  }
+  /** 关联 BurstSimulator */
+  setBurstSimulator(sim) {
+    this.burstSimulator = sim;
+  }
+};
+
+exports.BurstSimulator = BurstSimulator;
+exports.DEFAULT_WEIGHTS = DEFAULT_WEIGHTS;
+exports.HEALTH_LEVEL_COLORS = HEALTH_LEVEL_COLORS;
+exports.HEALTH_LEVEL_LABELS = HEALTH_LEVEL_LABELS;
+exports.LeakagePlume = LeakagePlume;
+exports.NODE_KIND_COLORS = NODE_KIND_COLORS;
+exports.NODE_KIND_ICONS = NODE_KIND_ICONS;
+exports.PIPELINE_TYPES = PIPELINE_TYPES;
+exports.PIPELINE_TYPE_COLORS = PIPELINE_TYPE_COLORS;
+exports.PIPELINE_TYPE_ICONS = PIPELINE_TYPE_ICONS;
+exports.PIPELINE_TYPE_LABELS = PIPELINE_TYPE_LABELS;
+exports.PIPE_MATERIAL_COLORS = PIPE_MATERIAL_COLORS;
+exports.PIPE_STATUS_COLORS = PIPE_STATUS_COLORS;
+exports.PIPE_STATUS_META = PIPE_STATUS_META;
+exports.PipelineHealth = PipelineHealth;
+exports.PipelineNlp = PipelineNlp;
+exports.PipelineTopology = PipelineTopology;
+exports.aggregateHeatmap = aggregateHeatmap;
+exports.bfs = bfs;
+exports.buildAdjacency = buildAdjacency;
+exports.buildLegend = buildLegend;
+exports.classifyFromMeteo = classifyFromMeteo;
+exports.classifyStability = classifyStability;
+exports.convexHull = convexHull;
+exports.detectCycles = detectCycles;
+exports.dfs = dfs;
+exports.dijkstra = dijkstra;
+exports.dispersionCoefficients = dispersionCoefficients;
+exports.edgesOf = edgesOf;
+exports.evaluateValvePlan = evaluateValvePlan;
+exports.findConnectedComponents = findConnectedComponents;
+exports.findPaths = findPaths;
+exports.findUpstreamNode = findUpstreamNode;
+exports.gaussianPlume = gaussianPlume;
+exports.haversine = haversine;
+exports.healthLevel = healthLevel;
+exports.heatmapToGeoJSON = heatmapToGeoJSON;
+exports.highlightConnectivity = highlightConnectivity;
+exports.impactAreaSquareMeters = impactAreaSquareMeters;
+exports.impactCenter = impactCenter;
+exports.legendByDiameter = legendByDiameter;
+exports.legendByHealth = legendByHealth;
+exports.legendByMaterial = legendByMaterial;
+exports.legendByStatus = legendByStatus;
+exports.legendByType = legendByType;
+exports.listCandidateValves = listCandidateValves;
+exports.multiSourceBfs = multiSourceBfs;
+exports.nearestNodeOnPipe = nearestNodeOnPipe;
+exports.neighborIds = neighborIds;
+exports.paintNodeByKind = paintNodeByKind;
+exports.paintPipeBy = paintPipeBy;
+exports.paintPipeByDiameter = paintPipeByDiameter;
+exports.paintPipeByHealth = paintPipeByHealth;
+exports.paintPipeByMaterial = paintPipeByMaterial;
+exports.paintPipeByStatus = paintPipeByStatus;
+exports.paintPipeByType = paintPipeByType;
+exports.paintPipeWidthByDiameter = paintPipeWidthByDiameter;
+exports.parsePipelineQuery = parsePipelineQuery;
+exports.pipeLengthFromGeometry = pipeLengthFromGeometry;
+exports.pipelineTypeColor = pipelineTypeColor;
+exports.prioritizeMaintenance = prioritizeMaintenance;
+exports.reconstructPath = reconstructPath;
+exports.scorePipeHealth = scorePipeHealth;
+exports.scorePipes = scorePipes;
+exports.simulateBurst = simulateBurst;
+exports.simulateFlood = simulateFlood;
+exports.toMapLayerData = toMapLayerData;
+exports.userSeverity = userSeverity;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map