@tabularis/explain 0.1.0

package/dist/index.js

@@ -0,0 +1,1792 @@
+// src/parsers/node.ts
+var NodeIdAllocator = class {
+  counter = 0;
+  next() {
+    const id = `node_${this.counter}`;
+    this.counter += 1;
+    return id;
+  }
+};
+function createExplainNode(id, overrides = {}) {
+  return {
+    id,
+    node_type: "Unknown",
+    relation: null,
+    startup_cost: null,
+    total_cost: null,
+    plan_rows: null,
+    actual_rows: null,
+    actual_time_ms: null,
+    actual_loops: null,
+    buffers_hit: null,
+    buffers_read: null,
+    filter: null,
+    index_condition: null,
+    join_type: null,
+    hash_condition: null,
+    extra: {},
+    children: [],
+    ...overrides
+  };
+}
+function hasAnalyzeDataRecursive(node) {
+  if (node.actual_rows !== null || node.actual_time_ms !== null) {
+    return true;
+  }
+  return node.children.some(hasAnalyzeDataRecursive);
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asLooseNumber(value) {
+  const direct = asNumber(value);
+  if (direct !== null) return direct;
+  const text = asString(value);
+  if (text === null || text.trim() === "") return null;
+  const parsed = Number(text);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function asLoopCount(value) {
+  const num = asNumber(value);
+  return num === null ? null : Math.trunc(num);
+}
+
+// src/parsers/mysql.ts
+function parseMysqlJson(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse EXPLAIN JSON: ${String(err)}`);
+  }
+  const doc = asObject(value);
+  const queryBlock = doc?.["query_block"];
+  if (queryBlock === void 0) {
+    throw new Error("EXPLAIN JSON missing 'query_block' key");
+  }
+  const ids = new NodeIdAllocator();
+  const root = parseMysqlQueryBlock(queryBlock, ids);
+  const planningTime = asNumber(asObject(doc?.["query_optimization"])?.["r_total_time_ms"]);
+  return {
+    root,
+    planning_time_ms: planningTime,
+    execution_time_ms: null,
+    original_query: "",
+    driver: "mysql",
+    has_analyze_data: hasAnalyzeDataRecursive(root),
+    raw_output: raw
+  };
+}
+function parseMysqlText(raw) {
+  if (raw.trim() === "") {
+    throw new Error("EXPLAIN ANALYZE returned no output");
+  }
+  const ids = new NodeIdAllocator();
+  const root = parseMysqlAnalyzeText(raw, ids);
+  return {
+    root,
+    planning_time_ms: null,
+    execution_time_ms: null,
+    original_query: "",
+    driver: "mysql",
+    has_analyze_data: hasAnalyzeDataRecursive(root),
+    raw_output: raw
+  };
+}
+function parseMariadbFilesort(value, ids) {
+  const id = ids.next();
+  const filesort = asObject(value) ?? {};
+  const extra = {};
+  for (const key of [
+    "sort_key",
+    "r_sort_mode",
+    "r_buffer_size",
+    "r_limit",
+    "r_used_priority_queue"
+  ]) {
+    if (filesort[key] !== void 0) {
+      extra[key] = filesort[key];
+    }
+  }
+  const children = [];
+  if (filesort["temporary_table"] !== void 0) {
+    children.push(parseMariadbTemporaryTable(filesort["temporary_table"], ids));
+  }
+  const nestedLoop = asArray(filesort["nested_loop"]);
+  if (nestedLoop !== null) {
+    for (const item of nestedLoop) {
+      children.push(parseMysqlQueryBlock(item, ids));
+    }
+  }
+  if (filesort["ordering_operation"] !== void 0) {
+    children.push(parseMysqlQueryBlock(filesort["ordering_operation"], ids));
+  }
+  if (filesort["table"] !== void 0 && filesort["nested_loop"] === void 0 && filesort["temporary_table"] === void 0) {
+    children.push(parseMysqlQueryBlock(filesort, ids));
+  }
+  return createExplainNode(id, {
+    node_type: "Filesort",
+    actual_rows: asNumber(filesort["r_output_rows"]),
+    actual_time_ms: asNumber(filesort["r_total_time_ms"]),
+    actual_loops: asLoopCount(filesort["r_loops"]),
+    extra,
+    children
+  });
+}
+function parseMariadbTemporaryTable(value, ids) {
+  const id = ids.next();
+  const tmpTbl = asObject(value) ?? {};
+  const children = [];
+  const nestedLoop = asArray(tmpTbl["nested_loop"]);
+  if (nestedLoop !== null) {
+    for (const item of nestedLoop) {
+      children.push(parseMysqlQueryBlock(item, ids));
+    }
+  }
+  if (tmpTbl["filesort"] !== void 0) {
+    children.push(parseMariadbFilesort(tmpTbl["filesort"], ids));
+  }
+  return createExplainNode(id, { node_type: "Temporary Table", children });
+}
+function parseMariadbSubqueryCache(value, ids) {
+  const id = ids.next();
+  const cache = asObject(value) ?? {};
+  const extra = {};
+  if (cache["r_hit_ratio"] !== void 0) {
+    extra["r_hit_ratio"] = cache["r_hit_ratio"];
+  }
+  const children = [];
+  if (cache["query_block"] !== void 0) {
+    children.push(parseMysqlQueryBlock(cache["query_block"], ids));
+  }
+  return createExplainNode(id, {
+    node_type: "Subquery Cache",
+    actual_loops: asLoopCount(cache["r_loops"]),
+    extra,
+    children
+  });
+}
+function parseMariadbWrapper(value, label, ids) {
+  const id = ids.next();
+  const obj = asObject(value) ?? {};
+  const children = [];
+  if (obj["table"] !== void 0) {
+    children.push(parseMysqlQueryBlock(obj, ids));
+  }
+  const nestedLoop = asArray(obj["nested_loop"]);
+  if (nestedLoop !== null) {
+    for (const item of nestedLoop) {
+      children.push(parseMysqlQueryBlock(item, ids));
+    }
+  }
+  if (asObject(obj["filesort"]) !== null) {
+    children.push(parseMariadbFilesort(obj["filesort"], ids));
+  }
+  if (obj["temporary_table"] !== void 0) {
+    children.push(parseMariadbTemporaryTable(obj["temporary_table"], ids));
+  }
+  if (obj["query_block"] !== void 0) {
+    children.push(parseMysqlQueryBlock(obj["query_block"], ids));
+  }
+  const specs = asArray(obj["query_specifications"]);
+  if (specs !== null) {
+    for (const spec of specs) {
+      children.push(parseMysqlQueryBlock(spec, ids));
+    }
+  }
+  if (obj["ordering_operation"] !== void 0) {
+    children.push(parseMysqlQueryBlock(obj["ordering_operation"], ids));
+  }
+  if (obj["grouping_operation"] !== void 0) {
+    children.push(parseMysqlQueryBlock(obj["grouping_operation"], ids));
+  }
+  const subs = asArray(obj["attached_subqueries"]);
+  if (subs !== null) {
+    for (const sq of subs) {
+      children.push(parseMysqlQueryBlock(sq, ids));
+    }
+  }
+  return createExplainNode(id, {
+    node_type: label,
+    total_cost: asLooseNumber(obj["cost"]),
+    actual_rows: asNumber(obj["r_rows"]) ?? asNumber(obj["r_output_rows"]),
+    actual_time_ms: asNumber(obj["r_total_time_ms"]),
+    actual_loops: asLoopCount(obj["r_loops"]),
+    children
+  });
+}
+var MYSQL_ACCESS_TYPES = {
+  ALL: "Full Table Scan",
+  index: "Index Scan",
+  range: "Range Scan",
+  ref: "Index Lookup",
+  eq_ref: "Unique Index Lookup",
+  const: "Const Lookup",
+  system: "Const Lookup",
+  fulltext: "Fulltext Search"
+};
+function parseMysqlQueryBlock(value, ids) {
+  const id = ids.next();
+  const block = asObject(value) ?? {};
+  let nodeType;
+  let relation = null;
+  let planRows = null;
+  let startupCost = null;
+  let totalCost = null;
+  let filter = null;
+  const table = asObject(block["table"]);
+  if (table !== null) {
+    const access = asString(table["access_type"]) ?? "ALL";
+    nodeType = MYSQL_ACCESS_TYPES[access] ?? access;
+    relation = asString(table["table_name"]);
+    planRows = asNumber(table["rows_examined_per_scan"]) ?? asNumber(table["rows"]);
+    const costInfo = asObject(table["cost_info"]);
+    startupCost = asLooseNumber(costInfo?.["read_cost"]);
+    totalCost = asLooseNumber(costInfo?.["prefix_cost"]) ?? startupCost ?? asLooseNumber(table["cost"]);
+    filter = asString(table["attached_condition"]);
+  } else {
+    if (asObject(block)?.["using_filesort"] === true) {
+      nodeType = "Filesort";
+    } else if (block["grouping_operation"] !== void 0) {
+      nodeType = "Group";
+    } else if (block["duplicates_removal"] !== void 0) {
+      nodeType = "Duplicate Removal";
+    } else if (block["having_condition"] !== void 0) {
+      nodeType = "Having Filter";
+    } else if (block["window_functions_computation"] !== void 0) {
+      nodeType = "Window Functions";
+    } else {
+      nodeType = "Query Block";
+    }
+    const costInfo = asObject(block["cost_info"]);
+    totalCost = asLooseNumber(
+      costInfo?.["query_cost"] ?? costInfo?.["sort_cost"] ?? costInfo?.["prefix_cost"]
+    ) ?? asLooseNumber(block["cost"]);
+    filter = asString(block["having_condition"]);
+  }
+  const knownKeys = [
+    "access_type",
+    "table_name",
+    "rows_examined_per_scan",
+    "rows",
+    "cost_info",
+    "attached_condition",
+    "key",
+    "possible_keys",
+    "used_key_parts"
+  ];
+  const extra = {};
+  if (table !== null) {
+    for (const [k, v] of Object.entries(table)) {
+      if (!knownKeys.includes(k)) {
+        extra[k] = v;
+      }
+    }
+    const key = asString(table["key"]);
+    if (key !== null) {
+      extra["key"] = key;
+    }
+  }
+  const children = [];
+  const nestedLoop = asArray(block["nested_loop"]);
+  if (nestedLoop !== null) {
+    for (const rawItem of nestedLoop) {
+      const item = asObject(rawItem) ?? {};
+      if (item["table"] !== void 0) {
+        children.push(parseMysqlQueryBlock(item, ids));
+      } else if (item["read_sorted_file"] !== void 0) {
+        children.push(parseMariadbWrapper(item["read_sorted_file"], "Read Sorted File", ids));
+      } else if (asObject(item["filesort"]) !== null) {
+        children.push(parseMariadbFilesort(item["filesort"], ids));
+      } else if (item["temporary_table"] !== void 0) {
+        children.push(parseMariadbTemporaryTable(item["temporary_table"], ids));
+      } else if (item["materialized"] !== void 0) {
+        children.push(parseMariadbWrapper(item["materialized"], "Materialized Subquery", ids));
+      } else if (item["buffer_result"] !== void 0) {
+        children.push(parseMariadbWrapper(item["buffer_result"], "Buffer Result", ids));
+      }
+    }
+  }
+  if (block["ordering_operation"] !== void 0) {
+    children.push(parseMysqlQueryBlock(block["ordering_operation"], ids));
+  }
+  if (block["grouping_operation"] !== void 0) {
+    children.push(parseMysqlQueryBlock(block["grouping_operation"], ids));
+  }
+  if (block["duplicates_removal"] !== void 0) {
+    children.push(parseMysqlQueryBlock(block["duplicates_removal"], ids));
+  }
+  for (const listKey of ["optimized_away_subqueries", "attached_subqueries"]) {
+    const list = asArray(block[listKey]);
+    if (list !== null) {
+      for (const sq of list) {
+        children.push(parseMysqlQueryBlock(sq, ids));
+      }
+    }
+  }
+  const subqueries = asArray(block["subqueries"]);
+  if (subqueries !== null) {
+    for (const rawSq of subqueries) {
+      const sq = asObject(rawSq) ?? {};
+      if (sq["subquery_cache"] !== void 0) {
+        children.push(parseMariadbSubqueryCache(sq["subquery_cache"], ids));
+      } else if (sq["query_block"] !== void 0 || sq["table"] !== void 0) {
+        children.push(parseMysqlQueryBlock(sq, ids));
+      }
+    }
+  }
+  if (asObject(block["filesort"]) !== null) {
+    children.push(parseMariadbFilesort(block["filesort"], ids));
+  }
+  if (block["temporary_table"] !== void 0) {
+    children.push(parseMariadbTemporaryTable(block["temporary_table"], ids));
+  }
+  if (block["materialized"] !== void 0) {
+    children.push(parseMariadbWrapper(block["materialized"], "Materialized Subquery", ids));
+  }
+  if (block["union_result"] !== void 0) {
+    children.push(parseMariadbWrapper(block["union_result"], "Union Result", ids));
+  }
+  if (block["buffer_result"] !== void 0) {
+    children.push(parseMariadbWrapper(block["buffer_result"], "Buffer Result", ids));
+  }
+  if (block["window_functions_computation"] !== void 0) {
+    children.push(
+      parseMariadbWrapper(block["window_functions_computation"], "Window Functions", ids)
+    );
+  }
+  if (block["expression_cache"] !== void 0) {
+    children.push(parseMariadbWrapper(block["expression_cache"], "Expression Cache", ids));
+  }
+  if (block["read_sorted_file"] !== void 0) {
+    children.push(parseMariadbWrapper(block["read_sorted_file"], "Read Sorted File", ids));
+  }
+  const specs = asArray(block["query_specifications"]);
+  if (specs !== null) {
+    for (const spec of specs) {
+      children.push(parseMysqlQueryBlock(spec, ids));
+    }
+  }
+  const indexCondition = table !== null ? asString(table["key"]) : null;
+  let actualTimeMs = asNumber(table?.["r_total_time_ms"]);
+  if (actualTimeMs === null && table !== null) {
+    const tableMs = asNumber(table["r_table_time_ms"]);
+    const otherMs = asNumber(table["r_other_time_ms"]);
+    if (tableMs !== null) {
+      actualTimeMs = otherMs !== null ? tableMs + otherMs : tableMs;
+    }
+  }
+  if (actualTimeMs === null) {
+    actualTimeMs = asNumber(block["r_total_time_ms"]);
+  }
+  const actualRows = asNumber(table?.["r_rows"]) ?? asNumber(block["r_rows"]);
+  const actualLoops = asLoopCount(table?.["r_loops"]) ?? asLoopCount(block["r_loops"]);
+  return createExplainNode(id, {
+    node_type: nodeType,
+    relation,
+    startup_cost: startupCost,
+    total_cost: totalCost,
+    plan_rows: planRows,
+    actual_rows: actualRows,
+    actual_time_ms: actualTimeMs,
+    actual_loops: actualLoops,
+    filter,
+    index_condition: indexCondition,
+    extra,
+    children
+  });
+}
+function parseMysqlAnalyzeText(text, ids) {
+  const parsedLines = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.replace(/\s+$/, "");
+    if (trimmed === "") continue;
+    const leading = trimmed.length - trimmed.trimStart().length;
+    const depth = Math.floor(leading / 4);
+    const content = trimmed.trimStart();
+    if (!content.startsWith("-> ")) continue;
+    const descRest = content.slice(3);
+    const descEnd = descRest.indexOf("  (");
+    const description = descEnd === -1 ? descRest : descRest.slice(0, descEnd);
+    const metrics = descEnd === -1 ? "" : descRest.slice(descEnd);
+    const [estCost, estRows] = parseAnalyzeEstimated(metrics);
+    const [actualTimeMs, actualRows, actualLoops] = parseAnalyzeActual(metrics);
+    const [nodeType, relation, filter, indexCondition, joinType] = mapAnalyzeDescription(description);
+    parsedLines.push({
+      depth,
+      node_type: nodeType,
+      relation,
+      filter,
+      index_condition: indexCondition,
+      join_type: joinType,
+      est_cost: estCost,
+      est_rows: estRows,
+      actual_time_ms: actualTimeMs,
+      actual_rows: actualRows,
+      actual_loops: actualLoops
+    });
+  }
+  if (parsedLines.length === 0) {
+    return createExplainNode(ids.next(), { node_type: "Query" });
+  }
+  const [roots] = buildAnalyzeTree(parsedLines, 0, -1, ids);
+  if (roots.length === 1) {
+    return roots[0];
+  }
+  return createExplainNode(ids.next(), { node_type: "Query", children: roots });
+}
+function buildAnalyzeTree(lines, start, parentDepth, ids) {
+  const children = [];
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.depth <= parentDepth) break;
+    const id = ids.next();
+    const [grandchildren, nextI] = buildAnalyzeTree(lines, i + 1, line.depth, ids);
+    children.push(
+      createExplainNode(id, {
+        node_type: line.node_type,
+        relation: line.relation,
+        total_cost: line.est_cost,
+        plan_rows: line.est_rows,
+        actual_rows: line.actual_rows,
+        actual_time_ms: line.actual_time_ms,
+        actual_loops: line.actual_loops,
+        filter: line.filter,
+        index_condition: line.index_condition,
+        join_type: line.join_type,
+        children: grandchildren
+      })
+    );
+    i = nextI;
+  }
+  return [children, i];
+}
+function parseAnalyzeEstimated(s) {
+  const idx = s.indexOf("(cost=");
+  if (idx === -1) return [null, null];
+  const section = s.slice(idx);
+  const end = section.indexOf(")");
+  if (end === -1) return [null, null];
+  const inner = section.slice(1, end);
+  let cost = null;
+  let rows = null;
+  for (const part of inner.split(/\s+/)) {
+    if (part.startsWith("cost=")) {
+      cost = parseAnalyzeNumber(part.slice(5));
+    } else if (part.startsWith("rows=")) {
+      rows = parseAnalyzeNumber(part.slice(5));
+    }
+  }
+  return [cost, rows];
+}
+function parseAnalyzeActual(s) {
+  const idx = s.indexOf("(actual time=");
+  if (idx === -1) return [null, null, null];
+  const section = s.slice(idx);
+  const end = section.indexOf(")");
+  if (end === -1) return [null, null, null];
+  const inner = section.slice(1, end);
+  let perLoopTimeMs = null;
+  let rows = null;
+  let loops = null;
+  for (const part of inner.split(/\s+/)) {
+    if (part.startsWith("time=")) {
+      const val = part.slice(5);
+      const dotPos = val.indexOf("..");
+      perLoopTimeMs = parseAnalyzeNumber(dotPos === -1 ? val : val.slice(dotPos + 2));
+    } else if (part.startsWith("rows=")) {
+      rows = parseAnalyzeNumber(part.slice(5));
+    } else if (part.startsWith("loops=")) {
+      loops = parseAnalyzeNumber(part.slice(6));
+    }
+  }
+  const timeMs = perLoopTimeMs !== null && loops !== null ? perLoopTimeMs * loops : perLoopTimeMs;
+  return [timeMs, rows, loops];
+}
+function parseAnalyzeNumber(text) {
+  if (text.trim() === "") return null;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : null;
+}
+function mapAnalyzeDescription(desc) {
+  const lower = desc.toLowerCase();
+  const relation = extractOnRelation(desc);
+  const indexCond = extractUsingIndex(desc);
+  let nodeType;
+  let filter = null;
+  let joinType = null;
+  if (lower.startsWith("table scan")) {
+    nodeType = "Full Table Scan";
+  } else if (lower.startsWith("covering index scan")) {
+    nodeType = "Index Only Scan";
+  } else if (lower.startsWith("index range scan") || lower.startsWith("range scan")) {
+    nodeType = "Range Scan";
+  } else if (lower.startsWith("index scan")) {
+    nodeType = "Index Scan";
+  } else if (lower.startsWith("single-row index lookup")) {
+    nodeType = "Unique Index Lookup";
+  } else if (lower.startsWith("index lookup") || lower.startsWith("multi-range index lookup")) {
+    nodeType = "Index Lookup";
+  } else if (lower.startsWith("constant row")) {
+    nodeType = "Const Lookup";
+  } else if (lower.startsWith("nested loop")) {
+    nodeType = "Nested Loop";
+    if (lower.includes("inner")) joinType = "Inner";
+    else if (lower.includes("left")) joinType = "Left";
+    else if (lower.includes("semijoin")) joinType = "Semi";
+    else if (lower.includes("antijoin") || lower.includes("anti")) joinType = "Anti";
+  } else if (lower.includes("hash join")) {
+    nodeType = "Hash Join";
+    joinType = lower.includes("left") ? "Left" : "Inner";
+  } else if (lower.startsWith("filter:")) {
+    nodeType = "Filter";
+    const filt = desc.slice(7).trim();
+    filter = filt === "" ? null : filt;
+  } else if (lower.startsWith("sort:") || lower.startsWith("sort row")) {
+    nodeType = "Sort";
+  } else if (lower.startsWith("limit:") || lower.startsWith("limit ")) {
+    nodeType = "Limit";
+  } else if (lower.startsWith("group aggregate") || lower.startsWith("aggregate")) {
+    nodeType = "Aggregate";
+  } else if (lower.startsWith("temporary table") || lower.startsWith("materialize")) {
+    nodeType = "Materialize";
+  } else if (lower.startsWith("stream results") || lower.startsWith("stream")) {
+    nodeType = "Stream";
+  } else if (lower.startsWith("window aggregate") || lower.startsWith("window")) {
+    nodeType = "Window";
+  } else {
+    nodeType = desc;
+  }
+  return [nodeType, relation, filter, indexCond, joinType];
+}
+function extractOnRelation(desc) {
+  const pos = desc.indexOf(" on ");
+  if (pos === -1) return null;
+  const after = desc.slice(pos + 4);
+  const endMatch = after.search(/[ (]/);
+  const name = (endMatch === -1 ? after : after.slice(0, endMatch)).trim();
+  return name === "" ? null : name;
+}
+function extractUsingIndex(desc) {
+  const pos = desc.toLowerCase().indexOf(" using ");
+  if (pos === -1) return null;
+  const after = desc.slice(pos + 7);
+  const endMatch = after.search(/[ (]/);
+  const name = (endMatch === -1 ? after : after.slice(0, endMatch)).trim();
+  return name === "" ? null : name;
+}
+function parseMysqlTabularRows(rows) {
+  const ids = new NodeIdAllocator();
+  const rootId = ids.next();
+  const rawLines = [];
+  const children = [];
+  for (const row of rows) {
+    const accessType = row.access_type ?? "";
+    const nodeType = accessType === "" ? "Unknown" : MYSQL_ACCESS_TYPES[accessType] ?? accessType;
+    rawLines.push(
+      [
+        row.select_type,
+        row.table ?? "",
+        accessType,
+        row.key ?? "-",
+        row.rows ?? 0,
+        row.extra ?? ""
+      ].join("	")
+    );
+    const extra = { select_type: row.select_type };
+    if (row.possible_keys !== null) extra["possible_keys"] = row.possible_keys;
+    if (row.filtered !== null) extra["filtered"] = row.filtered;
+    if (row.extra !== null) extra["extra"] = row.extra;
+    children.push(
+      createExplainNode(ids.next(), {
+        node_type: nodeType,
+        relation: row.table === null || row.table === "" ? null : row.table,
+        plan_rows: row.rows,
+        filter: row.extra,
+        index_condition: row.key,
+        extra
+      })
+    );
+  }
+  const root = createExplainNode(rootId, { node_type: "Query", children });
+  return {
+    root,
+    planning_time_ms: null,
+    execution_time_ms: null,
+    original_query: "",
+    driver: "mysql",
+    has_analyze_data: false,
+    raw_output: rawLines.join("\n")
+  };
+}
+
+// src/parsers/postgres.ts
+function parsePostgresJson(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse EXPLAIN JSON: ${String(err)}`);
+  }
+  const top = firstStatement(value);
+  const planObj = top["Plan"];
+  if (planObj === void 0) {
+    throw new Error("EXPLAIN JSON missing 'Plan' key");
+  }
+  const ids = new NodeIdAllocator();
+  const root = parsePgPlanNode(planObj, ids);
+  const planningTime = asNumber(top["Planning Time"]);
+  const executionTime = asNumber(top["Execution Time"]);
+  const hasAnalyzeData = root.actual_rows !== null || root.actual_time_ms !== null;
+  return {
+    root,
+    planning_time_ms: planningTime,
+    execution_time_ms: executionTime,
+    original_query: "",
+    driver: "postgres",
+    has_analyze_data: hasAnalyzeData,
+    raw_output: raw
+  };
+}
+function firstStatement(value) {
+  if (Array.isArray(value)) {
+    const first = asObject(value[0]);
+    if (first === null) {
+      throw new Error("EXPLAIN JSON array is empty");
+    }
+    return first;
+  }
+  const obj = asObject(value);
+  if (obj !== null) {
+    return obj;
+  }
+  throw new Error("EXPLAIN JSON must be an array or object");
+}
+var PG_KNOWN_KEYS = [
+  "Node Type",
+  "Relation Name",
+  "Startup Cost",
+  "Total Cost",
+  "Plan Rows",
+  "Actual Rows",
+  "Actual Total Time",
+  "Actual Loops",
+  "Shared Hit Blocks",
+  "Shared Read Blocks",
+  "Filter",
+  "Index Cond",
+  "Join Type",
+  "Hash Cond",
+  "Plans"
+];
+function parsePgPlanNode(node, ids) {
+  const id = ids.next();
+  const obj = asObject(node) ?? {};
+  const extra = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!PG_KNOWN_KEYS.includes(key)) {
+      extra[key] = value;
+    }
+  }
+  const children = (asArray(obj["Plans"]) ?? []).map(
+    (child) => parsePgPlanNode(child, ids)
+  );
+  return createExplainNode(id, {
+    node_type: asString(obj["Node Type"]) ?? "Unknown",
+    relation: asString(obj["Relation Name"]),
+    startup_cost: asNumber(obj["Startup Cost"]),
+    total_cost: asNumber(obj["Total Cost"]),
+    plan_rows: asNumber(obj["Plan Rows"]),
+    actual_rows: asNumber(obj["Actual Rows"]),
+    actual_time_ms: asNumber(obj["Actual Total Time"]),
+    actual_loops: asLoopCount(obj["Actual Loops"]),
+    buffers_hit: asLoopCount(obj["Shared Hit Blocks"]),
+    buffers_read: asLoopCount(obj["Shared Read Blocks"]),
+    filter: asString(obj["Filter"]),
+    index_condition: asString(obj["Index Cond"]),
+    join_type: asString(obj["Join Type"]),
+    hash_condition: asString(obj["Hash Cond"]),
+    extra,
+    children
+  });
+}
+function parsePostgresText(raw) {
+  let planningTime = null;
+  let executionTime = null;
+  let hasAnalyzeData = false;
+  const ids = new NodeIdAllocator();
+  const stack = [];
+  let root = null;
+  const promoteOrAttach = (node) => {
+    const parent = stack[stack.length - 1];
+    if (parent !== void 0) {
+      parent.node.children.push(node);
+    } else if (root === null) {
+      root = node;
+    } else {
+      root.children.push(node);
+    }
+  };
+  const popUntilShallower = (cutoff) => {
+    while (stack.length > 0 && stack[stack.length - 1].indent >= cutoff) {
+      const frame = stack.pop();
+      if (frame !== void 0) {
+        promoteOrAttach(frame.node);
+      }
+    }
+  };
+  for (const line of raw.split("\n")) {
+    const rawLine = line.replace(/\s+$/, "");
+    if (rawLine.trim() === "") continue;
+    if (isTextMetadataLine(rawLine)) continue;
+    const indent = leadingWidth(rawLine);
+    const trimmed = rawLine.trimStart();
+    const planning = stripMsSuffix(trimmed, "Planning Time:");
+    if (planning !== null) {
+      planningTime = planning;
+      continue;
+    }
+    const execution = stripMsSuffix(trimmed, "Execution Time:");
+    if (execution !== null) {
+      executionTime = execution;
+      continue;
+    }
+    const node = parseTextNodeHeader(trimmed, ids);
+    if (node !== null) {
+      if (node.actual_rows !== null || node.actual_time_ms !== null) {
+        hasAnalyzeData = true;
+      }
+      popUntilShallower(indent);
+      stack.push({ indent, node });
+    } else {
+      const top = stack[stack.length - 1];
+      if (top !== void 0) {
+        applyTextAttribute(top.node, trimmed);
+      }
+    }
+  }
+  popUntilShallower(0);
+  if (root === null) {
+    throw new Error("No plan nodes found in EXPLAIN text output");
+  }
+  return {
+    root,
+    planning_time_ms: planningTime,
+    execution_time_ms: executionTime,
+    original_query: "",
+    driver: "postgres",
+    has_analyze_data: hasAnalyzeData,
+    raw_output: raw
+  };
+}
+function isTextMetadataLine(line) {
+  const t = line.trim();
+  if (t.toUpperCase() === "QUERY PLAN") return true;
+  if (t !== "" && [...t].every((c) => c === "-")) return true;
+  if (t.startsWith("(") && (t.endsWith("rows)") || t.endsWith("row)"))) return true;
+  return false;
+}
+function leadingWidth(line) {
+  let count = 0;
+  for (const ch of line) {
+    if (/\s/.test(ch)) count += 1;
+    else break;
+  }
+  return count;
+}
+function stripMsSuffix(line, prefix) {
+  if (!line.startsWith(prefix)) return null;
+  let rest = line.slice(prefix.length).trim();
+  if (rest.endsWith("ms")) rest = rest.slice(0, -2).trim();
+  const value = Number(rest);
+  return rest !== "" && Number.isFinite(value) ? value : null;
+}
+function parseTextNodeHeader(content, ids) {
+  const body = content.startsWith("->") ? content.slice(2).trimStart() : content;
+  const costPos = body.indexOf("(cost=");
+  if (costPos === -1) return null;
+  const header = body.slice(0, costPos).trim();
+  const tail = body.slice(costPos);
+  const costGroup = extractParens(tail);
+  if (costGroup === null) return null;
+  const [startupCost, totalCost, planRows] = parseCostFields(costGroup.inner);
+  const actualSection = costGroup.rest.trimStart();
+  const actualGroup = extractParens(actualSection);
+  const [actualTimeMs, actualRows, actualLoops] = actualGroup !== null ? parseActualFields(actualGroup.inner) : [null, null, null];
+  const [nodeType, relation] = splitNodeTypeAndRelation(header);
+  return createExplainNode(ids.next(), {
+    node_type: nodeType,
+    relation,
+    startup_cost: startupCost,
+    total_cost: totalCost,
+    plan_rows: planRows,
+    actual_rows: actualRows,
+    actual_time_ms: actualTimeMs,
+    actual_loops: actualLoops
+  });
+}
+function splitNodeTypeAndRelation(header) {
+  const idx = header.lastIndexOf(" on ");
+  if (idx === -1) return [header.trim(), null];
+  const nodeType = header.slice(0, idx).trim();
+  const relation = header.slice(idx + 4).trim();
+  return relation === "" ? [nodeType, null] : [nodeType, relation];
+}
+function extractParens(input) {
+  if (!input.startsWith("(")) return null;
+  let depth = 0;
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        return { inner: input.slice(1, i), rest: input.slice(i + 1) };
+      }
+    }
+  }
+  return null;
+}
+function parseCostFields(inner) {
+  let startup = null;
+  let total = null;
+  let rows = null;
+  if (inner.startsWith("cost=")) {
+    const parts = inner.slice(5).split(/\s+/);
+    const costExpr = parts[0];
+    if (costExpr !== void 0) {
+      const sep = costExpr.indexOf("..");
+      if (sep !== -1) {
+        startup = parseFiniteNumber(costExpr.slice(0, sep));
+        total = parseFiniteNumber(costExpr.slice(sep + 2));
+      }
+    }
+    for (const part of parts.slice(1)) {
+      if (part.startsWith("rows=")) {
+        rows = parseFiniteNumber(part.slice(5));
+      }
+    }
+  }
+  return [startup, total, rows];
+}
+function parseActualFields(inner) {
+  const trimmed = inner.trim();
+  if (trimmed.toLowerCase() === "never executed") {
+    return [null, null, null];
+  }
+  const rest = trimmed.startsWith("actual ") ? trimmed.slice(7) : trimmed;
+  let totalTime = null;
+  let rows = null;
+  let loops = null;
+  for (const part of rest.split(/\s+/)) {
+    if (part.startsWith("time=")) {
+      const expr = part.slice(5);
+      const sep = expr.indexOf("..");
+      if (sep !== -1) {
+        totalTime = parseFiniteNumber(expr.slice(sep + 2));
+      }
+    } else if (part.startsWith("rows=")) {
+      rows = parseFiniteNumber(part.slice(5));
+    } else if (part.startsWith("loops=")) {
+      loops = parseFiniteNumber(part.slice(6));
+    }
+  }
+  return [totalTime, rows, loops];
+}
+function parseFiniteNumber(text) {
+  if (text.trim() === "") return null;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : null;
+}
+function applyTextAttribute(node, content) {
+  if (content.startsWith("Filter:")) {
+    node.filter = content.slice("Filter:".length).trim();
+  } else if (content.startsWith("Index Cond:")) {
+    node.index_condition = content.slice("Index Cond:".length).trim();
+  } else if (content.startsWith("Hash Cond:")) {
+    node.hash_condition = content.slice("Hash Cond:".length).trim();
+  } else if (content.startsWith("Join Type:")) {
+    node.join_type = content.slice("Join Type:".length).trim();
+  } else {
+    const sep = content.indexOf(":");
+    if (sep !== -1) {
+      node.extra[content.slice(0, sep).trim()] = content.slice(sep + 1).trim();
+    }
+  }
+}
+
+// src/parsers/source.ts
+var SOURCE_PARSERS = [
+  { engine: "postgres", format: "postgres-json", parse: parsePostgresJson },
+  { engine: "postgres", format: "postgres-text", parse: parsePostgresText },
+  { engine: "mysql", format: "mysql-json", parse: parseMysqlJson },
+  { engine: "mysql", format: "mysql-text", parse: parseMysqlText }
+];
+function parserFor(format) {
+  const parser = SOURCE_PARSERS.find((candidate) => candidate.format === format);
+  if (parser === void 0) {
+    throw new Error(`No parser registered for format '${format}'`);
+  }
+  return parser;
+}
+function explainEngineFromDriverName(name) {
+  switch (name.trim().toLowerCase()) {
+    case "postgres":
+    case "postgresql":
+    case "pg":
+      return "postgres";
+    case "mysql":
+    case "mariadb":
+      return "mysql";
+    case "sqlite":
+    case "sqlite3":
+      return "sqlite";
+    default:
+      return null;
+  }
+}
+function detectFormat(raw) {
+  return detectFormatFor(raw, null);
+}
+function detectFormatFor(raw, engine) {
+  switch (engine) {
+    case "postgres":
+    case null:
+      if (looksLikeJson(raw)) return "postgres-json";
+      if (looksLikePostgresText(raw)) return "postgres-text";
+      throw new Error(
+        "Unsupported EXPLAIN file format: expected Postgres JSON or text output"
+      );
+    case "mysql":
+      if (looksLikeJson(raw)) return "mysql-json";
+      if (raw.trim() === "") {
+        throw new Error("Unsupported EXPLAIN file format: input is empty");
+      }
+      return "mysql-text";
+    case "sqlite":
+      throw new Error(
+        "SQLite EXPLAIN QUERY PLAN has no text form here: pass its (id, parent, detail) rows to buildSqliteTree"
+      );
+  }
+}
+function looksLikeJson(raw) {
+  const trimmed = raw.trimStart();
+  return trimmed.startsWith("[") || trimmed.startsWith("{");
+}
+function looksLikePostgresText(raw) {
+  return raw.split("\n").some((line) => line.includes("(cost=") && line.includes("width="));
+}
+function parseExplain(raw) {
+  return parseExplainFor(raw, null);
+}
+function parseExplainFor(raw, engine) {
+  return parserFor(detectFormatFor(raw, engine)).parse(raw);
+}
+function withSourceLabel(plan, name) {
+  if (plan.original_query === "") {
+    return { ...plan, original_query: `-- loaded from ${name}` };
+  }
+  return plan;
+}
+
+// src/parsers/sqlite.ts
+function buildSqliteTree(entries, parentId, ids) {
+  const rootEntry = entries.find(
+    (entry) => parentId === 0 ? entry.parent === 0 && entry.id === 0 : entry.id === parentId
+  );
+  const [nodeType, relation, indexCondition] = rootEntry !== void 0 ? parseSqliteDetail(rootEntry.detail) : ["Query Plan", null, null];
+  const id = ids.next();
+  const rootId = rootEntry?.id ?? 0;
+  const childIds = entries.filter((entry) => entry.parent === rootId && entry.id !== rootId).map((entry) => entry.id);
+  const children = childIds.map((childId) => {
+    const childEntry = entries.find((entry) => entry.id === childId);
+    const [ct, cr, ci] = childEntry !== void 0 ? parseSqliteDetail(childEntry.detail) : ["Unknown", null, null];
+    const childNodeId = ids.next();
+    const grandchildren = entries.filter((entry) => entry.parent === childId).map((entry) => buildSqliteTree(entries, entry.id, ids));
+    return createExplainNode(childNodeId, {
+      node_type: ct,
+      relation: cr,
+      index_condition: ci,
+      children: grandchildren
+    });
+  });
+  return createExplainNode(id, {
+    node_type: nodeType,
+    relation,
+    index_condition: indexCondition,
+    children
+  });
+}
+function parseSqliteEqpRows(entries) {
+  if (entries.length === 0) {
+    throw new Error("EXPLAIN QUERY PLAN returned no output");
+  }
+  const ids = new NodeIdAllocator();
+  const root = buildSqliteTree(entries, 0, ids);
+  const rawOutput = entries.map((entry) => `${entry.id}|${entry.parent}|${entry.detail}`).join("\n");
+  return {
+    root,
+    planning_time_ms: null,
+    execution_time_ms: null,
+    original_query: "",
+    driver: "sqlite",
+    has_analyze_data: false,
+    raw_output: rawOutput
+  };
+}
+function parseSqliteDetail(detail) {
+  const detailUpper = detail.toUpperCase();
+  if (detailUpper.startsWith("SCAN")) {
+    const parts = detail.split(" ");
+    const relation = parts[1] ?? null;
+    let index = null;
+    if (detailUpper.includes("USING INDEX")) {
+      index = detail.slice(detail.indexOf("USING INDEX") + 12).trim();
+    } else if (detailUpper.includes("USING COVERING INDEX")) {
+      index = detail.slice(detail.indexOf("USING COVERING INDEX") + 21).trim();
+    }
+    return ["Scan", relation, index];
+  }
+  if (detailUpper.startsWith("SEARCH")) {
+    const parts = detail.split(" ");
+    const relation = parts[1] ?? null;
+    let index = null;
+    if (detailUpper.includes("USING INDEX")) {
+      index = detail.slice(detail.indexOf("USING INDEX") + 12).trim();
+    } else if (detailUpper.includes("USING INTEGER PRIMARY KEY")) {
+      index = "PRIMARY KEY";
+    } else if (detailUpper.includes("USING COVERING INDEX")) {
+      index = detail.slice(detail.indexOf("USING COVERING INDEX") + 21).trim();
+    }
+    return ["Search", relation, index];
+  }
+  if (detailUpper.includes("TEMP B-TREE")) {
+    return ["Sort", null, null];
+  }
+  if (detailUpper.startsWith("CO-ROUTINE")) {
+    return ["Co-routine", null, null];
+  }
+  if (detailUpper.startsWith("COMPOUND SUBQUERIES")) {
+    return ["Compound Subquery", null, null];
+  }
+  if (detailUpper.startsWith("MATERIALIZE")) {
+    return ["Materialize", null, null];
+  }
+  return [detail, null, null];
+}
+
+// src/raw.ts
+function parseRawExplain(raw) {
+  const plan = parseRawPayload(raw);
+  return {
+    ...plan,
+    driver: raw.engine,
+    original_query: raw.original_query
+  };
+}
+function resolveExplainOutput(output) {
+  return output.kind === "plan" ? output.plan : parseRawExplain(output.raw);
+}
+function parseRawPayload(raw) {
+  switch (raw.format) {
+    case "postgres-json":
+      return parsePostgresJson(raw.payload);
+    case "mysql-json":
+      return parseMysqlJson(raw.payload);
+    case "mysql-analyze-text":
+      return parseMysqlText(raw.payload);
+    case "mysql-tabular-rows":
+      return parseMysqlTabularRows(parseJsonRows(raw));
+    case "sqlite-eqp-rows":
+      return parseSqliteEqpRows(parseJsonRows(raw));
+  }
+}
+function parseJsonRows(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw.payload);
+  } catch (err) {
+    throw new Error(`Failed to parse EXPLAIN rows: ${String(err)}`);
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`EXPLAIN rows payload for '${raw.format}' must be a JSON array`);
+  }
+  return value;
+}
+
+// src/metrics.ts
+var EXPLAIN_METRIC_KINDS = [
+  "time",
+  "rows",
+  "cost",
+  "buffers"
+];
+function loopCount(node) {
+  return node.actual_loops != null && node.actual_loops > 0 ? node.actual_loops : 1;
+}
+function isSubplanChild(node) {
+  const relationship = node.extra["Parent Relationship"];
+  return relationship === "InitPlan" || relationship === "SubPlan";
+}
+function bufferCount(node) {
+  if (node.buffers_hit == null && node.buffers_read == null) {
+    return null;
+  }
+  return (node.buffers_hit ?? 0) + (node.buffers_read ?? 0);
+}
+function selfValue(total, childSum) {
+  if (total == null) {
+    return null;
+  }
+  return Math.max(0, total - childSum);
+}
+function computeExplainMetrics(plan) {
+  const byId = /* @__PURE__ */ new Map();
+  const order = [];
+  let nextIndex = 1;
+  function walk(node, depth) {
+    const metrics = {
+      nodeId: node.id,
+      index: nextIndex,
+      depth,
+      inclusiveTimeMs: null,
+      exclusiveTimeMs: null,
+      totalCost: node.total_cost,
+      exclusiveCost: null,
+      totalRows: null,
+      inclusiveBuffers: bufferCount(node),
+      exclusiveBuffers: null,
+      timeShare: null,
+      neverExecuted: node.actual_loops === 0
+    };
+    nextIndex += 1;
+    byId.set(node.id, metrics);
+    order.push(metrics);
+    let childTimeMs = 0;
+    let childCost = 0;
+    let childBuffers = 0;
+    for (const child of node.children) {
+      const contribution = walk(child, depth + 1);
+      childCost += contribution.cost;
+      childBuffers += contribution.buffers;
+      if (!isSubplanChild(child)) {
+        childTimeMs += contribution.timeMs;
+      }
+    }
+    const loops = loopCount(node);
+    metrics.inclusiveTimeMs = node.actual_time_ms != null ? node.actual_time_ms * loops : null;
+    metrics.exclusiveTimeMs = selfValue(metrics.inclusiveTimeMs, childTimeMs);
+    metrics.exclusiveCost = selfValue(metrics.totalCost, childCost);
+    metrics.exclusiveBuffers = selfValue(metrics.inclusiveBuffers, childBuffers);
+    metrics.totalRows = node.actual_rows != null ? node.actual_rows * loops : null;
+    return {
+      timeMs: metrics.inclusiveTimeMs ?? 0,
+      cost: metrics.totalCost ?? 0,
+      buffers: metrics.inclusiveBuffers ?? 0
+    };
+  }
+  walk(plan.root, 0);
+  let maxExclusiveTimeMs = 0;
+  let maxExclusiveCost = 0;
+  let maxTotalRows = 0;
+  let maxExclusiveBuffers = 0;
+  let totalExclusiveTimeMs = 0;
+  for (const metrics of order) {
+    maxExclusiveTimeMs = Math.max(
+      maxExclusiveTimeMs,
+      metrics.exclusiveTimeMs ?? 0
+    );
+    maxExclusiveCost = Math.max(maxExclusiveCost, metrics.exclusiveCost ?? 0);
+    maxTotalRows = Math.max(maxTotalRows, metrics.totalRows ?? 0);
+    maxExclusiveBuffers = Math.max(
+      maxExclusiveBuffers,
+      metrics.exclusiveBuffers ?? 0
+    );
+    totalExclusiveTimeMs += metrics.exclusiveTimeMs ?? 0;
+  }
+  if (totalExclusiveTimeMs > 0) {
+    for (const metrics of order) {
+      if (metrics.exclusiveTimeMs != null) {
+        metrics.timeShare = metrics.exclusiveTimeMs / totalExclusiveTimeMs;
+      }
+    }
+  }
+  return {
+    byId,
+    order,
+    maxExclusiveTimeMs,
+    maxExclusiveCost,
+    maxTotalRows,
+    maxExclusiveBuffers,
+    totalExclusiveTimeMs
+  };
+}
+function getNodeMetrics(metrics, nodeId) {
+  if (!nodeId) {
+    return null;
+  }
+  return metrics.byId.get(nodeId) ?? null;
+}
+function getMetricValue(metrics, kind) {
+  switch (kind) {
+    case "time":
+      return metrics.exclusiveTimeMs;
+    case "rows":
+      return metrics.totalRows;
+    case "cost":
+      return metrics.exclusiveCost;
+    case "buffers":
+      return metrics.exclusiveBuffers;
+  }
+}
+function getMetricMax(metrics, kind) {
+  switch (kind) {
+    case "time":
+      return metrics.maxExclusiveTimeMs;
+    case "rows":
+      return metrics.maxTotalRows;
+    case "cost":
+      return metrics.maxExclusiveCost;
+    case "buffers":
+      return metrics.maxExclusiveBuffers;
+  }
+}
+function isMetricAvailable(metrics, kind) {
+  return metrics.order.some((node) => getMetricValue(node, kind) != null);
+}
+function getAvailableMetricKinds(metrics) {
+  return EXPLAIN_METRIC_KINDS.filter((kind) => isMetricAvailable(metrics, kind));
+}
+function getDefaultMetricKind(metrics) {
+  if (metrics.maxExclusiveTimeMs > 0) {
+    return "time";
+  }
+  const available = getAvailableMetricKinds(metrics);
+  return available.includes("cost") ? "cost" : available[0] ?? null;
+}
+
+// src/plan.ts
+function getNodeCostStyle(cost, maxCost) {
+  if (maxCost <= 0) return { border: "border-l-green-500", headerBg: "bg-green-950/30" };
+  const ratio = cost / maxCost;
+  if (ratio < 0.2) return { border: "border-l-green-500", headerBg: "bg-green-950/30" };
+  if (ratio < 0.6) return { border: "border-l-yellow-500", headerBg: "bg-yellow-950/30" };
+  return { border: "border-l-red-500", headerBg: "bg-red-950/30" };
+}
+function getHeatBarClass(value, max) {
+  if (max <= 0) return "bg-green-500/70";
+  const ratio = value / max;
+  if (ratio < 0.2) return "bg-green-500/70";
+  if (ratio < 0.6) return "bg-yellow-500/70";
+  return "bg-red-500/70";
+}
+function formatCost(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  if (n >= 100) return n.toFixed(0);
+  if (n >= 1) return n.toFixed(1);
+  return n.toFixed(2);
+}
+function formatTime(ms) {
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)} s`;
+  if (ms >= 1) return `${ms.toFixed(2)} ms`;
+  return `${(ms * 1e3).toFixed(0)} us`;
+}
+function formatRows(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toFixed(0);
+}
+function formatRatio(n) {
+  if (n >= 100) return `${n.toFixed(0)}x`;
+  if (n >= 10) return `${n.toFixed(1)}x`;
+  return `${n.toFixed(2)}x`;
+}
+function getMaxCost(node) {
+  let max = node.total_cost ?? 0;
+  for (const child of node.children) {
+    const childMax = getMaxCost(child);
+    if (childMax > max) max = childMax;
+  }
+  return max;
+}
+function getMaxTime(node) {
+  let max = node.actual_time_ms ?? 0;
+  for (const child of node.children) {
+    const childMax = getMaxTime(child);
+    if (childMax > max) max = childMax;
+  }
+  return max;
+}
+function flattenExplainNodes(root) {
+  const nodes = [];
+  function walk(node) {
+    nodes.push(node);
+    for (const child of node.children) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return nodes;
+}
+function findExplainNode(root, nodeId) {
+  if (!nodeId) {
+    return null;
+  }
+  if (root.id === nodeId) {
+    return root;
+  }
+  for (const child of root.children) {
+    const found = findExplainNode(child, nodeId);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+function getRowEstimateRatio(node) {
+  if (node.plan_rows == null || node.actual_rows == null || node.plan_rows <= 0 || node.actual_rows <= 0) {
+    return null;
+  }
+  return node.actual_rows / node.plan_rows;
+}
+function getMismatchMagnitude(node) {
+  const ratio = getRowEstimateRatio(node);
+  if (ratio == null) {
+    return null;
+  }
+  return ratio >= 1 ? ratio : 1 / ratio;
+}
+function isSequentialScan(node) {
+  const normalizedType = node.node_type.toLowerCase();
+  const accessType = typeof node.extra.access_type === "string" ? node.extra.access_type.toLowerCase() : "";
+  return normalizedType.includes("seq scan") || normalizedType.includes("table scan") || normalizedType.includes("full scan") || accessType === "all";
+}
+function isTempOperation(node) {
+  const normalizedType = node.node_type.toLowerCase();
+  const extraText = Object.values(node.extra).filter((value) => typeof value === "string").join(" ").toLowerCase();
+  return normalizedType.includes("sort") || normalizedType.includes("filesort") || normalizedType.includes("temporary") || extraText.includes("using temporary") || extraText.includes("using filesort");
+}
+function getExplainPlanSummary(plan, metrics) {
+  const nodes = flattenExplainNodes(plan.root);
+  const planMetrics = metrics ?? computeExplainMetrics(plan);
+  let highestCostNode = null;
+  let slowestNode = null;
+  let largestRowMismatchNode = null;
+  let sequentialScans = 0;
+  let tempOperations = 0;
+  for (const node of nodes) {
+    const nodeMetrics = planMetrics.byId.get(node.id);
+    const exclusiveCost = nodeMetrics?.exclusiveCost ?? null;
+    const exclusiveTimeMs = nodeMetrics?.exclusiveTimeMs ?? null;
+    if (exclusiveCost != null && (highestCostNode == null || exclusiveCost > highestCostNode.value)) {
+      highestCostNode = {
+        nodeId: node.id,
+        nodeType: node.node_type,
+        relation: node.relation,
+        value: exclusiveCost
+      };
+    }
+    if (exclusiveTimeMs != null && (slowestNode == null || exclusiveTimeMs > slowestNode.value)) {
+      slowestNode = {
+        nodeId: node.id,
+        nodeType: node.node_type,
+        relation: node.relation,
+        value: exclusiveTimeMs
+      };
+    }
+    const ratio = getRowEstimateRatio(node);
+    const magnitude = getMismatchMagnitude(node);
+    if (ratio != null && magnitude != null && (largestRowMismatchNode == null || magnitude > largestRowMismatchNode.value)) {
+      largestRowMismatchNode = {
+        nodeId: node.id,
+        nodeType: node.node_type,
+        relation: node.relation,
+        value: magnitude,
+        ratio
+      };
+    }
+    if (isSequentialScan(node)) {
+      sequentialScans += 1;
+    }
+    if (isTempOperation(node)) {
+      tempOperations += 1;
+    }
+  }
+  return {
+    highestCostNode,
+    slowestNode,
+    largestRowMismatchNode,
+    sequentialScans,
+    tempOperations
+  };
+}
+function getExplainDriverLegend(plan) {
+  switch (plan.driver) {
+    case "postgres":
+      return plan.has_analyze_data ? [
+        "editor.visualExplain.postgresAnalyzeLegend1",
+        "editor.visualExplain.postgresAnalyzeLegend2"
+      ] : [
+        "editor.visualExplain.postgresEstimateLegend1",
+        "editor.visualExplain.postgresEstimateLegend2"
+      ];
+    case "mysql":
+      return plan.has_analyze_data ? [
+        "editor.visualExplain.mysqlAnalyzeLegend1",
+        "editor.visualExplain.mysqlAnalyzeLegend2"
+      ] : [
+        "editor.visualExplain.mysqlEstimateLegend1",
+        "editor.visualExplain.mysqlEstimateLegend2"
+      ];
+    case "sqlite":
+      return [
+        "editor.visualExplain.sqliteLegend1",
+        "editor.visualExplain.sqliteLegend2"
+      ];
+    default:
+      return [];
+  }
+}
+
+// src/diagnostics.ts
+var EXPLAIN_DIAGNOSTIC_THRESHOLDS = {
+  /** Share of total plan time above which a node is called a hotspot. */
+  hotspotTimeShare: 0.25,
+  /** Nodes faster than this never count as a hotspot, however large the share. */
+  hotspotMinTimeMs: 1,
+  /** Row estimate off by this factor is a warning. */
+  estimateWarnFactor: 4,
+  /** Row estimate off by this factor is critical. */
+  estimateCriticalFactor: 10,
+  /** Estimate checks are skipped below this many actual rows, to cut noise. */
+  estimateMinRows: 10,
+  /** Fraction of scanned rows dropped by a filter that counts as wasted work. */
+  filterLossRatio: 0.9,
+  /** Filter checks are skipped below this many discarded rows. */
+  filterLossMinRows: 1e3,
+  /** Sequential scans below this many rows are not reported. */
+  seqScanMinRows: 1e4,
+  /** Heap fetches above this count suggest the visibility map is stale. */
+  heapFetchesMinCount: 1e3,
+  /** Loop count above which repeated execution is worth pointing out. */
+  highLoopsMinCount: 1e3,
+  /** Fraction of buffer accesses that missed shared buffers. */
+  cacheMissRatio: 0.5,
+  /** Cache checks are skipped below this many blocks read from disk. */
+  cacheMissMinBlocks: 1e3
+};
+var SEVERITY_RANK = {
+  critical: 0,
+  warning: 1,
+  info: 2
+};
+function extraString(node, key) {
+  const value = node.extra[key];
+  return typeof value === "string" ? value : null;
+}
+function extraNumber(node, key) {
+  const value = node.extra[key];
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function isSequentialScan2(node) {
+  const nodeType = node.node_type.toLowerCase();
+  const accessType = extraString(node, "access_type")?.toLowerCase() ?? "";
+  return nodeType.includes("seq scan") || nodeType.includes("table scan") || nodeType.includes("full scan") || accessType === "all";
+}
+function usesDiskWorkspace(node) {
+  const sortMethod = extraString(node, "Sort Method")?.toLowerCase() ?? "";
+  const sortSpace = extraString(node, "Sort Space Type")?.toLowerCase() ?? "";
+  if (sortMethod.includes("disk") || sortSpace === "disk") {
+    return true;
+  }
+  return (extraNumber(node, "Temp Written Blocks") ?? 0) > 0;
+}
+function estimateDiagnostic(node) {
+  const { estimateMinRows, estimateWarnFactor, estimateCriticalFactor } = EXPLAIN_DIAGNOSTIC_THRESHOLDS;
+  if (node.plan_rows == null || node.actual_rows == null || node.plan_rows <= 0 || node.actual_rows < estimateMinRows) {
+    return null;
+  }
+  const ratio = node.actual_rows / node.plan_rows;
+  const factor = ratio >= 1 ? ratio : 1 / ratio;
+  if (factor < estimateWarnFactor) {
+    return null;
+  }
+  const severity = factor >= estimateCriticalFactor ? "critical" : "warning";
+  return ratio >= 1 ? {
+    kind: "over-estimate",
+    severity,
+    labelKey: "editor.visualExplain.diagnostics.overEstimate",
+    descriptionKey: "editor.visualExplain.diagnostics.overEstimateHint",
+    value: formatRatio(factor)
+  } : {
+    kind: "under-estimate",
+    severity,
+    labelKey: "editor.visualExplain.diagnostics.underEstimate",
+    descriptionKey: "editor.visualExplain.diagnostics.underEstimateHint",
+    value: formatRatio(factor)
+  };
+}
+function getNodeDiagnostics(node, metrics) {
+  const t = EXPLAIN_DIAGNOSTIC_THRESHOLDS;
+  const diagnostics = [];
+  if (metrics?.neverExecuted) {
+    diagnostics.push({
+      kind: "never-executed",
+      severity: "info",
+      labelKey: "editor.visualExplain.diagnostics.neverExecuted",
+      descriptionKey: "editor.visualExplain.diagnostics.neverExecutedHint"
+    });
+    return diagnostics;
+  }
+  if (metrics?.timeShare != null && metrics.timeShare >= t.hotspotTimeShare && (metrics.exclusiveTimeMs ?? 0) >= t.hotspotMinTimeMs) {
+    diagnostics.push({
+      kind: "hotspot",
+      severity: "critical",
+      labelKey: "editor.visualExplain.diagnostics.hotspot",
+      descriptionKey: "editor.visualExplain.diagnostics.hotspotHint",
+      value: `${Math.round(metrics.timeShare * 100)}%`
+    });
+  }
+  const estimate = estimateDiagnostic(node);
+  if (estimate) {
+    diagnostics.push(estimate);
+  }
+  if (usesDiskWorkspace(node)) {
+    diagnostics.push({
+      kind: "disk-sort",
+      severity: "warning",
+      labelKey: "editor.visualExplain.diagnostics.diskSort",
+      descriptionKey: "editor.visualExplain.diagnostics.diskSortHint",
+      value: extraString(node, "Sort Method") ?? void 0
+    });
+  }
+  const rowsRemoved = extraNumber(node, "Rows Removed by Filter");
+  if (rowsRemoved != null && rowsRemoved >= t.filterLossMinRows) {
+    const kept = node.actual_rows ?? 0;
+    const scanned = kept + rowsRemoved;
+    if (scanned > 0 && rowsRemoved / scanned >= t.filterLossRatio) {
+      diagnostics.push({
+        kind: "filter-loss",
+        severity: "warning",
+        labelKey: "editor.visualExplain.diagnostics.filterLoss",
+        descriptionKey: "editor.visualExplain.diagnostics.filterLossHint",
+        value: formatRows(rowsRemoved)
+      });
+    }
+  }
+  if (isSequentialScan2(node)) {
+    const rows = node.actual_rows ?? node.plan_rows;
+    if (rows != null && rows >= t.seqScanMinRows) {
+      diagnostics.push({
+        kind: "large-seq-scan",
+        severity: "warning",
+        labelKey: "editor.visualExplain.diagnostics.largeSeqScan",
+        descriptionKey: "editor.visualExplain.diagnostics.largeSeqScanHint",
+        value: formatRows(rows)
+      });
+    }
+  }
+  const heapFetches = extraNumber(node, "Heap Fetches");
+  if (heapFetches != null && heapFetches >= t.heapFetchesMinCount) {
+    diagnostics.push({
+      kind: "heap-fetches",
+      severity: "warning",
+      labelKey: "editor.visualExplain.diagnostics.heapFetches",
+      descriptionKey: "editor.visualExplain.diagnostics.heapFetchesHint",
+      value: formatRows(heapFetches)
+    });
+  }
+  const workersPlanned = extraNumber(node, "Workers Planned");
+  const workersLaunched = extraNumber(node, "Workers Launched");
+  if (workersPlanned != null && workersLaunched != null && workersLaunched < workersPlanned) {
+    diagnostics.push({
+      kind: "workers-underused",
+      severity: "warning",
+      labelKey: "editor.visualExplain.diagnostics.workersUnderused",
+      descriptionKey: "editor.visualExplain.diagnostics.workersUnderusedHint",
+      value: `${workersLaunched}/${workersPlanned}`
+    });
+  }
+  if (node.actual_loops != null && node.actual_loops >= t.highLoopsMinCount) {
+    diagnostics.push({
+      kind: "high-loops",
+      severity: "info",
+      labelKey: "editor.visualExplain.diagnostics.highLoops",
+      descriptionKey: "editor.visualExplain.diagnostics.highLoopsHint",
+      value: formatRows(node.actual_loops)
+    });
+  }
+  if (node.buffers_read != null && node.buffers_read >= t.cacheMissMinBlocks && node.buffers_read / (node.buffers_read + (node.buffers_hit ?? 0)) >= t.cacheMissRatio) {
+    diagnostics.push({
+      kind: "cache-miss",
+      severity: "info",
+      labelKey: "editor.visualExplain.diagnostics.cacheMiss",
+      descriptionKey: "editor.visualExplain.diagnostics.cacheMissHint",
+      value: formatRows(node.buffers_read)
+    });
+  }
+  return diagnostics.sort(
+    (a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]
+  );
+}
+function getPlanDiagnostics(plan, metrics) {
+  const result = /* @__PURE__ */ new Map();
+  for (const node of flattenExplainNodes(plan.root)) {
+    const diagnostics = getNodeDiagnostics(node, metrics.byId.get(node.id));
+    if (diagnostics.length > 0) {
+      result.set(node.id, diagnostics);
+    }
+  }
+  return result;
+}
+function getWorstSeverity(diagnostics) {
+  let worst = null;
+  for (const diagnostic of diagnostics) {
+    if (worst == null || SEVERITY_RANK[diagnostic.severity] < SEVERITY_RANK[worst]) {
+      worst = diagnostic.severity;
+    }
+  }
+  return worst;
+}
+function countDiagnosticsBySeverity(diagnostics) {
+  const counts = {
+    critical: 0,
+    warning: 0,
+    info: 0
+  };
+  for (const list of diagnostics.values()) {
+    for (const diagnostic of list) {
+      counts[diagnostic.severity] += 1;
+    }
+  }
+  return counts;
+}
+
+// src/stats.ts
+function addTo(sum, value) {
+  if (value != null) {
+    sum.total += value;
+    sum.hasData = true;
+  }
+}
+function resolve(sum) {
+  return sum.hasData ? sum.total : null;
+}
+function newSum() {
+  return { total: 0, hasData: false };
+}
+function indexNameOf(node) {
+  const value = node.extra["Index Name"];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getExplainPlanStats(plan, metrics) {
+  const nodes = flattenExplainNodes(plan.root);
+  const byNodeType = /* @__PURE__ */ new Map();
+  const byRelation = /* @__PURE__ */ new Map();
+  const byIndex = /* @__PURE__ */ new Map();
+  let maxDepth = 0;
+  let neverExecutedCount = 0;
+  const totalTime = newSum();
+  for (const node of nodes) {
+    const nodeMetrics = metrics.byId.get(node.id);
+    const exclusiveTimeMs = nodeMetrics?.exclusiveTimeMs ?? null;
+    maxDepth = Math.max(maxDepth, (nodeMetrics?.depth ?? 0) + 1);
+    if (nodeMetrics?.neverExecuted) {
+      neverExecutedCount += 1;
+    }
+    addTo(totalTime, exclusiveTimeMs);
+    const typeStat = byNodeType.get(node.node_type) ?? {
+      count: 0,
+      time: newSum()
+    };
+    typeStat.count += 1;
+    addTo(typeStat.time, exclusiveTimeMs);
+    byNodeType.set(node.node_type, typeStat);
+    if (node.relation) {
+      const relationStat = byRelation.get(node.relation) ?? {
+        accessCount: 0,
+        nodeTypes: [],
+        time: newSum(),
+        rows: newSum()
+      };
+      relationStat.accessCount += 1;
+      if (!relationStat.nodeTypes.includes(node.node_type)) {
+        relationStat.nodeTypes.push(node.node_type);
+      }
+      addTo(relationStat.time, exclusiveTimeMs);
+      addTo(relationStat.rows, nodeMetrics?.totalRows ?? null);
+      byRelation.set(node.relation, relationStat);
+    }
+    const indexName = indexNameOf(node);
+    if (indexName) {
+      const indexStat = byIndex.get(indexName) ?? {
+        relation: node.relation,
+        scanCount: 0,
+        time: newSum()
+      };
+      indexStat.scanCount += 1;
+      indexStat.relation = indexStat.relation ?? node.relation;
+      addTo(indexStat.time, exclusiveTimeMs);
+      byIndex.set(indexName, indexStat);
+    }
+  }
+  const planTotalTime = resolve(totalTime);
+  const nodeTypes = Array.from(byNodeType.entries()).map(([nodeType, stat]) => {
+    const exclusiveTimeMs = resolve(stat.time);
+    return {
+      nodeType,
+      count: stat.count,
+      exclusiveTimeMs,
+      timeShare: exclusiveTimeMs != null && planTotalTime != null && planTotalTime > 0 ? exclusiveTimeMs / planTotalTime : null
+    };
+  }).sort(compareByTimeThenCount);
+  const relations = Array.from(byRelation.entries()).map(([relation, stat]) => ({
+    relation,
+    accessCount: stat.accessCount,
+    nodeTypes: stat.nodeTypes,
+    exclusiveTimeMs: resolve(stat.time),
+    totalRows: resolve(stat.rows)
+  })).sort(
+    (a, b) => (b.exclusiveTimeMs ?? 0) - (a.exclusiveTimeMs ?? 0) || b.accessCount - a.accessCount || a.relation.localeCompare(b.relation)
+  );
+  const indexes = Array.from(byIndex.entries()).map(([indexName, stat]) => ({
+    indexName,
+    relation: stat.relation,
+    scanCount: stat.scanCount,
+    exclusiveTimeMs: resolve(stat.time)
+  })).sort(
+    (a, b) => (b.exclusiveTimeMs ?? 0) - (a.exclusiveTimeMs ?? 0) || b.scanCount - a.scanCount || a.indexName.localeCompare(b.indexName)
+  );
+  return {
+    nodeCount: nodes.length,
+    maxDepth,
+    neverExecutedCount,
+    totalExclusiveTimeMs: planTotalTime,
+    nodeTypes,
+    relations,
+    indexes
+  };
+}
+function compareByTimeThenCount(a, b) {
+  return (b.exclusiveTimeMs ?? 0) - (a.exclusiveTimeMs ?? 0) || b.count - a.count || a.nodeType.localeCompare(b.nodeType);
+}
+
+export { EXPLAIN_DIAGNOSTIC_THRESHOLDS, EXPLAIN_METRIC_KINDS, NodeIdAllocator, buildSqliteTree, computeExplainMetrics, countDiagnosticsBySeverity, detectFormat, detectFormatFor, explainEngineFromDriverName, findExplainNode, flattenExplainNodes, formatCost, formatRatio, formatRows, formatTime, getAvailableMetricKinds, getDefaultMetricKind, getExplainDriverLegend, getExplainPlanStats, getExplainPlanSummary, getHeatBarClass, getMaxCost, getMaxTime, getMetricMax, getMetricValue, getNodeCostStyle, getNodeDiagnostics, getNodeMetrics, getPlanDiagnostics, getRowEstimateRatio, getWorstSeverity, hasAnalyzeDataRecursive, isMetricAvailable, parseExplain, parseExplainFor, parseMysqlJson, parseMysqlTabularRows, parseMysqlText, parsePostgresJson, parsePostgresText, parseRawExplain, parseSqliteEqpRows, resolveExplainOutput, withSourceLabel };