@mmapp/react 0.1.0-alpha.1 → 0.1.0-alpha.4

package/dist/index.mjs

@@ -1,1087 +1,11 @@
-// ../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 evaluateExpression(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 = 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, expr2) => {
-          const value = evaluateExpression(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}"`);
-        results.push({ type: action2.type, success: false, error: `No handler for "${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;
-  }
-  /** 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;
@@ -1180,24 +104,24 @@ import { useEffect, useRef } from "react";
 import { createContext, useContext } from "react";
 var RuntimeContext = createContext(null);
 function useRuntimeContext() {
-  const runtime = useContext(RuntimeContext);
-  if (!runtime) {
+  const runtime2 = useContext(RuntimeContext);
+  if (!runtime2) {
     throw new Error(
       "useRuntimeContext must be used within a WorkflowProvider or RuntimeContext.Provider"
     );
   }
-  return runtime;
+  return runtime2;
 }
 
 // src/hooks/useOnEnter.ts
 function useOnEnter(stateName, effect) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const effectRef = useRef(effect);
   effectRef.current = effect;
   const cleanupRef = useRef(null);
   const states = Array.isArray(stateName) ? stateName : [stateName];
   useEffect(() => {
-    if (states.includes(runtime.sm.currentState)) {
+    if (states.includes(runtime2.sm.currentState)) {
       const result = effectRef.current();
       if (result instanceof Promise) {
         result.then((cleanup) => {
@@ -1207,7 +131,7 @@ function useOnEnter(stateName, effect) {
         cleanupRef.current = result;
       }
     }
-    const unsub = runtime.sm.on((event) => {
+    const unsub = runtime2.sm.on((event) => {
       if (event.type === "state_enter" && event.to_state && states.includes(event.to_state)) {
         cleanupRef.current?.();
         const result = effectRef.current();
@@ -1228,34 +152,34 @@ function useOnEnter(stateName, effect) {
       unsub();
       cleanupRef.current?.();
     };
-  }, [runtime, ...states]);
+  }, [runtime2, ...states]);
 }
 
 // src/hooks/useOnExit.ts
 import { useEffect as useEffect2, useRef as useRef2 } from "react";
 function useOnExit(stateName, effect) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const effectRef = useRef2(effect);
   effectRef.current = effect;
   const states = Array.isArray(stateName) ? stateName : [stateName];
   useEffect2(() => {
-    const unsub = runtime.sm.on((event) => {
+    const unsub = runtime2.sm.on((event) => {
       if (event.type === "state_exit" && event.from_state && states.includes(event.from_state)) {
         effectRef.current();
       }
     });
     return unsub;
-  }, [runtime, ...states]);
+  }, [runtime2, ...states]);
 }
 
 // src/hooks/useOnTransition.ts
 import { useEffect as useEffect3, useRef as useRef3 } from "react";
 function useOnTransition(effect) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const effectRef = useRef3(effect);
   effectRef.current = effect;
   useEffect3(() => {
-    const unsub = runtime.sm.on((event) => {
+    const unsub = runtime2.sm.on((event) => {
       if (event.type === "transition") {
         effectRef.current({
           from: event.from_state,
@@ -1264,33 +188,33 @@ function useOnTransition(effect) {
       }
     });
     return unsub;
-  }, [runtime]);
+  }, [runtime2]);
 }
 
 // src/hooks/useOnEvent.ts
 import { useEffect as useEffect4, useRef as useRef4 } from "react";
 function useOnEvent(pattern, handler, options) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const handlerRef = useRef4(handler);
   handlerRef.current = handler;
   useEffect4(() => {
-    const unsub = runtime.eventBus.subscribe(pattern, (event) => {
-      if (options?.while && runtime.sm.currentState !== options.while) return;
+    const unsub = runtime2.eventBus.subscribe(pattern, (event) => {
+      if (options?.while && runtime2.sm.currentState !== options.while) return;
       handlerRef.current(event);
     });
     return unsub;
-  }, [runtime, pattern, options?.while]);
+  }, [runtime2, pattern, options?.while]);
 }
 
 // src/hooks/useOnChange.ts
 import { useEffect as useEffect5, useRef as useRef5 } from "react";
 function useOnChange(field2, handler) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const handlerRef = useRef5(handler);
   handlerRef.current = handler;
-  const prevRef = useRef5(runtime.sm.stateData[field2]);
+  const prevRef = useRef5(runtime2.sm.stateData[field2]);
   useEffect5(() => {
-    const unsub = runtime.subscribe((snap) => {
+    const unsub = runtime2.subscribe((snap) => {
       const newVal = snap.stateData[field2];
       if (newVal !== prevRef.current) {
         handlerRef.current(newVal, prevRef.current);
@@ -1298,13 +222,13 @@ function useOnChange(field2, handler) {
       }
     });
     return unsub;
-  }, [runtime, field2]);
+  }, [runtime2, field2]);
 }
 
 // src/hooks/useWhileIn.ts
 import { useEffect as useEffect6, useRef as useRef6 } from "react";
 function useWhileIn(stateName, intervalMs, effect) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const effectRef = useRef6(effect);
   effectRef.current = effect;
   useEffect6(() => {
@@ -1319,8 +243,8 @@ function useWhileIn(stateName, intervalMs, effect) {
         timer = null;
       }
     }
-    if (runtime.sm.currentState === stateName) startInterval();
-    const unsub = runtime.sm.on((event) => {
+    if (runtime2.sm.currentState === stateName) startInterval();
+    const unsub = runtime2.sm.on((event) => {
       if (event.type === "state_enter" && event.to_state === stateName) startInterval();
       if (event.type === "state_exit" && event.from_state === stateName) stopInterval();
     });
@@ -1328,13 +252,13 @@ function useWhileIn(stateName, intervalMs, effect) {
       unsub();
       stopInterval();
     };
-  }, [runtime, stateName, intervalMs]);
+  }, [runtime2, stateName, intervalMs]);
 }
 
 // src/hooks/useDuringAction.ts
 import { useEffect as useEffect7, useRef as useRef7 } from "react";
 function useDuringAction(config) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const actionRef = useRef7(config.action);
   actionRef.current = config.action;
   const states = Array.isArray(config.state) ? config.state : [config.state];
@@ -1372,10 +296,10 @@ function useDuringAction(config) {
         timer = null;
       }
     }
-    if (states.includes(runtime.sm.currentState)) {
+    if (states.includes(runtime2.sm.currentState)) {
       startAction();
     }
-    const unsub = runtime.sm.on((event) => {
+    const unsub = runtime2.sm.on((event) => {
       if (event.type === "state_enter" && event.to_state && states.includes(event.to_state)) {
         startAction();
       }
@@ -1387,7 +311,7 @@ function useDuringAction(config) {
       unsub();
       stopAction();
     };
-  }, [runtime, intervalMs, immediate, enabled, ...states]);
+  }, [runtime2, intervalMs, immediate, enabled, ...states]);
 }
 
 // src/hooks/useQuery.ts
@@ -1880,29 +804,29 @@ function useServerState(instanceId, options = {}) {
 // src/hooks/useWorkflow.ts
 import { useState as useState7, useEffect as useEffect12, useMemo, useCallback as useCallback7 } from "react";
 function useWorkflow(definition, options) {
-  const runtime = useMemo(() => new WorkflowRuntime({
+  const runtime2 = useMemo(() => new WorkflowRuntime({
     definition,
     initialData: options?.initialData,
     actionHandlers: options?.actionHandlers
   }), [definition.id]);
-  const [snapshot, setSnapshot] = useState7(() => runtime.getSnapshot());
+  const [snapshot, setSnapshot] = useState7(() => runtime2.getSnapshot());
   useEffect12(() => {
-    const unsub = runtime.subscribe(setSnapshot);
+    const unsub = runtime2.subscribe(setSnapshot);
     return unsub;
-  }, [runtime]);
+  }, [runtime2]);
   const transition2 = useCallback7(async (name, data) => {
-    const result = await runtime.transition(name, data);
+    const result = await runtime2.transition(name, data);
     options?.onTransition?.(result);
     return result;
-  }, [runtime, options?.onTransition]);
+  }, [runtime2, options?.onTransition]);
   const handle = {
     slug: definition.slug,
     ...snapshot,
     transition: transition2,
-    setField: runtime.setField.bind(runtime),
-    setMemory: runtime.setMemory.bind(runtime),
-    publishEvent: runtime.publishEvent.bind(runtime),
-    runtime
+    setField: runtime2.setField.bind(runtime2),
+    setMemory: runtime2.setMemory.bind(runtime2),
+    publishEvent: runtime2.publishEvent.bind(runtime2),
+    runtime: runtime2
   };
   return handle;
 }
@@ -1910,17 +834,17 @@ function useWorkflow(definition, options) {
 // src/hooks/useTransition.ts
 import { useCallback as useCallback8, useState as useState8 } from "react";
 function useTransition(transitionName, _config) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const [pending, setPending] = useState8(false);
-  const available = runtime.sm.getAvailableTransitions().some((t) => t.name === transitionName);
+  const available = runtime2.sm.getAvailableTransitions().some((t) => t.name === transitionName);
   const fire = useCallback8(async (data) => {
     setPending(true);
     try {
-      return await runtime.transition(transitionName, data);
+      return await runtime2.transition(transitionName, data);
     } finally {
       setPending(false);
     }
-  }, [runtime, transitionName]);
+  }, [runtime2, transitionName]);
   const handle = { fire, available, pending };
   return handle;
 }
@@ -1932,12 +856,12 @@ function setRoleHierarchy(hierarchy) {
   _globalHierarchy = hierarchy;
 }
 function useRole(roleName, options = {}) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   const hierarchy = options.hierarchy ?? _globalHierarchy ?? [];
   const inheritPermissions = options.inheritPermissions ?? true;
   const result = useMemo2(() => {
-    const snapshot = runtime.getSnapshot();
-    const definition = runtime.config?.definition;
+    const snapshot = runtime2.getSnapshot();
+    const definition = runtime2.config?.definition;
     const userRoles = snapshot.stateData?._userRoles ?? snapshot.stateData?.user_roles ?? [];
     let hasRole2 = userRoles.includes(roleName);
     if (!hasRole2 && hierarchy.length > 0) {
@@ -1985,7 +909,7 @@ function useRole(roleName, options = {}) {
       }
     }
     return { hasRole: hasRole2, permissions, roles: userRoles, highestRole };
-  }, [runtime, roleName, hierarchy, inheritPermissions]);
+  }, [runtime2, roleName, hierarchy, inheritPermissions]);
   const isAbove = useCallback9(
     (role) => {
       if (hierarchy.length === 0) return false;
@@ -2036,21 +960,21 @@ function useRole(roleName, options = {}) {
 // src/hooks/useParams.ts
 import { useMemo as useMemo3 } from "react";
 function useParams() {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   return useMemo3(() => {
-    const snapshot = runtime.getSnapshot();
+    const snapshot = runtime2.getSnapshot();
     const params = snapshot.stateData?._params ?? snapshot.memory?._callParams ?? {};
     return params;
-  }, [runtime]);
+  }, [runtime2]);
 }
 
 // src/hooks/usePackage.ts
 import { useMemo as useMemo4 } from "react";
 function usePackage(packageSlug) {
-  const runtime = useRuntimeContext();
+  const runtime2 = useRuntimeContext();
   return useMemo4(() => {
-    const snapshot = runtime.getSnapshot();
-    const definition = runtime.config?.definition;
+    const snapshot = runtime2.getSnapshot();
+    const definition = runtime2.config?.definition;
     const childDefs = definition?.child_definitions ?? [];
     const metadata = definition?.metadata ?? {};
     if (definition?.slug === packageSlug && definition?.category === "blueprint") {
@@ -2113,7 +1037,7 @@ function usePackage(packageSlug) {
       isResolved: false,
       dependencySlugs: []
     };
-  }, [runtime, packageSlug]);
+  }, [runtime2, packageSlug]);
 }
 
 // src/hooks/useRouter.ts
@@ -2239,16 +1163,16 @@ function useRouter(options = {}) {
       };
       setIsNavigating(true);
       try {
-        for (const guard of guardsRef.current) {
-          const allowed = await guard(to, location);
+        for (const guard2 of guardsRef.current) {
+          const allowed = await guard2(to, location);
           if (!allowed) {
             onRejectRef.current?.(to);
             return false;
           }
         }
         if (found?.route?.guards) {
-          for (const guard of found.route.guards) {
-            const allowed = await guard(to, location);
+          for (const guard2 of found.route.guards) {
+            const allowed = await guard2(to, location);
             if (!allowed) {
               if (found.route.redirectOnFail) {
                 const fullRedirect = basePathRef.current + found.route.redirectOnFail;
@@ -2674,7 +1598,7 @@ function useGeolocation(options = {}) {
   const {
     enableHighAccuracy = false,
     maximumAge = 0,
-    timeout = 1e4,
+    timeout: timeout2 = 1e4,
     watch = false,
     enabled = true
   } = options;
@@ -2685,8 +1609,8 @@ function useGeolocation(options = {}) {
   const watchIdRef = useRef18(null);
   const supported = typeof navigator !== "undefined" && "geolocation" in navigator;
   const positionOptions = useMemo8(
-    () => ({ enableHighAccuracy, maximumAge, timeout }),
-    [enableHighAccuracy, maximumAge, timeout]
+    () => ({ enableHighAccuracy, maximumAge, timeout: timeout2 }),
+    [enableHighAccuracy, maximumAge, timeout2]
   );
   const handleSuccess = useCallback13((pos) => {
     setPosition({
@@ -3046,7 +1970,7 @@ import { useState as useState16, useCallback as useCallback16, useMemo as useMem
 function useForm(config) {
   const {
     initialValues,
-    validate,
+    validate: validate2,
     fieldValidators,
     onSubmit,
     onError,
@@ -3059,8 +1983,8 @@ function useForm(config) {
   const [isSubmitting, setIsSubmitting] = useState16(false);
   const [submitCount, setSubmitCount] = useState16(0);
   const initialRef = useRef20(initialValues);
-  const validateRef = useRef20(validate);
-  validateRef.current = validate;
+  const validateRef = useRef20(validate2);
+  validateRef.current = validate2;
   const fieldValidatorsRef = useRef20(fieldValidators);
   fieldValidatorsRef.current = fieldValidators;
   const onSubmitRef = useRef20(onSubmit);
@@ -3277,7 +2201,7 @@ function useNotification() {
     setPermission(result);
     return result;
   }, [supported]);
-  const notify2 = useCallback17(
+  const notify3 = useCallback17(
     (title, options = {}) => {
       if (!supported || permission !== "granted") return null;
       const {
@@ -3310,8 +2234,8 @@ function useNotification() {
     [supported, permission]
   );
   return useMemo12(
-    () => ({ permission, supported, requestPermission, notify: notify2 }),
-    [permission, supported, requestPermission, notify2]
+    () => ({ permission, supported, requestPermission, notify: notify3 }),
+    [permission, supported, requestPermission, notify3]
   );
 }
 
@@ -3328,12 +2252,12 @@ function notifyListeners() {
 }
 function addToast(config) {
   const id = `toast-${++_nextId}`;
-  const instance = {
+  const instance2 = {
     ...config,
     id,
     createdAt: Date.now()
   };
-  _toasts = [..._toasts, instance];
+  _toasts = [..._toasts, instance2];
   const duration = config.duration ?? 5e3;
   if (duration > 0) {
     const timer = setTimeout(() => {
@@ -3384,8 +2308,191 @@ function useToast() {
   );
 }
 
+// src/hooks/useVisibility.ts
+import { useMemo as useMemo14 } from "react";
+function useVisibility(model2, role, playerType) {
+  return useMemo14(() => {
+    return computeVisibility(model2, role, playerType);
+  }, [model2, role, playerType]);
+}
+function computeVisibility(model2, role, playerType) {
+  const allFields = Object.keys(model2.fields || {});
+  const allStates = Object.keys(model2.states || {});
+  const vis = model2.orchestration?.visibility;
+  if (!vis) {
+    return makeResult(allFields, allStates);
+  }
+  let roleFields;
+  let roleStates;
+  let playerFields;
+  if (role && vis.roles && vis.roles[role]) {
+    const rv = vis.roles[role];
+    roleFields = rv.fields === "*" ? "*" : [...rv.fields];
+    roleStates = rv.states === "*" ? "*" : rv.states ? [...rv.states] : "*";
+  }
+  if (playerType && vis.players && vis.players[playerType]) {
+    const pv = vis.players[playerType];
+    playerFields = pv.fields === "*" ? "*" : [...pv.fields];
+  }
+  if (roleFields === void 0 && playerFields === void 0) {
+    return makeResult(allFields, allStates);
+  }
+  let resolvedFields;
+  if (roleFields === "*" && playerFields === "*") {
+    resolvedFields = allFields;
+  } else if (roleFields === "*") {
+    resolvedFields = playerFields === void 0 ? allFields : playerFields;
+  } else if (playerFields === "*") {
+    resolvedFields = roleFields === void 0 ? allFields : roleFields;
+  } else if (roleFields !== void 0 && playerFields !== void 0) {
+    const roleSet = new Set(roleFields);
+    resolvedFields = playerFields.filter((f) => roleSet.has(f));
+  } else {
+    resolvedFields = roleFields || playerFields || allFields;
+  }
+  const resolvedStates = roleStates === "*" || roleStates === void 0 ? allStates : roleStates;
+  return makeResult(resolvedFields, resolvedStates);
+}
+function makeResult(fields, states) {
+  const fieldSet = new Set(fields);
+  const stateSet = new Set(states);
+  return {
+    visibleFields: fields,
+    visibleStates: states,
+    canSeeField: (f) => fieldSet.has(f),
+    canSeeState: (s) => stateSet.has(s)
+  };
+}
+
+// src/hooks/usePresence.ts
+import { useState as useState19, useEffect as useEffect20, useCallback as useCallback19, useRef as useRef22 } from "react";
+var PRESENCE_EVENTS = {
+  JOIN: "presence:join",
+  LEAVE: "presence:leave",
+  HEARTBEAT: "presence:heartbeat",
+  EDIT_START: "presence:edit_start",
+  EDIT_STOP: "presence:edit_stop"
+};
+function usePresence(instanceId, options = {}) {
+  const {
+    userId = "anonymous",
+    userName = "Anonymous",
+    wsUrl,
+    enabled = true,
+    heartbeatInterval = 15e3,
+    staleTimeout = 45e3
+  } = options;
+  const channelName = `presence:${instanceId}`;
+  const { publish, subscribe, connected } = useChannel(channelName, {
+    wsUrl,
+    enabled
+  });
+  const [viewers, setViewers] = useState19([]);
+  const [editors, setEditors] = useState19([]);
+  const viewersRef = useRef22(/* @__PURE__ */ new Map());
+  const editorsRef = useRef22(/* @__PURE__ */ new Map());
+  useEffect20(() => {
+    if (!connected || !enabled) return;
+    publish(PRESENCE_EVENTS.JOIN, { id: userId, name: userName, connectedAt: Date.now() });
+    const hb = setInterval(() => {
+      publish(PRESENCE_EVENTS.HEARTBEAT, { id: userId, name: userName });
+    }, heartbeatInterval);
+    return () => {
+      clearInterval(hb);
+      publish(PRESENCE_EVENTS.LEAVE, { id: userId });
+    };
+  }, [connected, enabled, userId, userName, heartbeatInterval, publish]);
+  useEffect20(() => {
+    if (!enabled) return;
+    const cleanup = setInterval(() => {
+      const now = Date.now();
+      const stale = [];
+      for (const [id, v] of viewersRef.current) {
+        if (now - v.connectedAt > staleTimeout) stale.push(id);
+      }
+      if (stale.length > 0) {
+        for (const id of stale) {
+          viewersRef.current.delete(id);
+          editorsRef.current.delete(id);
+        }
+        setViewers(Array.from(viewersRef.current.values()));
+        setEditors(Array.from(editorsRef.current.values()));
+      }
+    }, staleTimeout / 3);
+    return () => clearInterval(cleanup);
+  }, [enabled, staleTimeout]);
+  useEffect20(() => {
+    if (!enabled) return;
+    const unsubs = [];
+    unsubs.push(subscribe(PRESENCE_EVENTS.JOIN, (data) => {
+      if (data.id === userId) return;
+      viewersRef.current.set(data.id, {
+        id: data.id,
+        name: data.name || "Anonymous",
+        connectedAt: data.connectedAt || Date.now()
+      });
+      setViewers(Array.from(viewersRef.current.values()));
+    }));
+    unsubs.push(subscribe(PRESENCE_EVENTS.LEAVE, (data) => {
+      viewersRef.current.delete(data.id);
+      editorsRef.current.delete(data.id);
+      setViewers(Array.from(viewersRef.current.values()));
+      setEditors(Array.from(editorsRef.current.values()));
+    }));
+    unsubs.push(subscribe(PRESENCE_EVENTS.HEARTBEAT, (data) => {
+      if (data.id === userId) return;
+      const existing = viewersRef.current.get(data.id);
+      if (existing) {
+        existing.connectedAt = Date.now();
+      } else {
+        viewersRef.current.set(data.id, {
+          id: data.id,
+          name: data.name || "Anonymous",
+          connectedAt: Date.now()
+        });
+        setViewers(Array.from(viewersRef.current.values()));
+      }
+    }));
+    unsubs.push(subscribe(PRESENCE_EVENTS.EDIT_START, (data) => {
+      if (data.id === userId) return;
+      editorsRef.current.set(data.id, {
+        id: data.id,
+        name: data.name || "Anonymous",
+        field: data.field,
+        startedAt: Date.now()
+      });
+      setEditors(Array.from(editorsRef.current.values()));
+    }));
+    unsubs.push(subscribe(PRESENCE_EVENTS.EDIT_STOP, (data) => {
+      editorsRef.current.delete(data.id);
+      setEditors(Array.from(editorsRef.current.values()));
+    }));
+    return () => unsubs.forEach((fn) => fn());
+  }, [enabled, userId, subscribe]);
+  const startEditing = useCallback19((field2) => {
+    publish(PRESENCE_EVENTS.EDIT_START, { id: userId, name: userName, field: field2 });
+  }, [publish, userId, userName]);
+  const stopEditing = useCallback19((_field) => {
+    publish(PRESENCE_EVENTS.EDIT_STOP, { id: userId });
+  }, [publish, userId]);
+  const isEditing = useCallback19((field2) => {
+    for (const editor of editorsRef.current.values()) {
+      if (editor.field === field2 && editor.id !== userId) return true;
+    }
+    return false;
+  }, [userId]);
+  return {
+    viewers,
+    editors,
+    viewerCount: viewers.length,
+    isEditing,
+    startEditing,
+    stopEditing
+  };
+}
+
 // src/hooks/useMiddleware.ts
-import { useState as useState19, useEffect as useEffect20, useRef as useRef22, useMemo as useMemo14 } from "react";
+import { useState as useState20, useEffect as useEffect21, useRef as useRef23, useMemo as useMemo15 } from "react";
 function requireAuth(loginPath = "/login") {
   return (ctx) => {
     if (!ctx.token) {
@@ -3457,24 +2564,24 @@ function useMiddleware(middlewares, options = {}) {
     watchPathname = true,
     onRedirect
   } = options;
-  const [ready, setReady] = useState19(false);
-  const [loading, setLoading] = useState19(true);
-  const [redirect, setRedirect] = useState19(null);
-  const [error, setError] = useState19(null);
-  const [data, setData] = useState19({});
-  const [runKey, setRunKey] = useState19(0);
-  const middlewaresRef = useRef22(middlewares);
+  const [ready, setReady] = useState20(false);
+  const [loading, setLoading] = useState20(true);
+  const [redirect, setRedirect] = useState20(null);
+  const [error, setError] = useState20(null);
+  const [data, setData] = useState20({});
+  const [runKey, setRunKey] = useState20(0);
+  const middlewaresRef = useRef23(middlewares);
   middlewaresRef.current = middlewares;
-  const onRedirectRef = useRef22(onRedirect);
+  const onRedirectRef = useRef23(onRedirect);
   onRedirectRef.current = onRedirect;
-  const [pathname, setPathname] = useState19(getPathname);
-  useEffect20(() => {
+  const [pathname, setPathname] = useState20(getPathname);
+  useEffect21(() => {
     if (!watchPathname) return;
     const handler = () => setPathname(getPathname());
     window.addEventListener("popstate", handler);
     return () => window.removeEventListener("popstate", handler);
   }, [watchPathname]);
-  useEffect20(() => {
+  useEffect21(() => {
     if (!enabled) {
       setReady(true);
       setLoading(false);
@@ -3521,11 +2628,11 @@ function useMiddleware(middlewares, options = {}) {
       cancelled = true;
     };
   }, [enabled, pathname, runKey]);
-  const rerun = useMemo14(
+  const rerun = useMemo15(
     () => () => setRunKey((k) => k + 1),
     []
   );
-  return useMemo14(
+  return useMemo15(
     () => ({ ready, loading, redirect, error, data, rerun }),
     [ready, loading, redirect, error, data, rerun]
   );
@@ -3535,8 +2642,8 @@ function useMiddleware(middlewares, options = {}) {
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { jsx } from "react/jsx-runtime";
 var defaultQueryClient = new QueryClient();
-function WorkflowProvider({ runtime, queryClient, children }) {
-  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient ?? defaultQueryClient, children: /* @__PURE__ */ jsx(RuntimeContext.Provider, { value: runtime, children }) });
+function WorkflowProvider({ runtime: runtime2, queryClient, children }) {
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient ?? defaultQueryClient, children: /* @__PURE__ */ jsx(RuntimeContext.Provider, { value: runtime2, children }) });
 }
 
 // src/local/LocalEngine.ts
@@ -3597,8 +2704,8 @@ var LocalWorkflowEngine = class {
    * Process all pending events from a transition result.
    * Emits locally and returns the events for P2P broadcast.
    */
-  processPendingEvents(instance) {
-    const events = instance._pendingEvents;
+  processPendingEvents(instance2) {
+    const events = instance2._pendingEvents;
     if (!events?.length) return [];
     for (const evt of events) {
       this.emitEvent(evt);
@@ -3641,18 +2748,18 @@ var LocalWorkflowEngine = class {
     };
   }
   /** Check if a transition can fire from the instance's current state */
-  canTransition(instance, transitionName) {
-    const def = this.definitions.get(instance.definitionSlug);
+  canTransition(instance2, transitionName) {
+    const def = this.definitions.get(instance2.definitionSlug);
     if (!def) return false;
     const transition2 = def.transitions.find((t) => t.name === transitionName);
     if (!transition2) return false;
-    return transition2.from.includes(instance.currentState);
+    return transition2.from.includes(instance2.currentState);
   }
   /** Get all transitions available from the instance's current state */
-  getAvailableTransitions(instance) {
-    const def = this.definitions.get(instance.definitionSlug);
+  getAvailableTransitions(instance2) {
+    const def = this.definitions.get(instance2.definitionSlug);
     if (!def) return [];
-    return def.transitions.filter((t) => t.from.includes(instance.currentState)).map((t) => t.name);
+    return def.transitions.filter((t) => t.from.includes(instance2.currentState)).map((t) => t.name);
   }
   /**
    * Apply a transition, returning a new WorkflowInstance (immutable).
@@ -3663,29 +2770,29 @@ var LocalWorkflowEngine = class {
    * @returns New WorkflowInstance with updated state and version
    * @throws If transition is not valid from current state
    */
-  applyTransition(instance, transitionName, data) {
-    const def = this.definitions.get(instance.definitionSlug);
+  applyTransition(instance2, transitionName, data) {
+    const def = this.definitions.get(instance2.definitionSlug);
     if (!def) {
-      throw new Error(`Definition not found: ${instance.definitionSlug}`);
+      throw new Error(`Definition not found: ${instance2.definitionSlug}`);
     }
     const transition2 = def.transitions.find((t) => t.name === transitionName);
     if (!transition2) {
       throw new Error(
-        `Transition "${transitionName}" not found in ${instance.definitionSlug}`
+        `Transition "${transitionName}" not found in ${instance2.definitionSlug}`
       );
     }
-    if (!transition2.from.includes(instance.currentState)) {
+    if (!transition2.from.includes(instance2.currentState)) {
       throw new Error(
-        `Transition "${transitionName}" cannot fire from state "${instance.currentState}" (allowed from: ${transition2.from.join(", ")})`
+        `Transition "${transitionName}" cannot fire from state "${instance2.currentState}" (allowed from: ${transition2.from.join(", ")})`
       );
     }
-    const nextState = transition2.to ?? instance.currentState;
-    const fields = data ? { ...instance.fields, ...data } : { ...instance.fields };
+    const nextState = transition2.to ?? instance2.currentState;
+    const fields = data ? { ...instance2.fields, ...data } : { ...instance2.fields };
     let result = {
-      ...instance,
+      ...instance2,
       currentState: nextState,
       fields,
-      version: instance.version + 1,
+      version: instance2.version + 1,
       updatedAt: Date.now()
     };
     const targetStateDef = def.states.find((s) => s.name === nextState);
@@ -3758,14 +2865,14 @@ var LocalWorkflowEngine = class {
    * Apply a transition only if the incoming version is newer.
    * Used for P2P sync — skips stale transitions.
    */
-  applyRemoteTransition(instance, transitionName, data, remoteVersion) {
-    if (remoteVersion <= instance.version) {
+  applyRemoteTransition(instance2, transitionName, data, remoteVersion) {
+    if (remoteVersion <= instance2.version) {
       return null;
     }
-    if (!this.canTransition(instance, transitionName)) {
+    if (!this.canTransition(instance2, transitionName)) {
       return null;
     }
-    const updated = this.applyTransition(instance, transitionName, data);
+    const updated = this.applyTransition(instance2, transitionName, data);
     return { ...updated, version: remoteVersion };
   }
 };
@@ -4031,6 +3138,155 @@ function defineModel(def) {
   return def;
 }
 
+// src/config/orchestration-presets.ts
+var SOLO = {
+  strategy: "solo",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "any" },
+  events: { evaluator: "any-subscriber" },
+  errorHandling: { strategy: "manual" },
+  conflicts: { default: "last-writer-wins", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: false, showEditing: false, showViewing: false },
+  services: {},
+  actionRouting: {}
+};
+var CLIENT_SERVER = {
+  strategy: "client-server",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "server" },
+  events: { evaluator: "server" },
+  errorHandling: { strategy: "rollback" },
+  conflicts: { default: "last-writer-wins", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: false, showEditing: false, showViewing: false },
+  services: {},
+  actionRouting: {}
+};
+var MULTI_CLIENT = {
+  strategy: "multi-client",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "server" },
+  events: { evaluator: "server" },
+  errorHandling: { strategy: "compensate" },
+  conflicts: { default: "last-writer-wins", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: true, showEditing: true, showViewing: true, conflictHighlight: true },
+  services: {},
+  actionRouting: {}
+};
+var SERVICE_MESH = {
+  strategy: "service-mesh",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "server" },
+  events: { evaluator: "all" },
+  errorHandling: { strategy: "saga" },
+  conflicts: { default: "first-write-wins", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: false, showEditing: false, showViewing: false },
+  services: {},
+  actionRouting: {}
+};
+var PEER_TO_PEER = {
+  strategy: "peer-to-peer",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "any" },
+  events: { evaluator: "any-subscriber" },
+  errorHandling: { strategy: "compensate" },
+  conflicts: { default: "crdt", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: true, showEditing: true, showViewing: true, conflictHighlight: false },
+  services: {},
+  actionRouting: {}
+};
+var HYBRID = {
+  strategy: "hybrid",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "server" },
+  events: { evaluator: "server" },
+  errorHandling: { strategy: "saga" },
+  conflicts: { default: "last-writer-wins", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: true, showEditing: true, showViewing: false, conflictHighlight: false },
+  services: {},
+  actionRouting: {}
+};
+var HEADLESS = {
+  strategy: "headless",
+  evaluation: { pure: "local" },
+  // expression engine runs server-local (native Rust, fastest)
+  scheduling: { coordinator: "server" },
+  // server manages cron/interval/timeout
+  events: { evaluator: "server" },
+  // server matches events, no clients involved
+  errorHandling: { strategy: "compensate" },
+  conflicts: { default: "first-write-wins", fields: {} },
+  // no concurrent clients
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: false, showEditing: false, showViewing: false, conflictHighlight: false },
+  services: {},
+  actionRouting: {}
+};
+var ORCHESTRATION_PRESETS = {
+  "solo": SOLO,
+  "client-server": CLIENT_SERVER,
+  "multi-client": MULTI_CLIENT,
+  "service-mesh": SERVICE_MESH,
+  "peer-to-peer": PEER_TO_PEER,
+  "hybrid": HYBRID,
+  "headless": HEADLESS,
+  "custom": CLIENT_SERVER
+  // custom uses client-server as base
+};
+var DEFAULT_RESOLVED = {
+  strategy: "client-server",
+  evaluation: { pure: "local" },
+  scheduling: { coordinator: "server" },
+  events: { evaluator: "server" },
+  errorHandling: { strategy: "rollback" },
+  conflicts: { default: "last-writer-wins", fields: {} },
+  visibility: { roles: {}, players: {} },
+  presence: { enabled: false, showEditing: false, showViewing: false, conflictHighlight: false },
+  services: {},
+  actionRouting: {}
+};
+function resolveOrchestration(config) {
+  if (!config) return { ...DEFAULT_RESOLVED };
+  const strategy = config.strategy || "client-server";
+  const preset = ORCHESTRATION_PRESETS[strategy] || CLIENT_SERVER;
+  return {
+    strategy,
+    evaluation: {
+      pure: config.evaluation?.pure ?? preset.evaluation?.pure ?? "local"
+    },
+    scheduling: {
+      coordinator: config.scheduling?.coordinator ?? preset.scheduling?.coordinator ?? "server"
+    },
+    events: {
+      evaluator: config.events?.evaluator ?? preset.events?.evaluator ?? "server"
+    },
+    errorHandling: {
+      strategy: config.errorHandling?.strategy ?? preset.errorHandling?.strategy ?? "rollback"
+    },
+    conflicts: {
+      default: config.conflicts?.default ?? preset.conflicts?.default ?? "last-writer-wins",
+      fields: { ...preset.conflicts?.fields || {}, ...config.conflicts?.fields || {} }
+    },
+    visibility: {
+      roles: { ...preset.visibility?.roles || {}, ...config.visibility?.roles || {} },
+      players: { ...preset.visibility?.players || {}, ...config.visibility?.players || {} }
+    },
+    presence: {
+      enabled: config.presence?.enabled ?? preset.presence?.enabled ?? false,
+      showEditing: config.presence?.showEditing ?? preset.presence?.showEditing ?? false,
+      showViewing: config.presence?.showViewing ?? preset.presence?.showViewing ?? false,
+      conflictHighlight: config.presence?.conflictHighlight ?? preset.presence?.conflictHighlight ?? false
+    },
+    services: { ...preset.services || {}, ...config.services || {} },
+    actionRouting: { ...preset.actionRouting || {}, ...config.actionRouting || {} }
+  };
+}
+
 // src/config/defineBlueprint.ts
 function defineBlueprint(config) {
   if (!config.slug) {
@@ -4144,13 +3400,13 @@ function inState(state2) {
 function notInState(state2) {
   return { type: "expression", expression: `current_state != "${state2}"` };
 }
-function and2(...conditions) {
+function and(...conditions) {
   return { AND: conditions.map(normalize) };
 }
-function or2(...conditions) {
+function or(...conditions) {
   return { OR: conditions.map(normalize) };
 }
-function not2(condition) {
+function not(condition) {
   const c = normalize(condition);
   if (c.type === "expression" && c.expression) {
     return { type: "expression", expression: `NOT(${c.expression})` };
@@ -4195,7 +3451,7 @@ function refHasAnyRole(slug, lookupField, lookupValue, roles) {
 }
 
 // src/hooks/useModel.ts
-import { useCallback as useCallback19, useRef as useRef23, useMemo as useMemo15 } from "react";
+import { useCallback as useCallback20, useRef as useRef24, useMemo as useMemo16 } from "react";
 function getDefaultFields(definition) {
   const defaults = {};
   for (const [key, field2] of Object.entries(definition.fields)) {
@@ -4250,18 +3506,18 @@ function useModel(definition, options = {}) {
   if (options.state) queryParams.state = options.state;
   const query = useQuery(slug, queryParams);
   const mutation = useMutation(slug);
-  const instance = query.data?.[0];
-  const instanceId = instance?.id ?? null;
-  const currentState = instance?.currentState ?? "";
-  const instanceFields = instance?.fields ?? null;
-  const defaultFields = useMemo15(() => getDefaultFields(definition), [definition]);
-  const fields = useMemo15(() => {
+  const instance2 = query.data?.[0];
+  const instanceId = instance2?.id ?? null;
+  const currentState = instance2?.currentState ?? "";
+  const instanceFields = instance2?.fields ?? null;
+  const defaultFields = useMemo16(() => getDefaultFields(definition), [definition]);
+  const fields = useMemo16(() => {
     if (!instanceFields) return defaultFields;
     return { ...defaultFields, ...instanceFields };
   }, [instanceFields, defaultFields]);
-  const instanceIdRef = useRef23(instanceId);
+  const instanceIdRef = useRef24(instanceId);
   instanceIdRef.current = instanceId;
-  const trigger = useCallback19(async (name, input) => {
+  const trigger = useCallback20(async (name, input) => {
     const id = instanceIdRef.current;
     if (!id) {
       throw new Error(`useModel(${slug}): No instance loaded. Cannot trigger '${name}'.`);
@@ -4269,12 +3525,12 @@ function useModel(definition, options = {}) {
     await mutation.transition(id, name, input);
     await query.refetch();
   }, [slug, mutation, query]);
-  const create = useCallback19(async (input) => {
+  const create = useCallback20(async (input) => {
     const id = await mutation.create(input);
     await query.refetch();
     return id;
   }, [mutation, query]);
-  const update = useCallback19(async (fieldUpdates) => {
+  const update = useCallback20(async (fieldUpdates) => {
     const id = instanceIdRef.current;
     if (!id) {
       throw new Error(`useModel(${slug}): No instance loaded. Cannot update.`);
@@ -4303,27 +3559,27 @@ function useCollection(definition, options = {}) {
   const slug = definition.slug;
   const query = useQuery(slug, options);
   const mutation = useMutation(slug);
-  const items = useMemo15(() => {
-    return (query.data || []).map((instance) => ({
-      id: instance.id,
-      fields: instance.fields ?? {},
-      state: instance.currentState ?? ""
+  const items = useMemo16(() => {
+    return (query.data || []).map((instance2) => ({
+      id: instance2.id,
+      fields: instance2.fields ?? {},
+      state: instance2.currentState ?? ""
     }));
   }, [query.data]);
-  const trigger = useCallback19(async (instanceId, name, input) => {
+  const trigger = useCallback20(async (instanceId, name, input) => {
     await mutation.transition(instanceId, name, input);
     await query.refetch();
   }, [mutation, query]);
-  const create = useCallback19(async (input) => {
+  const create = useCallback20(async (input) => {
     const id = await mutation.create(input);
     await query.refetch();
     return id;
   }, [mutation, query]);
-  const update = useCallback19(async (instanceId, fieldUpdates) => {
+  const update = useCallback20(async (instanceId, fieldUpdates) => {
     await mutation.update(instanceId, fieldUpdates);
     await query.refetch();
   }, [mutation, query]);
-  const remove = useCallback19(async (instanceId) => {
+  const remove = useCallback20(async (instanceId) => {
     await mutation.remove(instanceId);
     await query.refetch();
   }, [mutation, query]);
@@ -4347,7 +3603,7 @@ function useCollection(definition, options = {}) {
 function stub(displayName) {
   const Component = () => {
     throw new Error(
-      `<${displayName}> is a compile-time stub from @mindmatrix/react/atoms. It should only appear in .workflow.tsx files processed by the compiler. At runtime, use the ComponentTreeRenderer which resolves "${displayName}" from the component registry.`
+      `<${displayName}> is a compile-time stub from @mmapp/react/atoms. It should only appear in .workflow.tsx files processed by the compiler. At runtime, use the ComponentTreeRenderer which resolves "${displayName}" from the component registry.`
     );
   };
   Component.displayName = displayName;
@@ -4474,7 +3730,7 @@ function djb2Hash(str) {
 }
 
 // src/authoring.ts
-function useState20(_defaultOrKey) {
+function useState21(_defaultOrKey) {
   return [void 0, () => {
   }];
 }
@@ -4485,10 +3741,10 @@ function defineWorkspace(config) {
 }
 
 // src/hooks/useModule.ts
-import { useMemo as useMemo16 } from "react";
+import { useMemo as useMemo17 } from "react";
 function useModule(slug, config = {}, options = {}) {
   const { enabled = true } = options;
-  return useMemo16(() => ({
+  return useMemo17(() => ({
     slug,
     config,
     isLoaded: enabled
@@ -4496,7 +3752,7 @@ function useModule(slug, config = {}, options = {}) {
 }
 
 // src/hooks/useModuleConfig.ts
-import { useMemo as useMemo17 } from "react";
+import { useCallback as useCallback21, useMemo as useMemo18, useState as useState22 } from "react";
 var installedModulesStore = [];
 var configDefaultsStore = /* @__PURE__ */ new Map();
 function setInstalledModules(modules) {
@@ -4512,12 +3768,65 @@ function getInstalledModules() {
   return installedModulesStore;
 }
 function useModuleConfig(moduleSlug) {
-  return useMemo17(() => {
+  return useMemo18(() => {
     const installed = getInstalledModule(moduleSlug);
     const defaults = configDefaultsStore.get(moduleSlug) ?? {};
-    return { ...defaults, ...installed?.config };
+    const persisted = persistedConfigStore.get(moduleSlug) ?? {};
+    return { ...defaults, ...persisted, ...installed?.config };
   }, [moduleSlug]);
 }
+var persistedConfigStore = /* @__PURE__ */ new Map();
+function setPersistedModuleConfig(moduleSlug, config) {
+  persistedConfigStore.set(moduleSlug, config);
+}
+async function syncConfigDefaults(moduleSlug, defaults, definitionId) {
+  const id = definitionId ?? activeDefinitionIdStore;
+  if (!id) return;
+  try {
+    const moduleKey = `module_config.${moduleSlug}`;
+    await updateDefinitionConfig({ [moduleKey]: defaults }, id);
+    persistedConfigStore.set(moduleSlug, defaults);
+  } catch (e) {
+    console.warn(`[useModuleConfig] Failed to sync config for ${moduleSlug}:`, e);
+  }
+}
+var activeDefinitionIdStore = null;
+var apiBaseUrlStore = "/api/v1/workflow";
+function setConfigContext(definitionId, apiBaseUrl) {
+  activeDefinitionIdStore = definitionId;
+  if (apiBaseUrl) apiBaseUrlStore = apiBaseUrl;
+}
+async function updateDefinitionConfig(values, definitionId) {
+  const id = definitionId ?? activeDefinitionIdStore;
+  if (!id) throw new Error("No active definition ID. Call setConfigContext() first.");
+  const token = typeof localStorage !== "undefined" ? localStorage.getItem("auth_token") : null;
+  const response = await fetch(`${apiBaseUrlStore}/definitions/${id}/config`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify(values)
+  });
+  if (!response.ok) {
+    const err = await response.json().catch(() => ({ message: response.statusText }));
+    throw new Error(err.message || `Failed to update config: ${response.status}`);
+  }
+  return response.json();
+}
+function useModuleConfigWithMutation(moduleSlug) {
+  const config = useModuleConfig(moduleSlug);
+  const [isSaving, setIsSaving] = useState22(false);
+  const updateConfig = useCallback21(async (values) => {
+    setIsSaving(true);
+    try {
+      return await updateDefinitionConfig(values);
+    } finally {
+      setIsSaving(false);
+    }
+  }, []);
+  return { config, updateConfig, isSaving };
+}
 
 // src/builders.ts
 function handlerToAction(handler, qualifier) {
@@ -6021,7 +5330,7 @@ function approval(config = {}) {
 }
 function escalation(config) {
   const {
-    timeout,
+    timeout: timeout2,
     notifyRole = "admin",
     fromState = "pending_approval",
     escalatedState = "escalated"
@@ -6033,7 +5342,7 @@ function escalation(config) {
     });
     if (def.states[fromState]) {
       def.states[fromState].timeout = {
-        duration: timeout,
+        duration: timeout2,
         fallback: { transition: "escalate" }
       };
     }
@@ -6052,8 +5361,8 @@ function escalation(config) {
         from: fromState,
         to: escalatedState,
         auto: true,
-        description: `Auto-escalate after ${timeout}`,
-        actions: [logEvent("escalated", { timeout })]
+        description: `Auto-escalate after ${timeout2}`,
+        actions: [logEvent("escalated", { timeout: timeout2 })]
       }
     });
     return def;
@@ -6711,7 +6020,14 @@ function describeModel(def) {
 }
 
 // src/hooks/usePlayer.ts
-import { useCallback as useCallback20, useEffect as useEffect21, useMemo as useMemo18, useRef as useRef24, useState as useState21 } from "react";
+import { useCallback as useCallback22, useEffect as useEffect22, useMemo as useMemo19, useRef as useRef25, useState as useState23 } 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;
@@ -6751,18 +6067,18 @@ function computePlayerState(sm) {
   };
 }
 function usePlayer(config) {
-  const configRef = useRef24(config);
+  const configRef = useRef25(config);
   configRef.current = config;
-  useEffect21(() => {
+  useEffect22(() => {
     if (config.debug) setPlayerDebug(true);
   }, [config.debug]);
-  const evaluator = useMemo18(() => {
-    return createEvaluator({
+  const evaluator = useMemo19(() => {
+    return createEvaluator2({
       functions: config.functions ?? [],
-      failurePolicy: WEB_FAILURE_POLICIES.EVENT_REACTION
+      failurePolicy: WEB_FAILURE_POLICIES2.EVENT_REACTION
     });
   }, [config.definition.id]);
-  const engine = useMemo18(() => {
+  const engine = useMemo19(() => {
     const actionHandlers = /* @__PURE__ */ new Map();
     if (config.actionHandlers) {
       for (const [type, handler] of Object.entries(config.actionHandlers)) {
@@ -6790,14 +6106,14 @@ function usePlayer(config) {
         });
       }
     });
-    const sm2 = new StateMachine(
+    const sm2 = new StateMachine2(
       config.definition,
       config.initialData ?? {},
       { evaluator, actionHandlers }
     );
     smRef = sm2;
-    const eventBus2 = new EventBus();
-    const dispatcher = new ActionDispatcher();
+    const eventBus2 = new EventBus2();
+    const dispatcher = new ActionDispatcher2();
     dispatcher.register("set_field", (cfg) => {
       if (smRef && typeof cfg.field === "string") {
         smRef.setField(cfg.field, cfg.value);
@@ -6816,8 +6132,8 @@ function usePlayer(config) {
     return { sm: sm2, eventBus: eventBus2, dispatcher };
   }, [config.definition.id, evaluator]);
   const { sm, eventBus } = engine;
-  const [playerState, setPlayerState] = useState21(() => computePlayerState(sm));
-  useEffect21(() => {
+  const [playerState, setPlayerState] = useState23(() => computePlayerState(sm));
+  useEffect22(() => {
     const stateDef = sm.getCurrentStateDefinition();
     if (!stateDef?.on_event?.length) return;
     const unsubs = [];
@@ -6881,7 +6197,7 @@ function usePlayer(config) {
       for (const unsub of unsubs) unsub();
     };
   }, [sm, eventBus, evaluator, engine.dispatcher, playerState.currentState]);
-  useEffect21(() => {
+  useEffect22(() => {
     const unsub = sm.on((event) => {
       if (event.type === "transition" || event.type === "state_enter") {
         setPlayerState(computePlayerState(sm));
@@ -6897,7 +6213,7 @@ function usePlayer(config) {
     });
     return unsub;
   }, [sm]);
-  const transition2 = useCallback20(
+  const transition2 = useCallback22(
     async (name, data) => {
       playerLog({
         level: "info",
@@ -6924,20 +6240,20 @@ function usePlayer(config) {
     },
     [sm]
   );
-  const setField2 = useCallback20(
+  const setField2 = useCallback22(
     (field2, value) => {
       sm.setField(field2, value);
       setPlayerState(computePlayerState(sm));
     },
     [sm]
   );
-  const setMemory = useCallback20(
+  const setMemory = useCallback22(
     (key, value) => {
       sm.setMemory(key, value);
     },
     [sm]
   );
-  const publishEvent = useCallback20(
+  const publishEvent = useCallback22(
     (topic, payload) => {
       playerLog({
         level: "debug",
@@ -6963,11 +6279,11 @@ function usePlayer(config) {
 }
 
 // src/hooks/useDomainSubscription.ts
-import { useEffect as useEffect22, useRef as useRef25 } from "react";
+import { useEffect as useEffect23, useRef as useRef26 } from "react";
 function useDomainSubscription(eventBus, transport, config) {
-  const configRef = useRef25(config);
+  const configRef = useRef26(config);
   configRef.current = config;
-  useEffect22(() => {
+  useEffect23(() => {
     if (!transport || config.enabled === false) return;
     const unsub = transport.subscribe(
       {
@@ -7020,11 +6336,11 @@ function useDomainSubscription(eventBus, transport, config) {
 }
 
 // src/hooks/useExperienceState.ts
-import { useCallback as useCallback21, useRef as useRef26 } from "react";
+import { useCallback as useCallback23, useRef as useRef27 } from "react";
 function useExperienceState(player, selector) {
-  const selectorRef = useRef26(selector);
+  const selectorRef = useRef27(selector);
   selectorRef.current = selector;
-  const getSnapshot = useCallback21(() => {
+  const getSnapshot = useCallback23(() => {
     return selectorRef.current({
       currentState: player.currentState,
       stateData: player.stateData,
@@ -7040,20 +6356,20 @@ function useStateField(player, field2, defaultValue) {
 }
 
 // src/hooks/useComputed.ts
-import { useMemo as useMemo19, useRef as useRef27 } from "react";
+import { useMemo as useMemo20, useRef as useRef28 } from "react";
 function useComputed(_name, compute, options) {
   const mode = options?.mode ?? "read-time";
   const deps = options?.deps ?? [];
-  const computeRef = useRef27(compute);
+  const computeRef = useRef28(compute);
   computeRef.current = compute;
   if (mode === "read-time") {
-    return useMemo19(() => computeRef.current(), [
+    return useMemo20(() => computeRef.current(), [
       // We intentionally depend on deps.join to recompute when tracked fields change
       // The actual dependency tracking happens at the compiler level
       deps.join(",")
     ]);
   }
-  return useMemo19(() => computeRef.current(), [deps.join(",")]);
+  return useMemo20(() => computeRef.current(), [deps.join(",")]);
 }
 function useComputedWithMeta(name, compute, options) {
   const value = useComputed(name, compute, options);
@@ -7086,7 +6402,7 @@ function usePlayerContextSafe() {
 }
 
 // src/components/ExperienceWorkflowBridge.tsx
-import { useMemo as useMemo20 } from "react";
+import { useMemo as useMemo21 } from "react";
 import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 function ExperienceWorkflowBridgeInner({
   definition,
@@ -7104,7 +6420,7 @@ function ExperienceWorkflowBridgeInner({
     actionHandlers,
     debug
   });
-  const viewConfig = useMemo20(() => {
+  const viewConfig = useMemo21(() => {
     if (!definition.state_views) return void 0;
     return definition.state_views[player.currentState];
   }, [definition.state_views, player.currentState]);
@@ -7460,7 +6776,7 @@ var BrowserPlayer = class {
     this.ensureInitialized();
     const id = crypto.randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const instance = {
+    const instance2 = {
       id,
       definitionId: options.definitionId ?? definitionSlug,
       definitionSlug,
@@ -7472,15 +6788,15 @@ var BrowserPlayer = class {
       createdAt: now,
       updatedAt: now
     };
-    await this.putInstance(instance);
+    await this.putInstance(instance2);
     this.log("info", `Instance created: ${id} (${definitionSlug})`);
     this.emit({
       type: "instance:created",
       instanceId: id,
-      data: { definitionSlug, currentState: instance.currentState },
+      data: { definitionSlug, currentState: instance2.currentState },
       timestamp: Date.now()
     });
-    return instance;
+    return instance2;
   }
   /** Get an instance by ID. */
   async getInstance(id) {
@@ -7489,13 +6805,13 @@ var BrowserPlayer = class {
   }
   /** Get the current state of an instance. */
   async getState(id) {
-    const instance = await this.getInstance(id);
-    if (!instance) return null;
+    const instance2 = await this.getInstance(id);
+    if (!instance2) return null;
     return {
-      currentState: instance.currentState,
-      status: instance.status,
-      stateData: instance.stateData,
-      lockVersion: instance.lockVersion
+      currentState: instance2.currentState,
+      status: instance2.status,
+      stateData: instance2.stateData,
+      lockVersion: instance2.lockVersion
     };
   }
   /**
@@ -7506,34 +6822,34 @@ var BrowserPlayer = class {
    */
   async transition(instanceId, transitionName, data = {}) {
     this.ensureInitialized();
-    const instance = await this.getInstanceFromDb(instanceId);
-    if (!instance) {
+    const instance2 = await this.getInstanceFromDb(instanceId);
+    if (!instance2) {
       return {
         success: false,
         instance: null,
         error: `Instance ${instanceId} not found`
       };
     }
-    if (instance.status !== "ACTIVE") {
+    if (instance2.status !== "ACTIVE") {
       return {
         success: false,
-        instance,
-        error: `Instance is ${instance.status}, cannot transition`
+        instance: instance2,
+        error: `Instance is ${instance2.status}, cannot transition`
       };
     }
     try {
-      const newStateData = { ...instance.stateData, ...data };
-      const newLockVersion = instance.lockVersion + 1;
+      const newStateData = { ...instance2.stateData, ...data };
+      const newLockVersion = instance2.lockVersion + 1;
       if (this.wasm.execute_transition) {
         const request = {
           instance: {
-            id: instance.id,
-            definition_id: instance.definitionId,
-            current_state: instance.currentState,
-            status: instance.status,
+            id: instance2.id,
+            definition_id: instance2.definitionId,
+            current_state: instance2.currentState,
+            status: instance2.status,
             state_data: newStateData,
-            memory: instance.memory,
-            execution_lock_version: instance.lockVersion
+            memory: instance2.memory,
+            execution_lock_version: instance2.lockVersion
           },
           transition_name: transitionName,
           actor_id: this.peerId,
@@ -7542,26 +6858,26 @@ var BrowserPlayer = class {
         const resultJson = this.wasm.execute_transition(JSON.stringify(request));
         const result = JSON.parse(resultJson);
         if (result.success === false || result.error) {
-          return { success: false, instance, error: result.error ?? "Transition failed" };
+          return { success: false, instance: instance2, error: result.error ?? "Transition failed" };
         }
-        instance.currentState = result.to_state ?? instance.currentState;
-        instance.status = result.status ?? instance.status;
-        instance.stateData = result.state_data ?? newStateData;
-        instance.memory = result.memory ?? instance.memory;
+        instance2.currentState = result.to_state ?? instance2.currentState;
+        instance2.status = result.status ?? instance2.status;
+        instance2.stateData = result.state_data ?? newStateData;
+        instance2.memory = result.memory ?? instance2.memory;
       } else {
-        instance.stateData = newStateData;
+        instance2.stateData = newStateData;
       }
-      instance.lockVersion = newLockVersion;
-      instance.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.putInstance(instance);
+      instance2.lockVersion = newLockVersion;
+      instance2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.putInstance(instance2);
       this.log("info", `Transition: ${instanceId} ${transitionName}`);
       this.emit({
         type: "instance:transition",
         instanceId,
         data: {
           transitionName,
-          fromState: instance.currentState,
-          toState: instance.currentState,
+          fromState: instance2.currentState,
+          toState: instance2.currentState,
           lockVersion: newLockVersion
         },
         timestamp: Date.now()
@@ -7571,7 +6887,7 @@ var BrowserPlayer = class {
           type: "TransitionReplication",
           instance_id: instanceId,
           transition_name: transitionName,
-          state_data: instance.stateData,
+          state_data: instance2.stateData,
           lock_version: newLockVersion
         });
         const envelope = this.wasm.sign_envelope(this.secretKeyHex, payload);
@@ -7581,11 +6897,11 @@ var BrowserPlayer = class {
           envelope
         }));
       }
-      return { success: true, instance };
+      return { success: true, instance: instance2 };
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
       this.log("error", `Transition failed: ${error}`);
-      return { success: false, instance, error };
+      return { success: false, instance: instance2, error };
     }
   }
   // ─── Subscriptions ──────────────────────────────────────────────────
@@ -7665,12 +6981,12 @@ var BrowserPlayer = class {
       request.onerror = () => reject(request.error);
     });
   }
-  async putInstance(instance) {
+  async putInstance(instance2) {
     if (!this.db) return;
     return new Promise((resolve, reject) => {
       const tx = this.db.transaction(INSTANCE_STORE_NAME, "readwrite");
       const store = tx.objectStore(INSTANCE_STORE_NAME);
-      store.put(instance);
+      store.put(instance2);
       tx.oncomplete = () => resolve();
       tx.onerror = () => reject(tx.error);
     });
@@ -7817,9 +7133,381 @@ var BrowserPlayer = class {
     }
   }
 };
+
+// src/middleware-def.ts
+function defineMiddleware(def) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!def.name || typeof def.name !== "string") {
+      throw new Error("defineMiddleware: name is required and must be a string");
+    }
+    if (!def.match) {
+      throw new Error("defineMiddleware: match pattern is required");
+    }
+    const patterns = Array.isArray(def.match) ? def.match : [def.match];
+    for (const p of patterns) {
+      if (typeof p !== "string") {
+        throw new Error(`defineMiddleware: match pattern must be a string, got ${typeof p}`);
+      }
+    }
+    if (def.priority !== void 0 && typeof def.priority !== "number") {
+      throw new Error("defineMiddleware: priority must be a number");
+    }
+    if (!def.before && !def.after && !def.around) {
+      throw new Error("defineMiddleware: at least one of before, after, or around must be provided");
+    }
+  }
+  return def;
+}
+function extendMiddleware(base, overrides) {
+  let introduce;
+  if (base.introduce || overrides.introduce) {
+    introduce = {
+      fields: { ...base.introduce?.fields, ...overrides.introduce?.fields },
+      states: { ...base.introduce?.states, ...overrides.introduce?.states },
+      transitions: { ...base.introduce?.transitions, ...overrides.introduce?.transitions }
+    };
+    if (introduce.fields && Object.keys(introduce.fields).length === 0) introduce.fields = void 0;
+    if (introduce.states && Object.keys(introduce.states).length === 0) introduce.states = void 0;
+    if (introduce.transitions && Object.keys(introduce.transitions).length === 0) introduce.transitions = void 0;
+  }
+  const merged = {
+    ...base,
+    ...overrides,
+    // Config is merged (overrides win per-key)
+    config: base.config || overrides.config ? { ...base.config, ...overrides.config } : void 0
+  };
+  if (introduce) {
+    merged.introduce = introduce;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    if (!merged.name || typeof merged.name !== "string") {
+      throw new Error("extendMiddleware: resulting middleware must have a name");
+    }
+    if (!merged.match) {
+      throw new Error("extendMiddleware: resulting middleware must have a match pattern");
+    }
+    if (!merged.before && !merged.after && !merged.around) {
+      throw new Error("extendMiddleware: resulting middleware must have at least one of before, after, or around");
+    }
+  }
+  return merged;
+}
+function withAuth(opts) {
+  const _redirectTo = opts?.redirectTo;
+  return {
+    name: "mm:auth",
+    match: "*:*:transition.execute",
+    priority: 90,
+    before(ctx) {
+      if (!ctx.actor.id) {
+        ctx.block(_redirectTo ? `redirect:${_redirectTo}` : "Authentication required");
+      }
+    }
+  };
+}
+function withAuditLog(opts) {
+  const _level = opts?.level ?? "info";
+  return {
+    name: "mm:audit-log",
+    match: "*:*:transition.execute",
+    priority: 0,
+    after(ctx) {
+      ctx.modify({
+        __audit: {
+          level: _level,
+          actor: ctx.actor.id,
+          transition: ctx.transition?.name,
+          from: ctx.transition?.from,
+          to: ctx.transition?.to,
+          timestamp: ctx.timestamp
+        }
+      });
+    }
+  };
+}
+function withRateLimit(opts) {
+  const _max = opts?.maxPerMinute ?? 60;
+  return {
+    name: "mm:rate-limit",
+    match: "*:*:transition.execute",
+    priority: 80,
+    config: {
+      maxPerMinute: { type: "number", default: _max }
+    },
+    before(ctx) {
+      const fields = ctx.instance.fields;
+      const counter = fields.__rateCounter || 0;
+      if (counter >= _max) {
+        ctx.block(`Rate limit exceeded: ${_max} per minute`);
+      }
+    }
+  };
+}
+function withValidation(opts) {
+  const _rules = opts?.rules ?? [];
+  return {
+    name: "mm:validation",
+    match: "*:*:field.change",
+    priority: 70,
+    config: {
+      rules: { type: "json", default: _rules }
+    },
+    before(ctx) {
+      if (!ctx.field) return;
+      for (const rule of _rules) {
+        if (rule.fields.includes(ctx.field.name)) {
+          ctx.block(rule.message);
+        }
+      }
+    }
+  };
+}
+function withMetrics(opts) {
+  const _endpoint = opts?.endpoint;
+  return {
+    name: "mm:metrics",
+    match: "*:*:*",
+    priority: 100,
+    config: {
+      endpoint: { type: "string", default: _endpoint }
+    },
+    async around(ctx, next) {
+      const start = ctx.timestamp;
+      await next();
+      const duration = Date.now() - start;
+      ctx.modify({
+        __metrics: {
+          duration,
+          endpoint: _endpoint,
+          actor: ctx.actor.id
+        }
+      });
+    }
+  };
+}
+
+// src/actor.ts
+function compileTimeOnly(name) {
+  throw new Error(
+    `${name}() is a compile-time function and cannot be called at runtime. Use \`mmrc build\` to compile your workflow.`
+  );
+}
+var DEFAULT_SUPERVISION = {
+  strategy: "escalate"
+};
+var DEFAULT_MAILBOX = {
+  capacity: 1e3,
+  overflow: "error",
+  priority: "fifo"
+};
+function configureActor(config) {
+  void config;
+  return {
+    __actor: true,
+    supervision: config.supervision ?? DEFAULT_SUPERVISION,
+    mailbox: config.mailbox ?? DEFAULT_MAILBOX,
+    hierarchy: config.hierarchy ?? {}
+  };
+}
+function spawnActor(_slug, _options) {
+  compileTimeOnly("spawnActor");
+}
+function sendMessage(_instanceId, _action, _payload) {
+  compileTimeOnly("sendMessage");
+}
+function isActorConfig(value) {
+  return typeof value === "object" && value !== null && value.__actor === true;
+}
+
+// src/constraints.ts
+var BUILT_IN_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "every state is reachable",
+  "no deadlocks",
+  "no unreachable states",
+  "deterministic guards",
+  "terminates",
+  "no guard overlaps",
+  "all roles defined",
+  "all fields validated"
+]);
+function constraints(...rules) {
+  if (process.env.NODE_ENV !== "production") {
+    if (rules.length === 0) {
+      throw new Error("constraints(): at least one constraint rule is required");
+    }
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      if (typeof rule !== "string" || rule.trim() === "") {
+        throw new Error(
+          `constraints(): rule at index ${i} must be a non-empty string, got ${typeof rule}`
+        );
+      }
+    }
+  }
+  return {
+    __constraints: true,
+    rules: Object.freeze([...rules])
+  };
+}
+function isConstraintDeclaration(value) {
+  return typeof value === "object" && value !== null && value.__constraints === true && Array.isArray(value.rules);
+}
+function isBuiltInConstraint(rule) {
+  return BUILT_IN_CONSTRAINTS.has(rule);
+}
+
+// src/extend.ts
+function extend(base, options) {
+  const _metadata = {
+    __extend: true,
+    base,
+    options
+  };
+  throw new Error(
+    `extend() is a compile-time declaration and cannot be called at runtime. Ensure your build pipeline includes the @mmapp/react-compiler Babel plugin or compile your workflow files with \`mmrc build\` before execution.
+
+Base workflow: ${base?.name ?? "(anonymous)"}
+Derived slug: ${options.slug ?? "(not specified)"}`
+  );
+  return _metadata;
+}
+
+// src/compose.ts
+function compose(workflow, ...mixins) {
+  for (let i = 0; i < mixins.length; i++) {
+    const mixin = mixins[i];
+    if (!mixin || mixin.__mixin !== true) {
+      throw new Error(
+        `compose() argument ${i + 2} is not a valid WorkflowMixin. Each mixin must be created by a mixin factory (e.g. withAuditTrail(), withSoftDelete()). Received: ${typeof mixin === "object" ? JSON.stringify(mixin) : String(mixin)}`
+      );
+    }
+  }
+  const metadata = {
+    __composed: true,
+    workflow,
+    mixins: Object.freeze([...mixins])
+  };
+  const composed = (async (...args) => {
+    return workflow(...args);
+  });
+  Object.defineProperty(composed, "__composed", {
+    value: metadata,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(composed, "name", {
+    value: `composed(${workflow.name || "anonymous"})`,
+    writable: false,
+    configurable: true
+  });
+  return composed;
+}
+
+// src/imperative.ts
+function compileTimeOnly2(name) {
+  throw new Error(
+    `${name}() is a compile-time function and cannot be called at runtime. Use \`mmrc build\` to compile your workflow.`
+  );
+}
+function compileTimeProxy(label) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        throw new Error(
+          `Cannot access \`${label}.${String(prop)}\` at runtime. \`${label}\` is a compile-time constant. Use \`mmrc build\` to compile your workflow.`
+        );
+      }
+    }
+  );
+}
+function validate(_condition, _message, _severity) {
+  compileTimeOnly2("validate");
+}
+function log(_event, _data) {
+  compileTimeOnly2("log");
+}
+function notify2(_to, _message, _opts) {
+  compileTimeOnly2("notify");
+}
+function emit(_event, _payload) {
+  compileTimeOnly2("emit");
+}
+function requireRole2(..._roles) {
+  compileTimeOnly2("requireRole");
+}
+function requireField(..._fields) {
+  compileTimeOnly2("requireField");
+}
+function guard(_expression) {
+  compileTimeOnly2("guard");
+}
+function every(_interval, _fn) {
+  compileTimeOnly2("every");
+}
+function cron2(_expression, _fn) {
+  compileTimeOnly2("cron");
+}
+function after(_delay, _fn) {
+  compileTimeOnly2("after");
+}
+function on(_pattern, _handlerOrOpts) {
+  compileTimeOnly2("on");
+}
+function timeout(_duration, _handler) {
+  compileTimeOnly2("timeout");
+}
+function userAction(_name, _opts) {
+  compileTimeOnly2("userAction");
+}
+function userChoice(_options) {
+  compileTimeOnly2("userChoice");
+}
+function named(_name, _stateCall) {
+  compileTimeOnly2("named");
+}
+function delay(_duration) {
+  compileTimeOnly2("delay");
+}
+function allowTransition(_name, _opts) {
+  compileTimeOnly2("allowTransition");
+}
+function restrict(_field, _opts) {
+  compileTimeOnly2("restrict");
+}
+function visibleTo(..._roles) {
+  compileTimeOnly2("visibleTo");
+}
+function editableBy(..._roles) {
+  compileTimeOnly2("editableBy");
+}
+function editableIn(..._states) {
+  compileTimeOnly2("editableIn");
+}
+function defineRoles(roles) {
+  void roles;
+  compileTimeOnly2("defineRoles");
+}
+function runtime(_target) {
+  compileTimeOnly2("runtime");
+}
+function orchestration(config) {
+  void config;
+  compileTimeOnly2("orchestration");
+}
+function blueprint(_slug, _config) {
+  compileTimeOnly2("blueprint");
+}
+function patch(_id, _overrides) {
+  compileTimeOnly2("patch");
+}
+var actor = compileTimeProxy("actor");
+var instance = compileTimeProxy("instance");
 export {
   Accordion,
   AnimatedBox,
+  BUILT_IN_CONSTRAINTS,
   Badge,
   Blueprint,
   BrowserPlayer,
@@ -7846,6 +7534,7 @@ export {
   Modal,
   ModelBuilder,
   NavLink,
+  ORCHESTRATION_PRESETS,
   PlayerProvider,
   RoleGuard,
   Route,
@@ -7869,12 +7558,19 @@ export {
   WorkflowProvider,
   WorkflowRuntime,
   action,
-  and2 as and,
+  actor,
+  after,
+  allowTransition,
+  and,
   applyMixins,
   approval,
   assertModelValid,
   cedar,
+  compose,
+  computeVisibility,
+  configureActor,
   connector,
+  constraints,
   createActions,
   createCRUD,
   createLocalDataResolver,
@@ -7883,16 +7579,26 @@ export {
   cron,
   crud,
   defineBlueprint,
+  blueprint as defineImperativeBlueprint,
+  defineMiddleware,
   defineModel,
   defineModule,
+  defineRoles,
   defineWorkspace,
+  delay,
   deriveInstanceKey,
   deriveInstanceKeySync,
   describeModel,
   deviceAction,
   dmn,
+  editableBy,
+  editableIn,
+  emit,
   escalation,
+  every,
   expr,
+  extend,
+  extendMiddleware,
   field,
   fieldContains,
   fieldEquals,
@@ -7907,12 +7613,21 @@ export {
   getInstalledModule,
   getInstalledModules,
   graphql,
+  guard,
   hasAnyRole,
   hasRole,
+  cron2 as imperativeCron,
+  log as imperativeLog,
+  notify2 as imperativeNotify,
+  requireRole2 as imperativeRequireRole,
   inState,
   inputEquals,
   inputRequired,
+  instance,
   isActor,
+  isActorConfig,
+  isBuiltInConstraint,
+  isConstraintDeclaration,
   isCreator,
   isOwner,
   isPlayerDebug,
@@ -7922,28 +7637,39 @@ export {
   loadExperienceWorkflow,
   logEvent,
   model,
+  named,
   normalizeDefinition,
-  not2 as not,
+  not,
   notInState,
   notify,
-  or2 as or,
+  on,
+  or,
+  orchestration,
+  patch,
   pipe,
   playerLog,
   prefetchData,
   refHasAnyRole,
   refHasRole,
   requireAuth,
+  requireField,
   requireRole,
+  resolveOrchestration,
+  restrict,
   review,
+  runtime,
+  sendMessage,
   serverAction,
   setAuthResolver,
   setChannelTransport,
+  setConfigContext,
   setExpressionLibraryResolver,
   setField,
   setFields,
   setInstalledModules,
   setModuleConfigDefaults,
   setMutationResolver,
+  setPersistedModuleConfig,
   setPlayerDebug,
   setQueryResolver,
   setRealtimeQueryResolver,
@@ -7952,10 +7678,14 @@ export {
   setServerStateResolver,
   setViewResolver,
   spawn,
+  spawnActor,
   sql,
   state,
+  syncConfigDefaults,
   testModel,
+  timeout,
   transition,
+  updateDefinitionConfig,
   useAuth,
   useChannel,
   useCollection,
@@ -7973,6 +7703,7 @@ export {
   useModel,
   useModule,
   useModuleConfig,
+  useModuleConfigWithMutation,
   useMutation,
   useNotification,
   useOnChange,
@@ -7985,6 +7716,7 @@ export {
   usePlayer,
   usePlayerContext,
   usePlayerContextSafe,
+  usePresence,
   useQuery,
   useRealtimeQuery,
   useRole,
@@ -7997,20 +7729,30 @@ export {
   useToast,
   useTransition,
   useView,
+  useVisibility,
   useWhileIn,
   useWorkflow,
-  useState20 as useWorkflowState,
+  useState21 as useWorkflowState,
+  userAction,
+  userChoice,
+  validate,
   validateExperienceWorkflow,
   validateModel,
+  visibleTo,
   when,
+  withAuditLog,
   withAuditTrail,
+  withAuth,
+  withMetrics,
   withOwnership,
   withPagination,
   withRBAC,
+  withRateLimit,
   withSearch,
   withSlug,
   withSoftDelete,
   withTags,
   withTimestamps,
+  withValidation,
   withVersioning
 };