schematex 0.9.3 → 0.9.4

package/dist/{chunk-BP6MLXJU.js → chunk-UFXDAIDD.js}

@@ -1,21 +1,21 @@
-import { orgchart } from './chunk-ZUK4BY55.js';
-import { circuit } from './chunk-QHZEGWE7.js';
-import { blockdiagram } from './chunk-JEQGWH5N.js';
-import { ladder } from './chunk-X3GEGVW2.js';
-import { sld } from './chunk-7P4C5DMD.js';
-import { entity } from './chunk-XAYD5NVJ.js';
-import { fishbone } from './chunk-6GHXO3WQ.js';
-import { venn } from './chunk-UNLLWCQK.js';
-import { flowchart, layoutFlowchart } from './chunk-PUD7PIY5.js';
-import { genogram } from './chunk-PZCYFT2A.js';
-import { ecomap, estimateTextWidth } from './chunk-OND4N5ZZ.js';
-import { pedigree } from './chunk-4CLAD7VZ.js';
+import { orgchart } from './chunk-3J4DZPZC.js';
+import { circuit } from './chunk-RDYACU2G.js';
+import { blockdiagram } from './chunk-3PH2MQGN.js';
+import { ladder } from './chunk-B4CMWA6Y.js';
+import { sld } from './chunk-PFZKW3HE.js';
+import { entity } from './chunk-JEMAOC2D.js';
+import { fishbone } from './chunk-GYYYULBL.js';
+import { venn } from './chunk-SXOAAQNY.js';
+import { flowchart, layoutFlowchart } from './chunk-AXMBXAEA.js';
+import { genogram } from './chunk-M26ORU4P.js';
+import { ecomap, estimateTextWidth } from './chunk-XCCXG6RR.js';
+import { pedigree } from './chunk-ZCHGIWJK.js';
 import { parseFrontmatter } from './chunk-2KTQ75LN.js';
-import { phylo } from './chunk-ZQECHIBI.js';
-import { sociogram } from './chunk-TDSGQT7R.js';
+import { phylo } from './chunk-3WX24RCH.js';
+import { sociogram } from './chunk-64LABNTF.js';
 import { timing } from './chunk-MTIZIHWE.js';
-import { logic } from './chunk-U4AJLMHC.js';
-import { resolveBaseTheme, resolveTimelineTheme, resolveStateTheme, cssCustomProperties, resolvePetriTheme, resolveNetworkTheme, resolveUmlClassTheme, DEFAULT_FONT_FAMILY, FONT_SIZE, resolveReliabilityTheme, STROKE_WIDTH, resolveBowtieTheme, resolveMindmapTheme, resolveMatrixTheme, resolveBpmnTheme, resolveFloorplanTheme, TITLE } from './chunk-D4QZ6UDO.js';
+import { logic } from './chunk-NKYR4PAS.js';
+import { resolveBaseTheme, resolveTimelineTheme, resolveStateTheme, cssCustomProperties, resolvePetriTheme, resolveNetworkTheme, resolveUmlClassTheme, DEFAULT_FONT_FAMILY, FONT_SIZE, resolveReliabilityTheme, STROKE_WIDTH, resolveBowtieTheme, resolveMindmapTheme, resolveMatrixTheme, resolveBpmnTheme, resolveFloorplanTheme, TITLE, resolvePlaybookTheme } from './chunk-4MRVJI7G.js';
 import { QUOTE_PAIRS, stripQuotes, isOpenQuote, extractQuotedString, matchQuotedTitle } from './chunk-TO6PNBT3.js';
 import { el, escapeXml, group, rect, text, line, path, circle, polygon, title, desc, svgRoot, defs, multilineText } from './chunk-SYYBKDL7.js';
 
@@ -1876,7 +1876,7 @@ function parseTimeline(src) {
   let i = 0;
   let autoId = 0;
   const nextId2 = (prefix) => `${prefix}-${++autoId}`;
-  const ordinal = { index: 0 };
+  const ordinal2 = { index: 0 };
   const first = lines[0];
   if (/^timeline\b/i.test(first.text)) {
     const rest = first.text.replace(/^timeline\b/i, "").trim();
@@ -1947,7 +1947,7 @@ function parseTimeline(src) {
           i++;
           continue;
         }
-        const parsed2 = parseEventLine(child.text, child.line, nextId2, ordinal);
+        const parsed2 = parseEventLine(child.text, child.line, nextId2, ordinal2);
         if (!parsed2) throw new TimelineParseError(`Unrecognized line in ${keyword}: ${child.text}`, child.line);
         parsed2.event.trackId = trackId;
         ast.events.push(parsed2.event);
@@ -1961,7 +1961,7 @@ function parseTimeline(src) {
       }
       continue;
     }
-    const parsed = parseEventLine(text2, L.line, nextId2, ordinal);
+    const parsed = parseEventLine(text2, L.line, nextId2, ordinal2);
     if (parsed) {
       ast.events.push(parsed.event);
       i++;
@@ -1985,12 +1985,12 @@ function safeParseDate(raw, line2) {
     throw new TimelineParseError(msg, line2);
   }
 }
-function parseRowKey(raw, ordinal) {
+function parseRowKey(raw, ordinal2) {
   const parsed = tryParseDate(raw);
   if (parsed) return parsed;
-  ordinal.index += 1;
+  ordinal2.index += 1;
   return {
-    value: ordinal.index,
+    value: ordinal2.index,
     raw,
     precision: "ordinal"
   };
@@ -2027,7 +2027,7 @@ function applyConfig(ast, k, v, line2) {
       (ast.metadata ??= {})[k] = v;
   }
 }
-function parseEventLine(text2, line2, nextId2, ordinal) {
+function parseEventLine(text2, line2, nextId2, ordinal2) {
   const { props, rest } = parseProperties(text2, line2);
   const { date, end, body } = splitDateAndBody(rest, line2);
   let kind = end ? "range" : "point";
@@ -2044,8 +2044,8 @@ function parseEventLine(text2, line2, nextId2, ordinal) {
     id: nextId2("ev"),
     label,
     kind,
-    start: parseRowKey(date, ordinal),
-    end: end ? parseRowKey(end, ordinal) : void 0,
+    start: parseRowKey(date, ordinal2),
+    end: end ? parseRowKey(end, ordinal2) : void 0,
     icon: props["icon"],
     shape: props["shape"],
     color: props["color"],
@@ -38071,7 +38071,7 @@ function renderErrorPanel(lay, t) {
   const w = Math.max(560, ...lines.map((l) => l.length * 6.6 + 48));
   const h = 56 + lines.length * 19;
   return svgRoot(
-    { viewBox: `0 0 ${r24(w)} ${h}`, class: "sx-fp", role: "img" },
+    { viewBox: `0 0 ${r24(w)} ${h}`, width: r24(w), height: h, class: "sx-fp", role: "img" },
     [
       title(lay.title),
       desc(`Floor plan validation failed with ${lines.length} error${lines.length === 1 ? "" : "s"}.`),
@@ -38407,7 +38407,7 @@ function renderFloorplanLayout(lay, config) {
   const nRooms = lay.rooms.length;
   const descText = `${nRooms} room${nRooms === 1 ? "" : "s"}, ${formatArea(lay.totalAreaM2, lay.unit)} total. ${lay.items.length} furniture item${lay.items.length === 1 ? "" : "s"}.` + (lay.warnings.length ? ` Warnings: ${lay.warnings.join("; ")}.` : "");
   return svgRoot(
-    { viewBox: `0 0 ${W2} ${H2}`, class: "sx-fp", role: "img" },
+    { viewBox: `0 0 ${W2} ${H2}`, width: W2, height: H2, class: "sx-fp", role: "img" },
     [
       title(lay.title),
       desc(descText),
@@ -38473,6 +38473,1526 @@ var floorplan = {
   }
 };
 
+// src/diagrams/playbook/parser.ts
+var PlaybookParseError = class extends Error {
+  line;
+  constructor(message, line2) {
+    super(`line ${line2}: ${message}`);
+    this.name = "PlaybookParseError";
+    this.line = line2;
+  }
+};
+var isStr2 = (t) => t !== void 0 && "str" in t;
+var isWord2 = (t, w) => t !== void 0 && "word" in t && (w === void 0 || t.word.toLowerCase() === w);
+var tokDisplay = (t) => "word" in t ? t.word : `"${t.str}"`;
+var normalizeQuotes4 = (s) => s.replace(/[“”「」『』]/g, '"').replace(/[‘’]/g, "'");
+function tokenize8(line2) {
+  const out = [];
+  const re = /"([^"]*)"|(\S+)/g;
+  let m;
+  while (m = re.exec(line2)) {
+    if (m[1] !== void 0) out.push({ str: m[1] });
+    else out.push({ word: m[2] });
+  }
+  return out;
+}
+function parseNum2(t, what, ln) {
+  if (!isWord2(t)) throw new PlaybookParseError(`expected a number for ${what}`, ln);
+  const v = Number(t.word);
+  if (!Number.isFinite(v)) throw new PlaybookParseError(`expected a number for ${what}, got "${t.word}"`, ln);
+  return v;
+}
+function parseId2(t, what, ln) {
+  if (!isWord2(t)) throw new PlaybookParseError(`expected ${what}`, ln);
+  return t.word;
+}
+var COORD = /^([+-]?\d*\.?\d+),([+-]?\d*\.?\d+)$/;
+var POSITIONS = ["o", "c", "ol", "qb", "rb", "wr", "te", "x", "dl", "lb", "db", "s", "gk"];
+var NAMED_ROUTES = [
+  "go",
+  "fly",
+  "streak",
+  "vertical",
+  "slant",
+  "flat",
+  "hitch",
+  "out",
+  "in",
+  "dig",
+  "curl",
+  "comeback",
+  "corner",
+  "flag",
+  "post",
+  "wheel",
+  "cross",
+  "drag",
+  "seam",
+  "screen",
+  "dive",
+  "iso",
+  "power",
+  "counter",
+  "sweep",
+  "toss",
+  "draw",
+  "trap"
+];
+var RUN_CONCEPTS = /* @__PURE__ */ new Set(["dive", "iso", "power", "counter", "sweep", "toss", "draw", "trap"]);
+var FORMATIONS = [
+  "i-form",
+  "shotgun",
+  "singleback",
+  "pistol",
+  "trips",
+  "spread",
+  "trips-right",
+  "trips-left",
+  "empty",
+  "goal-line",
+  "wishbone",
+  "4-4-2",
+  "4-3-3",
+  "4-2-3-1",
+  "3-5-2",
+  "4-4-1-1",
+  "4-5-1",
+  "3-4-3",
+  "horns",
+  "1-4-high",
+  "1-4-low",
+  "box",
+  "spread-pnr",
+  "5-out",
+  "4-out"
+];
+var DEFENSES = [
+  "4-3",
+  "3-4",
+  "4-4",
+  "nickel",
+  "dime",
+  "cover-0",
+  "cover-1",
+  "cover-2",
+  "cover-3",
+  "cover-4",
+  "cover-6",
+  "man",
+  "zone-2-3",
+  "zone-3-2",
+  "zone-1-3-1",
+  "low-block",
+  "mid-block",
+  "high-press"
+];
+var DIRS = ["left", "right"];
+function parseHeader4(tok, ast, ln) {
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr2(t)) ast.title = t.str;
+    else if (isWord2(t, "sport")) {
+      const s = parseId2(tok.shift(), "sport", ln).toLowerCase();
+      if (s !== "football" && s !== "basketball" && s !== "soccer") {
+        throw new PlaybookParseError(`sport must be football|basketball|soccer, got "${s}"`, ln);
+      }
+      ast.sport = s;
+    } else throw new PlaybookParseError(`playbook: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+}
+function parseField(tok, ast, ln) {
+  while (tok.length) {
+    const t = tok.shift();
+    if (isWord2(t, "down")) ast.down = parseNum2(tok.shift(), "down", ln);
+    else if (isWord2(t, "distance") || isWord2(t, "togo")) ast.distance = parseNum2(tok.shift(), "distance", ln);
+    else if (isWord2(t, "los") || isWord2(t, "ball")) ast.losYard = parseNum2(tok.shift(), "los", ln);
+    else if (isWord2(t, "goal") || isWord2(t, "togoal")) ast.toGoal = parseNum2(tok.shift(), "goal", ln);
+    else if (isWord2(t, "view")) {
+      const v = parseId2(tok.shift(), "view (full|half)", ln).toLowerCase();
+      if (v !== "full" && v !== "half" && v !== "auto") throw new PlaybookParseError(`view must be full|half`, ln);
+      ast.view = v;
+    } else if (isWord2(t, "hash")) {
+      const h = parseId2(tok.shift(), "hash (nfl|college|none)", ln).toLowerCase();
+      if (h !== "nfl" && h !== "college" && h !== "none") throw new PlaybookParseError(`hash must be nfl|college|none`, ln);
+      ast.hash = h;
+    } else throw new PlaybookParseError(`field: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+}
+function parseFormation(tok, ast, ln) {
+  let name = parseId2(tok.shift(), "a formation", ln).toLowerCase();
+  let side;
+  const hy = /^(.*)-(left|right)$/.exec(name);
+  if (hy && FORMATIONS.includes(hy[1]) && hy[1] !== "trips") {
+    name = hy[1];
+    side = hy[2];
+  }
+  if (!FORMATIONS.includes(name)) {
+    throw new PlaybookParseError(`unknown formation "${name}"`, ln);
+  }
+  ast.formation = name;
+  while (tok.length) {
+    const t = tok.shift();
+    if (isWord2(t, "left") || isWord2(t, "right")) side = t.word.toLowerCase();
+    else throw new PlaybookParseError(`formation: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+  if (name === "trips-right") ast.formationSide = "right";
+  else if (name === "trips-left") ast.formationSide = "left";
+  else if (side) ast.formationSide = side;
+}
+function parseDefense(tok, ast, ln) {
+  const d = parseId2(tok.shift(), "a defensive scheme", ln).toLowerCase();
+  if (!DEFENSES.includes(d)) throw new PlaybookParseError(`unknown defense "${d}"`, ln);
+  ast.defense = d;
+}
+function parsePlayer(tok, ast, ln) {
+  const id = parseId2(tok.shift(), "a player id", ln);
+  const posRaw = parseId2(tok.shift(), "a position", ln).toLowerCase();
+  if (!POSITIONS.includes(posRaw)) throw new PlaybookParseError(`unknown position "${posRaw}"`, ln);
+  const isDef = posRaw === "x" || posRaw === "dl" || posRaw === "lb" || posRaw === "db" || posRaw === "s";
+  const p = { id, side: isDef ? "defense" : "offense", pos: posRaw, label: id, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr2(t)) p.label = t.str;
+    else if (isWord2(t, "label")) {
+      const lt = tok.shift();
+      p.label = isStr2(lt) ? lt.str : parseId2(lt, "a label", ln);
+    } else if (isWord2(t, "at")) {
+      const c = COORD.exec(parseId2(tok.shift(), "x,y", ln));
+      if (!c) throw new PlaybookParseError(`expected "x,y" after at`, ln);
+      p.at = { x: Number(c[1]), y: Number(c[2]) };
+    } else if (isWord2(t, "side")) {
+      const sv = parseId2(tok.shift(), "side", ln).toLowerCase();
+      if (sv !== "offense" && sv !== "defense") throw new PlaybookParseError(`side must be offense|defense`, ln);
+      p.side = sv;
+    } else throw new PlaybookParseError(`player: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+  ast.players.push(p);
+}
+function splitNameDir(token) {
+  const m = /^(.*)-(left|right)$/.exec(token.toLowerCase());
+  if (m) return { name: m[1], dir: m[2] };
+  return { name: token.toLowerCase() };
+}
+function parseDests(tok) {
+  const pts = [];
+  while (tok.length) {
+    const t = tok.shift();
+    if (isWord2(t, "to") || isWord2(t, "then") || isWord2(t, "->")) continue;
+    if (!isWord2(t)) continue;
+    const c = COORD.exec(t.word);
+    if (c) {
+      const rel = /^[+]/.test(c[1]) || /^[+]/.test(c[2]);
+      pts.push({ x: Number(c[1]), y: Number(c[2]), rel });
+    } else {
+      pts.push({ ref: t.word });
+    }
+  }
+  return pts;
+}
+function parseRouteRun(kind, tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const m = { player, kind, line: ln };
+  const first = tok[0];
+  if (isWord2(first, "to") || isWord2(first, "path")) {
+    tok.shift();
+    m.points = parseDests(tok);
+    ast.moves.push(m);
+    return;
+  }
+  if (isWord2(first)) {
+    const { name, dir } = splitNameDir(first.word);
+    if (NAMED_ROUTES.includes(name)) {
+      tok.shift();
+      m.named = name;
+      if (dir) m.dir = dir;
+      if (kind === "route" && RUN_CONCEPTS.has(name)) m.kind = "run";
+      while (tok.length) {
+        const t = tok.shift();
+        if (isWord2(t) && DIRS.includes(t.word.toLowerCase())) m.dir = t.word.toLowerCase();
+        else if (isWord2(t) && Number.isFinite(Number(t.word))) m.depth = Number(t.word);
+        else if (isWord2(t, "depth")) m.depth = parseNum2(tok.shift(), "depth", ln);
+        else throw new PlaybookParseError(`${kind}: unexpected token "${tokDisplay(t)}"`, ln);
+      }
+      ast.moves.push(m);
+      return;
+    }
+  }
+  m.points = parseDests(tok);
+  if (m.points.length === 0) throw new PlaybookParseError(`${kind} ${player}: needs a route name or destination`, ln);
+  ast.moves.push(m);
+}
+function parsePoly(kind, tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const points = parseDests(tok);
+  if (points.length === 0) throw new PlaybookParseError(`${kind} ${player}: needs a destination (x,y or a landmark)`, ln);
+  ast.moves.push({ player, kind, points, line: ln });
+}
+function parseTargeted(kind, tok, ast, ln, optionalTarget = false) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const nxt = tok[0];
+  if (isWord2(nxt, "to")) tok.shift();
+  const tgt = tok.shift();
+  if (!tgt) {
+    if (optionalTarget) {
+      ast.moves.push({ player, kind, line: ln });
+      return;
+    }
+    throw new PlaybookParseError(`${kind} ${player}: needs a target (player id, landmark, or x,y)`, ln);
+  }
+  const target = isWord2(tgt) ? tgt.word : tgt.str;
+  ast.moves.push({ player, kind, target, line: ln });
+}
+function parsePull(tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a lineman id", ln);
+  const dt = tok.shift();
+  const { dir } = splitNameDir(isWord2(dt) ? dt.word : "");
+  let d = dir;
+  if (!d && isWord2(dt) && DIRS.includes(dt.word.toLowerCase())) d = dt.word.toLowerCase();
+  if (!d) throw new PlaybookParseError(`pull: expected left|right`, ln);
+  ast.moves.push({ player, kind: "pull", named: "power", dir: d, line: ln });
+}
+function parseMotion(tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const m = { player, kind: "motion", line: ln };
+  const dt = tok.shift();
+  if (isWord2(dt) && DIRS.includes(dt.word.toLowerCase())) {
+    m.dir = dt.word.toLowerCase();
+    const n = tok.shift();
+    if (isWord2(n) && Number.isFinite(Number(n.word))) m.depth = Number(n.word);
+  } else if (isWord2(dt, "to")) {
+    m.points = parseDests(tok);
+  } else if (isWord2(dt)) {
+    const c = COORD.exec(dt.word);
+    if (c) m.points = [{ x: Number(c[1]), y: Number(c[2]), rel: /^[+]/.test(c[1]) }];
+    else m.points = [{ ref: dt.word }];
+  } else throw new PlaybookParseError(`motion: expected left|right or a destination`, ln);
+  ast.moves.push(m);
+}
+function parseZone(tok, ast, ln) {
+  const z = { x: 0, y: 0, rx: 6, ry: 5, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr2(t)) z.label = t.str;
+    else if (isWord2(t, "at")) {
+      const c = COORD.exec(parseId2(tok.shift(), "x,y", ln));
+      if (!c) throw new PlaybookParseError(`zone: expected "x,y" after at`, ln);
+      z.x = Number(c[1]);
+      z.y = Number(c[2]);
+    } else if (isWord2(t, "size")) {
+      const st = tok.shift();
+      const m = /^(\d*\.?\d+)x(\d*\.?\d+)$/i.exec(isWord2(st) ? st.word : "");
+      if (!m) throw new PlaybookParseError(`zone size expects "rxXry"`, ln);
+      z.rx = Number(m[1]);
+      z.ry = Number(m[2]);
+    } else if (isWord2(t, "label")) {
+      const lt = tok.shift();
+      z.label = isStr2(lt) ? lt.str : parseId2(lt, "a label", ln);
+    } else throw new PlaybookParseError(`zone: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+  ast.zones.push(z);
+}
+function parseHandoff(tok, ast, ln) {
+  const from = parseId2(tok.shift(), "the source id", ln);
+  const to = parseId2(tok.shift(), "the target id", ln);
+  ast.moves.push({ player: from, kind: "handoff", target: to, line: ln });
+}
+function parsePlaybook(text2) {
+  const ast = {
+    type: "playbook",
+    title: "Football Play",
+    sport: "football",
+    down: 0,
+    distance: 0,
+    hash: "nfl",
+    view: "auto",
+    formationSide: "right",
+    players: [],
+    moves: [],
+    zones: []
+  };
+  let sawHeader = false;
+  let titleSetByUser = false;
+  const lines = text2.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const ln = i + 1;
+    const raw = normalizeQuotes4(lines[i]).trim();
+    if (!raw) continue;
+    const all = tokenize8(raw);
+    const tok = [];
+    for (const t of all) {
+      if (isWord2(t) && (t.word.startsWith("#") || t.word.startsWith("//"))) break;
+      tok.push(t);
+    }
+    if (tok.length === 0) continue;
+    const head = tok.shift();
+    if (!isWord2(head)) throw new PlaybookParseError(`unexpected string at line start`, ln);
+    const kw = head.word.toLowerCase();
+    if (kw === "playbook") {
+      const before = ast.title;
+      parseHeader4(tok, ast, ln);
+      if (ast.title !== before) titleSetByUser = true;
+      sawHeader = true;
+      continue;
+    }
+    if (!sawHeader) throw new PlaybookParseError(`the first statement must be the "playbook" header`, ln);
+    if (kw === "field") parseField(tok, ast, ln);
+    else if (kw === "view") {
+      const v = parseId2(tok.shift(), "view (full|half)", ln).toLowerCase();
+      if (v !== "full" && v !== "half" && v !== "auto") throw new PlaybookParseError(`view must be full|half`, ln);
+      ast.view = v;
+    } else if (kw === "formation" || kw === "set") parseFormation(tok, ast, ln);
+    else if (kw === "defense" || kw === "def") parseDefense(tok, ast, ln);
+    else if (kw === "player") parsePlayer(tok, ast, ln);
+    else if (kw === "route") parseRouteRun("route", tok, ast, ln);
+    else if (kw === "run") parseRouteRun("run", tok, ast, ln);
+    else if (kw === "cut") parsePoly("cut", tok, ast, ln);
+    else if (kw === "move") parsePoly("move", tok, ast, ln);
+    else if (kw === "dribble" || kw === "drive") parsePoly("dribble", tok, ast, ln);
+    else if (kw === "pass") parseTargeted("pass", tok, ast, ln);
+    else if (kw === "screen") parseTargeted("screen", tok, ast, ln);
+    else if (kw === "block") parseTargeted("block", tok, ast, ln);
+    else if (kw === "shot" || kw === "shoot") parseTargeted("shot", tok, ast, ln, true);
+    else if (kw === "pull") parsePull(tok, ast, ln);
+    else if (kw === "handoff") parseHandoff(tok, ast, ln);
+    else if (kw === "motion") parseMotion(tok, ast, ln);
+    else if (kw === "zone") parseZone(tok, ast, ln);
+    else throw new PlaybookParseError(`unknown keyword "${kw}"`, ln);
+  }
+  if (!titleSetByUser) {
+    ast.title = ast.sport === "basketball" ? "Basketball Play" : ast.sport === "soccer" ? "Soccer Tactic" : "Football Play";
+  }
+  return ast;
+}
+
+// src/diagrams/playbook/geometry/football.ts
+var K = {
+  scale: 14,
+  olSplit: 1.4,
+  wrSplit: 13,
+  slotSplit: 6,
+  minHalfWidth: 20,
+  margin: 2,
+  hashNfl: 3.08,
+  hashCollege: 6.67
+};
+var r25 = (n) => Math.round(n * 100) / 100;
+var round22 = (p) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 });
+var dirSign = (d) => d === "right" ? 1 : -1;
+function offensiveLine() {
+  return [
+    { id: "LT", pos: "ol", label: "T", x: -2 * K.olSplit, y: 0 },
+    { id: "LG", pos: "ol", label: "G", x: -1 * K.olSplit, y: 0 },
+    { id: "C", pos: "c", label: "C", x: 0, y: 0 },
+    { id: "RG", pos: "ol", label: "G", x: 1 * K.olSplit, y: 0 },
+    { id: "RT", pos: "ol", label: "T", x: 2 * K.olSplit, y: 0 }
+  ];
+}
+function tightEnd(side) {
+  const s = side === "right" ? 1 : -1;
+  return { id: "Y", pos: "te", label: "Y", x: s * (2 * K.olSplit + 1.3), y: 0 };
+}
+function formationRoster(formation, side) {
+  const s = side === "right" ? 1 : -1;
+  const ol = offensiveLine();
+  const X = { id: "X", pos: "wr", label: "X", x: -s * K.wrSplit, y: 0 };
+  const Z = { id: "Z", pos: "wr", label: "Z", x: s * K.wrSplit, y: -1 };
+  switch (formation) {
+    case "i-form":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "FB", pos: "rb", label: "F", x: 0, y: -3.6 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -6.2 },
+        X,
+        Z
+      ];
+    case "wishbone":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "FB", pos: "rb", label: "F", x: 0, y: -3.4 },
+        { id: "LH", pos: "rb", label: "H", x: -3.5, y: -5.2 },
+        { id: "RB", pos: "rb", label: "H", x: 3.5, y: -5.2 },
+        X
+      ];
+    case "singleback":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -5 },
+        X,
+        { id: "H", pos: "wr", label: "H", x: s * K.slotSplit, y: -1 },
+        Z
+      ];
+    case "pistol":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -4 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -7 },
+        X,
+        Z
+      ];
+    case "shotgun":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "RB", pos: "rb", label: "RB", x: s * 1.8, y: -5 },
+        X,
+        Z
+      ];
+    case "spread":
+      return [
+        ...ol,
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "RB", pos: "rb", label: "RB", x: s * 1.8, y: -5 },
+        { id: "X", pos: "wr", label: "X", x: -13 - 1, y: 0 },
+        { id: "H", pos: "wr", label: "H", x: -6, y: -1 },
+        { id: "Y", pos: "wr", label: "Y", x: K.slotSplit, y: -1 },
+        { id: "Z", pos: "wr", label: "Z", x: K.wrSplit + 1, y: 0 }
+      ];
+    case "trips":
+    case "trips-right":
+    case "trips-left": {
+      const t = formation === "trips-left" ? -1 : formation === "trips-right" ? 1 : s;
+      return [
+        ...ol,
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "RB", pos: "rb", label: "RB", x: -t * 1.8, y: -5 },
+        { id: "X", pos: "wr", label: "X", x: -t * (K.wrSplit + 1), y: 0 },
+        { id: "Z", pos: "wr", label: "Z", x: t * (K.wrSplit + 1), y: 0 },
+        { id: "H", pos: "wr", label: "H", x: t * 9, y: -1 },
+        { id: "Y", pos: "wr", label: "Y", x: t * 5, y: -1 }
+      ];
+    }
+    case "empty":
+      return [
+        ...ol,
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "X", pos: "wr", label: "X", x: -13 - 1, y: 0 },
+        { id: "H", pos: "wr", label: "H", x: -6 - 1, y: -1 },
+        { id: "Z", pos: "wr", label: "Z", x: K.wrSplit + 1, y: 0 },
+        { id: "Y", pos: "wr", label: "Y", x: K.slotSplit + 1, y: -1 },
+        { id: "H2", pos: "wr", label: "h", x: K.slotSplit - 2, y: -1 }
+      ];
+    case "goal-line":
+      return [
+        ...ol,
+        { id: "Y", pos: "te", label: "Y", x: 2 * K.olSplit + 1.3, y: 0 },
+        { id: "TE2", pos: "te", label: "Y", x: -4.1, y: 0 },
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "FB", pos: "rb", label: "F", x: 0, y: -3.4 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -5.4 },
+        { id: "Z", pos: "wr", label: "Z", x: s * 9, y: 0 }
+      ];
+    default:
+      return [...ol, { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 }];
+  }
+}
+function front43(side) {
+  const s = side === "right" ? 1 : -1;
+  return [
+    { id: "DE_W", pos: "dl", label: "E", x: -3.6, y: 1 },
+    { id: "DT_W", pos: "dl", label: "T", x: -1.2, y: 1 },
+    { id: "DT_S", pos: "dl", label: "T", x: 1.2, y: 1 },
+    { id: "DE_S", pos: "dl", label: "E", x: 3.6, y: 1 },
+    { id: "WLB", pos: "lb", label: "W", x: -4.5, y: 4.3 },
+    { id: "MLB", pos: "lb", label: "M", x: 0, y: 4.8 },
+    { id: "SLB", pos: "lb", label: "S", x: s * 4.5, y: 4.3 }
+  ];
+}
+function front34(side) {
+  const s = side === "right" ? 1 : -1;
+  return [
+    { id: "DE_W", pos: "dl", label: "E", x: -2.6, y: 1 },
+    { id: "NT", pos: "dl", label: "N", x: 0, y: 1 },
+    { id: "DE_S", pos: "dl", label: "E", x: 2.6, y: 1 },
+    { id: "WOLB", pos: "lb", label: "W", x: -5.4, y: 3.6 },
+    { id: "WILB", pos: "lb", label: "M", x: -1.6, y: 4.6 },
+    { id: "SILB", pos: "lb", label: "M", x: 1.6, y: 4.6 },
+    { id: "SOLB", pos: "lb", label: "S", x: s * 5.4, y: 3.6 }
+  ];
+}
+function defensePreset(scheme, side) {
+  const s = side === "right" ? 1 : -1;
+  const cb = (sign, y, label = "C") => ({ id: sign < 0 ? "LCB" : "RCB", pos: "db", label, x: sign * K.wrSplit, y });
+  let front;
+  let cover;
+  let showZones = true;
+  if (scheme === "3-4") {
+    front = front34(side);
+    cover = "cover-2";
+    showZones = false;
+  } else if (scheme === "4-4") {
+    front = [...front43(side), { id: "SS", pos: "s", label: "$", x: s * 6, y: 4.6 }];
+    cover = "cover-3";
+  } else if (scheme === "nickel") {
+    front = front43(side).slice(0, 6);
+    cover = "cover-2";
+  } else if (scheme === "dime") {
+    front = front43(side).slice(0, 5);
+    cover = "cover-3";
+  } else if (scheme.startsWith("cover")) {
+    front = front43(side);
+    cover = scheme;
+  } else {
+    front = front43(side);
+    cover = "cover-2";
+    showZones = false;
+  }
+  const sec = [];
+  const zones = [];
+  switch (cover) {
+    case "cover-0":
+      sec.push(cb(-1, 5.5), cb(1, 5.5), { id: "FS", pos: "s", label: "F", x: -6, y: 5 }, { id: "SS", pos: "s", label: "$", x: s * 6, y: 5 });
+      break;
+    case "cover-1":
+      sec.push(cb(-1, 6), cb(1, 6), { id: "SS", pos: "s", label: "$", x: s * 6, y: 5 }, { id: "FS", pos: "s", label: "F", x: 0, y: 13.5 });
+      zones.push({ x: 0, y: 13.5, rx: 5, ry: 3.5, label: "deep middle" });
+      break;
+    case "cover-2":
+      sec.push(cb(-1, 5), cb(1, 5), { id: "FS", pos: "s", label: "F", x: -9, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 9, y: 12.5 });
+      zones.push({ x: -9, y: 12.5, rx: 9, ry: 4, label: "deep half" }, { x: 9, y: 12.5, rx: 9, ry: 4, label: "deep half" });
+      break;
+    case "cover-3":
+      sec.push(cb(-1, 11.5), cb(1, 11.5), { id: "FS", pos: "s", label: "F", x: 0, y: 14 }, { id: "SS", pos: "s", label: "$", x: s * 6, y: 5 });
+      zones.push({ x: -13.5, y: 12, rx: 5.8, ry: 3.6, label: "deep \u2153" }, { x: 0, y: 14.5, rx: 5.8, ry: 3.6, label: "deep \u2153" }, { x: 13.5, y: 12, rx: 5.8, ry: 3.6, label: "deep \u2153" });
+      break;
+    case "cover-4":
+      sec.push(cb(-1, 10), cb(1, 10), { id: "FS", pos: "s", label: "F", x: -6, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 6, y: 12.5 });
+      zones.push({ x: -13, y: 12, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: -5, y: 13, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: 5, y: 13, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: 13, y: 12, rx: 6.5, ry: 4, label: "deep \xBC" });
+      break;
+    case "cover-6":
+      sec.push(cb(-1, 10), cb(1, 5), { id: "FS", pos: "s", label: "F", x: -7, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 9, y: 12.5 });
+      zones.push({ x: -7, y: 12.5, rx: 7, ry: 4, label: "deep \xBC" }, { x: -13, y: 12, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: 9, y: 12.5, rx: 9, ry: 4, label: "deep \xBD" });
+      break;
+    default:
+      sec.push(cb(-1, 5), cb(1, 5), { id: "FS", pos: "s", label: "F", x: -9, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 9, y: 12.5 });
+  }
+  return { defenders: [...front, ...sec].slice(0, 11), zones: showZones ? zones : [] };
+}
+function passRoute(named, depth, outSign, inSign) {
+  const d = depth;
+  switch (named) {
+    case "go":
+    case "fly":
+    case "streak":
+    case "vertical":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 16 }];
+    case "seam":
+      return [{ x: 0, y: 0 }, { x: inSign * 0.5, y: d ?? 14 }];
+    case "slant":
+      return [{ x: 0, y: 0 }, { x: 0, y: 1.6 }, { x: inSign * 4.5, y: 6 }];
+    case "flat":
+      return [{ x: 0, y: 0 }, { x: outSign * 1.5, y: 1 }, { x: outSign * 5.5, y: 2.2 }];
+    case "hitch":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 5.5 }, { x: inSign * 1, y: (d ?? 5.5) - 1.2 }];
+    case "out":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: outSign * 5.5, y: d ?? 10 }];
+    case "in":
+    case "dig":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: inSign * 6.5, y: d ?? 10 }];
+    case "curl":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 12 }, { x: inSign * 1.6, y: (d ?? 12) - 1.6 }];
+    case "comeback":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 14 }, { x: outSign * 2.2, y: (d ?? 14) - 2.4 }];
+    case "corner":
+    case "flag":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: outSign * 5.5, y: (d ?? 10) + 5 }];
+    case "post":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: inSign * 5.5, y: (d ?? 10) + 6 }];
+    case "wheel":
+      return [{ x: 0, y: 0 }, { x: outSign * 3, y: 1 }, { x: outSign * 4, y: d ?? 11 }];
+    case "cross":
+    case "drag":
+      return [{ x: 0, y: 0 }, { x: 0, y: 1.5 }, { x: inSign * 14, y: 3.2 }];
+    case "screen":
+      return [{ x: 0, y: 0 }, { x: 0, y: -1 }, { x: outSign * 4.5, y: -1 }];
+    default:
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }];
+  }
+}
+function runPath(named, start, dir) {
+  const k = dirSign(dir);
+  switch (named) {
+    case "dive":
+    case "trap":
+      return [start, { x: k * 1, y: 0.5 }, { x: k * 1.6, y: 3.2 }];
+    case "iso":
+      return [start, { x: k * 0.4, y: 0.5 }, { x: k * 0.8, y: 3.4 }];
+    case "power":
+      return [start, { x: start.x + k * 1.4, y: start.y + 1.5 }, { x: k * 2.6, y: 0.6 }, { x: k * 3.6, y: 4.2 }];
+    case "counter":
+      return [start, { x: -k * 1.6, y: start.y + 0.3 }, { x: k * 2.2, y: 0.6 }, { x: k * 3.2, y: 4.2 }];
+    case "sweep":
+    case "toss":
+      return [start, { x: k * 5, y: start.y + 0.6 }, { x: k * 7, y: 1.2 }, { x: k * 7, y: 5 }];
+    case "draw":
+      return [start, { x: 0, y: start.y + 1.5 }, { x: k * 1, y: 3.4 }];
+    default:
+      return [start, { x: k * 1.4, y: 3.2 }];
+  }
+}
+var footballModule = {
+  scale: K.scale,
+  yUp: true,
+  buildPlayers(ast) {
+    const players = [];
+    const byId = /* @__PURE__ */ new Map();
+    const add = (p) => {
+      if (byId.has(p.id)) players[byId.get(p.id)] = p;
+      else {
+        byId.set(p.id, players.length);
+        players.push(p);
+      }
+    };
+    if (ast.formation) for (const sl of formationRoster(ast.formation, ast.formationSide)) add({ id: sl.id, side: "offense", pos: sl.pos, label: sl.label, x: sl.x, y: sl.y });
+    if (ast.defense) for (const d of defensePreset(ast.defense, ast.formationSide).defenders) add({ id: d.id, side: "defense", pos: d.pos, label: d.label, x: d.x, y: d.y });
+    for (const p of ast.players) {
+      const at = p.at ?? (byId.has(p.id) ? { x: players[byId.get(p.id)].x, y: players[byId.get(p.id)].y } : { x: 0, y: 0 });
+      add({ id: p.id, side: p.side, pos: p.pos, label: p.label, x: at.x, y: at.y });
+    }
+    return players;
+  },
+  buildZones(ast) {
+    const zones = [];
+    if (ast.defense) zones.push(...defensePreset(ast.defense, ast.formationSide).zones);
+    for (const z of ast.zones) zones.push({ x: z.x, y: z.y, rx: z.rx, ry: z.ry, label: z.label });
+    return zones;
+  },
+  resolveNamed(m, src, players, byId) {
+    const endFor2 = (kind) => m.end ?? ("arrow");
+    if (m.kind === "pull") {
+      const k = dirSign(m.dir ?? "right");
+      const offTackle = 2 * K.olSplit + 0.8;
+      const pts = [{ x: src.x, y: 0 }, { x: src.x, y: -1.3 }, { x: k * offTackle, y: -1.3 }, { x: k * offTackle, y: 1.6 }];
+      return { player: m.player, kind: "pull", style: "solid", points: pts.map(round22), end: "arrow" };
+    }
+    if ((m.kind === "run" || m.kind === "route") && m.named) {
+      if (m.kind === "run") {
+        return { player: m.player, kind: "run", style: "solid", points: runPath(m.named, src, m.dir ?? "right").map(round22), end: "arrow" };
+      }
+      const outSign = m.dir ? dirSign(m.dir) : src.x >= 0 ? 1 : -1;
+      const rel = passRoute(m.named, m.depth, outSign, -outSign);
+      return { player: m.player, kind: "route", style: "solid", points: rel.map((p) => round22({ x: src.x + p.x, y: src.y + p.y })), end: endFor2() };
+    }
+    return null;
+  },
+  bounds(ast, players, moves, zones) {
+    let minX = -20, maxX = K.minHalfWidth, minY = -7, maxY = 6;
+    const ext = (x, y) => {
+      minX = Math.min(minX, x);
+      maxX = Math.max(maxX, x);
+      minY = Math.min(minY, y);
+      maxY = Math.max(maxY, y);
+    };
+    for (const p of players) ext(p.x, p.y);
+    for (const mv of moves) for (const pt of mv.points) ext(pt.x, pt.y);
+    for (const z of zones) {
+      ext(z.x - z.rx, z.y - z.ry);
+      ext(z.x + z.rx, z.y + z.ry);
+    }
+    if (ast.toGoal !== void 0) maxY = Math.max(maxY, ast.toGoal + 11);
+    const m = K.margin;
+    return { minX: minX - m, maxX: maxX + m, minY: minY - m, maxY: maxY + m };
+  },
+  drawField(lay, ctx, t) {
+    const b = lay.bounds;
+    const parts = [];
+    const x1 = ctx.X(b.minX), x2 = ctx.X(b.maxX);
+    if (lay.toGoal !== void 0) {
+      const gl = lay.toGoal;
+      const ezTop = Math.min(gl + 10, b.maxY);
+      parts.push(rect({ class: "sx-pb-endzone", x: r25(x1), y: r25(ctx.Y(ezTop)), width: r25((b.maxX - b.minX) * K.scale), height: r25((ezTop - gl) * K.scale) }));
+      parts.push(line({ class: "sx-pb-goalline", x1: r25(x1), y1: r25(ctx.Y(gl)), x2: r25(x2), y2: r25(ctx.Y(gl)) }));
+      const gy = ctx.Y(Math.min(gl + 10, b.maxY) - 0.2);
+      const cx = ctx.X(0);
+      const up = ctx.px(2.2);
+      const cross = ctx.px(3);
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx), y1: r25(gy), x2: r25(cx), y2: r25(gy + ctx.px(1)) }));
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx - cross / 2), y1: r25(gy), x2: r25(cx + cross / 2), y2: r25(gy) }));
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx - cross / 2), y1: r25(gy), x2: r25(cx - cross / 2), y2: r25(gy - up) }));
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx + cross / 2), y1: r25(gy), x2: r25(cx + cross / 2), y2: r25(gy - up) }));
+    }
+    const startY = Math.ceil(b.minY / 5) * 5;
+    for (let yd = startY; yd <= b.maxY; yd += 5) {
+      if (Math.abs(yd) < 1e-6) continue;
+      if (lay.toGoal !== void 0 && yd > lay.toGoal + 0.01) continue;
+      parts.push(line({ class: "sx-pb-yard", x1: r25(x1), y1: r25(ctx.Y(yd)), x2: r25(x2), y2: r25(ctx.Y(yd)) }));
+      if (lay.toGoal !== void 0) {
+        const yardNum = lay.toGoal - yd;
+        if (yardNum > 0 && yardNum % 10 === 0) {
+          parts.push(text({ class: "sx-pb-yardnum", x: r25(x1 + 12), y: r25(ctx.Y(yd) + 4), "text-anchor": "middle" }, String(yardNum)));
+          parts.push(text({ class: "sx-pb-yardnum", x: r25(x2 - 12), y: r25(ctx.Y(yd) + 4), "text-anchor": "middle" }, String(yardNum)));
+        }
+      }
+    }
+    if (lay.hash !== "none") {
+      const hx = lay.hash === "college" ? K.hashCollege : K.hashNfl;
+      const top = lay.toGoal !== void 0 ? Math.min(b.maxY, lay.toGoal) : b.maxY;
+      for (let yd = Math.ceil(b.minY); yd <= top; yd += 1) {
+        for (const sgn of [-1, 1]) {
+          const xc = ctx.X(sgn * hx);
+          parts.push(line({ class: "sx-pb-hash", x1: r25(xc - 2), y1: r25(ctx.Y(yd)), x2: r25(xc + 2), y2: r25(ctx.Y(yd)) }));
+        }
+      }
+    }
+    parts.push(line({ class: "sx-pb-los", x1: r25(x1), y1: r25(ctx.Y(0)), x2: r25(x2), y2: r25(ctx.Y(0)) }));
+    return group({ class: "sx-pb-field-g" }, parts);
+  },
+  legend(lay) {
+    const items = [
+      { kind: "offense", label: "Offense" },
+      { kind: "defense", label: "Defense" },
+      { kind: "run", label: "Route / run" },
+      { kind: "screen", label: "Block" },
+      { kind: "motion", label: "Motion" }
+    ];
+    if (lay.zones.length) items.push({ kind: "zone", label: "Zone" });
+    return items;
+  }
+};
+
+// src/diagrams/playbook/geometry/basketball.ts
+var K2 = {
+  scale: 11,
+  // x ∈ [-25, 25]
+  half: 47,
+  rimY: 5.25,
+  laneHalf: 8,
+  // NBA lane half-width
+  ftY: 15,
+  ftR: 6,
+  threeR: 23.75,
+  cornerX: 22,
+  cornerMeetY: 14.2,
+  restrictedR: 4,
+  centerR: 6,
+  margin: 2.5
+};
+var r26 = (n) => Math.round(n * 100) / 100;
+var LANDMARKS = {
+  top: { x: 0, y: 28 },
+  rslot: { x: 8, y: 26 },
+  lslot: { x: -8, y: 26 },
+  slot: { x: 8, y: 26 },
+  rwing: { x: 19, y: 17 },
+  lwing: { x: -19, y: 17 },
+  wing: { x: 19, y: 17 },
+  rcorner: { x: 22, y: 3 },
+  lcorner: { x: -22, y: 3 },
+  corner: { x: 22, y: 3 },
+  "rshort-corner": { x: 12, y: 2 },
+  "lshort-corner": { x: -12, y: 2 },
+  relbow: { x: 8, y: 15 },
+  lelbow: { x: -8, y: 15 },
+  elbow: { x: 8, y: 15 },
+  rblock: { x: 8, y: 7 },
+  lblock: { x: -8, y: 7 },
+  block: { x: 8, y: 7 },
+  rdunker: { x: 9, y: 4 },
+  ldunker: { x: -9, y: 4 },
+  "high-post": { x: 0, y: 15 },
+  ft: { x: 0, y: 15 },
+  "free-throw": { x: 0, y: 15 },
+  "rlow-post": { x: 9, y: 8 },
+  "llow-post": { x: -9, y: 8 },
+  rim: { x: 0, y: 5.25 },
+  basket: { x: 0, y: 5.25 },
+  hoop: { x: 0, y: 5.25 },
+  paint: { x: 0, y: 10 }
+};
+function setRoster(formation) {
+  const L = LANDMARKS;
+  const at = (lm) => L[lm];
+  const slots = (pts) => pts.map((p, i) => ({ id: String(i + 1), label: String(i + 1), x: p.x, y: p.y }));
+  switch (formation) {
+    case "horns":
+      return slots([at("top"), at("lcorner"), at("rcorner"), at("lelbow"), at("relbow")]);
+    case "1-4-high":
+      return slots([at("top"), at("lwing"), at("rwing"), at("lelbow"), at("relbow")]);
+    case "1-4-low":
+      return slots([at("top"), at("lcorner"), at("rcorner"), at("lblock"), at("rblock")]);
+    case "box":
+      return slots([at("top"), at("lelbow"), at("relbow"), at("lblock"), at("rblock")]);
+    case "spread-pnr":
+      return slots([at("top"), at("lcorner"), at("rcorner"), at("lwing"), { x: 8, y: 24 }]);
+    case "4-out":
+      return slots([at("top"), at("lwing"), at("rwing"), at("lcorner"), at("rblock")]);
+    case "5-out":
+    default:
+      return slots([at("top"), at("lwing"), at("rwing"), at("lcorner"), at("rcorner")]);
+  }
+}
+function defenseRoster(scheme, offense) {
+  const zones = [];
+  if (scheme === "man") {
+    const defenders2 = offense.filter((p) => p.side === "offense").slice(0, 5).map((o) => {
+      const dx = -o.x * 0.12;
+      const dy = (K2.rimY - o.y) * 0.18;
+      return { id: "X" + o.id, label: "X" + o.label, x: o.x + dx, y: o.y + dy };
+    });
+    return { defenders: defenders2, zones };
+  }
+  let pts;
+  if (scheme === "zone-3-2") pts = [{ x: 0, y: 20 }, { x: -13, y: 17 }, { x: 13, y: 17 }, { x: -8, y: 8 }, { x: 8, y: 8 }];
+  else if (scheme === "zone-1-3-1") pts = [{ x: 0, y: 22 }, { x: -12, y: 14 }, { x: 0, y: 13 }, { x: 12, y: 14 }, { x: 0, y: 5.5 }];
+  else pts = [{ x: -7, y: 18 }, { x: 7, y: 18 }, { x: 0, y: 9 }, { x: -13, y: 6 }, { x: 13, y: 6 }];
+  const defenders = pts.map((p, i) => ({ id: "X" + (i + 1), label: "X", x: p.x, y: p.y }));
+  return { defenders, zones };
+}
+var basketballModule = {
+  scale: K2.scale,
+  yUp: false,
+  buildPlayers(ast) {
+    const players = [];
+    const byId = /* @__PURE__ */ new Map();
+    const add = (p) => {
+      if (byId.has(p.id)) players[byId.get(p.id)] = p;
+      else {
+        byId.set(p.id, players.length);
+        players.push(p);
+      }
+    };
+    for (const sl of setRoster(ast.formation)) add({ id: sl.id, side: "offense", pos: "o", label: sl.label, x: sl.x, y: sl.y });
+    if (ast.defense) for (const d of defenseRoster(ast.defense, players).defenders) add({ id: d.id, side: "defense", pos: "x", label: d.label, x: d.x, y: d.y });
+    for (const p of ast.players) {
+      const at = p.at ?? (byId.has(p.id) ? { x: players[byId.get(p.id)].x, y: players[byId.get(p.id)].y } : { x: 0, y: 0 });
+      add({ id: p.id, side: p.side, pos: p.pos === "c" || p.pos === "ol" ? "o" : p.pos, label: p.label, x: at.x, y: at.y });
+    }
+    return players;
+  },
+  buildZones(ast) {
+    return ast.zones.map((z) => ({ x: z.x, y: z.y, rx: z.rx, ry: z.ry, label: z.label }));
+  },
+  resolveLandmark(name) {
+    return LANDMARKS[name.toLowerCase()] ?? null;
+  },
+  bounds(_ast, players, moves, zones) {
+    let minX = -25, maxX = 25, minY = 0, maxY = 30;
+    const ext = (x, y) => {
+      minX = Math.min(minX, x);
+      maxX = Math.max(maxX, x);
+      minY = Math.min(minY, y);
+      maxY = Math.max(maxY, y);
+    };
+    for (const p of players) ext(p.x, p.y);
+    for (const mv of moves) for (const pt of mv.points) ext(pt.x, pt.y);
+    for (const z of zones) {
+      ext(z.x - z.rx, z.y - z.ry);
+      ext(z.x + z.rx, z.y + z.ry);
+    }
+    const m = K2.margin;
+    return { minX: Math.min(-25, minX) - m * 0.4, maxX: Math.max(25, maxX) + m * 0.4, minY: Math.min(0, minY) - m * 0.4, maxY: Math.min(K2.half, maxY + m * 0.6) };
+  },
+  drawField(_lay, ctx, t) {
+    const parts = [];
+    const X = ctx.X, Y = ctx.Y, px = ctx.px;
+    parts.push(rect({ class: "sx-pb-court-line", fill: "none", x: r26(X(-8)), y: r26(Y(0)), width: r26(px(2 * K2.laneHalf)), height: r26(px(K2.ftY)) }));
+    parts.push(circle({ class: "sx-pb-court-line", fill: "none", cx: r26(X(0)), cy: r26(Y(K2.ftY)), r: r26(px(K2.ftR)) }));
+    parts.push(line({ class: "sx-pb-court-line", x1: r26(X(-3)), y1: r26(Y(4)), x2: r26(X(3)), y2: r26(Y(4)) }));
+    parts.push(circle({ class: "sx-pb-rim", fill: "none", cx: r26(X(0)), cy: r26(Y(K2.rimY)), r: r26(px(0.75)) }));
+    parts.push(path({ class: "sx-pb-court-line", fill: "none", d: `M ${r26(X(-4))} ${r26(Y(K2.rimY))} A ${r26(px(K2.restrictedR))} ${r26(px(K2.restrictedR))} 0 0 0 ${r26(X(K2.restrictedR))} ${r26(Y(K2.rimY))}` }));
+    parts.push(path({
+      class: "sx-pb-court-line",
+      fill: "none",
+      d: `M ${r26(X(-22))} ${r26(Y(0))} L ${r26(X(-22))} ${r26(Y(K2.cornerMeetY))} A ${r26(px(K2.threeR))} ${r26(px(K2.threeR))} 0 0 0 ${r26(X(K2.cornerX))} ${r26(Y(K2.cornerMeetY))} L ${r26(X(K2.cornerX))} ${r26(Y(0))}`
+    }));
+    parts.push(path({ class: "sx-pb-court-line", fill: "none", d: `M ${r26(X(-6))} ${r26(Y(K2.half))} A ${r26(px(K2.centerR))} ${r26(px(K2.centerR))} 0 0 1 ${r26(X(K2.centerR))} ${r26(Y(K2.half))}` }));
+    return group({ class: "sx-pb-field-g" }, parts);
+  },
+  legend() {
+    return [
+      { kind: "offense", label: "Offense (1\u20135)" },
+      { kind: "defense", label: "Defense (X)" },
+      { kind: "run", label: "Cut" },
+      { kind: "pass", label: "Pass" },
+      { kind: "dribble", label: "Dribble" },
+      { kind: "screen", label: "Screen" }
+    ];
+  }
+};
+
+// src/diagrams/playbook/geometry/soccer.ts
+var K3 = {
+  scale: 8,
+  L: 105,
+  W: 68,
+  circleR: 9.15,
+  paDepth: 16.5,
+  paHalf: 20.16,
+  // 40.32 / 2
+  gaDepth: 5.5,
+  gaHalf: 9.16,
+  // 18.32 / 2
+  penDist: 11,
+  goalHalf: 3.66,
+  // 7.32 / 2
+  cornerR: 1,
+  margin: 3
+};
+var r27 = (n) => Math.round(n * 100) / 100;
+function formationRoster2(formation) {
+  const p = (id, x, y, gk2 = false) => ({ id, label: id, x, y, gk: gk2 });
+  const back4 = [p("2", 20, 12), p("4", 20, 27), p("5", 20, 41), p("3", 20, 56)];
+  const gk = p("1", 5, 34, true);
+  switch (formation) {
+    case "4-4-2":
+      return [gk, ...back4, p("7", 50, 10), p("6", 50, 27), p("8", 50, 41), p("11", 50, 58), p("9", 80, 28), p("10", 80, 40)];
+    case "4-2-3-1":
+      return [gk, ...back4, p("6", 40, 28), p("8", 40, 40), p("7", 65, 12), p("10", 65, 34), p("11", 65, 56), p("9", 85, 34)];
+    case "4-5-1":
+      return [gk, ...back4, p("6", 48, 27), p("8", 48, 41), p("7", 52, 10), p("11", 52, 58), p("10", 62, 34), p("9", 85, 34)];
+    case "4-4-1-1":
+      return [gk, ...back4, p("7", 50, 10), p("6", 50, 27), p("8", 50, 41), p("11", 50, 58), p("10", 68, 34), p("9", 84, 34)];
+    case "3-5-2":
+      return [gk, p("4", 20, 20), p("5", 20, 34), p("6", 20, 48), p("2", 52, 6), p("3", 52, 62), p("8", 50, 25), p("10", 55, 43), p("7", 45, 34), p("9", 82, 28), p("11", 82, 40)];
+    case "3-4-3":
+      return [gk, p("4", 20, 20), p("5", 20, 34), p("6", 20, 48), p("2", 48, 8), p("8", 48, 28), p("10", 48, 40), p("3", 48, 60), p("7", 82, 14), p("9", 82, 34), p("11", 82, 54)];
+    case "4-3-3":
+    default:
+      return [gk, ...back4, p("6", 42, 34), p("8", 52, 24), p("10", 52, 44), p("7", 82, 12), p("9", 82, 34), p("11", 82, 56)];
+  }
+}
+function opponentBlock(scheme) {
+  const cx = scheme === "high-press" ? 45 : scheme === "mid-block" ? 70 : 88;
+  const p = (i, x, y) => ({ id: "X" + i, label: "X", x, y });
+  return [
+    p(1, cx + 12, 34),
+    p(2, cx, 12),
+    p(3, cx, 27),
+    p(4, cx, 41),
+    p(5, cx, 56),
+    p(6, cx - 14, 14),
+    p(7, cx - 14, 28),
+    p(8, cx - 14, 40),
+    p(9, cx - 14, 54),
+    p(10, cx - 26, 28),
+    p(11, cx - 26, 40)
+  ];
+}
+var LANDMARKS2 = {
+  center: { x: 52.5, y: 34 },
+  "centre-spot": { x: 52.5, y: 34 },
+  box: { x: 96, y: 34 },
+  "top-box": { x: 88.5, y: 34 },
+  d: { x: 84.85, y: 34 },
+  "penalty-arc": { x: 84.85, y: 34 },
+  "penalty-spot": { x: 94, y: 34 },
+  "near-post": { x: 105, y: 30.5 },
+  "far-post": { x: 105, y: 37.7 },
+  goal: { x: 105, y: 34 },
+  "rcorner": { x: 105, y: 2 },
+  "lcorner": { x: 105, y: 66 },
+  "six-yard": { x: 101, y: 34 }
+};
+var soccerModule = {
+  scale: K3.scale,
+  yUp: false,
+  buildPlayers(ast) {
+    const players = [];
+    const byId = /* @__PURE__ */ new Map();
+    const add = (pl2) => {
+      if (byId.has(pl2.id)) players[byId.get(pl2.id)] = pl2;
+      else {
+        byId.set(pl2.id, players.length);
+        players.push(pl2);
+      }
+    };
+    for (const sl of formationRoster2(ast.formation)) add({ id: sl.id, side: "offense", pos: sl.gk ? "gk" : "o", label: sl.label, x: sl.x, y: sl.y });
+    if (ast.defense) for (const d of opponentBlock(ast.defense)) add({ id: d.id, side: "defense", pos: "x", label: d.label, x: d.x, y: d.y });
+    for (const pl2 of ast.players) {
+      const at = pl2.at ?? (byId.has(pl2.id) ? { x: players[byId.get(pl2.id)].x, y: players[byId.get(pl2.id)].y } : { x: 0, y: 0 });
+      add({ id: pl2.id, side: pl2.side, pos: pl2.pos === "c" || pl2.pos === "ol" ? "o" : pl2.pos, label: pl2.label, x: at.x, y: at.y });
+    }
+    return players;
+  },
+  buildZones(ast) {
+    return ast.zones.map((z) => ({ x: z.x, y: z.y, rx: z.rx, ry: z.ry, label: z.label }));
+  },
+  resolveLandmark(name) {
+    return LANDMARKS2[name.toLowerCase()] ?? null;
+  },
+  bounds(ast) {
+    const m = K3.margin;
+    if (ast.view === "half") return { minX: 52.5 - m, maxX: K3.L + m, minY: -m, maxY: K3.W + m };
+    return { minX: -m, maxX: K3.L + m, minY: -m, maxY: K3.W + m };
+  },
+  drawField(_lay, ctx, t) {
+    const X = ctx.X, Y = ctx.Y, px = ctx.px;
+    const parts = [];
+    const ln = (x1, y1, x2, y2) => line({ class: "sx-pb-pitch-line", x1: r27(X(x1)), y1: r27(Y(y1)), x2: r27(X(x2)), y2: r27(Y(y2)) });
+    const bands = 10;
+    for (let i = 0; i < bands; i++) {
+      if (i % 2 === 0) continue;
+      parts.push(rect({ class: "sx-pb-stripe", x: r27(X(i * K3.L / bands)), y: r27(Y(0)), width: r27(px(K3.L / bands)), height: r27(px(K3.W)) }));
+    }
+    const cr = px(K3.cornerR);
+    const corners = [[0, 0, 0], [K3.L, 0, 1], [0, K3.W, 2], [K3.L, K3.W, 3]];
+    for (const [cxF, cyF, q] of corners) {
+      const cx = X(cxF), cy = Y(cyF);
+      const sx = cxF === 0 ? 1 : -1;
+      const sy = cyF === 0 ? 1 : -1;
+      parts.push(path({ class: "sx-pb-pitch-line", fill: "none", d: `M ${r27(cx + sx * cr)} ${r27(cy)} A ${r27(cr)} ${r27(cr)} 0 0 ${q === 1 || q === 2 ? 1 : 0} ${r27(cx)} ${r27(cy + sy * cr)}` }));
+    }
+    parts.push(ln(52.5, 0, 52.5, K3.W));
+    parts.push(circle({ class: "sx-pb-pitch-line", fill: "none", cx: r27(X(52.5)), cy: r27(Y(34)), r: r27(px(K3.circleR)) }));
+    parts.push(circle({ class: "sx-pb-pitch-dot", cx: r27(X(52.5)), cy: r27(Y(34)), r: 1.6 }));
+    const topY = (half) => Math.min(Y(34 - half), Y(34 + half));
+    for (const end of [0, 1]) {
+      const gx = end === 0 ? 0 : K3.L;
+      const sgn = end === 0 ? 1 : -1;
+      parts.push(rect({ class: "sx-pb-pitch-line", fill: "none", x: r27(X(Math.min(gx, gx + sgn * K3.paDepth))), y: r27(topY(K3.paHalf)), width: r27(px(K3.paDepth)), height: r27(px(2 * K3.paHalf)) }));
+      parts.push(rect({ class: "sx-pb-pitch-line", fill: "none", x: r27(X(Math.min(gx, gx + sgn * K3.gaDepth))), y: r27(topY(K3.gaHalf)), width: r27(px(K3.gaDepth)), height: r27(px(2 * K3.gaHalf)) }));
+      const spotX = gx + sgn * K3.penDist;
+      parts.push(circle({ class: "sx-pb-pitch-dot", cx: r27(X(spotX)), cy: r27(Y(34)), r: 1.4 }));
+      const edgeX = gx + sgn * K3.paDepth;
+      const dy = Math.sqrt(K3.circleR * K3.circleR - (K3.paDepth - K3.penDist) * (K3.paDepth - K3.penDist));
+      const sweep = end === 0 ? 1 : 0;
+      parts.push(path({ class: "sx-pb-pitch-line", fill: "none", d: `M ${r27(X(edgeX))} ${r27(Y(34 - dy))} A ${r27(px(K3.circleR))} ${r27(px(K3.circleR))} 0 0 ${sweep} ${r27(X(edgeX))} ${r27(Y(34 + dy))}` }));
+      const goalX = gx - sgn * 2.2;
+      parts.push(rect({ class: "sx-pb-goalbox", x: r27(X(Math.min(gx, goalX))), y: r27(topY(K3.goalHalf)), width: r27(px(2.2)), height: r27(px(2 * K3.goalHalf)) }));
+    }
+    return group({ class: "sx-pb-field-g" }, parts);
+  },
+  legend() {
+    return [
+      { kind: "offense", label: "Team" },
+      { kind: "gk", label: "Keeper" },
+      { kind: "defense", label: "Opponent" },
+      { kind: "pass", label: "Pass" },
+      { kind: "run", label: "Run" },
+      { kind: "dribble", label: "Dribble" },
+      { kind: "shot", label: "Shot" }
+    ];
+  }
+};
+
+// src/diagrams/playbook/layout.ts
+var MODULES = {
+  football: footballModule,
+  basketball: basketballModule,
+  soccer: soccerModule
+};
+function sportModule(sport) {
+  return MODULES[sport];
+}
+var round23 = (p) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 });
+function styleFor(sport, kind) {
+  if (kind === "dribble") return "wavy";
+  if (kind === "shot") return sport === "soccer" ? "double" : "solid";
+  if (kind === "pass") return sport === "soccer" ? "solid" : "dashed";
+  if (kind === "motion") return "dashed";
+  if (sport === "soccer" && (kind === "run" || kind === "cut" || kind === "move")) return "dashed";
+  return "solid";
+}
+function endFor(kind, override) {
+  if (override) return override;
+  if (kind === "screen" || kind === "block") return "tee";
+  if (kind === "handoff") return "none";
+  return "arrow";
+}
+function findPlayer(ref, byId) {
+  if (byId.has(ref)) return byId.get(ref);
+  const lower = ref.toLowerCase();
+  for (const [k, v] of byId) if (k.toLowerCase() === lower) return v;
+  return void 0;
+}
+function resolveRef(token, byId, players, mod) {
+  const coord = /^(-?\d*\.?\d+),(-?\d*\.?\d+)$/.exec(token);
+  if (coord) return { x: Number(coord[1]), y: Number(coord[2]) };
+  const pi = findPlayer(token, byId);
+  if (pi !== void 0) return { x: players[pi].x, y: players[pi].y };
+  const lm = mod.resolveLandmark?.(token);
+  if (lm) return { x: lm.x, y: lm.y };
+  return null;
+}
+function layoutPlaybook(ast) {
+  const mod = MODULES[ast.sport];
+  const errors = [];
+  const warnings = [];
+  const players = mod.buildPlayers(ast);
+  const byId = /* @__PURE__ */ new Map();
+  players.forEach((p, i) => byId.set(p.id, i));
+  if (players.length === 0) {
+    errors.push("no players \u2014 add a `formation`/set or explicit `player` statements");
+  }
+  const zones = mod.buildZones(ast, players);
+  const moves = [];
+  for (const m of ast.moves) {
+    const srcIdx = findPlayer(m.player, byId);
+    if (srcIdx === void 0) {
+      warnings.push(`move on unknown player "${m.player}" \u2014 skipped`);
+      continue;
+    }
+    const src = { x: players[srcIdx].x, y: players[srcIdx].y };
+    const named = mod.resolveNamed?.(m, src, players, byId, warnings);
+    if (named) {
+      moves.push(named);
+      continue;
+    }
+    const geom = resolveGeneric(m, src, byId, players, mod, ast.sport, warnings);
+    if (geom) moves.push(geom);
+  }
+  const bounds = mod.bounds(ast, players, moves, zones);
+  return {
+    title: ast.title,
+    sport: ast.sport,
+    down: ast.down,
+    distance: ast.distance,
+    losYard: ast.losYard,
+    toGoal: ast.toGoal,
+    hash: ast.hash,
+    view: ast.view === "half" ? "half" : "full",
+    players,
+    moves,
+    zones,
+    bounds,
+    errors,
+    warnings
+  };
+}
+function resolveGeneric(m, src, byId, players, mod, sport, warnings) {
+  const style = styleFor(sport, m.kind);
+  if (m.points && m.points.length) {
+    const pts = [{ x: src.x, y: src.y }];
+    let cur = { x: src.x, y: src.y };
+    for (const p of m.points) {
+      if (p.ref) {
+        const r6 = resolveRef(p.ref, byId, players, mod);
+        if (!r6) {
+          warnings.push(`${m.kind} ${m.player}: unknown destination "${p.ref}" \u2014 skipped`);
+          return null;
+        }
+        cur = r6;
+      } else if (p.rel) {
+        cur = { x: cur.x + (p.x ?? 0), y: cur.y + (p.y ?? 0) };
+      } else {
+        cur = { x: p.x ?? cur.x, y: p.y ?? cur.y };
+      }
+      pts.push(cur);
+    }
+    return { player: m.player, kind: m.kind, style, points: pts.map(round23), end: endFor(m.kind, m.end) };
+  }
+  let dest = null;
+  if (m.target) dest = resolveRef(m.target, byId, players, mod);
+  else if (m.kind === "shot") dest = mod.resolveLandmark?.("rim") ?? mod.resolveLandmark?.("goal") ?? null;
+  if (!dest) {
+    warnings.push(`${m.kind} ${m.player}: needs a target/destination \u2014 skipped`);
+    return null;
+  }
+  if (m.kind === "screen" || m.kind === "block") {
+    const dx = dest.x - src.x, dy = dest.y - src.y;
+    const len = Math.hypot(dx, dy) || 1;
+    const gap = sport === "football" ? 0.6 : sport === "basketball" ? 1.2 : 1.6;
+    const stop = Math.max(0, len - gap);
+    const end = { x: src.x + dx / len * stop, y: src.y + dy / len * stop };
+    return { player: m.player, kind: m.kind, style, points: [round23(src), round23(end)], end: "tee" };
+  }
+  return { player: m.player, kind: m.kind, style, points: [round23(src), round23(dest)], end: endFor(m.kind, m.end) };
+}
+
+// src/diagrams/playbook/renderer.ts
+var r28 = (n) => Math.round(n * 100) / 100;
+function buildCss14(t) {
+  return `
+.sx-pb { font-family: ${DEFAULT_FONT_FAMILY}; }
+.sx-pb-title { font: ${TITLE.weight} ${TITLE.size}px sans-serif; fill: ${t.text}; }
+.sx-pb-field, .sx-pb-turf { fill: ${t.surface}; }
+.sx-pb-court { fill: ${t.courtSurface}; }
+.sx-pb-surround { fill: ${t.surround}; }
+.sx-pb-surround-court { fill: ${t.courtSurround}; }
+.sx-pb-boundary { fill: none; stroke: ${t.lineBold}; stroke-width: 2.6; }
+.sx-pb-boundary-court { fill: none; stroke: ${t.courtLine}; stroke-width: 2.6; }
+.sx-pb-stripe { fill: ${t.surfaceAlt}; }
+.sx-pb-yard, .sx-pb-pitch-line, .sx-pb-goalbox { fill: none; stroke: ${t.lineSoft}; stroke-width: 1.4; }
+.sx-pb-court-line { fill: none; stroke: ${t.courtLine}; stroke-width: 1.5; }
+.sx-pb-hash { fill: none; stroke: ${t.lineSoft}; stroke-width: 1.2; }
+.sx-pb-los, .sx-pb-goalline { fill: none; stroke: ${t.lineBold}; stroke-width: 2.4; }
+.sx-pb-goalline { stroke: ${t.goalAccent}; }
+.sx-pb-goalpost { fill: none; stroke: ${t.goalAccent}; stroke-width: 2.4; stroke-linecap: round; }
+.sx-pb-endzone { fill: ${t.endzoneFill}; }
+.sx-pb-yardnum { font: 600 11px sans-serif; fill: ${t.surfaceText}; }
+.sx-pb-rim { stroke: ${t.rim}; stroke-width: 2.4; }
+.sx-pb-pitch-dot { fill: ${t.lineBold}; }
+.sx-pb-zone { fill: ${t.zoneFill}; stroke: ${t.zoneStroke}; stroke-width: 1.3; stroke-dasharray: 5 4; }
+.sx-pb-zone-text { font: 9px sans-serif; fill: ${t.zoneStroke}; }
+.sx-pb-move { fill: none; stroke: ${t.moveStroke}; stroke-width: 2.4; stroke-linejoin: round; stroke-linecap: round; }
+.sx-pb-move-dash { fill: none; stroke: ${t.moveStroke}; stroke-width: 2.2; stroke-dasharray: 6 4; stroke-linejoin: round; stroke-linecap: round; }
+.sx-pb-shot { fill: none; stroke: ${t.shotStroke}; stroke-width: 3.4; stroke-linecap: round; }
+.sx-pb-motion { fill: none; stroke: ${t.motionStroke}; stroke-width: 1.9; stroke-dasharray: 4 3; }
+.sx-pb-move-fill { fill: ${t.moveStroke}; stroke: none; }
+.sx-pb-shot-fill { fill: ${t.shotStroke}; stroke: none; }
+.sx-pb-motion-fill { fill: ${t.motionStroke}; stroke: none; }
+.sx-pb-o { fill: ${t.offenseFill}; stroke: ${t.offenseStroke}; stroke-width: 2; }
+.sx-pb-gk { fill: ${t.gkFill}; stroke: ${t.offenseStroke}; stroke-width: 2; }
+.sx-pb-o-text { font: 700 10.5px sans-serif; fill: ${t.offenseLabel}; }
+.sx-pb-x { fill: none; stroke: ${t.defenseStroke}; stroke-width: 2.6; stroke-linecap: round; }
+.sx-pb-x-text { font: 700 9px sans-serif; fill: ${t.defenseStroke}; }
+.sx-pb-ball { fill: ${t.ballFill}; stroke: ${t.lineBold}; stroke-width: 0.8; }
+.sx-pb-anno { font: 600 12px sans-serif; fill: ${t.annotation}; }
+.sx-pb-legend { font: 11px sans-serif; fill: ${t.annotation}; }
+.sx-pb-error-box { fill: ${t.bg}; stroke: ${t.negative}; stroke-width: 1.5; }
+.sx-pb-error-title { font: 700 13px ui-monospace, Menlo, monospace; fill: ${t.negative}; }
+.sx-pb-error-line { font: 12px ui-monospace, Menlo, monospace; fill: ${t.negative}; }
+`.trim();
+}
+function renderErrorPanel2(lay, t) {
+  const lines = lay.errors;
+  const w = Math.max(520, ...lines.map((l) => l.length * 6.6 + 48));
+  const h = 56 + lines.length * 19;
+  return svgRoot(
+    { viewBox: `0 0 ${r28(w)} ${h}`, width: r28(w), height: h, class: "sx-pb", role: "img" },
+    [
+      title(lay.title),
+      desc(`Playbook validation failed with ${lines.length} error${lines.length === 1 ? "" : "s"}.`),
+      el("style", {}, buildCss14(t)),
+      rect({ class: "sx-pb-error-box", x: 1, y: 1, width: r28(w - 2), height: h - 2, rx: 6 }),
+      text({ class: "sx-pb-error-title", x: 16, y: 26 }, `playbook: ${lines.length} validation error${lines.length === 1 ? "" : "s"}`),
+      ...lines.map((e, i) => text({ class: "sx-pb-error-line", x: 16, y: 50 + i * 19 }, `\u26A0 ${e}`))
+    ]
+  );
+}
+function wavyPath(pts, amp = 3.4, wl = 11) {
+  const flat = [];
+  let acc = 0;
+  for (let i = 1; i < pts.length; i++) {
+    const a = pts[i - 1], b = pts[i];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const segLen = Math.hypot(dx, dy) || 1;
+    const ux = dx / segLen, uy = dy / segLen;
+    const nx = -uy, ny = ux;
+    const lastSeg = i === pts.length - 1;
+    const straightTail = lastSeg ? 9 : 0;
+    const usable = Math.max(0, segLen - straightTail);
+    const steps = Math.max(2, Math.round(usable / 2));
+    for (let s = 0; s <= steps; s++) {
+      const d = usable * s / steps;
+      const off = amp * Math.sin(2 * Math.PI * (acc + d) / wl);
+      flat.push({ x: a.x + ux * d + nx * off, y: a.y + uy * d + ny * off });
+    }
+    acc += usable;
+    if (lastSeg) flat.push({ x: b.x, y: b.y });
+  }
+  return flat.map((p, i) => `${i === 0 ? "M" : "L"} ${r28(p.x)} ${r28(p.y)}`).join(" ");
+}
+function arrowHead4(pts, cls) {
+  if (pts.length < 2) return "";
+  const a = pts[pts.length - 2], b = pts[pts.length - 1];
+  const ang = Math.atan2(b.y - a.y, b.x - a.x);
+  const size = 8, wing = 0.42;
+  const p2 = `${r28(b.x - size * Math.cos(ang - wing))},${r28(b.y - size * Math.sin(ang - wing))}`;
+  const p3 = `${r28(b.x - size * Math.cos(ang + wing))},${r28(b.y - size * Math.sin(ang + wing))}`;
+  return polygon({ class: cls, points: `${r28(b.x)},${r28(b.y)} ${p2} ${p3}` });
+}
+function teeBar(pts, cls) {
+  if (pts.length < 2) return "";
+  const a = pts[pts.length - 2], b = pts[pts.length - 1];
+  const ang = Math.atan2(b.y - a.y, b.x - a.x) + Math.PI / 2;
+  const half = 7;
+  return line({ class: cls, x1: r28(b.x - half * Math.cos(ang)), y1: r28(b.y - half * Math.sin(ang)), x2: r28(b.x + half * Math.cos(ang)), y2: r28(b.y + half * Math.sin(ang)) });
+}
+function renderMove(mv, ctx) {
+  const pts = mv.points.map((p) => ({ x: ctx.X(p.x), y: ctx.Y(p.y) }));
+  const strokeCls = mv.kind === "motion" ? "sx-pb-motion" : mv.kind === "shot" ? "sx-pb-shot" : mv.style === "dashed" ? "sx-pb-move-dash" : "sx-pb-move";
+  const headCls = mv.kind === "motion" ? "sx-pb-motion-fill" : mv.kind === "shot" ? "sx-pb-shot-fill" : "sx-pb-move-fill";
+  const parts = [];
+  if (mv.style === "wavy") {
+    parts.push(path({ class: strokeCls, d: wavyPath(pts) }));
+  } else {
+    parts.push(path({ class: strokeCls, d: pts.map((p, i) => `${i === 0 ? "M" : "L"} ${r28(p.x)} ${r28(p.y)}`).join(" ") }));
+  }
+  if (mv.end === "arrow") parts.push(arrowHead4(pts, headCls));
+  else if (mv.end === "tee") parts.push(teeBar(pts, strokeCls));
+  return group({ class: "sx-pb-move-g", "data-kind": mv.kind, "data-player": mv.player }, parts);
+}
+function playerSymbol(p, ctx) {
+  const cx = ctx.X(p.x), cy = ctx.Y(p.y), r6 = 10;
+  const parts = [];
+  if (p.side === "defense" || p.pos === "x") {
+    const k = r6 * 0.78;
+    parts.push(line({ class: "sx-pb-x", x1: r28(cx - k), y1: r28(cy - k), x2: r28(cx + k), y2: r28(cy + k) }));
+    parts.push(line({ class: "sx-pb-x", x1: r28(cx - k), y1: r28(cy + k), x2: r28(cx + k), y2: r28(cy - k) }));
+    if (p.label) parts.push(text({ class: "sx-pb-x-text", x: r28(cx + k + 5), y: r28(cy - k + 2), "text-anchor": "middle" }, p.label));
+  } else if (p.pos === "gk") {
+    const h = r6 * 1.15;
+    parts.push(polygon({ class: "sx-pb-gk", points: `${r28(cx)},${r28(cy - h)} ${r28(cx + h)},${r28(cy + h * 0.8)} ${r28(cx - h)},${r28(cy + h * 0.8)}` }));
+    parts.push(text({ class: "sx-pb-o-text", x: r28(cx), y: r28(cy + 6), "text-anchor": "middle" }, p.label));
+  } else if (p.pos === "c") {
+    parts.push(rect({ class: "sx-pb-o", x: r28(cx - r6 * 0.82), y: r28(cy - r6 * 0.82), width: r28(r6 * 1.64), height: r28(r6 * 1.64) }));
+    parts.push(text({ class: "sx-pb-o-text", x: r28(cx), y: r28(cy + 3.6), "text-anchor": "middle" }, p.label));
+  } else {
+    parts.push(circle({ class: "sx-pb-o", cx: r28(cx), cy: r28(cy), r: r6 }));
+    parts.push(text({ class: "sx-pb-o-text", x: r28(cx), y: r28(cy + 3.6), "text-anchor": "middle" }, p.label));
+  }
+  return group({ class: "sx-pb-player", "data-side": p.side, "data-id": p.id }, parts);
+}
+function legendSwatch(kind, sport) {
+  const moveCls = (dashed) => dashed ? "sx-pb-move-dash" : "sx-pb-move";
+  const arrow2 = polygon({ class: "sx-pb-move-fill", points: "20,0 13,-3.5 13,3.5" });
+  switch (kind) {
+    case "offense":
+      return circle({ class: "sx-pb-o", cx: 8, cy: 0, r: 6 });
+    case "gk":
+      return polygon({ class: "sx-pb-gk", points: "8,-7 15,5 1,5" });
+    case "defense":
+      return `${line({ class: "sx-pb-x", x1: 3, y1: -5, x2: 13, y2: 5 })}${line({ class: "sx-pb-x", x1: 3, y1: 5, x2: 13, y2: -5 })}`;
+    case "run":
+      return `${line({ class: moveCls(sport === "soccer"), x1: 0, y1: 0, x2: 14, y2: 0 })}${arrow2}`;
+    case "pass":
+      return `${line({ class: moveCls(sport !== "soccer"), x1: 0, y1: 0, x2: 14, y2: 0 })}${arrow2}`;
+    case "dribble":
+      return `${path({ class: "sx-pb-move", d: "M0,0 Q3,-4 6,0 T12,0" })}${polygon({ class: "sx-pb-move-fill", points: "20,0 13,-3.5 13,3.5" })}`;
+    case "screen":
+      return `${line({ class: "sx-pb-move", x1: 0, y1: 0, x2: 16, y2: 0 })}${line({ class: "sx-pb-move", x1: 16, y1: -5, x2: 16, y2: 5 })}`;
+    case "shot":
+      return `${line({ class: "sx-pb-shot", x1: 0, y1: 0, x2: 14, y2: 0 })}${polygon({ class: "sx-pb-shot-fill", points: "20,0 13,-3.5 13,3.5" })}`;
+    case "motion":
+      return `${line({ class: "sx-pb-motion", x1: 0, y1: 0, x2: 14, y2: 0 })}${polygon({ class: "sx-pb-motion-fill", points: "20,0 13,-3.5 13,3.5" })}`;
+    case "zone":
+      return rect({ class: "sx-pb-zone", x: 0, y: -6, width: 18, height: 12, rx: 6 });
+    default:
+      return "";
+  }
+}
+function renderLegend4(items, y, sport) {
+  const parts = [];
+  let cx = 12;
+  for (const it of items) {
+    parts.push(group({ transform: `translate(${r28(cx)},${r28(y)})` }, [legendSwatch(it.kind, sport)]));
+    parts.push(text({ class: "sx-pb-legend", x: r28(cx + 26), y: r28(y + 4) }, it.label));
+    cx += 26 + it.label.length * 6.5 + 20;
+  }
+  return group({ class: "sx-pb-legend-g" }, parts);
+}
+function ordinal(n) {
+  return n === 1 ? "1st" : n === 2 ? "2nd" : n === 3 ? "3rd" : n === 4 ? "4th" : `${n}th`;
+}
+function renderPlaybookLayout(lay, config) {
+  let themeName = config?.theme ?? "default";
+  if (lay.sport === "soccer" && themeName === "dark") themeName = "default";
+  const t = resolvePlaybookTheme(themeName);
+  if (lay.errors.length > 0) return renderErrorPanel2(lay, t);
+  const mod = sportModule(lay.sport);
+  const scale = mod.scale;
+  const b = lay.bounds;
+  const titleH = TITLE.bandH;
+  const annoH = lay.sport === "football" && (lay.down || lay.distance || lay.losYard !== void 0) ? 20 : 0;
+  const topH = titleH + annoH;
+  const legendH = 30;
+  const EDGE = 16;
+  const fieldW = (b.maxX - b.minX) * scale;
+  const fieldH = (b.maxY - b.minY) * scale;
+  const W2 = r28(fieldW + EDGE * 2);
+  const fieldTop = topH + EDGE;
+  const H2 = r28(fieldH + topH + EDGE * 2 + legendH);
+  const X = (u) => r28((u - b.minX) * scale + EDGE);
+  const Y = (v) => r28(mod.yUp ? (b.maxY - v) * scale + fieldTop : (v - b.minY) * scale + fieldTop);
+  const px = (u) => r28(u * scale);
+  const ctx = { X, Y, px };
+  const isCourt = lay.sport === "basketball";
+  const surfaceCls = isCourt ? "sx-pb-court" : lay.sport === "soccer" ? "sx-pb-turf" : "sx-pb-field";
+  const surroundCls = isCourt ? "sx-pb-surround-court" : "sx-pb-surround";
+  const boundaryCls = isCourt ? "sx-pb-boundary-court" : "sx-pb-boundary";
+  const fieldRx = 7;
+  const surround = rect({ class: surroundCls, x: 2, y: r28(topH), width: r28(W2 - 4), height: r28(fieldH + EDGE * 2), rx: 12 });
+  const surfaceBase = rect({ class: surfaceCls, x: EDGE, y: r28(fieldTop), width: r28(fieldW), height: r28(fieldH), rx: fieldRx });
+  const boundary = rect({ class: boundaryCls, x: EDGE, y: r28(fieldTop), width: r28(fieldW), height: r28(fieldH), rx: fieldRx });
+  const clipId = "sx-pb-clip";
+  const clip6 = el("clipPath", { id: clipId }, [rect({ x: EDGE, y: r28(fieldTop), width: r28(fieldW), height: r28(fieldH), rx: fieldRx })]);
+  const field = group({ "clip-path": `url(#${clipId})` }, [mod.drawField(lay, ctx, t)]);
+  const zones = [];
+  for (const z of lay.zones) {
+    zones.push(el("ellipse", { class: "sx-pb-zone", cx: X(z.x), cy: Y(z.y), rx: px(z.rx), ry: px(z.ry) }));
+    if (z.label) zones.push(text({ class: "sx-pb-zone-text", x: X(z.x), y: r28(Y(z.y) - px(z.ry) + (mod.yUp ? 11 : -4)), "text-anchor": "middle" }, z.label));
+  }
+  const moves = lay.moves.map((m) => renderMove(m, ctx));
+  const players = lay.players.map((p) => playerSymbol(p, ctx));
+  const ball = lay.sport === "football" ? el("ellipse", { class: "sx-pb-ball", cx: X(0), cy: Y(0), rx: 4.5, ry: 2.7 }) : "";
+  const annoParts = [];
+  if (annoH) {
+    const bits = [];
+    if (lay.down) bits.push(ordinal(lay.down) + (lay.distance ? ` & ${lay.distance}` : ""));
+    else if (lay.distance) bits.push(`${lay.distance} to go`);
+    if (lay.losYard !== void 0) bits.push(`ball on ${lay.losYard}`);
+    annoParts.push(text({ class: "sx-pb-anno", x: 8, y: titleH + 14 }, bits.join("   \xB7   ")));
+  }
+  const nOff = lay.players.filter((p) => p.side === "offense").length;
+  const nDef = lay.players.filter((p) => p.side === "defense").length;
+  const descText = `${lay.sport} play. ${nOff} ${lay.sport === "football" ? "offensive players" : "players"}, ${nDef} ${lay.sport === "football" ? "defenders" : "opponents"}, ${lay.moves.length} assignment${lay.moves.length === 1 ? "" : "s"}.` + (lay.warnings.length ? ` Warnings: ${lay.warnings.join("; ")}.` : "");
+  return svgRoot(
+    { viewBox: `0 0 ${W2} ${H2}`, width: W2, height: H2, class: "sx-pb", role: "img" },
+    [
+      title(lay.title),
+      desc(descText),
+      el("style", {}, buildCss14(t)),
+      rect({ fill: t.bg, x: 0, y: 0, width: W2, height: H2 }),
+      el("defs", {}, [clip6]),
+      text({ class: "sx-pb-title", x: r28(W2 / 2), y: TITLE.y, "text-anchor": "middle" }, lay.title),
+      ...annoParts,
+      surround,
+      surfaceBase,
+      field,
+      group({ class: "sx-pb-zones", "clip-path": `url(#${clipId})` }, zones),
+      group({ class: "sx-pb-moves" }, moves),
+      boundary,
+      group({ class: "sx-pb-players" }, players),
+      ball,
+      renderLegend4(mod.legend(lay), fieldH + topH + EDGE * 2 + 18, lay.sport)
+    ]
+  );
+}
+function renderPlaybook(text2, config) {
+  return renderPlaybookLayout(layoutPlaybook(parsePlaybook(text2)), config);
+}
+
+// src/diagrams/playbook/index.ts
+var playbook = {
+  type: "playbook",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (!t) continue;
+      if (t.startsWith("#") || t.startsWith("//")) continue;
+      return /^playbook\b/i.test(t);
+    }
+    return false;
+  },
+  parse: parsePlaybook,
+  render(text2, config) {
+    return renderPlaybook(text2, config);
+  },
+  lint(text2) {
+    try {
+      const lay = layoutPlaybook(parsePlaybook(text2));
+      return [
+        ...lay.errors.map(
+          (message) => ({
+            severity: "error",
+            code: "playbook/validation",
+            message,
+            fatal: false
+          })
+        ),
+        ...lay.warnings.map(
+          (message) => ({
+            severity: "warning",
+            code: "playbook/warning",
+            message,
+            fatal: false
+          })
+        )
+      ];
+    } catch {
+      return [];
+    }
+  }
+};
+
 // src/core/api.ts
 var plugins = [
   genogram,
@@ -38520,7 +40040,8 @@ var plugins = [
   idef0,
   threatmodel,
   welding,
-  floorplan
+  floorplan,
+  playbook
 ];
 function detectPlugin(text2, config) {
   if (config?.type) {
@@ -38531,7 +40052,7 @@ function detectPlugin(text2, config) {
     if (plugin.detect(text2)) return plugin;
   }
   throw new Error(
-    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', 'orgchart', 'state', 'pid', 'erd', 'breadboard', 'bpmn', 'fbd', 'sfc', 'prisma', 'usecase', 'pert', 'sequence', 'petri', 'network', 'umlclass', 'faulttree', 'bowtie', or 'floorplan'."
+    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', 'orgchart', 'state', 'pid', 'erd', 'breadboard', 'bpmn', 'fbd', 'sfc', 'prisma', 'usecase', 'pert', 'sequence', 'petri', 'network', 'umlclass', 'faulttree', 'bowtie', 'floorplan', or 'playbook'."
   );
 }
 function stripCodeFences(text2) {
@@ -38669,5 +40190,5 @@ function renderWithPlugin(prepared, plugin, config) {
 }
 
 export { FLOORPLAN_SYMBOLS, GEOMETRY, bowtie2 as bowtie, causalloop, decisiontree, drawDeviceIcon, epc, eventtree, faulttree, fmea, gitgraph, iconSize, idef0, markov, network, parse, parseResult, pert, petri, pid, prisma, render, renderEquip, renderPreview, renderResult, sequence, state, threatmodel, timeline, umlclass, usecase, welding };
-//# sourceMappingURL=chunk-BP6MLXJU.js.map
-//# sourceMappingURL=chunk-BP6MLXJU.js.map
+//# sourceMappingURL=chunk-UFXDAIDD.js.map
+//# sourceMappingURL=chunk-UFXDAIDD.js.map