@markdy/core 0.8.5 → 0.8.7

package/dist/index.d.ts

@@ -77,6 +77,12 @@ type Cue = {
     zoom?: number;
     dur?: number;
     line: number;
+} | {
+    kind: "frame";
+    targets: string[];
+    zoom?: number;
+    dur?: number;
+    line: number;
 } | {
     kind: "use";
     pattern: string;
@@ -163,7 +169,7 @@ type RoutedEdge = {
 type TimedCue = {
     start: number;
     duration: number;
-    kind: "show" | "hide" | "flow" | "glow" | "focus";
+    kind: "show" | "hide" | "flow" | "glow" | "focus" | "frame";
     targets: string[];
     edgeId?: string;
     segments?: FlowSegment[];

package/dist/index.js

@@ -349,8 +349,9 @@ var EDGE_OPERATORS = {
   "~>": "event",
   "--": "dependency"
 };
-var BEAT_CUE_KEYWORDS = /* @__PURE__ */ new Set(["show", "hide", "glow", "focus", "use"]);
-var SCENE_KEYS = /* @__PURE__ */ new Set(["width", "height", "fps", "theme", "duration", "direction"]);
+var RESERVED_SELECTORS = /* @__PURE__ */ new Set(["$title", "$nodes", "$edges"]);
+var BEAT_CUE_KEYWORDS = /* @__PURE__ */ new Set(["show", "hide", "glow", "focus", "frame", "use"]);
+var SCENE_KEYS = /* @__PURE__ */ new Set(["width", "height", "fps", "theme", "duration", "direction", "layout"]);
 function nodeRole(kind) {
   return TECHNICAL_NODE_KINDS[kind] ?? "compute";
 }
@@ -391,6 +392,7 @@ var DEFAULTS = {
   flow: 0.55,
   glow: 0.45,
   focus: 0.6,
+  frame: 0.7,
   beatGap: 0.14,
   cueGap: 0.08,
   stagger: 0.06
@@ -575,7 +577,7 @@ function scheduleBeats(ast, edges) {
         }
         return;
       }
-      if (cue.kind !== "show" && cue.kind !== "hide" && cue.kind !== "glow" && cue.kind !== "focus") return;
+      if (cue.kind !== "show" && cue.kind !== "hide" && cue.kind !== "glow" && cue.kind !== "focus" && cue.kind !== "frame") return;
       const targets = resolveTargets(cue.targets, ast, Object.fromEntries(Object.entries(ast.groups).map(([k, g]) => [k, g.members])));
       scheduled.push({
         start: t,
@@ -586,7 +588,7 @@ function scheduleBeats(ast, edges) {
           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
+          zoom: cue.kind === "focus" || cue.kind === "frame" ? cue.zoom : void 0
         },
         beat: beat.name
       });
@@ -756,24 +758,79 @@ var ParseError = class extends Error {
   }
 };
 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;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString && ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "/" && line[i + 1] === "/") return line.slice(0, i);
+    if (ch === "#" && (i === 0 || /\s/.test(line[i - 1]))) return line.slice(0, i);
+  }
+  return line;
+}
+function parsePropValue(raw) {
+  let val = raw;
+  if (raw.startsWith('"')) {
+    const parsed = parseStringToken(raw);
+    if (parsed && parsed.rest === "") val = parsed.value;
+  }
+  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));
+  }
+  return val;
 }
 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));
+  let i = 0;
+  while (i < raw.length) {
+    const ch = raw[i];
+    if (ch === '"') {
+      const parsed = parseStringToken(raw.slice(i));
+      if (!parsed) break;
+      i = raw.length - parsed.rest.length;
+      continue;
+    }
+    const keyMatch = raw.slice(i).match(/^(\w[\w.-]*)=/);
+    if (!keyMatch) {
+      i++;
+      continue;
     }
-    props[key] = val;
+    const key = keyMatch[1];
+    i += key.length + 1;
+    let value = "";
+    if (raw[i] === '"') {
+      const start = i;
+      const parsed = parseStringToken(raw.slice(i));
+      if (!parsed) {
+        value = raw.slice(i);
+        i = raw.length;
+      } else {
+        i = raw.length - parsed.rest.length;
+        value = raw.slice(start, i).trim();
+      }
+    } else {
+      const start = i;
+      while (i < raw.length && !/\s/.test(raw[i])) i++;
+      value = raw.slice(start, i);
+    }
+    props[key] = parsePropValue(value);
   }
   return props;
 }
@@ -798,6 +855,56 @@ function parseStringToken(raw) {
 function splitTargets(raw) {
   return raw.split(/[\s,]+/).map((t) => t.trim()).filter(Boolean);
 }
+function splitOutsideQuotes(raw, separator) {
+  const parts = [];
+  let start = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString && ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (!inString && ch === separator && /\s/.test(raw[i - 1] ?? "") && /\s/.test(raw[i + 1] ?? "")) {
+      parts.push(raw.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  parts.push(raw.slice(start).trim());
+  return parts.filter(Boolean);
+}
+function stripCueProps(raw, keys) {
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString && ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString || !/\s/.test(ch)) continue;
+    const rest = raw.slice(i + 1);
+    if (keys.some((key) => rest.startsWith(`${key}=`))) return raw.slice(0, i).trim();
+  }
+  return raw.trim();
+}
 function parseFlowChain(line, lineNo) {
   const segments = [];
   const parts = line.split(FLOW_OP_RE).map((p) => p.trim()).filter(Boolean);
@@ -834,18 +941,17 @@ function splitTargetLabel(token, lineNo) {
 }
 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+/);
+  const props = parseProps(trimmed);
+  const parallelParts = splitOutsideQuotes(trimmed, "&");
+  if (parallelParts.length > 1) {
     return {
       kind: "parallel",
-      cues: parts.map((p, idx) => parseCueLine(p, lineNo + idx * 1e-3)),
+      cues: parallelParts.map((p, idx) => parseCueLine(p, lineNo + idx * 1e-3)),
       line: lineNo
     };
   }
   if (FLOW_OP_RE.test(trimmed)) {
-    const chainPart = trimmed.split(/\s+(?:dur|stagger|color|strength|zoom|after)=/)[0].trim();
+    const chainPart = stripCueProps(trimmed, ["dur", "stagger", "color", "strength", "zoom", "after"]);
     return {
       kind: "flow",
       segments: parseFlowChain(chainPart, lineNo),
@@ -856,7 +962,7 @@ function parseCueLine(line, lineNo) {
   const [head, ...rest] = trimmed.split(/\s+/);
   const keyword = head.toLowerCase();
   if (keyword === "show" || keyword === "hide") {
-    const targetRaw = rest.join(" ").split(/\s+(?:dur|stagger)=/)[0];
+    const targetRaw = stripCueProps(rest.join(" "), ["dur", "stagger"]);
     return {
       kind: keyword,
       targets: splitTargets(targetRaw),
@@ -866,7 +972,7 @@ function parseCueLine(line, lineNo) {
     };
   }
   if (keyword === "glow") {
-    const targetRaw = rest.join(" ").split(/\s+(?:color|strength|dur)=/)[0];
+    const targetRaw = stripCueProps(rest.join(" "), ["color", "strength", "dur"]);
     return {
       kind: "glow",
       targets: splitTargets(targetRaw),
@@ -877,7 +983,7 @@ function parseCueLine(line, lineNo) {
     };
   }
   if (keyword === "focus") {
-    const targetRaw = rest.join(" ").split(/\s+(?:zoom|dur)=/)[0];
+    const targetRaw = stripCueProps(rest.join(" "), ["zoom", "dur"]);
     return {
       kind: "focus",
       targets: splitTargets(targetRaw),
@@ -886,6 +992,18 @@ function parseCueLine(line, lineNo) {
       line: lineNo
     };
   }
+  if (keyword === "frame") {
+    const targetRaw = stripCueProps(rest.join(" "), ["zoom", "dur"]);
+    const targets = splitTargets(targetRaw);
+    if (targets.length === 0) throw new ParseError(`expected frame target`, lineNo);
+    return {
+      kind: "frame",
+      targets,
+      zoom: typeof props.zoom === "number" ? props.zoom : void 0,
+      dur: typeof props.dur === "number" ? props.dur : void 0,
+      line: lineNo
+    };
+  }
   if (keyword === "use") {
     const call = rest.join(" ");
     const m = call.match(/^(\w+)\s*\((.*)\)\s*$/);
@@ -931,10 +1049,9 @@ function substitutePatternCue(cue, params, 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;
+  for (const key of Object.keys(resolvedArgs)) {
+    if (key.startsWith("__pos_")) delete resolvedArgs[key];
+  }
   const sub = (s) => {
     for (const p of params) {
       if (resolvedArgs[p]) s = s.replaceAll(`$${p}`, resolvedArgs[p]);
@@ -952,7 +1069,7 @@ function substitutePatternCue(cue, params, args) {
       }))
     };
   }
-  if (cue.kind === "show" || cue.kind === "hide" || cue.kind === "glow" || cue.kind === "focus") {
+  if (cue.kind === "show" || cue.kind === "hide" || cue.kind === "glow" || cue.kind === "focus" || cue.kind === "frame") {
     return { ...cue, targets: cue.targets.map(sub) };
   }
   if (cue.kind === "parallel") {
@@ -980,6 +1097,91 @@ function readIndentedBody(blocks, startIdx, parentIndent) {
   }
   return { body, nextIdx: i };
 }
+function readBody(blocks, startIdx, parentIndent, braceDelimited) {
+  if (!braceDelimited) return readIndentedBody(blocks, startIdx, parentIndent);
+  const body = [];
+  let i = startIdx;
+  while (i < blocks.length) {
+    if (blocks[i].text === "}") return { body, nextIdx: i + 1 };
+    body.push(blocks[i]);
+    i++;
+  }
+  return { body, nextIdx: i };
+}
+function normalizeCueBlocks(blocks) {
+  const normalized = [];
+  for (const block of blocks) {
+    if (block.text.startsWith("& ")) {
+      const prev = normalized[normalized.length - 1];
+      if (!prev) throw new ParseError(`parallel continuation must follow a cue`, block.line);
+      prev.text = `${prev.text} ${block.text}`;
+      continue;
+    }
+    normalized.push({ ...block });
+  }
+  return normalized;
+}
+function pushWarning(diagnostics, seen, line, message) {
+  const key = `${line}:${message}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  diagnostics.push({ severity: "warning", message, line });
+}
+function visitCues(cues, visit) {
+  for (const cue of cues) {
+    visit(cue);
+    if (cue.kind === "parallel") visitCues(cue.cues, visit);
+  }
+}
+function validateReferences(ast) {
+  const seen = /* @__PURE__ */ new Set();
+  const hasNode = (id) => Boolean(ast.nodes[id]);
+  const hasGroup = (id) => Boolean(ast.groups[id]);
+  const isKnownTarget = (target) => {
+    if (RESERVED_SELECTORS.has(target)) return true;
+    if (target.startsWith("$")) return hasGroup(target.slice(1));
+    return hasNode(target) || hasGroup(target);
+  };
+  for (const group of Object.values(ast.groups)) {
+    for (const member of group.members) {
+      if (!hasNode(member)) {
+        pushWarning(ast.diagnostics, seen, group.line, `group '${group.id}' references unknown node '${member}'`);
+      }
+    }
+  }
+  for (const node of Object.values(ast.nodes)) {
+    if (node.style && !ast.styles[node.style]) {
+      pushWarning(ast.diagnostics, seen, node.line, `node '${node.id}' references unknown style '${node.style}'`);
+    }
+  }
+  const validateFlowEndpoint = (line, endpoint) => {
+    if (!hasNode(endpoint)) {
+      pushWarning(ast.diagnostics, seen, line, `flow references unknown node '${endpoint}'`);
+    }
+  };
+  for (const edge of ast.edges) {
+    validateFlowEndpoint(edge.line, edge.from);
+    validateFlowEndpoint(edge.line, edge.to);
+  }
+  for (const beat of ast.beats) {
+    visitCues(beat.cues, (cue) => {
+      if (cue.kind === "flow") {
+        for (const segment of cue.segments) {
+          validateFlowEndpoint(cue.line, segment.from);
+          validateFlowEndpoint(cue.line, segment.to);
+        }
+        return;
+      }
+      if (cue.kind === "show" || cue.kind === "hide" || cue.kind === "glow" || cue.kind === "focus" || cue.kind === "frame") {
+        for (const target of cue.targets) {
+          if (!isKnownTarget(target)) {
+            pushWarning(ast.diagnostics, seen, cue.line, `${cue.kind} references unknown target '${target}'`);
+          }
+        }
+      }
+    });
+  }
+}
 function parse(source, opts = {}) {
   const lines = source.replace(/\r\n/g, "\n").split("\n");
   const diagnostics = [];
@@ -1012,6 +1214,11 @@ function parse(source, opts = {}) {
         title = str.value;
         remainder = str.rest;
       }
+      const inlineLayout = remainder.match(/\blayout\s+(LR|RL|TB|BT)\b/i);
+      if (inlineLayout) {
+        meta.direction = inlineLayout[1].toUpperCase();
+        remainder = remainder.replace(/\blayout\s+(LR|RL|TB|BT)\b/i, " ");
+      }
       const props = parseProps(remainder);
       for (const [k, v] of Object.entries(props)) {
         if (!SCENE_KEYS.has(k)) {
@@ -1021,7 +1228,7 @@ function parse(source, opts = {}) {
         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();
+        else if (k === "direction" || k === "layout") meta.direction = String(v).toUpperCase();
       }
       i++;
       continue;
@@ -1039,11 +1246,11 @@ function parse(source, opts = {}) {
       continue;
     }
     if (line.startsWith("pattern ")) {
-      const m = line.match(/^pattern\s+(\w+)\s*\(([^)]*)\)\s*:\s*$/);
+      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));
+      const { body, nextIdx } = readBody(blocks, i + 1, block.indent, line.endsWith("{"));
+      const cues = normalizeCueBlocks(body).map((b) => parseCueLine(b.text, b.line));
       patterns[m[1]] = { name: m[1], params, body: cues, line: lineNo };
       i = nextIdx;
       continue;
@@ -1080,10 +1287,10 @@ function parse(source, opts = {}) {
       continue;
     }
     if (line.startsWith("beat ")) {
-      const m = line.match(/^beat\s+(\w+)(?:\s+"([^"]*)")?\s*:\s*$/);
+      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));
+      const { body, nextIdx } = readBody(blocks, i + 1, block.indent, line.endsWith("{"));
+      let cues = normalizeCueBlocks(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;
@@ -1122,10 +1329,6 @@ function parse(source, opts = {}) {
     }
     throw new ParseError(`unexpected statement`, lineNo);
   }
-  const errors = diagnostics.filter((d) => d.severity === "error");
-  if (errors.length) {
-    throw new ParseError(errors[0].message, errors[0].line, errors[0].column);
-  }
   const ast = {
     meta: { ...meta, title: title || void 0 },
     styles,
@@ -1136,6 +1339,11 @@ function parse(source, opts = {}) {
     beats,
     diagnostics
   };
+  validateReferences(ast);
+  const errors = ast.diagnostics.filter((d) => d.severity === "error");
+  if (errors.length) {
+    throw new ParseError(errors[0].message, errors[0].line, errors[0].column);
+  }
   if (!opts.parseOnly && Object.keys(nodes).length === 0 && beats.length === 0) {
   }
   return ast;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markdy/core",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "MarkdyScript parser and diagram compiler (auto-layout, edge routing, cue scheduling) — zero runtime dependencies.",
   "license": "MIT",
   "type": "module",