@mmapp/player-core 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,4828 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionDispatcher: () => ActionDispatcher,
+  CORE_FUNCTIONS: () => CORE_FUNCTIONS,
+  CURRENT_IR_VERSION: () => CURRENT_IR_VERSION,
+  EventBus: () => EventBus,
+  StateMachine: () => StateMachine,
+  WEB_FAILURE_POLICIES: () => WEB_FAILURE_POLICIES,
+  analyzeDefinition: () => analyzeDefinition,
+  buildFunctionMap: () => buildFunctionMap,
+  clearExpressionCache: () => clearExpressionCache,
+  clearPatternCache: () => clearPatternCache,
+  compareNRT: () => compareNRT,
+  compile: () => compile,
+  compilePattern: () => compilePattern,
+  compileTestProgram: () => compileTestProgram,
+  compileTestScenario: () => compileTestScenario,
+  countByKind: () => countByKind,
+  countNodes: () => countNodes,
+  createActionRecorder: () => createActionRecorder,
+  createApiTestActions: () => createApiTestActions,
+  createEmptyNRT: () => createEmptyNRT,
+  createEvaluator: () => createEvaluator,
+  createInProcessTestActions: () => createInProcessTestActions,
+  detectIRVersion: () => detectIRVersion,
+  findInteractiveNodes: () => findInteractiveNodes,
+  findNode: () => findNode,
+  findVisibleNodes: () => findVisibleNodes,
+  generateCoverageScenarios: () => generateCoverageScenarios,
+  getFinalState: () => getFinalState,
+  getTransitionPath: () => getTransitionPath,
+  hasTransition: () => hasTransition,
+  isViableDefinition: () => isViableDefinition,
+  matchTopic: () => matchTopic,
+  needsMigration: () => needsMigration,
+  normalizeCategory: () => normalizeCategory,
+  normalizeDefinition: () => normalizeDefinition,
+  runBlueprintScenario: () => runBlueprintScenario,
+  runBlueprintTestProgram: () => runBlueprintTestProgram,
+  runScenario: () => runScenario,
+  runTestProgram: () => runTestProgram,
+  validateDefinition: () => validateDefinition
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/expression/functions.ts
+var add = {
+  name: "add",
+  fn: (a, b) => Number(a) + Number(b),
+  arity: 2
+};
+var subtract = {
+  name: "subtract",
+  fn: (a, b) => Number(a) - Number(b),
+  arity: 2
+};
+var multiply = {
+  name: "multiply",
+  fn: (a, b) => Number(a) * Number(b),
+  arity: 2
+};
+var divide = {
+  name: "divide",
+  fn: (a, b) => {
+    const d = Number(b);
+    return d === 0 ? 0 : Number(a) / d;
+  },
+  arity: 2
+};
+var abs = {
+  name: "abs",
+  fn: (a) => Math.abs(Number(a)),
+  arity: 1
+};
+var round = {
+  name: "round",
+  fn: (a, decimals) => {
+    const d = decimals != null ? Number(decimals) : 0;
+    const factor = Math.pow(10, d);
+    return Math.round(Number(a) * factor) / factor;
+  },
+  arity: -1
+};
+var min = {
+  name: "min",
+  fn: (...args) => {
+    const nums = args.flat().map(Number).filter((n) => !isNaN(n));
+    return nums.length === 0 ? 0 : Math.min(...nums);
+  },
+  arity: -1
+};
+var max = {
+  name: "max",
+  fn: (...args) => {
+    const nums = args.flat().map(Number).filter((n) => !isNaN(n));
+    return nums.length === 0 ? 0 : Math.max(...nums);
+  },
+  arity: -1
+};
+var eq = {
+  name: "eq",
+  fn: (a, b) => a === b || String(a) === String(b),
+  arity: 2
+};
+var neq = {
+  name: "neq",
+  fn: (a, b) => a !== b && String(a) !== String(b),
+  arity: 2
+};
+var gt = {
+  name: "gt",
+  fn: (a, b) => Number(a) > Number(b),
+  arity: 2
+};
+var gte = {
+  name: "gte",
+  fn: (a, b) => Number(a) >= Number(b),
+  arity: 2
+};
+var lt = {
+  name: "lt",
+  fn: (a, b) => Number(a) < Number(b),
+  arity: 2
+};
+var lte = {
+  name: "lte",
+  fn: (a, b) => Number(a) <= Number(b),
+  arity: 2
+};
+var if_fn = {
+  name: "if",
+  fn: (cond, then, else_) => cond ? then : else_,
+  arity: 3
+};
+var and = {
+  name: "and",
+  fn: (...args) => args.every(Boolean),
+  arity: -1
+};
+var or = {
+  name: "or",
+  fn: (...args) => args.some(Boolean),
+  arity: -1
+};
+var not = {
+  name: "not",
+  fn: (a) => !a,
+  arity: 1
+};
+var coalesce = {
+  name: "coalesce",
+  fn: (...args) => {
+    for (const arg of args) {
+      if (arg != null) return arg;
+    }
+    return null;
+  },
+  arity: -1
+};
+var concat = {
+  name: "concat",
+  fn: (...args) => args.map(String).join(""),
+  arity: -1
+};
+var upper = {
+  name: "upper",
+  fn: (s) => String(s ?? "").toUpperCase(),
+  arity: 1
+};
+var lower = {
+  name: "lower",
+  fn: (s) => String(s ?? "").toLowerCase(),
+  arity: 1
+};
+var trim = {
+  name: "trim",
+  fn: (s) => String(s ?? "").trim(),
+  arity: 1
+};
+var format = {
+  name: "format",
+  fn: (template, ...args) => {
+    let result = String(template ?? "");
+    args.forEach((arg, i) => {
+      result = result.replace(`{${i}}`, String(arg ?? ""));
+    });
+    return result;
+  },
+  arity: -1
+};
+var length = {
+  name: "length",
+  fn: (v) => {
+    if (Array.isArray(v)) return v.length;
+    if (typeof v === "string") return v.length;
+    if (v && typeof v === "object") return Object.keys(v).length;
+    return 0;
+  },
+  arity: 1
+};
+var get = {
+  name: "get",
+  fn: (obj, path) => {
+    if (obj == null || typeof path !== "string") return void 0;
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current == null || typeof current !== "object") return void 0;
+      current = current[part];
+    }
+    return current;
+  },
+  arity: 2
+};
+var includes = {
+  name: "includes",
+  fn: (collection, value) => {
+    if (Array.isArray(collection)) return collection.includes(value);
+    if (typeof collection === "string") return collection.includes(String(value));
+    return false;
+  },
+  arity: 2
+};
+var is_defined = {
+  name: "is_defined",
+  fn: (v) => v !== void 0 && v !== null,
+  arity: 1
+};
+var is_empty = {
+  name: "is_empty",
+  fn: (v) => {
+    if (v == null) return true;
+    if (typeof v === "string") return v.length === 0;
+    if (Array.isArray(v)) return v.length === 0;
+    if (typeof v === "object") return Object.keys(v).length === 0;
+    return false;
+  },
+  arity: 1
+};
+var is_null = {
+  name: "is_null",
+  fn: (v) => v === null || v === void 0,
+  arity: 1
+};
+var to_string = {
+  name: "to_string",
+  fn: (v) => {
+    if (v == null) return "";
+    if (typeof v === "object") return JSON.stringify(v);
+    return String(v);
+  },
+  arity: 1
+};
+var CORE_FUNCTIONS = [
+  // Math (8)
+  add,
+  subtract,
+  multiply,
+  divide,
+  abs,
+  round,
+  min,
+  max,
+  // Comparison (6)
+  eq,
+  neq,
+  gt,
+  gte,
+  lt,
+  lte,
+  // Logic (5)
+  if_fn,
+  and,
+  or,
+  not,
+  coalesce,
+  // String (6)
+  concat,
+  upper,
+  lower,
+  trim,
+  format,
+  length,
+  // Path (3)
+  get,
+  includes,
+  is_defined,
+  // Type (3)
+  is_empty,
+  is_null,
+  to_string
+];
+function buildFunctionMap(functions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    map.set(fn.name, fn.fn);
+  }
+  return map;
+}
+
+// src/expression/evaluator.ts
+var MAX_DEPTH = 50;
+var Parser = class {
+  pos = 0;
+  depth = 0;
+  input;
+  constructor(input) {
+    this.input = input;
+  }
+  parse() {
+    this.skipWhitespace();
+    const node = this.parseExpression();
+    this.skipWhitespace();
+    if (this.pos < this.input.length) {
+      throw new Error(`Unexpected character at position ${this.pos}: '${this.input[this.pos]}'`);
+    }
+    return node;
+  }
+  guardDepth() {
+    if (++this.depth > MAX_DEPTH) {
+      throw new Error("Expression too deeply nested");
+    }
+  }
+  parseExpression() {
+    this.guardDepth();
+    try {
+      return this.parseTernary();
+    } finally {
+      this.depth--;
+    }
+  }
+  parseTernary() {
+    let node = this.parseLogicalOr();
+    this.skipWhitespace();
+    if (this.peek() === "?") {
+      this.advance();
+      const consequent = this.parseExpression();
+      this.skipWhitespace();
+      this.expect(":");
+      const alternate = this.parseExpression();
+      node = { type: "ternary", condition: node, consequent, alternate };
+    }
+    return node;
+  }
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    this.skipWhitespace();
+    while (this.match("||")) {
+      const right = this.parseLogicalAnd();
+      left = { type: "binary", operator: "||", left, right };
+      this.skipWhitespace();
+    }
+    return left;
+  }
+  parseLogicalAnd() {
+    let left = this.parseEquality();
+    this.skipWhitespace();
+    while (this.match("&&")) {
+      const right = this.parseEquality();
+      left = { type: "binary", operator: "&&", left, right };
+      this.skipWhitespace();
+    }
+    return left;
+  }
+  parseEquality() {
+    let left = this.parseComparison();
+    this.skipWhitespace();
+    while (true) {
+      if (this.match("==")) {
+        const right = this.parseComparison();
+        left = { type: "binary", operator: "==", left, right };
+      } else if (this.match("!=")) {
+        const right = this.parseComparison();
+        left = { type: "binary", operator: "!=", left, right };
+      } else {
+        break;
+      }
+      this.skipWhitespace();
+    }
+    return left;
+  }
+  parseComparison() {
+    let left = this.parseUnary();
+    this.skipWhitespace();
+    while (true) {
+      if (this.match(">=")) {
+        const right = this.parseUnary();
+        left = { type: "binary", operator: ">=", left, right };
+      } else if (this.match("<=")) {
+        const right = this.parseUnary();
+        left = { type: "binary", operator: "<=", left, right };
+      } else if (this.peek() === ">" && !this.lookAhead(">=")) {
+        this.advance();
+        const right = this.parseUnary();
+        left = { type: "binary", operator: ">", left, right };
+      } else if (this.peek() === "<" && !this.lookAhead("<=")) {
+        this.advance();
+        const right = this.parseUnary();
+        left = { type: "binary", operator: "<", left, right };
+      } else {
+        break;
+      }
+      this.skipWhitespace();
+    }
+    return left;
+  }
+  parseUnary() {
+    this.skipWhitespace();
+    if (this.peek() === "!") {
+      this.advance();
+      const operand = this.parseUnary();
+      return { type: "unary", operator: "!", operand };
+    }
+    if (this.peek() === "-") {
+      const nextChar = this.input[this.pos + 1];
+      if (nextChar !== void 0 && (nextChar >= "0" && nextChar <= "9" || nextChar === ".")) {
+        return this.parseCallChain();
+      }
+    }
+    return this.parseCallChain();
+  }
+  parseCallChain() {
+    let node = this.parsePrimary();
+    while (true) {
+      this.skipWhitespace();
+      if (this.peek() === "(") {
+        this.advance();
+        const args = this.parseArgList();
+        this.expect(")");
+        if (node.type === "identifier") {
+          node = { type: "call", name: node.name, args };
+        } else if (node.type === "path") {
+          const name = node.segments.join(".");
+          node = { type: "call", name, args };
+        } else if (node.type === "member") {
+          node = { type: "method_call", object: node.object, method: node.property, args };
+        } else {
+          throw new Error("Cannot call non-function");
+        }
+      } else if (this.peek() === ".") {
+        this.advance();
+        const prop = this.parseIdentifierName();
+        node = { type: "member", object: node, property: prop };
+      } else {
+        break;
+      }
+    }
+    return node;
+  }
+  parsePrimary() {
+    this.skipWhitespace();
+    const ch = this.peek();
+    if (ch === "(") {
+      this.advance();
+      const expr = this.parseExpression();
+      this.skipWhitespace();
+      this.expect(")");
+      return expr;
+    }
+    if (ch === "'" || ch === '"') {
+      return this.parseString();
+    }
+    if (ch === "-" || ch >= "0" && ch <= "9") {
+      return this.parseNumber();
+    }
+    if (this.isIdentStart(ch)) {
+      return this.parseIdentifierOrPath();
+    }
+    throw new Error(
+      `Unexpected character at position ${this.pos}: '${ch || "EOF"}'`
+    );
+  }
+  parseString() {
+    const quote = this.advance();
+    let value = "";
+    while (this.pos < this.input.length && this.peek() !== quote) {
+      if (this.peek() === "\\") {
+        this.advance();
+        const esc = this.advance();
+        if (esc === "n") value += "\n";
+        else if (esc === "t") value += "	";
+        else if (esc === "r") value += "\r";
+        else value += esc;
+      } else {
+        value += this.advance();
+      }
+    }
+    if (this.pos >= this.input.length) {
+      throw new Error("Unterminated string literal");
+    }
+    this.advance();
+    return { type: "string", value };
+  }
+  parseNumber() {
+    let numStr = "";
+    if (this.peek() === "-") {
+      numStr += this.advance();
+    }
+    while (this.pos < this.input.length && (this.input[this.pos] >= "0" && this.input[this.pos] <= "9")) {
+      numStr += this.advance();
+    }
+    if (this.peek() === "." && this.pos + 1 < this.input.length && this.input[this.pos + 1] >= "0" && this.input[this.pos + 1] <= "9") {
+      numStr += this.advance();
+      while (this.pos < this.input.length && (this.input[this.pos] >= "0" && this.input[this.pos] <= "9")) {
+        numStr += this.advance();
+      }
+    }
+    return { type: "number", value: Number(numStr) };
+  }
+  parseIdentifierOrPath() {
+    const name = this.parseIdentifierName();
+    if (name === "true") return { type: "boolean", value: true };
+    if (name === "false") return { type: "boolean", value: false };
+    if (name === "null") return { type: "null" };
+    if (name === "undefined") return { type: "null" };
+    return { type: "identifier", name };
+  }
+  parseIdentifierName() {
+    let name = "";
+    if (this.peek() === "$") name += this.advance();
+    while (this.pos < this.input.length && this.isIdentPart(this.input[this.pos])) {
+      name += this.advance();
+    }
+    if (!name) {
+      throw new Error(`Expected identifier at position ${this.pos}`);
+    }
+    return name;
+  }
+  parseArgList() {
+    this.skipWhitespace();
+    if (this.peek() === ")") return [];
+    const args = [];
+    args.push(this.parseExpression());
+    this.skipWhitespace();
+    while (this.peek() === ",") {
+      this.advance();
+      args.push(this.parseExpression());
+      this.skipWhitespace();
+    }
+    return args;
+  }
+  // Character utilities
+  peek() {
+    return this.input[this.pos] ?? "";
+  }
+  advance() {
+    return this.input[this.pos++] ?? "";
+  }
+  match(str) {
+    if (this.input.startsWith(str, this.pos)) {
+      this.pos += str.length;
+      return true;
+    }
+    return false;
+  }
+  lookAhead(str) {
+    return this.input.startsWith(str, this.pos);
+  }
+  expect(ch) {
+    this.skipWhitespace();
+    if (this.peek() !== ch) {
+      throw new Error(`Expected '${ch}' at position ${this.pos}, got '${this.peek() || "EOF"}'`);
+    }
+    this.advance();
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length && " 	\n\r".includes(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  isIdentStart(ch) {
+    return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_" || ch === "$";
+  }
+  isIdentPart(ch) {
+    return this.isIdentStart(ch) || ch >= "0" && ch <= "9";
+  }
+};
+function evaluateAST(node, context, fnMap) {
+  switch (node.type) {
+    case "number":
+      return node.value;
+    case "string":
+      return node.value;
+    case "boolean":
+      return node.value;
+    case "null":
+      return null;
+    case "identifier":
+      return resolvePath(node.name, context);
+    case "path":
+      return resolvePath(node.segments.join("."), context);
+    case "member": {
+      const obj = evaluateAST(node.object, context, fnMap);
+      if (obj == null || typeof obj !== "object") return void 0;
+      return obj[node.property];
+    }
+    case "call": {
+      const fn = fnMap.get(node.name);
+      if (!fn) return void 0;
+      const args = node.args.map((a) => evaluateAST(a, context, fnMap));
+      return fn(...args);
+    }
+    case "method_call": {
+      const obj = evaluateAST(node.object, context, fnMap);
+      if (obj != null && typeof obj === "object") {
+        const method = obj[node.method];
+        if (typeof method === "function") {
+          const args = node.args.map((a) => evaluateAST(a, context, fnMap));
+          return method.apply(obj, args);
+        }
+      }
+      return void 0;
+    }
+    case "unary": {
+      const operand = evaluateAST(node.operand, context, fnMap);
+      return !operand;
+    }
+    case "binary": {
+      if (node.operator === "&&") {
+        const left2 = evaluateAST(node.left, context, fnMap);
+        if (!left2) return left2;
+        return evaluateAST(node.right, context, fnMap);
+      }
+      if (node.operator === "||") {
+        const left2 = evaluateAST(node.left, context, fnMap);
+        if (left2) return left2;
+        return evaluateAST(node.right, context, fnMap);
+      }
+      const left = evaluateAST(node.left, context, fnMap);
+      const right = evaluateAST(node.right, context, fnMap);
+      switch (node.operator) {
+        // eslint-disable-next-line eqeqeq
+        case "==":
+          return left == right;
+        // eslint-disable-next-line eqeqeq
+        case "!=":
+          return left != right;
+        case ">":
+          return Number(left) > Number(right);
+        case "<":
+          return Number(left) < Number(right);
+        case ">=":
+          return Number(left) >= Number(right);
+        case "<=":
+          return Number(left) <= Number(right);
+        default:
+          return void 0;
+      }
+    }
+    case "ternary": {
+      const condition = evaluateAST(node.condition, context, fnMap);
+      return condition ? evaluateAST(node.consequent, context, fnMap) : evaluateAST(node.alternate, context, fnMap);
+    }
+  }
+}
+var MAX_CACHE = 500;
+var astCache = /* @__PURE__ */ new Map();
+function evictIfNeeded() {
+  if (astCache.size > MAX_CACHE) {
+    const keys = Array.from(astCache.keys());
+    const evictCount = Math.floor(MAX_CACHE * 0.25);
+    for (let i = 0; i < evictCount; i++) {
+      astCache.delete(keys[i]);
+    }
+  }
+}
+function parseAndCache(expr) {
+  const cached = astCache.get(expr);
+  if (cached) return cached;
+  const parser = new Parser(expr);
+  const ast = parser.parse();
+  astCache.set(expr, ast);
+  evictIfNeeded();
+  return ast;
+}
+var TEMPLATE_RE = /\{\{(.+?)\}\}/g;
+function resolvePath(path, context) {
+  const parts = path.split(".");
+  let current = context;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function evaluateExpression(expr, context, fnMap) {
+  const trimmed = expr.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (trimmed === "undefined") return void 0;
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") return num;
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  if (/^[a-zA-Z_$][\w$.]*$/.test(trimmed)) {
+    return resolvePath(trimmed, context);
+  }
+  const ast = parseAndCache(trimmed);
+  return evaluateAST(ast, context, fnMap);
+}
+var WEB_FAILURE_POLICIES = {
+  VIEW_BINDING: {
+    on_error: "return_fallback",
+    fallback_value: "",
+    log_level: "warn"
+  },
+  EVENT_REACTION: {
+    on_error: "log_and_skip",
+    fallback_value: void 0,
+    log_level: "error"
+  },
+  DURING_ACTION: {
+    on_error: "log_and_skip",
+    fallback_value: void 0,
+    log_level: "error"
+  },
+  CONDITIONAL_VISIBILITY: {
+    on_error: "return_fallback",
+    fallback_value: true,
+    // Show by default if condition fails
+    log_level: "warn"
+  }
+};
+function createEvaluator(config) {
+  const allFunctions = [...CORE_FUNCTIONS, ...config.functions];
+  const fnMap = buildFunctionMap(allFunctions);
+  const policy = config.failurePolicy;
+  function handleError(expr, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (policy.log_level === "error") {
+      console.error(`[player-core] Expression error: "${expr}" \u2014 ${message}`);
+    } else if (policy.log_level === "warn") {
+      console.warn(`[player-core] Expression error: "${expr}" \u2014 ${message}`);
+    }
+    switch (policy.on_error) {
+      case "throw":
+        throw error;
+      case "return_fallback":
+        return { value: policy.fallback_value, status: "fallback", error: message };
+      case "log_and_skip":
+      default:
+        return { value: policy.fallback_value, status: "error", error: message };
+    }
+  }
+  return {
+    evaluate(expression, context) {
+      try {
+        const value = evaluateExpression(expression, context, fnMap);
+        return { value, status: "ok" };
+      } catch (error) {
+        return handleError(expression, error);
+      }
+    },
+    evaluateTemplate(template, context) {
+      try {
+        if (!template.includes("{{")) {
+          return { value: template, status: "ok" };
+        }
+        const result = template.replace(TEMPLATE_RE, (_match, expr) => {
+          const value = evaluateExpression(expr, context, fnMap);
+          return value != null ? String(value) : "";
+        });
+        return { value: result, status: "ok" };
+      } catch (error) {
+        return handleError(template, error);
+      }
+    },
+    validate(expression) {
+      const errors = [];
+      try {
+        parseAndCache(expression);
+      } catch (e) {
+        errors.push(e instanceof Error ? e.message : String(e));
+      }
+      return { valid: errors.length === 0, errors };
+    }
+  };
+}
+function clearExpressionCache() {
+  astCache.clear();
+}
+
+// src/state-machine/interpreter.ts
+var MAX_AUTO_CHAIN = 10;
+var StateMachine = class {
+  evaluator;
+  actionHandlers;
+  listeners = /* @__PURE__ */ new Set();
+  instance;
+  constructor(definition, initialData = {}, config) {
+    this.evaluator = config.evaluator;
+    this.actionHandlers = config.actionHandlers ?? /* @__PURE__ */ new Map();
+    const startState = definition.states.find((s) => s.type === "START");
+    if (!startState) {
+      throw new Error(`No START state found in definition ${definition.slug}`);
+    }
+    this.instance = {
+      definition,
+      current_state: startState.name,
+      state_data: { ...initialData },
+      memory: {},
+      status: "ACTIVE"
+    };
+  }
+  /** Get the current instance snapshot (immutable copy) */
+  getSnapshot() {
+    return { ...this.instance, state_data: { ...this.instance.state_data }, memory: { ...this.instance.memory } };
+  }
+  /** Get current state name */
+  get currentState() {
+    return this.instance.current_state;
+  }
+  /** Get current state_data */
+  get stateData() {
+    return this.instance.state_data;
+  }
+  /** Get current status */
+  get status() {
+    return this.instance.status;
+  }
+  /** Subscribe to state machine events */
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Register an action handler */
+  registerAction(type, handler) {
+    this.actionHandlers.set(type, handler);
+  }
+  /** Execute a named transition */
+  async transition(transitionName, data) {
+    if (this.instance.status !== "ACTIVE") {
+      return {
+        success: false,
+        from_state: this.instance.current_state,
+        to_state: this.instance.current_state,
+        actions_executed: [],
+        error: `Cannot transition: instance status is ${this.instance.status}`
+      };
+    }
+    const transition = this.instance.definition.transitions.find(
+      (t) => t.name === transitionName && t.from.includes(this.instance.current_state)
+    );
+    if (!transition) {
+      return {
+        success: false,
+        from_state: this.instance.current_state,
+        to_state: this.instance.current_state,
+        actions_executed: [],
+        error: `Transition "${transitionName}" not valid from state "${this.instance.current_state}"`
+      };
+    }
+    if (data) {
+      this.instance.state_data = { ...this.instance.state_data, ...data };
+    }
+    if (transition.conditions && transition.conditions.length > 0) {
+      const ctx = this.buildContext();
+      for (const condition of transition.conditions) {
+        const result2 = this.evaluator.evaluate(condition, ctx);
+        if (!result2.value) {
+          return {
+            success: false,
+            from_state: this.instance.current_state,
+            to_state: this.instance.current_state,
+            actions_executed: [],
+            error: `Transition condition not met: ${condition}`
+          };
+        }
+      }
+    }
+    const result = await this.executeTransition(transition);
+    if (result.success) {
+      await this.drainAutoTransitions();
+    }
+    return result;
+  }
+  /** Update state_data directly (for on_event set_field actions) */
+  setField(field, value) {
+    this.instance.state_data = { ...this.instance.state_data, [field]: value };
+  }
+  /** Update memory */
+  setMemory(key, value) {
+    this.instance.memory = { ...this.instance.memory, [key]: value };
+  }
+  /** Get available transitions from the current state */
+  getAvailableTransitions() {
+    return this.instance.definition.transitions.filter(
+      (t) => t.from.includes(this.instance.current_state) && !t.auto
+    );
+  }
+  /** Get the current state definition */
+  getCurrentStateDefinition() {
+    return this.instance.definition.states.find((s) => s.name === this.instance.current_state);
+  }
+  // ===========================================================================
+  // Private implementation
+  // ===========================================================================
+  async executeTransition(transition) {
+    const fromState = this.instance.current_state;
+    const allActionsExecuted = [];
+    const fromStateDef = this.getCurrentStateDefinition();
+    if (fromStateDef?.on_exit) {
+      await this.executeActions(fromStateDef.on_exit, allActionsExecuted);
+    }
+    this.emit({
+      type: "state_exit",
+      instance_id: this.instance.definition.id,
+      from_state: fromState
+    });
+    if (transition.actions) {
+      await this.executeActions(transition.actions, allActionsExecuted);
+    }
+    this.instance.current_state = transition.to;
+    const toStateDef = this.instance.definition.states.find((s) => s.name === transition.to);
+    if (toStateDef?.type === "END") {
+      this.instance.status = "COMPLETED";
+    } else if (toStateDef?.type === "CANCELLED") {
+      this.instance.status = "CANCELLED";
+    }
+    this.emit({
+      type: "state_enter",
+      instance_id: this.instance.definition.id,
+      to_state: transition.to
+    });
+    if (toStateDef?.on_enter) {
+      await this.executeActions(toStateDef.on_enter, allActionsExecuted);
+    }
+    this.emit({
+      type: "transition",
+      instance_id: this.instance.definition.id,
+      from_state: fromState,
+      to_state: transition.to
+    });
+    return {
+      success: true,
+      from_state: fromState,
+      to_state: transition.to,
+      actions_executed: allActionsExecuted
+    };
+  }
+  async drainAutoTransitions() {
+    for (let depth = 0; depth < MAX_AUTO_CHAIN; depth++) {
+      if (this.instance.status !== "ACTIVE") break;
+      const autoTransition = this.findMatchingAutoTransition();
+      if (!autoTransition) break;
+      const result = await this.executeTransition(autoTransition);
+      if (!result.success) break;
+    }
+  }
+  findMatchingAutoTransition() {
+    const candidates = this.instance.definition.transitions.filter(
+      (t) => t.auto && t.from.includes(this.instance.current_state)
+    );
+    const ctx = this.buildContext();
+    for (const candidate of candidates) {
+      if (!candidate.conditions || candidate.conditions.length === 0) {
+        return candidate;
+      }
+      const allMet = candidate.conditions.every((condition) => {
+        const result = this.evaluator.evaluate(condition, ctx);
+        return result.value === true;
+      });
+      if (allMet) return candidate;
+    }
+    return null;
+  }
+  async executeActions(actions, collector) {
+    const ctx = this.buildContext();
+    for (const action of actions) {
+      if (action.condition) {
+        const condResult = this.evaluator.evaluate(action.condition, ctx);
+        if (!condResult.value) continue;
+      }
+      const handler = this.actionHandlers.get(action.type);
+      if (handler) {
+        try {
+          await handler(action, ctx);
+          collector.push(action);
+          this.emit({
+            type: "action_executed",
+            instance_id: this.instance.definition.id,
+            action
+          });
+        } catch (error) {
+          this.emit({
+            type: "error",
+            instance_id: this.instance.definition.id,
+            action,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+  }
+  buildContext() {
+    return {
+      state_data: this.instance.state_data,
+      memory: this.instance.memory,
+      current_state: this.instance.current_state,
+      status: this.instance.status,
+      // Spread state_data for direct field access (e.g., "title" instead of "state_data.title")
+      ...this.instance.state_data
+    };
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/events/pattern-matcher.ts
+var patternCache = /* @__PURE__ */ new Map();
+var MAX_CACHE2 = 200;
+function compilePattern(pattern) {
+  const cached = patternCache.get(pattern);
+  if (cached) return cached;
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<DOUBLESTAR>>").replace(/\*/g, "[^:.]+").replace(/<<DOUBLESTAR>>/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  if (patternCache.size >= MAX_CACHE2) {
+    const firstKey = patternCache.keys().next().value;
+    if (firstKey) patternCache.delete(firstKey);
+  }
+  patternCache.set(pattern, regex);
+  return regex;
+}
+function matchTopic(pattern, topic) {
+  return pattern.test(topic);
+}
+function clearPatternCache() {
+  patternCache.clear();
+}
+
+// src/events/event-bus.ts
+var EventBus = class {
+  subscriptions = [];
+  /**
+   * Subscribe to events matching a glob pattern.
+   * Returns an unsubscribe function.
+   */
+  subscribe(pattern, handler) {
+    const regex = compilePattern(pattern);
+    const subscription = { pattern, regex, handler };
+    this.subscriptions.push(subscription);
+    return () => {
+      const idx = this.subscriptions.indexOf(subscription);
+      if (idx !== -1) this.subscriptions.splice(idx, 1);
+    };
+  }
+  /**
+   * Publish an event. All matching subscriptions fire (async).
+   * Errors in handlers are caught and logged, never propagated.
+   */
+  async publish(topic, payload = {}) {
+    const event = { topic, payload };
+    for (const sub of this.subscriptions) {
+      if (matchTopic(sub.regex, topic)) {
+        try {
+          await sub.handler(event);
+        } catch (error) {
+          console.warn(
+            `[player-core] Event handler error for pattern "${sub.pattern}" on topic "${topic}":`,
+            error
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Publish synchronously (fire-and-forget).
+   * Useful when you don't need to await handler completion.
+   */
+  emit(topic, payload = {}) {
+    void this.publish(topic, payload);
+  }
+  /** Get count of active subscriptions */
+  get size() {
+    return this.subscriptions.length;
+  }
+  /** Remove all subscriptions */
+  clear() {
+    this.subscriptions.length = 0;
+  }
+};
+
+// src/actions/dispatcher.ts
+var ActionDispatcher = class {
+  handlers = /* @__PURE__ */ new Map();
+  /** Register a handler for an action type */
+  register(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  /** Unregister a handler */
+  unregister(type) {
+    this.handlers.delete(type);
+  }
+  /** Check if a handler is registered for the given type */
+  has(type) {
+    return this.handlers.has(type);
+  }
+  /**
+   * Execute a list of actions sequentially.
+   * Each action's condition is evaluated first (if present).
+   * Missing handlers are skipped with a warning.
+   */
+  async execute(actions, context, evaluator) {
+    const results = [];
+    for (const action of actions) {
+      if (action.condition && evaluator) {
+        const condResult = evaluator.evaluate(action.condition, context);
+        if (!condResult.value) continue;
+      }
+      const handler = this.handlers.get(action.type);
+      if (!handler) {
+        console.warn(`[player-core] No handler registered for action type "${action.type}"`);
+        results.push({ type: action.type, success: false, error: `No handler for "${action.type}"` });
+        continue;
+      }
+      try {
+        await handler(action.config, context);
+        results.push({ type: action.type, success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[player-core] Action "${action.type}" failed: ${message}`);
+        results.push({ type: action.type, success: false, error: message });
+      }
+    }
+    return results;
+  }
+  /** Get count of registered handlers */
+  get size() {
+    return this.handlers.size;
+  }
+  /** Remove all handlers */
+  clear() {
+    this.handlers.clear();
+  }
+};
+
+// src/testing/graph-walker.ts
+var MAX_PATHS = 1e3;
+function analyzeDefinition(def) {
+  const states = def.states.map((s) => ({
+    name: s.name,
+    type: s.type,
+    reachable: false,
+    // Will be set during DFS
+    hasOnEvent: Boolean(s.on_event?.length),
+    hasOnEnter: Boolean(s.on_enter?.length),
+    hasOnExit: Boolean(s.on_exit?.length)
+  }));
+  const edges = [];
+  for (const t of def.transitions) {
+    for (const from of t.from) {
+      edges.push({
+        name: t.name,
+        from,
+        to: t.to,
+        auto: Boolean(t.auto),
+        hasConditions: Boolean(t.conditions?.length)
+      });
+    }
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const s of def.states) {
+    adjacency.set(s.name, []);
+  }
+  for (const e of edges) {
+    adjacency.get(e.from)?.push(e);
+  }
+  const startState = def.states.find((s) => s.type === "START");
+  if (!startState) {
+    return {
+      states,
+      edges,
+      terminalPaths: [],
+      cycles: [],
+      unreachableStates: states.map((s) => s.name),
+      deadEndStates: [],
+      summary: {
+        totalStates: states.length,
+        totalTransitions: edges.length,
+        reachableStates: 0,
+        terminalPaths: 0,
+        cycles: 0,
+        unreachableStates: states.length,
+        deadEndStates: 0
+      }
+    };
+  }
+  const terminalStates = new Set(
+    def.states.filter((s) => s.type === "END" || s.type === "CANCELLED").map((s) => s.name)
+  );
+  const terminalPaths = [];
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  function dfs(state, pathStates, pathTransitions, pathSet) {
+    if (terminalPaths.length + cycles.length >= MAX_PATHS) return;
+    const stateNode = states.find((s) => s.name === state);
+    if (stateNode) stateNode.reachable = true;
+    visited.add(state);
+    const isTerminal = terminalStates.has(state);
+    if (isTerminal) {
+      terminalPaths.push({
+        states: [...pathStates],
+        transitions: [...pathTransitions]
+      });
+    }
+    const outEdges = adjacency.get(state) ?? [];
+    for (const edge of outEdges) {
+      if (terminalPaths.length + cycles.length >= MAX_PATHS) return;
+      if (pathSet.has(edge.to)) {
+        const cycleStart = pathStates.indexOf(edge.to);
+        cycles.push({
+          states: [...pathStates.slice(cycleStart), edge.to],
+          transitions: [...pathTransitions.slice(cycleStart), edge.name]
+        });
+        continue;
+      }
+      pathStates.push(edge.to);
+      pathTransitions.push(edge.name);
+      pathSet.add(edge.to);
+      dfs(edge.to, pathStates, pathTransitions, pathSet);
+      pathStates.pop();
+      pathTransitions.pop();
+      pathSet.delete(edge.to);
+    }
+  }
+  dfs(startState.name, [startState.name], [], /* @__PURE__ */ new Set([startState.name]));
+  const unreachableStates = states.filter((s) => !s.reachable).map((s) => s.name);
+  const deadEndStates = states.filter((s) => {
+    if (!s.reachable) return false;
+    if (terminalStates.has(s.name)) return false;
+    const outEdges = adjacency.get(s.name) ?? [];
+    return outEdges.length === 0;
+  }).map((s) => s.name);
+  const uniqueCycles = [];
+  const seenCycleKeys = /* @__PURE__ */ new Set();
+  for (const cycle of cycles) {
+    const key = cycle.states.join("\u2192");
+    if (!seenCycleKeys.has(key)) {
+      seenCycleKeys.add(key);
+      uniqueCycles.push(cycle);
+    }
+  }
+  return {
+    states,
+    edges,
+    terminalPaths,
+    cycles: uniqueCycles,
+    unreachableStates,
+    deadEndStates,
+    summary: {
+      totalStates: states.length,
+      totalTransitions: edges.length,
+      reachableStates: states.filter((s) => s.reachable).length,
+      terminalPaths: terminalPaths.length,
+      cycles: uniqueCycles.length,
+      unreachableStates: unreachableStates.length,
+      deadEndStates: deadEndStates.length
+    }
+  };
+}
+function generateCoverageScenarios(def, analysis) {
+  const resolved = analysis ?? analyzeDefinition(def);
+  const scenarios = [];
+  for (const path of resolved.terminalPaths) {
+    const pathLabel = path.states.join(" \u2192 ");
+    const steps = [];
+    for (let i = 0; i < path.transitions.length; i++) {
+      const transitionName = path.transitions[i];
+      const expectedState = path.states[i + 1];
+      const stateDef = def.states.find((s) => s.name === expectedState);
+      const isTerminal = stateDef?.type === "END" || stateDef?.type === "CANCELLED";
+      const expectedStatus = stateDef?.type === "END" ? "COMPLETED" : stateDef?.type === "CANCELLED" ? "CANCELLED" : "ACTIVE";
+      steps.push({
+        name: `${transitionName} \u2192 ${expectedState}`,
+        action: { type: "transition", name: transitionName },
+        assertions: [
+          {
+            target: "state",
+            operator: "eq",
+            expected: expectedState,
+            label: `State should be "${expectedState}"`
+          },
+          ...isTerminal ? [
+            {
+              target: "status",
+              operator: "eq",
+              expected: expectedStatus,
+              label: `Status should be "${expectedStatus}"`
+            }
+          ] : []
+        ]
+      });
+    }
+    scenarios.push({
+      name: `Path: ${pathLabel}`,
+      tags: ["auto-generated", "coverage"],
+      steps
+    });
+  }
+  return scenarios;
+}
+
+// src/testing/test-runner.ts
+async function runTestProgram(program, config) {
+  const start = performance.now();
+  const scenarioResults = [];
+  let allPassed = true;
+  for (let i = 0; i < program.scenarios.length; i++) {
+    if (config?.abortSignal?.aborted) {
+      break;
+    }
+    const result = await runScenario(program.scenarios[i], program.definitions, config);
+    scenarioResults.push(result);
+    if (!result.passed) allPassed = false;
+    config?.onScenarioComplete?.(result);
+  }
+  return {
+    passed: allPassed,
+    scenarioResults,
+    durationMs: performance.now() - start
+  };
+}
+async function runScenario(scenario, definitions, config) {
+  const start = performance.now();
+  try {
+    const evaluator = createEvaluator({
+      functions: [],
+      failurePolicy: WEB_FAILURE_POLICIES.EVENT_REACTION
+    });
+    const eventBus = scenario.connectEventBuses ? new EventBus() : null;
+    const instances = /* @__PURE__ */ new Map();
+    if (scenario.instances?.length) {
+      for (const inst of scenario.instances) {
+        const def = definitions[inst.definitionSlug];
+        if (!def) {
+          return {
+            scenarioName: scenario.name,
+            passed: false,
+            stepResults: [],
+            durationMs: performance.now() - start,
+            error: `Definition not found: "${inst.definitionSlug}"`
+          };
+        }
+        const sm = createStateMachine(def, inst.initialData ?? {}, evaluator, config);
+        instances.set(inst.id, sm);
+        if (eventBus) {
+          wireOnEventSubscriptions(sm, eventBus, evaluator);
+        }
+      }
+    } else {
+      const defKeys = Object.keys(definitions);
+      if (defKeys.length === 0) {
+        return {
+          scenarioName: scenario.name,
+          passed: false,
+          stepResults: [],
+          durationMs: performance.now() - start,
+          error: "No definitions provided"
+        };
+      }
+      const def = definitions[defKeys[0]];
+      const sm = createStateMachine(def, {}, evaluator, config);
+      instances.set("default", sm);
+      if (eventBus) {
+        wireOnEventSubscriptions(sm, eventBus, evaluator);
+      }
+    }
+    const stepResults = [];
+    let allPassed = true;
+    for (let i = 0; i < scenario.steps.length; i++) {
+      if (config?.abortSignal?.aborted) {
+        break;
+      }
+      const step = scenario.steps[i];
+      const stepResult = await executeStep(step, instances, eventBus, evaluator);
+      stepResults.push(stepResult);
+      if (!stepResult.passed) allPassed = false;
+      config?.onStepComplete?.(0, stepResult);
+    }
+    return {
+      scenarioName: scenario.name,
+      passed: allPassed,
+      stepResults,
+      durationMs: performance.now() - start
+    };
+  } catch (error) {
+    return {
+      scenarioName: scenario.name,
+      passed: false,
+      stepResults: [],
+      durationMs: performance.now() - start,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createStateMachine(def, initialData, evaluator, config) {
+  const actionHandlers = /* @__PURE__ */ new Map();
+  let smRef = null;
+  actionHandlers.set("set_field", (action) => {
+    if (smRef && typeof action.config.field === "string") {
+      smRef.setField(action.config.field, action.config.value);
+    }
+  });
+  actionHandlers.set("set_memory", (action) => {
+    if (smRef && typeof action.config.key === "string") {
+      smRef.setMemory(action.config.key, action.config.value);
+    }
+  });
+  if (config?.actionHandlers) {
+    for (const [type, handler] of Object.entries(config.actionHandlers)) {
+      actionHandlers.set(type, (action, ctx) => handler(action.config, ctx));
+    }
+  }
+  const sm = new StateMachine(def, initialData, { evaluator, actionHandlers });
+  smRef = sm;
+  return sm;
+}
+function wireOnEventSubscriptions(sm, eventBus, evaluator) {
+  const unsubs = [];
+  function subscribeCurrentState() {
+    for (const unsub of unsubs) unsub();
+    unsubs.length = 0;
+    const stateDef = sm.getCurrentStateDefinition();
+    if (!stateDef?.on_event?.length) return;
+    for (const sub of stateDef.on_event) {
+      const unsub = eventBus.subscribe(sub.match, async (event) => {
+        const ctx = {
+          ...sm.stateData,
+          state_data: sm.stateData,
+          event: event.payload,
+          current_state: sm.currentState,
+          status: sm.status
+        };
+        if (sub.conditions?.length) {
+          for (const condition of sub.conditions) {
+            const result = evaluator.evaluate(condition, ctx);
+            if (!result.value) return;
+          }
+        }
+        for (const action of sub.actions) {
+          if (action.type === "set_field" && typeof action.config.field === "string") {
+            sm.setField(action.config.field, action.config.value);
+          } else if (action.type === "set_memory" && typeof action.config.key === "string") {
+            sm.setMemory(action.config.key, action.config.value);
+          }
+        }
+      });
+      unsubs.push(unsub);
+    }
+  }
+  subscribeCurrentState();
+  sm.on((event) => {
+    if (event.type === "state_enter") {
+      subscribeCurrentState();
+    }
+  });
+}
+async function executeStep(step, instances, eventBus, evaluator) {
+  const stepStart = performance.now();
+  try {
+    const instanceId = step.instanceId ?? "default";
+    const sm = instances.get(instanceId);
+    if (step.action.type !== "assert_only") {
+      if (!sm && step.action.type !== "publish_event") {
+        return {
+          stepName: step.name,
+          passed: false,
+          assertionResults: [],
+          durationMs: performance.now() - stepStart,
+          error: `Instance not found: "${instanceId}"`
+        };
+      }
+      switch (step.action.type) {
+        case "transition": {
+          const result = await sm.transition(step.action.name, step.action.data);
+          if (!result.success) {
+            return {
+              stepName: step.name,
+              passed: false,
+              assertionResults: [],
+              durationMs: performance.now() - stepStart,
+              error: `Transition failed: ${result.error}`
+            };
+          }
+          break;
+        }
+        case "set_field": {
+          sm.setField(step.action.field, step.action.value);
+          break;
+        }
+        case "publish_event": {
+          if (eventBus) {
+            await eventBus.publish(step.action.topic, step.action.payload ?? {});
+          }
+          break;
+        }
+      }
+    }
+    const assertionResults = evaluateAssertions(step.assertions, instances, evaluator);
+    const passed = assertionResults.every((r) => r.passed);
+    return {
+      stepName: step.name,
+      passed,
+      assertionResults,
+      durationMs: performance.now() - stepStart
+    };
+  } catch (error) {
+    return {
+      stepName: step.name,
+      passed: false,
+      assertionResults: [],
+      durationMs: performance.now() - stepStart,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function evaluateAssertions(assertions, instances, _evaluator) {
+  return assertions.map((assertion) => {
+    try {
+      const instanceId = assertion.instanceId ?? "default";
+      const sm = instances.get(instanceId);
+      if (!sm) {
+        return {
+          passed: false,
+          assertion,
+          actual: void 0,
+          error: `Instance not found: "${instanceId}"`
+        };
+      }
+      const actual = getAssertionTarget(assertion, sm);
+      const passed = compareValues(actual, assertion.operator, assertion.expected);
+      return { passed, assertion, actual };
+    } catch (error) {
+      return {
+        passed: false,
+        assertion,
+        actual: void 0,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+}
+function getAssertionTarget(assertion, sm) {
+  switch (assertion.target) {
+    case "state":
+      return sm.currentState;
+    case "status":
+      return sm.status;
+    case "state_data": {
+      if (!assertion.path) return sm.stateData;
+      return getNestedValue(sm.stateData, assertion.path);
+    }
+    case "available_transitions":
+      return sm.getAvailableTransitions().map((t) => t.name);
+    default:
+      throw new Error(`Unknown assertion target: "${assertion.target}"`);
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function compareValues(actual, operator, expected) {
+  switch (operator) {
+    case "eq":
+      return deepEqual(actual, expected);
+    case "neq":
+      return !deepEqual(actual, expected);
+    case "gt":
+      return typeof actual === "number" && typeof expected === "number" && actual > expected;
+    case "gte":
+      return typeof actual === "number" && typeof expected === "number" && actual >= expected;
+    case "lt":
+      return typeof actual === "number" && typeof expected === "number" && actual < expected;
+    case "lte":
+      return typeof actual === "number" && typeof expected === "number" && actual <= expected;
+    case "contains": {
+      if (Array.isArray(actual)) return actual.includes(expected);
+      if (typeof actual === "string" && typeof expected === "string") return actual.includes(expected);
+      return false;
+    }
+    case "truthy":
+      return Boolean(actual);
+    case "falsy":
+      return !actual;
+    default:
+      return false;
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(
+      (k) => deepEqual(
+        a[k],
+        b[k]
+      )
+    );
+  }
+  return false;
+}
+
+// src/testing/test-compiler.ts
+function compileTestScenario(scenario, definitions, scenarioIndex = 0) {
+  const states = [];
+  const transitions = [];
+  const stepCount = scenario.steps.length;
+  states.push({
+    name: "__idle",
+    type: "START"
+  });
+  const setupActions = [
+    {
+      type: "__test_init",
+      config: {
+        scenarioName: scenario.name,
+        scenarioIndex,
+        definitions: Object.keys(definitions),
+        connectEventBuses: scenario.connectEventBuses ?? false
+      }
+    }
+  ];
+  if (scenario.instances?.length) {
+    for (const inst of scenario.instances) {
+      setupActions.push({
+        type: "__test_create_instance",
+        config: {
+          testId: inst.id,
+          definitionSlug: inst.definitionSlug,
+          initialData: inst.initialData ?? {}
+        }
+      });
+    }
+  } else {
+    const firstSlug = Object.keys(definitions)[0];
+    if (firstSlug) {
+      setupActions.push({
+        type: "__test_create_instance",
+        config: {
+          testId: "default",
+          definitionSlug: firstSlug,
+          initialData: {}
+        }
+      });
+    }
+  }
+  states.push({
+    name: "__setup",
+    type: "REGULAR",
+    on_enter: setupActions
+  });
+  for (let i = 0; i < stepCount; i++) {
+    const step = scenario.steps[i];
+    states.push({
+      name: `__step_${i}`,
+      type: "REGULAR",
+      on_enter: compileStepActions(step, i)
+    });
+  }
+  states.push({
+    name: "__pass",
+    type: "END",
+    on_enter: [
+      { type: "__test_report", config: { passed: true } }
+    ]
+  });
+  states.push({
+    name: "__fail",
+    type: "CANCELLED",
+    on_enter: [
+      { type: "__test_report", config: { passed: false } }
+    ]
+  });
+  transitions.push({
+    name: "setup",
+    from: ["__idle"],
+    to: "__setup"
+  });
+  transitions.push({
+    name: "next",
+    from: ["__setup"],
+    to: stepCount > 0 ? "__step_0" : "__pass"
+  });
+  for (let i = 0; i < stepCount; i++) {
+    transitions.push({
+      name: "next",
+      from: [`__step_${i}`],
+      to: i < stepCount - 1 ? `__step_${i + 1}` : "__pass"
+    });
+  }
+  const abortFromStates = ["__setup", ...Array.from({ length: stepCount }, (_, i) => `__step_${i}`)];
+  transitions.push({
+    name: "abort",
+    from: abortFromStates,
+    to: "__fail"
+  });
+  return {
+    id: `__test_scenario_${scenarioIndex}`,
+    slug: `__test_scenario_${scenarioIndex}`,
+    states,
+    transitions
+  };
+}
+function compileTestProgram(program) {
+  return program.scenarios.map(
+    (scenario, i) => compileTestScenario(scenario, program.definitions, i)
+  );
+}
+function compileStepActions(step, stepIndex) {
+  const actions = [];
+  const defaultTestId = step.instanceId ?? "default";
+  actions.push({
+    type: "__test_step_begin",
+    config: { stepName: step.name, stepIndex }
+  });
+  switch (step.action.type) {
+    case "transition":
+      actions.push({
+        type: "__test_transition",
+        config: {
+          testId: defaultTestId,
+          transitionName: step.action.name,
+          data: step.action.data
+        }
+      });
+      break;
+    case "set_field":
+      actions.push({
+        type: "__test_set_field",
+        config: {
+          testId: defaultTestId,
+          field: step.action.field,
+          value: step.action.value
+        }
+      });
+      break;
+    case "publish_event":
+      actions.push({
+        type: "__test_publish_event",
+        config: {
+          topic: step.action.topic,
+          payload: step.action.payload ?? {}
+        }
+      });
+      break;
+    case "assert_only":
+      break;
+  }
+  actions.push({
+    type: "__test_settle",
+    config: {}
+  });
+  for (let a = 0; a < step.assertions.length; a++) {
+    const assertion = step.assertions[a];
+    actions.push({
+      type: "__test_assert",
+      config: {
+        testId: assertion.instanceId ?? defaultTestId,
+        target: assertion.target,
+        path: assertion.path,
+        operator: assertion.operator,
+        expected: assertion.expected,
+        label: assertion.label,
+        assertionIndex: a
+      }
+    });
+  }
+  actions.push({
+    type: "__test_step_end",
+    config: { stepIndex }
+  });
+  return actions;
+}
+
+// src/testing/test-actions.ts
+function createTestState() {
+  return {
+    stepResults: [],
+    failed: false,
+    currentStep: null,
+    setOrchestratorField: () => {
+    }
+  };
+}
+function createInProcessTestActions(definitions) {
+  const testState = createTestState();
+  const handlers = /* @__PURE__ */ new Map();
+  const evaluator = createEvaluator({
+    functions: [],
+    failurePolicy: WEB_FAILURE_POLICIES.EVENT_REACTION
+  });
+  const machines = /* @__PURE__ */ new Map();
+  let eventBus = null;
+  handlers.set("__test_init", (action) => {
+    const config = action.config;
+    if (config.connectEventBuses) {
+      eventBus = new EventBus();
+    }
+  });
+  handlers.set("__test_create_instance", (action) => {
+    const { testId, definitionSlug, initialData } = action.config;
+    const def = definitions[definitionSlug];
+    if (!def) {
+      throw new Error(`Definition not found: "${definitionSlug}"`);
+    }
+    const smHandlers = createInstanceActionHandlers(def, evaluator);
+    const sm = new StateMachine(def, initialData, { evaluator, actionHandlers: smHandlers });
+    machines.set(testId, sm);
+    if (eventBus) {
+      wireOnEventSubscriptions2(sm, eventBus, evaluator);
+    }
+  });
+  handlers.set("__test_step_begin", (action) => {
+    const { stepName, stepIndex } = action.config;
+    testState.currentStep = {
+      name: stepName,
+      index: stepIndex,
+      startTime: performance.now(),
+      assertions: []
+    };
+  });
+  handlers.set("__test_step_end", (_action) => {
+    if (!testState.currentStep) return;
+    const step = testState.currentStep;
+    const passed = !step.error && step.assertions.every((a) => a.passed);
+    if (!passed) testState.failed = true;
+    testState.stepResults.push({
+      stepName: step.name,
+      passed,
+      assertionResults: step.assertions,
+      durationMs: performance.now() - step.startTime,
+      error: step.error
+    });
+    testState.setOrchestratorField("__test_step_failed", !passed);
+    testState.currentStep = null;
+  });
+  handlers.set("__test_transition", async (action) => {
+    const { testId, transitionName, data } = action.config;
+    const sm = machines.get(testId);
+    if (!sm) {
+      if (testState.currentStep) {
+        testState.currentStep.error = `Instance not found: "${testId}"`;
+      }
+      return;
+    }
+    const result = await sm.transition(transitionName, data);
+    if (!result.success) {
+      if (testState.currentStep) {
+        testState.currentStep.error = `Transition failed: ${result.error}`;
+      }
+    }
+  });
+  handlers.set("__test_set_field", (action) => {
+    const { testId, field, value } = action.config;
+    const sm = machines.get(testId);
+    if (!sm) {
+      if (testState.currentStep) {
+        testState.currentStep.error = `Instance not found: "${testId}"`;
+      }
+      return;
+    }
+    sm.setField(field, value);
+  });
+  handlers.set("__test_publish_event", async (action) => {
+    const { topic, payload } = action.config;
+    if (eventBus) {
+      await eventBus.publish(topic, payload);
+    }
+  });
+  handlers.set("__test_settle", () => {
+  });
+  handlers.set("__test_assert", (action) => {
+    const { testId, target, path, operator, expected, label } = action.config;
+    const sm = machines.get(testId);
+    if (!sm) {
+      testState.currentStep?.assertions.push({
+        passed: false,
+        assertion: { target, path, operator, expected, label },
+        actual: void 0,
+        error: `Instance not found: "${testId}"`
+      });
+      return;
+    }
+    const actual = getInProcessTarget(target, path, sm);
+    const passed = compareValues2(actual, operator, expected);
+    testState.currentStep?.assertions.push({
+      passed,
+      assertion: { target, path, operator, expected, label },
+      actual
+    });
+  });
+  handlers.set("__test_report", () => {
+  });
+  handlers.set("set_field", (action) => {
+    testState.setOrchestratorField(
+      action.config.field,
+      action.config.value
+    );
+  });
+  return { handlers, state: testState };
+}
+function createApiTestActions(adapter, options) {
+  const testState = createTestState();
+  const handlers = /* @__PURE__ */ new Map();
+  const settleDelayMs = options?.settleDelayMs ?? 200;
+  const instanceMap = /* @__PURE__ */ new Map();
+  const createdIds = [];
+  handlers.set("__test_init", () => {
+  });
+  handlers.set("__test_create_instance", async (action) => {
+    const { testId, definitionSlug, initialData } = action.config;
+    const snapshot = await adapter.createInstance({
+      definitionSlug,
+      stateData: Object.keys(initialData).length > 0 ? initialData : void 0
+    });
+    instanceMap.set(testId, snapshot.id);
+    createdIds.push(snapshot.id);
+    await adapter.startInstance(snapshot.id);
+  });
+  handlers.set("__test_step_begin", (action) => {
+    const { stepName, stepIndex } = action.config;
+    testState.currentStep = {
+      name: stepName,
+      index: stepIndex,
+      startTime: performance.now(),
+      assertions: []
+    };
+  });
+  handlers.set("__test_step_end", (_action) => {
+    if (!testState.currentStep) return;
+    const step = testState.currentStep;
+    const passed = !step.error && step.assertions.every((a) => a.passed);
+    if (!passed) testState.failed = true;
+    testState.stepResults.push({
+      stepName: step.name,
+      passed,
+      assertionResults: step.assertions,
+      durationMs: performance.now() - step.startTime,
+      error: step.error
+    });
+    testState.setOrchestratorField("__test_step_failed", !passed);
+    testState.currentStep = null;
+  });
+  handlers.set("__test_transition", async (action) => {
+    const { testId, transitionName, data } = action.config;
+    const serverId = instanceMap.get(testId);
+    if (!serverId) {
+      if (testState.currentStep) {
+        testState.currentStep.error = `Instance not found: "${testId}"`;
+      }
+      return;
+    }
+    const result = await adapter.triggerTransition(serverId, transitionName, data);
+    if (!result.success) {
+      if (testState.currentStep) {
+        testState.currentStep.error = `Transition failed: ${result.error ?? "unknown"}`;
+      }
+    }
+  });
+  handlers.set("__test_set_field", async (action) => {
+    const { testId, field, value } = action.config;
+    const serverId = instanceMap.get(testId);
+    if (!serverId) {
+      if (testState.currentStep) {
+        testState.currentStep.error = `Instance not found: "${testId}"`;
+      }
+      return;
+    }
+    await adapter.updateStateData(serverId, { [field]: value });
+  });
+  handlers.set("__test_publish_event", async (_action) => {
+    if (testState.currentStep) {
+      testState.currentStep.error = "publish_event not supported in API mode. Events flow via EventRouter when transitions fire.";
+    }
+  });
+  handlers.set("__test_settle", async () => {
+    if (settleDelayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, settleDelayMs));
+    }
+  });
+  handlers.set("__test_assert", async (action) => {
+    const { testId, target, path, operator, expected, label } = action.config;
+    const serverId = instanceMap.get(testId);
+    if (!serverId) {
+      testState.currentStep?.assertions.push({
+        passed: false,
+        assertion: { target, path, operator, expected, label },
+        actual: void 0,
+        error: `Instance not found: "${testId}"`
+      });
+      return;
+    }
+    const snapshot = await adapter.getInstance(serverId);
+    const actual = getApiTarget(target, path, snapshot);
+    const passed = compareValues2(actual, operator, expected);
+    testState.currentStep?.assertions.push({
+      passed,
+      assertion: { target, path, operator, expected, label },
+      actual
+    });
+  });
+  handlers.set("__test_report", () => {
+  });
+  handlers.set("set_field", (action) => {
+    testState.setOrchestratorField(
+      action.config.field,
+      action.config.value
+    );
+  });
+  return {
+    handlers,
+    state: testState,
+    // Expose for cleanup
+    getCreatedInstanceIds: () => createdIds,
+    getInstanceMap: () => instanceMap
+  };
+}
+function getInProcessTarget(target, path, sm) {
+  switch (target) {
+    case "state":
+      return sm.currentState;
+    case "status":
+      return sm.status;
+    case "state_data":
+      if (!path) return sm.stateData;
+      return getNestedValue2(sm.stateData, path);
+    case "available_transitions":
+      return sm.getAvailableTransitions().map((t) => t.name);
+    default:
+      throw new Error(`Unknown assertion target: "${target}"`);
+  }
+}
+function getApiTarget(target, path, snapshot) {
+  switch (target) {
+    case "state":
+      return snapshot.currentState;
+    case "status":
+      return snapshot.status;
+    case "state_data":
+      if (!path) return snapshot.stateData;
+      return getNestedValue2(snapshot.stateData, path);
+    case "available_transitions":
+      return snapshot.availableTransitions;
+    default:
+      throw new Error(`Unknown assertion target: "${target}"`);
+  }
+}
+function getNestedValue2(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function compareValues2(actual, operator, expected) {
+  switch (operator) {
+    case "eq":
+      return deepEqual2(actual, expected);
+    case "neq":
+      return !deepEqual2(actual, expected);
+    case "gt":
+      return typeof actual === "number" && typeof expected === "number" && actual > expected;
+    case "gte":
+      return typeof actual === "number" && typeof expected === "number" && actual >= expected;
+    case "lt":
+      return typeof actual === "number" && typeof expected === "number" && actual < expected;
+    case "lte":
+      return typeof actual === "number" && typeof expected === "number" && actual <= expected;
+    case "contains": {
+      if (Array.isArray(actual)) return actual.includes(expected);
+      if (typeof actual === "string" && typeof expected === "string")
+        return actual.includes(expected);
+      return false;
+    }
+    case "truthy":
+      return Boolean(actual);
+    case "falsy":
+      return !actual;
+    default:
+      return false;
+  }
+}
+function deepEqual2(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual2(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(
+      (k) => deepEqual2(
+        a[k],
+        b[k]
+      )
+    );
+  }
+  return false;
+}
+function createInstanceActionHandlers(_def, _evaluator) {
+  const handlers = /* @__PURE__ */ new Map();
+  let smRef = null;
+  handlers.set("set_field", (action) => {
+    if (smRef && typeof action.config.field === "string") {
+      smRef.setField(action.config.field, action.config.value);
+    }
+  });
+  handlers.set("set_memory", (action) => {
+    if (smRef && typeof action.config.key === "string") {
+      smRef.setMemory(action.config.key, action.config.value);
+    }
+  });
+  handlers.__bindSm = (sm) => {
+    smRef = sm;
+  };
+  return handlers;
+}
+function wireOnEventSubscriptions2(sm, eventBus, evaluator) {
+  const unsubs = [];
+  function subscribeCurrentState() {
+    for (const unsub of unsubs) unsub();
+    unsubs.length = 0;
+    const stateDef = sm.getCurrentStateDefinition();
+    if (!stateDef?.on_event?.length) return;
+    for (const sub of stateDef.on_event) {
+      const unsub = eventBus.subscribe(sub.match, async (event) => {
+        const ctx = {
+          ...sm.stateData,
+          state_data: sm.stateData,
+          event: event.payload,
+          current_state: sm.currentState,
+          status: sm.status
+        };
+        if (sub.conditions?.length) {
+          for (const condition of sub.conditions) {
+            const result = evaluator.evaluate(condition, ctx);
+            if (!result.value) return;
+          }
+        }
+        for (const action of sub.actions) {
+          if (action.type === "set_field" && typeof action.config.field === "string") {
+            sm.setField(action.config.field, action.config.value);
+          } else if (action.type === "set_memory" && typeof action.config.key === "string") {
+            sm.setMemory(action.config.key, action.config.value);
+          }
+        }
+      });
+      unsubs.push(unsub);
+    }
+  }
+  subscribeCurrentState();
+  sm.on((event) => {
+    if (event.type === "state_enter") {
+      subscribeCurrentState();
+    }
+  });
+}
+
+// src/testing/blueprint-test-runner.ts
+async function runBlueprintTestProgram(program, config) {
+  const start = performance.now();
+  const scenarioResults = [];
+  let allPassed = true;
+  for (let i = 0; i < program.scenarios.length; i++) {
+    if (config.abortSignal?.aborted) break;
+    const result = await runBlueprintScenario(
+      program.scenarios[i],
+      program.definitions,
+      i,
+      config
+    );
+    scenarioResults.push(result);
+    if (!result.passed) allPassed = false;
+    config.onScenarioComplete?.(result);
+  }
+  return {
+    passed: allPassed,
+    scenarioResults,
+    durationMs: performance.now() - start
+  };
+}
+async function runBlueprintScenario(scenario, definitions, scenarioIndex, config) {
+  const start = performance.now();
+  try {
+    const blueprint = compileTestScenario(scenario, definitions, scenarioIndex);
+    const { handlers, state: testState } = createActionHandlers(definitions, config);
+    const evaluator = createEvaluator({
+      functions: [],
+      failurePolicy: WEB_FAILURE_POLICIES.EVENT_REACTION
+    });
+    const sm = new StateMachine(blueprint, {}, { evaluator, actionHandlers: handlers });
+    testState.setOrchestratorField = (field, value) => {
+      sm.setField(field, value);
+    };
+    const stepCount = scenario.steps.length;
+    const setupResult = await sm.transition("setup");
+    if (!setupResult.success) {
+      return {
+        scenarioName: scenario.name,
+        passed: false,
+        stepResults: [],
+        durationMs: performance.now() - start,
+        error: `Setup failed: ${setupResult.error}`
+      };
+    }
+    for (let i = 0; i < stepCount; i++) {
+      if (config.abortSignal?.aborted) break;
+      const result = await sm.transition("next");
+      if (!result.success) {
+        testState.stepResults.push({
+          stepName: scenario.steps[i]?.name ?? `step_${i}`,
+          passed: false,
+          assertionResults: [],
+          durationMs: 0,
+          error: `Blueprint transition failed: ${result.error}`
+        });
+        testState.failed = true;
+        break;
+      }
+      const lastStep = testState.stepResults[testState.stepResults.length - 1];
+      if (lastStep) {
+        config.onStepComplete?.(scenarioIndex, lastStep);
+      }
+      if (sm.stateData.__test_step_failed) {
+        await sm.transition("abort");
+        break;
+      }
+    }
+    if (!testState.failed && !config.abortSignal?.aborted) {
+      await sm.transition("next");
+    }
+    const passed = !testState.failed;
+    return {
+      scenarioName: scenario.name,
+      passed,
+      stepResults: testState.stepResults,
+      durationMs: performance.now() - start
+    };
+  } catch (error) {
+    return {
+      scenarioName: scenario.name,
+      passed: false,
+      stepResults: [],
+      durationMs: performance.now() - start,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createActionHandlers(definitions, config) {
+  if (config.mode === "api") {
+    return createApiTestActions(config.adapter, {
+      settleDelayMs: config.settleDelayMs
+    });
+  }
+  return createInProcessTestActions(definitions);
+}
+
+// src/testing/nrt-types.ts
+function createEmptyNRT() {
+  return {
+    version: 1,
+    root: {
+      id: "root",
+      type: "Root",
+      visible: true,
+      children: []
+    }
+  };
+}
+function findNode(nrt, nodeId) {
+  return findNodeRecursive(nrt.root, nodeId);
+}
+function findNodeRecursive(node, nodeId) {
+  if (node.id === nodeId) return node;
+  for (const child of node.children) {
+    const found = findNodeRecursive(child, nodeId);
+    if (found) return found;
+  }
+  return void 0;
+}
+function findVisibleNodes(nrt) {
+  const result = [];
+  collectVisible(nrt.root, result);
+  return result;
+}
+function collectVisible(node, result) {
+  if (node.visible) {
+    result.push(node);
+    for (const child of node.children) {
+      collectVisible(child, result);
+    }
+  }
+}
+function findInteractiveNodes(nrt) {
+  const result = [];
+  collectInteractive(nrt.root, result);
+  return result;
+}
+function collectInteractive(node, result) {
+  if (node.events && Object.keys(node.events).length > 0) {
+    result.push(node);
+  }
+  for (const child of node.children) {
+    collectInteractive(child, result);
+  }
+}
+function countNodes(nrt) {
+  return countNodesRecursive(nrt.root);
+}
+function countNodesRecursive(node) {
+  let count = 1;
+  for (const child of node.children) {
+    count += countNodesRecursive(child);
+  }
+  return count;
+}
+
+// src/testing/nrt-comparator.ts
+function compareNRT(before, after) {
+  const changes = [];
+  if (before.workflowState !== after.workflowState) {
+    changes.push({
+      type: "modified",
+      path: "workflowState",
+      field: "workflowState",
+      oldValue: before.workflowState,
+      newValue: after.workflowState
+    });
+  }
+  if (before.nav?.routeState !== after.nav?.routeState) {
+    changes.push({
+      type: "modified",
+      path: "nav.routeState",
+      field: "routeState",
+      oldValue: before.nav?.routeState,
+      newValue: after.nav?.routeState
+    });
+  }
+  compareNodes(before.root, after.root, "root", changes);
+  return {
+    equal: changes.length === 0,
+    changes
+  };
+}
+function compareNodes(before, after, path, changes) {
+  if (!before && after) {
+    changes.push({
+      type: "added",
+      path,
+      nodeId: after.id,
+      field: "node",
+      newValue: summarizeNode(after)
+    });
+    return;
+  }
+  if (before && !after) {
+    changes.push({
+      type: "removed",
+      path,
+      nodeId: before.id,
+      field: "node",
+      oldValue: summarizeNode(before)
+    });
+    return;
+  }
+  if (!before || !after) return;
+  if (before.type !== after.type) {
+    changes.push({
+      type: "modified",
+      path,
+      nodeId: after.id,
+      field: "type",
+      oldValue: before.type,
+      newValue: after.type
+    });
+  }
+  if (before.text !== after.text) {
+    changes.push({
+      type: "modified",
+      path,
+      nodeId: after.id,
+      field: "text",
+      oldValue: before.text,
+      newValue: after.text
+    });
+  }
+  if (before.visible !== after.visible) {
+    changes.push({
+      type: "modified",
+      path,
+      nodeId: after.id,
+      field: "visible",
+      oldValue: before.visible,
+      newValue: after.visible
+    });
+  }
+  if (before.enabled !== after.enabled) {
+    changes.push({
+      type: "modified",
+      path,
+      nodeId: after.id,
+      field: "enabled",
+      oldValue: before.enabled,
+      newValue: after.enabled
+    });
+  }
+  if (JSON.stringify(before.value) !== JSON.stringify(after.value)) {
+    changes.push({
+      type: "modified",
+      path,
+      nodeId: after.id,
+      field: "value",
+      oldValue: before.value,
+      newValue: after.value
+    });
+  }
+  const beforeEvents = Object.keys(before.events || {});
+  const afterEvents = Object.keys(after.events || {});
+  for (const event of afterEvents) {
+    if (!beforeEvents.includes(event)) {
+      changes.push({
+        type: "added",
+        path: `${path}.events`,
+        nodeId: after.id,
+        field: event,
+        newValue: after.events[event]
+      });
+    }
+  }
+  for (const event of beforeEvents) {
+    if (!afterEvents.includes(event)) {
+      changes.push({
+        type: "removed",
+        path: `${path}.events`,
+        nodeId: before.id,
+        field: event,
+        oldValue: before.events[event]
+      });
+    }
+  }
+  const maxChildren = Math.max(before.children.length, after.children.length);
+  for (let i = 0; i < maxChildren; i++) {
+    compareNodes(
+      before.children[i],
+      after.children[i],
+      `${path}.children[${i}]`,
+      changes
+    );
+  }
+}
+function summarizeNode(node) {
+  return {
+    id: node.id,
+    type: node.type,
+    text: node.text,
+    visible: node.visible,
+    childCount: node.children.length
+  };
+}
+
+// src/testing/action-trace.ts
+function createActionRecorder(workflowSlug, instanceId) {
+  let tickCounter = 0;
+  let ticks = [];
+  let startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let endedAt;
+  function recordTick(kind, name, extra) {
+    ticks.push({
+      tick: tickCounter++,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      kind,
+      name,
+      fromState: extra?.fromState,
+      toState: extra?.toState,
+      durationMs: extra?.durationMs,
+      detail: extra?.detail || {}
+    });
+  }
+  return {
+    recordTransition(name, fromState, toState, detail) {
+      recordTick("transition", name, { fromState, toState, detail });
+    },
+    recordAction(name, detail) {
+      recordTick("action", name, { detail });
+    },
+    recordTimer(name, detail) {
+      recordTick("timer", name, { detail });
+    },
+    recordQuery(name, detail) {
+      recordTick("query", name, { detail });
+    },
+    recordMutation(name, detail) {
+      recordTick("mutation", name, { detail });
+    },
+    recordEvent(name, detail) {
+      recordTick("event", name, { detail });
+    },
+    recordError(name, detail) {
+      recordTick("error", name, { detail });
+    },
+    getTrace() {
+      return {
+        version: 1,
+        workflowSlug,
+        instanceId,
+        startedAt,
+        endedAt,
+        ticks: [...ticks]
+      };
+    },
+    finalize() {
+      endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return this.getTrace();
+    },
+    reset() {
+      tickCounter = 0;
+      ticks = [];
+      startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      endedAt = void 0;
+    }
+  };
+}
+function getTransitionPath(trace) {
+  return trace.ticks.filter((t) => t.kind === "transition").map((t) => `${t.fromState} \u2192 ${t.toState}`);
+}
+function getFinalState(trace) {
+  const transitions = trace.ticks.filter((t) => t.kind === "transition");
+  if (transitions.length === 0) return void 0;
+  return transitions[transitions.length - 1].toState;
+}
+function countByKind(trace) {
+  const counts = {};
+  for (const tick of trace.ticks) {
+    counts[tick.kind] = (counts[tick.kind] || 0) + 1;
+  }
+  return counts;
+}
+function hasTransition(trace, from, to) {
+  return trace.ticks.some(
+    (t) => t.kind === "transition" && t.fromState === from && t.toState === to
+  );
+}
+
+// src/validation/definition-validator.ts
+var DEFAULT_BINDING_ROOTS = [
+  "$instance",
+  "$definition",
+  "$instances",
+  "$local",
+  "$entity",
+  "$user",
+  "$fn",
+  "$action",
+  "$item",
+  "$index",
+  "$pagination"
+];
+function validateDefinition(def, options = {}) {
+  const issues = [];
+  const knownRoots = options.knownBindingRoots ?? DEFAULT_BINDING_ROOTS;
+  validateStructure(def, issues);
+  validateReferences(def, issues);
+  if (!options.skipSemantic) {
+    validateSemantics(def, issues);
+  }
+  if (!options.skipExperience && def.metadata?.experience) {
+    validateExperienceTree(
+      def.metadata.experience,
+      options.knownComponents,
+      knownRoots,
+      issues
+    );
+  }
+  const errorCount = issues.filter((i) => i.severity === "error").length;
+  const warningCount = issues.filter((i) => i.severity === "warning").length;
+  return {
+    valid: errorCount === 0,
+    issues,
+    errorCount,
+    warningCount,
+    summary: {
+      stateCount: def.states?.length ?? 0,
+      transitionCount: def.transitions?.length ?? 0,
+      fieldCount: def.fields?.length ?? 0,
+      hasExperience: !!def.metadata?.experience,
+      hasExtensions: !!def.extensions && Object.keys(def.extensions).length > 0
+    }
+  };
+}
+function validateStructure(def, issues) {
+  if (!def.slug) {
+    issues.push({
+      code: "MISSING_SLUG",
+      message: "Workflow definition is missing a slug",
+      severity: "error",
+      category: "structural",
+      suggestion: "Add a slug field to the workflow definition"
+    });
+  }
+  if (!def.name) {
+    issues.push({
+      code: "MISSING_NAME",
+      message: "Workflow definition is missing a name",
+      severity: "warning",
+      category: "structural",
+      suggestion: "Add a name field to the workflow definition"
+    });
+  }
+  if (!def.version) {
+    issues.push({
+      code: "MISSING_VERSION",
+      message: "Workflow definition is missing a version",
+      severity: "warning",
+      category: "structural",
+      suggestion: 'Add a version field (e.g., "1.0.0")'
+    });
+  }
+  if (!def.states || def.states.length === 0) {
+    issues.push({
+      code: "NO_STATES",
+      message: "Workflow definition has no states",
+      severity: "error",
+      category: "structural",
+      suggestion: "Add at least one state with type START"
+    });
+    return;
+  }
+  for (let i = 0; i < def.states.length; i++) {
+    validateState(def.states[i], i, issues);
+  }
+  if (def.transitions) {
+    for (let i = 0; i < def.transitions.length; i++) {
+      validateTransitionStructure(def.transitions[i], i, issues);
+    }
+  }
+  if (def.fields) {
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (let i = 0; i < def.fields.length; i++) {
+      validateFieldStructure(def.fields[i], i, fieldNames, issues);
+    }
+  }
+}
+function validateState(state, index, issues) {
+  const path = `states[${index}]`;
+  if (!state.name) {
+    issues.push({
+      code: "STATE_MISSING_NAME",
+      message: `State at index ${index} is missing a name`,
+      severity: "error",
+      category: "structural",
+      path
+    });
+  }
+  const stateType = state.type || state.state_type;
+  if (!stateType) {
+    issues.push({
+      code: "STATE_MISSING_TYPE",
+      message: `State '${state.name || index}' is missing a type`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: "Set type to START, REGULAR, END, or CANCELLED"
+    });
+  }
+  if (state.on_enter) {
+    for (let j = 0; j < state.on_enter.length; j++) {
+      validateAction(state.on_enter[j], `${path}.on_enter[${j}]`, issues);
+    }
+  }
+  if (state.on_exit) {
+    for (let j = 0; j < state.on_exit.length; j++) {
+      validateAction(state.on_exit[j], `${path}.on_exit[${j}]`, issues);
+    }
+  }
+  if (state.during) {
+    for (let j = 0; j < state.during.length; j++) {
+      validateDuringAction(state.during[j], `${path}.during[${j}]`, issues);
+    }
+  }
+}
+function validateAction(action, path, issues) {
+  const actionType = action.type || action.action_type;
+  if (!action.id) {
+    issues.push({
+      code: "ACTION_MISSING_ID",
+      message: `Action at ${path} is missing an id`,
+      severity: "warning",
+      category: "structural",
+      path
+    });
+  }
+  if (!actionType) {
+    issues.push({
+      code: "ACTION_MISSING_TYPE",
+      message: `Action '${action.id || "unknown"}' at ${path} is missing a type`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: 'Add a type field (e.g., "set_field", "set_memory")'
+    });
+  }
+}
+function validateDuringAction(during, path, issues) {
+  if (!during.type) {
+    issues.push({
+      code: "DURING_MISSING_TYPE",
+      message: `During action at ${path} is missing a type`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: "Set type to interval, timeout, poll, once, or cron"
+    });
+  }
+  if (during.type === "interval" && !during.interval_ms) {
+    issues.push({
+      code: "DURING_MISSING_INTERVAL",
+      message: `Interval during action at ${path} is missing interval_ms`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: "Set interval_ms to a positive number (milliseconds)"
+    });
+  }
+  if (during.type === "cron" && !during.cron) {
+    issues.push({
+      code: "DURING_MISSING_CRON",
+      message: `Cron during action at ${path} is missing cron expression`,
+      severity: "error",
+      category: "structural",
+      path
+    });
+  }
+}
+function validateTransitionStructure(transition, index, issues) {
+  const path = `transitions[${index}]`;
+  if (!transition.name) {
+    issues.push({
+      code: "TRANSITION_MISSING_NAME",
+      message: `Transition at index ${index} is missing a name`,
+      severity: "error",
+      category: "structural",
+      path
+    });
+  }
+  if (!transition.from || transition.from.length === 0) {
+    issues.push({
+      code: "TRANSITION_MISSING_FROM",
+      message: `Transition '${transition.name || index}' has no source states`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: "Add at least one source state in the from array"
+    });
+  }
+  if (!transition.to) {
+    issues.push({
+      code: "TRANSITION_MISSING_TO",
+      message: `Transition '${transition.name || index}' has no target state`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: "Set the to field to a valid state name"
+    });
+  }
+}
+function validateFieldStructure(field, index, seen, issues) {
+  const path = `fields[${index}]`;
+  if (!field.name) {
+    issues.push({
+      code: "FIELD_MISSING_NAME",
+      message: `Field at index ${index} is missing a name`,
+      severity: "error",
+      category: "structural",
+      path
+    });
+    return;
+  }
+  if (seen.has(field.name)) {
+    issues.push({
+      code: "DUPLICATE_FIELD",
+      message: `Duplicate field name '${field.name}'`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: `Rename one of the '${field.name}' fields`
+    });
+  }
+  seen.add(field.name);
+  const fieldType = field.type || field.field_type;
+  if (!fieldType) {
+    issues.push({
+      code: "FIELD_MISSING_TYPE",
+      message: `Field '${field.name}' is missing a type`,
+      severity: "error",
+      category: "structural",
+      path,
+      suggestion: 'Add a type field (e.g., "text", "number", "boolean")'
+    });
+  }
+}
+function validateReferences(def, issues) {
+  const stateNames = new Set((def.states || []).map((s) => s.name));
+  const fieldNames = new Set((def.fields || []).map((f) => f.name));
+  if (def.transitions) {
+    for (let i = 0; i < def.transitions.length; i++) {
+      const t = def.transitions[i];
+      const path = `transitions[${i}]`;
+      if (t.from) {
+        for (const fromState of t.from) {
+          if (!stateNames.has(fromState)) {
+            issues.push({
+              code: "TRANSITION_UNKNOWN_FROM",
+              message: `Transition '${t.name}' references unknown source state '${fromState}'`,
+              severity: "error",
+              category: "referential",
+              path,
+              suggestion: `Valid states: ${Array.from(stateNames).join(", ")}`
+            });
+          }
+        }
+      }
+      if (t.to && !stateNames.has(t.to)) {
+        issues.push({
+          code: "TRANSITION_UNKNOWN_TO",
+          message: `Transition '${t.name}' references unknown target state '${t.to}'`,
+          severity: "error",
+          category: "referential",
+          path,
+          suggestion: `Valid states: ${Array.from(stateNames).join(", ")}`
+        });
+      }
+      if (t.required_fields) {
+        for (const rf of t.required_fields) {
+          if (!fieldNames.has(rf)) {
+            issues.push({
+              code: "TRANSITION_UNKNOWN_FIELD",
+              message: `Transition '${t.name}' requires unknown field '${rf}'`,
+              severity: "warning",
+              category: "referential",
+              path
+            });
+          }
+        }
+      }
+    }
+  }
+  if (def.states) {
+    for (let i = 0; i < def.states.length; i++) {
+      const state = def.states[i];
+      validateActionFieldRefs(state.on_enter, fieldNames, `states[${i}].on_enter`, issues);
+      validateActionFieldRefs(state.on_exit, fieldNames, `states[${i}].on_exit`, issues);
+    }
+  }
+  if (def.fields) {
+    for (let i = 0; i < def.fields.length; i++) {
+      const field = def.fields[i];
+      const path = `fields[${i}]`;
+      if (field.visible_in_states) {
+        for (const s of field.visible_in_states) {
+          if (!stateNames.has(s)) {
+            issues.push({
+              code: "FIELD_UNKNOWN_STATE",
+              message: `Field '${field.name}' references unknown state '${s}' in visible_in_states`,
+              severity: "warning",
+              category: "referential",
+              path
+            });
+          }
+        }
+      }
+      if (field.editable_in_states) {
+        for (const s of field.editable_in_states) {
+          if (!stateNames.has(s)) {
+            issues.push({
+              code: "FIELD_UNKNOWN_STATE",
+              message: `Field '${field.name}' references unknown state '${s}' in editable_in_states`,
+              severity: "warning",
+              category: "referential",
+              path
+            });
+          }
+        }
+      }
+    }
+  }
+}
+function validateActionFieldRefs(actions, fieldNames, basePath, issues) {
+  if (!actions) return;
+  for (let j = 0; j < actions.length; j++) {
+    const action = actions[j];
+    const actionType = action.type || action.action_type;
+    if (actionType === "set_field" && action.config?.field) {
+      const fieldName = String(action.config.field);
+      if (!fieldNames.has(fieldName)) {
+        issues.push({
+          code: "ACTION_UNKNOWN_FIELD",
+          message: `Action '${action.id}' references unknown field '${fieldName}'`,
+          severity: "warning",
+          category: "referential",
+          path: `${basePath}[${j}]`,
+          suggestion: `Declare field '${fieldName}' in the fields array`
+        });
+      }
+    }
+  }
+}
+function getStateType(state) {
+  return state.type || state.state_type;
+}
+function validateSemantics(def, issues) {
+  if (!def.states || def.states.length === 0) return;
+  const startStates = def.states.filter((s) => getStateType(s) === "START");
+  if (startStates.length === 0) {
+    issues.push({
+      code: "NO_START_STATE",
+      message: "Workflow has no START state",
+      severity: "error",
+      category: "semantic",
+      suggestion: 'Mark one state with type: "START"'
+    });
+  } else if (startStates.length > 1) {
+    issues.push({
+      code: "MULTIPLE_START_STATES",
+      message: `Workflow has ${startStates.length} START states: ${startStates.map((s) => s.name).join(", ")}`,
+      severity: "error",
+      category: "semantic",
+      suggestion: 'Only one state should have type: "START"'
+    });
+  }
+  const stateNameCounts = /* @__PURE__ */ new Map();
+  for (const state of def.states) {
+    const count = stateNameCounts.get(state.name) || 0;
+    stateNameCounts.set(state.name, count + 1);
+  }
+  for (const [name, count] of stateNameCounts) {
+    if (count > 1) {
+      issues.push({
+        code: "DUPLICATE_STATE",
+        message: `Duplicate state name '${name}' (appears ${count} times)`,
+        severity: "error",
+        category: "semantic"
+      });
+    }
+  }
+  if (def.transitions) {
+    const transitionNames = /* @__PURE__ */ new Map();
+    for (const t of def.transitions) {
+      const count = transitionNames.get(t.name) || 0;
+      transitionNames.set(t.name, count + 1);
+    }
+    for (const [name, count] of transitionNames) {
+      if (count > 1) {
+        issues.push({
+          code: "DUPLICATE_TRANSITION",
+          message: `Duplicate transition name '${name}' (appears ${count} times)`,
+          severity: "warning",
+          category: "semantic",
+          suggestion: "Consider using unique transition names for clarity"
+        });
+      }
+    }
+  }
+  if (def.transitions && def.transitions.length > 0) {
+    const reachableStates = /* @__PURE__ */ new Set();
+    for (const state of startStates) {
+      reachableStates.add(state.name);
+    }
+    for (const t of def.transitions) {
+      if (t.to) reachableStates.add(t.to);
+    }
+    for (const state of def.states) {
+      if (!reachableStates.has(state.name)) {
+        issues.push({
+          code: "UNREACHABLE_STATE",
+          message: `State '${state.name}' is unreachable (no transition targets it)`,
+          severity: "warning",
+          category: "semantic",
+          suggestion: `Add a transition with to: "${state.name}" or remove this state`
+        });
+      }
+    }
+  }
+  if (def.transitions) {
+    const statesWithOutgoing = /* @__PURE__ */ new Set();
+    for (const t of def.transitions) {
+      if (t.from) {
+        for (const fromState of t.from) {
+          statesWithOutgoing.add(fromState);
+        }
+      }
+    }
+    for (const state of def.states) {
+      const sType = getStateType(state);
+      if (sType !== "END" && sType !== "CANCELLED" && !statesWithOutgoing.has(state.name)) {
+        issues.push({
+          code: "DEAD_END_STATE",
+          message: `State '${state.name}' has no outgoing transitions (dead end)`,
+          severity: "info",
+          category: "semantic",
+          suggestion: `Add a transition from "${state.name}" or mark it as an END state`
+        });
+      }
+    }
+  }
+  if (def.transitions) {
+    const endStates = new Set(
+      def.states.filter((s) => {
+        const sType = getStateType(s);
+        return sType === "END" || sType === "CANCELLED";
+      }).map((s) => s.name)
+    );
+    for (const t of def.transitions) {
+      if (t.from) {
+        for (const fromState of t.from) {
+          if (endStates.has(fromState)) {
+            issues.push({
+              code: "TRANSITION_FROM_END",
+              message: `Transition '${t.name}' has source state '${fromState}' which is an END/CANCELLED state`,
+              severity: "warning",
+              category: "semantic",
+              suggestion: "Remove transitions from END/CANCELLED states"
+            });
+          }
+        }
+      }
+    }
+  }
+}
+function validateExperienceTree(node, knownComponents, knownRoots, issues, path = "metadata.experience") {
+  if (node.component && knownComponents) {
+    if (!knownComponents.includes(node.component)) {
+      issues.push({
+        code: "UNKNOWN_COMPONENT",
+        message: `Experience node '${node.id}' references unknown component '${node.component}'`,
+        severity: "warning",
+        category: "experience",
+        path,
+        suggestion: `Registered components: ${knownComponents.slice(0, 10).join(", ")}${knownComponents.length > 10 ? "..." : ""}`
+      });
+    }
+  }
+  if (node.bindings) {
+    for (const [prop, expr] of Object.entries(node.bindings)) {
+      validateBindingExpression(expr, `${path}.bindings.${prop}`, knownRoots, issues);
+    }
+  }
+  if (node.visible_when) {
+    validateBindingExpression(node.visible_when, `${path}.visible_when`, knownRoots, issues);
+  }
+  if (node.children) {
+    const childIds = /* @__PURE__ */ new Set();
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (child.id && childIds.has(child.id)) {
+        issues.push({
+          code: "DUPLICATE_NODE_ID",
+          message: `Duplicate experience node ID '${child.id}' under '${node.id}'`,
+          severity: "warning",
+          category: "experience",
+          path: `${path}.children[${i}]`
+        });
+      }
+      if (child.id) childIds.add(child.id);
+      validateExperienceTree(child, knownComponents, knownRoots, issues, `${path}.children[${i}]`);
+    }
+  }
+}
+function validateBindingExpression(expr, path, knownRoots, issues) {
+  if (!expr) return;
+  const trimmed = expr.trim();
+  if (trimmed.startsWith('"') || trimmed.startsWith("'") || /^-?\d/.test(trimmed) || trimmed === "true" || trimmed === "false" || trimmed === "null") {
+    return;
+  }
+  if (trimmed.startsWith("action:") || trimmed.startsWith("setLocal:")) {
+    return;
+  }
+  if (/^\w+\.fire$/.test(trimmed)) {
+    return;
+  }
+  if (trimmed.startsWith("$")) {
+    const dotIdx = trimmed.indexOf(".");
+    const parenIdx = trimmed.indexOf("(");
+    let root;
+    if (dotIdx > 0 && (parenIdx < 0 || dotIdx < parenIdx)) {
+      root = trimmed.slice(0, dotIdx);
+    } else if (parenIdx > 0) {
+      root = trimmed.slice(0, parenIdx);
+    } else {
+      root = trimmed;
+    }
+    const rootClean = root.replace(/[!=<>&|+\-*/\s].*/g, "").trim();
+    if (rootClean && !knownRoots.includes(rootClean)) {
+      issues.push({
+        code: "UNKNOWN_BINDING_ROOT",
+        message: `Binding expression at ${path} uses unknown root '${rootClean}'`,
+        severity: "warning",
+        category: "experience",
+        path,
+        suggestion: `Known roots: ${knownRoots.join(", ")}`
+      });
+    }
+  }
+}
+function isViableDefinition(def) {
+  if (!def || typeof def !== "object") return false;
+  const d = def;
+  return typeof d.slug === "string" && Array.isArray(d.states) && d.states.length > 0 && Array.isArray(d.transitions) && Array.isArray(d.fields);
+}
+
+// src/dsl/lexer.ts
+var SECTION_KEYWORDS = /* @__PURE__ */ new Set([
+  "things",
+  "paths",
+  "levels",
+  "numbers",
+  "tabs",
+  "controls",
+  "overlay",
+  "actions"
+]);
+var QUALIFIER_PATTERNS = [
+  { pattern: /^(\w[\w\s]*)\s+first$/, kind: "order" },
+  { pattern: /^searchable\s+by\s+(.+)$/, kind: "searchable" },
+  { pattern: /^filterable\s+by\s+(.+)$/, kind: "filterable" },
+  { pattern: /^(\d+)\s+at\s+a\s+time$/, kind: "pagination" }
+];
+var TYPE_ADJECTIVES = /* @__PURE__ */ new Set([
+  "required",
+  "unique",
+  "computed",
+  "non-negative",
+  "positive",
+  "negative",
+  "lowercase",
+  "uppercase",
+  "optional",
+  "readonly"
+]);
+var FIELD_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "number",
+  "integer",
+  "time",
+  "rich text",
+  "choice"
+]);
+var CONTENT_ROLES = /* @__PURE__ */ new Set([
+  "tag",
+  "card",
+  "progress",
+  "meter",
+  "slider",
+  "timeline",
+  "image"
+]);
+var PRONOUNS = /* @__PURE__ */ new Set(["its", "my", "the", "this", "these"]);
+function tokenize(source) {
+  const rawLines = source.split("\n");
+  return rawLines.map((raw, i) => tokenizeLine(raw, i + 1));
+}
+function tokenizeLine(raw, lineNumber = 1) {
+  const indent = measureIndent(raw);
+  const trimmed = raw.trim();
+  const data = classifyLine(trimmed);
+  return { indent, lineNumber, raw, data };
+}
+function measureIndent(line) {
+  let count = 0;
+  for (const ch of line) {
+    if (ch === " ") count++;
+    else if (ch === "	") count += 2;
+    else break;
+  }
+  return count;
+}
+function classifyLine(trimmed) {
+  if (trimmed === "") return { type: "blank" };
+  if (trimmed.startsWith("#")) {
+    return { type: "comment", text: trimmed.slice(1).trim() };
+  }
+  if (trimmed === "pages") return { type: "pages" };
+  if (SECTION_KEYWORDS.has(trimmed)) {
+    return { type: "section", name: trimmed };
+  }
+  const taggedMatch = trimmed.match(/^tagged:\s*(.+)$/);
+  if (taggedMatch) {
+    return {
+      type: "tagged",
+      tags: taggedMatch[1].split(",").map((t) => t.trim())
+    };
+  }
+  const pathMappingMatch = trimmed.match(
+    /^(\/[\w\/:.-]+)\s*→\s*([\w\s]+?)(?:\s*\((\w+)\))?$/
+  );
+  if (pathMappingMatch) {
+    return {
+      type: "path_mapping",
+      path: pathMappingMatch[1],
+      view: pathMappingMatch[2].trim(),
+      context: pathMappingMatch[3]
+    };
+  }
+  const levelMatch = trimmed.match(
+    /^(\d+):\s*"([^"]+)",\s*from\s+(\d+)\s+xp$/
+  );
+  if (levelMatch) {
+    return {
+      type: "level_def",
+      level: parseInt(levelMatch[1], 10),
+      title: levelMatch[2],
+      fromXp: parseInt(levelMatch[3], 10)
+    };
+  }
+  const startsAtMatch = trimmed.match(/^starts\s+at\s+(.+)$/);
+  if (startsAtMatch) {
+    return { type: "starts_at", state: startsAtMatch[1].trim() };
+  }
+  const transitionMatch = trimmed.match(
+    /^can\s+(.+?)\s*→\s*(.+?)(?:,\s*(.+))?$/
+  );
+  if (transitionMatch) {
+    return {
+      type: "transition",
+      verb: transitionMatch[1].trim(),
+      target: transitionMatch[2].trim(),
+      guard: transitionMatch[3]?.trim()
+    };
+  }
+  if (trimmed.startsWith("when ") || trimmed === "when") {
+    return { type: "when", condition: trimmed.slice(5).trim() };
+  }
+  const setMatch = trimmed.match(/^set\s+(.+?)\s*=\s*(.+)$/);
+  if (setMatch) {
+    return {
+      type: "set_action",
+      field: setMatch[1].trim(),
+      expression: setMatch[2].trim()
+    };
+  }
+  if (trimmed.startsWith("do ")) {
+    return { type: "do_action", action: trimmed.slice(3).trim() };
+  }
+  const goMatch = trimmed.match(/^go\s+to\s+(.+)$/);
+  if (goMatch) {
+    return { type: "go_action", path: goMatch[1].trim() };
+  }
+  const tellMatch = trimmed.match(/^tell\s+(.+?)\s+"([^"]+)"$/);
+  if (tellMatch) {
+    return {
+      type: "tell_action",
+      target: tellMatch[1].trim(),
+      message: tellMatch[2]
+    };
+  }
+  const showMatch = trimmed.match(/^show\s+(.+?)(?:\s+(briefly))?$/);
+  if (showMatch) {
+    return {
+      type: "show_action",
+      content: showMatch[1].trim(),
+      modifier: showMatch[2]
+    };
+  }
+  if (trimmed.startsWith("search ")) {
+    return { type: "search", target: trimmed.slice(7).trim() };
+  }
+  const eachMatch = trimmed.match(
+    /^each\s+(.+?)(?:\s+as\s+([\w\s]+?))?(?:,\s*(big|small))?$/
+  );
+  if (eachMatch) {
+    return {
+      type: "iteration",
+      subject: eachMatch[1].trim(),
+      role: eachMatch[2]?.trim(),
+      emphasis: eachMatch[3]
+    };
+  }
+  for (const { pattern, kind } of QUALIFIER_PATTERNS) {
+    const qMatch = trimmed.match(pattern);
+    if (qMatch) {
+      return { type: "qualifier", kind, value: qMatch[1] ?? trimmed };
+    }
+  }
+  const versionedDeclMatch = trimmed.match(
+    /^(?:a\s+)?(.+?)\s+@(\d+\.\d+\.\d+)$/
+  );
+  if (versionedDeclMatch) {
+    const hasPrefix = trimmed.startsWith("a ");
+    const name = versionedDeclMatch[1].replace(/^a\s+/, "").trim();
+    if (hasPrefix) {
+      return { type: "thing_decl", name, version: versionedDeclMatch[2] };
+    }
+    return { type: "space_decl", name, version: versionedDeclMatch[2] };
+  }
+  const fragmentMatch = trimmed.match(/^a\s+(.+):$/);
+  if (fragmentMatch) {
+    return { type: "fragment_def", name: fragmentMatch[1].trim() };
+  }
+  const thingRefMatch = trimmed.match(/^(?:a\s+)?(.+?)\s*\((\w+)\)$/);
+  if (thingRefMatch) {
+    return {
+      type: "thing_ref",
+      name: thingRefMatch[1].trim(),
+      kind: thingRefMatch[2]
+    };
+  }
+  const stringLitMatch = trimmed.match(
+    /^"([^"]+)"(?:,\s*(big|small))?$/
+  );
+  if (stringLitMatch) {
+    return {
+      type: "string_literal",
+      text: stringLitMatch[1],
+      emphasis: stringLitMatch[2]
+    };
+  }
+  const navMatch = trimmed.match(/^(.+?)\s*→\s*(.+)$/);
+  if (navMatch) {
+    return {
+      type: "navigation",
+      trigger: navMatch[1].trim(),
+      target: navMatch[2].trim()
+    };
+  }
+  const dataSourceResult = tryParseDataSource(trimmed);
+  if (dataSourceResult) return dataSourceResult;
+  const contentResult = tryParseContent(trimmed);
+  if (contentResult) return contentResult;
+  const fieldResult = tryParseFieldDef(trimmed);
+  if (fieldResult) return fieldResult;
+  const groupMatch = trimmed.match(/^(.+?)\s+by\s+(.+)$/);
+  if (groupMatch) {
+    return {
+      type: "grouping",
+      collection: groupMatch[1].trim(),
+      key: groupMatch[2].trim()
+    };
+  }
+  const stateResult = tryParseStateDef(trimmed);
+  if (stateResult) return stateResult;
+  return { type: "unknown", text: trimmed };
+}
+function splitOutsideBrackets(str) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const ch of str) {
+    if (ch === "[") depth++;
+    else if (ch === "]") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+function tryParseFieldDef(trimmed) {
+  const asMatch = trimmed.match(/^(.+?)\s+as\s+(.+)$/);
+  if (!asMatch) return null;
+  const name = asMatch[1].trim();
+  const rest = asMatch[2].trim();
+  const firstWord = name.split(/\s+/)[0];
+  if (PRONOUNS.has(firstWord)) return null;
+  if (rest.startsWith('"')) return null;
+  const parts = splitOutsideBrackets(rest);
+  const typeSpec = parts[0];
+  const constraintParts = parts.slice(1);
+  const typeWords = typeSpec.split(/\s+/);
+  const adjectives = [];
+  let baseType = "";
+  const choiceMatch = typeSpec.match(/^(.+?\s+)?choice\s+of\s+\[(.+)\]$/);
+  if (choiceMatch) {
+    const prefix = choiceMatch[1]?.trim() ?? "";
+    if (prefix) {
+      for (const w of prefix.split(/\s+/)) {
+        if (TYPE_ADJECTIVES.has(w)) adjectives.push(w);
+      }
+    }
+    baseType = `choice of [${choiceMatch[2]}]`;
+  } else {
+    let i = 0;
+    while (i < typeWords.length && TYPE_ADJECTIVES.has(typeWords[i])) {
+      adjectives.push(typeWords[i]);
+      i++;
+    }
+    baseType = typeWords.slice(i).join(" ");
+  }
+  if (!baseType) return null;
+  const knownFieldType = FIELD_TYPES.has(baseType) || baseType.startsWith("choice of") || adjectives.length > 0;
+  if (!knownFieldType) return null;
+  if (CONTENT_ROLES.has(baseType) && adjectives.length === 0) return null;
+  const constraints = [];
+  for (const cp of constraintParts) {
+    const constraint = parseConstraint(cp);
+    if (constraint) constraints.push(constraint);
+  }
+  return {
+    type: "field_def",
+    name,
+    adjectives,
+    baseType,
+    constraints
+  };
+}
+function parseConstraint(text) {
+  const trimmed = text.trim();
+  const maxMatch = trimmed.match(/^max\s+(\d+)$/);
+  if (maxMatch) return { kind: "max", value: parseInt(maxMatch[1], 10) };
+  const minMatch = trimmed.match(/^min\s+(\d+)$/);
+  if (minMatch) return { kind: "min", value: parseInt(minMatch[1], 10) };
+  const defaultMatch = trimmed.match(/^default\s+(.+)$/);
+  if (defaultMatch) {
+    const val = defaultMatch[1].trim();
+    const num = Number(val);
+    return { kind: "default", value: isNaN(num) ? val.replace(/^"(.*)"$/, "$1") : num };
+  }
+  const betweenMatch = trimmed.match(/^between\s+(\d+)\s+and\s+(\d+)$/);
+  if (betweenMatch) {
+    return {
+      kind: "between",
+      value: parseInt(betweenMatch[1], 10),
+      value2: parseInt(betweenMatch[2], 10)
+    };
+  }
+  if (trimmed === "unique") return { kind: "unique", value: true };
+  return null;
+}
+function tryParseContent(trimmed) {
+  const pronounMatch = trimmed.match(
+    /^(its|my|the|this)\s+(.+?)(?:,\s*(big|small))?(?:\s+as\s+(.+?))?(?:\s+with\s+"([^"]+)")?$/
+  );
+  if (pronounMatch) {
+    return {
+      type: "content",
+      pronoun: pronounMatch[1],
+      field: pronounMatch[2].trim(),
+      emphasis: pronounMatch[3],
+      role: pronounMatch[4]?.trim(),
+      label: pronounMatch[5]
+    };
+  }
+  const labelMatch = trimmed.match(
+    /^([\w\s]+?)\s+as\s+"([^"]+)"(?:\s+with\s+"([^"]+)")?$/
+  );
+  if (labelMatch) {
+    return {
+      type: "content",
+      field: labelMatch[1].trim(),
+      label: labelMatch[2]
+    };
+  }
+  return null;
+}
+function tryParseDataSource(trimmed) {
+  const fromMatch = trimmed.match(
+    /^(.+?)\s+from\s+([\w-]+)(?:,\s*(.+?))?(?:\s+for\s+(.+))?$/
+  );
+  if (!fromMatch) return null;
+  const alias = fromMatch[1].trim();
+  const source = fromMatch[2].trim();
+  const qualifierOrLive = fromMatch[3]?.trim();
+  const scope = fromMatch[4]?.trim();
+  return {
+    type: "data_source",
+    alias,
+    source,
+    isLive: qualifierOrLive === "live",
+    qualifier: qualifierOrLive !== "live" ? qualifierOrLive : void 0,
+    scope
+  };
+}
+function tryParseStateDef(trimmed) {
+  const nonStateStarters = [
+    "a ",
+    "an ",
+    "the ",
+    "my ",
+    "its ",
+    "this ",
+    "each ",
+    "when ",
+    "can ",
+    "set ",
+    "do ",
+    "go ",
+    "tell ",
+    "show ",
+    "search ",
+    "from ",
+    "emit ",
+    "tagged",
+    "starts ",
+    "follow ",
+    "facing ",
+    "playing ",
+    "volume ",
+    "playback "
+  ];
+  for (const prefix of nonStateStarters) {
+    if (trimmed.startsWith(prefix)) return null;
+  }
+  if (trimmed.includes("\u2192")) return null;
+  if (trimmed.includes(" from ")) return null;
+  if (trimmed.includes(" by ")) return null;
+  if (trimmed.includes(" as ")) return null;
+  const finalMatch = trimmed.match(/^(.+?),\s*final$/);
+  if (finalMatch) {
+    return { type: "state_decl", name: finalMatch[1].trim(), isFinal: true };
+  }
+  if (/^[a-z][\w\s]*$/i.test(trimmed) && !SECTION_KEYWORDS.has(trimmed) && trimmed !== "pages") {
+    return { type: "state_decl", name: trimmed, isFinal: false };
+  }
+  return null;
+}
+
+// src/dsl/parser.ts
+function parse(tokens) {
+  const errors = [];
+  const roots = [];
+  const meaningful = tokens.filter(
+    (t) => t.data.type !== "blank" && t.data.type !== "comment"
+  );
+  if (meaningful.length === 0) {
+    return { nodes: [], errors };
+  }
+  const stack = [];
+  for (const token of meaningful) {
+    const node = { token, children: [] };
+    while (stack.length > 0 && stack[stack.length - 1].indent >= token.indent) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      roots.push(node);
+    } else {
+      stack[stack.length - 1].node.children.push(node);
+    }
+    stack.push({ node, indent: token.indent });
+  }
+  validateStructure2(roots, errors);
+  return { nodes: roots, errors };
+}
+function validateStructure2(nodes, errors) {
+  for (const node of nodes) {
+    const { data } = node.token;
+    if (data.type === "transition" && !isInsideState(node, nodes)) {
+    }
+    if (data.type === "set_action" && !hasAncestorType(node, "when", nodes)) {
+    }
+    if (node.children.length > 0) {
+      validateStructure2(node.children, errors);
+    }
+  }
+}
+function isInsideState(_node, _roots) {
+  return true;
+}
+function hasAncestorType(_node, _type, _roots) {
+  return true;
+}
+
+// src/dsl/compiler/symbol-table.ts
+var VIEW_CHILD_TYPES = /* @__PURE__ */ new Set([
+  "data_source",
+  "content",
+  "iteration",
+  "section",
+  "string_literal",
+  "search",
+  "grouping",
+  "navigation",
+  "pages",
+  "qualifier"
+]);
+function collectSymbols(nodes) {
+  const table = {
+    things: /* @__PURE__ */ new Map(),
+    fragments: /* @__PURE__ */ new Map(),
+    views: /* @__PURE__ */ new Map()
+  };
+  for (const node of nodes) {
+    const { data } = node.token;
+    switch (data.type) {
+      case "space_decl":
+        table.space = collectSpace(node);
+        break;
+      case "thing_decl":
+        table.things.set(data.name, collectThing(node));
+        break;
+      case "fragment_def":
+        table.fragments.set(data.name, { name: data.name, node });
+        break;
+      case "state_decl":
+        if (hasViewChildren(node)) {
+          table.views.set(data.name, { name: data.name, node });
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  return table;
+}
+function collectSpace(node) {
+  const data = node.token.data;
+  if (data.type !== "space_decl") throw new Error("Expected space_decl");
+  const space = {
+    name: data.name,
+    version: data.version,
+    node,
+    thingRefs: [],
+    paths: [],
+    tags: []
+  };
+  for (const child of node.children) {
+    const cd = child.token.data;
+    if (cd.type === "tagged") {
+      space.tags.push(...cd.tags);
+    } else if (cd.type === "section" && cd.name === "things") {
+      for (const ref of child.children) {
+        if (ref.token.data.type === "thing_ref") {
+          space.thingRefs.push({
+            name: ref.token.data.name,
+            kind: ref.token.data.kind
+          });
+        }
+      }
+    } else if (cd.type === "section" && cd.name === "paths") {
+      for (const pm of child.children) {
+        if (pm.token.data.type === "path_mapping") {
+          space.paths.push({
+            path: pm.token.data.path,
+            view: pm.token.data.view,
+            context: pm.token.data.context
+          });
+        }
+      }
+    }
+  }
+  return space;
+}
+function collectThing(node) {
+  const data = node.token.data;
+  if (data.type !== "thing_decl") throw new Error("Expected thing_decl");
+  const thing = {
+    name: data.name,
+    version: data.version ?? "1.0.0",
+    node,
+    fields: [],
+    states: [],
+    tags: [],
+    levels: []
+  };
+  for (const child of node.children) {
+    const cd = child.token.data;
+    switch (cd.type) {
+      case "field_def":
+        thing.fields.push(child);
+        break;
+      case "state_decl":
+        thing.states.push(child);
+        break;
+      case "starts_at":
+        thing.startsAt = cd.state;
+        break;
+      case "tagged":
+        thing.tags.push(...cd.tags);
+        break;
+      case "section":
+        if (cd.name === "levels") {
+          for (const lvl of child.children) {
+            if (lvl.token.data.type === "level_def") {
+              thing.levels.push(lvl);
+            }
+          }
+        }
+        break;
+    }
+  }
+  return thing;
+}
+function hasViewChildren(node) {
+  for (const child of node.children) {
+    if (VIEW_CHILD_TYPES.has(child.token.data.type)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/dsl/compiler/utils.ts
+function slugify(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function snakeCase(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9\s_]/g, "").replace(/\s+/g, "_").replace(/_+/g, "_");
+}
+function generateId(...parts) {
+  return parts.map((p) => slugify(p)).join("--");
+}
+function generateActionId(context, index) {
+  return `${context}-${index}`;
+}
+
+// src/dsl/compiler/field-mapper.ts
+var BASE_TYPE_MAP = {
+  "text": "text",
+  "rich text": "rich_text",
+  "number": "number",
+  "integer": "number",
+  "time": "datetime"
+};
+function isTextLikeType(irType) {
+  return irType === "text" || irType === "rich_text";
+}
+function mapField(data) {
+  const field = {
+    name: snakeCase(data.name),
+    type: resolveType(data.baseType)
+  };
+  for (const adj of data.adjectives) {
+    applyAdjective(field, adj);
+  }
+  const validation = buildValidation(data, field.type);
+  if (validation) {
+    field.validation = mergeValidation(field.validation, validation);
+  }
+  if (data.baseType === "integer") {
+    if (!field.validation) field.validation = {};
+    if (!field.validation.rules) field.validation.rules = [];
+    field.validation.rules.push({
+      expression: "eq(round($value), $value)",
+      message: "Must be a whole number",
+      severity: "error"
+    });
+  }
+  if (data.baseType.startsWith("choice of")) {
+    field.type = "select";
+    const optionsMatch = data.baseType.match(/\[(.+)\]/);
+    if (optionsMatch) {
+      if (!field.validation) field.validation = {};
+      field.validation.options = optionsMatch[1].split(",").map((o) => o.trim());
+    }
+  }
+  const defaultConstraint = data.constraints.find((c) => c.kind === "default");
+  if (defaultConstraint) {
+    field.default_value = defaultConstraint.value;
+  }
+  return field;
+}
+function resolveType(baseType) {
+  if (baseType.startsWith("choice of")) return "select";
+  return BASE_TYPE_MAP[baseType] ?? baseType;
+}
+function applyAdjective(field, adjective) {
+  switch (adjective) {
+    case "required":
+      field.required = true;
+      break;
+    case "optional":
+      field.required = false;
+      break;
+    case "non-negative":
+      if (!field.validation) field.validation = {};
+      field.validation.min = 0;
+      break;
+    case "positive":
+      if (!field.validation) field.validation = {};
+      field.validation.min = 1;
+      break;
+    case "computed":
+      field.computed = "";
+      break;
+    // lowercase, uppercase, readonly — stored but no direct IR mapping
+    default:
+      break;
+  }
+}
+function buildValidation(data, irType) {
+  if (data.constraints.length === 0) return null;
+  const validation = {};
+  let hasProps = false;
+  for (const c of data.constraints) {
+    switch (c.kind) {
+      case "max":
+        if (isTextLikeType(irType)) {
+          validation.maxLength = c.value;
+        } else {
+          validation.max = c.value;
+        }
+        hasProps = true;
+        break;
+      case "min":
+        if (isTextLikeType(irType)) {
+          validation.minLength = c.value;
+        } else {
+          validation.min = c.value;
+        }
+        hasProps = true;
+        break;
+      case "between":
+        validation.min = c.value;
+        validation.max = c.value2;
+        hasProps = true;
+        break;
+      case "default":
+        break;
+      case "unique":
+        break;
+    }
+  }
+  return hasProps ? validation : null;
+}
+function mergeValidation(existing, incoming) {
+  if (!existing) return incoming;
+  return { ...existing, ...incoming };
+}
+
+// src/dsl/compiler/workflow-compiler.ts
+function compileWorkflows(symbols) {
+  const workflows = [];
+  const errors = [];
+  for (const [, thing] of symbols.things) {
+    const { workflow, errors: wfErrors } = compileThing(thing);
+    workflows.push(workflow);
+    errors.push(...wfErrors);
+  }
+  return { workflows, errors };
+}
+function compileThing(thing) {
+  const errors = [];
+  const slug = slugify(thing.name);
+  const fieldNames = new Set(
+    thing.fields.map((f) => {
+      const fd = f.token.data;
+      return fd.type === "field_def" ? fd.name : "";
+    }).filter(Boolean)
+  );
+  const fields = compileFields(thing.fields);
+  const stateNames = new Set(
+    thing.states.map((s) => {
+      const sd = s.token.data;
+      return sd.type === "state_decl" ? sd.name : "";
+    }).filter(Boolean)
+  );
+  const states = compileStates(thing, fieldNames);
+  const transitions = compileTransitions(thing, fieldNames, stateNames, errors);
+  const roles = collectRoles(thing);
+  if (!thing.startsAt) {
+    errors.push({
+      code: "MISSING_STARTS_AT",
+      message: `Workflow "${thing.name}" has no starts_at declaration`,
+      lineNumber: thing.node.token.lineNumber,
+      severity: "error"
+    });
+  }
+  const tags = thing.tags.length > 0 ? thing.tags.map((t) => ({ tag_name: t })) : void 0;
+  let metadata;
+  if (thing.levels.length > 0) {
+    metadata = {
+      levels: thing.levels.map((l) => {
+        const ld = l.token.data;
+        if (ld.type === "level_def") {
+          return { level: ld.level, title: ld.title, fromXp: ld.fromXp };
+        }
+        return null;
+      }).filter(Boolean)
+    };
+  }
+  return {
+    workflow: {
+      slug,
+      name: thing.name,
+      version: thing.version,
+      category: "blueprint",
+      states,
+      transitions,
+      fields,
+      roles,
+      tags,
+      metadata
+    },
+    errors
+  };
+}
+function compileFields(fieldNodes) {
+  return fieldNodes.map((node) => {
+    const data = node.token.data;
+    if (data.type !== "field_def") return null;
+    return mapField(data);
+  }).filter((f) => f !== null);
+}
+function compileStates(thing, fieldNames) {
+  return thing.states.map((stateNode) => {
+    const data = stateNode.token.data;
+    if (data.type !== "state_decl") {
+      return null;
+    }
+    const stateName = data.name;
+    const stateType = resolveStateType(stateName, data.isFinal, thing.startsAt);
+    const onEnterActions = [];
+    const onEventSubs = [];
+    for (const child of stateNode.children) {
+      const cd = child.token.data;
+      if (cd.type === "when") {
+        if (cd.condition === "entered") {
+          const actions = compileWhenEnteredActions(child, stateName, fieldNames);
+          onEnterActions.push(...actions);
+        } else if (cd.condition.startsWith("receives ")) {
+          const sub = compileOnEvent(child, stateName, fieldNames);
+          if (sub) onEventSubs.push(sub);
+        }
+      }
+    }
+    const state = {
+      name: stateName,
+      type: stateType,
+      on_enter: onEnterActions,
+      during: [],
+      on_exit: []
+    };
+    if (onEventSubs.length > 0) {
+      state.on_event = onEventSubs;
+    }
+    return state;
+  }).filter((s) => s !== null);
+}
+function resolveStateType(name, isFinal, startsAt) {
+  if (startsAt && name === startsAt) return "START";
+  if (isFinal && name.toLowerCase().includes("cancel")) return "CANCELLED";
+  if (isFinal) return "END";
+  return "REGULAR";
+}
+function compileWhenEnteredActions(whenNode, stateName, fieldNames) {
+  const context = `${slugify(stateName)}-on-enter`;
+  return whenNode.children.map((child, i) => {
+    const cd = child.token.data;
+    if (cd.type === "set_action") {
+      return {
+        id: generateActionId(context, i),
+        type: "set_field",
+        mode: "auto",
+        config: {
+          field: snakeCase(cd.field),
+          expression: transformExpression(cd.expression, fieldNames)
+        }
+      };
+    }
+    if (cd.type === "do_action") {
+      return {
+        id: generateActionId(context, i),
+        type: cd.action,
+        mode: "auto",
+        config: {}
+      };
+    }
+    return null;
+  }).filter((a) => a !== null);
+}
+function compileOnEvent(whenNode, stateName, fieldNames) {
+  const cd = whenNode.token.data;
+  if (cd.type !== "when") return null;
+  const match = cd.condition.match(/^receives\s+"([^"]+)"\s+from\s+(\S+)$/);
+  if (!match) return null;
+  const eventName = match[1];
+  const sourceSlug = slugify(match[2]);
+  const eventSlug = eventName.replace(/\s+/g, ".");
+  const topicPattern = `*:{{ entity_id }}:${sourceSlug}:instance.${eventSlug}`;
+  const actions = whenNode.children.map((child) => {
+    const acd = child.token.data;
+    if (acd.type === "set_action") {
+      return {
+        type: "set_field",
+        field: snakeCase(acd.field),
+        expression: transformExpression(acd.expression, fieldNames)
+      };
+    }
+    return null;
+  }).filter((a) => a !== null);
+  return {
+    match: topicPattern,
+    description: `On ${eventName} from ${match[2]}`,
+    actions
+  };
+}
+function compileTransitions(thing, fieldNames, stateNames, errors) {
+  const transitions = [];
+  for (const stateNode of thing.states) {
+    const stateData = stateNode.token.data;
+    if (stateData.type !== "state_decl") continue;
+    const fromState = stateData.name;
+    for (const child of stateNode.children) {
+      const cd = child.token.data;
+      if (cd.type !== "transition") continue;
+      const isAuto = cd.verb.startsWith("auto ");
+      const transitionName = slugify(cd.verb);
+      if (!stateNames.has(cd.target)) {
+        errors.push({
+          code: "UNKNOWN_TARGET_STATE",
+          message: `Transition "${cd.verb}" targets unknown state "${cd.target}"`,
+          lineNumber: child.token.lineNumber,
+          severity: "warning"
+        });
+      }
+      let roles;
+      if (cd.guard) {
+        roles = parseGuard(cd.guard);
+      }
+      const conditions = compileTransitionConditions(child, fieldNames);
+      const actions = compileTransitionActions(child, transitionName, fieldNames);
+      const transition = {
+        name: transitionName,
+        from: [fromState],
+        to: cd.target,
+        actions
+      };
+      if (isAuto) transition.auto = true;
+      if (roles && roles.length > 0) transition.roles = roles;
+      if (conditions && conditions.length > 0) transition.conditions = conditions;
+      transitions.push(transition);
+    }
+  }
+  return transitions;
+}
+function parseGuard(guard) {
+  const cleaned = guard.replace(/\s+only$/, "");
+  return cleaned.split(/\s+and\s+/).map((r) => r.trim());
+}
+function compileTransitionConditions(transitionNode, fieldNames) {
+  const conditions = [];
+  for (const child of transitionNode.children) {
+    const cd = child.token.data;
+    if (cd.type === "when") {
+      const parsed = parseConditionExpression(cd.condition, fieldNames);
+      if (parsed) conditions.push(parsed);
+    }
+  }
+  return conditions.length > 0 ? conditions : void 0;
+}
+function compileTransitionActions(transitionNode, transitionName, fieldNames) {
+  const actions = [];
+  const context = `${transitionName}-action`;
+  for (const child of transitionNode.children) {
+    const cd = child.token.data;
+    if (cd.type === "set_action") {
+      actions.push({
+        id: generateActionId(context, actions.length),
+        type: "set_field",
+        mode: "auto",
+        config: {
+          field: snakeCase(cd.field),
+          expression: transformExpression(cd.expression, fieldNames)
+        }
+      });
+    } else if (cd.type === "do_action") {
+      actions.push({
+        id: generateActionId(context, actions.length),
+        type: cd.action,
+        mode: "auto",
+        config: {}
+      });
+    }
+  }
+  return actions;
+}
+function parseConditionExpression(condition, fieldNames) {
+  if (condition.includes(" and ")) {
+    const parts = condition.split(/\s+and\s+/);
+    const subConditions = parts.map((p) => parseSingleCondition(p.trim(), fieldNames)).filter((c) => c !== null);
+    if (subConditions.length > 1) {
+      return { AND: subConditions };
+    }
+    if (subConditions.length === 1) {
+      return subConditions[0];
+    }
+    return null;
+  }
+  return parseSingleCondition(condition, fieldNames);
+}
+function parseSingleCondition(expr, fieldNames) {
+  const opMatch = expr.match(/^(.+?)\s*(>=|<=|>|<|==|!=)\s*(.+)$/);
+  if (!opMatch) return null;
+  const left = opMatch[1].trim();
+  const op = opMatch[2];
+  const right = opMatch[3].trim();
+  const operatorMap = {
+    ">=": "gte",
+    "<=": "lte",
+    ">": "gt",
+    "<": "lt",
+    "==": "eq",
+    "!=": "ne"
+  };
+  const operator = operatorMap[op];
+  if (!operator) return null;
+  const leftField = resolveFieldRef(left, fieldNames);
+  const rightValue = resolveConditionValue(right, fieldNames);
+  const condition = {
+    field: leftField,
+    operator
+  };
+  if (typeof rightValue === "number") {
+    condition.value = rightValue;
+  } else {
+    condition.expression = rightValue;
+  }
+  return condition;
+}
+function resolveFieldRef(name, fieldNames) {
+  if (fieldNames.has(name)) {
+    return `state_data.${snakeCase(name)}`;
+  }
+  for (const fn of fieldNames) {
+    if (fn === name) return `state_data.${snakeCase(fn)}`;
+  }
+  return `state_data.${snakeCase(name)}`;
+}
+function resolveConditionValue(value, fieldNames) {
+  const num = Number(value);
+  if (!isNaN(num)) return num;
+  if (fieldNames.has(value)) {
+    return `state_data.${snakeCase(value)}`;
+  }
+  return `state_data.${snakeCase(value)}`;
+}
+function transformExpression(expression, fieldNames) {
+  const trimmed = expression.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed;
+  }
+  if (trimmed === "now()") return "now()";
+  const addMatch = trimmed.match(/^(.+?)\s*\+\s*(.+)$/);
+  if (addMatch) {
+    const left = resolveExpressionPart(addMatch[1].trim(), fieldNames);
+    const right = resolveExpressionPart(addMatch[2].trim(), fieldNames);
+    return `add(${left}, ${right})`;
+  }
+  const subMatch = trimmed.match(/^(.+?)\s*-\s*(.+)$/);
+  if (subMatch) {
+    const left = resolveExpressionPart(subMatch[1].trim(), fieldNames);
+    const right = resolveExpressionPart(subMatch[2].trim(), fieldNames);
+    return `subtract(${left}, ${right})`;
+  }
+  return resolveExpressionPart(trimmed, fieldNames);
+}
+function resolveExpressionPart(part, fieldNames) {
+  const trimmed = part.trim();
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") return String(num);
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) return trimmed;
+  const eventMatch = trimmed.match(/^the event's\s+(.+)$/);
+  if (eventMatch) {
+    return `$event.state_data.${snakeCase(eventMatch[1])}`;
+  }
+  if (trimmed === "now()") return "now()";
+  if (fieldNames.has(trimmed)) {
+    return `state_data.${snakeCase(trimmed)}`;
+  }
+  return `state_data.${snakeCase(trimmed)}`;
+}
+function collectRoles(thing) {
+  const roleNames = /* @__PURE__ */ new Set();
+  for (const stateNode of thing.states) {
+    for (const child of stateNode.children) {
+      const cd = child.token.data;
+      if (cd.type === "transition" && cd.guard) {
+        const roles = parseGuard(cd.guard);
+        for (const r of roles) roleNames.add(r);
+      }
+    }
+  }
+  return Array.from(roleNames).map((name) => ({
+    name,
+    permissions: [`transition:${name}`]
+  }));
+}
+
+// src/dsl/compiler/component-mapper.ts
+var INSTANCE_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "current_state",
+  "state",
+  "status",
+  "created_at",
+  "updated_at",
+  "entity_type",
+  "entity_id"
+]);
+function mapContent(data, insideEach, parentId, index) {
+  const fieldSnake = snakeCase(data.field);
+  const nodeId = generateId(parentId, data.field, String(index));
+  const prefix = insideEach ? "$item" : "$instance";
+  const isInstanceField = INSTANCE_FIELDS.has(fieldSnake);
+  const bindingPath = isInstanceField ? `${prefix}.${fieldSnake === "state" ? "current_state" : fieldSnake}` : `${prefix}.state_data.${fieldSnake}`;
+  if (data.role) {
+    return mapContentWithRole(data, nodeId, bindingPath);
+  }
+  const node = {
+    id: nodeId,
+    component: "Text",
+    bindings: { value: bindingPath }
+  };
+  if (data.emphasis === "big") {
+    node.config = { variant: "heading" };
+  } else if (data.emphasis === "small") {
+    node.config = { variant: "caption" };
+  }
+  if (data.label) {
+    if (!node.config) node.config = {};
+    node.config.label = data.label;
+  }
+  return node;
+}
+function mapContentWithRole(data, nodeId, bindingPath) {
+  switch (data.role) {
+    case "tag":
+      return {
+        id: nodeId,
+        component: "Badge",
+        bindings: { value: bindingPath }
+      };
+    case "progress":
+    case "meter":
+      return {
+        id: nodeId,
+        component: "ProgressTracker",
+        bindings: { value: bindingPath }
+      };
+    case "image":
+      return {
+        id: nodeId,
+        component: "Image",
+        bindings: { src: bindingPath }
+      };
+    case "number": {
+      const node = {
+        id: nodeId,
+        component: "Text",
+        config: { variant: "metric" },
+        bindings: { value: bindingPath }
+      };
+      if (data.label) {
+        node.config.label = data.label;
+      }
+      return node;
+    }
+    default:
+      return {
+        id: nodeId,
+        component: "Text",
+        bindings: { value: bindingPath }
+      };
+  }
+}
+function mapStringLiteral(data, parentId, index) {
+  const nodeId = generateId(parentId, "text", String(index));
+  const node = {
+    id: nodeId,
+    component: "Text",
+    bindings: { value: `"${data.text}"` }
+  };
+  if (data.emphasis === "big") {
+    node.config = { variant: "heading" };
+  } else if (data.emphasis === "small") {
+    node.config = { variant: "caption" };
+  }
+  return node;
+}
+function mapIteration(data, children, parentId, index) {
+  const nodeId = generateId(parentId, "each", data.subject);
+  const eachNode = {
+    id: nodeId,
+    component: "Each"
+  };
+  if (data.role === "card") {
+    const cardNode = {
+      id: generateId(nodeId, "card"),
+      component: "Card",
+      children
+    };
+    if (data.emphasis === "small") {
+      cardNode.config = { size: "small" };
+    }
+    if (children.length > 1) {
+      cardNode.layout = "stack";
+    }
+    eachNode.children = [cardNode];
+  } else {
+    eachNode.children = children;
+  }
+  return eachNode;
+}
+function mapSection(data, children, parentId) {
+  switch (data.name) {
+    case "numbers":
+      return {
+        id: generateId(parentId, "numbers"),
+        component: "MetricsGrid",
+        children
+      };
+    case "tabs":
+      return {
+        id: generateId(parentId, "tabs"),
+        component: "TabbedLayout",
+        children
+      };
+    case "actions":
+      return {
+        id: generateId(parentId, "actions"),
+        component: "TransitionActions"
+      };
+    case "controls":
+      return {
+        id: generateId(parentId, "controls"),
+        layout: "row",
+        children
+      };
+    default:
+      return {
+        id: generateId(parentId, data.name),
+        children
+      };
+  }
+}
+function mapSearch(data, parentId, index) {
+  return {
+    id: generateId(parentId, "search", String(index)),
+    component: "SearchInput",
+    config: { target: data.target }
+  };
+}
+function mapNavigation(data, insideEach, parentId, index) {
+  const nodeId = generateId(parentId, "nav", String(index));
+  const prefix = insideEach ? "$item" : "$instance";
+  const target = data.target.replace(
+    /\{its\s+id\}/g,
+    `\${${prefix}.id}`
+  );
+  return {
+    id: nodeId,
+    component: "Link",
+    bindings: { onClick: `$action.navigate("${target}")` },
+    config: { trigger: data.trigger }
+  };
+}
+function mapPages(parentId, index) {
+  return {
+    id: generateId(parentId, "pages", String(index)),
+    component: "Pagination"
+  };
+}
+
+// src/dsl/compiler/view-compiler.ts
+function compileViews(symbols) {
+  const experiences = [];
+  const errors = [];
+  for (const [, fragment] of symbols.fragments) {
+    const exp = compileViewNode(
+      fragment.name,
+      fragment.node,
+      symbols.space
+    );
+    experiences.push(exp);
+  }
+  for (const [, view] of symbols.views) {
+    const exp = compileViewNode(
+      view.name,
+      view.node,
+      symbols.space
+    );
+    experiences.push(exp);
+  }
+  return { experiences, errors };
+}
+function compileViewNode(name, node, space) {
+  const viewSlug = slugify(name);
+  const dataSources = [];
+  const workflowSlugs = [];
+  for (const child of node.children) {
+    if (child.token.data.type === "data_source") {
+      const ds = compileDataSource(child);
+      dataSources.push(ds);
+      if (ds.type === "workflow" && ds.slug) {
+        workflowSlugs.push(ds.slug);
+      }
+    }
+  }
+  const children = compileChildren(node.children, viewSlug, false);
+  const rootNode = {
+    id: viewSlug,
+    children: children.length > 0 ? children : void 0,
+    dataSources: dataSources.length > 0 ? dataSources : void 0
+  };
+  if (children.length > 1) {
+    rootNode.layout = "stack";
+  }
+  return {
+    slug: viewSlug,
+    version: space?.version ?? "1.0.0",
+    name,
+    category: "purpose",
+    view_definition: rootNode,
+    workflows: workflowSlugs,
+    children: [],
+    data_bindings: [],
+    is_default: false
+  };
+}
+function compileDataSource(node) {
+  const data = node.token.data;
+  if (data.type !== "data_source") throw new Error("Expected data_source");
+  const query = resolveQueryType(data.alias);
+  const name = stripPronoun(data.alias);
+  const slug = slugify(data.source);
+  const ds = {
+    type: "workflow",
+    name,
+    slug,
+    query
+  };
+  if (data.scope) {
+    ds.parentInstanceId = "{{ parent_instance_id }}";
+  }
+  for (const child of node.children) {
+    const cd = child.token.data;
+    if (cd.type === "qualifier") {
+      applyQualifier(ds, cd);
+    }
+  }
+  return ds;
+}
+function resolveQueryType(alias) {
+  const firstWord = alias.split(/\s+/)[0];
+  if (firstWord === "this") return "latest";
+  return "list";
+}
+function stripPronoun(alias) {
+  const pronouns = ["my", "this", "its", "these"];
+  const words = alias.split(/\s+/);
+  if (words.length > 1 && pronouns.includes(words[0])) {
+    return words.slice(1).join(" ");
+  }
+  return alias;
+}
+function applyQualifier(ds, qualifier) {
+  switch (qualifier.kind) {
+    case "order":
+      if (qualifier.value === "newest") {
+        ds.sort = "created_at:desc";
+      } else if (qualifier.value === "oldest") {
+        ds.sort = "created_at:asc";
+      } else {
+        ds.sort = `${snakeCase(qualifier.value)}:desc`;
+      }
+      break;
+    case "pagination":
+      ds.paginated = true;
+      ds.pageSize = parseInt(qualifier.value, 10);
+      break;
+    case "searchable":
+      ds.searchFields = qualifier.value.split(/\s+and\s+/).map((f) => snakeCase(f.trim()));
+      break;
+    case "filterable":
+      ds.facets = qualifier.value.split(/\s+and\s+/).map((f) => snakeCase(f.trim()));
+      break;
+  }
+}
+function compileChildren(children, parentId, insideEach) {
+  const nodes = [];
+  let childIndex = 0;
+  for (const child of children) {
+    const cd = child.token.data;
+    switch (cd.type) {
+      case "data_source":
+        break;
+      case "qualifier":
+        break;
+      case "content":
+        nodes.push(mapContent(cd, insideEach, parentId, childIndex++));
+        break;
+      case "string_literal": {
+        const strNode = mapStringLiteral(cd, parentId, childIndex++);
+        if (child.children.length > 0) {
+          strNode.children = compileChildren(child.children, strNode.id, insideEach);
+          if (strNode.children.length > 1) {
+            strNode.layout = "stack";
+          }
+        }
+        nodes.push(strNode);
+        break;
+      }
+      case "iteration": {
+        const iterChildren = compileChildren(child.children, generateId(parentId, "each", cd.subject), true);
+        nodes.push(mapIteration(cd, iterChildren, parentId, childIndex++));
+        break;
+      }
+      case "section": {
+        const sectionChildren = compileChildren(child.children, generateId(parentId, cd.name), insideEach);
+        nodes.push(mapSection(cd, sectionChildren, parentId));
+        break;
+      }
+      case "search":
+        nodes.push(mapSearch(cd, parentId, childIndex++));
+        break;
+      case "navigation":
+        nodes.push(mapNavigation(cd, insideEach, parentId, childIndex++));
+        break;
+      case "pages":
+        nodes.push(mapPages(parentId, childIndex++));
+        break;
+      case "grouping":
+        nodes.push({
+          id: generateId(parentId, "group", cd.collection),
+          config: {
+            groupBy: snakeCase(cd.key),
+            collection: cd.collection
+          },
+          children: compileChildren(child.children, generateId(parentId, "group", cd.collection), insideEach)
+        });
+        break;
+      default:
+        break;
+    }
+  }
+  return nodes;
+}
+
+// src/dsl/compiler/manifest-compiler.ts
+function compileManifest(symbols) {
+  const errors = [];
+  if (!symbols.space) {
+    return { manifest: void 0, errors };
+  }
+  const space = symbols.space;
+  const workflows = space.thingRefs.map((ref) => ({
+    slug: slugify(ref.name),
+    role: ref.kind ?? "primary"
+  }));
+  const experience_id = slugify(space.name);
+  const routes = space.paths.map((p) => {
+    const route = {
+      path: p.path,
+      node: slugify(p.view)
+    };
+    if (p.context) {
+      route.entityType = p.context;
+      route.entityIdSource = inferEntityIdSource(p.path, p.context);
+    }
+    return route;
+  });
+  return {
+    manifest: {
+      workflows,
+      experience_id,
+      routes: routes.length > 0 ? routes : void 0
+    },
+    errors
+  };
+}
+function inferEntityIdSource(path, context) {
+  if (context === "user") return "user";
+  if (path.includes(":id")) return "param";
+  return "user";
+}
+
+// src/dsl/compiler/index.ts
+function compile(source) {
+  const tokens = tokenize(source);
+  const { nodes, errors: parseErrors } = parse(tokens);
+  return compileAST(nodes, parseErrors);
+}
+function compileAST(nodes, parseErrors) {
+  const allErrors = [];
+  const allWarnings = [];
+  if (parseErrors) {
+    for (const pe of parseErrors) {
+      allErrors.push({
+        code: "INVALID_EXPRESSION",
+        message: pe.message,
+        lineNumber: pe.lineNumber,
+        severity: "error"
+      });
+    }
+  }
+  const symbols = collectSymbols(nodes);
+  const { workflows, errors: wfErrors } = compileWorkflows(symbols);
+  for (const e of wfErrors) {
+    if (e.severity === "error") allErrors.push(e);
+    else allWarnings.push(e);
+  }
+  const { experiences, errors: viewErrors } = compileViews(symbols);
+  for (const e of viewErrors) {
+    if (e.severity === "error") allErrors.push(e);
+    else allWarnings.push(e);
+  }
+  const { manifest, errors: mfErrors } = compileManifest(symbols);
+  for (const e of mfErrors) {
+    if (e.severity === "error") allErrors.push(e);
+    else allWarnings.push(e);
+  }
+  return {
+    workflows,
+    experiences,
+    manifest,
+    errors: allErrors,
+    warnings: allWarnings
+  };
+}
+
+// src/dsl/ir-types.ts
+function normalizeCategory(primary, ...tags) {
+  const uniqueTags = [...new Set(tags.filter((t) => t !== primary))];
+  uniqueTags.sort();
+  return [primary, ...uniqueTags];
+}
+
+// src/dsl/ir-migration.ts
+var CURRENT_IR_VERSION = "1.2";
+function detectIRVersion(def) {
+  if (typeof def.ir_version === "string") return def.ir_version;
+  if (def.extensions || def.on_event && Array.isArray(def.on_event)) {
+    return "1.2";
+  }
+  const states = def.states;
+  const fields = def.fields;
+  if (states && states.length > 0 && states[0].state_type) return "1.0";
+  if (fields && fields.length > 0 && fields[0].field_type && !fields[0].type) return "1.0";
+  if (states && states.length > 0 && states[0].type) return "1.1";
+  return "1.0";
+}
+function migrateV10ToV11(def) {
+  const result = { ...def };
+  if (Array.isArray(result.states)) {
+    result.states = result.states.map((state) => {
+      const normalized = { ...state };
+      if ("state_type" in normalized && !("type" in normalized)) {
+        normalized.type = normalized.state_type;
+        delete normalized.state_type;
+      }
+      if (Array.isArray(normalized.on_enter)) {
+        normalized.on_enter = normalizeActions(normalized.on_enter);
+      }
+      if (Array.isArray(normalized.on_exit)) {
+        normalized.on_exit = normalizeActions(normalized.on_exit);
+      }
+      if (Array.isArray(normalized.during)) {
+        normalized.during = normalized.during.map((d) => {
+          if (Array.isArray(d.actions)) {
+            return { ...d, actions: normalizeActions(d.actions) };
+          }
+          return d;
+        });
+      }
+      return normalized;
+    });
+  }
+  if (Array.isArray(result.fields)) {
+    result.fields = result.fields.map((field) => {
+      const normalized = { ...field };
+      if ("field_type" in normalized && !("type" in normalized)) {
+        normalized.type = normalized.field_type;
+        delete normalized.field_type;
+      }
+      return normalized;
+    });
+  }
+  if (Array.isArray(result.transitions)) {
+    result.transitions = result.transitions.map((t) => {
+      if (Array.isArray(t.actions)) {
+        return { ...t, actions: normalizeActions(t.actions) };
+      }
+      return t;
+    });
+  }
+  return result;
+}
+function migrateV11ToV12(def) {
+  const result = { ...def };
+  if (!result.extensions) {
+    result.extensions = {};
+  }
+  if (Array.isArray(result.states)) {
+    result.states = result.states.map((state) => ({
+      ...state,
+      during: state.during ?? [],
+      on_event: state.on_event ?? []
+    }));
+  }
+  return result;
+}
+function normalizeActions(actions) {
+  return actions.map((action) => {
+    const normalized = { ...action };
+    if ("action_type" in normalized && !("type" in normalized)) {
+      normalized.type = normalized.action_type;
+      delete normalized.action_type;
+    }
+    return normalized;
+  });
+}
+var MIGRATIONS = [
+  { from: "1.0", to: "1.1", fn: migrateV10ToV11 },
+  { from: "1.1", to: "1.2", fn: migrateV11ToV12 }
+];
+function normalizeDefinition(def) {
+  let currentVersion = detectIRVersion(def);
+  let current = def;
+  const applied = [];
+  if (currentVersion === CURRENT_IR_VERSION) {
+    return {
+      definition: current,
+      fromVersion: currentVersion,
+      toVersion: CURRENT_IR_VERSION,
+      migrated: false,
+      appliedMigrations: []
+    };
+  }
+  const fromVersion = currentVersion;
+  for (const migration of MIGRATIONS) {
+    if (currentVersion === migration.from) {
+      current = migration.fn(current);
+      currentVersion = migration.to;
+      applied.push(`${migration.from} \u2192 ${migration.to}`);
+    }
+  }
+  return {
+    definition: current,
+    fromVersion,
+    toVersion: currentVersion,
+    migrated: applied.length > 0,
+    appliedMigrations: applied
+  };
+}
+function needsMigration(def) {
+  return detectIRVersion(def) !== CURRENT_IR_VERSION;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionDispatcher,
+  CORE_FUNCTIONS,
+  CURRENT_IR_VERSION,
+  EventBus,
+  StateMachine,
+  WEB_FAILURE_POLICIES,
+  analyzeDefinition,
+  buildFunctionMap,
+  clearExpressionCache,
+  clearPatternCache,
+  compareNRT,
+  compile,
+  compilePattern,
+  compileTestProgram,
+  compileTestScenario,
+  countByKind,
+  countNodes,
+  createActionRecorder,
+  createApiTestActions,
+  createEmptyNRT,
+  createEvaluator,
+  createInProcessTestActions,
+  detectIRVersion,
+  findInteractiveNodes,
+  findNode,
+  findVisibleNodes,
+  generateCoverageScenarios,
+  getFinalState,
+  getTransitionPath,
+  hasTransition,
+  isViableDefinition,
+  matchTopic,
+  needsMigration,
+  normalizeCategory,
+  normalizeDefinition,
+  runBlueprintScenario,
+  runBlueprintTestProgram,
+  runScenario,
+  runTestProgram,
+  validateDefinition
+});