@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-7EKXJZ2Y.js

@@ -0,0 +1,2902 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  parseXml
+} from "./chunk-MC3H7736.js";
+import {
+  ZipError,
+  peekZip,
+  readZip,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/ingestors/dist/labels.js
+var DEFAULT_LEGEND = { new: ["New"], modify: ["Modify"], retire: ["Retire"] };
+var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var PATTERN = /^[A-Z][A-Z0-9]*(\.[A-Z0-9]+)+$/;
+var KINDS = ["new", "modify", "retire"];
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function edgeParts(text) {
+  const toks = text.split(" ").filter(Boolean);
+  const out = {};
+  if (toks[0] && PATTERN.test(toks[0]))
+    out.pattern = toks.shift();
+  if (toks[0] && METHODS.has(toks[0].toUpperCase()) && toks[1]) {
+    out.method = toks[0].toUpperCase();
+    out.path = toks[1];
+  } else if (toks.length === 1 && /^[A-Za-z0-9][\w.-]*$/.test(toks[0]))
+    out.topic = toks[0];
+  return out;
+}
+function legendWord(value, words2) {
+  const v = value?.trim().toLowerCase();
+  if (!v)
+    return void 0;
+  for (const k of KINDS)
+    if (v === k || words2[k].some((w) => w.toLowerCase() === v))
+      return k;
+  return void 0;
+}
+function legendOf(given, text, words2) {
+  let legend = given;
+  let rest = text;
+  for (const k of KINDS) {
+    for (const w of words2[k]) {
+      const re = new RegExp(`\\s*[[(]\\s*${escape(w)}\\s*[\\])]\\s*`, "i");
+      if (re.test(rest)) {
+        legend ??= k;
+        rest = rest.replace(re, " ").trim();
+      }
+    }
+  }
+  return { ...legend ? { legend } : {}, text: rest };
+}
+var squash = (s) => s.replace(/\s+/g, " ").trim();
+
+// packages/ingestors/dist/record.js
+import { createHash } from "node:crypto";
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+var fileBase = (fileName) => fileName.split(/[\\/]/).pop() ?? fileName;
+function extOf(fileName) {
+  const base = fileBase(fileName);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot).toLowerCase() : "";
+}
+var DOUBLE = /\.(drawio\.xml|lucid\.csv|figma\.json)$/i;
+function stem(fileName) {
+  const base = fileBase(fileName);
+  if (DOUBLE.test(base))
+    return base.replace(DOUBLE, "");
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(0, dot) : base;
+}
+function documentId(fileName) {
+  const s = slug(stem(fileName)).slice(0, 110);
+  return `doc.${s || "file"}`;
+}
+function isoDate(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime()))
+    return value.toISOString().slice(0, 10);
+  if (typeof value !== "string")
+    return void 0;
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(value.trim());
+  if (!m)
+    return void 0;
+  const d = /* @__PURE__ */ new Date(`${m[1]}-${m[2]}-${m[3]}T00:00:00Z`);
+  return !Number.isNaN(d.getTime()) && d.toISOString().startsWith(m[0]) ? m[0] : void 0;
+}
+function sourceDocument(fileName, content, docType, source, meta = {}) {
+  const clean = (s) => s && s.trim() ? s.trim() : void 0;
+  const version = clean(meta.version);
+  const author = clean(meta.author);
+  return {
+    schemaVersion: 1,
+    kind: "SourceDocument",
+    id: documentId(fileName),
+    status: "current",
+    confidence: "verified",
+    ...meta.flags?.length ? { flags: meta.flags } : {},
+    path: fileName,
+    docType,
+    ...version ? { version } : {},
+    ...author ? { author } : {},
+    ...meta.date ? { date: meta.date } : {},
+    hash: createHash("sha256").update(content).digest("hex"),
+    recordsProduced: [],
+    evidence: [{ source, path: fileName }]
+  };
+}
+var utf8 = (b) => {
+  const s = new TextDecoder("utf-8").decode(b);
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+};
+
+// packages/reconcile/dist/aliases.js
+var slug2 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+var words = (s) => new Set(slug2(s).split("-").filter((w) => w.length > 1));
+function curatedAliases(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (r.kind !== "CuratedDecision" || r.action !== "alias")
+      continue;
+    const names = Array.isArray(r.value) ? r.value : [r.value];
+    for (const n of names)
+      if (typeof n === "string")
+        out.set(n.toLowerCase(), r.target);
+  }
+  return out;
+}
+function resolveNames(names, records, systems) {
+  const curated = curatedAliases(records);
+  const components = records.filter((r) => r.kind === "Component");
+  const ids = /* @__PURE__ */ new Set([
+    ...components.map((c) => c.id),
+    ...records.filter((r) => r.kind === "System").map((r) => r.id),
+    ...systems.map((s) => s.id)
+  ]);
+  const componentsOf = (sys) => components.filter((c) => c.system === sys).map((c) => c.id);
+  const profileName = /* @__PURE__ */ new Map();
+  for (const s of systems)
+    for (const n of [s.name, ...s.aliases])
+      profileName.set(n.toLowerCase(), s.id);
+  const out = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    if (out.has(name))
+      continue;
+    const key = name.toLowerCase();
+    const c = curated.get(key);
+    if (c) {
+      out.set(name, { name, id: c, how: "curated", similar: [] });
+      continue;
+    }
+    if (ids.has(slug2(name))) {
+      out.set(name, { name, id: slug2(name), how: "exact", similar: [] });
+      continue;
+    }
+    const sys = profileName.get(key);
+    if (sys) {
+      const comps = componentsOf(sys);
+      out.set(name, {
+        name,
+        id: comps.length === 1 ? comps[0] : sys,
+        how: "profile",
+        similar: []
+      });
+      continue;
+    }
+    const w = words(name);
+    const similar = [...ids].map((id) => ({ id, score: [...words(id)].filter((x) => w.has(x)).length })).filter((x) => x.score > 0).sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : 1)).slice(0, 3).map((x) => x.id);
+    out.set(name, { name, similar });
+  }
+  return out;
+}
+
+// packages/reconcile/dist/drawio.js
+import { createHash as createHash2 } from "node:crypto";
+import { inflateRawSync } from "node:zlib";
+var DEFAULT_LEGEND2 = { new: ["New"], modify: ["Modify"], retire: ["Retire"] };
+var METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var PATTERN2 = /^[A-Z][A-Z0-9]*(\.[A-Z0-9]+)+$/;
+var ENTITIES = {
+  nbsp: " ",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function labelText(value) {
+  return value.replace(/<br\s*\/?>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&(#\d+|#x[0-9a-f]+|[a-z]+);/gi, (m, e) => {
+    if (e.startsWith("#x"))
+      return String.fromCodePoint(parseInt(e.slice(2), 16));
+    if (e.startsWith("#"))
+      return String.fromCodePoint(parseInt(e.slice(1), 10));
+    return ENTITIES[e.toLowerCase()] ?? m;
+  }).replace(/\s+/g, " ").trim();
+}
+function parseStyle(style) {
+  const out = {};
+  for (const part of (style ?? "").split(";")) {
+    if (!part)
+      continue;
+    const eq = part.indexOf("=");
+    if (eq < 0)
+      out[part] = "1";
+    else
+      out[part.slice(0, eq)] = part.slice(eq + 1);
+  }
+  return out;
+}
+function legendOf2(style, text, words2) {
+  const fromStyle = style.legend?.toLowerCase();
+  let legend = fromStyle === "new" || fromStyle === "modify" || fromStyle === "retire" ? fromStyle : void 0;
+  let rest = text;
+  for (const k of ["new", "modify", "retire"]) {
+    for (const w of words2[k]) {
+      const re = new RegExp(`\\s*[[(]\\s*${w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*[\\])]\\s*`, "i");
+      if (re.test(rest)) {
+        legend ??= k;
+        rest = rest.replace(re, " ").trim();
+      }
+    }
+  }
+  return { ...legend ? { legend } : {}, text: rest };
+}
+function pages(doc) {
+  if (doc.name === "mxGraphModel")
+    return [{ name: "", model: doc }];
+  if (doc.name !== "mxfile")
+    return [];
+  const out = [];
+  for (const d of doc.children.filter((c) => c.name === "diagram")) {
+    const name = d.attrs.name ?? d.attrs.id ?? "";
+    let model = d.children.find((c) => c.name === "mxGraphModel");
+    if (!model && d.text.trim()) {
+      const xml = decodeURIComponent(inflateRawSync(Buffer.from(d.text.trim(), "base64")).toString("utf8"));
+      const parsed = parseXml(xml);
+      if (parsed?.name === "mxGraphModel")
+        model = parsed;
+    }
+    if (model)
+      out.push({ name, model });
+  }
+  return out;
+}
+function cells(model) {
+  const root = model.children.find((c) => c.name === "root");
+  const out = [];
+  for (const el of root?.children ?? []) {
+    const cell = el.name === "mxCell" ? el : el.children.find((c) => c.name === "mxCell");
+    if (!cell)
+      continue;
+    const id = el.attrs.id ?? cell.attrs.id;
+    if (!id)
+      continue;
+    out.push({
+      id,
+      value: el.name === "mxCell" ? cell.attrs.value ?? "" : el.attrs.label ?? el.attrs.value ?? "",
+      ...cell.attrs.parent ? { parent: cell.attrs.parent } : {},
+      ...cell.attrs.source ? { source: cell.attrs.source } : {},
+      ...cell.attrs.target ? { target: cell.attrs.target } : {},
+      vertex: cell.attrs.vertex === "1",
+      edge: cell.attrs.edge === "1",
+      style: parseStyle(cell.attrs.style),
+      line: el.line
+    });
+  }
+  return out;
+}
+function edgeParts2(text) {
+  const toks = text.split(" ").filter(Boolean);
+  const out = {};
+  if (toks[0] && PATTERN2.test(toks[0]))
+    out.pattern = toks.shift();
+  if (toks[0] && METHODS2.has(toks[0].toUpperCase()) && toks[1]) {
+    out.method = toks[0].toUpperCase();
+    out.path = toks[1];
+  } else if (toks.length === 1 && /^[A-Za-z0-9][\w.-]*$/.test(toks[0]))
+    out.topic = toks[0];
+  return out;
+}
+function readDrawio(xml, legendWords = DEFAULT_LEGEND2) {
+  const doc = parseXml(xml);
+  const diagram = { nodes: [], edges: [], problems: [] };
+  if (!doc)
+    return diagram;
+  for (const { name: page, model } of pages(doc)) {
+    const all = cells(model);
+    const byId = new Map(all.map((c) => [c.id, c]));
+    const nodeOf = /* @__PURE__ */ new Map();
+    for (const c of all) {
+      if (!c.vertex || c.style.edgeLabel !== void 0 || byId.get(c.parent ?? "")?.edge)
+        continue;
+      const { legend, text } = legendOf2(c.style, labelText(c.value), legendWords);
+      if (!text)
+        continue;
+      const n = {
+        cell: c.id,
+        label: text,
+        page,
+        line: c.line,
+        ...legend ? { legend } : {},
+        style: c.style
+      };
+      diagram.nodes.push(n);
+      nodeOf.set(c.id, n);
+    }
+    const boxOf = (id) => {
+      for (let cur = id ? byId.get(id) : void 0, hops = 0; cur && hops < 50; cur = cur.parent ? byId.get(cur.parent) : void 0, hops++) {
+        const n = nodeOf.get(cur.id);
+        if (n && !n.style.group)
+          return n;
+      }
+      return void 0;
+    };
+    for (const c of all.filter((x) => x.edge)) {
+      const childText = all.filter((x) => x.parent === c.id && x.vertex).map((x) => labelText(x.value)).filter(Boolean);
+      const raw = [labelText(c.value), ...childText].filter(Boolean).join(" ");
+      const { legend, text } = legendOf2(c.style, raw, legendWords);
+      const from = boxOf(c.source);
+      const to = boxOf(c.target);
+      if (!from || !to) {
+        diagram.problems.push({
+          cell: c.id,
+          message: !from && !to ? "edge connects no boxes" : !from ? "edge has no source box" : "edge has no target box"
+        });
+        continue;
+      }
+      diagram.edges.push({
+        cell: c.id,
+        from: from.label,
+        to: to.label,
+        label: text,
+        ...edgeParts2(text),
+        ...legend ? { legend } : {},
+        page,
+        line: c.line
+      });
+    }
+  }
+  return diagram;
+}
+var slug3 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+var drawioIngestor = {
+  id: "drawio",
+  version: "0.1.0",
+  sniff(fileName, head) {
+    if (/\.drawio(\.xml)?$/i.test(fileName))
+      return 1;
+    return /^\s*(<\?xml[^>]*>\s*)?<mxfile/.test(new TextDecoder().decode(head.slice(0, 200))) ? 0.9 : 0;
+  },
+  async *ingest(fileName, content) {
+    const base = fileName.split(/[\\/]/).pop().replace(/\.drawio(\.xml)?$/i, "").replace(/\.xml$/i, "");
+    const record = {
+      schemaVersion: 1,
+      kind: "SourceDocument",
+      id: `doc.${slug3(base)}`,
+      status: "current",
+      confidence: "verified",
+      path: fileName,
+      docType: "diagram",
+      hash: createHash2("sha256").update(content).digest("hex"),
+      recordsProduced: [],
+      evidence: [{ source: "diagram", path: fileName }]
+    };
+    yield record;
+  }
+};
+
+// packages/reconcile/dist/reconcile.js
+var VIA = {
+  gateway: "through the gateway",
+  direct: "directly",
+  "event-bus": "over the event bus",
+  pubsub: "over pub/sub",
+  mq: "over a queue",
+  sftp: "by file transfer",
+  other: "another way"
+};
+var viaText = (v) => VIA[v] ?? `via ${v}`;
+var normPath = (p) => p.replace(/\{[^}]*\}/g, "{}").replace(/\/+$/, "") || "/";
+function distance(a, b) {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++)
+    d[0][j] = j;
+  for (let i = 1; i <= a.length; i++)
+    for (let j = 1; j <= b.length; j++)
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+  return d[a.length][b.length];
+}
+function reconcile(input) {
+  const { diagram, file, records } = input;
+  const items = [];
+  const add = (i) => {
+    const { key, ...rest } = i;
+    items.push({ id: `${i.type}.${slug2(key)}`, ...rest });
+  };
+  const place = (cell, page, line) => ({ file, page, cell, line });
+  const names = resolveNames([
+    .../* @__PURE__ */ new Set([
+      ...diagram.nodes.map((n) => n.label),
+      ...diagram.edges.flatMap((e) => [e.from, e.to])
+    ])
+  ], records, input.systems);
+  const idOf = (name) => names.get(name)?.id;
+  const components = new Map(records.filter((r) => r.kind === "Component").map((r) => [r.id, r]));
+  const systemIds = /* @__PURE__ */ new Set([
+    ...records.filter((r) => r.kind === "System").map((r) => r.id),
+    ...input.systems.map((s) => s.id)
+  ]);
+  const systemOf = (id) => components.get(id)?.system ?? (systemIds.has(id) ? id : void 0);
+  const boundaryOf = (id) => {
+    const s = records.find((r) => r.kind === "System" && r.id === systemOf(id));
+    return s?.boundary;
+  };
+  const same = (drawn, end) => drawn === end || systemIds.has(drawn) && !components.has(drawn) && systemOf(end) === drawn;
+  const interfaces = records.filter((r) => r.kind === "Interface");
+  const routes = new Map(records.filter((r) => r.kind === "GatewayRoute").map((r) => [r.id, r.basepath]));
+  const tables = records.filter((r) => r.kind === "Table");
+  const stores = new Map(records.filter((r) => r.kind === "DataStore").map((r) => [r.id, r.ownerComponent]));
+  const patterns = new Map(input.patterns.map((p) => [p.code, p]));
+  for (const n of diagram.nodes) {
+    const res = names.get(n.label);
+    if (res.how === "profile")
+      add({
+        key: n.label,
+        type: "alias-needed",
+        name: n.label,
+        summary: `The diagram's "${n.label}" was matched to ${res.id} through the profile; confirm it so later diagrams match it directly.`,
+        diagram: place(n.cell, n.page, n.line),
+        records: [res.id],
+        suggestion: {
+          text: `Confirm "${n.label}" is ${res.id}`,
+          action: "alias",
+          target: res.id,
+          value: n.label
+        }
+      });
+    else if (!res.id && !n.legend && diagram.edges.some((e) => e.from === n.label || e.to === n.label))
+      add({
+        key: n.label,
+        type: "unknown-box",
+        name: n.label,
+        summary: `The diagram's "${n.label}" matches nothing in the catalog${res.similar.length ? ` (similar: ${res.similar.join(", ")})` : ""}.`,
+        diagram: place(n.cell, n.page, n.line),
+        records: res.similar,
+        suggestion: res.similar.length ? {
+          text: `If "${n.label}" is ${res.similar[0]}, record the alias`,
+          action: "alias",
+          target: res.similar[0],
+          value: n.label
+        } : { text: `Say what "${n.label}" is, or mark it New if it doesn't exist yet` }
+      });
+  }
+  const matched = /* @__PURE__ */ new Set();
+  const explainedAccess = /* @__PURE__ */ new Set();
+  const matches = [];
+  const label = (e) => `${e.from} \u2192 ${e.to}${e.label ? ` (${e.label})` : ""}`;
+  for (const e of diagram.edges) {
+    const where = place(e.cell, e.page, e.line);
+    if (e.pattern && !patterns.has(e.pattern)) {
+      const near = [...patterns.keys()].map((c) => ({ c, d: distance(c, e.pattern) })).sort((a, b) => a.d - b.d)[0];
+      add({
+        key: e.cell,
+        type: "unknown-pattern",
+        summary: `Edge ${label(e)} names pattern ${e.pattern}, which the org pack doesn't have.`,
+        diagram: where,
+        records: [],
+        suggestion: {
+          text: near && near.d <= 2 ? `Did you mean ${near.c}?` : `Use one of: ${[...patterns.keys()].join(", ")}`
+        }
+      });
+    }
+    const from = idOf(e.from);
+    const to = idOf(e.to);
+    const candidates = from && to ? interfaces.filter((i) => {
+      if (!same(from, i.from) || !same(to, i.to))
+        return false;
+      if (e.topic)
+        return i.sync === "async" && i.normalizedPath === e.topic;
+      if (e.path) {
+        const grpc = /^\/?([\w.]+\.[\w]+)\/(\w+)$/.exec(e.path);
+        if (grpc && (!e.method || e.method === "POST") && i.normalizedPath === `${grpc[1]}/${grpc[2]}`)
+          return true;
+        if (e.method && i.method && e.method !== i.method.toUpperCase())
+          return false;
+        const p = normPath(e.path);
+        const base = i.route ? routes.get(i.route) : void 0;
+        return p === i.normalizedPath || base !== void 0 && p === normPath(base) + i.normalizedPath;
+      }
+      return true;
+    }) : [];
+    if (candidates.length > 0) {
+      for (const i of candidates)
+        matched.add(i.id);
+      matches.push({ cell: e.cell, interfaces: candidates.map((i) => i.id).sort() });
+      const p = e.pattern ? patterns.get(e.pattern) : void 0;
+      for (const i of candidates) {
+        if (p) {
+          const via = p.detection.via.length > 0 ? p.detection.via : p.route !== "jdbc" && p.route !== "other" ? [p.route] : [];
+          const diffs = [];
+          if (via.length > 0 && !via.includes(i.via))
+            diffs.push(`${p.code} goes ${via.map(viaText).join(" or ")}, the code calls ${viaText(i.via)}`);
+          const sync = p.detection.sync ?? (p.interaction === "data-access" ? void 0 : p.interaction);
+          if (sync && sync !== i.sync)
+            diffs.push(`${p.code} is ${sync}, the code is ${i.sync}`);
+          const tb = p.detection.targetBoundary;
+          if (tb && boundaryOf(i.to) && tb !== boundaryOf(i.to))
+            diffs.push(`${p.code} targets a ${tb} system, ${i.to} is ${boundaryOf(i.to)}`);
+          if (diffs.length > 0)
+            add({
+              key: `${e.cell}-${i.id}`,
+              type: "pattern-mismatch",
+              summary: `Edge ${label(e)}: ${diffs.join("; ")}. The code is what runs; fix the design or the code.`,
+              diagram: where,
+              records: [i.id],
+              suggestion: {
+                text: `Redraw the edge to match the code, or plan a change that routes it as ${p.code} says`
+              }
+            });
+          else if (i.pattern && i.pattern.code !== p.code)
+            add({
+              key: `${e.cell}-${i.id}`,
+              type: "pattern-differs",
+              summary: `Edge ${label(e)} is drawn as ${p.code}; the code looks like ${i.pattern.code}.`,
+              diagram: where,
+              records: [i.id],
+              suggestion: {
+                text: `Confirm which pattern applies`,
+                action: "assert",
+                target: i.id,
+                value: { pattern: { code: p.code, source: "asserted" } }
+              }
+            });
+        }
+        if (e.legend === "modify" || e.legend === "retire")
+          add({
+            key: `${e.cell}-${i.id}`,
+            type: "planned",
+            legend: e.legend,
+            summary: `Edge ${label(e)} is marked ${e.legend}: add it to a change as planned-${e.legend}.`,
+            diagram: where,
+            records: [i.id],
+            suggestion: { text: `Add ${i.id} to a change as planned-${e.legend}` }
+          });
+      }
+      continue;
+    }
+    if (e.legend) {
+      add({
+        key: e.cell,
+        type: "planned",
+        legend: e.legend,
+        summary: `Edge ${label(e)} is marked ${e.legend} and isn't in code yet: it becomes a planned-${e.legend} interface in a change.`,
+        diagram: where,
+        records: [],
+        suggestion: { text: `Add ${label(e)} to a change as a planned-${e.legend} interface` }
+      });
+      continue;
+    }
+    if (!from || !to) {
+      add({
+        key: e.cell,
+        type: "diagram-only",
+        summary: `Edge ${label(e)} can't be checked: ${!from ? e.from : e.to} isn't in the catalog.`,
+        diagram: where,
+        records: []
+      });
+      continue;
+    }
+    const owned = tables.filter((t) => {
+      const owner = t.ownerComponent ?? stores.get(t.dataStore);
+      return owner !== void 0 && same(to, owner) && (t.readers.some((c) => same(from, c)) || t.writers.some((c) => same(from, c)));
+    });
+    if (owned.length > 0 && e.pattern && patterns.get(e.pattern)?.interaction === "data-access") {
+      for (const t of owned)
+        explainedAccess.add(`${from}|${t.id}`);
+      matches.push({ cell: e.cell, interfaces: [], tables: owned.map((t) => t.id).sort() });
+      continue;
+    }
+    if (owned.length > 0) {
+      for (const t of owned)
+        explainedAccess.add(`${from}|${t.id}`);
+      const jdbc = input.patterns.find((p) => p.interaction === "data-access" && p.status !== "deprecated");
+      add({
+        key: e.cell,
+        type: "drawn-call-reads-database",
+        summary: `Edge ${label(e)} is drawn as a call to ${to}, but in code ${from} ${owned.every((t) => t.readers.some((c) => same(from, c))) ? "reads" : "uses"} ${to}'s database directly (${owned.map((t) => t.id).join(", ")})${jdbc ? `: that is ${jdbc.code}, not ${e.pattern ?? "a call"}` : ""}.`,
+        diagram: where,
+        records: owned.map((t) => t.id),
+        suggestion: {
+          text: `Redraw it as ${jdbc?.code ?? "direct database access"}, or plan a change to go through ${to}'s API`
+        }
+      });
+      continue;
+    }
+    const reverse = interfaces.filter((i) => same(to, i.from) && same(from, i.to));
+    if (reverse.length > 0) {
+      add({
+        key: e.cell,
+        type: "direction-differs",
+        summary: `Edge ${label(e)} is drawn from ${from} to ${to}; in code ${to} calls ${from}.`,
+        diagram: where,
+        records: reverse.map((i) => i.id).sort()
+      });
+      continue;
+    }
+    add({
+      key: e.cell,
+      type: "diagram-only",
+      summary: `Edge ${label(e)} is drawn, but no such call is in the code.`,
+      diagram: where,
+      records: [],
+      suggestion: {
+        text: "Remove it from the diagram, mark it New, or point Atticus at the repo that makes the call"
+      }
+    });
+  }
+  const onDiagram = new Set([...names.values()].flatMap((n) => n.id ? [n.id] : []));
+  const touches = (id) => [...onDiagram].some((d) => same(d, id));
+  for (const i of interfaces.filter((x) => !matched.has(x.id) && x.status !== "retired").sort((a, b) => a.id < b.id ? -1 : 1)) {
+    if (!touches(i.from) && !touches(i.to))
+      continue;
+    const what = i.sync === "async" ? `publishes ${i.normalizedPath} to` : `calls`;
+    add({
+      key: i.id,
+      type: "code-only",
+      summary: `In code ${i.from} ${what} ${i.to}${i.sync === "async" ? "" : ` (${i.method ?? ""} ${i.normalizedPath}`.trimEnd() + ")"}${i.confidence === "inferred" ? ", seen at one end only" : ""}; the diagram doesn't show it.`,
+      records: [i.id],
+      suggestion: {
+        text: `Add it to the diagram, or record why it is left out`,
+        action: "suppress",
+        target: i.id,
+        value: { diagram: file }
+      }
+    });
+  }
+  for (const t of tables) {
+    const owner = t.ownerComponent ?? stores.get(t.dataStore);
+    for (const c of [.../* @__PURE__ */ new Set([...t.readers, ...t.writers])].sort()) {
+      if (!owner || c === owner || explainedAccess.has(`${c}|${t.id}`) || !touches(c) || !touches(owner))
+        continue;
+      add({
+        key: `${c}-${t.id}`,
+        type: "code-only",
+        summary: `In code ${c} uses ${owner}'s table ${t.id} directly; the diagram doesn't show it.`,
+        records: [t.id, c]
+      });
+    }
+  }
+  return { items, matches, names: [...names.values()] };
+}
+
+// packages/ingestors/dist/lucid.js
+function parseCsv(text) {
+  const out = [];
+  let cells2 = [];
+  let cell = "";
+  let quoted = false;
+  let line = 1;
+  let start = 1;
+  let any = false;
+  const endRecord = () => {
+    cells2.push(cell);
+    if (any || cells2.length > 1 || cell !== "")
+      out.push({ line: start, cells: cells2 });
+    cells2 = [];
+    cell = "";
+    any = false;
+  };
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quoted) {
+      if (c === '"') {
+        if (text[i + 1] === '"') {
+          cell += '"';
+          i++;
+        } else
+          quoted = false;
+      } else {
+        if (c === "\n")
+          line++;
+        cell += c;
+      }
+      continue;
+    }
+    if (c === '"') {
+      quoted = true;
+      any = true;
+    } else if (c === ",") {
+      cells2.push(cell);
+      cell = "";
+      any = true;
+    } else if (c === "\r" && text[i + 1] === "\n")
+      continue;
+    else if (c === "\n" || c === "\r") {
+      endRecord();
+      line++;
+      start = line;
+    } else
+      cell += c;
+  }
+  if (cell !== "" || cells2.length || any)
+    endRecord();
+  return out;
+}
+var norm = (s) => s.trim().toLowerCase();
+function readLucidCsv(text, legendWords = DEFAULT_LEGEND) {
+  const diagram = { nodes: [], edges: [], problems: [] };
+  const rows = parseCsv(text.charCodeAt(0) === 65279 ? text.slice(1) : text);
+  const header = rows.shift();
+  const col = /* @__PURE__ */ new Map();
+  header?.cells.forEach((h, i) => col.set(norm(h), i));
+  if (!col.has("id")) {
+    diagram.problems.push({ cell: "", message: "not a Lucidchart export: no Id column" });
+    return diagram;
+  }
+  const textCols = [...col.entries()].filter(([h]) => /^text area \d+$/.test(h)).sort((a, b) => Number(a[0].slice(10)) - Number(b[0].slice(10))).map(([, i]) => i);
+  const get = (r, name) => {
+    const i = col.get(name);
+    return i === void 0 ? "" : (r.cells[i] ?? "").trim();
+  };
+  const textOf2 = (r) => labelText(textCols.map((i) => r.cells[i] ?? "").filter((t) => t.trim()).join(" "));
+  const pages2 = /* @__PURE__ */ new Map();
+  for (const r of rows)
+    if (norm(get(r, "name")) === "page")
+      pages2.set(get(r, "id"), textOf2(r));
+  const isLine = (r) => norm(get(r, "name")) === "line" || !!get(r, "line source") || !!get(r, "line destination");
+  const byId = new Map(rows.map((r) => [get(r, "id"), r]));
+  const nodeOf = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const kind = norm(get(r, "name"));
+    if (kind === "document" || kind === "page" || isLine(r))
+      continue;
+    const { legend, text: label } = legendOf(legendWord(get(r, "legend"), legendWords), textOf2(r), legendWords);
+    if (!label)
+      continue;
+    const library = get(r, "shape library");
+    const n = {
+      cell: get(r, "id"),
+      label,
+      page: pages2.get(get(r, "page id")) ?? "",
+      line: r.line,
+      ...legend ? { legend } : {},
+      style: { shape: get(r, "name"), ...library ? { library } : {} }
+    };
+    diagram.nodes.push(n);
+    nodeOf.set(n.cell, n);
+  }
+  const boxOf = (id) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (let cur = id; cur && !seen.has(cur); ) {
+      seen.add(cur);
+      const n = nodeOf.get(cur);
+      if (n)
+        return n;
+      const r = byId.get(cur);
+      cur = r ? (get(r, "contained by") || get(r, "group")).split(/[;,\s]+/)[0] : void 0;
+    }
+    return void 0;
+  };
+  for (const r of rows.filter(isLine)) {
+    const id = get(r, "id");
+    const src = get(r, "line source");
+    const dst = get(r, "line destination");
+    const from = src ? boxOf(src) : void 0;
+    const to = dst ? boxOf(dst) : void 0;
+    if (!from || !to) {
+      diagram.problems.push({
+        cell: id,
+        message: !from && !to ? "edge connects no boxes" : !from ? "edge has no source box" : "edge has no target box"
+      });
+      continue;
+    }
+    const { legend, text: label } = legendOf(legendWord(get(r, "legend"), legendWords), textOf2(r), legendWords);
+    diagram.edges.push({
+      cell: id,
+      from: from.label,
+      to: to.label,
+      label,
+      ...edgeParts(label),
+      ...legend ? { legend } : {},
+      page: pages2.get(get(r, "page id")) ?? "",
+      line: r.line
+    });
+  }
+  return diagram;
+}
+
+// packages/ingestors/dist/mermaid.js
+var SHAPES = [
+  ["(((", ")))", "double-circle"],
+  ["([", "])", "stadium"],
+  ["[[", "]]", "subroutine"],
+  ["[(", ")]", "cylinder"],
+  ["((", "))", "circle"],
+  ["{{", "}}", "hexagon"],
+  ["[/", "/]", "parallelogram"],
+  ["[/", "\\]", "trapezoid"],
+  ["[\\", "\\]", "parallelogram-alt"],
+  ["[\\", "/]", "trapezoid-alt"],
+  [">", "]", "asymmetric"],
+  ["[", "]", "rect"],
+  ["(", ")", "rounded"],
+  ["{", "}", "diamond"]
+];
+var LINK = /^(?:<|o|x)?(?:-{2,}>|-{2,}[ox](?![\w])|-{3,}|={2,}>|={2,}[ox](?![\w])|={3,}|-\.+->|-\.+-|~{3,})/;
+var LINK_TEXT = /^(?:<|o|x)?(?:--|==|-\.)\s+(.+?)\s+(?:-{2,}>|-{2,}[ox](?![\w])|-{3,}|={2,}>|={2,}[ox](?![\w])|={3,}|\.+->|\.+-)/;
+var ID = /^[A-Za-z0-9_]+/;
+function frontMatterTitle(lines) {
+  if (lines[0]?.trim() !== "---")
+    return { skip: 0 };
+  const end = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+  if (end < 0)
+    return { skip: 0 };
+  let title;
+  for (const l of lines.slice(1, end)) {
+    const m = /^title:\s*(.*)$/.exec(l.trim());
+    if (m)
+      title = m[1].replace(/^(["'])(.*)\1$/, "$2").trim();
+  }
+  return { ...title ? { title } : {}, skip: end + 1 };
+}
+function blocks(text) {
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  const fm = frontMatterTitle(lines);
+  const fenced = lines.some((l) => /^\s*(`{3,}|~{3,})\s*mermaid\s*$/.test(l));
+  if (!fenced)
+    return [{ lines: lines.slice(fm.skip), first: fm.skip + 1, page: fm.title ?? "" }];
+  const out = [];
+  let heading = fm.title ?? "";
+  let fence;
+  let mermaid;
+  for (let i = fm.skip; i < lines.length; i++) {
+    const l = lines[i];
+    if (fence) {
+      if (l.trim().startsWith(fence) && /^\s*(`+|~+)\s*$/.test(l)) {
+        if (mermaid)
+          out.push(mermaid);
+        fence = void 0;
+        mermaid = void 0;
+      } else
+        mermaid?.lines.push(l);
+      continue;
+    }
+    const open = /^\s*(`{3,}|~{3,})\s*(\S*)/.exec(l);
+    if (open) {
+      fence = open[1];
+      if (open[2] === "mermaid")
+        mermaid = { lines: [], first: i + 2, page: heading };
+      continue;
+    }
+    const h = /^#{1,6}\s+(.*?)\s*#*\s*$/.exec(l);
+    if (h && !fm.title)
+      heading = h[1];
+  }
+  return out;
+}
+function statements(line) {
+  const out = [];
+  let depth = 0;
+  let quote = false;
+  let pipe = false;
+  let cur = "";
+  for (const c of line) {
+    if (c === '"')
+      quote = !quote;
+    else if (!quote) {
+      if (c === "|")
+        pipe = !pipe;
+      else if (!pipe && "[({".includes(c))
+        depth++;
+      else if (!pipe && "])}".includes(c))
+        depth = Math.max(0, depth - 1);
+      else if (c === ";" && depth === 0 && !pipe) {
+        out.push(cur);
+        cur = "";
+        continue;
+      }
+    }
+    cur += c;
+  }
+  out.push(cur);
+  return out.map((s) => s.trim()).filter(Boolean);
+}
+var unquote = (s) => {
+  const t = s.trim();
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"'))
+    return t.slice(1, -1);
+  if (t.length >= 2 && t.startsWith("`") && t.endsWith("`"))
+    return t.slice(1, -1);
+  return t;
+};
+function parseNode(s) {
+  const id = ID.exec(s);
+  if (!id)
+    return void 0;
+  let rest = s.slice(id[0].length);
+  const node = { id: id[0], classes: [] };
+  if (rest.startsWith("@{")) {
+    let q = false;
+    let end = -1;
+    for (let i = 2; i < rest.length; i++) {
+      if (rest[i] === '"')
+        q = !q;
+      else if (!q && rest[i] === "}") {
+        end = i;
+        break;
+      }
+    }
+    if (end < 0)
+      return void 0;
+    for (const m of rest.slice(2, end).matchAll(/(\w+)\s*:\s*("([^"]*)"|'([^']*)'|[^,]+)/g)) {
+      const v = (m[3] ?? m[4] ?? m[2]).trim();
+      if (m[1] === "label")
+        node.label = v;
+      else if (m[1] === "shape")
+        node.shape = v;
+    }
+    rest = rest.slice(end + 1);
+  } else {
+    for (const [open, close, shape] of SHAPES) {
+      if (!rest.startsWith(open))
+        continue;
+      const body = rest.slice(open.length);
+      let end = -1;
+      let label = "";
+      if (body.startsWith('"')) {
+        const q = body.indexOf('"', 1);
+        if (q > 0 && body.slice(q + 1).trimStart().startsWith(close)) {
+          label = body.slice(1, q);
+          end = body.indexOf(close, q + 1);
+        }
+      } else {
+        end = body.indexOf(close);
+        label = end >= 0 ? body.slice(0, end) : "";
+      }
+      if (end < 0)
+        continue;
+      node.label = unquote(label);
+      node.shape = shape;
+      rest = body.slice(end + close.length);
+      break;
+    }
+  }
+  const cls = /^:::([\w-]+)/.exec(rest);
+  if (cls) {
+    node.classes.push(cls[1]);
+    rest = rest.slice(cls[0].length);
+  }
+  return { node, rest };
+}
+function parseLink(s) {
+  let rest = s;
+  let id;
+  const named = /^([A-Za-z0-9_]+)@(?=[-=.<ox~])/.exec(rest);
+  if (named) {
+    id = named[1];
+    rest = rest.slice(named[0].length);
+  }
+  const plain = LINK.exec(rest);
+  if (plain) {
+    rest = rest.slice(plain[0].length);
+    let text = "";
+    const piped = /^\s*\|([^|]*)\|/.exec(rest);
+    if (piped) {
+      text = piped[1];
+      rest = rest.slice(piped[0].length);
+    }
+    return { link: { ...id ? { id } : {}, text: unquote(text) }, rest };
+  }
+  const middle = LINK_TEXT.exec(rest);
+  if (middle) {
+    return {
+      link: { ...id ? { id } : {}, text: unquote(middle[1]) },
+      rest: rest.slice(middle[0].length)
+    };
+  }
+  return void 0;
+}
+function parseChain(s) {
+  const groups = [];
+  const links = [];
+  let rest = s.trim();
+  const group = () => {
+    const g = [];
+    for (; ; ) {
+      const n = parseNode(rest);
+      if (!n)
+        return false;
+      g.push(n.node);
+      rest = n.rest.trimStart();
+      if (!rest.startsWith("&"))
+        break;
+      rest = rest.slice(1).trimStart();
+    }
+    groups.push(g);
+    return true;
+  };
+  if (!group())
+    return void 0;
+  while (rest) {
+    const l = parseLink(rest);
+    if (!l)
+      return void 0;
+    links.push(l.link);
+    rest = l.rest.trimStart();
+    if (!group())
+      return void 0;
+  }
+  return { groups, links };
+}
+function readMermaid(text, legendWords = DEFAULT_LEGEND) {
+  const diagram = { nodes: [], edges: [], problems: [] };
+  let found = false;
+  for (const block of blocks(text)) {
+    const fm = frontMatterTitle(block.lines);
+    const page = fm.title ?? block.page;
+    const nodes = /* @__PURE__ */ new Map();
+    const edges = [];
+    const classOf = /* @__PURE__ */ new Map();
+    let header = false;
+    let count = 0;
+    const mention = (n, line, extra = {}) => {
+      let st = nodes.get(n.id);
+      if (!st) {
+        st = { cell: n.id, line, page, style: { ...extra }, classes: [] };
+        nodes.set(n.id, st);
+      }
+      if (n.label !== void 0 && st.label === void 0)
+        st.label = n.label;
+      if (n.shape && !st.style.shape && !st.style.subgraph)
+        st.style.shape = n.shape;
+      st.classes.push(...n.classes);
+    };
+    for (let i = fm.skip; i < block.lines.length; i++) {
+      const raw = block.lines[i].trim();
+      const line = block.first + i;
+      if (!raw || raw.startsWith("%%"))
+        continue;
+      for (const st of statements(raw)) {
+        if (!header) {
+          if (!/^(flowchart|graph)\b/i.test(st))
+            break;
+          header = true;
+          found = true;
+          continue;
+        }
+        if (/^end$/i.test(st))
+          continue;
+        if (/^(classDef|style|linkStyle|click|direction|accTitle|accDescr)\b/.test(st))
+          continue;
+        const cls = /^class\s+([\w,\s]+?)\s+([\w-]+)$/.exec(st);
+        if (cls) {
+          for (const id of cls[1].split(",").map((x) => x.trim()))
+            classOf.set(id, [...classOf.get(id) ?? [], cls[2]]);
+          continue;
+        }
+        const sub = /^subgraph\s+(.+)$/i.exec(st);
+        if (sub) {
+          const n = parseNode(sub[1].trim());
+          const ref2 = n && !n.rest.trim() ? n.node : { id: sub[1].trim(), label: unquote(sub[1]), classes: [] };
+          mention({ ...ref2, shape: void 0 }, line, { subgraph: "1" });
+          continue;
+        }
+        const chain = parseChain(st);
+        if (!chain) {
+          diagram.problems.push({ cell: `L${line}`, message: "line not understood" });
+          continue;
+        }
+        chain.groups.forEach((g) => g.forEach((n) => mention(n, line)));
+        chain.links.forEach((l, k) => {
+          for (const a of chain.groups[k])
+            for (const b of chain.groups[k + 1]) {
+              count++;
+              edges.push({
+                cell: l.id ?? `e${count}`,
+                from: a.id,
+                to: b.id,
+                text: l.text,
+                line
+              });
+            }
+        });
+      }
+      if (!header)
+        break;
+    }
+    if (!header)
+      continue;
+    const label = (id) => {
+      const n = nodes.get(id);
+      return labelText(n.label ?? n.cell) || n.cell;
+    };
+    const classLegend = (id, own = []) => {
+      for (const c of [...own, ...classOf.get(id) ?? []]) {
+        const l = legendWord(c, legendWords);
+        if (l)
+          return l;
+      }
+      return void 0;
+    };
+    const labels = /* @__PURE__ */ new Map();
+    for (const n of nodes.values()) {
+      const { legend, text: lbl } = legendOf(classLegend(n.cell, n.classes), label(n.cell), legendWords);
+      labels.set(n.cell, lbl);
+      diagram.nodes.push({
+        cell: n.cell,
+        label: lbl,
+        page: n.page,
+        line: n.line,
+        ...legend ? { legend } : {},
+        style: n.style
+      });
+    }
+    for (const e of edges) {
+      const { legend, text: lbl } = legendOf(classLegend(e.cell), labelText(e.text), legendWords);
+      diagram.edges.push({
+        cell: e.cell,
+        from: labels.get(e.from),
+        to: labels.get(e.to),
+        label: lbl,
+        ...edgeParts(lbl),
+        ...legend ? { legend } : {},
+        page,
+        line: e.line
+      });
+    }
+  }
+  if (!found)
+    diagram.problems.push({ cell: "", message: "no flowchart or graph diagram found" });
+  return diagram;
+}
+
+// packages/ingestors/dist/xml.js
+var NAMED = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+function decodeEntities(s, named = NAMED) {
+  return s.replace(/&(#\d+|#x[0-9a-f]+|[a-z][a-z0-9]*);/gi, (m, e) => {
+    if (e[0] === "#") {
+      const cp = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+      return cp > 0 && cp <= 1114111 ? String.fromCodePoint(cp) : m;
+    }
+    return named[e] ?? named[e.toLowerCase()] ?? m;
+  });
+}
+function parseXmlTree(src) {
+  const root = { name: "#document", attrs: {}, children: [], line: 1 };
+  const stack = [root];
+  let i = 0;
+  let line = 1;
+  const advance = (to) => {
+    for (let k = i; k < to; k++)
+      if (src.charCodeAt(k) === 10)
+        line++;
+    i = to;
+  };
+  const addText = (t) => {
+    if (!t)
+      return;
+    const top = stack.at(-1);
+    if (top === root)
+      return;
+    const last = top.children.at(-1);
+    if (typeof last === "string")
+      top.children[top.children.length - 1] = last + t;
+    else
+      top.children.push(t);
+  };
+  while (i < src.length) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      addText(decodeEntities(src.slice(i)));
+      break;
+    }
+    addText(decodeEntities(src.slice(i, lt)));
+    advance(lt);
+    if (src.startsWith("<!--", i)) {
+      const end2 = src.indexOf("-->", i);
+      advance(end2 === -1 ? src.length : end2 + 3);
+      continue;
+    }
+    if (src.startsWith("<![CDATA[", i)) {
+      const end2 = src.indexOf("]]>", i);
+      addText(src.slice(i + 9, end2 === -1 ? src.length : end2));
+      advance(end2 === -1 ? src.length : end2 + 3);
+      continue;
+    }
+    if (src.startsWith("<?", i)) {
+      const end2 = src.indexOf("?>", i);
+      advance(end2 === -1 ? src.length : end2 + 2);
+      continue;
+    }
+    if (src.startsWith("<!", i)) {
+      let depth = 0;
+      let k = i + 2;
+      for (; k < src.length; k++) {
+        const c = src[k];
+        if (c === "[")
+          depth++;
+        else if (c === "]")
+          depth--;
+        else if (c === ">" && depth <= 0)
+          break;
+      }
+      advance(Math.min(k + 1, src.length));
+      continue;
+    }
+    let end = i + 1;
+    let quote = "";
+    for (; end < src.length; end++) {
+      const c = src[end];
+      if (quote) {
+        if (c === quote)
+          quote = "";
+      } else if (c === '"' || c === "'")
+        quote = c;
+      else if (c === ">")
+        break;
+    }
+    if (end >= src.length)
+      break;
+    const tag = src.slice(i + 1, end);
+    const startLine = line;
+    advance(end + 1);
+    if (tag.startsWith("/")) {
+      const name = localName(tag.slice(1).trim());
+      for (let k = stack.length - 1; k > 0; k--) {
+        if (stack[k].name === name) {
+          stack.length = k;
+          break;
+        }
+      }
+      continue;
+    }
+    const selfClosing = tag.endsWith("/");
+    const body = selfClosing ? tag.slice(0, -1) : tag;
+    const m = /^([^\s/>]+)([\s\S]*)$/.exec(body.trim());
+    if (!m)
+      continue;
+    const attrs = {};
+    for (const a of m[2].matchAll(/([^\s=]+)\s*=\s*("([^"]*)"|'([^']*)')/g))
+      attrs[a[1]] = decodeEntities(a[3] ?? a[4] ?? "");
+    const el = { name: localName(m[1]), attrs, children: [], line: startLine };
+    stack.at(-1).children.push(el);
+    if (!selfClosing)
+      stack.push(el);
+  }
+  return root.children.find((c) => typeof c !== "string");
+}
+var localName = (q) => q.replace(/^.*:/, "");
+function attr(el, name) {
+  if (el.attrs[name] !== void 0)
+    return el.attrs[name];
+  for (const [k, v] of Object.entries(el.attrs))
+    if (localName(k) === name)
+      return v;
+  return void 0;
+}
+function relId(el) {
+  for (const [k, v] of Object.entries(el.attrs))
+    if (/^[^:]+:id$/.test(k))
+      return v;
+  return void 0;
+}
+var elements = (el) => (el?.children ?? []).filter((c) => typeof c !== "string");
+var child = (el, name) => elements(el).find((c) => c.name === name);
+var childrenNamed = (el, name) => elements(el).filter((c) => c.name === name);
+function findAll(el, name, intoMatches = false) {
+  const out = [];
+  const walk = (n) => {
+    for (const c of elements(n)) {
+      if (c.name === name) {
+        out.push(c);
+        if (!intoMatches)
+          continue;
+      }
+      walk(c);
+    }
+  };
+  if (el)
+    walk(el);
+  return out;
+}
+function textOf(el) {
+  if (!el)
+    return "";
+  return el.children.map((c) => typeof c === "string" ? c : textOf(c)).join("");
+}
+function relationships(xml) {
+  const out = /* @__PURE__ */ new Map();
+  const doc = xml ? parseXmlTree(xml) : void 0;
+  for (const r of childrenNamed(doc, "Relationship")) {
+    const id = r.attrs.Id;
+    const target = r.attrs.Target;
+    if (id && target && r.attrs.TargetMode !== "External")
+      out.set(id, target);
+  }
+  return out;
+}
+function resolvePart(fromFolder, target) {
+  const parts = target.startsWith("/") ? [] : fromFolder.split("/").filter(Boolean);
+  for (const seg of target.split("/")) {
+    if (!seg || seg === ".")
+      continue;
+    if (seg === "..")
+      parts.pop();
+    else
+      parts.push(seg);
+  }
+  return parts.join("/");
+}
+
+// packages/ingestors/dist/vsdx.js
+function shapeText(el) {
+  const t = child(el, "Text");
+  if (!t)
+    return "";
+  const walk = (n) => n.children.map((c) => typeof c === "string" ? c : walk(c)).join("");
+  return squash(walk(t));
+}
+function dataLegend(el, words2) {
+  for (const section of childrenNamed(el, "Section")) {
+    if (section.attrs.N !== "Property")
+      continue;
+    for (const row of childrenNamed(section, "Row")) {
+      const cells2 = new Map(childrenNamed(row, "Cell").map((c) => [c.attrs.N, c]));
+      const label = cells2.get("Label")?.attrs.V;
+      if (row.attrs.N?.toLowerCase() !== "legend" && label?.toLowerCase() !== "legend")
+        continue;
+      const value = cells2.get("Value");
+      const v = value?.attrs.V ?? (value ? squash(value.children.join(" ")) : void 0);
+      const legend = legendWord(v, words2);
+      if (legend)
+        return legend;
+    }
+  }
+  return void 0;
+}
+function shapesOf(container, parent, masters, words2, out) {
+  const list = [];
+  for (const el of childrenNamed(child(container, "Shapes"), "Shape")) {
+    const cells2 = {};
+    for (const c of childrenNamed(el, "Cell"))
+      if (c.attrs.N && c.attrs.V !== void 0)
+        cells2[c.attrs.N] = c.attrs.V;
+    const masterName = el.attrs.Master ? masters.get(el.attrs.Master) : void 0;
+    const s = {
+      el,
+      id: el.attrs.ID ?? "",
+      ...parent ? { parent } : {},
+      children: [],
+      text: shapeText(el),
+      ...masterName ? { master: masterName } : {},
+      group: el.attrs.Type === "Group",
+      oneD: "BeginX" in cells2 || "EndX" in cells2,
+      ...(() => {
+        const l = dataLegend(el, words2);
+        return l ? { legend: l } : {};
+      })(),
+      cells: cells2
+    };
+    out.push(s);
+    list.push(s);
+    s.children = shapesOf(el, s, masters, words2, out);
+  }
+  return list;
+}
+function readVsdx(bytes, legendWords = DEFAULT_LEGEND, limits = {}) {
+  const zip = readZip(bytes, limits);
+  const diagram = { nodes: [], edges: [], problems: [] };
+  const masters = /* @__PURE__ */ new Map();
+  for (const m of findAll(parseXmlTree(zip.text("visio/masters/masters.xml") ?? ""), "Master"))
+    if (m.attrs.ID)
+      masters.set(m.attrs.ID, m.attrs.NameU ?? m.attrs.Name ?? "");
+  const rels = relationships(zip.text("visio/pages/_rels/pages.xml.rels"));
+  const listed = [];
+  childrenNamed(parseXmlTree(zip.text("visio/pages/pages.xml") ?? ""), "Page").forEach((p, i) => {
+    const rel = child(p, "Rel");
+    const rid = rel ? relId(rel) : void 0;
+    const target = rid ? rels.get(rid) : void 0;
+    if (!target)
+      return;
+    listed.push({
+      id: p.attrs.ID ?? String(i),
+      name: p.attrs.Name ?? p.attrs.NameU ?? "",
+      part: resolvePart("visio/pages", target)
+    });
+  });
+  const pageNo = (n) => Number(/page(\d+)\.xml$/.exec(n)?.[1] ?? 0);
+  for (const part of zip.names.filter((n) => /^visio\/pages\/page\d+\.xml$/.test(n)).sort((a, b) => pageNo(a) - pageNo(b)))
+    if (!listed.some((l) => l.part === part))
+      listed.push({ id: String(pageNo(part)), name: "", part });
+  const pages2 = listed.filter((p) => zip.has(p.part));
+  if (!pages2.length) {
+    diagram.problems.push({ cell: "", message: "no pages found in the Visio file" });
+    return diagram;
+  }
+  for (const page of pages2) {
+    const doc = parseXmlTree(zip.text(page.part) ?? "");
+    const all = [];
+    shapesOf(doc, void 0, masters, legendWords, all);
+    const byId = new Map(all.map((s) => [s.id, s]));
+    const ends = /* @__PURE__ */ new Map();
+    for (const c of findAll(child(doc, "Connects"), "Connect")) {
+      const from = c.attrs.FromSheet;
+      const to = c.attrs.ToSheet;
+      if (!from || !to)
+        continue;
+      const e = ends.get(from) ?? {};
+      if (c.attrs.FromCell === "BeginX")
+        e.begin = to;
+      else if (c.attrs.FromCell === "EndX")
+        e.end = to;
+      else
+        continue;
+      ends.set(from, e);
+    }
+    const isConnector = (s) => ends.has(s.id) || s.oneD;
+    const cell = (s) => `${page.id}.${s.id}`;
+    const nodeOf = /* @__PURE__ */ new Map();
+    for (const s of all) {
+      if (isConnector(s))
+        continue;
+      const { legend, text } = legendOf(s.legend, s.text, legendWords);
+      if (!text)
+        continue;
+      const style = {};
+      if (s.master)
+        style.master = s.master;
+      if (s.cells.PinX !== void 0)
+        style.x = s.cells.PinX;
+      if (s.cells.PinY !== void 0)
+        style.y = s.cells.PinY;
+      if (s.group)
+        style.group = "1";
+      const n = {
+        cell: cell(s),
+        label: text,
+        page: page.name,
+        line: s.el.line,
+        ...legend ? { legend } : {},
+        style
+      };
+      diagram.nodes.push(n);
+      nodeOf.set(s, n);
+    }
+    const boxOf = (id) => {
+      const start = id ? byId.get(id) : void 0;
+      for (let cur = start; cur; cur = cur.parent) {
+        const n = nodeOf.get(cur);
+        if (n)
+          return n;
+      }
+      if (!start)
+        return void 0;
+      const inside = [];
+      const walk = (s) => s.children.forEach((c) => {
+        const n = nodeOf.get(c);
+        if (n)
+          inside.push(n);
+        else
+          walk(c);
+      });
+      walk(start);
+      return inside.length === 1 ? inside[0] : void 0;
+    };
+    for (const s of all.filter(isConnector)) {
+      const e = ends.get(s.id) ?? {};
+      const from = boxOf(e.begin);
+      const to = boxOf(e.end);
+      if (!from || !to) {
+        diagram.problems.push({
+          cell: cell(s),
+          message: !from && !to ? "edge connects no boxes" : !from ? "edge has no source box" : "edge has no target box"
+        });
+        continue;
+      }
+      const { legend, text } = legendOf(s.legend, s.text, legendWords);
+      diagram.edges.push({
+        cell: cell(s),
+        from: from.label,
+        to: to.label,
+        label: text,
+        ...edgeParts(text),
+        ...legend ? { legend } : {},
+        page: page.name,
+        line: s.el.line
+      });
+    }
+  }
+  return diagram;
+}
+
+// packages/ingestors/dist/diagram.js
+function readDiagram(fileName, bytes, legendWords = DEFAULT_LEGEND) {
+  const ext = extOf(fileName);
+  if (/\.drawio(\.xml)?$/i.test(fileBase(fileName)))
+    return readDrawio(utf8(bytes), legendWords);
+  if (ext === ".vsdx")
+    return readVsdx(bytes, legendWords);
+  if (ext === ".csv")
+    return readLucidCsv(utf8(bytes), legendWords);
+  if (ext === ".mmd" || ext === ".mermaid")
+    return readMermaid(utf8(bytes), legendWords);
+  if (ext === ".md" || ext === ".markdown") {
+    const text = utf8(bytes);
+    return /^\s*(`{3,}|~{3,})\s*mermaid\s*$/m.test(text) ? readMermaid(text, legendWords) : void 0;
+  }
+  return void 0;
+}
+
+// packages/ingestors/dist/markup.js
+var import_yaml = __toESM(require_dist(), 1);
+
+// packages/ingestors/dist/text-model.js
+var ReadError = class extends Error {
+  name = "ReadError";
+};
+var Sections = class {
+  list = [];
+  lines = [];
+  cur = { heading: "", level: 0, text: "" };
+  firstLine;
+  heading(heading, level, at = {}) {
+    this.flush();
+    this.cur = { heading, level, text: "", ...at };
+  }
+  /** Add a line of text; `line` is where it is in the file (an untitled section starts there). */
+  add(text, line) {
+    if (this.firstLine === void 0 && line !== void 0 && text.trim())
+      this.firstLine = line;
+    this.lines.push(text);
+  }
+  /** Take back the last line added (Markdown: a setext underline turns it into a heading). */
+  popLine() {
+    return this.lines.pop();
+  }
+  /** Close the current section. One with neither heading nor text is dropped. */
+  flush() {
+    const text = trimBlankLines(this.lines);
+    const untitled = this.cur.heading === "";
+    if (!(untitled && !text)) {
+      const line = this.cur.line ?? (untitled ? this.firstLine : void 0);
+      this.list.push({ ...this.cur, text, ...line !== void 0 ? { line } : {} });
+    }
+    this.lines = [];
+    this.firstLine = void 0;
+  }
+  done() {
+    this.flush();
+    return this.list;
+  }
+};
+function trimBlankLines(lines) {
+  const l = lines.map((x) => x.replace(/\s+$/, ""));
+  while (l.length && !l[0])
+    l.shift();
+  while (l.length && !l.at(-1))
+    l.pop();
+  return l.join("\n");
+}
+
+// packages/ingestors/dist/markup.js
+var str = (v) => {
+  if (typeof v === "string")
+    return v.trim() || void 0;
+  if (Array.isArray(v)) {
+    const parts = v.filter((x) => typeof x === "string" && !!x.trim());
+    return parts.length ? parts.join(", ") : void 0;
+  }
+  return void 0;
+};
+function tableCells(line) {
+  let t = line.trim();
+  if (t.startsWith("|"))
+    t = t.slice(1);
+  if (t.endsWith("|") && !t.endsWith("\\|"))
+    t = t.slice(0, -1);
+  return t.split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, "|"));
+}
+var TABLE_SEP = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+function readMarkdown(src) {
+  const lines = src.replace(/^\uFEFF/, "").split(/\r?\n/);
+  const notes = [];
+  const meta = {};
+  let title;
+  let start = 0;
+  if (lines[0]?.trim() === "---") {
+    const end = lines.findIndex((l, i) => i > 0 && (l.trim() === "---" || l.trim() === "..."));
+    if (end > 0) {
+      start = end + 1;
+      try {
+        const fm = (0, import_yaml.parse)(lines.slice(1, end).join("\n"), { schema: "failsafe" });
+        if (fm && typeof fm === "object" && !Array.isArray(fm)) {
+          const o = fm;
+          title = str(o.title);
+          const version = str(o.version);
+          const author = str(o.author ?? o.authors);
+          const date = isoDate(str(o.date));
+          if (version)
+            meta.version = version;
+          if (author)
+            meta.author = author;
+          if (date)
+            meta.date = date;
+        }
+      } catch {
+        notes.push("The front matter could not be read, so its fields were skipped.");
+      }
+    }
+  }
+  const s = new Sections();
+  const tables = [];
+  let fence;
+  let table;
+  let prevPara = false;
+  for (let i = start; i < lines.length; i++) {
+    const l = lines[i];
+    const lineNo = i + 1;
+    if (fence) {
+      s.add(l, lineNo);
+      const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(l);
+      if (close && close[1][0] === fence.char && close[1].length >= fence.len)
+        fence = void 0;
+      prevPara = false;
+      continue;
+    }
+    const open = /^ {0,3}(`{3,}|~{3,})/.exec(l);
+    if (open) {
+      fence = { char: open[1][0], len: open[1].length };
+      table = void 0;
+      s.add(l, lineNo);
+      prevPara = false;
+      continue;
+    }
+    const atx = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/.exec(l);
+    if (atx) {
+      s.heading((atx[2] ?? "").trim(), atx[1].length, { line: lineNo });
+      table = void 0;
+      prevPara = false;
+      continue;
+    }
+    const setext = /^ {0,3}(=+|-+)[ \t]*$/.exec(l);
+    if (setext && prevPara) {
+      const text = s.popLine();
+      s.heading((text ?? "").trim(), setext[1][0] === "=" ? 1 : 2, { line: lineNo - 1 });
+      prevPara = false;
+      continue;
+    }
+    const next = lines[i + 1] ?? "";
+    if (table) {
+      if (l.trim() && l.includes("|")) {
+        if (!TABLE_SEP.test(l))
+          table.push(tableCells(l));
+      } else
+        table = void 0;
+    } else if (l.includes("|") && next.includes("-") && TABLE_SEP.test(next)) {
+      table = [tableCells(l)];
+      tables.push(table);
+    }
+    s.add(l, lineNo);
+    prevPara = !!l.trim() && !table;
+  }
+  return { ...title ? { title } : {}, sections: s.done(), tables, meta, notes };
+}
+function readPlainText(src) {
+  const s = new Sections();
+  src.replace(/^\uFEFF/, "").split(/\r\n|\r|\n/).forEach((l, i) => s.add(l, i + 1));
+  return { sections: s.done(), tables: [], meta: {}, notes: [] };
+}
+var HTML_ENTITIES = {
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  hellip: "\u2026",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  bull: "\u2022",
+  middot: "\xB7",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  deg: "\xB0",
+  times: "\xD7",
+  euro: "\u20AC",
+  pound: "\xA3",
+  aacute: "\xE1",
+  agrave: "\xE0",
+  acirc: "\xE2",
+  auml: "\xE4",
+  aring: "\xE5",
+  ccedil: "\xE7",
+  eacute: "\xE9",
+  egrave: "\xE8",
+  ecirc: "\xEA",
+  euml: "\xEB",
+  iacute: "\xED",
+  iuml: "\xEF",
+  ntilde: "\xF1",
+  oacute: "\xF3",
+  ocirc: "\xF4",
+  ouml: "\xF6",
+  oslash: "\xF8",
+  uacute: "\xFA",
+  uuml: "\xFC",
+  szlig: "\xDF"
+};
+var BLOCK = new Set("p div br li ul ol dl dt dd tr table thead tbody tfoot section article header footer nav main aside blockquote pre hr figure figcaption form fieldset address caption h1 h2 h3 h4 h5 h6".split(" "));
+var blank = (m) => m.replace(/[^\n]/g, "");
+function readHtml(src) {
+  const meta = {};
+  const titleM = /<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(src);
+  const title = titleM ? decodeEntities(titleM[1].replace(/<[^>]*>/g, " "), HTML_ENTITIES).replace(/\s+/g, " ").trim() : void 0;
+  for (const m of src.matchAll(/<meta\b[^>]*>/gi)) {
+    const tag2 = m[0];
+    const name = /\b(?:name|property)\s*=\s*["']([^"']+)["']/i.exec(tag2)?.[1]?.toLowerCase();
+    const content = /\bcontent\s*=\s*["']([^"']*)["']/i.exec(tag2)?.[1];
+    if (!name || content === void 0)
+      continue;
+    const value = decodeEntities(content, HTML_ENTITIES).trim();
+    if (name === "author" && value)
+      meta.author ??= value;
+    if (["date", "dcterms.date", "article:published_time"].includes(name))
+      meta.date ??= isoDate(value);
+  }
+  if (!meta.date)
+    delete meta.date;
+  const clean = src.replace(/<!--[\s\S]*?-->/g, blank).replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, blank).replace(/<![^>]*>|<\?[\s\S]*?\?>/g, blank).replace(/<(script|style|noscript|template|svg)\b[\s\S]*?<\/\1\s*>/gi, blank).replace(/<head\b[\s\S]*?<\/head\s*>/gi, blank);
+  const s = new Sections();
+  const tables = [];
+  let line = "";
+  let lineStart;
+  let heading;
+  let table;
+  let row;
+  let cell;
+  let pos = 0;
+  let lineNo = 1;
+  const lineAt = (to) => {
+    for (; pos < to; pos++)
+      if (clean.charCodeAt(pos) === 10)
+        lineNo++;
+    return lineNo;
+  };
+  const flush = () => {
+    const t = line.replace(/\s+/g, " ").trim();
+    if (t)
+      s.add(t, lineStart);
+    line = "";
+    lineStart = void 0;
+  };
+  const tag = /<(\/?)([a-zA-Z][a-zA-Z0-9]*)\b[^>]*>/g;
+  let last = 0;
+  const text = (raw, at) => {
+    const t = decodeEntities(raw, HTML_ENTITIES);
+    if (heading)
+      heading.text += t;
+    else if (cell !== void 0)
+      cell += t;
+    else if (table)
+      return;
+    else {
+      if (t.trim() && lineStart === void 0)
+        lineStart = lineAt(at + raw.search(/\S/));
+      line += t;
+    }
+  };
+  for (let m = tag.exec(clean); m; m = tag.exec(clean)) {
+    text(clean.slice(last, m.index), last);
+    last = tag.lastIndex;
+    const close = m[1] === "/";
+    const name = m[2].toLowerCase();
+    const h = /^h([1-6])$/.exec(name);
+    if (h) {
+      if (!close) {
+        flush();
+        heading = { level: Number(h[1]), text: "", line: lineAt(m.index) };
+      } else if (heading) {
+        s.heading(heading.text.replace(/\s+/g, " ").trim(), heading.level, { line: heading.line });
+        heading = void 0;
+      }
+      continue;
+    }
+    if (name === "table") {
+      flush();
+      if (!close) {
+        table = [];
+        tables.push(table);
+      } else
+        table = void 0;
+      continue;
+    }
+    if (table && name === "tr") {
+      if (!close)
+        row = [];
+      else if (row) {
+        if (row.length) {
+          table.push(row);
+          s.add(row.join("	"));
+        }
+        row = void 0;
+      }
+      continue;
+    }
+    if (table && (name === "td" || name === "th")) {
+      if (!close)
+        cell = "";
+      else if (cell !== void 0) {
+        row?.push(cell.replace(/\s+/g, " ").trim());
+        cell = void 0;
+      }
+      continue;
+    }
+    if (name === "br" && heading)
+      heading.text += " ";
+    else if (name === "br" && cell !== void 0)
+      cell += " ";
+    else if (BLOCK.has(name) && !heading && cell === void 0)
+      flush();
+  }
+  text(clean.slice(last), last);
+  flush();
+  return {
+    ...title ? { title } : {},
+    sections: s.done(),
+    tables: tables.filter((t) => t.length),
+    meta,
+    notes: []
+  };
+}
+
+// packages/ingestors/dist/office.js
+function coreProps(zip) {
+  const doc = parseXmlTree(zip.text("docProps/core.xml") ?? "");
+  const get = (name) => {
+    const t = textOf(child(doc, name)).trim();
+    return t || void 0;
+  };
+  const meta = {};
+  const author = get("creator");
+  const version = get("version");
+  const date = isoDate(get("modified")) ?? isoDate(get("created"));
+  if (author)
+    meta.author = author;
+  if (version)
+    meta.version = version;
+  if (date)
+    meta.date = date;
+  const title = get("title");
+  return { ...title ? { title } : {}, meta };
+}
+function need(zip, part) {
+  const text = zip.text(part);
+  if (text === void 0)
+    throw new ReadError(`${part} is missing`);
+  const doc = parseXmlTree(text);
+  if (!doc)
+    throw new ReadError(`${part} is not XML`);
+  return doc;
+}
+function wordText(p) {
+  let out = "";
+  const walk = (n) => {
+    for (const c of elements(n)) {
+      if (c.name === "t")
+        out += textOf(c);
+      else if (c.name === "tab")
+        out += "	";
+      else if (c.name === "br" || c.name === "cr")
+        out += "\n";
+      else if (c.name === "noBreakHyphen")
+        out += "-";
+      else if (c.name !== "pPr" && c.name !== "rPr" && c.name !== "del")
+        walk(c);
+    }
+  };
+  walk(p);
+  return out;
+}
+function wordStyles(zip) {
+  const levels = /* @__PURE__ */ new Map();
+  const doc = parseXmlTree(zip.text("word/styles.xml") ?? "");
+  for (const s of childrenNamed(doc, "style")) {
+    const id = attr(s, "styleId");
+    if (!id)
+      continue;
+    const name = (attr(child(s, "name") ?? s, "val") ?? "").toLowerCase();
+    const outline = attr(child(child(s, "pPr"), "outlineLvl") ?? s, "val");
+    const h = /^heading (\d)$/.exec(name) ?? /^Heading(\d)$/.exec(id);
+    if (name === "title" || id === "Title")
+      levels.set(id, 0);
+    else if (h)
+      levels.set(id, Number(h[1]));
+    else if (outline !== void 0 && /^\d$/.test(outline))
+      levels.set(id, Number(outline) + 1);
+  }
+  return levels;
+}
+function readDocx(zip) {
+  const doc = need(zip, "word/document.xml");
+  const levels = wordStyles(zip);
+  const { title, meta } = coreProps(zip);
+  const s = new Sections();
+  const tables = [];
+  const levelOf = (p) => {
+    const pPr = child(p, "pPr");
+    const pStyle = child(pPr, "pStyle");
+    const style = pStyle ? attr(pStyle, "val") : void 0;
+    if (style && levels.has(style))
+      return levels.get(style);
+    const style2 = style ? /^Heading(\d)$/.exec(style) : null;
+    if (style2)
+      return Number(style2[1]);
+    const outline = child(pPr, "outlineLvl");
+    const v = outline ? attr(outline, "val") : void 0;
+    return v !== void 0 && /^\d$/.test(v) ? Number(v) + 1 : void 0;
+  };
+  const block = (container) => {
+    for (const el of elements(container)) {
+      if (el.name === "p") {
+        const text = wordText(el);
+        const level = levelOf(el);
+        if (level !== void 0 && text.trim())
+          s.heading(text.trim(), level);
+        else if (text.trim())
+          s.add(text);
+      } else if (el.name === "tbl") {
+        const rows = findAll(el, "tr").map((tr) => findAll(tr, "tc").map((tc) => findAll(tc, "p").map(wordText).map((t) => t.trim()).filter(Boolean).join(" ")));
+        if (rows.length) {
+          tables.push(rows);
+          for (const r of rows)
+            s.add(r.join("	"));
+        }
+      } else if (el.name === "sdt")
+        block(child(el, "sdtContent"));
+      else if (el.name === "customXml" || el.name === "smartTag")
+        block(el);
+    }
+  };
+  block(child(doc, "body"));
+  return { ...title ? { title } : {}, sections: s.done(), tables, meta, notes: [] };
+}
+function drawingParagraphs(body) {
+  return findAll(body, "p").map((p) => {
+    let out = "";
+    const walk = (n) => {
+      for (const c of elements(n)) {
+        if (c.name === "t")
+          out += textOf(c);
+        else if (c.name === "br")
+          out += "\n";
+        else if (c.name === "tab")
+          out += "	";
+        else if (c.name !== "pPr" && c.name !== "rPr" && c.name !== "endParaRPr")
+          walk(c);
+      }
+    };
+    walk(p);
+    return out;
+  });
+}
+function slideParts(zip) {
+  const rels = relationships(zip.text("ppt/_rels/presentation.xml.rels"));
+  const pres = parseXmlTree(zip.text("ppt/presentation.xml") ?? "");
+  const parts = [];
+  for (const id of findAll(child(pres, "sldIdLst"), "sldId")) {
+    const target = rels.get(relId(id) ?? "");
+    if (target)
+      parts.push(resolvePart("ppt", target));
+  }
+  const num = (n) => Number(/slide(\d+)\.xml$/.exec(n)?.[1] ?? 0);
+  const rest = zip.names.filter((n) => /^ppt\/slides\/slide\d+\.xml$/.test(n) && !parts.includes(n)).sort((a, b) => num(a) - num(b));
+  return [...parts, ...rest].filter((p) => zip.has(p));
+}
+function readPptx(zip) {
+  const parts = slideParts(zip);
+  if (!parts.length && !zip.has("ppt/presentation.xml"))
+    throw new ReadError("ppt/presentation.xml is missing");
+  const { title, meta } = coreProps(zip);
+  const s = new Sections();
+  const tables = [];
+  parts.forEach((part, i) => {
+    const doc = parseXmlTree(zip.text(part) ?? "");
+    let heading = "";
+    const lines = [];
+    const walk = (n) => {
+      for (const c of elements(n)) {
+        if (c.name === "sp") {
+          const ph = findAll(child(c, "nvSpPr"), "ph")[0];
+          const type = ph?.attrs.type;
+          const paras = drawingParagraphs(child(c, "txBody"));
+          if ((type === "title" || type === "ctrTitle") && !heading)
+            heading = paras.join(" ").replace(/\s+/g, " ").trim();
+          else
+            lines.push(...paras.filter((p) => p.trim()));
+        } else if (c.name === "graphicFrame") {
+          for (const tbl of findAll(c, "tbl")) {
+            const rows = findAll(tbl, "tr").map((tr) => findAll(tr, "tc").map((tc) => drawingParagraphs(child(tc, "txBody")).map((t) => t.trim()).filter(Boolean).join(" ")));
+            if (rows.length) {
+              tables.push(rows);
+              lines.push(...rows.map((r) => r.join("	")));
+            }
+          }
+        } else
+          walk(c);
+      }
+    };
+    const tree = child(child(doc, "cSld"), "spTree") ?? doc;
+    if (tree)
+      walk(tree);
+    s.heading(heading, 1, { page: i + 1 });
+    for (const l of lines)
+      s.add(l);
+  });
+  return { ...title ? { title } : {}, sections: s.done(), tables, meta, notes: [] };
+}
+var colIndex = (ref2) => {
+  const letters = /^[A-Z]+/i.exec(ref2)?.[0].toUpperCase() ?? "";
+  let n = 0;
+  for (const ch of letters)
+    n = n * 26 + (ch.charCodeAt(0) - 64);
+  return n - 1;
+};
+var stringItem = (si) => elements(si).flatMap((c) => c.name === "t" ? [c] : c.name === "r" ? childrenNamed(c, "t") : []).map(textOf).join("");
+function readXlsx(zip) {
+  const wb = need(zip, "xl/workbook.xml");
+  const rels = relationships(zip.text("xl/_rels/workbook.xml.rels"));
+  const shared = childrenNamed(parseXmlTree(zip.text("xl/sharedStrings.xml") ?? ""), "si").map(stringItem);
+  const { title, meta } = coreProps(zip);
+  const s = new Sections();
+  const tables = [];
+  findAll(child(wb, "sheets"), "sheet").forEach((sheet, i) => {
+    const target = rels.get(relId(sheet) ?? "");
+    const part = target ? resolvePart("xl", target) : void 0;
+    const doc = part ? parseXmlTree(zip.text(part) ?? "") : void 0;
+    const rows = [];
+    let prev;
+    for (const row of findAll(child(doc, "sheetData"), "row")) {
+      const r = Number(row.attrs.r) || (prev ?? 0) + 1;
+      if (prev !== void 0)
+        for (let k = prev + 1; k < r; k++)
+          rows.push([]);
+      prev = r;
+      const cells2 = [];
+      let next = 0;
+      for (const c of childrenNamed(row, "c")) {
+        const at = c.attrs.r ? colIndex(c.attrs.r) : next;
+        const v = textOf(child(c, "v"));
+        let value;
+        switch (c.attrs.t) {
+          case "s":
+            value = shared[Number(v)] ?? "";
+            break;
+          case "inlineStr":
+            value = stringItem(child(c, "is"));
+            break;
+          case "b":
+            value = v === "1" ? "TRUE" : v === "0" ? "FALSE" : v;
+            break;
+          default:
+            value = v;
+        }
+        while (cells2.length < at)
+          cells2.push("");
+        cells2[at] = value;
+        next = at + 1;
+      }
+      while (cells2.length && cells2.at(-1) === "")
+        cells2.pop();
+      rows.push(cells2);
+    }
+    tables.push(rows);
+    s.heading(sheet.attrs.name ?? `Sheet ${i + 1}`, 1, { page: i + 1 });
+    for (const r of rows)
+      s.add(r.join("	"));
+  });
+  return { ...title ? { title } : {}, sections: s.done(), tables, meta, notes: [] };
+}
+
+// packages/ingestors/dist/pdf.js
+import { constants, inflateSync } from "node:zlib";
+var NO_TEXT = "No text was found in this PDF. It may be a scanned image, so a person needs to read it.";
+var MAX_STREAM = 64 * 1024 * 1024;
+var refs = (s) => [...s.matchAll(/(\d+)\s+\d+\s+R\b/g)].map((m) => Number(m[1]));
+var ref = (dict, key) => {
+  const m = new RegExp(`/${key}\\s+(\\d+)\\s+\\d+\\s+R\\b`).exec(dict);
+  return m ? Number(m[1]) : void 0;
+};
+var isType = (dict, type) => new RegExp(`/Type\\s*/${type}(?![A-Za-z])`).test(dict);
+function decodeStream(o) {
+  if (!o.stream)
+    return void 0;
+  const filter = /\/Filter\s*(\[[^\]]*\]|\/\w+)/.exec(o.dict)?.[1];
+  if (!filter)
+    return o.stream;
+  const names = filter.match(/\/\w+/g) ?? [];
+  if (names.length !== 1 || names[0] !== "/FlateDecode")
+    return void 0;
+  try {
+    return inflateSync(o.stream, { maxOutputLength: MAX_STREAM });
+  } catch {
+    try {
+      return inflateSync(o.stream, {
+        finishFlush: constants.Z_SYNC_FLUSH,
+        maxOutputLength: MAX_STREAM
+      });
+    } catch {
+      return void 0;
+    }
+  }
+}
+function objects(src, bytes) {
+  const out = /* @__PURE__ */ new Map();
+  const re = /(\d+)\s+(\d+)\s+obj\b/g;
+  for (let m = re.exec(src); m; m = re.exec(src)) {
+    const start = re.lastIndex;
+    const end = src.indexOf("endobj", start);
+    const body = src.slice(start, end < 0 ? src.length : end);
+    const s = /\bstream\r?\n/.exec(body);
+    const obj = { dict: s ? body.slice(0, s.index) : body };
+    if (s) {
+      const dataStart = start + s.index + s[0].length;
+      const len = /\/Length\s+(\d+)(?!\s+\d+\s+R)/.exec(obj.dict);
+      let dataEnd = -1;
+      if (len) {
+        const e = dataStart + Number(len[1]);
+        if (/^\s*endstream/.test(src.slice(e, e + 30)))
+          dataEnd = e;
+      }
+      if (dataEnd < 0) {
+        const es = src.indexOf("endstream", dataStart);
+        dataEnd = es < 0 ? dataStart : es;
+        while (dataEnd > dataStart && (src[dataEnd - 1] === "\n" || src[dataEnd - 1] === "\r"))
+          dataEnd--;
+      }
+      obj.stream = bytes.subarray(dataStart, dataEnd);
+    }
+    out.set(Number(m[1]), obj);
+    if (end > 0)
+      re.lastIndex = end;
+  }
+  for (const o of [...out.values()]) {
+    if (!isType(o.dict, "ObjStm"))
+      continue;
+    const data = decodeStream(o)?.toString("latin1");
+    const n = Number(/\/N\s+(\d+)/.exec(o.dict)?.[1] ?? 0);
+    const first = Number(/\/First\s+(\d+)/.exec(o.dict)?.[1] ?? 0);
+    if (!data || !n)
+      continue;
+    const head = data.slice(0, first).trim().split(/\s+/).map(Number);
+    for (let k = 0; k < n; k++) {
+      const num = head[2 * k];
+      const off = first + head[2 * k + 1];
+      const nextOff = k + 1 < n ? first + head[2 * k + 3] : data.length;
+      if (!out.has(num))
+        out.set(num, { dict: data.slice(off, nextOff) });
+    }
+  }
+  return out;
+}
+function literalBytes(s) {
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c !== "\\") {
+      out.push(c.charCodeAt(0) & 255);
+      continue;
+    }
+    const n = s[++i];
+    if (n === void 0)
+      break;
+    const simple = { n: 10, r: 13, t: 9, b: 8, f: 12 };
+    if (n in simple)
+      out.push(simple[n]);
+    else if (/[0-7]/.test(n)) {
+      let oct = n;
+      while (oct.length < 3 && /[0-7]/.test(s[i + 1] ?? ""))
+        oct += s[++i];
+      out.push(parseInt(oct, 8) & 255);
+    } else if (n === "\r") {
+      if (s[i + 1] === "\n")
+        i++;
+    } else if (n !== "\n")
+      out.push(n.charCodeAt(0) & 255);
+  }
+  return out;
+}
+function bytesText(b) {
+  let s;
+  if (b[0] === 254 && b[1] === 255) {
+    s = "";
+    for (let i = 2; i + 1 < b.length; i += 2)
+      s += String.fromCharCode(b[i] << 8 | b[i + 1]);
+  } else
+    s = String.fromCharCode(...b);
+  let out = "";
+  for (const ch of s) {
+    const c = ch.charCodeAt(0);
+    if (c >= 32 ? c !== 127 : c === 9 || c === 10 || c === 13)
+      out += ch;
+  }
+  return out;
+}
+function readLiteral(src, i) {
+  let depth = 1;
+  let k = i;
+  for (; k < src.length; k++) {
+    const c = src[k];
+    if (c === "\\")
+      k++;
+    else if (c === "(")
+      depth++;
+    else if (c === ")" && --depth === 0)
+      break;
+  }
+  return [src.slice(i, k), k + 1];
+}
+function hexBytes(h) {
+  const clean = h.replace(/[^0-9a-fA-F]/g, "");
+  const even = clean.length % 2 ? clean + "0" : clean;
+  const out = [];
+  for (let i = 0; i < even.length; i += 2)
+    out.push(parseInt(even.slice(i, i + 2), 16));
+  return out;
+}
+function contentText(src) {
+  const lines = [];
+  let cur = "";
+  const newline = () => {
+    if (cur.trim())
+      lines.push(cur.replace(/\s+/g, " ").trim());
+    cur = "";
+  };
+  const show = (tok) => {
+    if (tok?.t === "str")
+      cur += bytesText(tok.v);
+    else if (tok?.t === "arr")
+      for (const x of tok.v) {
+        if (x.t === "str")
+          cur += bytesText(x.v);
+        else if (x.t === "num" && x.v < -200)
+          cur += " ";
+      }
+  };
+  const stack = [];
+  const arrays = [];
+  const push = (tok) => arrays.length ? arrays.at(-1).push(tok) : stack.push(tok);
+  let lastY;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (/\s/.test(c)) {
+      i++;
+    } else if (c === "%") {
+      const e = src.indexOf("\n", i);
+      i = e < 0 ? src.length : e + 1;
+    } else if (c === "(") {
+      const [body, next] = readLiteral(src, i + 1);
+      push({ t: "str", v: literalBytes(body) });
+      i = next;
+    } else if (c === "<" && src[i + 1] === "<") {
+      i += 2;
+    } else if (c === ">" && src[i + 1] === ">") {
+      i += 2;
+    } else if (c === "<") {
+      const e = src.indexOf(">", i);
+      push({ t: "str", v: hexBytes(src.slice(i + 1, e < 0 ? src.length : e)) });
+      i = e < 0 ? src.length : e + 1;
+    } else if (c === "[") {
+      arrays.push([]);
+      i++;
+    } else if (c === "]") {
+      const a = arrays.pop() ?? [];
+      push({ t: "arr", v: a });
+      i++;
+    } else if (c === "/") {
+      const m = /^\/[^\s/[\]()<>{}%]*/.exec(src.slice(i, i + 128));
+      push({ t: "other" });
+      i += m[0].length;
+    } else {
+      const m = /^[+-]?(\d+\.?\d*|\.\d+)/.exec(src.slice(i, i + 32));
+      if (m) {
+        push({ t: "num", v: Number(m[0]) });
+        i += m[0].length;
+        continue;
+      }
+      const w = /^[A-Za-z'"*0-9]+/.exec(src.slice(i, i + 32));
+      const op = w ? w[0] : c;
+      i += op.length;
+      const num = (k) => {
+        const t = stack[stack.length - k];
+        return t?.t === "num" ? t.v : 0;
+      };
+      switch (op) {
+        case "BT":
+        case "ET":
+        case "T*":
+          newline();
+          break;
+        case "Td":
+        case "TD":
+          if (num(1) !== 0)
+            newline();
+          break;
+        case "Tm": {
+          const y = num(1);
+          if (lastY !== void 0 && y !== lastY)
+            newline();
+          lastY = y;
+          break;
+        }
+        case "Tj":
+        case "TJ":
+          show(stack.at(-1));
+          break;
+        case "'":
+          newline();
+          show(stack.at(-1));
+          break;
+        case '"':
+          newline();
+          show(stack.at(-1));
+          break;
+        case "ID": {
+          const e = src.slice(i).search(/\sEI(\s|$)/);
+          i = e < 0 ? src.length : i + e + 3;
+          break;
+        }
+      }
+      if (op === "BT")
+        lastY = void 0;
+      stack.length = 0;
+    }
+  }
+  newline();
+  return lines;
+}
+function dictString(dict, key) {
+  const m = new RegExp(`/${key}\\s*([(<])`).exec(dict);
+  if (!m)
+    return void 0;
+  const at = m.index + m[0].length;
+  if (m[1] === "(")
+    return bytesText(literalBytes(readLiteral(dict, at)[0])).trim() || void 0;
+  const e = dict.indexOf(">", at);
+  return bytesText(hexBytes(dict.slice(at, e < 0 ? dict.length : e))).trim() || void 0;
+}
+function pdfDate(s) {
+  const m = s ? /^(?:D:)?(\d{4})(\d{2})?(\d{2})?/.exec(s) : null;
+  if (!m)
+    return void 0;
+  return `${m[1]}-${m[2] ?? "01"}-${m[3] ?? "01"}`;
+}
+function readPdf(bytes) {
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const src = buf.toString("latin1");
+  const objs = objects(src, buf);
+  const trailers = [...src.matchAll(/trailer\s*(<<[\s\S]*?>>)/g)].map((m) => m[1]);
+  for (const o of objs.values())
+    if (isType(o.dict, "XRef"))
+      trailers.push(o.dict);
+  const latestFirst = [...trailers].reverse();
+  const trailerRef = (key) => {
+    for (const t of latestFirst) {
+      const r = ref(t, key);
+      if (r !== void 0)
+        return r;
+    }
+    return void 0;
+  };
+  const meta = {};
+  const notes = [];
+  if (trailers.some((t) => /\/Encrypt\b/.test(t))) {
+    notes.push("This PDF is encrypted, so its text was not read. A person needs to read it.");
+    return { sections: [], tables: [], meta: { flags: ["needs-reading"] }, notes };
+  }
+  const infoNo = trailerRef("Info");
+  const info = infoNo !== void 0 ? objs.get(infoNo)?.dict : void 0;
+  const title = info ? dictString(info, "Title") : void 0;
+  if (info) {
+    const author = dictString(info, "Author");
+    const date = pdfDate(dictString(info, "ModDate")) ?? pdfDate(dictString(info, "CreationDate"));
+    if (author)
+      meta.author = author;
+    if (date && /^\d{4}-\d{2}-\d{2}$/.test(date))
+      meta.date = date;
+  }
+  const pages2 = [];
+  let rootNo = trailerRef("Root");
+  if (rootNo === void 0) {
+    for (const [n, o] of objs)
+      if (isType(o.dict, "Catalog"))
+        rootNo ??= n;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (n, depth) => {
+    const o = objs.get(n);
+    if (!o || seen.has(n) || depth > 64)
+      return;
+    seen.add(n);
+    if (isType(o.dict, "Pages")) {
+      const kids = /\/Kids\s*\[([^\]]*)\]/.exec(o.dict)?.[1] ?? "";
+      for (const k of refs(kids))
+        walk(k, depth + 1);
+    } else if (isType(o.dict, "Page"))
+      pages2.push(n);
+  };
+  const pagesRoot = rootNo !== void 0 ? ref(objs.get(rootNo)?.dict ?? "", "Pages") : void 0;
+  if (pagesRoot !== void 0)
+    walk(pagesRoot, 0);
+  if (!pages2.length) {
+    for (const [n, o] of [...objs].sort((a, b) => a[0] - b[0]))
+      if (isType(o.dict, "Page"))
+        pages2.push(n);
+  }
+  const s = new Sections();
+  pages2.forEach((n, i) => {
+    const dict = objs.get(n).dict;
+    const contents = /\/Contents\s*(\[[^\]]*\]|\d+\s+\d+\s+R)/.exec(dict)?.[1] ?? "";
+    let streams = refs(contents);
+    if (streams.length === 1 && !objs.get(streams[0])?.stream)
+      streams = refs(objs.get(streams[0])?.dict ?? "");
+    const text = streams.map((r) => objs.get(r)).map((o) => o ? decodeStream(o)?.toString("latin1") : void 0).filter((t) => t !== void 0).flatMap(contentText);
+    s.heading("", 0, { page: i + 1 });
+    for (const l of text)
+      s.add(l);
+  });
+  const sections = s.done();
+  if (!sections.length) {
+    notes.push(NO_TEXT);
+    meta.flags = ["needs-reading"];
+  }
+  return { ...title ? { title } : {}, sections, tables: [], meta, notes };
+}
+
+// packages/ingestors/dist/documents.js
+var BY_EXT = {
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".html": "html",
+  ".htm": "html",
+  ".txt": "text",
+  ".text": "text",
+  ".docx": "docx",
+  ".pptx": "pptx",
+  ".xlsx": "xlsx",
+  ".pdf": "pdf"
+};
+var DOC_TYPE = {
+  markdown: "document",
+  html: "document",
+  text: "document",
+  docx: "document",
+  pptx: "presentation",
+  xlsx: "spreadsheet",
+  pdf: "document"
+};
+function officeFormat(head) {
+  const peek = peekZip(head);
+  if (!peek)
+    return void 0;
+  const text = `${peek.name}
+${peek.content}`;
+  if (/wordprocessingml|^word\//m.test(text))
+    return "docx";
+  if (/presentationml|^ppt\//m.test(text))
+    return "pptx";
+  if (/spreadsheetml|^xl\//m.test(text))
+    return "xlsx";
+  if (/ms-visio|^visio\//m.test(text))
+    return "vsdx";
+  return void 0;
+}
+function documentFormat(fileName, head) {
+  const byExt = BY_EXT[extOf(fileName)];
+  if (byExt)
+    return byExt;
+  if (new TextDecoder("latin1").decode(head.slice(0, 1024)).includes("%PDF-"))
+    return "pdf";
+  const office = officeFormat(head);
+  return office && office !== "vsdx" ? office : void 0;
+}
+function parse(format, bytes, limits) {
+  switch (format) {
+    case "markdown":
+      return readMarkdown(utf8(bytes));
+    case "html":
+      return readHtml(utf8(bytes));
+    case "text":
+      return readPlainText(utf8(bytes));
+    case "pdf":
+      return readPdf(bytes);
+    case "docx":
+      return readDocx(readZip(bytes, limits));
+    case "pptx":
+      return readPptx(readZip(bytes, limits));
+    case "xlsx":
+      return readXlsx(readZip(bytes, limits));
+  }
+}
+var HEADING_TITLE = /* @__PURE__ */ new Set(["markdown", "html", "docx", "pptx"]);
+function readDocument(fileName, bytes, limits = {}) {
+  const format = documentFormat(fileName, bytes.slice(0, 4096));
+  if (!format)
+    throw new Error(`${fileBase(fileName)} is not a document type Atticus reads.`);
+  let parsed;
+  try {
+    parsed = parse(format, bytes, limits);
+  } catch (err) {
+    if (!(err instanceof ZipError || err instanceof ReadError))
+      throw err;
+    parsed = {
+      sections: [],
+      tables: [],
+      meta: {},
+      notes: [`This file could not be read as a .${format}: ${err.message}.`]
+    };
+  }
+  const firstHeading = HEADING_TITLE.has(format) ? parsed.sections.find((s) => s.heading)?.heading : void 0;
+  const text = {
+    title: parsed.title ?? firstHeading ?? stem(fileName),
+    sections: parsed.sections,
+    ...parsed.tables.length ? { tables: parsed.tables } : {}
+  };
+  return {
+    format,
+    record: sourceDocument(fileName, bytes, DOC_TYPE[format], "document", parsed.meta),
+    text,
+    notes: parsed.notes
+  };
+}
+
+// packages/ingestors/dist/image.js
+var NEEDS_READING_FLAG = "needs-reading";
+var REASON = "Edges in a picture are read later, by AI or a person, and each edge is asserted only after a person confirms it.";
+var EXT = {
+  ".png": "png",
+  ".jpg": "jpeg",
+  ".jpeg": "jpeg",
+  ".gif": "gif",
+  ".webp": "webp",
+  ".svg": "svg"
+};
+var IMAGE_EXTENSIONS = Object.keys(EXT);
+function imageFormat(head) {
+  const b = head;
+  const ascii = (from, to) => String.fromCharCode(...b.slice(from, to));
+  if (b.length >= 8 && b[0] === 137 && ascii(1, 4) === "PNG" && b[4] === 13 && b[5] === 10)
+    return "png";
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255)
+    return "jpeg";
+  if (b.length >= 6 && /^GIF8[79]a$/.test(ascii(0, 6)))
+    return "gif";
+  if (b.length >= 12 && ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP")
+    return "webp";
+  const text = new TextDecoder().decode(b.slice(0, 1024));
+  if (/^\s*(<\?xml[^>]*\?>\s*)?(<!--[\s\S]*?-->\s*|<!DOCTYPE[^>]*>\s*)*<svg[\s>]/i.test(text))
+    return "svg";
+  return void 0;
+}
+function size(format, b) {
+  const be16 = (i) => b[i] << 8 | b[i + 1];
+  const le16 = (i) => b[i] | b[i + 1] << 8;
+  const le24 = (i) => b[i] | b[i + 1] << 8 | b[i + 2] << 16;
+  const be32 = (i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+  try {
+    if (format === "png" && b.length >= 24)
+      return { width: be32(16), height: be32(20) };
+    if (format === "gif" && b.length >= 10)
+      return { width: le16(6), height: le16(8) };
+    if (format === "jpeg") {
+      for (let i = 2; i + 9 < b.length; ) {
+        if (b[i] !== 255)
+          return {};
+        const marker = b[i + 1];
+        if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker))
+          return { height: be16(i + 5), width: be16(i + 7) };
+        i += 2 + be16(i + 2);
+      }
+      return {};
+    }
+    if (format === "webp" && b.length >= 30) {
+      const chunk = String.fromCharCode(...b.slice(12, 16));
+      if (chunk === "VP8X")
+        return { width: le24(24) + 1, height: le24(27) + 1 };
+      if (chunk === "VP8 ")
+        return { width: le16(26) & 16383, height: le16(28) & 16383 };
+      if (chunk === "VP8L") {
+        const bits = b[21] | b[22] << 8 | b[23] << 16 | b[24] << 24;
+        return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+      }
+    }
+  } catch {
+    return {};
+  }
+  return {};
+}
+function svgLabels(svg) {
+  const out = [];
+  for (const t of findAll(svg, "text")) {
+    const parts = t.children.map((c) => typeof c === "string" ? c : textOf(c));
+    const label = squash(parts.join(" "));
+    if (label && !out.includes(label))
+      out.push(label);
+  }
+  return out;
+}
+var px = (v) => {
+  const m = v ? /^\s*(\d+(?:\.\d+)?)\s*(px)?\s*$/.exec(v) : null;
+  return m ? Number(m[1]) : void 0;
+};
+function readImage(fileName, bytes) {
+  const notes = [];
+  const byExt = EXT[extOf(fileName)];
+  const byBytes = imageFormat(bytes.slice(0, 1024));
+  const format = byBytes ?? "unknown";
+  if (!byBytes)
+    notes.push("The content is not a picture format Atticus recognises.");
+  else if (byExt && byExt !== byBytes)
+    notes.push(`The file name says ${byExt} but the content is ${byBytes}.`);
+  let dims = {};
+  let candidateLabels = [];
+  if (format === "svg") {
+    const svg = parseXmlTree(utf8(bytes));
+    if (svg) {
+      const width = px(svg.attrs.width);
+      const height = px(svg.attrs.height);
+      dims = { ...width ? { width } : {}, ...height ? { height } : {} };
+      candidateLabels = svgLabels(svg);
+    }
+  } else if (format !== "unknown")
+    dims = size(format, bytes);
+  return {
+    record: sourceDocument(fileName, bytes, "image", "diagram", { flags: [NEEDS_READING_FLAG] }),
+    image: { format, ...dims },
+    needsReading: { reason: REASON, candidateLabels, confirmed: false },
+    notes
+  };
+}
+
+// packages/ingestors/dist/figma.js
+var FIG_MAGIC = "fig-kiwi";
+var LINK2 = /https:\/\/(?:www\.)?figma\.com\/[^\s"'<>]+/;
+function looksLikeFigma(head) {
+  const text = new TextDecoder().decode(head.slice(0, 4096));
+  if (text.startsWith(FIG_MAGIC))
+    return "binary";
+  if (/^\s*\{/.test(text) && /"document"\s*:/.test(text) && /"type"\s*:\s*"DOCUMENT"/.test(text))
+    return "json";
+  if (LINK2.test(text) && text.length < 4096 && !/^\s*</.test(text))
+    return "link";
+  return void 0;
+}
+function readFigma(fileName, bytes) {
+  const kind = looksLikeFigma(bytes);
+  const notes = [];
+  let title;
+  let version;
+  let date;
+  let link;
+  const pages2 = [];
+  if (kind === "json") {
+    try {
+      const doc = JSON.parse(utf8(bytes));
+      if (typeof doc.name === "string" && doc.name.trim())
+        title = doc.name.trim();
+      if (typeof doc.version === "string" || typeof doc.version === "number")
+        version = String(doc.version);
+      date = isoDate(doc.lastModified);
+      for (const c of doc.document?.children ?? [])
+        if (c?.type === "CANVAS" && typeof c.name === "string")
+          pages2.push(c.name);
+    } catch {
+      notes.push("The Figma export is not valid JSON, so only the file itself is recorded.");
+    }
+  } else if (kind === "link")
+    link = LINK2.exec(utf8(bytes))[0];
+  else if (kind !== "binary")
+    notes.push("This does not look like a Figma file, export or link.");
+  return {
+    record: sourceDocument(fileName, bytes, "design", "document", {
+      ...version ? { version } : {},
+      ...date ? { date } : {}
+    }),
+    ...title ? { title } : {},
+    pages: pages2,
+    ...link ? { link } : {},
+    notes
+  };
+}
+
+// packages/ingestors/dist/ingestors.js
+var VERSION = "0.1.0";
+var headText = (head) => new TextDecoder().decode(head.slice(0, 4096));
+function diagramIngestor(id, sniff, check) {
+  return {
+    id,
+    version: VERSION,
+    sniff,
+    async *ingest(fileName, content, ctx) {
+      const problem = check(content);
+      if (problem)
+        ctx.warn(problem, fileName);
+      yield sourceDocument(fileName, content, "diagram", "diagram");
+    }
+  };
+}
+var isLucidHeader = (head) => {
+  const first = headText(head).replace(/^\uFEFF/, "").split(/\r?\n/)[0].toLowerCase();
+  const cols = first.split(",").map((c) => c.trim().replace(/^"|"$/g, ""));
+  return cols.includes("id") && cols.includes("line source") && cols.includes("line destination");
+};
+var lucidIngestor = diagramIngestor("lucid", (fileName, head) => isLucidHeader(head) ? extOf(fileName) === ".csv" ? 1 : 0.9 : 0, (content) => {
+  const d = readLucidCsv(utf8(content));
+  return d.problems.find((p) => p.cell === "") ? "This file is not a Lucidchart CSV export." : void 0;
+});
+var visioIngestor = diagramIngestor("visio", (fileName, head) => extOf(fileName) === ".vsdx" ? 1 : officeFormat(head) === "vsdx" ? 0.9 : 0, (content) => {
+  try {
+    const d = readVsdx(content);
+    return d.problems.find((p) => p.cell === "") ? "No pages were found in this Visio file." : void 0;
+  } catch (err) {
+    if (err instanceof ZipError)
+      return `This file could not be read as a .vsdx: ${err.message}.`;
+    throw err;
+  }
+});
+function mermaidHeader(text) {
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  let i = 0;
+  if (lines[0]?.trim() === "---") {
+    const end = lines.findIndex((l, k) => k > 0 && l.trim() === "---");
+    i = end > 0 ? end + 1 : 0;
+  }
+  for (; i < lines.length; i++) {
+    const l = lines[i].trim();
+    if (l && !l.startsWith("%%"))
+      return l;
+  }
+  return "";
+}
+var mermaidIngestor = diagramIngestor("mermaid", (fileName, head) => {
+  const ext = extOf(fileName);
+  if (ext === ".mmd" || ext === ".mermaid")
+    return 1;
+  return /^(flowchart|graph)\b/i.test(mermaidHeader(headText(head))) ? 0.8 : 0;
+}, (content) => readMermaid(utf8(content)).problems.find((p) => p.cell === "") ? "No Mermaid flowchart was found in this file." : void 0);
+var imageIngestor = {
+  id: "image",
+  version: VERSION,
+  sniff(fileName, head) {
+    if (IMAGE_EXTENSIONS.includes(extOf(fileName)))
+      return 1;
+    return imageFormat(head) ? 0.9 : 0;
+  },
+  async *ingest(fileName, content, ctx) {
+    const r = readImage(fileName, content);
+    for (const n of r.notes)
+      ctx.warn(n, fileName);
+    yield r.record;
+  }
+};
+function documentIngestor(format, extensions, bySniff) {
+  return {
+    id: format,
+    version: VERSION,
+    sniff(fileName, head) {
+      if (extensions.includes(extOf(fileName)))
+        return 1;
+      if (documentFormat(fileName, head) === format)
+        return bySniff(head) || 0.9;
+      return bySniff(head);
+    },
+    async *ingest(fileName, content, ctx) {
+      const r = readDocument(fileName, content);
+      for (const n of r.notes)
+        ctx.warn(n, fileName);
+      yield r.record;
+    }
+  };
+}
+var none = () => 0;
+var markdownIngestor = documentIngestor("markdown", [".md", ".markdown"], none);
+var htmlIngestor = documentIngestor("html", [".html", ".htm"], (head) => /^\s*(<!doctype html|<html[\s>])/i.test(headText(head)) ? 0.8 : 0);
+var textIngestor = documentIngestor("text", [".txt", ".text"], none);
+var docxIngestor = documentIngestor("docx", [".docx"], none);
+var pptxIngestor = documentIngestor("pptx", [".pptx"], none);
+var xlsxIngestor = documentIngestor("xlsx", [".xlsx"], none);
+var pdfIngestor = documentIngestor("pdf", [".pdf"], (head) => new TextDecoder("latin1").decode(head.slice(0, 1024)).includes("%PDF-") ? 0.95 : 0);
+var figmaIngestor = {
+  id: "figma",
+  version: VERSION,
+  sniff(fileName, head) {
+    const ext = extOf(fileName);
+    if (ext === ".fig")
+      return 1;
+    const kind = looksLikeFigma(head);
+    if (kind === "binary")
+      return 0.95;
+    if (kind === "json")
+      return 0.9;
+    if (kind === "link" && [".url", ".webloc", ".figma"].includes(ext))
+      return 0.9;
+    return 0;
+  },
+  async *ingest(fileName, content, ctx) {
+    const r = readFigma(fileName, content);
+    for (const n of r.notes)
+      ctx.warn(n, fileName);
+    yield r.record;
+  }
+};
+function listIngestors() {
+  return [
+    drawioIngestor,
+    lucidIngestor,
+    visioIngestor,
+    mermaidIngestor,
+    imageIngestor,
+    markdownIngestor,
+    htmlIngestor,
+    textIngestor,
+    docxIngestor,
+    pptxIngestor,
+    xlsxIngestor,
+    pdfIngestor,
+    figmaIngestor
+  ];
+}
+function pickIngestor(fileName, head) {
+  let best;
+  let score = 0;
+  for (const i of listIngestors()) {
+    const s = i.sniff(fileName, head);
+    if (s > score) {
+      best = i;
+      score = s;
+    }
+  }
+  return best;
+}
+
+export {
+  curatedAliases,
+  resolveNames,
+  readDrawio,
+  drawioIngestor,
+  reconcile,
+  DEFAULT_LEGEND,
+  edgeParts,
+  legendWord,
+  legendOf,
+  fileBase,
+  extOf,
+  stem,
+  documentId,
+  isoDate,
+  sourceDocument,
+  utf8,
+  parseCsv,
+  readLucidCsv,
+  readMermaid,
+  readVsdx,
+  readDiagram,
+  ReadError,
+  officeFormat,
+  documentFormat,
+  readDocument,
+  NEEDS_READING_FLAG,
+  IMAGE_EXTENSIONS,
+  imageFormat,
+  readImage,
+  looksLikeFigma,
+  readFigma,
+  lucidIngestor,
+  visioIngestor,
+  mermaidIngestor,
+  imageIngestor,
+  markdownIngestor,
+  htmlIngestor,
+  textIngestor,
+  docxIngestor,
+  pptxIngestor,
+  xlsxIngestor,
+  pdfIngestor,
+  figmaIngestor,
+  listIngestors,
+  pickIngestor
+};