@mmapp/react 0.1.0-alpha.22 → 0.1.0-alpha.24

package/dist/index.mjs

@@ -66,14 +66,1094 @@ import {
   useScope
 } from "./chunk-WV7DVCP6.mjs";
 
+// ../player-core/dist/index.mjs
+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;
+}
+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 expr2 = this.parseExpression();
+      this.skipWhitespace();
+      this.expect(")");
+      return expr2;
+    }
+    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(expr2) {
+  const cached = astCache.get(expr2);
+  if (cached) return cached;
+  const parser = new Parser(expr2);
+  const ast = parser.parse();
+  astCache.set(expr2, 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 evaluateExpression2(expr2, context, fnMap) {
+  const trimmed = expr2.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(expr2, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (policy.log_level === "error") {
+      console.error(`[player-core] Expression error: "${expr2}" \u2014 ${message}`);
+    } else if (policy.log_level === "warn") {
+      console.warn(`[player-core] Expression error: "${expr2}" \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 = evaluateExpression2(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, expr2) => {
+          const value = evaluateExpression2(expr2, 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 };
+    }
+  };
+}
+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 transition2 = this.instance.definition.transitions.find(
+      (t) => t.name === transitionName && t.from.includes(this.instance.current_state)
+    );
+    if (!transition2) {
+      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 (transition2.conditions && transition2.conditions.length > 0) {
+      const ctx = this.buildContext();
+      for (const condition of transition2.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(transition2);
+    if (result.success) {
+      await this.drainAutoTransitions();
+    }
+    return result;
+  }
+  /** Update state_data directly (for on_event set_field actions) */
+  setField(field2, value) {
+    this.instance.state_data = { ...this.instance.state_data, [field2]: 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(transition2) {
+    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 (transition2.actions) {
+      await this.executeActions(transition2.actions, allActionsExecuted);
+    }
+    this.instance.current_state = transition2.to;
+    const toStateDef = this.instance.definition.states.find((s) => s.name === transition2.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: transition2.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: transition2.to
+    });
+    return {
+      success: true,
+      from_state: fromState,
+      to_state: transition2.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 action2 of actions) {
+      if (action2.condition) {
+        const condResult = this.evaluator.evaluate(action2.condition, ctx);
+        if (!condResult.value) continue;
+      }
+      const handler = this.actionHandlers.get(action2.type);
+      if (handler) {
+        try {
+          await handler(action2, ctx);
+          collector.push(action2);
+          this.emit({
+            type: "action_executed",
+            instance_id: this.instance.definition.id,
+            action: action2
+          });
+        } catch (error) {
+          this.emit({
+            type: "error",
+            instance_id: this.instance.definition.id,
+            action: action2,
+            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 {
+      }
+    }
+  }
+};
+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);
+}
+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;
+  }
+};
+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 action2 of actions) {
+      if (action2.condition && evaluator) {
+        const condResult = evaluator.evaluate(action2.condition, context);
+        if (!condResult.value) continue;
+      }
+      const handler = this.handlers.get(action2.type);
+      if (!handler) {
+        console.warn(`[player-core] No handler registered for action type "${action2.type}" \u2014 unsupported action`);
+        results.push({ type: action2.type, success: false, error: `unsupported action: "${action2.type}"` });
+        continue;
+      }
+      try {
+        await handler(action2.config, context);
+        results.push({ type: action2.type, success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[player-core] Action "${action2.type}" failed: ${message}`);
+        results.push({ type: action2.type, success: false, error: message });
+      }
+    }
+    return results;
+  }
+  /** Get count of registered handlers */
+  get size() {
+    return this.handlers.size;
+  }
+  /** Get all registered action type names */
+  getRegisteredTypes() {
+    return Array.from(this.handlers.keys());
+  }
+  /** Remove all handlers */
+  clear() {
+    this.handlers.clear();
+  }
+};
+
 // src/core/WorkflowRuntime.ts
-import {
-  StateMachine,
-  EventBus,
-  ActionDispatcher,
-  createEvaluator,
-  WEB_FAILURE_POLICIES
-} from "@mmapp/player-core";
 var WorkflowRuntime = class {
   sm;
   eventBus;
@@ -3303,13 +4383,13 @@ function inState(state2) {
 function notInState(state2) {
   return { type: "expression", expression: `current_state != "${state2}"` };
 }
-function and(...conditions) {
+function and2(...conditions) {
   return { AND: conditions.map(normalize) };
 }
-function or(...conditions) {
+function or2(...conditions) {
   return { OR: conditions.map(normalize) };
 }
-function not(condition) {
+function not2(condition) {
   const c = normalize(condition);
   if (c.type === "expression" && c.expression) {
     return { type: "expression", expression: `NOT(${c.expression})` };
@@ -5860,13 +6940,6 @@ function describeModel(def) {
 
 // src/hooks/usePlayer.ts
 import { useCallback as useCallback20, useEffect as useEffect21, useMemo as useMemo19, useRef as useRef23, useState as useState21 } from "react";
-import {
-  StateMachine as StateMachine2,
-  EventBus as EventBus2,
-  ActionDispatcher as ActionDispatcher2,
-  createEvaluator as createEvaluator2,
-  WEB_FAILURE_POLICIES as WEB_FAILURE_POLICIES2
-} from "@mmapp/player-core";
 
 // src/logger.ts
 var debugEnabled = false;
@@ -5912,9 +6985,9 @@ function usePlayer(config) {
     if (config.debug) setPlayerDebug(true);
   }, [config.debug]);
   const evaluator = useMemo19(() => {
-    return createEvaluator2({
+    return createEvaluator({
       functions: config.functions ?? [],
-      failurePolicy: WEB_FAILURE_POLICIES2.EVENT_REACTION
+      failurePolicy: WEB_FAILURE_POLICIES.EVENT_REACTION
     });
   }, [config.definition.id]);
   const engine = useMemo19(() => {
@@ -5945,14 +7018,14 @@ function usePlayer(config) {
         });
       }
     });
-    const sm2 = new StateMachine2(
+    const sm2 = new StateMachine(
       config.definition,
       config.initialData ?? {},
       { evaluator, actionHandlers }
     );
     smRef = sm2;
-    const eventBus2 = new EventBus2();
-    const dispatcher = new ActionDispatcher2();
+    const eventBus2 = new EventBus();
+    const dispatcher = new ActionDispatcher();
     dispatcher.register("set_field", (cfg) => {
       if (smRef && typeof cfg.field === "string") {
         smRef.setField(cfg.field, cfg.value);
@@ -7398,7 +8471,7 @@ export {
   actor,
   after,
   allowTransition,
-  and,
+  and2 as and,
   applyMixins,
   approval,
   assertModelValid,
@@ -7486,11 +8559,11 @@ export {
   model,
   named,
   normalizeDefinition,
-  not,
+  not2 as not,
   notInState,
   notify,
   on,
-  or,
+  or2 as or,
   orchestration,
   patch,
   pipe,