@avodado/core 0.0.1

package/dist/index.js

@@ -0,0 +1,1180 @@
+import { parse, LineCounter, parseDocument, isNode } from 'yaml';
+import { z } from 'zod';
+
+// src/types.ts
+var BLOCK_TYPES = [
+  "meta",
+  "callout",
+  "table",
+  "sequence",
+  "erd",
+  "userstory",
+  "timeline",
+  "kanban",
+  "tracker",
+  // Phase 2 — easy HTML-only blocks (plus pyramid/funnel which are simple SVG)
+  "prose",
+  "glossary",
+  "proscons",
+  "cvt",
+  "stats",
+  "code",
+  "agenda",
+  "tree",
+  "pyramid",
+  "funnel",
+  // Phase 3 — medium SVG blocks
+  "flow",
+  "state",
+  "dfd",
+  "journey",
+  "gantt",
+  "graph",
+  "quadrant",
+  "swimlane",
+  // Phase 4 — complex SVG blocks
+  "c4",
+  "uml",
+  "mece",
+  "frontend",
+  "cluster",
+  // Phase 5 — layout engines (block / infra) + felogic + aliases
+  "block",
+  "infra",
+  "felogic",
+  "belogic",
+  "event",
+  "ddd",
+  "network",
+  "dag",
+  // Phase 6 — UI mockups
+  "wireframe"
+];
+var BLOCK_TYPE_SET = new Set(BLOCK_TYPES);
+
+// src/diagnostics.ts
+var ERRORS_BASE = "https://avodado.dev/errors";
+function helpUrl(code) {
+  return `${ERRORS_BASE}/${code.toLowerCase()}`;
+}
+function assertNever(x) {
+  throw new Error(`Unhandled case: ${JSON.stringify(x)}`);
+}
+
+// src/suggest.ts
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = new Array(b.length + 1);
+  let curr = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++) prev[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    const ai = a.charCodeAt(i - 1);
+    for (let j = 1; j <= b.length; j++) {
+      const cost = ai === b.charCodeAt(j - 1) ? 0 : 1;
+      const del = (prev[j] ?? 0) + 1;
+      const ins = (curr[j - 1] ?? 0) + 1;
+      const sub = (prev[j - 1] ?? 0) + cost;
+      curr[j] = del < ins ? del < sub ? del : sub : ins < sub ? ins : sub;
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length] ?? 0;
+}
+function closest(input, candidates, maxDistance = 2) {
+  const needle = input.toLowerCase();
+  const scored = [];
+  for (const c of candidates) {
+    const dist = levenshtein(needle, c.toLowerCase());
+    if (dist <= maxDistance) scored.push({ value: c, dist });
+  }
+  scored.sort((x, y) => x.dist - y.dist || x.value.localeCompare(y.value));
+  return scored.slice(0, 3).map((s) => s.value);
+}
+
+// src/splitter.ts
+var OPEN_FENCE_RE = /^```([A-Za-z][\w-]*)\s*$/;
+var CLOSE_FENCE_RE = /^```\s*$/;
+function splitMarkdown(md) {
+  const normalised = md.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const lines = normalised.split("\n");
+  const segments = [];
+  let proseBuf = [];
+  let proseStart = 1;
+  let i = 0;
+  const flushProse = () => {
+    if (proseBuf.length === 0) return;
+    const text = proseBuf.join("\n");
+    if (text.trim().length > 0) {
+      segments.push({ kind: "markdown", text, line: proseStart });
+    }
+    proseBuf = [];
+  };
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const openMatch = OPEN_FENCE_RE.exec(line);
+    const tag = openMatch?.[1];
+    if (tag !== void 0 && BLOCK_TYPE_SET.has(tag)) {
+      flushProse();
+      const blockStart = i + 1;
+      const bodyLines = [];
+      i++;
+      while (i < lines.length && !CLOSE_FENCE_RE.test(lines[i] ?? "")) {
+        bodyLines.push(lines[i] ?? "");
+        i++;
+      }
+      segments.push({
+        kind: tag,
+        raw: bodyLines.join("\n"),
+        line: blockStart
+      });
+      if (i < lines.length) i++;
+      proseStart = i + 1;
+    } else {
+      if (proseBuf.length === 0) proseStart = i + 1;
+      proseBuf.push(line);
+      i++;
+    }
+  }
+  flushProse();
+  return segments;
+}
+function detectSuspectFences(md) {
+  const lines = md.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const tag = OPEN_FENCE_RE.exec(line)?.[1];
+    if (tag !== void 0 && BLOCK_TYPE_SET.has(tag)) {
+      i++;
+      while (i < lines.length && !CLOSE_FENCE_RE.test(lines[i] ?? "")) i++;
+      if (i < lines.length) i++;
+      continue;
+    }
+    if (tag !== void 0) {
+      const [suggestion] = closest(tag, BLOCK_TYPES, 2);
+      if (suggestion !== void 0) {
+        out.push({ line: i + 1, tag, suggestion });
+      }
+    }
+    i++;
+  }
+  return out;
+}
+function parseBlockBody(raw) {
+  try {
+    const data = parse(raw);
+    return { ok: true, data };
+  } catch (err) {
+    const e = err;
+    const pos = e.linePos?.[0];
+    if (pos !== void 0) {
+      return { ok: false, message: e.message, line: pos.line, column: pos.col };
+    }
+    return { ok: false, message: e.message };
+  }
+}
+function locateYamlPath(raw, path) {
+  let doc;
+  const lineCounter = new LineCounter();
+  try {
+    doc = parseDocument(raw, { lineCounter });
+  } catch {
+    return void 0;
+  }
+  if (doc.errors.length > 0 && doc.contents === null) return void 0;
+  const node = path.length === 0 ? doc.contents : doc.getIn(path, true);
+  if (!isNode(node) || node.range === null || node.range === void 0) return void 0;
+  const [start, valueEnd] = node.range;
+  const startPos = lineCounter.linePos(start);
+  const endPos = lineCounter.linePos(valueEnd);
+  const loc = {
+    line: startPos.line,
+    column: startPos.col
+  };
+  if (endPos.line === startPos.line) loc.endColumn = endPos.col;
+  return loc;
+}
+
+// src/parser.ts
+function extractId(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return void 0;
+  const id = data.id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function extractMeta(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return void 0;
+  const d = data;
+  const meta = {};
+  if (typeof d.title === "string") meta.title = d.title;
+  if (typeof d.subtitle === "string") meta.subtitle = d.subtitle;
+  if (typeof d.tag === "string") meta.tag = d.tag;
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+function parseDocument2(markdown, slug) {
+  const raws = splitMarkdown(markdown);
+  const segments = [];
+  let meta;
+  let typedBlockCount = 0;
+  for (const r of raws) {
+    if (r.kind === "markdown") {
+      segments.push({ kind: "markdown", text: r.text, line: r.line });
+      continue;
+    }
+    typedBlockCount += 1;
+    const parsed = parseBlockBody(r.raw);
+    const id = parsed.ok ? extractId(parsed.data) : void 0;
+    const seg = {
+      kind: r.kind,
+      raw: r.raw,
+      line: r.line,
+      data: parsed.ok ? parsed.data : void 0,
+      ...id !== void 0 ? { id } : {},
+      ...parsed.ok ? {} : {
+        parseError: parsed.message,
+        ...parsed.line !== void 0 ? { parseErrorLine: parsed.line } : {},
+        ...parsed.column !== void 0 ? { parseErrorColumn: parsed.column } : {}
+      }
+    };
+    segments.push(seg);
+    if (r.kind === "meta" && meta === void 0 && typedBlockCount === 1 && parsed.ok) {
+      meta = extractMeta(parsed.data);
+    }
+  }
+  const suspectFences = detectSuspectFences(markdown);
+  return {
+    slug,
+    segments,
+    ...meta !== void 0 ? { meta } : {},
+    ...suspectFences.length > 0 ? { suspectFences } : {}
+  };
+}
+var metaSchema = z.object({
+  title: z.string().optional(),
+  subtitle: z.string().optional(),
+  tag: z.string().optional()
+}).strict();
+var calloutSchema = z.object({
+  tone: z.enum(["note", "tip", "warn", "danger"]).optional(),
+  title: z.string().optional(),
+  body: z.string().optional()
+}).strict();
+var tableColumnSchema = z.union([
+  z.string(),
+  z.object({
+    label: z.string(),
+    align: z.enum(["l", "c", "r"]).optional(),
+    highlight: z.boolean().optional()
+  }).strict()
+]);
+var tableCellSchema = z.union([
+  z.string(),
+  z.number(),
+  z.object({
+    v: z.union([z.string(), z.number()]),
+    tone: z.enum(["pos", "neg", "warn", "muted"]).optional(),
+    lead: z.boolean().optional(),
+    highlight: z.boolean().optional()
+  }).strict()
+]);
+var tableSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  columns: z.array(tableColumnSchema).optional(),
+  rows: z.array(z.array(tableCellSchema)).optional(),
+  note: z.string().optional()
+}).strict();
+var sequenceActorSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  sub: z.string().optional(),
+  external: z.boolean().optional()
+}).strict();
+var sequenceMessageSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum(["sync", "response", "async", "error", "note"]).optional(),
+  summary: z.string().optional(),
+  code: z.string().optional(),
+  note: z.string().optional()
+}).strict();
+var sequenceEndpointSchema = z.object({
+  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  path: z.string(),
+  status: z.string().optional()
+}).strict();
+var sequenceFootSchema = z.object({
+  label: z.string(),
+  value: z.string()
+}).strict();
+var sequenceSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  endpoint: sequenceEndpointSchema.optional(),
+  actors: z.array(sequenceActorSchema).optional(),
+  messages: z.array(sequenceMessageSchema).optional(),
+  foot: z.array(sequenceFootSchema).optional()
+}).strict();
+var erdColumnSchema = z.object({
+  name: z.string(),
+  type: z.string().optional(),
+  pk: z.boolean().optional(),
+  fk: z.boolean().optional()
+}).strict();
+var erdEntitySchema = z.object({
+  name: z.string(),
+  columns: z.array(erdColumnSchema).optional()
+}).strict();
+var erdRelationSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  card: z.enum(["1:1", "1:N", "N:M"]).optional()
+}).strict();
+var erdSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  entities: z.array(erdEntitySchema).optional(),
+  relations: z.array(erdRelationSchema).optional()
+}).strict();
+var criterionSchema = z.object({
+  given: z.string().optional(),
+  when: z.string().optional(),
+  then: z.string().optional()
+}).strict();
+var linkSchema = z.object({
+  ref: z.string().optional(),
+  mode: z.string().optional(),
+  label: z.string().optional()
+}).strict();
+var userstorySchema = z.object({
+  role: z.string().optional(),
+  want: z.string().optional(),
+  soThat: z.string().optional(),
+  priority: z.string().optional(),
+  points: z.number().optional(),
+  criteria: z.array(criterionSchema).optional(),
+  links: z.array(linkSchema).optional()
+}).strict();
+var timelineItemSchema = z.object({
+  label: z.string(),
+  date: z.string().optional(),
+  desc: z.string().optional(),
+  status: z.enum(["done", "current", "next", "future"]).optional()
+}).strict();
+var timelineSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  items: z.array(timelineItemSchema).optional()
+}).strict();
+var kanbanCardSchema = z.object({
+  title: z.string(),
+  tag: z.string().optional()
+}).strict();
+var kanbanColumnSchema = z.object({
+  label: z.string(),
+  cards: z.array(kanbanCardSchema).optional()
+}).strict();
+var kanbanSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  columns: z.array(kanbanColumnSchema).optional()
+}).strict();
+var trackerItemSchema = z.object({
+  task: z.string(),
+  status: z.enum(["todo", "doing", "done", "blocked"]).optional(),
+  priority: z.enum(["high", "med", "low"]).optional(),
+  owner: z.string().optional(),
+  due: z.string().optional()
+}).strict();
+var trackerSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  items: z.array(trackerItemSchema).optional()
+}).strict();
+var proseBlockSchema = z.object({
+  type: z.enum(["h", "p", "ul", "ol", "quote"]).optional(),
+  text: z.string().optional(),
+  items: z.array(z.string()).optional()
+}).strict();
+var proseSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  blocks: z.array(proseBlockSchema).optional()
+}).strict();
+var glossaryTermSchema = z.object({ term: z.string(), def: z.string() }).strict();
+var glossarySchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  terms: z.array(glossaryTermSchema).optional()
+}).strict();
+var prosconsSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  prosLabel: z.string().optional(),
+  consLabel: z.string().optional(),
+  pros: z.array(z.string()).optional(),
+  cons: z.array(z.string()).optional()
+}).strict();
+var cvtPanelSchema = z.object({
+  label: z.string().optional(),
+  items: z.array(z.string()).optional()
+}).strict();
+var cvtSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  current: cvtPanelSchema.optional(),
+  target: cvtPanelSchema.optional(),
+  note: z.string().optional()
+}).strict();
+var statSchema = z.object({
+  value: z.union([z.string(), z.number()]),
+  label: z.string(),
+  delta: z.string().optional(),
+  trend: z.enum(["up", "down", "flat"]).optional(),
+  accent: z.string().optional()
+}).strict();
+var statsSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  stats: z.array(statSchema).optional()
+}).strict();
+var codeEntrySchema = z.object({
+  title: z.string().optional(),
+  lang: z.string().optional(),
+  code: z.string()
+}).strict();
+var codeSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  blocks: z.array(codeEntrySchema).optional()
+}).strict();
+var agendaItemSchema = z.object({
+  time: z.string().optional(),
+  duration: z.string().optional(),
+  title: z.string(),
+  owner: z.string().optional(),
+  desc: z.string().optional()
+}).strict();
+var agendaSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  items: z.array(agendaItemSchema).optional()
+}).strict();
+var treeNodeSchema = z.object({
+  id: z.string(),
+  parent: z.string().optional(),
+  label: z.string(),
+  note: z.string().optional()
+}).strict();
+var treeSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  nodes: z.array(treeNodeSchema).optional()
+}).strict();
+var pyramidLevelSchema = z.object({ label: z.string(), desc: z.string().optional() }).strict();
+var pyramidSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  levels: z.array(pyramidLevelSchema).optional()
+}).strict();
+var funnelStageSchema = z.object({ label: z.string(), value: z.union([z.string(), z.number()]) }).strict();
+var funnelSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  stages: z.array(funnelStageSchema).optional()
+}).strict();
+var flowNodeSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  w: z.number().optional(),
+  label: z.string(),
+  kind: z.enum(["start", "end", "decision", "process"]).optional()
+}).strict();
+var flowEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum(["error"]).optional()
+}).strict();
+var flowSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  nodes: z.array(flowNodeSchema).optional(),
+  edges: z.array(flowEdgeSchema).optional()
+}).strict();
+var stateNodeSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  name: z.string().optional(),
+  kind: z.enum(["start", "terminal", "active", "wait"]).optional()
+}).strict();
+var stateTransitionSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  event: z.string(),
+  guard: z.string().optional()
+}).strict();
+var stateSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  states: z.array(stateNodeSchema).optional(),
+  transitions: z.array(stateTransitionSchema).optional()
+}).strict();
+var dfdNodeSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  name: z.string(),
+  kind: z.enum(["process", "external", "store", "datastore"]).optional(),
+  num: z.union([z.string(), z.number()]).optional()
+}).strict();
+var dfdEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional()
+}).strict();
+var dfdSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  nodes: z.array(dfdNodeSchema).optional(),
+  edges: z.array(dfdEdgeSchema).optional()
+}).strict();
+var journeyStageSchema = z.object({ label: z.string() }).strict();
+var journeyRowSchema = z.object({
+  label: z.string(),
+  cells: z.array(z.string()).optional()
+}).strict();
+var journeySchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  stages: z.array(journeyStageSchema).optional(),
+  rows: z.array(journeyRowSchema).optional(),
+  emotion: z.array(z.number()).optional()
+}).strict();
+var ganttTaskSchema = z.object({
+  label: z.string(),
+  start: z.number().optional(),
+  span: z.number().optional(),
+  kind: z.enum(["done", "active", "current", "milestone"]).optional()
+}).strict();
+var ganttSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  periods: z.array(z.string()).optional(),
+  tasks: z.array(ganttTaskSchema).optional()
+}).strict();
+var graphNodeSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  label: z.string(),
+  group: z.number().optional()
+}).strict();
+var graphEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  dir: z.enum(["directed", "undirected"]).optional()
+}).strict();
+var graphSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  nodes: z.array(graphNodeSchema).optional(),
+  edges: z.array(graphEdgeSchema).optional()
+}).strict();
+var quadrantAxisSchema = z.object({
+  label: z.string().optional(),
+  low: z.string().optional(),
+  high: z.string().optional()
+}).strict();
+var quadrantItemSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  label: z.string()
+}).strict();
+var quadrantSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  xAxis: quadrantAxisSchema.optional(),
+  yAxis: quadrantAxisSchema.optional(),
+  items: z.array(quadrantItemSchema).optional()
+}).strict();
+var swimlaneLaneSchema = z.object({ label: z.string() }).strict();
+var swimlaneStepSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  lane: z.number(),
+  label: z.string(),
+  kind: z.enum(["action", "decision", "start", "end", "wait"]).optional()
+}).strict();
+var swimlaneLinkSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional()
+}).strict();
+var swimlaneSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  lanes: z.array(swimlaneLaneSchema).optional(),
+  steps: z.array(swimlaneStepSchema).optional(),
+  links: z.array(swimlaneLinkSchema).optional()
+}).strict();
+var c4NodeSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  w: z.number().optional(),
+  kind: z.enum(["person", "system", "external", "store", "container", "component"]),
+  family: z.string().optional(),
+  name: z.string(),
+  tech: z.string().optional(),
+  desc: z.string().optional()
+}).strict();
+var c4EdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum(["solid", "dashed", "forbidden", "error"]).optional()
+}).strict();
+var c4BoundarySchema = z.object({ label: z.string() }).strict();
+var c4Schema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  level: z.enum(["context", "container", "component"]).optional(),
+  boundary: c4BoundarySchema.optional(),
+  nodes: z.array(c4NodeSchema).optional(),
+  edges: z.array(c4EdgeSchema).optional()
+}).strict();
+var umlClassSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  name: z.string(),
+  stereotype: z.string().optional(),
+  attrs: z.array(z.string()).optional(),
+  methods: z.array(z.string()).optional()
+}).strict();
+var umlRelSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum([
+    "inheritance",
+    "extends",
+    "implementation",
+    "implements",
+    "composition",
+    "aggregation",
+    "dependency",
+    "association"
+  ]).optional()
+}).strict();
+var umlSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  classes: z.array(umlClassSchema).optional(),
+  rels: z.array(umlRelSchema).optional()
+}).strict();
+var meceNodeSchema = z.object({
+  id: z.string(),
+  parent: z.string().optional(),
+  label: z.string(),
+  note: z.string().optional()
+}).strict();
+var meceSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  nodes: z.array(meceNodeSchema).optional()
+}).strict();
+var ftNodeSchema = z.object({
+  id: z.string(),
+  parent: z.string().optional(),
+  name: z.string(),
+  kind: z.enum([
+    "root",
+    "layout",
+    "page",
+    "component",
+    "leaf",
+    "provider",
+    "context",
+    "hook",
+    "store",
+    "state"
+  ]).optional(),
+  note: z.string().optional()
+}).strict();
+var frontendSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  nodes: z.array(ftNodeSchema).optional()
+}).strict();
+var clusterClusterSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  kind: z.string().optional()
+}).strict();
+var clusterServiceSchema = z.object({
+  id: z.string(),
+  cluster: z.string(),
+  label: z.string(),
+  kind: z.string().optional(),
+  tech: z.string().optional(),
+  replicas: z.number().optional()
+}).strict();
+var clusterEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum(["solid", "dashed", "forbidden", "error"]).optional()
+}).strict();
+var clusterSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  clusters: z.array(clusterClusterSchema).optional(),
+  services: z.array(clusterServiceSchema).optional(),
+  edges: z.array(clusterEdgeSchema).optional()
+}).strict();
+var blockGraphGroupSchema = z.object({
+  id: z.string().optional(),
+  col: z.number(),
+  row: z.number(),
+  cols: z.number().optional(),
+  rows: z.number().optional(),
+  label: z.string(),
+  color: z.string().optional()
+}).strict();
+var blockGraphLayerSchema = z.object({ label: z.string() }).strict();
+var blockGraphNodeSchema = z.object({
+  id: z.string(),
+  col: z.number().optional(),
+  row: z.number().optional(),
+  layer: z.number().optional(),
+  w: z.number().optional(),
+  kind: z.string().optional(),
+  name: z.string(),
+  tech: z.string().optional()
+}).strict();
+var blockGraphEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum(["solid", "dashed", "forbidden", "error"]).optional()
+}).strict();
+var blockGraphSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  systemLabel: z.string().optional(),
+  layers: z.array(blockGraphLayerSchema).optional(),
+  groups: z.array(blockGraphGroupSchema).optional(),
+  nodes: z.array(blockGraphNodeSchema).optional(),
+  edges: z.array(blockGraphEdgeSchema).optional()
+}).strict();
+var feLogicNodeSchema = z.object({
+  id: z.string(),
+  col: z.number(),
+  row: z.number(),
+  w: z.number().optional(),
+  kind: z.string().optional(),
+  name: z.string(),
+  note: z.string().optional()
+}).strict();
+var feLogicEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  kind: z.enum(["uses", "implements", "reads", "egress", "https", "api", "dashed", "async"]).optional()
+}).strict();
+var felogicSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  groups: z.array(blockGraphGroupSchema).optional(),
+  nodes: z.array(feLogicNodeSchema).optional(),
+  edges: z.array(feLogicEdgeSchema).optional()
+}).strict();
+var dagSchema = flowSchema;
+var wireframeElementSchema = z.object({
+  type: z.enum([
+    "header",
+    "subheader",
+    "text",
+    "button",
+    "input",
+    "search",
+    "image",
+    "avatar",
+    "card",
+    "list",
+    "nav",
+    "tabs",
+    "divider",
+    "badge",
+    "toggle",
+    "spacer"
+  ]).optional(),
+  label: z.string().optional(),
+  rows: z.number().optional(),
+  align: z.enum(["l", "c", "r"]).optional(),
+  tone: z.enum(["accent", "muted", "danger"]).optional()
+}).strict();
+var wireframeScreenSchema = z.object({
+  device: z.enum(["desktop", "browser", "phone"]).optional(),
+  title: z.string().optional(),
+  url: z.string().optional(),
+  label: z.string().optional(),
+  elements: z.array(wireframeElementSchema).optional()
+}).strict();
+var wireframeSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  lede: z.string().optional(),
+  screens: z.array(wireframeScreenSchema).optional()
+}).strict();
+var blockSchemas = {
+  meta: metaSchema,
+  callout: calloutSchema,
+  table: tableSchema,
+  sequence: sequenceSchema,
+  erd: erdSchema,
+  userstory: userstorySchema,
+  timeline: timelineSchema,
+  kanban: kanbanSchema,
+  tracker: trackerSchema,
+  prose: proseSchema,
+  glossary: glossarySchema,
+  proscons: prosconsSchema,
+  cvt: cvtSchema,
+  stats: statsSchema,
+  code: codeSchema,
+  agenda: agendaSchema,
+  tree: treeSchema,
+  pyramid: pyramidSchema,
+  funnel: funnelSchema,
+  flow: flowSchema,
+  state: stateSchema,
+  dfd: dfdSchema,
+  journey: journeySchema,
+  gantt: ganttSchema,
+  graph: graphSchema,
+  quadrant: quadrantSchema,
+  swimlane: swimlaneSchema,
+  c4: c4Schema,
+  uml: umlSchema,
+  mece: meceSchema,
+  frontend: frontendSchema,
+  cluster: clusterSchema,
+  block: blockGraphSchema,
+  infra: blockGraphSchema,
+  event: blockGraphSchema,
+  ddd: blockGraphSchema,
+  network: blockGraphSchema,
+  felogic: felogicSchema,
+  belogic: felogicSchema,
+  dag: dagSchema,
+  wireframe: wireframeSchema
+};
+
+// src/blocks/registry.ts
+var blockRegistry = {
+  meta: { type: "meta", schema: blockSchemas.meta },
+  callout: { type: "callout", schema: blockSchemas.callout },
+  table: { type: "table", schema: blockSchemas.table },
+  sequence: { type: "sequence", schema: blockSchemas.sequence },
+  erd: { type: "erd", schema: blockSchemas.erd },
+  userstory: {
+    type: "userstory",
+    schema: blockSchemas.userstory,
+    extractRefs: (data) => {
+      const links = data.links;
+      if (!Array.isArray(links)) return [];
+      const refs = [];
+      for (const link of links) {
+        if (typeof link.ref === "string" && link.ref.length > 0) refs.push(link.ref);
+      }
+      return refs;
+    }
+  },
+  timeline: { type: "timeline", schema: blockSchemas.timeline },
+  kanban: { type: "kanban", schema: blockSchemas.kanban },
+  tracker: { type: "tracker", schema: blockSchemas.tracker },
+  prose: { type: "prose", schema: blockSchemas.prose },
+  glossary: { type: "glossary", schema: blockSchemas.glossary },
+  proscons: { type: "proscons", schema: blockSchemas.proscons },
+  cvt: { type: "cvt", schema: blockSchemas.cvt },
+  stats: { type: "stats", schema: blockSchemas.stats },
+  code: { type: "code", schema: blockSchemas.code },
+  agenda: { type: "agenda", schema: blockSchemas.agenda },
+  tree: { type: "tree", schema: blockSchemas.tree },
+  pyramid: { type: "pyramid", schema: blockSchemas.pyramid },
+  funnel: { type: "funnel", schema: blockSchemas.funnel },
+  flow: { type: "flow", schema: blockSchemas.flow },
+  state: { type: "state", schema: blockSchemas.state },
+  dfd: { type: "dfd", schema: blockSchemas.dfd },
+  journey: { type: "journey", schema: blockSchemas.journey },
+  gantt: { type: "gantt", schema: blockSchemas.gantt },
+  graph: { type: "graph", schema: blockSchemas.graph },
+  quadrant: { type: "quadrant", schema: blockSchemas.quadrant },
+  swimlane: { type: "swimlane", schema: blockSchemas.swimlane },
+  c4: { type: "c4", schema: blockSchemas.c4 },
+  uml: { type: "uml", schema: blockSchemas.uml },
+  mece: { type: "mece", schema: blockSchemas.mece },
+  frontend: { type: "frontend", schema: blockSchemas.frontend },
+  cluster: { type: "cluster", schema: blockSchemas.cluster },
+  block: { type: "block", schema: blockSchemas.block },
+  infra: { type: "infra", schema: blockSchemas.infra },
+  event: { type: "event", schema: blockSchemas.event },
+  ddd: { type: "ddd", schema: blockSchemas.ddd },
+  network: { type: "network", schema: blockSchemas.network },
+  felogic: { type: "felogic", schema: blockSchemas.felogic },
+  belogic: { type: "belogic", schema: blockSchemas.belogic },
+  dag: { type: "dag", schema: blockSchemas.dag },
+  wireframe: { type: "wireframe", schema: blockSchemas.wireframe }
+};
+
+// src/validate.ts
+function unwrap(schema) {
+  let cur = schema;
+  for (; ; ) {
+    if (cur instanceof z.ZodOptional || cur instanceof z.ZodNullable) cur = cur.unwrap();
+    else if (cur instanceof z.ZodDefault) cur = cur._def.innerType;
+    else return cur;
+  }
+}
+function schemaAt(kind, path) {
+  let cur = blockSchemas[kind];
+  for (const seg of path) {
+    cur = unwrap(cur);
+    if (typeof seg === "number") {
+      if (!(cur instanceof z.ZodArray)) return void 0;
+      cur = cur.element;
+    } else {
+      if (!(cur instanceof z.ZodObject)) return void 0;
+      const next = cur.shape[seg];
+      if (next === void 0) return void 0;
+      cur = next;
+    }
+  }
+  return unwrap(cur);
+}
+function fieldNamesAt(kind, path) {
+  const schema = schemaAt(kind, path) ?? blockSchemas[kind];
+  return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
+}
+function renderIssue(kind, issue) {
+  const path = issue.path.join(".");
+  const at = path.length > 0 ? `${path}: ` : "";
+  if (issue.code === "unrecognized_keys") {
+    const bad = issue.keys[0] ?? "";
+    const valid = fieldNamesAt(kind, issue.path);
+    const suggestions = closest(bad, valid, 3);
+    const did = suggestions.length > 0 ? `Did you mean \`${suggestions[0]}\`? ` : "";
+    return {
+      message: `${kind}: unknown field${issue.keys.length > 1 ? "s" : ""} ${issue.keys.map((k) => `'${k}'`).join(", ")}`,
+      hint: `${did}Valid fields: ${valid.join(", ")}.`,
+      ...suggestions.length > 0 ? { suggestions } : {}
+    };
+  }
+  if (issue.code === "invalid_enum_value") {
+    const options = issue.options.map(String);
+    const received = String(issue.received);
+    const suggestions = closest(received, options, 3);
+    const did = suggestions.length > 0 ? ` Did you mean \`${suggestions[0]}\`?` : "";
+    return {
+      message: `${kind}: ${at}invalid value "${received}"`,
+      hint: `Use one of: ${options.join(" | ")}.${did}`,
+      ...suggestions.length > 0 ? { suggestions } : {}
+    };
+  }
+  if (issue.code === "invalid_type") {
+    if (issue.expected === "string" && issue.received === "number") {
+      return {
+        message: `${kind}: ${at}expected a string but got a number`,
+        hint: 'Quote the value to keep it a string (e.g. tech: "16").'
+      };
+    }
+    return {
+      message: `${kind}: ${at}expected ${issue.expected}, got ${issue.received}`
+    };
+  }
+  return { message: `${kind}: ${at}${issue.message}` };
+}
+function validateDocument(doc, file) {
+  const diagnostics = [];
+  for (const sf of doc.suspectFences ?? []) {
+    diagnostics.push({
+      file,
+      line: sf.line,
+      column: 1,
+      level: "warn",
+      code: "W_SUSPECT_BLOCK",
+      message: `Unknown block type "${sf.tag}" \u2014 rendered as plain text`,
+      hint: `Did you mean \`\`\`${sf.suggestion}? Use one of the documented block types.`,
+      value: sf.tag,
+      suggestions: [sf.suggestion]
+    });
+  }
+  for (const seg of doc.segments) {
+    if (seg.kind === "markdown") continue;
+    if (seg.parseError !== void 0) {
+      const line = seg.parseErrorLine !== void 0 ? seg.line + seg.parseErrorLine : seg.line;
+      diagnostics.push({
+        file,
+        line,
+        ...seg.parseErrorColumn !== void 0 ? { column: seg.parseErrorColumn } : {},
+        level: "error",
+        code: "E_PARSE_YAML",
+        message: `${seg.kind}: ${seg.parseError}`,
+        hint: "Often an unquoted special character (, : # | & *). Wrap the value in quotes."
+      });
+      continue;
+    }
+    if (seg.data === null || seg.data === void 0) {
+      diagnostics.push({
+        file,
+        line: seg.line,
+        level: "warn",
+        code: "W_EMPTY_BLOCK",
+        message: `${seg.kind}: empty body`,
+        hint: "Add the fields this block needs, or remove the block."
+      });
+      continue;
+    }
+    const def = blockRegistry[seg.kind];
+    const dataForSchema = typeof seg.data === "object" && !Array.isArray(seg.data) && "id" in seg.data ? Object.fromEntries(
+      Object.entries(seg.data).filter(([k]) => k !== "id")
+    ) : seg.data;
+    const result = def.schema.safeParse(dataForSchema);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        const rendered = renderIssue(seg.kind, issue);
+        const loc = locateYamlPath(seg.raw, issue.path) ?? (issue.path.length > 0 ? locateYamlPath(seg.raw, issue.path.slice(0, -1)) : void 0);
+        const position = loc !== void 0 ? {
+          line: seg.line + loc.line,
+          column: loc.column,
+          ...loc.endColumn !== void 0 ? { endColumn: loc.endColumn } : {}
+        } : { line: seg.line };
+        diagnostics.push({
+          file,
+          ...position,
+          level: "error",
+          code: "E_SCHEMA",
+          message: rendered.message,
+          ...rendered.hint !== void 0 ? { hint: rendered.hint } : {},
+          ...rendered.suggestions !== void 0 ? { suggestions: rendered.suggestions } : {}
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+
+// src/resolve.ts
+var REF_RE = /^(?:([\w/.-]+))?#([\w.-]+)$/;
+function callExtractRefs(kind, data) {
+  const def = blockRegistry[kind];
+  return def.extractRefs ? def.extractRefs(data) : [];
+}
+function resolveRefs(inputs) {
+  const diagnostics = [];
+  const nodes = /* @__PURE__ */ new Map();
+  for (const { doc, file } of inputs) {
+    for (const seg of doc.segments) {
+      if (seg.kind === "markdown" || seg.id === void 0) continue;
+      const existing = nodes.get(seg.id);
+      if (existing) {
+        diagnostics.push({
+          file,
+          line: seg.line,
+          level: "error",
+          code: "E_DUP_ID",
+          message: `Duplicate id "${seg.id}" (first defined in ${existing.file}:${existing.line})`,
+          value: seg.id
+        });
+        continue;
+      }
+      nodes.set(seg.id, { doc: doc.slug, block: seg, file, line: seg.line });
+    }
+  }
+  const edges = [];
+  for (const { doc, file } of inputs) {
+    for (const seg of doc.segments) {
+      if (seg.kind === "markdown" || seg.parseError !== void 0 || seg.data === void 0) continue;
+      const typedSeg = seg;
+      const refs = callExtractRefs(typedSeg.kind, typedSeg.data);
+      for (const ref of refs) {
+        const match = REF_RE.exec(ref);
+        if (!match) {
+          diagnostics.push({
+            file,
+            line: seg.line,
+            level: "error",
+            code: "E_BAD_REF_FORMAT",
+            message: `Invalid reference format: "${ref}" (expected doc#id or #id)`,
+            value: ref
+          });
+          continue;
+        }
+        const targetDoc = match[1] ?? doc.slug;
+        const targetId = match[2];
+        if (targetId === void 0) continue;
+        const node = nodes.get(targetId);
+        if (!node || node.doc !== targetDoc) {
+          diagnostics.push({
+            file,
+            line: seg.line,
+            level: "error",
+            code: "E_DANGLING_REF",
+            message: `Dangling reference: "${ref}" (target not found)`,
+            value: ref
+          });
+          continue;
+        }
+        const from = seg.id !== void 0 ? `${doc.slug}#${seg.id}` : `${doc.slug}@${seg.line}`;
+        edges.push({ from, to: `${targetDoc}#${targetId}` });
+      }
+    }
+  }
+  const publicNodes = /* @__PURE__ */ new Map();
+  for (const [id, { doc, block }] of nodes) publicNodes.set(id, { doc, block });
+  return { graph: { nodes: publicNodes, edges }, diagnostics };
+}
+
+// src/index.ts
+var version = "0.0.0";
+
+export { BLOCK_TYPES, BLOCK_TYPE_SET, agendaSchema, assertNever, blockGraphSchema, blockRegistry, blockSchemas, c4Schema, calloutSchema, closest, clusterSchema, codeSchema, cvtSchema, dagSchema, dfdSchema, erdSchema, felogicSchema, flowSchema, frontendSchema, funnelSchema, ganttSchema, glossarySchema, graphSchema, helpUrl, journeySchema, kanbanSchema, levenshtein, locateYamlPath, meceSchema, metaSchema, parseBlockBody, parseDocument2 as parseDocument, prosconsSchema, proseSchema, pyramidSchema, quadrantSchema, resolveRefs, sequenceSchema, splitMarkdown, stateSchema, statsSchema, swimlaneSchema, tableSchema, timelineSchema, trackerSchema, treeSchema, umlSchema, userstorySchema, validateDocument, version };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map