@markdy/core 0.7.24 → 0.7.26

package/dist/index.d.ts

@@ -116,6 +116,12 @@ type SceneAST = {
     seqs: Record<string, SequenceDef>;
     /** User-defined variables — kept in AST for tooling/inspection. */
     vars: Record<string, string>;
+    /**
+     * Named actor groups, in declaration order, mapping group name to member
+     * actor names. Groups fan out into per-actor events at parse time, so the
+     * renderer never sees them — this is kept for tooling and inspection.
+     */
+    groups: Record<string, string[]>;
     /** Named chapter blocks in author order. Empty when no chapters were used. */
     chapters: Chapter[];
     /** Soft parse issues. Always present; empty in the happy path. */
@@ -180,6 +186,25 @@ type PresetFn = (args: string[]) => string;
 declare const PRESETS: Record<string, PresetFn>;
 declare const PRESET_NAMES: readonly string[];
 
+/**
+ * The canonical vocabulary of the language.
+ *
+ * These arrays are the single source of truth for every tool that needs to
+ * know what Markdy understands — the parser, the language server, the
+ * playground's syntax highlighter, and the renderer's handler-coverage test.
+ * Anything that hard-codes its own copy will silently drift out of date, so
+ * import from here instead.
+ */
+declare const BUILTIN_ACTOR_TYPES: readonly BuiltinActorType[];
+/** Actions valid on every actor type. */
+declare const UNIVERSAL_ACTION_NAMES: readonly ["enter", "exit", "move", "fade_in", "fade_out", "scale", "rotate", "shake", "say", "throw", "play"];
+/**
+ * Actions that require a `figure` actor. Applying one to any other actor
+ * type is a hard `ParseError`, not a soft warning — it's always a mistake.
+ */
+declare const FIGURE_ONLY_ACTION_NAMES: readonly ["punch", "kick", "wave", "nod", "jump", "bounce", "face", "rotate_part", "pose"];
+/** Actions valid on the reserved `camera` actor. */
+declare const CAMERA_ACTION_NAMES: readonly ["pan", "zoom", "shake"];
 type ActorPack = {
     name: string;
     actors: readonly string[];
@@ -187,4 +212,4 @@ type ActorPack = {
 };
 declare function registerActorPack(pack: ActorPack): void;
 
-export { type ActorDef, type ActorPack, type ActorType, type AssetDef, type BuiltinActorType, type Chapter, type ImportDecl, PRESETS, PRESET_NAMES, ParseError, type ParseOptions, type ParseWarning, type PresetFn, type SceneAST, type SceneMeta, type SequenceDef, type TemplateDef, type TimelineEvent, parse, registerActorPack };
+export { type ActorDef, type ActorPack, type ActorType, type AssetDef, BUILTIN_ACTOR_TYPES, type BuiltinActorType, CAMERA_ACTION_NAMES, type Chapter, FIGURE_ONLY_ACTION_NAMES, type ImportDecl, PRESETS, PRESET_NAMES, ParseError, type ParseOptions, type ParseWarning, type PresetFn, type SceneAST, type SceneMeta, type SequenceDef, type TemplateDef, type TimelineEvent, UNIVERSAL_ACTION_NAMES, parse, registerActorPack };

package/dist/index.js

@@ -232,7 +232,7 @@ var BUILTIN_ACTOR_TYPES = [
   "figure",
   "caption"
 ];
-var UNIVERSAL_ACTIONS = /* @__PURE__ */ new Set([
+var UNIVERSAL_ACTION_NAMES = [
   "enter",
   "exit",
   "move",
@@ -244,8 +244,8 @@ var UNIVERSAL_ACTIONS = /* @__PURE__ */ new Set([
   "say",
   "throw",
   "play"
-]);
-var FIGURE_ONLY_ACTIONS = /* @__PURE__ */ new Set([
+];
+var FIGURE_ONLY_ACTION_NAMES = [
   "punch",
   "kick",
   "wave",
@@ -255,8 +255,11 @@ var FIGURE_ONLY_ACTIONS = /* @__PURE__ */ new Set([
   "face",
   "rotate_part",
   "pose"
-]);
-var CAMERA_ACTIONS = /* @__PURE__ */ new Set(["pan", "zoom", "shake"]);
+];
+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) {
@@ -555,6 +558,7 @@ function parse(source, opts = {}) {
     defs: {},
     seqs: {},
     vars: {},
+    groups: {},
     chapters: [],
     warnings: [],
     imports: []
@@ -800,6 +804,10 @@ function parse(source, opts = {}) {
       }
       continue;
     }
+    if (raw.startsWith("group ")) {
+      parseGroupLine(raw, lineNum, ast);
+      continue;
+    }
     if (raw.startsWith("@")) {
       parseEventLine(raw, lineNum, ast, inChapter, topScope);
       continue;
@@ -927,6 +935,59 @@ function parseActorLine(raw, lineNum, ast) {
   };
   return { name, args: resolvedArgs };
 }
+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);
+  }
+  const [, name, membersRaw] = m;
+  if (ast.actors[name]) {
+    throw new ParseError(`Group "${name}" collides with an actor of the same name`, lineNum);
+  }
+  if (ast.groups[name]) {
+    throw new ParseError(`Group "${name}" is already defined`, lineNum);
+  }
+  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);
+  }
+  for (const member of members) {
+    if (!ast.actors[member]) {
+      throw new ParseError(`Unknown actor "${member}" in group "${name}"`, lineNum);
+    }
+  }
+  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);
+    }
+    seen.add(member);
+  }
+  ast.groups[name] = members;
+}
+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;
+      continue;
+    }
+    kept.push(part);
+  }
+  return { step, rest: kept.join(",") };
+}
 function parseEventLine(raw, lineNum, ast, inChapter, topScope) {
   const scope = inChapter?.scope ?? topScope;
   const recordEventTime = (t) => {
@@ -977,18 +1038,54 @@ function parseEventLine(raw, lineNum, ast, inChapter, topScope) {
         line: lineNum
       });
     }
-    const params2 = parseActionParams(action, paramsRaw);
+    const params = parseActionParams(action, paramsRaw);
     recordEventTime(time);
     pushEvent(ast, scope, {
       time,
       actor: "camera",
       action,
-      params: params2,
+      params,
       line: lineNum,
       ...inChapter ? { chapter: inChapter.name } : {}
     });
     return;
   }
+  const groupMembers = ast.groups[actor];
+  if (!groupMembers && !ast.actors[actor]) {
+    throw new ParseError(`Unknown actor: "${actor}"`, lineNum);
+  }
+  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;
+  }
+  emitActorEvent(
+    actor,
+    time,
+    action,
+    paramsRaw,
+    mustUnderstand,
+    lineNum,
+    ast,
+    scope,
+    inChapter,
+    recordEventTime
+  );
+}
+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);
@@ -1105,9 +1202,13 @@ function round3(n) {
   return Math.round(n * 1e3) / 1e3;
 }
 export {
+  BUILTIN_ACTOR_TYPES,
+  CAMERA_ACTION_NAMES,
+  FIGURE_ONLY_ACTION_NAMES,
   PRESETS,
   PRESET_NAMES,
   ParseError,
+  UNIVERSAL_ACTION_NAMES,
   parse,
   registerActorPack
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markdy/core",
-  "version": "0.7.24",
+  "version": "0.7.26",
   "description": "MarkdyScript parser and AST types — zero runtime dependencies.",
   "license": "MIT",
   "type": "module",