@markdy/core 0.7.28 → 0.8.0

package/dist/index.js

@@ -1,304 +1,3 @@
-// src/presets.ts
-function quote(s) {
-  const stripped = s.replace(/^"|"$/g, "");
-  return `"${stripped.replace(/"/g, '\\"')}"`;
-}
-var PRESETS = {
-  meme: (args) => {
-    const top = quote(args[0] ?? "when the code works");
-    const bottom = quote(args[1] ?? "and you don't know why");
-    return `scene width=720 height=720 bg=#111
-
-actor top    = caption(${top}) at top
-actor hero   = figure(#c68642, m, \u{1F60E}) at (360, 430)
-actor bottom = caption(${bottom}) at bottom
-
-@0.0: top.fade_in(dur=0.4)
-@0.4: hero.enter(from=bottom, dur=0.6)
-@1.2: hero.face("\u{1F602}")
-@1.8: bottom.fade_in(dur=0.4)
-@3.2: hero.bounce(intensity=20, count=2, dur=0.8)
-`;
-  },
-  explainer: (args) => {
-    const title = quote(args[0] ?? "how it works");
-    return `scene width=960 height=540 bg=#0d1117
-
-actor title = caption(${title}) at top
-actor hero  = figure(#c68642, m, \u{1F60E}) at (480, 360)
-
-scene "intro" {
-  @+0.0: title.fade_in(dur=0.5)
-  @+1.0: hero.enter(from=bottom, dur=0.5)
-}
-
-scene "body" {
-  @+0.0: camera.zoom(to=1.2, dur=0.8)
-  @+1.0: hero.wave(side=right, dur=0.5)
-}
-`;
-  },
-  reaction: (args) => {
-    const line = quote(args[0] ?? "wait, what?");
-    return `scene width=720 height=720 bg=#fff5f9
-
-actor hero = figure(#c68642, m, \u{1F642}) at (360, 380)
-
-@0.0: hero.enter(from=left, dur=0.4)
-@0.5: hero.face("\u{1F633}")
-@0.5: hero.say(${line}, dur=1.4)
-@2.0: hero.face("\u{1F602}")
-@2.0: hero.shake(intensity=6, dur=0.5)
-`;
-  },
-  pov: (args) => {
-    const pov = quote(args[0] ?? "POV: you hit ship");
-    return `scene width=720 height=960 bg=#0d1117
-
-actor label = caption(${pov}) at top
-actor hero  = figure(#c68642, m, \u{1F60E}) at (360, 600)
-
-@0.0: label.fade_in(dur=0.4)
-@0.4: hero.enter(from=bottom, dur=0.6)
-@1.2: hero.pose(arm_left=70, arm_right=-70, dur=0.3)
-@1.2: hero.face("\u{1F525}")
-`;
-  },
-  typing: (args) => {
-    const text = quote(args[0] ?? "hello world");
-    return `scene width=800 height=300 bg=#0f1115
-
-actor cursor = text("|") at (120, 150) size 40 opacity 0
-actor line   = text(${text}) at (140, 150) size 32 opacity 0
-
-@0.0:  cursor.fade_in(dur=0.15)
-@+0.1: cursor.fade_out(dur=0.15)
-@+0.0: cursor.fade_in(dur=0.15)
-@+0.1: cursor.fade_out(dur=0.15)
-@+0.0: cursor.fade_in(dur=0.15)
-@+0.0: line.fade_in(dur=0.8)
-@+0.3: cursor.fade_out(dur=0.3)
-`;
-  },
-  terminal: (args) => {
-    const cmd = quote(args[0] ?? "$ npx markdy");
-    const output = quote(args[1] ?? "playground ready at http://localhost:4242");
-    return `scene width=960 height=420 bg=#0d1117
-
-actor prompt = text(${cmd})    at (60, 140) size 24 opacity 0
-actor result = text(${output}) at (60, 200) size 22 opacity 0
-
-@0.0: prompt.fade_in(dur=0.4)
-@1.0: result.fade_in(dur=0.4)
-`;
-  },
-  chat_bubble: (args) => {
-    const a = quote(args[0] ?? "how do I animate this?");
-    const b = quote(args[1] ?? "ask markdy.");
-    return `scene width=800 height=400 bg=#f6f7fb
-
-actor alice = figure(#fad4c0, f, \u{1F642}) at (180, 240)
-actor bob   = figure(#c68642, m, \u{1F642}) at (620, 240)
-
-@0.0: alice.enter(from=left, dur=0.4)
-@0.2: bob.enter(from=right, dur=0.4)
-@0.8: alice.say(${a}, dur=1.8)
-@2.6: bob.face("\u{1F60E}")
-@2.6: bob.say(${b}, dur=1.6)
-`;
-  },
-  vs: (args) => {
-    const left = quote(args[0] ?? "team a");
-    const right = quote(args[1] ?? "team b");
-    return `scene width=960 height=540 bg=#111
-
-actor a = caption(${left})  at top
-actor b = caption(${right}) at bottom
-actor lf = figure(#c68642, m, \u{1F624}) at (260, 320)
-actor rf = figure(#8d5524, m, \u{1F60F}) at (700, 320)
-
-@0.0: a.fade_in(dur=0.3)
-@0.0: b.fade_in(dur=0.3)
-@0.3: lf.enter(from=left, dur=0.5)
-@0.3: rf.enter(from=right, dur=0.5)
-@1.2: lf.punch(side=right, dur=0.3)
-@1.3: rf.shake(intensity=8, dur=0.4)
-`;
-  },
-  tutorial_step: (args) => {
-    const n = quote(args[0] ?? "Step 1");
-    const body = quote(args[1] ?? "open your editor");
-    return `scene width=960 height=420 bg=white
-
-actor step  = caption(${n}) at top
-actor descr = text(${body}) at (100, 220) size 32 opacity 0
-
-@0.0: step.fade_in(dur=0.4)
-@0.5: descr.fade_in(dur=0.4)
-@1.2: descr.move(to=(120, 220), dur=0.5, ease=out)
-`;
-  },
-  countdown: (args) => {
-    const to = quote(args[0] ?? "launch");
-    return `scene width=600 height=600 bg=#0d1117
-
-actor three = text("3") at (270, 280) size 120 opacity 0
-actor two   = text("2") at (270, 280) size 120 opacity 0
-actor one   = text("1") at (270, 280) size 120 opacity 0
-actor go    = caption(${to}) at center
-
-@0.0: three.fade_in(dur=0.2)
-@0.9: three.fade_out(dur=0.2)
-@0.9: two.fade_in(dur=0.2)
-@1.8: two.fade_out(dur=0.2)
-@1.8: one.fade_in(dur=0.2)
-@2.7: one.fade_out(dur=0.2)
-@2.7: go.fade_in(dur=0.4)
-`;
-  },
-  reveal: (args) => {
-    const secret = quote(args[0] ?? "and that's the trick");
-    return `scene width=800 height=450 bg=#0d1117
-
-actor cover  = box() at (350, 175) scale 10 opacity 1
-actor reveal = caption(${secret}) at center
-
-@0.4: cover.fade_out(dur=0.5)
-@0.4: reveal.fade_in(dur=0.5)
-`;
-  },
-  glitch: (_args) => {
-    const txt = quote("GLITCH");
-    return `scene width=800 height=400 bg=#000
-
-actor t = text(${txt}) at (260, 170) size 72
-
-@0.0: t.fade_in(dur=0.2)
-@0.4: t.shake(intensity=10, dur=0.3)
-@0.8: t.shake(intensity=6, dur=0.3)
-@1.3: t.fade_out(dur=0.3)
-`;
-  },
-  zoom_punchline: (args) => {
-    const line = quote(args[0] ?? "the punchline");
-    return `scene width=800 height=450 bg=#0d1117
-
-actor line = caption(${line}) at center
-
-@0.0: line.fade_in(dur=0.4)
-@0.6: camera.zoom(to=1.4, dur=0.8, ease=out)
-@1.6: camera.shake(intensity=6, dur=0.4)
-`;
-  },
-  before_after: (args) => {
-    const before = quote(args[0] ?? "before");
-    const after = quote(args[1] ?? "after");
-    return `scene width=960 height=420 bg=#f6f7fb
-
-actor a    = caption(${before}) at top
-actor b    = caption(${after})  at bottom
-actor dude = figure(#c68642, m, \u{1F635}) at (480, 240)
-
-@0.0: a.fade_in(dur=0.3)
-@0.0: dude.enter(from=left, dur=0.5)
-@1.4: dude.face("\u{1F60E}")
-@1.4: b.fade_in(dur=0.3)
-`;
-  },
-  tier_list: (_args) => {
-    return `scene width=960 height=540 bg=#111
-
-actor s     = text("S") at (60, 90)  size 72 opacity 0
-actor a     = text("A") at (60, 200) size 72 opacity 0
-actor b     = text("B") at (60, 310) size 72 opacity 0
-actor c     = text("C") at (60, 420) size 72 opacity 0
-actor title = caption("tier list") at top
-
-@0.0: title.fade_in(dur=0.3)
-@0.3: s.fade_in(dur=0.2)
-@0.6: a.fade_in(dur=0.2)
-@0.9: b.fade_in(dur=0.2)
-@1.2: c.fade_in(dur=0.2)
-`;
-  }
-};
-var PRESET_NAMES = Object.keys(PRESETS);
-
-// src/registry.ts
-var BUILTIN_ACTOR_TYPES = [
-  "sprite",
-  "text",
-  "box",
-  "figure",
-  "caption"
-];
-var UNIVERSAL_ACTION_NAMES = [
-  "enter",
-  "exit",
-  "move",
-  "spring",
-  "follow_path",
-  "fade_in",
-  "fade_out",
-  "scale",
-  "rotate",
-  "shake",
-  "pulse",
-  "glow",
-  "ripple",
-  "blur",
-  "line_reveal",
-  "mask",
-  "parallax",
-  "say",
-  "throw",
-  "play"
-];
-var FIGURE_ONLY_ACTION_NAMES = [
-  "punch",
-  "kick",
-  "wave",
-  "nod",
-  "jump",
-  "bounce",
-  "face",
-  "rotate_part",
-  "pose"
-];
-var CAMERA_ACTION_NAMES = ["pan", "zoom", "shake"];
-var UNIVERSAL_ACTIONS = new Set(UNIVERSAL_ACTION_NAMES);
-var FIGURE_ONLY_ACTIONS = new Set(FIGURE_ONLY_ACTION_NAMES);
-var CAMERA_ACTIONS = new Set(CAMERA_ACTION_NAMES);
-var actorTypes = new Set(BUILTIN_ACTOR_TYPES);
-var actorActions = /* @__PURE__ */ new Map();
-function registerActorPack(pack) {
-  for (const actor of pack.actors) {
-    actorTypes.add(actor);
-    if (!actorActions.has(actor)) actorActions.set(actor, /* @__PURE__ */ new Set());
-  }
-  if (!pack.actions) return;
-  for (const [actorType, actions] of Object.entries(pack.actions)) {
-    actorTypes.add(actorType);
-    const known = actorActions.get(actorType) ?? /* @__PURE__ */ new Set();
-    for (const action of actions) known.add(action);
-    actorActions.set(actorType, known);
-  }
-}
-function isKnownActorType(type) {
-  return actorTypes.has(type);
-}
-function isFigureOnlyAction(action) {
-  return FIGURE_ONLY_ACTIONS.has(action);
-}
-function isCameraAction(action) {
-  return CAMERA_ACTIONS.has(action);
-}
-function isKnownAction(actorType, action) {
-  if (UNIVERSAL_ACTIONS.has(action)) return true;
-  if (actorType === "figure" && FIGURE_ONLY_ACTIONS.has(action)) return true;
-  return actorActions.get(actorType)?.has(action) ?? false;
-}
-
 // src/system-vocabulary.ts
 var TECHNICAL_NODE_TYPES = [
   "service",
@@ -642,999 +341,785 @@ var TECHNICAL_NODE_KINDS = {
   lock: "distributed"
 };
 
-// src/parser.ts
-var ParseError = class extends Error {
-  constructor(message, line) {
-    super(`Line ${line}: ${message}`);
-    this.line = line;
-    this.name = "ParseError";
-  }
-  line;
+// src/registry.ts
+var NODE_KINDS = new Set(TECHNICAL_NODE_TYPES);
+var EDGE_OPERATORS = {
+  "->": "request",
+  "<-": "response",
+  "~>": "event",
+  "--": "dependency"
 };
-function stripComment(line) {
-  let depth = 0;
-  let stringQuote = null;
-  let lastNonSpace = "";
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if ((ch === '"' || ch === "'") && !isEscapedChar(line, i)) {
-      if (stringQuote === ch) stringQuote = null;
-      else if (stringQuote === null) stringQuote = ch;
-      lastNonSpace = ch;
-      continue;
-    }
-    if (stringQuote !== null) continue;
-    if (ch === "(") {
-      depth++;
-      lastNonSpace = ch;
-      continue;
-    }
-    if (ch === ")") {
-      depth--;
-      lastNonSpace = ch;
-      continue;
-    }
-    if (ch === "#" && depth === 0 && lastNonSpace !== "=") return line.slice(0, i);
-    if (ch !== " " && ch !== "	") lastNonSpace = ch;
-  }
-  return line;
+var BEAT_CUE_KEYWORDS = /* @__PURE__ */ new Set(["show", "hide", "glow", "focus", "use"]);
+var SCENE_KEYS = /* @__PURE__ */ new Set(["width", "height", "fps", "theme", "duration", "direction"]);
+function nodeRole(kind) {
+  return TECHNICAL_NODE_KINDS[kind] ?? "compute";
 }
-function splitByComma(s) {
-  const parts = [];
-  let depth = 0;
-  let stringQuote = null;
-  let start = 0;
-  for (let i = 0; i < s.length; i++) {
-    const ch = s[i];
-    if ((ch === '"' || ch === "'") && !isEscapedChar(s, i)) {
-      if (stringQuote === ch) stringQuote = null;
-      else if (stringQuote === null) stringQuote = ch;
-      continue;
-    }
-    if (stringQuote !== null) continue;
-    if (ch === "(") depth++;
-    else if (ch === ")") depth--;
-    else if (ch === "," && depth === 0) {
-      parts.push(s.slice(start, i));
-      start = i + 1;
-    }
-  }
-  parts.push(s.slice(start));
-  return parts;
+function humanizeId(id) {
+  return id.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
-function parseValue(s) {
-  const t = s.trim();
-  const quoted = parseQuotedLiteral(t);
-  if (quoted !== null) {
-    return quoted;
-  }
-  if (t.startsWith("(") && t.endsWith(")")) {
-    const inner = t.slice(1, -1);
-    return inner.split(",").map((p) => {
-      const v = p.trim();
-      const n2 = Number(v);
-      return Number.isNaN(n2) ? v : n2;
-    });
-  }
-  const n = Number(t);
-  if (!Number.isNaN(n) && t !== "") return n;
-  return t;
+var NODE_ALIASES = {
+  db: "database",
+  api: "service",
+  gateway: "api_gateway",
+  mq: "queue",
+  k8s: "cluster",
+  lb: "load_balancer"
+};
+function canonicalNodeKind(kind) {
+  return NODE_ALIASES[kind] ?? kind;
 }
-function isEscapedChar(s, idx) {
-  let slashCount = 0;
-  for (let i = idx - 1; i >= 0 && s[i] === "\\"; i--) {
-    slashCount++;
+
+// src/compiler.ts
+var SAFE = 64;
+var TITLE_BAND = 96;
+var NODE_W = 184;
+var NODE_H = 88;
+var DEFAULTS = {
+  show: 0.35,
+  hide: 0.35,
+  flow: 0.55,
+  glow: 0.45,
+  focus: 0.6,
+  beatGap: 0.14,
+  cueGap: 0.08,
+  stagger: 0.06
+};
+function collectStructuralEdges(ast) {
+  const edges = [...ast.edges.map((e) => ({
+    id: e.id,
+    kind: e.kind,
+    from: e.from,
+    to: e.to,
+    label: e.label
+  }))];
+  let counter = edges.length;
+  for (const beat of ast.beats) {
+    for (const cue of beat.cues) {
+      collectFlowSegments(cue, (seg) => {
+        const id = `flow_${++counter}`;
+        edges.push({ id, kind: seg.op, from: seg.from, to: seg.to, label: seg.label });
+      });
+    }
   }
-  return slashCount % 2 === 1;
+  return dedupeEdges(edges);
 }
-function parseQuotedLiteral(token) {
-  if (token.length < 2) return null;
-  const quote2 = token[0];
-  if (quote2 !== '"' && quote2 !== "'" || token[token.length - 1] !== quote2) {
-    return null;
+function collectFlowSegments(cue, emit) {
+  if (cue.kind === "parallel") {
+    for (const child of cue.cues) collectFlowSegments(child, emit);
+    return;
   }
-  if (isEscapedChar(token, token.length - 1)) {
-    return null;
+  if (cue.kind === "flow") {
+    for (const seg of cue.segments) emit(seg);
   }
-  return unescapeQuotedContent(token.slice(1, -1), quote2);
 }
-function unescapeQuotedContent(content, quote2) {
-  let out = "";
-  for (let i = 0; i < content.length; i++) {
-    const ch = content[i];
-    if (ch !== "\\") {
-      out += ch;
-      continue;
-    }
-    if (i + 1 >= content.length) {
-      out += "\\";
-      continue;
-    }
-    const next = content[++i];
-    if (next === "n") out += "\n";
-    else if (next === "r") out += "\r";
-    else if (next === "t") out += "	";
-    else if (next === "\\") out += "\\";
-    else if (next === quote2) out += quote2;
-    else if (next === '"' || next === "'") out += next;
-    else out += `\\${next}`;
+function dedupeEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of edges) {
+    const k = `${e.from}|${e.kind}|${e.to}|${e.label ?? ""}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(e);
   }
   return out;
 }
-var POSITIONAL_KEYS = {
-  say: ["text"],
-  throw: ["asset"]
-};
-function parseActionParams(action, raw) {
-  const params = {};
-  const trimmed = raw.trim();
-  if (!trimmed) return params;
-  const positionalKeys = POSITIONAL_KEYS[action] ?? [];
-  let positionalIndex = 0;
-  for (const token of splitByComma(trimmed)) {
-    const t = token.trim();
-    if (!t) continue;
-    const eqIdx = t.indexOf("=");
-    if (eqIdx === -1) {
-      const key = positionalKeys[positionalIndex] ?? `_${positionalIndex}`;
-      positionalIndex++;
-      params[key] = parseValue(t);
-    } else {
-      const key = t.slice(0, eqIdx).trim();
-      const val = t.slice(eqIdx + 1).trim();
-      params[key] = parseValue(val);
+function assignRanks(nodeIds, edges, direction) {
+  const ranks = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) ranks.set(id, 0);
+  const forward = edges.filter((e) => e.kind !== "response");
+  for (let sweep = 0; sweep < nodeIds.length; sweep++) {
+    let changed = false;
+    for (const e of forward) {
+      const next = (ranks.get(e.from) ?? 0) + 1;
+      if (next > (ranks.get(e.to) ?? 0)) {
+        ranks.set(e.to, next);
+        changed = true;
+      }
     }
+    if (!changed) break;
+  }
+  if (direction === "RL" || direction === "BT") {
+    const max = Math.max(...ranks.values(), 0);
+    for (const [id, r] of ranks) ranks.set(id, max - r);
   }
-  return params;
+  return ranks;
 }
-var MODIFIER_KEYS = /* @__PURE__ */ new Set(["scale", "rotate", "opacity", "size", "z"]);
-function parseSpaceModifiers(raw, lineNum, warnings) {
-  const result = {};
-  const tokens = raw.trim().split(/\s+/).filter(Boolean);
-  for (let i = 0; i + 1 < tokens.length; i += 2) {
-    const key = tokens[i];
-    const val = Number(tokens[i + 1]);
-    if (Number.isNaN(val)) continue;
-    if (MODIFIER_KEYS.has(key)) {
-      result[key] = val;
-    } else {
-      warnings.push({
-        kind: "unknown-modifier",
-        message: `unknown modifier "${key}" \u2014 ignored`,
-        line: lineNum
+function layoutNodes(ast, edges) {
+  const nodeIds = Object.keys(ast.nodes);
+  const ranks = assignRanks(nodeIds, edges, ast.meta.direction);
+  const byRank = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    const r = ranks.get(id) ?? 0;
+    if (!byRank.has(r)) byRank.set(r, []);
+    byRank.get(r).push(id);
+  }
+  for (const ids of byRank.values()) ids.sort();
+  const isVertical = ast.meta.direction === "TB" || ast.meta.direction === "BT";
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const maxRank = Math.max(...byRank.keys(), 0);
+  const rankCount = maxRank + 1;
+  const nodes = [];
+  for (const [rank, ids] of [...byRank.entries()].sort((a, b) => a[0] - b[0])) {
+    const rowCount = ids.length;
+    ids.forEach((id, idx) => {
+      const decl = ast.nodes[id];
+      const role = nodeRole(decl.kind);
+      let x;
+      let y;
+      if (isVertical) {
+        x = SAFE + contentW / (rowCount + 1) * (idx + 1) - NODE_W / 2;
+        y = TITLE_BAND + contentH / Math.max(rankCount, 1) * rank + (contentH / Math.max(rankCount, 1) - NODE_H) / 2;
+      } else {
+        x = SAFE + contentW / Math.max(rankCount, 1) * rank + (contentW / Math.max(rankCount, 1) - NODE_W) / 2;
+        y = TITLE_BAND + contentH / (rowCount + 1) * (idx + 1) - NODE_H / 2;
+      }
+      x = Math.round(x / 8) * 8;
+      y = Math.round(y / 8) * 8;
+      const style = decl.style ? ast.styles[decl.style]?.props : void 0;
+      nodes.push({
+        id,
+        kind: decl.kind,
+        role,
+        label: decl.label,
+        x,
+        y,
+        width: NODE_W,
+        height: NODE_H,
+        style,
+        opacity: 0
       });
-    }
+    });
   }
-  return result;
+  return nodes;
 }
-function parseWithModifiers(raw, lineNum, warnings) {
-  const result = {};
-  for (const token of splitByComma(raw)) {
-    const t = token.trim();
-    if (!t) continue;
-    const eqIdx = t.indexOf("=");
-    if (eqIdx === -1) {
-      warnings.push({
-        kind: "unknown-modifier",
-        message: `expected "key=value" in with-clause, got "${t}"`,
-        line: lineNum
-      });
+function resolveTargets(targets, ast, groups) {
+  const out = [];
+  for (const t of targets) {
+    if (t === "$nodes") {
+      out.push(...Object.keys(ast.nodes));
+    } else if (t === "$edges") {
       continue;
-    }
-    const key = t.slice(0, eqIdx).trim();
-    const val = Number(t.slice(eqIdx + 1).trim());
-    if (Number.isNaN(val)) {
-      warnings.push({
-        kind: "unknown-modifier",
-        message: `modifier "${key}" needs a numeric value \u2014 ignored`,
-        line: lineNum
-      });
-      continue;
-    }
-    if (MODIFIER_KEYS.has(key)) {
-      result[key] = val;
+    } else if (t.startsWith("$")) {
+      const g = t.slice(1);
+      if (groups[g]) out.push(...groups[g]);
+    } else if (groups[t]) {
+      out.push(...groups[t]);
     } else {
-      warnings.push({
-        kind: "unknown-modifier",
-        message: `unknown modifier "${key}" \u2014 ignored`,
-        line: lineNum
-      });
+      out.push(t);
     }
   }
-  return result;
-}
-function parseActorTrailer(trailerRaw, lineNum, warnings) {
-  const trimmed = trailerRaw.trim();
-  if (!trimmed) return {};
-  const withMatch = /(^|\s)with(\s|$)/.exec(trimmed);
-  if (!withMatch) {
-    return parseSpaceModifiers(trimmed, lineNum, warnings);
-  }
-  const before = trimmed.slice(0, withMatch.index).trim();
-  const after = trimmed.slice(withMatch.index + withMatch[0].length).trim();
-  const fromSpace = before ? parseSpaceModifiers(before, lineNum, warnings) : {};
-  const fromWith = after ? parseWithModifiers(after, lineNum, warnings) : {};
-  return { ...fromSpace, ...fromWith };
-}
-var ASSET_RE = /^asset\s+(\w+)\s*=\s*(image|icon)\("([^"]+)"\)$/;
-var ACTOR_NUM_POS_RE = /^actor\s+(\w+)\s*=\s*([\w.]+)\(([^)]*)\)\s+at\s+\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)(.*)$/;
-var ACTOR_ANCHOR_POS_RE = /^actor\s+(\w+)\s*=\s*([\w.]+)\(([^)]*)\)\s+at\s+(top|bottom|center)\b(.*)$/;
-var EVENT_RE = /^@([\d.]+):\s+(\w+)\.(!?\w+)\((.*)\)$/;
-var REL_EVENT_RE = /^@\+([\d.]+):\s+(\w+)\.(!?\w+)\((.*)\)$/;
-var VAR_RE = /^var\s+(\w+)\s*=\s*(.+)$/;
-var DEF_HEADER_RE = /^def\s+(\w+)\(([^)]*)\)\s*\{$/;
-var DEF_BODY_RE = /^\s*([\w]+)\(([^)]*)\)\s*$/;
-var SEQ_HEADER_RE = /^seq\s+(\w+)(?:\(([^)]*)\))?\s*\{$/;
-var SEQ_EVENT_RE = /^@\+([\d.]+):\s+\$\.(!?\w+)\((.*)\)$/;
-var CHAPTER_HEADER_RE = /^scene\s+"([^"]+)"\s*\{$/;
-var IMPORT_RE = /^import\s+"([^"]+)"\s+as\s+(\w+)\s*$/;
-var PRESET_RE = /^preset\s+(\w+)(?:\s*\((.*)\))?\s*$/;
-var ARCHITECTURE_NODE_RE = new RegExp(
-  `^(${TECHNICAL_NODE_TYPES.join("|")})\\s+(\\w+)(?:\\s+("[^"]+"|'[^']+'))?(?:\\s+at\\s+\\(\\s*(-?[\\d.]+)\\s*,\\s*(-?[\\d.]+)\\s*\\))?(.*)$`
-);
-var ARCHITECTURE_ALIAS_TO_TYPE = {
-  api: "service",
-  database: "database",
-  db: "db",
-  user: "client",
-  client: "client",
-  service: "service",
-  queue: "queue",
-  cache: "cache",
-  cloud: "cloud",
-  region: "region",
-  container: "container",
-  microservice: "microservice",
-  cluster: "cluster"
-};
-function interpolate(s, vars) {
-  return s.replace(
-    /\\?\$\{([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\}/g,
-    (_, name) => vars[name] ?? `\${${name}}`
-  );
-}
-var DEFAULTS = {
-  width: 800,
-  height: 400,
-  fps: 30,
-  bg: "white"
-};
-var CAPTION_TOP_Y_FRAC = 0.12;
-var CAPTION_BOTTOM_Y_FRAC = 0.88;
-var CAPTION_CENTER_Y_FRAC = 0.5;
-var KNOWN_SCENE_KEYS = /* @__PURE__ */ new Set(["width", "height", "fps", "bg", "duration"]);
-function validateMoveTarget(action, params, meta, actor, line) {
-  if (action !== "move") return;
-  const to = params.to;
-  if (!Array.isArray(to) || to.length < 2) return;
-  const [x, y] = to;
-  if (x < 0 || x > meta.width || y < 0 || y > meta.height) {
-    throw new ParseError(
-      `Actor "${actor}" move target (${x}, ${y}) is outside scene bounds (0\u2013${meta.width}, 0\u2013${meta.height})`,
-      line
-    );
-  }
+  return [...new Set(out)];
 }
-function parse(source, opts = {}) {
-  if (!opts._fromPreset) {
-    const expansion = tryExpandSolePreset(source);
-    if (expansion) return parse(expansion, { ...opts, _fromPreset: true });
+function scheduleBeats(ast, edges) {
+  const cues = [];
+  const beatRanges = [];
+  let t = 0;
+  let edgeCounter = edges.length;
+  const hasIntro = ast.beats.some((b) => b.cues.some((c) => c.kind === "show"));
+  if (!hasIntro && Object.keys(ast.nodes).length > 0) {
+    cues.push({
+      start: 0,
+      duration: DEFAULTS.show,
+      kind: "show",
+      targets: Object.keys(ast.nodes),
+      params: { stagger: DEFAULTS.stagger },
+      beat: "__intro"
+    });
+    t += DEFAULTS.show + DEFAULTS.cueGap;
   }
-  const ast = {
-    meta: { ...DEFAULTS },
-    assets: {},
-    actors: {},
-    events: [],
-    defs: {},
-    seqs: {},
-    vars: {},
-    groups: {},
-    chapters: [],
-    warnings: [],
-    imports: []
-  };
-  const actorCountWarningThreshold = opts.actorCountWarningThreshold ?? 10;
-  const labelLengthWarningThreshold = opts.labelLengthWarningThreshold ?? 36;
-  let actorCountWarned = false;
-  let sceneFound = false;
-  const lines = source.split(/\r?\n/);
-  let inDef = null;
-  let defNeedsClose = false;
-  let inSeq = null;
-  let inChapter = null;
-  const topScope = { name: "", prevEnd: 0 };
-  for (let i = 0; i < lines.length; i++) {
-    const lineNum = i + 1;
-    const rawUntouched = lines[i].trim();
-    if (!inDef && !defNeedsClose && !inSeq && rawUntouched.startsWith("var ")) {
-      const varLine = interpolate(rawUntouched, ast.vars);
-      const vm = VAR_RE.exec(varLine);
-      if (!vm) {
-        throw new ParseError(`Invalid var declaration: ${varLine}`, lineNum);
-      }
-      const [, name, value] = vm;
-      ast.vars[name] = value.trim();
-      continue;
-    }
-    let raw = stripComment(lines[i]).trim();
-    if (!raw) continue;
-    raw = interpolate(raw, ast.vars);
-    if (raw === "}") {
-      if (defNeedsClose) {
-        defNeedsClose = false;
-        continue;
-      }
-      if (inDef) {
-        throw new ParseError(`Empty def body for "${inDef.name}"`, lineNum);
-      }
-      if (inSeq) {
-        ast.seqs[inSeq.name] = { params: inSeq.params, events: inSeq.events };
-        inSeq = null;
-        continue;
-      }
-      if (inChapter) {
-        const endTime = inChapter.scope.prevEnd;
-        const startTime = inChapter.earliestEventTime === Infinity ? inChapter.openedAt : Math.min(inChapter.openedAt, inChapter.earliestEventTime);
-        ast.chapters.push({
-          name: inChapter.name,
-          startLine: inChapter.startLine,
-          startTime,
-          endTime
-        });
-        if (endTime > topScope.prevEnd) topScope.prevEnd = endTime;
-        inChapter = null;
-        continue;
-      }
-      throw new ParseError("Unexpected '}'", lineNum);
-    }
-    if (inDef) {
-      const bm = DEF_BODY_RE.exec(raw);
-      if (!bm) {
-        throw new ParseError(`Invalid def body (expected "type(args)"): ${raw}`, lineNum);
-      }
-      const [, actorType, bodyArgsRaw] = bm;
-      if (!isKnownActorType(actorType)) {
-        throw new ParseError(`Unknown actor type in def body: "${actorType}"`, lineNum);
-      }
-      const bodyArgs = bodyArgsRaw.trim() ? splitByComma(bodyArgsRaw).map((a) => a.trim()) : [];
-      ast.defs[inDef.name] = {
-        params: inDef.params,
-        actorType,
-        bodyArgs
-      };
-      inDef = null;
-      defNeedsClose = true;
-      continue;
-    }
-    if (inSeq) {
-      const interpolatedSeq = interpolate(raw, ast.vars);
-      const sm = SEQ_EVENT_RE.exec(interpolatedSeq);
-      if (!sm) {
-        throw new ParseError(`Invalid seq event (expected "@+offset: $.action(params)"): ${raw}`, lineNum);
-      }
-      const [, offsetStr, action, paramsRaw] = sm;
-      inSeq.events.push({ offset: Number(offsetStr), action, paramsRaw });
-      continue;
-    }
-    if (raw.startsWith("import ")) {
-      const im = IMPORT_RE.exec(raw);
-      if (!im) {
-        throw new ParseError(`Invalid import declaration: ${raw}`, lineNum);
-      }
-      const [, path, namespace] = im;
-      const decl = { path, namespace, line: lineNum };
-      ast.imports.push(decl);
-      const resolved = opts.imports?.[namespace];
-      if (!resolved) {
-        ast.warnings.push({
-          kind: "import-unresolved",
-          message: `import "${path}" as ${namespace} \u2014 no pre-parsed AST supplied by host`,
-          line: lineNum
-        });
-      } else {
-        for (const [k, v] of Object.entries(resolved.vars)) {
-          ast.vars[`${namespace}.${k}`] = v;
-        }
-        for (const [k, v] of Object.entries(resolved.defs)) {
-          ast.defs[`${namespace}.${k}`] = v;
-        }
-        for (const [k, v] of Object.entries(resolved.seqs)) {
-          ast.seqs[`${namespace}.${k}`] = v;
-        }
-      }
-      continue;
-    }
-    if (raw.startsWith("def ")) {
-      const dm = DEF_HEADER_RE.exec(raw);
-      if (!dm) {
-        throw new ParseError(`Invalid def declaration: ${raw}`, lineNum);
-      }
-      const [, name, paramsRaw] = dm;
-      const params = paramsRaw.split(",").map((p) => p.trim()).filter(Boolean);
-      inDef = { name, params, startLine: lineNum };
-      continue;
-    }
-    if (raw.startsWith("seq ")) {
-      const sm = SEQ_HEADER_RE.exec(raw);
-      if (!sm) {
-        throw new ParseError(`Invalid seq declaration: ${raw}`, lineNum);
-      }
-      const [, name, paramsRaw] = sm;
-      const params = paramsRaw ? paramsRaw.split(",").map((p) => p.trim()).filter(Boolean) : [];
-      inSeq = { name, params, events: [], startLine: lineNum };
-      continue;
-    }
-    if (/^scene(\s|$)/.test(raw)) {
-      const chm = CHAPTER_HEADER_RE.exec(raw);
-      if (chm) {
-        if (inChapter) {
-          throw new ParseError(
-            `Nested chapters are not supported; close chapter "${inChapter.name}" first`,
-            lineNum
-          );
-        }
-        const chapterName = chm[1];
-        inChapter = {
-          name: chapterName,
-          startLine: lineNum,
-          openedAt: topScope.prevEnd,
-          earliestEventTime: Infinity,
-          scope: { name: chapterName, prevEnd: topScope.prevEnd }
-        };
-        continue;
-      }
-      if (inChapter) {
-        throw new ParseError(
-          `scene header inside chapter "${inChapter.name}" is not allowed; close the chapter first or use 'scene "title" { ... }' for a nested section`,
-          lineNum
-        );
-      }
-      if (sceneFound) {
-        throw new ParseError("Duplicate scene declaration", lineNum);
-      }
-      sceneFound = true;
-      for (const [, key, val] of raw.matchAll(/(\w+)=([\S]+)/g)) {
-        switch (key) {
-          case "width":
-            ast.meta.width = Number(val);
-            break;
-          case "height":
-            ast.meta.height = Number(val);
-            break;
-          case "fps":
-            ast.meta.fps = Number(val);
-            break;
-          case "bg":
-            ast.meta.bg = val;
-            break;
-          case "duration":
-            ast.meta.duration = Number(val);
-            break;
-          default:
-            if (KNOWN_SCENE_KEYS.has(key)) break;
-            ast.warnings.push({
-              kind: "unknown-scene-key",
-              message: `unknown scene property "${key}" \u2014 ignored`,
-              line: lineNum
-            });
-        }
-      }
-      continue;
-    }
-    if (raw.startsWith("asset")) {
-      const m = ASSET_RE.exec(raw);
-      if (!m) {
-        throw new ParseError(`Invalid asset declaration: ${raw}`, lineNum);
-      }
-      const [, name, type, value] = m;
-      ast.assets[name] = { type, value };
-      continue;
-    }
-    if (raw.startsWith("preset ")) {
-      const pm = PRESET_RE.exec(raw);
-      const maybeName = pm?.[1];
-      if (maybeName && !PRESETS[maybeName]) {
-        const nameList = Object.keys(PRESETS).sort().join(", ");
-        ast.warnings.push({
-          kind: "unknown-preset",
-          message: `unknown preset "${maybeName}" \u2014 available: ${nameList}`,
-          line: lineNum
-        });
-      } else {
-        ast.warnings.push({
-          kind: "preset-mixed",
-          message: "`preset` is a whole-file shorthand; mid-file presets are ignored",
-          line: lineNum
-        });
-      }
-      continue;
-    }
-    if (raw.startsWith("actor ") || isArchitectureNodeLine(raw)) {
-      const actorInfo = parseActorLine(raw, lineNum, ast);
-      if (!actorCountWarned && actorCountWarningThreshold > 0) {
-        const actorCount = Object.keys(ast.actors).length;
-        if (actorCount > actorCountWarningThreshold) {
-          actorCountWarned = true;
-          ast.warnings.push({
-            kind: "actor-count-threshold",
-            message: `scene has ${actorCount} actors (threshold ${actorCountWarningThreshold}); consider splitting into multiple scenes`,
-            line: lineNum
-          });
+  for (const beat of ast.beats) {
+    const beatStart = t;
+    const scheduled = [];
+    const processCue = (cue, parallel = false) => {
+      if (cue.kind === "parallel") {
+        const start = t;
+        let maxDur = 0;
+        for (const child of cue.cues) {
+          const before = t;
+          processCue(child, true);
+          maxDur = Math.max(maxDur, t - before);
+          if (!parallel) t = before;
         }
+        if (!parallel) t = start + maxDur;
+        return;
       }
-      if (labelLengthWarningThreshold > 0 && typeof actorInfo.args[0] === "string") {
-        const label = actorInfo.args[0];
-        if (label.length > labelLengthWarningThreshold) {
-          ast.warnings.push({
-            kind: "label-overflow",
-            message: `actor "${actorInfo.name}" label length ${label.length} exceeds ${labelLengthWarningThreshold}; consider shortening to reduce overlap`,
-            line: lineNum
+      if (cue.kind === "use") return;
+      const dur = "dur" in cue && cue.dur !== void 0 ? cue.dur : DEFAULTS[cue.kind] ?? 0.5;
+      if (cue.kind === "flow") {
+        for (const seg of cue.segments) {
+          const edgeId = `flow_${++edgeCounter}`;
+          scheduled.push({
+            start: t,
+            duration: dur / cue.segments.length,
+            kind: "flow",
+            targets: [seg.from, seg.to],
+            edgeId,
+            segments: [seg],
+            params: {},
+            beat: beat.name
           });
+          t += dur / cue.segments.length + DEFAULTS.cueGap / cue.segments.length;
         }
+        return;
       }
-      continue;
-    }
-    if (raw.startsWith("group ")) {
-      parseGroupLine(raw, lineNum, ast);
-      continue;
-    }
-    if (raw.startsWith("@")) {
-      parseEventLine(raw, lineNum, ast, inChapter, topScope);
-      continue;
-    }
-    throw new ParseError(`Unrecognized statement: ${raw}`, lineNum);
-  }
-  if (inDef) {
-    throw new ParseError(`Unclosed def block "${inDef.name}"`, inDef.startLine);
-  }
-  if (defNeedsClose) {
-    throw new ParseError("Unclosed def block (missing '}')", lines.length);
-  }
-  if (inSeq) {
-    throw new ParseError(`Unclosed seq block "${inSeq.name}"`, inSeq.startLine);
-  }
-  if (inChapter) {
-    throw new ParseError(`Unclosed chapter "${inChapter.name}"`, inChapter.startLine);
-  }
-  if (ast.meta.duration === void 0) {
-    let maxEnd = 0;
-    for (const ev of ast.events) {
-      const dur = typeof ev.params.dur === "number" ? ev.params.dur : 0;
-      maxEnd = Math.max(maxEnd, ev.time + dur);
-    }
-    if (maxEnd > 0) ast.meta.duration = round3(maxEnd);
+      if (cue.kind !== "show" && cue.kind !== "hide" && cue.kind !== "glow" && cue.kind !== "focus") return;
+      const targets = resolveTargets(cue.targets, ast, Object.fromEntries(Object.entries(ast.groups).map(([k, g]) => [k, g.members])));
+      scheduled.push({
+        start: t,
+        duration: dur,
+        kind: cue.kind,
+        targets,
+        params: {
+          stagger: cue.kind === "show" ? cue.stagger ?? DEFAULTS.stagger : void 0,
+          color: cue.kind === "glow" ? cue.color : void 0,
+          strength: cue.kind === "glow" ? cue.strength : void 0,
+          zoom: cue.kind === "focus" ? cue.zoom : void 0
+        },
+        beat: beat.name
+      });
+      t += dur + DEFAULTS.cueGap;
+    };
+    for (const cue of beat.cues) processCue(cue);
+    cues.push(...scheduled);
+    beatRanges.push({
+      name: beat.name,
+      label: beat.label,
+      start: beatStart,
+      end: Math.max(t, beatStart + (beat.dur ?? 0))
+    });
+    t += DEFAULTS.beatGap;
   }
-  return ast;
+  return { cues, beats: beatRanges };
 }
-function parseActorCallArgs(argsRaw) {
-  if (!argsRaw.trim()) return [];
-  return splitByComma(argsRaw).map((a) => {
-    const t = a.trim();
-    const q = parseQuotedLiteral(t);
-    return q ?? t;
+function compilePlan(ast, theme) {
+  const structuralEdges = collectStructuralEdges(ast);
+  const nodes = layoutNodes(ast, structuralEdges);
+  const { cues, beats } = scheduleBeats(ast, structuralEdges);
+  const shown = /* @__PURE__ */ new Set();
+  for (const cue of cues) {
+    if (cue.kind === "show") cue.targets.forEach((id) => shown.add(id));
+  }
+  if (shown.size === 0) nodes.forEach((n) => {
+    n.opacity = 1;
+  });
+  else nodes.forEach((n) => {
+    n.opacity = shown.has(n.id) ? 1 : 0;
   });
+  const duration = ast.meta.duration ?? Math.max(
+    ...cues.map((c) => c.start + c.duration),
+    ...beats.map((b) => b.end),
+    1
+  );
+  const title = ast.meta.title ?? "Architecture Diagram";
+  return {
+    meta: ast.meta,
+    theme,
+    title,
+    nodes,
+    edges: structuralEdges,
+    cues,
+    beats,
+    groups: Object.fromEntries(Object.entries(ast.groups).map(([k, g]) => [k, g.members])),
+    duration
+  };
 }
-function parseActorLine(raw, lineNum, ast) {
-  const architectureNode = parseArchitectureNodeLine(raw, lineNum, ast);
-  if (architectureNode) return architectureNode;
-  const amAnchor = ACTOR_ANCHOR_POS_RE.exec(raw);
-  const amNum = amAnchor ? null : ACTOR_NUM_POS_RE.exec(raw);
-  if (!amAnchor && !amNum) throw new ParseError(`Invalid actor declaration: ${raw}`, lineNum);
-  let name;
-  let typeName;
-  let argsRaw;
-  let x;
-  let y;
-  let anchor;
-  let trailer;
-  if (amAnchor) {
-    const [, nm, tn, ar, an, tr] = amAnchor;
-    name = nm;
-    typeName = tn;
-    argsRaw = ar;
-    anchor = an;
-    trailer = tr;
-    x = ast.meta.width / 2;
-    switch (anchor) {
-      case "top":
-        y = Math.round(ast.meta.height * CAPTION_TOP_Y_FRAC);
-        break;
-      case "bottom":
-        y = Math.round(ast.meta.height * CAPTION_BOTTOM_Y_FRAC);
-        break;
-      default:
-        y = Math.round(ast.meta.height * CAPTION_CENTER_Y_FRAC);
-        break;
-    }
-  } else {
-    const [, nm, tn, ar, xs, ys, tr] = amNum;
-    name = nm;
-    typeName = tn;
-    argsRaw = ar;
-    x = Number(xs);
-    y = Number(ys);
-    trailer = tr;
+
+// src/themes.ts
+var ROLE_COLORS = {
+  compute: "#38bdf8",
+  code: "#38bdf8",
+  client: "#f59e0b",
+  data: "#22c55e",
+  messaging: "#a78bfa",
+  network: "#60a5fa",
+  platform: "#c084fc",
+  security: "#fb7185",
+  delivery: "#facc15",
+  observability: "#2dd4bf",
+  flow: "#e879f9",
+  distributed: "#94a3b8"
+};
+var EDGE_COLORS = {
+  request: "#38bdf8",
+  response: "#a78bfa",
+  event: "#f59e0b",
+  dependency: "#64748b"
+};
+var THEMES = {
+  midnight: {
+    name: "midnight",
+    canvas: "#07111f",
+    surface: "#0f1b2d",
+    surfaceRaised: "#16243a",
+    border: "#2b3b52",
+    text: "#f4f7fb",
+    textMuted: "#9aabc0",
+    gridMinor: "rgba(148, 163, 184, 0.13)",
+    gridMajor: "rgba(148, 163, 184, 0.2)",
+    vignette: "rgba(2, 6, 23, 0.72)",
+    accent: "#38bdf8",
+    roles: { ...ROLE_COLORS },
+    edges: { ...EDGE_COLORS }
+  },
+  paper: {
+    name: "paper",
+    canvas: "#f7f9fc",
+    surface: "#ffffff",
+    surfaceRaised: "#eef3f8",
+    border: "#ccd7e5",
+    text: "#132033",
+    textMuted: "#5d6d82",
+    gridMinor: "rgba(15, 23, 42, 0.09)",
+    gridMajor: "rgba(15, 23, 42, 0.14)",
+    vignette: "rgba(241, 245, 249, 0.74)",
+    accent: "#0ea5e9",
+    roles: { ...ROLE_COLORS },
+    edges: { ...EDGE_COLORS }
   }
-  if (name === "camera") {
-    throw new ParseError(
-      `"camera" is a reserved actor name; drop this declaration and use camera.pan/zoom/shake directly`,
-      lineNum
-    );
+};
+function resolveTheme(name) {
+  return THEMES[name] ?? THEMES.midnight;
+}
+
+// src/parser.ts
+var ParseError = class extends Error {
+  line;
+  column;
+  constructor(message, line, column) {
+    super(`line ${line}: ${message}`);
+    this.name = "ParseError";
+    this.line = line;
+    this.column = column;
   }
-  const rawArgs = parseActorCallArgs(argsRaw);
-  let resolvedType;
-  let resolvedArgs;
-  if (isKnownActorType(typeName)) {
-    resolvedType = typeName;
-    resolvedArgs = rawArgs;
-  } else if (ast.defs[typeName]) {
-    const tmpl = ast.defs[typeName];
-    const localVars = {};
-    for (let pi = 0; pi < tmpl.params.length; pi++) {
-      localVars[tmpl.params[pi]] = rawArgs[pi] ?? "";
+};
+var LEGACY_PATTERNS = [
+  { re: /^\s*actor\s+/i, message: 'MarkdyScript 0.8 removed `actor` declarations. Use node kinds instead: `service API "Label"`.' },
+  { re: /^\s*@\d/, message: "MarkdyScript 0.8 removed `@time:` events. Use `beat` blocks with flow chains and cues." },
+  { re: /^\s*def\s+/i, message: "MarkdyScript 0.8 removed `def`. Use `pattern name(...):` for reusable flows." },
+  { re: /^\s*seq\s+/i, message: "MarkdyScript 0.8 removed `seq`. Use `pattern` + `use` inside beats." },
+  { re: /^\s*preset\s+/i, message: "MarkdyScript 0.8 removed presets. Use `scene` + `beat` composition." },
+  { re: /^\s*asset\s+/i, message: "MarkdyScript 0.8 is diagram-only; `asset` declarations are not supported." },
+  { re: /figure\s*\(/i, message: "MarkdyScript 0.8 is diagram-only; `figure` actors were removed." }
+];
+var FLOW_OP_RE = /(->|<-|~>|--)/;
+var PROP_RE = /(\w[\w.-]*)=(\S+)/g;
+function stripComment(line) {
+  const idx = line.indexOf("//");
+  return idx >= 0 ? line.slice(0, idx) : line;
+}
+function parseProps(raw) {
+  const props = {};
+  for (const match of raw.matchAll(PROP_RE)) {
+    const key = match[1];
+    let val = match[2];
+    if (typeof val === "string") {
+      if (/^\d+(\.\d+)?$/.test(val)) val = Number(val);
+      else if (val === "true") val = true;
+      else if (val === "false") val = false;
+      else if (/^\d+ms$/.test(val)) val = Number(val.slice(0, -2)) / 1e3;
+      else if (/^\d+(\.\d+)?s$/.test(val)) val = Number(val.slice(0, -1));
     }
-    resolvedType = tmpl.actorType;
-    resolvedArgs = tmpl.bodyArgs.map((a) => interpolate(a, localVars));
-  } else {
-    throw new ParseError(`Unknown actor type or template: "${typeName}"`, lineNum);
-  }
-  const modifiers = parseActorTrailer(trailer, lineNum, ast.warnings);
-  if (anchor && resolvedType !== "caption") {
-    throw new ParseError(
-      `anchor syntax "at ${anchor}" only applies to caption actors; got ${typeName}`,
-      lineNum
-    );
-  }
-  if (resolvedType === "caption" && !anchor) {
-    throw new ParseError(
-      `Caption actors require anchor syntax (\`at top | bottom | center\`); got numeric position (${x}, ${y}) for "${name}"`,
-      lineNum
-    );
+    props[key] = val;
   }
-  if (!anchor && (x < 0 || x > ast.meta.width || y < 0 || y > ast.meta.height)) {
-    throw new ParseError(
-      `Actor "${name}" position (${x}, ${y}) is outside scene bounds (0\u2013${ast.meta.width}, 0\u2013${ast.meta.height})`,
-      lineNum
-    );
+  return props;
+}
+function parseStringToken(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith('"')) return null;
+  let i = 1;
+  let value = "";
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    if (ch === '"') return { value, rest: trimmed.slice(i + 1).trim() };
+    if (ch === "\\" && i + 1 < trimmed.length) {
+      value += trimmed[i + 1];
+      i += 2;
+      continue;
+    }
+    value += ch;
+    i++;
   }
-  ast.actors[name] = {
-    type: resolvedType,
-    args: resolvedArgs,
-    x,
-    y,
-    ...modifiers,
-    ...anchor ? { anchor } : {}
-  };
-  return { name, args: resolvedArgs };
+  return null;
 }
-function isArchitectureNodeLine(raw) {
-  return ARCHITECTURE_NODE_RE.test(raw);
+function splitTargets(raw) {
+  return raw.split(/[\s,]+/).map((t) => t.trim()).filter(Boolean);
 }
-function parseArchitectureNodeLine(raw, lineNum, ast) {
-  const m = ARCHITECTURE_NODE_RE.exec(raw);
-  if (!m) return null;
-  const [, alias, name, labelRaw, xRaw, yRaw, trailer] = m;
-  if (name === "camera") {
-    throw new ParseError(
-      `"camera" is a reserved actor name; choose a different architecture node name`,
-      lineNum
-    );
+function parseFlowChain(line, lineNo) {
+  const segments = [];
+  const parts = line.split(FLOW_OP_RE).map((p) => p.trim()).filter(Boolean);
+  if (parts.length < 3) {
+    throw new ParseError(`expected flow chain like A -> B "label"`, lineNo);
   }
-  const typeName = ARCHITECTURE_ALIAS_TO_TYPE[alias] ?? alias;
-  if (!isKnownActorType(typeName)) {
-    throw new ParseError(
-      `Architecture node "${alias}" requires an actor pack that registers type "${typeName}"`,
-      lineNum
-    );
-  }
-  const actorIndex = Object.keys(ast.actors).length;
-  const x = xRaw === void 0 ? autoNodeX(actorIndex, ast.meta.width) : Number(xRaw);
-  const y = yRaw === void 0 ? autoNodeY(actorIndex, ast.meta.height, ast.meta.width) : Number(yRaw);
-  if (x < 0 || x > ast.meta.width || y < 0 || y > ast.meta.height) {
-    throw new ParseError(
-      `Actor "${name}" position (${x}, ${y}) is outside scene bounds (0\u2013${ast.meta.width}, 0\u2013${ast.meta.height})`,
-      lineNum
-    );
+  let i = 0;
+  let from = splitTargetLabel(parts[i++], lineNo).node;
+  while (i < parts.length) {
+    const opToken = parts[i++];
+    const op = EDGE_OPERATORS[opToken];
+    if (!op) throw new ParseError(`unknown flow operator '${opToken}'`, lineNo);
+    if (i >= parts.length) throw new ParseError(`expected target after '${opToken}'`, lineNo);
+    const { node: to, label } = splitTargetLabel(parts[i++], lineNo);
+    if (!to) throw new ParseError(`expected target node after '${opToken}'`, lineNo);
+    segments.push({
+      from: op === "response" ? to : from,
+      op,
+      to: op === "response" ? from : to,
+      label
+    });
+    from = op === "response" ? from : to;
   }
-  const quoted = labelRaw ? parseQuotedLiteral(labelRaw.trim()) : null;
-  const label = quoted ?? labelRaw?.trim() ?? name;
-  const modifiers = parseActorTrailer(trailer, lineNum, ast.warnings);
-  ast.actors[name] = {
-    type: typeName,
-    args: [label],
-    x,
-    y,
-    ...modifiers
-  };
-  return { name, args: [label] };
-}
-function autoNodeX(index, width) {
-  const columns = Math.max(1, Math.floor(width / 220));
-  const gutter = width / (columns + 1);
-  return Math.round(gutter * (index % columns + 1));
+  return segments;
 }
-function autoNodeY(index, height, width = DEFAULTS.width) {
-  const columns = Math.max(1, Math.floor(width / 220));
-  const row = Math.floor(index / columns);
-  return Math.min(height - 60, 90 + row * 120);
+function splitTargetLabel(token, lineNo) {
+  const quoteIdx = token.indexOf('"');
+  if (quoteIdx < 0) return { node: token.trim() };
+  const parsed = parseStringToken(token.slice(quoteIdx));
+  if (!parsed) throw new ParseError("unterminated string in flow label", lineNo);
+  const before = token.slice(0, quoteIdx).trim();
+  const node = before || parsed.rest.trim();
+  return { node, label: parsed.value };
 }
-var GROUP_RE = /^group\s+([A-Za-z_][\w.]*)\s*=\s*(.+)$/;
-function parseGroupLine(raw, lineNum, ast) {
-  const m = GROUP_RE.exec(raw);
-  if (!m) {
-    throw new ParseError(`Invalid group declaration: ${raw}`, lineNum);
+function parseCueLine(line, lineNo) {
+  const trimmed = line.trim();
+  const propsMatch = trimmed.match(/\s+(?:dur|stagger|color|strength|zoom|after)=\S+/);
+  const props = propsMatch ? parseProps(propsMatch[0]) : {};
+  if (trimmed.includes(" & ")) {
+    const parts = trimmed.split(/\s+&\s+/);
+    return {
+      kind: "parallel",
+      cues: parts.map((p, idx) => parseCueLine(p, lineNo + idx * 1e-3)),
+      line: lineNo
+    };
   }
-  const [, name, membersRaw] = m;
-  if (ast.actors[name]) {
-    throw new ParseError(`Group "${name}" collides with an actor of the same name`, lineNum);
+  if (FLOW_OP_RE.test(trimmed)) {
+    const chainPart = trimmed.split(/\s+(?:dur|stagger|color|strength|zoom|after)=/)[0].trim();
+    return {
+      kind: "flow",
+      segments: parseFlowChain(chainPart, lineNo),
+      dur: typeof props.dur === "number" ? props.dur : void 0,
+      line: lineNo
+    };
   }
-  if (ast.groups[name]) {
-    throw new ParseError(`Group "${name}" is already defined`, lineNum);
+  const [head, ...rest] = trimmed.split(/\s+/);
+  const keyword = head.toLowerCase();
+  if (keyword === "show" || keyword === "hide") {
+    const targetRaw = rest.join(" ").split(/\s+(?:dur|stagger)=/)[0];
+    return {
+      kind: keyword,
+      targets: splitTargets(targetRaw),
+      stagger: typeof props.stagger === "number" ? props.stagger : void 0,
+      dur: typeof props.dur === "number" ? props.dur : void 0,
+      line: lineNo
+    };
   }
-  const members = splitByComma(membersRaw).map((part) => part.trim()).filter((part) => part.length > 0);
-  if (members.length === 0) {
-    throw new ParseError(`Group "${name}" has no members`, lineNum);
+  if (keyword === "glow") {
+    const targetRaw = rest.join(" ").split(/\s+(?:color|strength|dur)=/)[0];
+    return {
+      kind: "glow",
+      targets: splitTargets(targetRaw),
+      color: typeof props.color === "string" ? props.color : void 0,
+      strength: typeof props.strength === "number" ? props.strength : void 0,
+      dur: typeof props.dur === "number" ? props.dur : void 0,
+      line: lineNo
+    };
   }
-  for (const member of members) {
-    if (!ast.actors[member]) {
-      throw new ParseError(`Unknown actor "${member}" in group "${name}"`, lineNum);
-    }
+  if (keyword === "focus") {
+    const targetRaw = rest.join(" ").split(/\s+(?:zoom|dur)=/)[0];
+    return {
+      kind: "focus",
+      targets: splitTargets(targetRaw),
+      zoom: typeof props.zoom === "number" ? props.zoom : void 0,
+      dur: typeof props.dur === "number" ? props.dur : void 0,
+      line: lineNo
+    };
   }
-  const seen = /* @__PURE__ */ new Set();
-  for (const member of members) {
-    if (seen.has(member)) {
-      throw new ParseError(`Actor "${member}" listed twice in group "${name}"`, lineNum);
+  if (keyword === "use") {
+    const call = rest.join(" ");
+    const m = call.match(/^(\w+)\s*\((.*)\)\s*$/);
+    if (!m) throw new ParseError(`expected use pattern(args)`, lineNo);
+    const args = {};
+    if (m[2].trim()) {
+      for (const part of m[2].split(",")) {
+        const trimmed2 = part.trim();
+        if (trimmed2.includes("=")) {
+          const [k, v] = trimmed2.split("=").map((s) => s.trim());
+          if (!k || !v) throw new ParseError(`invalid use argument '${part}'`, lineNo);
+          args[k] = v;
+        } else {
+          args[`__pos_${Object.keys(args).length}`] = trimmed2;
+        }
+      }
     }
-    seen.add(member);
+    return { kind: "use", pattern: m[1], args, line: lineNo };
   }
-  ast.groups[name] = members;
+  throw new ParseError(`unknown cue '${head}'`, lineNo);
 }
-function takeStagger(paramsRaw, lineNum) {
-  if (!paramsRaw.includes("stagger")) return { step: 0, rest: paramsRaw };
-  const kept = [];
-  let step = 0;
-  for (const part of splitByComma(paramsRaw)) {
-    const eq = part.indexOf("=");
-    if (eq !== -1 && part.slice(0, eq).trim() === "stagger") {
-      const rawValue = part.slice(eq + 1).trim();
-      const value = Number(rawValue);
-      if (Number.isNaN(value)) {
-        throw new ParseError(`Invalid stagger value: ${rawValue}`, lineNum);
-      }
-      if (value < 0) {
-        throw new ParseError(`stagger must not be negative (got ${rawValue})`, lineNum);
-      }
-      step = value;
+function expandPatternCues(cues, patterns, line) {
+  const out = [];
+  for (const cue of cues) {
+    if (cue.kind === "use") {
+      const pat = patterns[cue.pattern];
+      if (!pat) throw new ParseError(`unknown pattern '${cue.pattern}'`, line);
+      const substituted = pat.body.map((c) => substitutePatternCue(c, pat.params, cue.args));
+      out.push(...substituted);
+      continue;
+    }
+    if (cue.kind === "parallel") {
+      out.push({ ...cue, cues: expandPatternCues(cue.cues, patterns, line) });
       continue;
     }
-    kept.push(part);
+    out.push(cue);
   }
-  return { step, rest: kept.join(",") };
+  return out;
 }
-function parseEventLine(raw, lineNum, ast, inChapter, topScope) {
-  const scope = inChapter?.scope ?? topScope;
-  const recordEventTime = (t) => {
-    if (inChapter && t < inChapter.earliestEventTime) {
-      inChapter.earliestEventTime = t;
+function substitutePatternCue(cue, params, args) {
+  const positional = Object.keys(args).filter((k) => k.startsWith("__pos_")).sort().map((k) => args[k]);
+  const resolvedArgs = { ...args };
+  params.forEach((p, i) => {
+    if (resolvedArgs[p] === void 0 && positional[i]) resolvedArgs[p] = positional[i];
+  });
+  delete resolvedArgs.__pos_0;
+  delete resolvedArgs.__pos_1;
+  delete resolvedArgs.__pos_2;
+  delete resolvedArgs.__pos_3;
+  const sub = (s) => {
+    for (const p of params) {
+      if (resolvedArgs[p]) s = s.replaceAll(`$${p}`, resolvedArgs[p]);
     }
+    return s;
   };
-  const rel = REL_EVENT_RE.exec(raw);
-  const abs = rel ? null : EVENT_RE.exec(raw);
-  if (!rel && !abs) {
-    throw new ParseError(`Invalid event: ${raw}`, lineNum);
+  if (cue.kind === "flow") {
+    return {
+      ...cue,
+      segments: cue.segments.map((seg) => ({
+        ...seg,
+        from: sub(seg.from),
+        to: sub(seg.to),
+        label: seg.label ? sub(seg.label) : void 0
+      }))
+    };
   }
-  let time;
-  let actor;
-  let actionToken;
-  let paramsRaw;
-  if (rel) {
-    const [, offsetStr, act, action2, pr] = rel;
-    const offset = Number(offsetStr);
-    if (Number.isNaN(offset)) {
-      throw new ParseError(`Invalid @+offset value: ${offsetStr}`, lineNum);
-    }
-    time = round3(scope.prevEnd + offset);
-    actor = act;
-    actionToken = action2;
-    paramsRaw = pr;
-  } else {
-    const [, timeStr, act, action2, pr] = abs;
-    const t = Number(timeStr);
-    if (Number.isNaN(t)) {
-      throw new ParseError(`Invalid time value: ${timeStr}`, lineNum);
-    }
-    time = t;
-    actor = act;
-    actionToken = action2;
-    paramsRaw = pr;
+  if (cue.kind === "show" || cue.kind === "hide" || cue.kind === "glow" || cue.kind === "focus") {
+    return { ...cue, targets: cue.targets.map(sub) };
   }
-  const mustUnderstand = actionToken.startsWith("!");
-  const action = mustUnderstand ? actionToken.slice(1) : actionToken;
-  if (actor === "camera") {
-    if (!isCameraAction(action)) {
-      if (mustUnderstand) {
-        throw new ParseError(`Unknown camera action "${action}"`, lineNum);
-      }
-      ast.warnings.push({
-        kind: "unknown-camera-action",
-        message: `unknown camera action "${action}" \u2014 renderer will no-op`,
-        line: lineNum
-      });
-    }
-    const params = parseActionParams(action, paramsRaw);
-    recordEventTime(time);
-    pushEvent(ast, scope, {
-      time,
-      actor: "camera",
-      action,
-      params,
-      line: lineNum,
-      ...inChapter ? { chapter: inChapter.name } : {}
-    });
-    return;
+  if (cue.kind === "parallel") {
+    return { ...cue, cues: cue.cues.map((c) => substitutePatternCue(c, params, args)) };
   }
-  const groupMembers = ast.groups[actor];
-  if (!groupMembers && !ast.actors[actor]) {
-    throw new ParseError(`Unknown actor: "${actor}"`, lineNum);
+  return cue;
+}
+function readBlocks(lines) {
+  const blocks = [];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (!raw.trim() || raw.trim().startsWith("//")) continue;
+    const indent = raw.match(/^\s*/)?.[0].length ?? 0;
+    blocks.push({ line: i + 1, indent, text: raw.trim() });
   }
-  if (groupMembers) {
-    const { step, rest } = takeStagger(paramsRaw, lineNum);
-    groupMembers.forEach((member, index) => {
-      emitActorEvent(
-        member,
-        round3(time + index * step),
-        action,
-        rest,
-        mustUnderstand,
-        lineNum,
-        ast,
-        scope,
-        inChapter,
-        recordEventTime
-      );
-    });
-    return;
+  return blocks;
+}
+function readIndentedBody(blocks, startIdx, parentIndent) {
+  const body = [];
+  let i = startIdx;
+  while (i < blocks.length) {
+    if (blocks[i].indent <= parentIndent) break;
+    body.push(blocks[i]);
+    i++;
   }
-  emitActorEvent(
-    actor,
-    time,
-    action,
-    paramsRaw,
-    mustUnderstand,
-    lineNum,
-    ast,
-    scope,
-    inChapter,
-    recordEventTime
-  );
+  return { body, nextIdx: i };
 }
-function emitActorEvent(actor, time, action, paramsRaw, mustUnderstand, lineNum, ast, scope, inChapter, recordEventTime) {
-  const actorDef = ast.actors[actor];
-  if (!actorDef) {
-    throw new ParseError(`Unknown actor: "${actor}"`, lineNum);
+function parse(source, opts = {}) {
+  const lines = source.replace(/\r\n/g, "\n").split("\n");
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = stripComment(lines[i2]);
+    for (const legacy of LEGACY_PATTERNS) {
+      if (legacy.re.test(line)) {
+        throw new ParseError(legacy.message, i2 + 1);
+      }
+    }
   }
-  if (action === "play") {
-    const playParts = splitByComma(paramsRaw);
-    const seqName = playParts[0]?.trim();
-    if (!seqName || !ast.seqs[seqName]) {
-      throw new ParseError(`Unknown sequence: "${seqName}"`, lineNum);
+  const diagnostics = [];
+  const meta = {
+    width: 1280,
+    height: 720,
+    fps: 60,
+    theme: "midnight",
+    direction: "LR"
+  };
+  const styles = {};
+  const nodes = {};
+  const edges = [];
+  const groups = {};
+  const patterns = {};
+  const beats = [];
+  let title = "";
+  let edgeCounter = 0;
+  const blocks = readBlocks(lines.map(stripComment));
+  let i = 0;
+  while (i < blocks.length) {
+    const block = blocks[i];
+    const line = block.text;
+    const lineNo = block.line;
+    if (line.startsWith("scene")) {
+      const rest = line.slice(5).trim();
+      let remainder = rest;
+      const str = parseStringToken(rest);
+      if (str) {
+        title = str.value;
+        remainder = str.rest;
+      }
+      const props = parseProps(remainder);
+      for (const [k, v] of Object.entries(props)) {
+        if (!SCENE_KEYS.has(k)) {
+          diagnostics.push({ severity: "warning", message: `unknown scene property '${k}'`, line: lineNo });
+          continue;
+        }
+        if (k === "width" || k === "height" || k === "fps") meta[k] = Number(v);
+        else if (k === "duration") meta.duration = Number(v);
+        else if (k === "theme") meta.theme = String(v);
+        else if (k === "direction") meta.direction = String(v).toUpperCase();
+      }
+      i++;
+      continue;
+    }
+    if (/^layout\s+(LR|RL|TB|BT)\b/i.test(line)) {
+      meta.direction = line.split(/\s+/)[1].toUpperCase();
+      i++;
+      continue;
+    }
+    if (line.startsWith("style ")) {
+      const m = line.match(/^style\s+(\w+)\s*=\s*(.+)$/);
+      if (!m) throw new ParseError(`expected style name = props`, lineNo);
+      styles[m[1]] = { name: m[1], props: parseProps(m[2]), line: lineNo };
+      i++;
+      continue;
+    }
+    if (line.startsWith("pattern ")) {
+      const m = line.match(/^pattern\s+(\w+)\s*\(([^)]*)\)\s*:\s*$/);
+      if (!m) throw new ParseError(`expected pattern name(params):`, lineNo);
+      const params = m[2].trim() ? m[2].split(",").map((p) => p.trim()) : [];
+      const { body, nextIdx } = readIndentedBody(blocks, i + 1, block.indent);
+      const cues = body.map((b) => parseCueLine(b.text, b.line));
+      patterns[m[1]] = { name: m[1], params, body: cues, line: lineNo };
+      i = nextIdx;
+      continue;
     }
-    const seq = ast.seqs[seqName];
-    const playVars = {};
-    for (let pi = 1; pi < playParts.length; pi++) {
-      const eqIdx = playParts[pi].indexOf("=");
-      if (eqIdx !== -1) {
-        const k = playParts[pi].slice(0, eqIdx).trim();
-        const v = playParts[pi].slice(eqIdx + 1).trim();
-        playVars[k] = v;
+    if (line.startsWith("group ")) {
+      const m = line.match(/^group\s+(\w+)(?:\s+"([^"]*)")?\s*:\s*(.+)$/);
+      if (!m) throw new ParseError(`expected group name: A B C`, lineNo);
+      groups[m[1]] = {
+        id: m[1],
+        label: m[2],
+        members: splitTargets(m[3]),
+        props: {},
+        line: lineNo
+      };
+      i++;
+      continue;
+    }
+    if (line.startsWith("edge ")) {
+      const m = line.match(/^edge\s+(\w+)\s*:\s*(.+)$/);
+      if (!m) throw new ParseError(`expected edge id: A -> B`, lineNo);
+      const segments = parseFlowChain(m[2].split(/\s+\w+=/)[0], lineNo);
+      for (const seg of segments) {
+        edges.push({
+          id: `edge_${++edgeCounter}`,
+          kind: seg.op,
+          from: seg.from,
+          to: seg.to,
+          label: seg.label,
+          props: parseProps(m[2]),
+          line: lineNo
+        });
       }
+      i++;
+      continue;
+    }
+    if (line.startsWith("beat ")) {
+      const m = line.match(/^beat\s+(\w+)(?:\s+"([^"]*)")?\s*:\s*$/);
+      if (!m) throw new ParseError(`expected beat name:`, lineNo);
+      const { body, nextIdx } = readIndentedBody(blocks, i + 1, block.indent);
+      let cues = body.map((b) => parseCueLine(b.text, b.line));
+      cues = expandPatternCues(cues, patterns, lineNo);
+      beats.push({ name: m[1], label: m[2], cues, line: lineNo });
+      i = nextIdx;
+      continue;
     }
-    let posIdx = 0;
-    for (let pi = 1; pi < playParts.length; pi++) {
-      if (!playParts[pi].includes("=") && posIdx < seq.params.length) {
-        playVars[seq.params[posIdx]] = playParts[pi].trim();
-        posIdx++;
+    const nodeMatch = line.match(/^(\w[\w.-]*)\s+(\w[\w.-]*)(.*)$/);
+    if (nodeMatch) {
+      const rawKind = nodeMatch[1].toLowerCase();
+      const kind = canonicalNodeKind(rawKind);
+      const id = nodeMatch[2];
+      let remainder = nodeMatch[3].trim();
+      if (!NODE_KINDS.has(kind)) {
+        throw new ParseError(`unknown node kind '${rawKind}'`, lineNo);
+      }
+      let label = humanizeId(id);
+      const str = parseStringToken(remainder);
+      if (str) {
+        label = str.value;
+        remainder = str.rest;
       }
+      const styleMatch = remainder.match(/\bstyle=(\w+)/);
+      const props = parseProps(remainder);
+      nodes[id] = {
+        kind,
+        id,
+        label,
+        style: styleMatch?.[1],
+        props,
+        line: lineNo
+      };
+      i++;
+      continue;
     }
-    for (const sev of seq.events) {
-      const expandedParams = interpolate(sev.paramsRaw, playVars);
-      const absTime = round3(time + sev.offset);
-      const sevMustUnderstand = sev.action.startsWith("!");
-      const sevAction = sevMustUnderstand ? sev.action.slice(1) : sev.action;
-      validateActionForActor(sevAction, actorDef, sevMustUnderstand, lineNum, ast.warnings);
-      const params2 = parseActionParams(sevAction, expandedParams);
-      validateMoveTarget(sevAction, params2, ast.meta, actor, lineNum);
-      recordEventTime(absTime);
-      pushEvent(ast, scope, {
-        time: absTime,
-        actor,
-        action: sevAction,
-        params: params2,
-        line: lineNum,
-        ...inChapter ? { chapter: inChapter.name } : {}
-      });
+    if (BEAT_CUE_KEYWORDS.has(line.split(/\s+/)[0].toLowerCase()) || FLOW_OP_RE.test(line)) {
+      throw new ParseError(`top-level cues must be inside a beat block`, lineNo);
     }
-    return;
+    throw new ParseError(`unexpected statement`, lineNo);
   }
-  validateActionForActor(action, actorDef, mustUnderstand, lineNum, ast.warnings);
-  const params = parseActionParams(action, paramsRaw);
-  validateMoveTarget(action, params, ast.meta, actor, lineNum);
-  recordEventTime(time);
-  pushEvent(ast, scope, {
-    time,
-    actor,
-    action,
-    params,
-    line: lineNum,
-    ...inChapter ? { chapter: inChapter.name } : {}
-  });
-}
-function pushEvent(ast, scope, ev) {
-  ast.events.push(ev);
-  const dur = typeof ev.params.dur === "number" ? ev.params.dur : 0;
-  const endTime = round3(ev.time + dur);
-  if (endTime > scope.prevEnd) scope.prevEnd = endTime;
-}
-function validateActionForActor(action, actorDef, mustUnderstand, lineNum, warnings) {
-  if (isKnownAction(actorDef.type, action)) return;
-  if (isFigureOnlyAction(action)) {
-    if (actorDef.type !== "figure") {
-      throw new ParseError(
-        `action "${action}" is figure-only; actor type is "${actorDef.type}"`,
-        lineNum
-      );
-    }
-    return;
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (errors.length) {
+    throw new ParseError(errors[0].message, errors[0].line, errors[0].column);
   }
-  if (mustUnderstand) {
-    throw new ParseError(`Unknown action "${action}" (must-understand form)`, lineNum);
+  const ast = {
+    meta: { ...meta, title: title || void 0 },
+    styles,
+    nodes,
+    edges,
+    groups,
+    patterns,
+    beats,
+    diagnostics
+  };
+  if (!opts.parseOnly && Object.keys(nodes).length === 0 && beats.length === 0) {
   }
-  warnings.push({
-    kind: "unknown-action",
-    message: `unknown action "${action}" on ${actorDef.type} actor \u2014 renderer will no-op`,
-    line: lineNum
-  });
+  return ast;
 }
-function tryExpandSolePreset(source) {
-  const lines = source.split(/\r?\n/);
-  let presetLine = null;
-  for (const raw of lines) {
-    const stripped = stripComment(raw).trim();
-    if (!stripped) continue;
-    if (stripped.startsWith("preset ")) {
-      if (presetLine) return null;
-      presetLine = stripped;
-    } else {
-      return null;
-    }
-  }
-  if (!presetLine) return null;
-  const pm = PRESET_RE.exec(presetLine);
-  if (!pm) return null;
-  const [, name, argsRaw] = pm;
-  const fn = PRESETS[name];
-  if (!fn) return null;
-  const args = argsRaw ? splitByComma(argsRaw).map((a) => {
-    const t = a.trim();
-    const q = parseQuotedLiteral(t);
-    return q ?? t;
-  }) : [];
-  return fn(args);
+function compile(ast) {
+  return compilePlan(ast, resolveTheme(ast.meta.theme));
 }
-function round3(n) {
-  return Math.round(n * 1e3) / 1e3;
+function parseAndCompile(source) {
+  const ast = parse(source);
+  const plan = compile(ast);
+  return { ast, plan };
 }
 export {
-  BUILTIN_ACTOR_TYPES,
-  CAMERA_ACTION_NAMES,
-  FIGURE_ONLY_ACTION_NAMES,
-  PRESETS,
-  PRESET_NAMES,
+  BEAT_CUE_KEYWORDS,
+  EDGE_OPERATORS,
+  NODE_ALIASES,
+  NODE_KINDS,
   ParseError,
+  SCENE_KEYS,
   TECHNICAL_NODE_KINDS,
   TECHNICAL_NODE_TYPES,
-  UNIVERSAL_ACTION_NAMES,
+  THEMES,
   VISUAL_PRIMITIVE_TYPES,
+  canonicalNodeKind,
+  compile,
+  compilePlan,
+  humanizeId,
+  nodeRole,
   parse,
-  registerActorPack
+  parseAndCompile,
+  resolveTheme
 };