@floken-io/engine 0.0.1

package/dist/index.js

@@ -0,0 +1,3645 @@
+import { isTerminalStatus, stateTerminal, cloneState, optionInvalid, stateShapeInvalid, engineDiagnostic, ENGINE_DIAGNOSTIC_CODES, assertRoundTrip, headerOf, definitionMissing, tokenOrphan, approverEmpty, deliverNoTarget, assertSerializable, persistAlreadyExists, persistConflict, conditionInvalid, STATE_SCHEMA_VERSION, stateNotFound, actionVetoed, stateSuspended, voteConfigInvalid, actionTargetInvalid, optionUnknown, actionUnknown, addSignLimit, actionNotAllowed, commentRequired } from './chunk-RMCROXES.js';
+export { ENGINE_DIAGNOSTIC_CODES, ENGINE_ERROR_CODES, EngineActionError, EngineError, EngineOptionError, EnginePersistError, EngineStateError, INSTANCE_STATUSES, STATE_SCHEMA_VERSION, TERMINAL_STATUSES, TOKEN_STATES, engineDiagnostic, isTerminalStatus, persistAlreadyExists, persistConflict } from './chunk-RMCROXES.js';
+import { requiredVotes, shouldTerminate as shouldTerminate$1, normalizeApproval } from '@floken-io/moddle';
+import { evaluate } from '@floken-io/feel';
+
+// src/core/primitives.ts
+var PRIMITIVE_NAMES = [
+  // —— 令牌级 8 ——
+  "advance",
+  "jumpTo",
+  "rollbackTo",
+  "spawnInstances",
+  "cancelInstances",
+  "transfer",
+  "delegate",
+  "halt",
+  // —— 实例级 2 ——
+  "suspend",
+  "resume"
+];
+var PRIMITIVE_GROUPS = {
+  token: ["advance", "jumpTo", "rollbackTo", "spawnInstances", "cancelInstances", "transfer", "delegate", "halt"],
+  instance: ["suspend", "resume"]
+};
+var LIVE_TOKEN_STATES = ["active", "waiting"];
+function transform(state, mutate) {
+  const next = cloneState(state);
+  mutate(next);
+  assertSerializable(next, "next");
+  return next;
+}
+function requireLiveInstance(state, primitive) {
+  if (isTerminalStatus(state.status)) {
+    throw stateTerminal(state.instanceId, state.status, primitive);
+  }
+  if (state.status === "suspended") {
+    throw stateSuspended(state.instanceId, primitive);
+  }
+}
+function requireLiveToken(state, tokenId, primitive) {
+  const token = state.tokens.find((t) => t.id === tokenId);
+  if (token === void 0) {
+    throw stateShapeInvalid(`primitive '${primitive}' targets unknown token '${tokenId}'`, {
+      primitive,
+      tokenId
+    });
+  }
+  if (!LIVE_TOKEN_STATES.includes(token.state)) {
+    throw stateShapeInvalid(
+      `primitive '${primitive}' targets a token that is already '${token.state}'`,
+      { primitive, tokenId, tokenState: token.state }
+    );
+  }
+  return token;
+}
+function requireCompletedTarget(state, to, primitive) {
+  const at = state.completedNodes.indexOf(to);
+  if (at < 0) {
+    throw stateShapeInvalid(`primitive '${primitive}' target '${to}' is not a completed node`, {
+      primitive,
+      target: to,
+      completedNodes: [...state.completedNodes]
+    });
+  }
+  return at;
+}
+function requireNonEmpty(value, what, primitive) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw stateShapeInvalid(`primitive '${primitive}' requires a non-empty ${what}`, {
+      primitive,
+      field: what
+    });
+  }
+}
+function markCompleted(next, nodeId) {
+  if (!next.completedNodes.includes(nodeId)) next.completedNodes.push(nodeId);
+}
+function clearAssignment(t) {
+  delete t.assignee;
+  delete t.returnTo;
+  delete t.createdAt;
+  delete t.awaiting;
+  delete t.race;
+}
+var isLive = (t) => LIVE_TOKEN_STATES.includes(t.state);
+function advance(state, input) {
+  requireLiveInstance(state, "advance");
+  const token = requireLiveToken(state, input.tokenId, "advance");
+  requireNonEmpty(input.to, "to", "advance");
+  const from = token.nodeId;
+  return transform(state, (next) => {
+    const t = next.tokens.find((x) => x.id === input.tokenId);
+    if (t === void 0) return;
+    t.nodeId = input.to;
+    clearAssignment(t);
+    markCompleted(next, from);
+  });
+}
+function jumpTo(state, input) {
+  requireLiveInstance(state, "jumpTo");
+  const token = requireLiveToken(state, input.tokenId, "jumpTo");
+  requireCompletedTarget(state, input.to, "jumpTo");
+  const from = token.nodeId;
+  return transform(state, (next) => {
+    const t = next.tokens.find((x) => x.id === input.tokenId);
+    if (t === void 0) return;
+    t.nodeId = input.to;
+    clearAssignment(t);
+    next.completedNodes = next.completedNodes.filter((n) => n !== input.to);
+    markCompleted(next, from);
+  });
+}
+function rollbackTo(state, input) {
+  requireLiveInstance(state, "rollbackTo");
+  requireLiveToken(state, input.tokenId, "rollbackTo");
+  const at = requireCompletedTarget(state, input.to, "rollbackTo");
+  return transform(state, (next) => {
+    next.completedNodes = next.completedNodes.slice(0, at);
+    for (const t of next.tokens) {
+      if (t.id === input.tokenId) {
+        t.nodeId = input.to;
+        clearAssignment(t);
+      } else if (isLive(t)) {
+        if (input.branch !== void 0 && t.branch !== input.branch) continue;
+        t.state = "cancelled";
+      }
+    }
+  });
+}
+function spawnInstances(state, input) {
+  requireLiveInstance(state, "spawnInstances");
+  requireNonEmpty(input.nodeId, "nodeId", "spawnInstances");
+  requireNonEmpty(input.groupId, "groupId", "spawnInstances");
+  if (!Array.isArray(input.assignees) || input.assignees.length === 0) {
+    throw stateShapeInvalid("primitive 'spawnInstances' requires at least one assignee", {
+      primitive: "spawnInstances",
+      nodeId: input.nodeId
+    });
+  }
+  return transform(state, (next) => {
+    if (input.replaceTokenId !== void 0) {
+      next.tokens = next.tokens.filter((t) => t.id !== input.replaceTokenId);
+    }
+    const grouped = input.grouped !== false;
+    const created = input.assignees.map((assignee, i) => ({
+      id: `${input.groupId}#${i}`,
+      nodeId: input.nodeId,
+      state: "active",
+      assignee,
+      ...grouped ? { instanceGroup: input.groupId } : {}
+    }));
+    next.tokens = [...next.tokens, ...created];
+    next.completedNodes = next.completedNodes.filter((n) => n !== input.nodeId);
+  });
+}
+function cancelInstances(state, input) {
+  requireLiveInstance(state, "cancelInstances");
+  const hasGroup = typeof input.groupId === "string" && input.groupId.length > 0;
+  const hasIds = Array.isArray(input.tokenIds) && input.tokenIds.length > 0;
+  if (!hasGroup && !hasIds) {
+    throw stateShapeInvalid(
+      "primitive 'cancelInstances' requires groupId or tokenIds (use 'halt' to cancel everything)",
+      { primitive: "cancelInstances" }
+    );
+  }
+  const ids = new Set(input.tokenIds ?? []);
+  return transform(state, (next) => {
+    for (const t of next.tokens) {
+      const inGroup = hasGroup && t.instanceGroup === input.groupId;
+      if (isLive(t) && (inGroup || ids.has(t.id))) t.state = "cancelled";
+    }
+  });
+}
+function transfer(state, input) {
+  requireLiveInstance(state, "transfer");
+  requireLiveToken(state, input.tokenId, "transfer");
+  requireNonEmpty(input.assignee, "assignee", "transfer");
+  return transform(state, (next) => {
+    const t = next.tokens.find((x) => x.id === input.tokenId);
+    if (t === void 0) return;
+    t.assignee = input.assignee;
+  });
+}
+function delegate(state, input) {
+  requireLiveInstance(state, "delegate");
+  const token = requireLiveToken(state, input.tokenId, "delegate");
+  requireNonEmpty(input.assignee, "assignee", "delegate");
+  const previous = token.assignee;
+  return transform(state, (next) => {
+    const t = next.tokens.find((x) => x.id === input.tokenId);
+    if (t === void 0) return;
+    if (previous !== void 0) t.returnTo = previous;
+    t.assignee = input.assignee;
+  });
+}
+function halt(state, _input = {}) {
+  if (isTerminalStatus(state.status)) {
+    throw stateTerminal(state.instanceId, state.status, "halt");
+  }
+  return transform(state, (next) => {
+    for (const t of next.tokens) {
+      if (isLive(t)) t.state = "cancelled";
+    }
+    next.status = "terminated";
+  });
+}
+function suspend(state, _input = {}) {
+  if (isTerminalStatus(state.status)) {
+    throw stateTerminal(state.instanceId, state.status, "suspend");
+  }
+  if (state.status === "suspended") return transform(state, () => void 0);
+  return transform(state, (next) => {
+    next.status = "suspended";
+  });
+}
+function resume(state, _input = {}) {
+  if (isTerminalStatus(state.status)) {
+    throw stateTerminal(state.instanceId, state.status, "resume");
+  }
+  if (state.status !== "suspended") {
+    throw stateShapeInvalid(
+      `primitive 'resume' requires a suspended instance, got '${state.status}'`,
+      { primitive: "resume", status: state.status }
+    );
+  }
+  return transform(state, (next) => {
+    next.status = "running";
+  });
+}
+var primitives = {
+  advance,
+  jumpTo,
+  rollbackTo,
+  spawnInstances,
+  cancelInstances,
+  transfer,
+  delegate,
+  halt,
+  suspend,
+  resume
+};
+
+// src/core/task.ts
+var TASK_STATUSES = [
+  "active",
+  "delegated",
+  "suspended",
+  "cancelled",
+  "done"
+];
+function diffTasks(before, after) {
+  const b = new Map(before.map((t) => [t.taskId, t]));
+  const a = new Map(after.map((t) => [t.taskId, t]));
+  const added = after.filter((t) => !b.has(t.taskId));
+  const removed = [...b.keys()].filter((id) => !a.has(id));
+  const changed = after.filter((t) => {
+    const prev = b.get(t.taskId);
+    return prev !== void 0 && JSON.stringify(prev) !== JSON.stringify(t);
+  });
+  return { added: [...added], removed, changed: [...changed] };
+}
+function subjectTokenOf(state, actor) {
+  const live = state.tokens.filter((t) => LIVE_TOKEN_STATES.includes(t.state));
+  if (live.length === 0) return void 0;
+  const mine = live.filter((t) => t.assignee !== void 0 && t.assignee === actor);
+  if (mine.length === 1) return mine[0];
+  if (live.length === 1) return live[0];
+  return void 0;
+}
+
+// src/core/spi.ts
+var SPI_NAMES = [
+  // 8.1 存储三线
+  "StateStore",
+  "DefinitionSource",
+  "TaskProjection",
+  // 8.2 业务接入
+  "ApproverSource",
+  "ServiceHandler",
+  "AuthResolver",
+  "FormProvider",
+  // 8.3 求值
+  "ConditionHandler",
+  "DecisionHandler",
+  // 8.4 出口
+  "EventSink",
+  "Scheduler"
+];
+var SPI_GROUPS = {
+  /** 存储三线：真相 / 图纸 / 视图 */
+  storage: ["StateStore", "DefinitionSource", "TaskProjection"],
+  /** 业务接入：取人 / 干活 / 鉴权 / 表单 */
+  business: ["ApproverSource", "ServiceHandler", "AuthResolver", "FormProvider"],
+  /** 求值：网关条件 / 决策表 */
+  eval: ["ConditionHandler", "DecisionHandler"],
+  /** 出口：事件 / 定时 */
+  exit: ["EventSink", "Scheduler"]
+};
+
+// src/core/events.ts
+var TASK_EVENT_NAMES = [
+  "taskCreated",
+  "taskAssigned",
+  "taskUpdated",
+  "taskCompleted",
+  "taskCancelled"
+];
+var INSTANCE_EVENT_NAMES = [
+  "started",
+  "completed",
+  "terminated",
+  "suspended",
+  "resumed"
+];
+var ENGINE_EVENT_NAMES = [
+  ...TASK_EVENT_NAMES,
+  ...INSTANCE_EVENT_NAMES
+];
+function isTaskEvent(e) {
+  return TASK_EVENT_NAMES.includes(e.name);
+}
+function isInstanceEvent(e) {
+  return INSTANCE_EVENT_NAMES.includes(e.name);
+}
+
+// src/actions/catalog.ts
+var ACTION_SPECS = Object.freeze([
+  // —— 流转 ——
+  {
+    names: ["approve"],
+    label: "\u901A\u8FC7",
+    primitiveExpr: "advance",
+    primitives: ["advance"],
+    gate: null,
+    needsTarget: false,
+    native: true
+  },
+  {
+    names: ["reject"],
+    label: "\u9A73\u56DE",
+    primitiveExpr: "jumpTo",
+    primitives: ["jumpTo"],
+    gate: "reject",
+    needsTarget: true,
+    native: true
+  },
+  {
+    names: ["rejectToPrev"],
+    label: "\u9A73\u56DE\u5230\u4E0A\u4E00\u8282\u70B9",
+    primitiveExpr: "jumpTo",
+    primitives: ["jumpTo"],
+    gate: "reject",
+    needsTarget: true,
+    native: true
+  },
+  {
+    names: ["jumpTo"],
+    label: "\u4EFB\u610F\u8DF3\u8F6C",
+    primitiveExpr: "jumpTo",
+    primitives: ["jumpTo"],
+    gate: "reject",
+    needsTarget: true,
+    requiresArbitrary: true,
+    native: true
+  },
+  {
+    names: ["returnTo"],
+    label: "\u4EFB\u610F\u9000\u56DE",
+    primitiveExpr: "jumpTo",
+    primitives: ["jumpTo"],
+    gate: "reject",
+    needsTarget: true,
+    requiresArbitrary: true,
+    native: true
+  },
+  {
+    names: ["takeBack"],
+    label: "\u62FF\u56DE",
+    primitiveExpr: "rollbackTo",
+    primitives: ["rollbackTo"],
+    gate: "withdraw",
+    needsTarget: true,
+    native: true
+  },
+  {
+    names: ["revoke"],
+    label: "\u64A4\u9500",
+    primitiveExpr: "rollbackTo",
+    primitives: ["rollbackTo"],
+    gate: "revoke",
+    needsTarget: true,
+    native: true
+  },
+  {
+    names: ["terminate"],
+    label: "\u7EC8\u6B62",
+    primitiveExpr: "halt",
+    primitives: ["halt"],
+    gate: null,
+    needsTarget: false,
+    native: true
+  },
+  // —— 换人 ——
+  {
+    names: ["transfer"],
+    label: "\u8F6C\u529E",
+    primitiveExpr: "transfer",
+    primitives: ["transfer"],
+    gate: "transfer",
+    needsTarget: false,
+    native: true
+  },
+  {
+    names: ["delegate"],
+    label: "\u59D4\u6D3E",
+    primitiveExpr: "delegate",
+    primitives: ["delegate"],
+    gate: "delegate",
+    needsTarget: false,
+    native: true
+  },
+  // —— 改待办集合 ——
+  {
+    names: ["addSignBefore"],
+    label: "\u524D\u52A0\u7B7E",
+    primitiveExpr: "spawnInstances",
+    primitives: ["spawnInstances"],
+    gate: "addSign.before",
+    needsTarget: false,
+    native: true
+  },
+  {
+    names: ["addSignAfter"],
+    label: "\u540E\u52A0\u7B7E",
+    primitiveExpr: "spawnInstances",
+    primitives: ["spawnInstances"],
+    gate: "addSign.after",
+    needsTarget: false,
+    native: true
+  },
+  {
+    names: ["reduceSign"],
+    label: "\u51CF\u7B7E",
+    primitiveExpr: "cancelInstances",
+    primitives: ["cancelInstances"],
+    gate: "reduceSign",
+    needsTarget: false,
+    native: true
+  },
+  // —— 多实例（汇聚模式由 `mode` 承载，不是动作开关）——
+  {
+    names: ["countersign"],
+    label: "\u4F1A\u7B7E",
+    primitiveExpr: "spawnInstances",
+    primitives: ["spawnInstances"],
+    gate: null,
+    needsTarget: false,
+    native: true,
+    mode: "all"
+  },
+  {
+    names: ["orSign"],
+    label: "\u6216\u7B7E",
+    primitiveExpr: "spawnInstances+cancelInstances",
+    // ★ `cancelInstances` 不在提交时执行 —— 它在**汇聚时**由 T10 `actions/convergence.ts` 触发
+    //   （一人通过 → 取消其余）。`primitiveExpr` 保留文档原文以便对账。
+    primitives: ["spawnInstances"],
+    gate: null,
+    needsTarget: false,
+    native: true,
+    mode: "any"
+  },
+  {
+    names: ["voteSign"],
+    label: "\u7968\u7B7E",
+    primitiveExpr: "spawnInstances+cancelInstances",
+    primitives: ["spawnInstances"],
+    gate: null,
+    needsTarget: false,
+    native: true,
+    mode: "vote"
+  },
+  // —— 内核外 ——
+  {
+    names: ["timeoutAction"],
+    label: "\u8D85\u65F6\u81EA\u52A8\u5904\u7406",
+    primitiveExpr: "advance",
+    primitives: ["advance"],
+    gate: "timeout",
+    needsTarget: false,
+    native: false
+  },
+  {
+    names: ["suspend", "resume"],
+    label: "\u6302\u8D77 / \u6062\u590D",
+    primitiveExpr: "suspend + resume",
+    primitives: ["suspend", "resume"],
+    gate: null,
+    needsTarget: false,
+    native: true
+  },
+  {
+    names: ["saveDraft"],
+    label: "\u6682\u5B58",
+    primitiveExpr: "\uFF08\u7A7A\uFF09",
+    primitives: [],
+    gate: null,
+    needsTarget: false,
+    native: false
+  }
+]);
+var ACTION_NAMES = Object.freeze(
+  ACTION_SPECS.flatMap((s) => s.names)
+);
+var ACTION_SPEC_BY_NAME = Object.freeze(
+  Object.fromEntries(ACTION_SPECS.flatMap((s) => s.names.map((n) => [n, s])))
+);
+Object.freeze(
+  ACTION_SPECS.filter((s) => s.needsTarget).flatMap((s) => s.names)
+);
+var HANDOVER_ACTIONS = Object.freeze(["transfer", "delegate"]);
+var SPAWN_ACTIONS = Object.freeze(
+  ACTION_SPECS.filter((s) => s.primitives.includes("spawnInstances")).flatMap((s) => s.names)
+);
+Object.freeze(
+  ACTION_SPECS.filter((s) => s.gate === null && s.mode === void 0).flatMap((s) => s.names)
+);
+
+// src/actions/gates.ts
+function readGate(approval, path) {
+  switch (path) {
+    case "reject":
+      return {
+        allowed: approval.reject.allowed,
+        requireComment: approval.reject.requireComment
+      };
+    case "withdraw":
+      return {
+        allowed: approval.withdraw.allowed,
+        requireComment: approval.withdraw.requireComment
+      };
+    case "revoke":
+      return { allowed: approval.revoke.allowed, requireComment: approval.revoke.requireComment };
+    case "transfer":
+      return {
+        allowed: approval.transfer.allowed,
+        requireComment: approval.transfer.requireComment
+      };
+    case "delegate":
+      return {
+        allowed: approval.delegate.allowed,
+        requireComment: approval.delegate.requireComment
+      };
+    case "reduceSign":
+      return {
+        allowed: approval.reduceSign.allowed,
+        requireComment: approval.reduceSign.requireComment ?? false
+      };
+    case "addSign.before":
+      return { allowed: approval.addSign.before, requireComment: false };
+    case "addSign.after":
+      return { allowed: approval.addSign.after, requireComment: false };
+    case "timeout":
+      return {
+        allowed: approval.timeout !== void 0 && approval.timeout.actions.length > 0,
+        requireComment: false
+      };
+    default: {
+      const _exhaustive = path;
+      throw new Error(`unknown gate path: ${String(_exhaustive)}`);
+    }
+  }
+}
+function isActionEnabled(spec, approval) {
+  if (spec.gate === null) return true;
+  if (approval === void 0) return false;
+  if (!readGate(approval, spec.gate).allowed) return false;
+  if (spec.requiresArbitrary === true && !approval.reject.allowArbitrary) return false;
+  return true;
+}
+function enabledActionNames(approval) {
+  return ACTION_SPECS.filter((s) => s.native && isActionEnabled(s, approval)).flatMap(
+    (s) => s.names
+  );
+}
+function assertActionEnabled(name, approval) {
+  const spec = ACTION_SPECS.find((s) => s.names.includes(name));
+  if (spec === void 0) {
+    throw actionNotAllowed(name, []);
+  }
+  if (!isActionEnabled(spec, approval)) {
+    throw actionNotAllowed(name, approval === void 0 ? [] : enabledActionNames(approval));
+  }
+  return spec;
+}
+function assertComment(name, spec, approval, comment) {
+  if (spec.gate === null) return;
+  if (approval === void 0) return;
+  if (!readGate(approval, spec.gate).requireComment) return;
+  if (typeof comment === "string" && comment.trim().length > 0) return;
+  throw commentRequired(name);
+}
+function assertTarget(params) {
+  const { name, approval, completedNodes, target, startNodeId } = params;
+  if (approval === void 0) {
+    throw actionTargetInvalid(name, target ?? "", completedNodes, []);
+  }
+  const allowedTargets = approval.reject.allowedTargets;
+  const reject = () => {
+    throw actionTargetInvalid(name, target ?? "", completedNodes, allowedTargets);
+  };
+  if (typeof target !== "string" || target.length === 0) reject();
+  const t = target;
+  if (!completedNodes.includes(t)) reject();
+  const last = completedNodes[completedNodes.length - 1];
+  const ok = allowedTargets.some((kind) => {
+    switch (kind) {
+      case "previous":
+        return t === last;
+      case "nodeId":
+        return true;
+      // ① 已保证 ∈ completedNodes
+      case "starter":
+        return startNodeId !== void 0 && t === startNodeId;
+      default:
+        return false;
+    }
+  });
+  if (!ok) reject();
+  return t;
+}
+function resolveRejectTarget(params) {
+  const { name, approval, completedNodes, startNodeId } = params;
+  if (params.target !== void 0 && params.target.length > 0) {
+    return assertTarget({ name, approval, completedNodes, target: params.target, startNodeId });
+  }
+  const allowed = approval.reject.allowedTargets;
+  for (const kind of allowed) {
+    if (kind === "previous") {
+      const last = completedNodes[completedNodes.length - 1];
+      if (last !== void 0) return last;
+    }
+    if (kind === "starter" && startNodeId !== void 0 && completedNodes.includes(startNodeId)) {
+      return startNodeId;
+    }
+  }
+  throw actionTargetInvalid(name, "", completedNodes, allowed);
+}
+function isNonNegativeInt(n) {
+  return typeof n === "number" && Number.isInteger(n) && n >= 0;
+}
+function assertConvergeCtx(ctx) {
+  if (ctx === null || typeof ctx !== "object") {
+    throw stateShapeInvalid("ConvergeCtx must be an object", { ctx });
+  }
+  if (ctx.mode !== "all" && ctx.mode !== "any" && ctx.mode !== "vote") {
+    throw stateShapeInvalid(`unknown converge mode '${String(ctx.mode)}'`, {
+      mode: ctx.mode,
+      allowed: ["all", "any", "vote"]
+    });
+  }
+  if (!isNonNegativeInt(ctx.total) || ctx.total < 1) {
+    throw stateShapeInvalid(`total must be an integer >= 1, got ${String(ctx.total)}`, {
+      total: ctx.total
+    });
+  }
+  for (const key of ["approved", "rejected", "pending"]) {
+    if (!isNonNegativeInt(ctx[key])) {
+      throw stateShapeInvalid(`${key} must be a non-negative integer, got ${String(ctx[key])}`, {
+        [key]: ctx[key]
+      });
+    }
+  }
+  const expectedPending = ctx.total - ctx.approved - ctx.rejected;
+  if (ctx.pending !== expectedPending) {
+    throw stateShapeInvalid(
+      `pending (${ctx.pending}) !== total \u2212 approved \u2212 rejected (${expectedPending})`,
+      { total: ctx.total, approved: ctx.approved, rejected: ctx.rejected, pending: ctx.pending }
+    );
+  }
+  if (ctx.approved + ctx.rejected > ctx.total) {
+    throw stateShapeInvalid("approved + rejected exceeds total", {
+      total: ctx.total,
+      approved: ctx.approved,
+      rejected: ctx.rejected
+    });
+  }
+  if (ctx.onReject !== "abort" && ctx.onReject !== "wait") {
+    throw stateShapeInvalid(`unknown onReject '${String(ctx.onReject)}'`, {
+      onReject: ctx.onReject,
+      allowed: ["abort", "wait"]
+    });
+  }
+}
+function voteSpecOf(ctx) {
+  const hasCount = ctx.count !== void 0;
+  const hasThreshold = ctx.threshold !== void 0;
+  if (ctx.mode !== "vote") return void 0;
+  if (hasCount === hasThreshold) {
+    throw voteConfigInvalid(
+      hasCount ? "mode:'vote' requires exactly one of vote.count / vote.threshold, got both" : "mode:'vote' requires vote.count or vote.threshold, got neither",
+      { mode: ctx.mode, count: ctx.count, threshold: ctx.threshold }
+    );
+  }
+  if (hasCount) {
+    if (!Number.isInteger(ctx.count) || ctx.count < 1) {
+      throw voteConfigInvalid("vote.count must be a positive integer", { count: ctx.count });
+    }
+    return { count: ctx.count };
+  }
+  const t = ctx.threshold;
+  if (typeof t !== "number" || !Number.isFinite(t) || t <= 0 || t > 1) {
+    throw voteConfigInvalid("vote.threshold must be a ratio in (0, 1]", { threshold: t });
+  }
+  return { threshold: t };
+}
+function requiredOf(ctx) {
+  assertConvergeCtx(ctx);
+  return requiredVotes(ctx.total, voteSpecOf(ctx));
+}
+function evaluateConvergence(ctx) {
+  assertConvergeCtx(ctx);
+  const vote = voteSpecOf(ctx);
+  const required = requiredVotes(ctx.total, vote);
+  const r = shouldTerminate$1(ctx.mode, ctx.total, ctx.approved, ctx.rejected, {
+    onReject: ctx.onReject,
+    ...vote === void 0 ? {} : { vote }
+  });
+  return {
+    outcome: r.outcome,
+    cancelRest: r.cancelRest,
+    reason: r.reason,
+    required
+  };
+}
+function shouldConverge(ctx) {
+  return evaluateConvergence(ctx).outcome === "approved";
+}
+function shouldTerminate(ctx) {
+  return evaluateConvergence(ctx).outcome === "rejected";
+}
+function groupTallies(tokens) {
+  const order = [];
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    const g = t.instanceGroup;
+    if (g === void 0) continue;
+    const list = byGroup.get(g);
+    if (list === void 0) {
+      byGroup.set(g, [t]);
+      order.push(g);
+    } else {
+      list.push(t);
+    }
+  }
+  const out = [];
+  for (const groupId of order) {
+    const members = byGroup.get(groupId) ?? [];
+    const approved = members.filter((t) => t.vote === "approved").length;
+    const rejected = members.filter((t) => t.vote === "rejected").length;
+    const pending = members.filter((t) => LIVE_TOKEN_STATES.includes(t.state)).length;
+    const total = approved + rejected + pending;
+    if (total < 1) continue;
+    out.push({ groupId, nodeId: members[0]?.nodeId ?? "", total, approved, rejected, pending });
+  }
+  return out;
+}
+function convergeCtxOf(tally, approval) {
+  const v = approval.vote;
+  return {
+    mode: approval.mode,
+    total: tally.total,
+    approved: tally.approved,
+    rejected: tally.rejected,
+    pending: tally.pending,
+    onReject: approval.onReject,
+    ...v !== void 0 && "count" in v && typeof v.count === "number" ? { count: v.count } : {},
+    ...v !== void 0 && "threshold" in v && typeof v.threshold === "number" ? { threshold: v.threshold } : {}
+  };
+}
+function restTokenIds(tokens, groupId, keep = []) {
+  const live = LIVE_TOKEN_STATES;
+  return tokens.filter((t) => t.instanceGroup === groupId && live.includes(t.state) && !keep.includes(t.id)).map((t) => t.id);
+}
+
+// src/core/action.ts
+function assertActionInput(action, path = "$") {
+  if (typeof action !== "object" || action === null || Array.isArray(action)) {
+    throw optionInvalid(path, "must be a plain object", action);
+  }
+  const a = action;
+  const fail = (field, reason2) => {
+    throw optionInvalid(`${path}.${field}`, reason2, a[field]);
+  };
+  if (typeof a.action !== "string" || a.action.length === 0) {
+    fail("action", "must be a non-empty string");
+  }
+  if (typeof a.actor !== "string" || a.actor.length === 0) {
+    fail("actor", "must be a non-empty string");
+  }
+  if (a.comment !== void 0 && typeof a.comment !== "string") {
+    fail("comment", "must be a string when present");
+  }
+  if (a.target !== void 0 && typeof a.target !== "string") {
+    fail("target", "must be a string when present");
+  }
+  if (a.at !== void 0 && (typeof a.at !== "string" || a.at.length === 0)) {
+    fail("at", "must be a non-empty ISO 8601 string when present");
+  }
+  if (a.payload !== void 0 && (typeof a.payload !== "object" || a.payload === null)) {
+    fail("payload", "must be a plain object when present");
+  }
+}
+
+// src/runtime/plan.ts
+function plan(state, action, options = {}) {
+  assertActionInput(action, "action");
+  assertSerializableInput(state);
+  if (isTerminalStatus(state.status)) {
+    throw stateTerminal(state.instanceId, state.status, action.action);
+  }
+  const at = resolveAt(action, options);
+  const diagnostics = [];
+  let next = cloneState(state);
+  if (action.payload !== void 0) {
+    next.variables = { ...next.variables, ...action.payload };
+  }
+  if (options.apply !== void 0) {
+    const applied = options.apply(next);
+    if (typeof applied !== "object" || applied === null) {
+      throw optionInvalid("options.apply", "must return an InstanceState object", applied);
+    }
+    next = applied;
+    if (next.rev !== state.rev) {
+      throw stateShapeInvalid("options.apply must not touch rev (plan() owns it)", {
+        expected: state.rev,
+        got: next.rev
+      });
+    }
+    if (next.definitionVersion !== state.definitionVersion) {
+      throw stateShapeInvalid(
+        "options.apply must not touch definitionVersion (INV-19: an instance is bound to its version for life)",
+        { expected: state.definitionVersion, got: next.definitionVersion }
+      );
+    }
+  }
+  next.rev = state.rev + 1;
+  next.updatedAt = at;
+  const record = {
+    name: action.action,
+    actor: action.actor,
+    at
+  };
+  if (action.comment !== void 0) record.comment = action.comment;
+  if (action.target !== void 0) record.nodeId = action.target;
+  next.lastAction = record;
+  const entry = {
+    seq: nextAuditSeq(state.auditTrail),
+    at,
+    actor: action.actor,
+    action: action.action
+  };
+  if (action.target !== void 0) entry.nodeId = action.target;
+  if (action.comment !== void 0) entry.payload = { comment: action.comment };
+  if (action.payload !== void 0) {
+    entry.payload = { ...entry.payload ?? {}, ...action.payload };
+  }
+  const subject = subjectTokenOf(state, action.actor);
+  if (subject !== void 0) {
+    entry.tokenId = subject.id;
+    entry.from = subject.nodeId;
+    const after = next.tokens.find((t) => t.id === subject.id);
+    if (after !== void 0) entry.to = after.nodeId;
+  }
+  next.auditTrail = [...state.auditTrail, entry];
+  const maxEntries = options.maxAuditEntries;
+  if (maxEntries !== void 0) {
+    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
+      throw optionInvalid("maxAuditEntries", "must be a positive integer", maxEntries);
+    }
+    if (next.auditTrail.length > maxEntries) {
+      const dropped = next.auditTrail.slice(0, next.auditTrail.length - maxEntries);
+      next.auditTrail = next.auditTrail.slice(next.auditTrail.length - maxEntries);
+      diagnostics.push(
+        engineDiagnostic({
+          code: ENGINE_DIAGNOSTIC_CODES.AUDIT_TRUNCATED,
+          message: `auditTrail exceeded maxAuditEntries and was truncated`,
+          instanceId: state.instanceId,
+          details: {
+            maxAuditEntries: maxEntries,
+            droppedCount: dropped.length,
+            droppedFromSeq: dropped[0]?.seq,
+            droppedToSeq: dropped[dropped.length - 1]?.seq
+          }
+        })
+      );
+    }
+  }
+  if (isTerminalStatus(next.status) && next.endedAt === void 0) {
+    next.endedAt = at;
+  }
+  assertRoundTrip(next, "next");
+  const tasks = options.tasks;
+  const diff = tasks === void 0 ? { added: [], removed: [], changed: [] } : diffTasks(tasks(state), tasks(next));
+  const delta = {
+    rev: next.rev,
+    action: record,
+    added: diff.added,
+    removed: diff.removed,
+    changed: diff.changed,
+    instance: headerOf(next)
+  };
+  return { next, delta, diagnostics };
+}
+function assertSerializableInput(state) {
+  if (typeof state !== "object" || state === null) {
+    throw optionInvalid("state", "must be a plain object", state);
+  }
+  if (typeof state.instanceId !== "string" || state.instanceId.length === 0) {
+    throw optionInvalid("state.instanceId", "must be a non-empty string", state.instanceId);
+  }
+  if (!Number.isInteger(state.rev) || state.rev < 0) {
+    throw optionInvalid("state.rev", "must be a non-negative integer", state.rev);
+  }
+}
+function resolveAt(action, options) {
+  if (action.at !== void 0) return action.at;
+  const clocked = options.clock?.();
+  if (typeof clocked === "string" && clocked.length > 0) return clocked;
+  throw optionInvalid(
+    "at",
+    "plan() needs a time source: pass action.at, or pass PlanOptions.clock (EngineConfig.clock in submit())",
+    void 0
+  );
+}
+function nextAuditSeq(trail) {
+  let max = 0;
+  for (const e of trail) {
+    if (typeof e.seq === "number" && e.seq > max) max = e.seq;
+  }
+  return max + 1;
+}
+
+// src/runtime/queue.ts
+function createInstanceQueue() {
+  const tails = /* @__PURE__ */ new Map();
+  const depths = /* @__PURE__ */ new Map();
+  function run(instanceId, fn) {
+    const prev = tails.get(instanceId) ?? Promise.resolve();
+    depths.set(instanceId, (depths.get(instanceId) ?? 0) + 1);
+    const task = async () => fn();
+    const result = prev.then(task, task);
+    const cleanup = result.then(
+      () => void 0,
+      () => void 0
+    );
+    tails.set(instanceId, cleanup);
+    void cleanup.then(() => {
+      const left = (depths.get(instanceId) ?? 1) - 1;
+      if (left <= 0) {
+        depths.delete(instanceId);
+        tails.delete(instanceId);
+      } else {
+        depths.set(instanceId, left);
+      }
+    });
+    return result;
+  }
+  async function drain() {
+    await Promise.all([...tails.values()]);
+  }
+  return {
+    run,
+    drain,
+    size: () => depths.size,
+    depth: (instanceId) => depths.get(instanceId) ?? 0
+  };
+}
+
+// src/nodes/events.ts
+function eventBehaviorOf(type) {
+  switch (type) {
+    case "startEvent":
+      return "start";
+    case "endEvent":
+      return "terminal";
+    case "intermediateCatchEvent":
+      return "catch";
+    case "boundaryEvent":
+      return "pass";
+    case "intermediateThrowEvent":
+    case "implicitThrowEvent":
+      return "unsupported";
+    default:
+      return void 0;
+  }
+}
+function assertEventSupported(type, nodeId, behavior) {
+  if (behavior !== "unsupported") return;
+  const owner = {
+    intermediateThrowEvent: "FR-E14 / T20\uFF08\u5411\u5916\u629B\u51FA\uFF1A\u65E0 MessageSink \u51FA\u53E3\uFF0C\u987B\u5148\u6539 ADR-006 \u4E8B\u4EF6\u96C6\uFF09",
+    implicitThrowEvent: "FR-E24 / T18\uFF08\u4E8B\u4EF6\u5B50\u6D41\u7A0B\u5185\u7684\u9690\u5F0F\u629B\u51FA\uFF09"
+  };
+  throw stateShapeInvalid(`node '${nodeId}' is a '${type}', which is not executable yet`, {
+    nodeId,
+    type,
+    owner: owner[type] ?? "unknown",
+    behavior,
+    hint: '\u8BE5\u4E8B\u4EF6\u7C7B\u578B\u5DF2\u77E5\u4F46\u5C1A\u672A\u5B9E\u73B0\uFF1B\u5F15\u64CE\u523B\u610F\u4E0D\u628A\u5B83\u964D\u7EA7\u6210\u81EA\u52A8\u76F4\u901A\uFF08\u90A3\u4F1A\u8BA9"\u4E8B\u4EF6\u6CA1\u53D1\u751F"\u53D8\u6210\u9759\u9ED8\u4E8B\u5B9E\uFF09'
+  });
+}
+
+// src/nodes/activities.ts
+function activityBehaviorOf(type) {
+  switch (type) {
+    case "callActivity":
+      return "call";
+    case "subProcess":
+    case "adHocSubProcess":
+    case "transaction":
+      return "unsupported";
+    default:
+      return void 0;
+  }
+}
+function assertActivitySupported(type, nodeId, behavior) {
+  if (behavior !== "unsupported") return;
+  const owner = {
+    subProcess: "FR-E24 / T21\uFF08\u4E8B\u4EF6\u5B50\u6D41\u7A0B triggeredByEvent\uFF09",
+    adHocSubProcess: "FR-E18\uFF08\u8FD0\u884C\u65F6\u7F16\u6392\uFF09",
+    transaction: "FR-E13 / T21\uFF08transaction \u5FC5\u987B\u542B\u5185\u5D4C\u8282\u70B9\u624D\u80FD\u5C55\u5F00\uFF1B\u8865\u507F\u5904\u7406\u5668 compensate \u5F52 v1.x\uFF09"
+  };
+  throw stateShapeInvalid(`node '${nodeId}' is a '${type}', which is not executable yet`, {
+    nodeId,
+    type,
+    owner: owner[type] ?? "unknown",
+    behavior,
+    hint: '\u8BE5\u6D3B\u52A8\u7C7B\u578B\u5DF2\u77E5\u4F46\u5C1A\u672A\u5B9E\u73B0\uFF1B\u5F15\u64CE\u523B\u610F\u4E0D\u628A\u5B83\u964D\u7EA7\u6210\u81EA\u52A8\u76F4\u901A\uFF08\u90A3\u4F1A\u8BA9"\u8FD9\u6BB5\u5B50\u6D41\u7A0B\u4ECE\u6765\u6CA1\u6267\u884C\u8FC7"\u53D8\u6210\u9759\u9ED8\u4E8B\u5B9E\uFF09'
+  });
+}
+var SUBPROCESS_PATH_SEP = "/";
+var SUBPROCESS_EXIT_TYPE = "subProcessExit";
+function expandSubProcesses(nodes, flows) {
+  return flatten(nodes, flows, "");
+}
+function isExpandable(n) {
+  return (n.type === "subProcess" || n.type === "transaction") && n.triggeredByEvent !== true && Array.isArray(n.nodes) && n.nodes.length > 0;
+}
+function flatten(nodes, flows, prefix) {
+  const outNodes = [];
+  const outFlows = [];
+  const subs = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n === null || typeof n !== "object" || typeof n.id !== "string") continue;
+    if (!isExpandable(n)) {
+      outNodes.push(rename(n, prefix));
+      continue;
+    }
+    const children = (n.nodes ?? []).filter(
+      (c) => c !== null && typeof c === "object" && typeof c.id === "string"
+    );
+    const childPrefix = `${prefix}${n.id}${SUBPROCESS_PATH_SEP}`;
+    const starts = children.filter((c) => c.type === "startEvent");
+    const ends = children.filter((c) => c.type === "endEvent");
+    if (starts.length !== 1) {
+      throw stateShapeInvalid(
+        `embedded subProcess '${prefix}${n.id}' must have exactly one startEvent (found ${starts.length})`,
+        { nodeId: `${prefix}${n.id}`, found: starts.length }
+      );
+    }
+    if (ends.length === 0) {
+      throw stateShapeInvalid(
+        `embedded subProcess '${prefix}${n.id}' has no endEvent \u2014\u2014 \u4EE4\u724C\u8FDB\u53BB\u5C31\u51FA\u4E0D\u6765\u4E86`,
+        { nodeId: `${prefix}${n.id}` }
+      );
+    }
+    const inner = flatten(children, n.flows ?? [], childPrefix);
+    const endIds = new Set(ends.map((e) => e.id));
+    for (const c of inner.nodes) {
+      const local = c.id.startsWith(childPrefix) ? c.id.slice(childPrefix.length) : c.id;
+      outNodes.push(endIds.has(local) ? { ...c, type: SUBPROCESS_EXIT_TYPE } : c);
+    }
+    outFlows.push(...inner.flows);
+    const entry = `${childPrefix}${starts[0].id}`;
+    const exits = ends.map((e) => `${childPrefix}${e.id}`);
+    subs.set(n.id, { entry, exits });
+  }
+  for (const f of flows) {
+    if (f === null || typeof f !== "object") continue;
+    if (typeof f.from !== "string" || typeof f.to !== "string") continue;
+    const fromSub = subs.get(f.from);
+    const toSub = subs.get(f.to);
+    const fromIds = fromSub === void 0 ? [`${prefix}${f.from}`] : fromSub.exits;
+    const to = toSub === void 0 ? `${prefix}${f.to}` : toSub.entry;
+    for (const from of fromIds) {
+      const base = typeof f.id === "string" ? `${prefix}${f.id}` : void 0;
+      const id = base === void 0 ? void 0 : fromIds.length > 1 ? `${base}@${from}` : base;
+      outFlows.push({ ...f, ...id === void 0 ? {} : { id }, from, to });
+    }
+  }
+  return { nodes: outNodes, flows: outFlows };
+}
+function rename(n, prefix) {
+  if (prefix === "") return n;
+  const out = { ...n, id: `${prefix}${n.id}` };
+  if (typeof n.defaultFlow === "string" && n.defaultFlow.length > 0) {
+    out.defaultFlow = `${prefix}${n.defaultFlow}`;
+  }
+  if (typeof n.attachedTo === "string" && n.attachedTo.length > 0) {
+    out.attachedTo = `${prefix}${n.attachedTo}`;
+  }
+  return out;
+}
+var CALL_EXT_KEY = "floken:call";
+function callTargetOf(node) {
+  if (node === void 0 || node.type !== "callActivity") return void 0;
+  const raw = node.extension?.[CALL_EXT_KEY];
+  const version = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw["version"] : void 0;
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
+    throw stateShapeInvalid(
+      `callActivity '${node.id}' must bind an explicit definition version (INV-16)`,
+      {
+        nodeId: node.id,
+        // 诊断文案**刻意不逐字写**禁用 API 名（有一道源码扫描门禁），语义照样讲清楚
+        hint: `\u5728\u8BE5\u8282\u70B9\u7684 extension['${CALL_EXT_KEY}'] \u4E0A\u5199 { version: <\u6B63\u6574\u6570> }\uFF1B\u5F15\u64CE\u4E0D\u66FF\u5BBF\u4E3B\u53D6\u6700\u65B0\u7248\uFF08AC-E10\uFF09`,
+        got: version === void 0 ? "undefined" : String(version)
+      }
+    );
+  }
+  const processId = typeof node.calledElement === "string" ? node.calledElement.trim() : "";
+  if (processId === "") {
+    throw stateShapeInvalid(`callActivity '${node.id}' has no calledElement (the process to call)`, {
+      nodeId: node.id,
+      hint: "\u7ED9\u8BE5\u8282\u70B9\u5199 calledElement = \u88AB\u8C03\u7528\u6D41\u7A0B\u7684 processId"
+    });
+  }
+  return { processId, definitionVersion: version };
+}
+function callInstanceIdOf(state, nodeId, tokenId) {
+  const base = `${state.instanceId}::${nodeId}::${tokenId}`;
+  const taken = (state.childInstanceIds ?? []).filter(
+    (id) => id === base || id.startsWith(`${base}#`)
+  );
+  return taken.length === 0 ? base : `${base}#${taken.length}`;
+}
+function parkForCall(next, token, target) {
+  const instanceId = callInstanceIdOf(next, token.nodeId, token.id);
+  token.state = "waiting";
+  const known = next.childInstanceIds ?? [];
+  if (!known.includes(instanceId)) next.childInstanceIds = [...known, instanceId];
+  return {
+    nodeId: token.nodeId,
+    tokenId: token.id,
+    instanceId,
+    processId: target.processId,
+    definitionVersion: target.definitionVersion,
+    variables: { ...next.variables }
+  };
+}
+var CALL_RETURN_ACTION = "callActivityReturn";
+function callReturnOf(state, parent, nextNodeId) {
+  const next = cloneState(state);
+  const token = next.tokens.find((t) => t.id === parent.tokenId);
+  if (token === void 0) {
+    throw stateShapeInvalid(
+      `callActivity return: parent instance '${state.instanceId}' has no token '${parent.tokenId}'`,
+      { instanceId: state.instanceId, tokenId: parent.tokenId }
+    );
+  }
+  if (token.state !== "waiting") {
+    throw stateShapeInvalid(
+      `callActivity return: token '${token.id}' is '${token.state}', expected 'waiting'`,
+      { instanceId: state.instanceId, tokenId: token.id, tokenState: token.state }
+    );
+  }
+  markCompleted(next, parent.nodeId);
+  token.state = "active";
+  token.nodeId = nextNodeId;
+  clearAssignment(token);
+  return next;
+}
+
+// src/nodes/flows.ts
+var DATA_NODE_TYPES = [
+  "dataObject",
+  "dataObjectReference",
+  "dataStoreReference"
+];
+var DATA_ACCESS = "readOnly";
+function isDataNode(type) {
+  return DATA_NODE_TYPES.includes(type ?? "");
+}
+function assertNotDataNode(type, nodeId) {
+  if (!isDataNode(type)) return;
+  throw stateShapeInvalid(
+    `token arrived at data node '${nodeId}' (${type}); data elements are not executable`,
+    {
+      nodeId,
+      type,
+      access: DATA_ACCESS,
+      hint: "\u6570\u636E\u5143\u7D20\uFF08dataObject / dataObjectReference / dataStoreReference\uFF09\u7531\u4E1A\u52A1\u65B9\u7BA1\u7406\uFF0C\u5F15\u64CE\u53EA\u8BFB\u4E0D\u5199\uFF1B\u4EE4\u724C\u4E0D\u8BE5\u7ECF sequenceFlow \u843D\u5230\u5B83\u4E0A\u9762"
+    }
+  );
+}
+function flowPasses(flow, isTrue) {
+  if (flow.expression === void 0) return true;
+  return isTrue(flow.expression);
+}
+
+// src/nodes/catch.ts
+var CATCH_KINDS = ["message", "signal"];
+var MESSAGE_DELIVER_ACTION = "deliverMessage";
+var SIGNAL_DELIVER_ACTION = "deliverSignal";
+var DELIVER_ACTIONS = [MESSAGE_DELIVER_ACTION, SIGNAL_DELIVER_ACTION];
+var WAIT_OWNER = {
+  timer: "FR-E14 / T21\uFF08\u5B9A\u65F6\u5668\uFF1A\u7ECF Scheduler SPI \u6392\u7A0B\uFF09",
+  error: "FR-E13 / T21\uFF08\u5F02\u5E38\u4E0E\u8865\u507F\uFF09",
+  escalation: "FR-E13 / T21\uFF08\u5347\u7EA7\u4E8B\u4EF6\uFF09",
+  cancel: "FR-E13 / T21\uFF08\u4E8B\u52A1\u53D6\u6D88\uFF09",
+  compensate: "FR-E13 / T21\uFF08\u8865\u507F\uFF09",
+  conditional: "FR-E14 / T21\uFF08\u6761\u4EF6\u4E8B\u4EF6\uFF1A\u9700\u8981\u53D8\u91CF\u7EA7\u53D8\u66F4\u8BA2\u9605\uFF09"
+};
+function catchBindingOf(node) {
+  if (node === void 0) return void 0;
+  if (node.type === "receiveTask") {
+    return { kind: "message", name: requiredName(node, node.messageRef, "messageRef") };
+  }
+  if (node.type !== "intermediateCatchEvent") return void 0;
+  const def = node.eventDefinition;
+  const type = typeof def?.type === "string" ? def.type : void 0;
+  if (type === "message") return { kind: "message", name: requiredName(node, def?.messageRef, "messageRef") };
+  if (type === "signal") return { kind: "signal", name: requiredName(node, def?.signalRef, "signalRef") };
+  throw stateShapeInvalid(
+    `node '${node.id}' is an intermediateCatchEvent waiting on '${type ?? "(no eventDefinition)"}', which is not deliverable yet`,
+    {
+      nodeId: node.id,
+      type: node.type,
+      ...type !== void 0 ? { eventDefinition: type } : {},
+      owner: type === void 0 ? "FR-E14 / T20" : WAIT_OWNER[type] ?? "FR-E13 / T21",
+      hint: "\u76EE\u524D\u53EA\u6709 message / signal \u4E24\u7C7B\u7B49\u5F85\u53EF\u88AB\u6295\u9012\u5524\u9192\uFF08T20\uFF09\uFF1B\u5176\u4F59\u7B49\u5F85\u79CD\u7C7B\u5F52 T21\uFF0C\u5F15\u64CE\u523B\u610F\u4E0D\u628A\u5B83\u4EEC\u964D\u7EA7\u6210\u81EA\u52A8\u76F4\u901A"
+    }
+  );
+}
+function requiredName(node, value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw stateShapeInvalid(
+      `node '${node.id}' (${node.type}) has no ${field}; it would wait forever with no way to wake it`,
+      {
+        nodeId: node.id,
+        type: node.type,
+        field,
+        owner: "FR-E14 / T20",
+        hint: `\u7ED9\u8BE5\u8282\u70B9\u8865 ${field}\uFF08\u6D88\u606F / \u4FE1\u53F7\u540D\uFF09\uFF1B\u5F15\u64CE\u523B\u610F\u4E0D\u628A\u5B83\u964D\u7EA7\u6210\u81EA\u52A8\u76F4\u901A \u2014\u2014 \u90A3\u4F1A\u53D8\u6210"\u6C38\u8FDC\u7B49\u4E0D\u5230\u3001\u4E14\u4E0D\u62A5\u9519"`
+      }
+    );
+  }
+  return value;
+}
+function parkForCatch(token, binding) {
+  const awaiting = { kind: binding.kind, name: binding.name };
+  token.awaiting = awaiting;
+}
+function matchingTokens(state, match) {
+  return state.tokens.filter(
+    (t) => LIVE_TOKEN_STATES.includes(t.state) && t.awaiting !== void 0 && t.awaiting.kind === match.kind && t.awaiting.name === match.name && (match.tokenIds === void 0 || match.tokenIds.includes(t.id))
+  );
+}
+function waitingNamesOf(state) {
+  const out = [];
+  for (const t of state.tokens) {
+    if (!LIVE_TOKEN_STATES.includes(t.state) || t.awaiting === void 0) continue;
+    const label = `${t.awaiting.kind}:${t.awaiting.name}`;
+    if (!out.includes(label)) out.push(label);
+  }
+  return out;
+}
+function wakeTokens(state, tokenIds) {
+  const next = cloneState(state);
+  for (const id of tokenIds) {
+    const t = next.tokens.find((x) => x.id === id);
+    if (t === void 0) {
+      throw stateShapeInvalid(`wakeTokens targets unknown token '${id}'`, {
+        tokenId: id,
+        tokenIds: next.tokens.map((x) => x.id)
+      });
+    }
+    delete t.awaiting;
+  }
+  return next;
+}
+
+// src/nodes/boundary.ts
+var BOUNDARY_TYPE = "boundaryEvent";
+function boundaryBindingOf(node) {
+  if (node === void 0 || node.type !== BOUNDARY_TYPE) return void 0;
+  const attachedTo = node.attachedTo;
+  if (typeof attachedTo !== "string" || attachedTo.trim() === "") {
+    throw stateShapeInvalid(
+      `boundaryEvent '${node.id}' has no attachedTo; it would listen to nothing`,
+      {
+        nodeId: node.id,
+        field: "attachedTo",
+        owner: "FR-E13 / T21",
+        hint: "\u8FB9\u754C\u4E8B\u4EF6\u5FC5\u987B\u6302\u5728\u67D0\u4E2A\u6D3B\u52A8\u4E0A\uFF08attachedTo = \u5BBF\u4E3B\u6D3B\u52A8 id\uFF09\uFF1B\u60AC\u7A7A\u7684\u8FB9\u754C\u4E8B\u4EF6\u6C38\u8FDC\u4E0D\u4F1A\u89E6\u53D1\uFF0C\u5F15\u64CE\u523B\u610F\u4E0D\u653E\u884C"
+      }
+    );
+  }
+  const trigger = catchBindingOf({
+    id: node.id,
+    type: "intermediateCatchEvent",
+    ...node.eventDefinition === void 0 ? {} : { eventDefinition: node.eventDefinition }
+  });
+  if (trigger === void 0) {
+    throw stateShapeInvalid(`boundaryEvent '${node.id}' has no deliverable eventDefinition`, {
+      nodeId: node.id,
+      owner: "FR-E13 / T21"
+    });
+  }
+  return {
+    nodeId: node.id,
+    attachedTo,
+    cancelActivity: node.cancelActivity !== false,
+    trigger
+  };
+}
+function armedBoundaries(state, graph, match) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of state.tokens) {
+    if (!LIVE_TOKEN_STATES.includes(t.state)) continue;
+    for (const b of graph.boundaryOf(t.nodeId)) {
+      if (b.trigger.kind !== match.kind || b.trigger.name !== match.name) continue;
+      const key = `${b.nodeId}::${b.attachedTo}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ boundary: b, hostTokenId: t.id });
+    }
+  }
+  return out;
+}
+function armedNamesOf(state, graph) {
+  const out = [];
+  for (const t of state.tokens) {
+    if (!LIVE_TOKEN_STATES.includes(t.state)) continue;
+    for (const b of graph.boundaryOf(t.nodeId)) {
+      const label = `boundary:${b.trigger.kind}:${b.trigger.name}`;
+      if (!out.includes(label)) out.push(label);
+    }
+  }
+  return out;
+}
+var SCOPE_SEP = "/";
+function inScopeOf(tokenNodeId, hostId) {
+  return tokenNodeId === hostId || tokenNodeId.startsWith(`${hostId}${SCOPE_SEP}`);
+}
+function cancelTargetsOf(state, hostId) {
+  return state.tokens.filter((t) => LIVE_TOKEN_STATES.includes(t.state) && inScopeOf(t.nodeId, hostId)).map((t) => t.id);
+}
+function boundaryTokenIdOf(state, hostTokenId, boundaryId) {
+  const base = `${hostTokenId}#${boundaryId}`;
+  if (!state.tokens.some((t) => t.id === base)) return base;
+  for (let n = 2; ; n += 1) {
+    const candidate = `${base}#${n}`;
+    if (!state.tokens.some((t) => t.id === candidate)) return candidate;
+  }
+}
+function boundaryTokenOf(state, fire, host) {
+  const out = {
+    id: boundaryTokenIdOf(state, fire.hostTokenId, fire.boundary.nodeId),
+    nodeId: fire.boundary.nodeId,
+    state: "active"
+  };
+  if (host.branch !== void 0) out.branch = host.branch;
+  return out;
+}
+
+// src/nodes/graph.ts
+var WAITING_NODE_TYPES = ["userTask"];
+var APPROVAL_EXT_KEY = "floken:approval";
+function isWaitingNode(type) {
+  return WAITING_NODE_TYPES.includes(type);
+}
+function expressionOf(condition) {
+  if (condition === void 0 || condition === null) return void 0;
+  const text = typeof condition === "string" ? condition : typeof condition === "object" && typeof condition.body === "string" ? condition.body : void 0;
+  if (text === void 0) return void 0;
+  const trimmed = text.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function createProcessGraph(definition, processId, definitionVersion) {
+  if (definition === null || typeof definition !== "object") {
+    throw definitionMissing(processId, definitionVersion);
+  }
+  const processes = Array.isArray(definition.processes) ? definition.processes : [];
+  const process = processes.find((p) => p?.id === processId);
+  if (process === void 0) {
+    throw definitionMissing(processId, definitionVersion);
+  }
+  const flat = expandSubProcesses(process.nodes ?? [], process.flows ?? []);
+  const flatNodes = flat.nodes;
+  const flatFlows = flat.flows;
+  const nodes = /* @__PURE__ */ new Map();
+  for (const n of flatNodes) {
+    if (n === null || typeof n !== "object" || typeof n.id !== "string") continue;
+    if (nodes.has(n.id)) {
+      throw stateShapeInvalid(`duplicate node id '${n.id}' in process '${processId}'`, {
+        processId,
+        nodeId: n.id
+      });
+    }
+    nodes.set(n.id, n);
+  }
+  const out = /* @__PURE__ */ new Map();
+  const inn = /* @__PURE__ */ new Map();
+  for (const f of flatFlows) {
+    if (f === null || typeof f !== "object") continue;
+    if (typeof f.from !== "string" || typeof f.to !== "string") continue;
+    const flowId = typeof f.id === "string" ? f.id : `flow:${f.from}->${f.to}`;
+    const expr = expressionOf(f.condition);
+    const outList = out.get(f.from);
+    if (outList === void 0) out.set(f.from, [{ id: flowId, to: f.to, ...expr === void 0 ? {} : { expression: expr } }]);
+    else outList.push({ id: flowId, to: f.to, ...expr === void 0 ? {} : { expression: expr } });
+    const inList = inn.get(f.to);
+    if (inList === void 0) inn.set(f.to, [{ id: flowId, from: f.from }]);
+    else inList.push({ id: flowId, from: f.from });
+  }
+  const startNode = flatNodes.find(
+    (n) => n !== null && typeof n === "object" && n.type === "startEvent"
+  );
+  if (startNode === void 0) {
+    throw definitionMissing(processId, definitionVersion);
+  }
+  const approvalCache = /* @__PURE__ */ new Map();
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const n of flatNodes) {
+    if (n === null || typeof n !== "object" || n.type !== "boundaryEvent") continue;
+    const b = boundaryBindingOf(n);
+    if (b === void 0) continue;
+    const scopeSep = `${b.attachedTo}${SUBPROCESS_PATH_SEP}`;
+    const inScope = [...nodes.keys()].some((id) => id === b.attachedTo || id.startsWith(scopeSep));
+    if (!inScope) {
+      throw stateShapeInvalid(
+        `boundaryEvent '${b.nodeId}' is attached to unknown node '${b.attachedTo}'`,
+        { nodeId: b.nodeId, attachedTo: b.attachedTo, processId }
+      );
+    }
+    const outCount = (out.get(b.nodeId) ?? []).length;
+    if (outCount !== 1) {
+      throw stateShapeInvalid(
+        `boundaryEvent '${b.nodeId}' must have exactly one outgoing flow (found ${outCount})`,
+        { nodeId: b.nodeId, found: outCount, processId }
+      );
+    }
+    const list = boundaries.get(b.attachedTo);
+    if (list === void 0) boundaries.set(b.attachedTo, [b]);
+    else list.push(b);
+  }
+  const reachCache = /* @__PURE__ */ new Map();
+  const reachable = (from, to) => {
+    if (from === to) return false;
+    const key = `${from}\u2192${to}`;
+    const cached = reachCache.get(key);
+    if (cached !== void 0) return cached;
+    const seen = /* @__PURE__ */ new Set([from]);
+    const queue = [from];
+    let found = false;
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      for (const e of out.get(cur) ?? []) {
+        if (e.to === to) {
+          found = true;
+          break;
+        }
+        if (seen.has(e.to)) continue;
+        seen.add(e.to);
+        queue.push(e.to);
+      }
+      if (found) break;
+    }
+    reachCache.set(key, found);
+    return found;
+  };
+  return {
+    processId,
+    definitionVersion,
+    startNodeId: startNode.id,
+    nodeIds: () => [...nodes.keys()],
+    has: (nodeId) => nodes.has(nodeId),
+    typeOf: (nodeId) => nodes.get(nodeId)?.type,
+    nameOf: (nodeId) => nodes.get(nodeId)?.name,
+    formKeyOf: (nodeId) => nodes.get(nodeId)?.formKey,
+    outFlowsOf: (nodeId) => [...out.get(nodeId) ?? []],
+    inFlowsOf: (nodeId) => [...inn.get(nodeId) ?? []],
+    defaultFlowIdOf: (nodeId) => {
+      const id = nodes.get(nodeId)?.defaultFlow;
+      return typeof id === "string" && id.length > 0 ? id : void 0;
+    },
+    reachable,
+    nextOf(nodeId) {
+      const list = out.get(nodeId) ?? [];
+      if (list.length === 0) return void 0;
+      if (list.length === 1) return list[0].to;
+      throw stateShapeInvalid(
+        `node '${nodeId}' has ${list.length} outgoing flows; only gateways may route multiple branches (D-22)`,
+        { nodeId, outgoing: list.map((f) => f.to) }
+      );
+    },
+    approvalOf(nodeId) {
+      const cached = approvalCache.get(nodeId);
+      if (cached !== void 0 || approvalCache.has(nodeId)) return cached;
+      const node = nodes.get(nodeId);
+      const raw = node?.extension?.[APPROVAL_EXT_KEY];
+      const value = raw === void 0 ? void 0 : normalizeApproval(raw, { nodeId });
+      approvalCache.set(nodeId, value);
+      return value;
+    },
+    hasApproval: (nodeId) => nodes.get(nodeId)?.extension?.[APPROVAL_EXT_KEY] !== void 0,
+    scriptOf: (nodeId) => {
+      const s = nodes.get(nodeId)?.script;
+      if (typeof s !== "string") return void 0;
+      const trimmed = s.trim();
+      return trimmed === "" ? void 0 : trimmed;
+    },
+    scriptFormatOf: (nodeId) => {
+      const f = nodes.get(nodeId)?.scriptFormat;
+      return typeof f === "string" && f.trim() !== "" ? f : void 0;
+    },
+    handlerRefOf(nodeId) {
+      const node = nodes.get(nodeId);
+      const impl = node?.implementation;
+      if (typeof impl === "string" && impl.length > 0 && !impl.startsWith("##")) return impl;
+      const op = node?.operationRef;
+      if (typeof op === "string" && op.length > 0) return op;
+      return nodeId;
+    },
+    callTargetOf: (nodeId) => callTargetOf(nodes.get(nodeId)),
+    catchOf: (nodeId) => catchBindingOf(nodes.get(nodeId)),
+    /*
+     * ★ 为什么要**沿内嵌作用域向上找**：`transaction` / `subProcess` 拍平后自身不在图里，
+     *   令牌停的是 `Tx_1/Task_a`。挂在 `Tx_1` 上的边界事件必须能被**它里面的令牌**看见 ——
+     *   否则事务边界事件永远不会被触发（而它唯一的意义就是管这一整片作用域）。
+     *   逐段去掉 `/` 后缀向上找，嵌套几层都成立。
+     */
+    boundaryOf: (nodeId) => {
+      const out2 = [];
+      const push = (key) => {
+        for (const b of boundaries.get(key) ?? []) out2.push(b);
+      };
+      push(nodeId);
+      let cut = nodeId.lastIndexOf(SUBPROCESS_PATH_SEP);
+      while (cut > 0) {
+        const scope = nodeId.slice(0, cut);
+        push(scope);
+        cut = scope.lastIndexOf(SUBPROCESS_PATH_SEP);
+      }
+      return out2;
+    }
+  };
+}
+function assertTokensInGraph(state, graph) {
+  for (const t of state.tokens) {
+    if (!graph.has(t.nodeId)) {
+      throw tokenOrphan(state.instanceId, t.id, t.nodeId);
+    }
+  }
+}
+
+// src/nodes/gateways.ts
+var GATEWAY_TYPES = [
+  "exclusiveGateway",
+  "parallelGateway",
+  "inclusiveGateway",
+  "complexGateway",
+  "eventBasedGateway"
+];
+function isGatewayType(type) {
+  return GATEWAY_TYPES.includes(type ?? "");
+}
+function isConverging(type) {
+  return type === "parallelGateway" || type === "inclusiveGateway";
+}
+function routeGateway(input) {
+  const { type, nodeId, outFlows, defaultFlowId, isTrue } = input;
+  if (!isGatewayType(type)) {
+    throw stateShapeInvalid(`node '${nodeId}' is not a gateway (type '${type}')`, {
+      nodeId,
+      type,
+      gateways: [...GATEWAY_TYPES]
+    });
+  }
+  if (outFlows.length === 0) {
+    throw definitionMissing(nodeId, 0);
+  }
+  if (type === "complexGateway") {
+    throw stateShapeInvalid(`gateway '${nodeId}' ('${type}') is not executable yet`, {
+      nodeId,
+      type,
+      owner: "FR-E17\uFF08\u81EA\u5B9A\u4E49\u8868\u8FBE\u5F0F\uFF0CC \u7EA7\uFF09",
+      hint: "\u8BE5\u7F51\u5173\u5DF2\u77E5\u4F46\u5F52 v1.x\uFF1B\u5F15\u64CE\u523B\u610F\u4E0D\u628A\u5B83\u964D\u7EA7\u6210\u300C\u53D6\u7B2C\u4E00\u6761\u51FA\u5411\u300D\uFF08\u90A3\u4F1A\u9759\u9ED8\u8D70\u9519\u5206\u652F\uFF09"
+    });
+  }
+  if (type === "parallelGateway" || type === "eventBasedGateway") {
+    return outFlows.map((f) => ({ flowId: f.id, to: f.to }));
+  }
+  const isDefault = (f) => f.id === defaultFlowId;
+  const candidates = outFlows.filter((f) => !isDefault(f));
+  const taken = (f) => flowPasses(f, () => isTrue(f));
+  if (type === "exclusiveGateway") {
+    for (const f of candidates) {
+      if (taken(f)) return [{ flowId: f.id, to: f.to }];
+    }
+    return fallbackOf(input);
+  }
+  const chosen = candidates.filter((f) => taken(f));
+  if (chosen.length > 0) return chosen.map((f) => ({ flowId: f.id, to: f.to }));
+  return fallbackOf(input);
+}
+function fallbackOf(input) {
+  const { nodeId, outFlows, defaultFlowId } = input;
+  const fallback = outFlows.find((f) => f.id === defaultFlowId);
+  if (fallback !== void 0) return [{ flowId: fallback.id, to: fallback.to }];
+  throw stateShapeInvalid(
+    `gateway '${nodeId}' ('${input.type}') has no branch to take: no condition matched and no default flow`,
+    {
+      nodeId,
+      type: input.type,
+      outgoing: outFlows.map((f) => f.id),
+      defaultFlowId: defaultFlowId ?? null,
+      hint: "\u7ED9\u8BE5\u7F51\u5173\u914D\u4E00\u6761 default \u6D41\uFF0C\u6216\u8BA9\u81F3\u5C11\u4E00\u6761\u51FA\u5411\u7684\u6761\u4EF6\u4E3A\u771F\uFF08BPMN \u89C4\u8303\u8981\u6C42\u81F3\u5C11\u8D70\u4E00\u6761\uFF09"
+    }
+  );
+}
+function canJoin(state, nodeId, graph) {
+  for (const t of state.tokens) {
+    if (!LIVE_TOKEN_STATES.includes(t.state)) continue;
+    if (t.nodeId === nodeId) continue;
+    if (graph.reachable(t.nodeId, nodeId)) return false;
+  }
+  return true;
+}
+function waitingAt(state, nodeId) {
+  const out = [];
+  state.tokens.forEach((t, i) => {
+    if (t.nodeId === nodeId && LIVE_TOKEN_STATES.includes(t.state)) out.push(i);
+  });
+  return out;
+}
+
+// src/nodes/tasks.ts
+function taskBehaviorOf(type) {
+  switch (type) {
+    case "userTask":
+      return "wait";
+    case "serviceTask":
+    case "scriptTask":
+    case "businessRuleTask":
+    case "manualTask":
+      return "effect";
+    case "receiveTask":
+      return "catch";
+    case "task":
+      return "pass";
+    case "sendTask":
+      return "unsupported";
+    default:
+      return void 0;
+  }
+}
+function assertTaskSupported(type, nodeId, behavior) {
+  if (behavior !== "unsupported") return;
+  const owner = {
+    sendTask: "FR-E14 / T20\uFF08\u5411\u5916\u629B\u51FA\uFF1AADR-006 \u4E8B\u4EF6\u96C6\u5B9A\u6B7B 10 \u4E2A\uFF0C\u987B\u5148\u6539 ADR \u518D\u52A0\uFF09"
+  };
+  throw stateShapeInvalid(`node '${nodeId}' is a '${type}', which is not executable yet`, {
+    nodeId,
+    type,
+    owner: owner[type] ?? "unknown",
+    behavior,
+    hint: '\u8BE5\u4EFB\u52A1\u7C7B\u578B\u5DF2\u77E5\u4F46\u5C1A\u672A\u5B9E\u73B0\uFF1B\u5F15\u64CE\u523B\u610F\u4E0D\u628A\u5B83\u964D\u7EA7\u6210\u81EA\u52A8\u76F4\u901A\uFF08\u90A3\u4F1A\u8BA9"\u6D88\u606F\u6CA1\u53D1\u751F"\u53D8\u6210\u9759\u9ED8\u4E8B\u5B9E\uFF09'
+  });
+}
+function effectKindOf(type) {
+  switch (type) {
+    case "serviceTask":
+      return "service";
+    case "scriptTask":
+      return "script";
+    case "businessRuleTask":
+      return "decision";
+    case "manualTask":
+      return "manual";
+    default:
+      return void 0;
+  }
+}
+var FEEL_SCRIPT_FORMATS = [
+  "feel",
+  "text/feel",
+  "application/feel",
+  "http://www.omg.org/spec/feel/20140401"
+];
+function isFeelScriptFormat(format) {
+  if (typeof format !== "string") return false;
+  const norm = format.trim().toLowerCase().replace(/\/+$/, "");
+  if (norm === "") return false;
+  if (FEEL_SCRIPT_FORMATS.includes(norm)) return true;
+  return norm.endsWith("/feel");
+}
+var NodeEffectUnresolved = class extends Error {
+  name = "NodeEffectUnresolved";
+  /** 内部信号：便于与其它错误一眼区分（不依赖 instanceof，跨包 / 跨产物都稳） */
+  unresolved = true;
+  key;
+  nodeId;
+  tokenId;
+  kind;
+  /** ★ 到达该节点**此刻**的变量快照 —— 解析要用它，不能拿提交前的旧值 */
+  variables;
+  constructor(args) {
+    super(`effect of node '${args.nodeId}' on token '${args.tokenId}' is not resolved yet`);
+    this.key = args.key;
+    this.nodeId = args.nodeId;
+    this.tokenId = args.tokenId;
+    this.kind = args.kind;
+    this.variables = args.variables;
+  }
+};
+function unresolvedEffect(args) {
+  return new NodeEffectUnresolved({
+    key: effectKeyOf(args.nodeId, args.tokenId),
+    nodeId: args.nodeId,
+    tokenId: args.tokenId,
+    kind: args.kind,
+    variables: args.variables
+  });
+}
+function effectKeyOf(nodeId, tokenId) {
+  return `${nodeId}::${tokenId}`;
+}
+function asUnresolvedEffect(e) {
+  if (e instanceof NodeEffectUnresolved) return e;
+  if (typeof e === "object" && e !== null && e.unresolved === true && typeof e.key === "string" && typeof e.kind === "string") {
+    return e;
+  }
+  return void 0;
+}
+function assertVariablePatch(nodeId, kind, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw stateShapeInvalid(
+      `${kind} handler of node '${nodeId}' must return a plain object of variables`,
+      { nodeId, kind, returned: value === void 0 ? "undefined" : Array.isArray(value) ? "array" : typeof value }
+    );
+  }
+  return { ...value };
+}
+
+// src/runtime/loop.ts
+var PROBE_ASSIGNEE = "__probe__";
+var MAX_STEPS = 1e4;
+function applyPrimitiveCalls(state, calls) {
+  let current = state;
+  for (const call of calls) {
+    const fn = primitives[call.primitive];
+    current = fn(current, call.input);
+  }
+  return current;
+}
+function step(state, ctx, input) {
+  let cur = applyPrimitiveCalls(state, input.calls);
+  if (input.post !== void 0) cur = applyPost(cur, input.post);
+  if (input.vote !== void 0) cur = castVote(cur, input.vote);
+  cur = promoteSequential(cur, ctx);
+  cur = settleGroups(cur, ctx, input.rejectTarget);
+  return runToWait(cur, ctx);
+}
+function applyPost(state, post) {
+  const next = cloneState(state);
+  if (post.returnFromTokenId !== void 0) {
+    const t = next.tokens.find((x) => x.id === post.returnFromTokenId);
+    if (t === void 0) {
+      throw stateShapeInvalid(`applyPost targets unknown token '${post.returnFromTokenId}'`, {
+        tokenId: post.returnFromTokenId,
+        tokenIds: next.tokens.map((x) => x.id)
+      });
+    }
+    if (t.returnTo === void 0) {
+      throw stateShapeInvalid(`token '${t.id}' has no delegation return path (returnTo)`, {
+        tokenId: t.id
+      });
+    }
+    t.assignee = t.returnTo;
+    delete t.returnTo;
+  }
+  for (const id of post.dissolveTokenIds ?? []) {
+    const t = next.tokens.find((x) => x.id === id);
+    if (t !== void 0) delete t.instanceGroup;
+  }
+  return next;
+}
+function castVote(state, vote) {
+  const next = cloneState(state);
+  const token = next.tokens.find((t) => t.id === vote.tokenId);
+  if (token === void 0) {
+    throw stateShapeInvalid(`castVote targets unknown token '${vote.tokenId}'`, {
+      tokenId: vote.tokenId,
+      tokenIds: next.tokens.map((t) => t.id)
+    });
+  }
+  if (!LIVE_TOKEN_STATES.includes(token.state)) {
+    throw stateShapeInvalid(`castVote targets a token that is already '${token.state}'`, {
+      tokenId: vote.tokenId,
+      tokenState: token.state
+    });
+  }
+  token.vote = vote.vote;
+  token.state = "completed";
+  return next;
+}
+function promoteSequential(state, ctx) {
+  const next = cloneState(state);
+  let changed = false;
+  for (const tally of groupTallies(next.tokens)) {
+    const approval = ctx.graph.approvalOf(tally.nodeId);
+    if (approval === void 0 || approval.sequential !== true) continue;
+    const members = next.tokens.filter((t) => t.instanceGroup === tally.groupId);
+    if (members.some((t) => t.state === "active")) continue;
+    const firstWaiting = members.find((t) => t.state === "waiting");
+    if (firstWaiting === void 0) continue;
+    firstWaiting.state = "active";
+    firstWaiting.createdAt = ctx.at;
+    changed = true;
+  }
+  return changed ? next : state;
+}
+function settleGroups(state, ctx, rejectTarget) {
+  let cur = state;
+  for (let i = 0; i < MAX_STEPS; i += 1) {
+    const found = nextSettledGroup(cur, ctx);
+    if (found === void 0) return cur;
+    cur = applySettlement(cur, ctx, found, rejectTarget);
+  }
+  throw stateShapeInvalid("convergence did not settle within the step budget", {
+    budget: MAX_STEPS,
+    instanceId: cur.instanceId
+  });
+}
+function nextSettledGroup(state, ctx) {
+  for (const tally of groupTallies(state.tokens)) {
+    const approval = ctx.graph.approvalOf(tally.nodeId);
+    if (approval === void 0) {
+      throw stateShapeInvalid(
+        `instance group '${tally.groupId}' on node '${tally.nodeId}' has no floken:approval config; convergence needs mode / onReject / vote`,
+        { groupId: tally.groupId, nodeId: tally.nodeId }
+      );
+    }
+    const result = evaluateConvergence(convergeCtxOf(tally, approval));
+    if (result.outcome !== "pending") return { tally, result, approval };
+  }
+  return void 0;
+}
+function applySettlement(state, ctx, g, rejectTarget) {
+  const next = cloneState(state);
+  const { groupId, nodeId } = g.tally;
+  const approved = g.result.outcome === "approved";
+  for (const id of restIdsOf(next, groupId)) {
+    const t = next.tokens.find((x) => x.id === id);
+    if (t !== void 0) t.state = "cancelled";
+  }
+  let to;
+  if (approved) {
+    const nxt = ctx.graph.nextOf(nodeId);
+    if (nxt === void 0) {
+      throw definitionMissing(ctx.graph.processId, ctx.graph.definitionVersion);
+    }
+    to = nxt;
+  } else {
+    to = resolveRejectTarget({
+      name: "reject",
+      approval: g.approval,
+      completedNodes: next.completedNodes,
+      ...rejectTarget !== void 0 ? { target: rejectTarget } : {},
+      startNodeId: ctx.graph.startNodeId
+    });
+  }
+  markCompleted(next, nodeId);
+  if (!approved) next.completedNodes = next.completedNodes.filter((n) => n !== to);
+  for (const t of next.tokens) {
+    if (t.instanceGroup === groupId) delete t.instanceGroup;
+  }
+  next.tokens.push({
+    id: `${groupId}#${approved ? "out" : "back"}`,
+    nodeId: to,
+    state: "active"
+  });
+  return next;
+}
+function restIdsOf(state, groupId) {
+  return state.tokens.filter((t) => t.instanceGroup === groupId && LIVE_TOKEN_STATES.includes(t.state)).map((t) => t.id);
+}
+function runToWait(state, ctx) {
+  let cur = cloneState(state);
+  const landings = [];
+  const events = [];
+  const pendingCalls = [];
+  const budget = { steps: 0 };
+  for (let round = 0; round < MAX_STEPS; round += 1) {
+    const merged = joinPass(cur, ctx);
+    cur = advanceTokens(cur, ctx, landings, budget, events, pendingCalls);
+    if (!merged) break;
+  }
+  const liveLeft = cur.tokens.filter((t) => LIVE_TOKEN_STATES.includes(t.state)).length;
+  if (liveLeft === 0 && !isTerminalStatus(cur.status)) {
+    cur.status = "completed";
+  }
+  return { next: cur, landings, events, pendingCalls };
+}
+function advanceTokens(state, ctx, landings, budget, events, pendingCalls) {
+  const next = cloneState(state);
+  for (let i = 0; i < next.tokens.length; i += 1) {
+    const token = next.tokens[i];
+    if (token === void 0) continue;
+    if (!LIVE_TOKEN_STATES.includes(token.state)) continue;
+    if (token.state === "waiting") continue;
+    if (token.awaiting !== void 0) continue;
+    for (; ; ) {
+      budget.steps += 1;
+      if (budget.steps > MAX_STEPS) {
+        throw stateShapeInvalid("run-to-wait exceeded the step budget (cycle in the definition graph?)", {
+          budget: MAX_STEPS,
+          instanceId: next.instanceId
+        });
+      }
+      const type = ctx.graph.typeOf(token.nodeId);
+      if (type === void 0) {
+        throw tokenOrphan(next.instanceId, token.id, token.nodeId);
+      }
+      assertNotDataNode(type, token.nodeId);
+      const behavior = eventBehaviorOf(type);
+      if (behavior !== void 0) {
+        assertEventSupported(type, token.nodeId, behavior);
+        if (behavior === "terminal") {
+          token.state = "completed";
+          break;
+        }
+        if (behavior === "catch") {
+          parkCatch(token, ctx);
+          break;
+        }
+      }
+      if (isGatewayType(type)) {
+        if (isConverging(type) && !canJoin(next, token.nodeId, ctx.graph)) break;
+        const routed = routeGateway({
+          type,
+          nodeId: token.nodeId,
+          outFlows: ctx.graph.outFlowsOf(token.nodeId),
+          defaultFlowId: ctx.graph.defaultFlowIdOf(token.nodeId),
+          // ★ 条件上下文取**此刻**的变量（T17：脚本 / 服务可能在本次推进里改过它）
+          isTrue: (f) => ctx.conditionsOf(f, token.nodeId, next.variables)
+        });
+        markCompleted(next, token.nodeId);
+        const race = type === "eventBasedGateway" ? `${token.nodeId}#${token.id}` : void 0;
+        if (routed.length === 1) {
+          token.nodeId = routed[0].to;
+          clearAssignment(token);
+          if (race !== void 0) token.race = race;
+          continue;
+        }
+        forkToken(next, token, i, routed, race);
+        continue;
+      }
+      const taskBehavior = taskBehaviorOf(type);
+      if (taskBehavior !== void 0) {
+        assertTaskSupported(type, token.nodeId, taskBehavior);
+        if (taskBehavior === "effect") applyEffect(next, token, ctx, events);
+        if (taskBehavior === "catch") {
+          parkCatch(token, ctx);
+          break;
+        }
+      }
+      const activityBehavior = activityBehaviorOf(type);
+      if (activityBehavior !== void 0) {
+        assertActivitySupported(type, token.nodeId, activityBehavior);
+        if (activityBehavior === "call") {
+          const target = ctx.graph.callTargetOf(token.nodeId);
+          if (target === void 0) {
+            throw stateShapeInvalid(`node '${token.nodeId}' is a callActivity without a call target`, {
+              nodeId: token.nodeId,
+              instanceId: next.instanceId
+            });
+          }
+          pendingCalls.push(parkForCall(next, token, target));
+          break;
+        }
+      }
+      if (isWaitingNode(type)) {
+        const settled = settleAssignee(token, ctx, next, i);
+        if (settled === "wait") {
+          if (token.createdAt === void 0) token.createdAt = ctx.at;
+          if (!landings.includes(token.nodeId)) landings.push(token.nodeId);
+          break;
+        }
+        if (settled === "expanded") break;
+      }
+      const to = ctx.graph.nextOf(token.nodeId);
+      if (to === void 0) {
+        throw definitionMissing(next.processId, ctx.graph.definitionVersion);
+      }
+      markCompleted(next, token.nodeId);
+      token.nodeId = to;
+      clearAssignment(token);
+    }
+  }
+  return next;
+}
+function applyEffect(next, token, ctx, events) {
+  const effect = ctx.effectsOf(token.nodeId, token.id, next.variables);
+  const patch = effect.variables;
+  if (patch !== void 0 && Object.keys(patch).length > 0) {
+    next.variables = { ...next.variables, ...patch };
+  }
+  for (const e of effect.events ?? []) events.push(e);
+}
+function forkToken(next, token, index, routed, race) {
+  const first = routed[0];
+  const root = token.branch ?? token.id;
+  token.nodeId = first.to;
+  token.branch = `${root}#${first.flowId}`;
+  clearAssignment(token);
+  if (race !== void 0) token.race = race;
+  const created = [];
+  for (let j = 1; j < routed.length; j += 1) {
+    const r = routed[j];
+    created.push({
+      id: `${token.id}#${r.flowId}`,
+      nodeId: r.to,
+      state: "active",
+      branch: `${root}#${r.flowId}`,
+      ...race === void 0 ? {} : { race }
+    });
+  }
+  next.tokens = [
+    ...next.tokens.slice(0, index + 1),
+    ...created,
+    ...next.tokens.slice(index + 1)
+  ];
+}
+function joinPass(state, ctx) {
+  let merged = false;
+  const visited = /* @__PURE__ */ new Set();
+  for (const t of state.tokens) {
+    if (!LIVE_TOKEN_STATES.includes(t.state)) continue;
+    const nodeId = t.nodeId;
+    if (visited.has(nodeId)) continue;
+    visited.add(nodeId);
+    const type = ctx.graph.typeOf(nodeId);
+    if (type === void 0 || !isGatewayType(type) || !isConverging(type)) continue;
+    if (ctx.graph.inFlowsOf(nodeId).length < 2) continue;
+    if (!canJoin(state, nodeId, ctx.graph)) continue;
+    const idxs = waitingAt(state, nodeId);
+    if (idxs.length === 0) continue;
+    for (let k = 1; k < idxs.length; k += 1) {
+      const other = state.tokens[idxs[k]];
+      if (other !== void 0) other.state = "completed";
+    }
+    const head = state.tokens[idxs[0]];
+    if (head !== void 0) delete head.branch;
+    merged = true;
+  }
+  return merged;
+}
+function parkCatch(token, ctx) {
+  const binding = ctx.graph.catchOf(token.nodeId);
+  if (binding === void 0) {
+    throw stateShapeInvalid(`node '${token.nodeId}' is a catch node without a catch binding`, {
+      nodeId: token.nodeId,
+      type: ctx.graph.typeOf(token.nodeId) ?? null,
+      instanceId: ctx.graph.processId
+    });
+  }
+  parkForCatch(token, binding);
+  if (token.createdAt === void 0) token.createdAt = ctx.at;
+}
+function settleAssignee(token, ctx, next, index) {
+  if (token.assignee !== void 0) return "wait";
+  const approval = ctx.graph.approvalOf(token.nodeId);
+  const chosen = selectAssignees(ctx.assigneesOf(token.nodeId), approval?.approverPolicy);
+  if (chosen.length === 0) {
+    const onEmpty = approval?.onEmpty ?? "error";
+    if (onEmpty === "error") {
+      throw approverEmpty(token.nodeId, onEmpty, {
+        instanceId: next.instanceId,
+        tokenId: token.id
+      });
+    }
+    return "skipped";
+  }
+  if (chosen.length === 1) {
+    token.assignee = chosen[0];
+    return "wait";
+  }
+  expandGroup(token, ctx, next, index, chosen, approval?.sequential === true);
+  return "expanded";
+}
+function selectAssignees(list, policy) {
+  if (policy === "first" || policy === "any") return list.slice(0, 1);
+  return list;
+}
+function expandGroup(token, ctx, next, index, assignees, sequential) {
+  const groupId = `${token.nodeId}#${token.id}`;
+  const created = assignees.map((assignee, i) => {
+    const active = i === 0 || !sequential;
+    const t = {
+      id: `${groupId}#${i}`,
+      nodeId: token.nodeId,
+      state: active ? "active" : "waiting",
+      assignee,
+      instanceGroup: groupId,
+      // ★ 分支标记**继承**：这一组人整体处在某条并行分支上（T16）
+      ...token.branch !== void 0 ? { branch: token.branch } : {}
+    };
+    if (active) t.createdAt = ctx.at;
+    return t;
+  });
+  next.tokens = [...next.tokens.slice(0, index), ...created, ...next.tokens.slice(index + 1)];
+}
+function taskStatusOf(state, token) {
+  if (state.status === "suspended") return "suspended";
+  if (token.returnTo !== void 0) return "delegated";
+  return "active";
+}
+function tasksOf(state, graph) {
+  const out = [];
+  for (const t of state.tokens) {
+    if (t.state !== "active") continue;
+    if (t.assignee === void 0) continue;
+    const view = {
+      /*
+       * ★ `taskId` = `${nodeId}:${tokenId}` —— **不是**裸 `token.id`。
+       *   同一个令牌会依次流经多个等待节点（approve → 下一节点 → …），
+       *   若 taskId 就是令牌 id，那么"驳回后重办"与"推进到下一步"会复用同一行，
+       *   宿主的待办表就分不出「这是新待办」还是「还是原来那条」。
+       */
+      taskId: `${t.nodeId}:${t.id}`,
+      instanceId: state.instanceId,
+      nodeId: t.nodeId,
+      assignee: t.assignee,
+      status: taskStatusOf(state, t),
+      createdAt: t.createdAt ?? state.startedAt
+    };
+    const name = graph.nameOf(t.nodeId);
+    if (name !== void 0) view.nodeName = name;
+    const formKey = graph.formKeyOf(t.nodeId);
+    if (formKey !== void 0) view.formKey = formKey;
+    out.push(view);
+  }
+  return out;
+}
+
+// src/runtime/deliver.ts
+function deliverStep(state, ctx, match, mode = "point") {
+  const graph = ctx.graph;
+  const matches = matchingTokens(state, match);
+  const winners = pickRaceWinners(matches);
+  const fires = mode === "broadcast" ? armedBoundaries(state, graph, match) : winners.length === 0 ? armedBoundaries(state, graph, match).slice(0, 1) : [];
+  if (winners.length === 0 && fires.length === 0) {
+    throw deliverNoTarget(state.instanceId, match.kind, match.name, [
+      ...waitingNamesOf(state),
+      ...armedNamesOf(state, graph)
+    ]);
+  }
+  const racedOut = resolveRace(state, winners);
+  let cur = applyBoundaryFires(state, fires, racedOut);
+  if (winners.length > 0) cur = leaveWait(cur, winners.map((t) => t.id), graph);
+  const r = runToWait(cur, ctx);
+  return {
+    next: r.next,
+    landings: r.landings,
+    events: r.events,
+    pendingCalls: r.pendingCalls,
+    woken: winners.map((t) => t.id),
+    nodeIds: winners.map((t) => t.nodeId),
+    racedOut,
+    fired: fires.map((f) => ({
+      nodeId: f.boundary.nodeId,
+      attachedTo: f.boundary.attachedTo,
+      cancelActivity: f.boundary.cancelActivity,
+      hostTokenId: f.hostTokenId
+    }))
+  };
+}
+function pickRaceWinners(matches) {
+  const winners = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of matches) {
+    if (t.race === void 0) {
+      winners.push(t);
+      continue;
+    }
+    if (seen.has(t.race)) continue;
+    seen.add(t.race);
+    winners.push(t);
+  }
+  return winners;
+}
+function resolveRace(state, winners) {
+  const races = /* @__PURE__ */ new Set();
+  for (const w of winners) if (w.race !== void 0) races.add(w.race);
+  if (races.size === 0) return [];
+  const winnerIds = new Set(winners.map((t) => t.id));
+  return state.tokens.filter(
+    (t) => t.race !== void 0 && races.has(t.race) && !winnerIds.has(t.id) && LIVE_TOKEN_STATES.includes(t.state)
+  ).map((t) => t.id);
+}
+function applyBoundaryFires(state, fires, racedOut) {
+  const next = cloneState(state);
+  for (const id of racedOut) {
+    const t = next.tokens.find((x) => x.id === id);
+    if (t !== void 0) t.state = "cancelled";
+  }
+  for (const fire of fires) {
+    const host = next.tokens.find((t) => t.id === fire.hostTokenId);
+    if (host === void 0) continue;
+    if (fire.boundary.cancelActivity) {
+      for (const id of cancelTargetsOf(next, fire.boundary.attachedTo)) {
+        const t = next.tokens.find((x) => x.id === id);
+        if (t !== void 0) t.state = "cancelled";
+      }
+    }
+    next.tokens.push(boundaryTokenOf(next, fire, host));
+  }
+  return next;
+}
+function leaveWait(state, tokenIds, graph) {
+  const next = wakeTokens(state, tokenIds);
+  for (const id of tokenIds) {
+    const t = next.tokens.find((x) => x.id === id);
+    if (t === void 0) continue;
+    const to = graph.nextOf(t.nodeId);
+    if (to === void 0) {
+      throw definitionMissing(graph.processId, graph.definitionVersion);
+    }
+    markCompleted(next, t.nodeId);
+    t.nodeId = to;
+    clearAssignment(t);
+  }
+  return next;
+}
+
+// src/runtime/timers.ts
+function timerKeyOf(nodeId, tokenId) {
+  return `${nodeId}::${tokenId}`;
+}
+function timeoutSpecOf(t) {
+  const out = {};
+  if (typeof t.duration === "string") out.duration = t.duration;
+  if (typeof t.date === "string") out.date = t.date;
+  if (typeof t.cycle === "string") out.cycle = t.cycle;
+  if (typeof t.workCalendar === "string") out.workCalendar = t.workCalendar;
+  return out;
+}
+function timingKeysOf(state, graph) {
+  const out = /* @__PURE__ */ new Map();
+  for (const t of state.tokens) {
+    if (t.state !== "active") continue;
+    if (t.assignee === void 0) continue;
+    const approval = graph.approvalOf(t.nodeId);
+    const timeout = approval?.timeout;
+    if (timeout === void 0) continue;
+    const kinds = (timeout.actions ?? []).map((a) => a?.type).filter((k) => typeof k === "string");
+    if (kinds.length === 0) continue;
+    out.set(timerKeyOf(t.nodeId, t.id), {
+      tokenId: t.id,
+      nodeId: t.nodeId,
+      // ★ 计时的起点 = **这条待办的创建时刻**，不是实例的启动时刻
+      fromAt: t.createdAt ?? state.startedAt,
+      timeout: timeoutSpecOf(timeout),
+      kinds
+    });
+  }
+  return out;
+}
+function diffTimers(prev, next, graph) {
+  const before = timingKeysOf(prev, graph);
+  const after = timingKeysOf(next, graph);
+  const schedule = [];
+  for (const [key, intent] of after) {
+    if (!before.has(key)) schedule.push(intent);
+  }
+  const cancel = [];
+  for (const key of before.keys()) {
+    if (after.has(key)) continue;
+    const [, tokenId] = splitKey(key);
+    const token = next.tokens.find((t) => t.id === tokenId);
+    const handles = token?.timerHandles ?? [];
+    if (handles.length === 0) continue;
+    cancel.push({ tokenId, handles });
+  }
+  return { schedule, cancel };
+}
+function splitKey(key) {
+  const i = key.indexOf("::");
+  return [key.slice(0, i), key.slice(i + 2)];
+}
+
+// src/runtime/trace.ts
+var SYSTEM_AUDIT_ACTIONS = [
+  "start",
+  "callActivityReturn",
+  "deliverMessage",
+  "deliverSignal"
+];
+function traceKindOf(action) {
+  return ACTION_NAMES.includes(action) ? "approval" : "system";
+}
+function traceOf(state) {
+  const entries = (state.auditTrail ?? []).map((e) => entryOf(e));
+  const first = entries[0];
+  if (first === void 0 || first.seq <= 1) {
+    return { entries, truncated: false };
+  }
+  return {
+    entries,
+    truncated: true,
+    droppedFromSeq: 1,
+    droppedToSeq: first.seq - 1
+  };
+}
+function entryOf(e) {
+  const out = {
+    seq: e.seq,
+    at: e.at,
+    actor: e.actor,
+    action: e.action,
+    kind: traceKindOf(e.action)
+  };
+  if (e.nodeId !== void 0) out.nodeId = e.nodeId;
+  if (e.tokenId !== void 0) out.tokenId = e.tokenId;
+  if (e.from !== void 0) out.from = e.from;
+  if (e.to !== void 0) out.to = e.to;
+  if (e.payload !== void 0) out.payload = e.payload;
+  return out;
+}
+
+// src/runtime/emit.ts
+function eventsOf(input) {
+  const { before, delta, next } = input;
+  const base = {
+    at: delta.action.at,
+    instanceId: next.instanceId,
+    processId: next.processId,
+    definitionVersion: next.definitionVersion,
+    action: delta.action
+  };
+  const beforeMap = new Map(before.map((t) => [t.taskId, t]));
+  const out = [];
+  const taskEvent = (name, view, taskStatus) => {
+    const e = {
+      ...base,
+      name,
+      taskId: view.taskId,
+      nodeId: view.nodeId,
+      assignee: view.assignee,
+      taskStatus
+    };
+    if (view.nodeName !== void 0) e.nodeName = view.nodeName;
+    if (view.formKey !== void 0) e.formKey = view.formKey;
+    out.push(e);
+  };
+  const instanceEvent = (name) => {
+    const e = { ...base, name, status: next.status, instance: headerOf(next) };
+    out.push(e);
+  };
+  if (input.previousStatus === void 0) instanceEvent("started");
+  const statusEvent = instanceEventNameOf(input.previousStatus, next.status);
+  if (statusEvent === "suspended" || statusEvent === "resumed") instanceEvent(statusEvent);
+  for (const taskId of delta.removed) {
+    const view = beforeMap.get(taskId);
+    if (view === void 0) continue;
+    const name = removalEventName(view, next);
+    taskEvent(name, view, name === "taskCompleted" ? "done" : "cancelled");
+  }
+  for (const view of delta.added) {
+    taskEvent("taskCreated", view, view.status);
+    if (view.assignee.length > 0) taskEvent("taskAssigned", view, view.status);
+  }
+  for (const view of delta.changed) {
+    taskEvent("taskUpdated", view, view.status);
+  }
+  if (statusEvent === "completed" || statusEvent === "terminated") instanceEvent(statusEvent);
+  return out;
+}
+function instanceEventNameOf(previous, next) {
+  if (previous === void 0) return "started";
+  if (previous === next) return void 0;
+  if (next === "suspended") return "suspended";
+  if (next === "running") return "resumed";
+  if (next === "completed") return "completed";
+  if (next === "terminated") return "terminated";
+  return void 0;
+}
+function removalEventName(view, next) {
+  const token = next.tokens.find((t) => `${view.nodeId}:${t.id}` === view.taskId);
+  if (token === void 0) return "taskCancelled";
+  if (token.state === "completed") return "taskCompleted";
+  if (token.state === "cancelled") return "taskCancelled";
+  return token.nodeId === view.nodeId ? "taskCancelled" : "taskCompleted";
+}
+function emitAll(sink, events) {
+  if (sink === void 0 || events.length === 0) return;
+  for (const event of events) {
+    try {
+      const r = sink.emit(event);
+      if (r !== null && typeof r === "object" && typeof r.then === "function") {
+        r.then(void 0, () => void 0);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/actions/compile.ts
+function groupSizeOf(state, token) {
+  const g = token.instanceGroup;
+  if (g === void 0) return 1;
+  return state.tokens.filter(
+    (t) => t.instanceGroup === g && (LIVE_TOKEN_STATES.includes(t.state) || t.vote !== void 0)
+  ).length;
+}
+var isActionName = (v) => ACTION_NAMES.includes(v);
+function resolveToken(state, ctx, action) {
+  if (ctx.tokenId !== void 0) {
+    const t = state.tokens.find((x) => x.id === ctx.tokenId);
+    if (t === void 0) {
+      throw stateShapeInvalid(`action '${action}' targets unknown token '${ctx.tokenId}'`, {
+        action,
+        tokenId: ctx.tokenId,
+        tokenIds: state.tokens.map((x) => x.id)
+      });
+    }
+    return t;
+  }
+  const live = state.tokens.filter((t) => LIVE_TOKEN_STATES.includes(t.state));
+  if (live.length === 1) return live[0];
+  throw stateShapeInvalid(
+    `action '${action}' cannot resolve a unique token: pass context.tokenId (found ${live.length} live tokens)`,
+    { action, liveTokenIds: live.map((t) => t.id) }
+  );
+}
+function resolveNext(state, ctx, from, action) {
+  const to = ctx.nextOf?.(from);
+  if (typeof to !== "string" || to.length === 0) {
+    throw definitionMissing(state.processId, state.definitionVersion);
+  }
+  return to;
+}
+function resolveAssignees(ctx, nodeId, action) {
+  const list = ctx.assignees ?? [];
+  if (list.length === 0) throw approverEmpty(nodeId, action);
+  return list;
+}
+function resolveSingleAssignee(ctx, nodeId, action) {
+  return resolveAssignees(ctx, nodeId, action)[0];
+}
+function compileAction(input, state, ctx) {
+  const name = input.action;
+  if (!isActionName(name)) {
+    throw actionUnknown(name, ACTION_NAMES);
+  }
+  const spec = ACTION_SPEC_BY_NAME[name];
+  const approval = ctx.approval;
+  assertActionEnabled(name, approval);
+  assertComment(name, spec, approval, input.comment);
+  if (spec.primitives.length === 0) {
+    throw stateShapeInvalid(
+      `action '${name}' is not handled by the kernel (it has no primitive mapping)`,
+      { action: name }
+    );
+  }
+  const head = name === "suspend" || name === "resume" ? name : spec.primitives[0];
+  const vote = groupVoteOf(name, state, ctx);
+  if (vote !== void 0) {
+    return { name, spec, calls: [], target: void 0, vote };
+  }
+  switch (head) {
+    // —— 实例级控制（不需要令牌）——
+    case "suspend":
+      return { name, spec, calls: [{ primitive: "suspend", input: reason(input) }], target: void 0 };
+    case "resume":
+      return { name, spec, calls: [{ primitive: "resume", input: reason(input) }], target: void 0 };
+    // —— 清场（不需要令牌）——
+    case "halt":
+      return { name, spec, calls: [{ primitive: "halt", input: reason(input) }], target: void 0 };
+    // —— 回退类 6 项：先校验目标（INV-6），再编译 ——
+    case "jumpTo":
+    case "rollbackTo": {
+      const token = resolveToken(state, ctx, name);
+      const target = assertTarget({
+        name,
+        approval,
+        completedNodes: state.completedNodes,
+        target: input.target,
+        ...ctx.startNodeId !== void 0 ? { startNodeId: ctx.startNodeId } : {}
+      });
+      const groupId = token.instanceGroup;
+      if (groupId !== void 0 && groupSizeOf(state, token) > 1) {
+        const others = state.tokens.filter(
+          (t) => t.instanceGroup === groupId && t.id !== token.id && LIVE_TOKEN_STATES.includes(t.state)
+        ).map((t) => t.id);
+        const calls = [];
+        if (others.length > 0) {
+          calls.push({ primitive: "cancelInstances", input: { tokenIds: others } });
+        }
+        calls.push(rollbackOrJump(head, token, target));
+        return { name, spec, calls, target, post: { dissolveTokenIds: [token.id] } };
+      }
+      return {
+        name,
+        spec,
+        calls: [rollbackOrJump(head, token, target)],
+        target
+      };
+    }
+    // —— 正向推进（需要定义图算后继）——
+    case "advance": {
+      const token = resolveToken(state, ctx, name);
+      if (name === "approve" && token.returnTo !== void 0) {
+        return { name, spec, calls: [], target: void 0, post: { returnFromTokenId: token.id } };
+      }
+      const to = resolveNext(state, ctx, token.nodeId);
+      return {
+        name,
+        spec,
+        calls: [{ primitive: "advance", input: { tokenId: token.id, to } }],
+        target: void 0
+      };
+    }
+    // —— 换人（不动令牌）——
+    case "transfer": {
+      const token = resolveToken(state, ctx, name);
+      return {
+        name,
+        spec,
+        calls: [
+          {
+            primitive: "transfer",
+            input: {
+              tokenId: token.id,
+              assignee: resolveSingleAssignee(ctx, token.nodeId, name)
+            }
+          }
+        ],
+        target: void 0
+      };
+    }
+    case "delegate": {
+      const token = resolveToken(state, ctx, name);
+      return {
+        name,
+        spec,
+        calls: [
+          {
+            primitive: "delegate",
+            input: {
+              tokenId: token.id,
+              assignee: resolveSingleAssignee(ctx, token.nodeId, name)
+            }
+          }
+        ],
+        target: void 0
+      };
+    }
+    // —— 加签 / 会签（INV-12 上限 + INV-13 空集）——
+    case "spawnInstances": {
+      const token = resolveToken(state, ctx, name);
+      const nodeId = name === "addSignAfter" ? resolveNext(state, ctx, token.nodeId) : token.nodeId;
+      const groupId = ctx.groupId ?? `${nodeId}#sign`;
+      const assignees = resolveAssignees(ctx, nodeId, name);
+      const isMultiInstance = spec.mode !== void 0;
+      if (isMultiInstance && approval === void 0) {
+        throw stateShapeInvalid(
+          `action '${name}' requires a floken:approval config on node '${nodeId}' (mode / onReject / vote come from it)`,
+          { action: name, nodeId }
+        );
+      }
+      const maxCount = approval?.addSign.maxCount;
+      if (typeof maxCount === "number") {
+        const current = state.tokens.filter(
+          (t) => t.nodeId === nodeId && LIVE_TOKEN_STATES.includes(t.state)
+        ).length;
+        const after = current + assignees.length;
+        if (after > maxCount) throw addSignLimit(nodeId, maxCount, after);
+      }
+      return {
+        name,
+        spec,
+        calls: [
+          {
+            primitive: "spawnInstances",
+            input: {
+              nodeId,
+              groupId,
+              assignees,
+              // 会签 / 或签 / 票签是"展开"：取代当前那个占位令牌；加签是"新增"
+              ...spec.mode !== void 0 ? { replaceTokenId: token.id } : {},
+              // 展开建组（要汇聚）；加签不建组（见 `SpawnInstancesInput.grouped` 注释）
+              grouped: isMultiInstance
+            }
+          }
+        ],
+        target: void 0
+      };
+    }
+    // —— 减签（必须点名范围，不代劳）——
+    case "cancelInstances": {
+      const tokenIds = ctx.reduceTokenIds ?? [];
+      if (tokenIds.length === 0) {
+        throw stateShapeInvalid(
+          `action '${name}' requires context.reduceTokenIds (which tokens to cancel)`,
+          { action: name }
+        );
+      }
+      return {
+        name,
+        spec,
+        calls: [{ primitive: "cancelInstances", input: { tokenIds } }],
+        target: void 0
+      };
+    }
+    default: {
+      const _exhaustive = head;
+      throw stateShapeInvalid(`action '${name}' maps to unmapped primitive`, {
+        action: name,
+        primitive: String(_exhaustive)
+      });
+    }
+  }
+}
+function rollbackOrJump(head, token, target) {
+  if (head === "rollbackTo") {
+    return {
+      primitive: "rollbackTo",
+      input: {
+        tokenId: token.id,
+        to: target,
+        ...token.branch !== void 0 ? { branch: token.branch } : {}
+      }
+    };
+  }
+  return { primitive: "jumpTo", input: { tokenId: token.id, to: target } };
+}
+function groupVoteOf(name, state, ctx) {
+  if (name !== "approve" && name !== "reject" && name !== "rejectToPrev") return void 0;
+  const token = resolveToken(state, ctx, name);
+  if (groupSizeOf(state, token) <= 1) return void 0;
+  return { tokenId: token.id, vote: name === "approve" ? "approved" : "rejected" };
+}
+function reason(input) {
+  return input.comment !== void 0 && input.comment.length > 0 ? { reason: input.comment } : {};
+}
+
+// src/core/hooks.ts
+function freezeActionContext(ctx) {
+  return deepFreeze(jsonClone(ctx));
+}
+function jsonClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    deepFreeze(value[key]);
+  }
+  return value;
+}
+
+// src/store/memory.ts
+function createMemoryStore() {
+  const rows = /* @__PURE__ */ new Map();
+  return {
+    async load(id) {
+      const row = rows.get(id);
+      return row === void 0 ? null : cloneState(row);
+    },
+    async save(next, expectedRev) {
+      assertSerializable(next, "next");
+      const current = rows.get(next.instanceId);
+      if (expectedRev === 0) {
+        if (current !== void 0) throw persistAlreadyExists(next.instanceId);
+        rows.set(next.instanceId, cloneState({ ...next, rev: 1 }));
+        return;
+      }
+      if (current === void 0) throw persistConflict(next.instanceId, expectedRev);
+      if (current.rev !== expectedRev) {
+        throw persistConflict(next.instanceId, expectedRev, current.rev);
+      }
+      rows.set(next.instanceId, cloneState({ ...next, rev: expectedRev + 1 }));
+    }
+  };
+}
+var JUEL_INTERPOLATION = /\$\{/;
+function assertNotJuel(source, where) {
+  if (!JUEL_INTERPOLATION.test(source)) return;
+  throw conditionInvalid(
+    source,
+    "JUEL \u63D2\u503C ${...} \u4E0D\u662F FEEL \u8BED\u6CD5",
+    { hintKind: "juel", where }
+  );
+}
+function createFeelConditionHandler(options = {}) {
+  const feel = {
+    ...options.allowedFunctions !== void 0 ? { allowedFunctions: [...options.allowedFunctions] } : {},
+    ...options.maxNodes !== void 0 ? { maxNodes: options.maxNodes } : {},
+    ...options.maxDepth !== void 0 ? { maxDepth: options.maxDepth } : {},
+    ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
+  };
+  return {
+    evaluate(expression, ctx) {
+      assertNotJuel(expression, "condition");
+      const src = expression.trim();
+      if (src === "") return true;
+      const result = evaluate(src, ctx.variables, feel);
+      if (typeof result.value !== "boolean") {
+        throw conditionInvalid(
+          expression,
+          result.value === null || result.value === void 0 ? "\u6C42\u503C\u4E3A null\uFF08\u672A\u77E5\uFF09\u2014\u2014 \u7F51\u5173\u6761\u4EF6\u5FC5\u987B\u662F true / false" : `\u6C42\u503C\u7ED3\u679C\u4E0D\u662F\u5E03\u5C14\u503C\uFF08${typeof result.value}\uFF09`,
+          {
+            value: result.value ?? null,
+            warnings: [...result.warnings]
+          }
+        );
+      }
+      return result.value;
+    }
+  };
+}
+async function evaluateCondition(handler, expression, ctx) {
+  const value = await handler.evaluate(expression, ctx);
+  if (typeof value !== "boolean") {
+    throw conditionInvalid(
+      expression,
+      value === null || value === void 0 ? "conditionHandler \u8FD4\u56DE\u4E86 null / undefined \u2014\u2014 \u6C42\u503C\u5931\u8D25\u5FC5\u987B\u629B\u9519\uFF0C\u4E0D\u5F97\u8FD4\u56DE\u7A7A" : `conditionHandler \u8FD4\u56DE\u4E86\u975E\u5E03\u5C14\u503C\uFF08${typeof value}\uFF09`,
+      { value: value ?? null, handler: "injected" }
+    );
+  }
+  return value;
+}
+var ConditionUnresolved = class extends Error {
+  name = "ConditionUnresolved";
+  /** 内部信号：便于与其它错误一眼区分（不依赖 instanceof，跨包/跨产物都稳） */
+  unresolved = true;
+  flowId;
+  expression;
+  nodeId;
+  /**
+   * ★ **到达该网关那一刻**的变量快照（T17）。
+   *
+   * 为什么必须由哨兵带出来：解析发生在**重跑**里，那时拿不到"当时"的状态。
+   * 若用提交前的旧变量去求值，`scriptTask` / `serviceTask` 在本次推进里改过的变量
+   * 就被忽略了 —— 表现为「脚本把 amount 改成了 9000，网关却按旧值走了分支」。
+   */
+  variables;
+  constructor(flowId, expression, nodeId, variables = {}) {
+    super(`condition of flow '${flowId}' is not resolved yet`);
+    this.flowId = flowId;
+    this.expression = expression;
+    this.nodeId = nodeId;
+    this.variables = variables;
+  }
+};
+function unresolvedCondition(flowId, expression, nodeId, variables = {}) {
+  return new ConditionUnresolved(flowId, expression, nodeId, variables);
+}
+function asUnresolved(e) {
+  if (e instanceof ConditionUnresolved) return e;
+  if (typeof e === "object" && e !== null && e.unresolved === true && typeof e.flowId === "string") {
+    return e;
+  }
+  return void 0;
+}
+function evaluateScript(source, variables) {
+  assertNotJuel(source, "script");
+  const src = source.trim();
+  const result = evaluate(src, variables);
+  return { value: result.value, warnings: [...result.warnings] };
+}
+
+// src/runtime/engine.ts
+var MAX_RESOLVE_ROUNDS = 256;
+function assertDeliverInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw optionInvalid("input", "must be a plain object", input);
+  }
+  const i = input;
+  const fail = (field, reason2) => {
+    throw optionInvalid(`input.${field}`, reason2, i[field]);
+  };
+  if (typeof i.name !== "string" || i.name.length === 0) fail("name", "must be a non-empty string");
+  if (typeof i.actor !== "string" || i.actor.length === 0) fail("actor", "must be a non-empty string");
+  if (i.at !== void 0 && (typeof i.at !== "string" || i.at.length === 0)) {
+    fail("at", "must be a non-empty ISO 8601 string when present");
+  }
+  if (i.payload !== void 0 && (typeof i.payload !== "object" || i.payload === null || Array.isArray(i.payload))) {
+    fail("payload", "must be a plain object when present");
+  }
+}
+var ENGINE_CONFIG_KEYS = [
+  "store",
+  "definitionSource",
+  "projection",
+  "approverSource",
+  "handlers",
+  "authResolver",
+  "formProvider",
+  "conditionHandler",
+  "decisionHandler",
+  "events",
+  "scheduler",
+  "hooks",
+  "clock",
+  "maxAuditEntries"
+];
+function assertEngineConfig(config) {
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    throw optionInvalid("config", "must be a plain object", config);
+  }
+  const c = config;
+  for (const key of Object.keys(c)) {
+    if (!ENGINE_CONFIG_KEYS.includes(key)) {
+      throw optionUnknown(key, ENGINE_CONFIG_KEYS);
+    }
+  }
+  const needFn = (key, methods) => {
+    const v = c[key];
+    if (v === void 0) return;
+    if (typeof v !== "object" || v === null) {
+      throw optionInvalid(key, "must be an object", v);
+    }
+    const o = v;
+    for (const m of methods) {
+      if (typeof o[m] !== "function") {
+        throw optionInvalid(`${key}.${m}`, "must be a function", o[m]);
+      }
+    }
+  };
+  needFn("store", ["load", "save"]);
+  needFn("definitionSource", ["getDefinition"]);
+  needFn("projection", ["apply", "sync"]);
+  needFn("approverSource", ["resolve"]);
+  needFn("conditionHandler", ["evaluate"]);
+  needFn("decisionHandler", ["evaluate"]);
+  if (c.definitionSource === void 0) {
+    throw optionInvalid("definitionSource", "is required (AC-E10: definitions are fetched by processId + version)", void 0);
+  }
+  if (c.clock !== void 0 && typeof c.clock !== "function") {
+    throw optionInvalid("clock", "must be a function returning an ISO 8601 string", c.clock);
+  }
+  if (c.maxAuditEntries !== void 0) {
+    const n = c.maxAuditEntries;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+      throw optionInvalid("maxAuditEntries", "must be a positive integer", n);
+    }
+  }
+}
+function assertStartOptions(opts) {
+  if (typeof opts !== "object" || opts === null || Array.isArray(opts)) {
+    throw optionInvalid("opts", "must be a plain object", opts);
+  }
+  const o = opts;
+  const fail = (field, reason2) => {
+    throw optionInvalid(`opts.${field}`, reason2, o[field]);
+  };
+  if (!Number.isInteger(o.definitionVersion) || o.definitionVersion < 1) {
+    fail("definitionVersion", "must be a positive integer");
+  }
+  if (typeof o.starter !== "string" || o.starter.length === 0) {
+    fail("starter", "must be a non-empty string");
+  }
+  if (o.businessKey !== void 0 && typeof o.businessKey !== "string") {
+    fail("businessKey", "must be a string when present");
+  }
+  if (o.tenantId !== void 0 && typeof o.tenantId !== "string") {
+    fail("tenantId", "must be a string when present");
+  }
+  if (o.variables !== void 0 && (typeof o.variables !== "object" || o.variables === null || Array.isArray(o.variables))) {
+    fail("variables", "must be a plain object when present");
+  }
+}
+var defaultClock = () => (/* @__PURE__ */ new Date()).toISOString();
+var DEFAULT_APPROVER_SOURCE = {
+  async resolve(spec) {
+    if (spec !== null && typeof spec === "object" && spec.type === "user" && typeof spec.value === "string") {
+      return [spec.value];
+    }
+    const type = spec?.type;
+    throw optionInvalid(
+      "approverSource",
+      `cannot resolve approver spec type '${String(type)}' without an injected ApproverSource`,
+      spec
+    );
+  }
+};
+var instanceSeq = 0;
+function newInstanceId() {
+  instanceSeq += 1;
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `pi_${Date.now().toString(36)}_${instanceSeq.toString(36)}_${rand}`;
+}
+function createEngine(config) {
+  assertEngineConfig(config);
+  const clock = config.clock ?? defaultClock;
+  const store = config.store ?? createMemoryStore();
+  const { definitionSource } = config;
+  const projection = config.projection;
+  const scheduler = config.scheduler;
+  const approverSource = config.approverSource ?? DEFAULT_APPROVER_SOURCE;
+  const condition = config.conditionHandler ?? createFeelConditionHandler();
+  const handlers = config.handlers;
+  const decisionHandler = config.decisionHandler;
+  const maxAuditEntries = config.maxAuditEntries;
+  const hooks = config.hooks;
+  const sink = config.events;
+  const queue = createInstanceQueue();
+  function now() {
+    const t = clock();
+    if (typeof t !== "string" || t.length === 0) {
+      throw optionInvalid("clock", "must return a non-empty ISO 8601 string", t);
+    }
+    return t;
+  }
+  async function graphOf(state) {
+    const def = await definitionSource.getDefinition(state.processId, state.definitionVersion);
+    if (def === null || def === void 0) {
+      throw definitionMissing(state.processId, state.definitionVersion);
+    }
+    return createProcessGraph(def, state.processId, state.definitionVersion);
+  }
+  async function buildApply(params) {
+    const { state, graph, at, record, run } = params;
+    const conditions = /* @__PURE__ */ new Map();
+    const conditionsOf = (flow, nodeId, variables) => {
+      if (flow.expression === void 0) return true;
+      const value = conditions.get(flow.id);
+      if (value === void 0) {
+        throw unresolvedCondition(flow.id, flow.expression, nodeId, variables);
+      }
+      return value;
+    };
+    const effects = /* @__PURE__ */ new Map();
+    const effectsOf = (nodeId, tokenId, variables) => {
+      const effect = effects.get(effectKeyOf(nodeId, tokenId));
+      if (effect === void 0) {
+        const kind = effectKindOf(graph.typeOf(nodeId));
+        if (kind === void 0) {
+          throw stateShapeInvalid(`node '${nodeId}' is not an effect task`, {
+            nodeId,
+            type: graph.typeOf(nodeId) ?? null
+          });
+        }
+        throw unresolvedEffect({ nodeId, tokenId, kind, variables });
+      }
+      return effect;
+    };
+    const pendingEvents = [];
+    const pendingCalls = [];
+    for (let round = 0; ; round += 1) {
+      try {
+        const probe = /* @__PURE__ */ new Set();
+        run(cloneState(state), {
+          graph,
+          at,
+          assigneesOf: (nodeId) => {
+            probe.add(nodeId);
+            return [PROBE_ASSIGNEE];
+          },
+          conditionsOf,
+          effectsOf
+        });
+        const resolved = /* @__PURE__ */ new Map();
+        for (const nodeId of probe) {
+          resolved.set(nodeId, await resolveAssigneesFor(nodeId, state, graph, approverSource));
+        }
+        return {
+          pendingEvents,
+          pendingCalls,
+          apply: (draft) => {
+            const r = run(
+              draft,
+              { graph, at, assigneesOf: (nodeId) => resolved.get(nodeId) ?? [], conditionsOf, effectsOf }
+            );
+            pendingEvents.length = 0;
+            for (const e of r.events) pendingEvents.push(e);
+            pendingCalls.length = 0;
+            for (const c of r.pendingCalls) pendingCalls.push(c);
+            return r.next;
+          }
+        };
+      } catch (e) {
+        const pendingEffect = asUnresolvedEffect(e);
+        if (pendingEffect !== void 0) {
+          if (round >= MAX_RESOLVE_ROUNDS) {
+            throw stateShapeInvalid("effect resolution did not converge (retry budget exceeded)", {
+              budget: MAX_RESOLVE_ROUNDS,
+              instanceId: state.instanceId
+            });
+          }
+          effects.set(
+            pendingEffect.key,
+            await resolveEffect({
+              nodeId: pendingEffect.nodeId,
+              tokenId: pendingEffect.tokenId,
+              kind: pendingEffect.kind,
+              variables: pendingEffect.variables,
+              graph,
+              state,
+              record,
+              handlers,
+              decisionHandler
+            })
+          );
+          continue;
+        }
+        const pending = asUnresolved(e);
+        if (pending === void 0) throw e;
+        if (round >= MAX_RESOLVE_ROUNDS) {
+          throw stateShapeInvalid("condition resolution did not converge (retry budget exceeded)", {
+            budget: MAX_RESOLVE_ROUNDS,
+            instanceId: state.instanceId
+          });
+        }
+        conditions.set(
+          pending.flowId,
+          await evaluateCondition(condition, pending.expression, {
+            instanceId: state.instanceId,
+            nodeId: pending.nodeId,
+            // ★ 用**到达该网关那一刻**的变量快照（哨兵带来），不是提交前的旧值
+            variables: pending.variables
+          })
+        );
+      }
+    }
+  }
+  async function start(processId, opts) {
+    assertStartOptions(opts);
+    const at = now();
+    const graph = await graphOf({ processId, definitionVersion: opts.definitionVersion });
+    const instanceId = newInstanceId();
+    const base = {
+      instanceId,
+      processId,
+      definitionVersion: opts.definitionVersion,
+      status: "running",
+      rev: 0,
+      // ★ INSERT 信号（store 据此分两条路径）
+      stateSchema: STATE_SCHEMA_VERSION,
+      startedAt: at,
+      updatedAt: at,
+      tokens: [{ id: "tk_start", nodeId: graph.startNodeId, state: "active" }],
+      completedNodes: [],
+      variables: { ...opts.variables ?? {} },
+      auditTrail: [],
+      starter: opts.starter
+    };
+    if (opts.businessKey !== void 0) base.businessKey = opts.businessKey;
+    if (opts.tenantId !== void 0) base.tenantId = opts.tenantId;
+    const record = { name: "start", actor: opts.starter, at };
+    const built = await buildApply({
+      state: base,
+      graph,
+      at,
+      record,
+      run: (s, ctx) => step(s, ctx, { calls: [] })
+    });
+    const looped = built.apply(cloneState(base));
+    const startTokenId = "tk_start";
+    const startTo = looped.tokens.find((t) => t.id === startTokenId)?.nodeId;
+    const startEntry = {
+      seq: 1,
+      at,
+      actor: opts.starter,
+      action: "start",
+      nodeId: graph.startNodeId,
+      tokenId: startTokenId,
+      from: graph.startNodeId,
+      ...startTo !== void 0 ? { to: startTo } : {}
+    };
+    const next = {
+      ...looped,
+      rev: 1,
+      lastAction: record,
+      auditTrail: [startEntry]
+    };
+    const delta = {
+      rev: next.rev,
+      action: record,
+      added: tasksOf(next, graph),
+      removed: [],
+      changed: [],
+      instance: headerOf(next)
+    };
+    await reconcileTimers(base, next, graph);
+    await store.save(next, 0);
+    if (projection !== void 0) await projection.apply(instanceId, delta);
+    emitAll(sink, [...eventsOf({ before: [], delta, next }), ...built.pendingEvents]);
+    await followUp(next, { next, pendingCalls: built.pendingCalls });
+    return instanceId;
+  }
+  async function submit(instanceId, action) {
+    const outcome = await queue.run(instanceId, () => doSubmit(instanceId, action));
+    await followUp(outcome.next, outcome);
+    return outcome.delta;
+  }
+  async function doSubmit(instanceId, action) {
+    const state = await store.load(instanceId);
+    if (state === null || state === void 0) throw stateNotFound(instanceId);
+    if (isTerminalStatus(state.status)) {
+      throw stateTerminal(state.instanceId, state.status, action.action);
+    }
+    const at = action.at ?? now();
+    const input = action.at === void 0 ? { ...action, at } : action;
+    const graph = await graphOf(state);
+    assertTokensInGraph(state, graph);
+    const tokenId = resolveSubjectToken(state, input);
+    const subject = tokenId === void 0 ? void 0 : state.tokens.find((t) => t.id === tokenId);
+    const nodeId = subject?.nodeId;
+    const approval = nodeId === void 0 ? void 0 : graph.approvalOf(nodeId);
+    const assignees = await resolveActionAssignees(input, nodeId, state, graph, approverSource);
+    const compiled = compileAction(input, state, {
+      approval,
+      nextOf: graph.nextOf,
+      startNodeId: graph.startNodeId,
+      ...tokenId !== void 0 ? { tokenId } : {},
+      ...assignees !== void 0 ? { assignees } : {},
+      ...payloadString(input.payload, "groupId") !== void 0 ? { groupId: payloadString(input.payload, "groupId") } : {},
+      ...payloadStringArray(input.payload, "reduceTokenIds") !== void 0 ? { reduceTokenIds: payloadStringArray(input.payload, "reduceTokenIds") } : {}
+    });
+    const before = tasksOf(state, graph);
+    const record = { name: input.action, actor: input.actor, at };
+    const stepInput = {
+      calls: compiled.calls,
+      ...compiled.vote !== void 0 ? { vote: compiled.vote } : {},
+      ...compiled.post !== void 0 ? { post: compiled.post } : {},
+      ...input.target !== void 0 ? { rejectTarget: input.target } : {}
+    };
+    const built = await buildApply({
+      /*
+       * ★ 传给探测/闭包的是**已并入 payload 增量**的状态。
+       *   `plan()` 在 ④.5 先并变量、④.6 才调 `apply` —— 探测必须用同一份，
+       *   否则「表单里把 amount 改成 9000、网关却按旧值走分支」（§7.2 要防的头号事故）。
+       */
+      state: withPayload(state, input.payload),
+      graph,
+      at,
+      record,
+      run: (s, ctx2) => step(s, ctx2, stepInput)
+    });
+    const result = plan(state, input, {
+      clock,
+      ...maxAuditEntries !== void 0 ? { maxAuditEntries } : {},
+      apply: built.apply,
+      tasks: (s) => tasksOf(s, graph)
+    });
+    await reconcileTimers(state, result.next, graph);
+    const ctx = freezeActionContext({
+      action: result.delta.action,
+      state: headerOf(state),
+      next: headerOf(result.next),
+      delta: result.delta
+    });
+    if (hooks?.beforeAction !== void 0) {
+      const verdict = await hooks.beforeAction(ctx);
+      if (verdict === false) throw actionVetoed(input.action, instanceId);
+    }
+    await store.save(result.next, state.rev);
+    if (projection !== void 0) await projection.apply(instanceId, result.delta);
+    if (hooks?.afterAction !== void 0) await hooks.afterAction(ctx);
+    emitAll(
+      sink,
+      [
+        ...eventsOf({ before, delta: result.delta, next: result.next, previousStatus: state.status }),
+        // ★ 节点副作用产出的事件（`manualTask` 的留痕）—— 状态已落库，此刻投递才安全
+        ...built.pendingEvents
+      ]
+    );
+    return { next: result.next, pendingCalls: built.pendingCalls, delta: result.delta };
+  }
+  async function deliverMessage(instanceId, input) {
+    const outcome = await queue.run(instanceId, () => doDeliver(instanceId, "message", input, "throw"));
+    await followUp(outcome.next, outcome);
+    return outcome.delta;
+  }
+  async function deliverSignal(instanceIds, input) {
+    assertDeliverInput(input);
+    if (!Array.isArray(instanceIds) || instanceIds.length === 0) {
+      throw optionInvalid("instanceIds", "must be a non-empty array", instanceIds);
+    }
+    const deltas = [];
+    const waiting = [];
+    for (const id of instanceIds) {
+      const outcome = await queue.run(id, () => doDeliver(id, "signal", input, "skip", waiting));
+      if (outcome === null) continue;
+      await followUp(outcome.next, outcome);
+      deltas.push(outcome.delta);
+    }
+    if (deltas.length === 0) {
+      throw deliverNoTarget(void 0, "signal", input.name, waiting, {
+        candidates: [...instanceIds]
+      });
+    }
+    return deltas;
+  }
+  async function doDeliver(instanceId, kind, input, onMiss, waitingSink) {
+    assertDeliverInput(input);
+    const state = await store.load(instanceId);
+    if (state === null || state === void 0) throw stateNotFound(instanceId);
+    const actionName = kind === "message" ? MESSAGE_DELIVER_ACTION : SIGNAL_DELIVER_ACTION;
+    if (isTerminalStatus(state.status) || state.status === "suspended") {
+      if (onMiss === "skip") return null;
+      if (isTerminalStatus(state.status)) {
+        throw stateTerminal(state.instanceId, state.status, actionName);
+      }
+      throw stateSuspended(state.instanceId, actionName);
+    }
+    const graph = await graphOf(state);
+    assertTokensInGraph(state, graph);
+    const match = { kind, name: input.name };
+    const mode = onMiss === "throw" ? "point" : "broadcast";
+    const waiters = matchingTokens(state, match);
+    const armed = armedBoundaries(state, graph, match);
+    const hitCount = mode === "point" ? waiters.length > 0 || armed.length > 0 ? 1 : 0 : waiters.length + armed.length;
+    if (hitCount === 0) {
+      const names = [...waitingNamesOf(state), ...armedNamesOf(state, graph)];
+      if (waitingSink !== void 0) {
+        for (const n of names) if (!waitingSink.includes(n)) waitingSink.push(n);
+      }
+      if (onMiss === "skip") return null;
+      throw deliverNoTarget(instanceId, kind, input.name, names);
+    }
+    const at = input.at ?? now();
+    const before = tasksOf(state, graph);
+    const record = { name: actionName, actor: input.actor, at };
+    const ai = {
+      action: actionName,
+      actor: input.actor,
+      at,
+      // 审计要记「唤醒了哪儿」：多个命中时取第一个（保序，可重放）
+      target: waiters[0]?.nodeId ?? armed[0]?.boundary.nodeId,
+      ...input.payload !== void 0 ? { payload: input.payload } : {}
+    };
+    const built = await buildApply({
+      state: withPayload(state, input.payload),
+      graph,
+      at,
+      record,
+      run: (s, ctx) => deliverStep(s, ctx, match, mode)
+    });
+    const result = plan(state, ai, {
+      clock,
+      ...maxAuditEntries !== void 0 ? { maxAuditEntries } : {},
+      apply: built.apply,
+      tasks: (s) => tasksOf(s, graph)
+    });
+    await reconcileTimers(state, result.next, graph);
+    const hookCtx = freezeActionContext({
+      action: result.delta.action,
+      state: headerOf(state),
+      next: headerOf(result.next),
+      delta: result.delta
+    });
+    if (hooks?.beforeAction !== void 0) {
+      const verdict = await hooks.beforeAction(hookCtx);
+      if (verdict === false) throw actionVetoed(actionName, instanceId);
+    }
+    await store.save(result.next, state.rev);
+    if (projection !== void 0) await projection.apply(instanceId, result.delta);
+    if (hooks?.afterAction !== void 0) await hooks.afterAction(hookCtx);
+    emitAll(
+      sink,
+      [
+        ...eventsOf({ before, delta: result.delta, next: result.next, previousStatus: state.status }),
+        ...built.pendingEvents
+      ]
+    );
+    return { next: result.next, pendingCalls: built.pendingCalls, delta: result.delta };
+  }
+  async function reconcileTimers(prev, next, graph) {
+    if (scheduler === void 0) return;
+    const diff = diffTimers(prev, next, graph);
+    const gained = /* @__PURE__ */ new Map();
+    for (const p of diff.schedule) {
+      const handles = [];
+      for (const kind of p.kinds) {
+        handles.push(
+          await scheduler.schedule({
+            instanceId: next.instanceId,
+            nodeId: p.nodeId,
+            tokenId: p.tokenId,
+            fromAt: p.fromAt,
+            timeout: p.timeout,
+            kind
+          })
+        );
+      }
+      gained.set(p.tokenId, handles);
+    }
+    for (const c of diff.cancel) {
+      for (const h of c.handles) await scheduler.cancel(h);
+      const t = next.tokens.find((x) => x.id === c.tokenId);
+      if (t !== void 0) delete t.timerHandles;
+    }
+    for (const [tokenId, handles] of gained) {
+      const t = next.tokens.find((x) => x.id === tokenId);
+      if (t === void 0) continue;
+      t.timerHandles = [...t.timerHandles ?? [], ...handles];
+    }
+  }
+  async function followUp(parent, outcome) {
+    for (const call of outcome.pendingCalls) {
+      await startChild({
+        instanceId: call.instanceId,
+        processId: call.processId,
+        definitionVersion: call.definitionVersion,
+        variables: { ...call.variables },
+        starter: parent.starter ?? parent.instanceId,
+        ...parent.tenantId !== void 0 ? { tenantId: parent.tenantId } : {},
+        parent: { instanceId: parent.instanceId, nodeId: call.nodeId, tokenId: call.tokenId }
+      });
+    }
+    if (isTerminalStatus(outcome.next.status)) {
+      if (outcome.next.parent !== void 0) await resumeParent(outcome.next);
+      await haltLiveChildren(outcome.next);
+    }
+  }
+  async function startChild(spec) {
+    const outcome = await queue.run(spec.instanceId, () => doStartChild(spec));
+    await followUp(outcome.next, outcome);
+  }
+  async function doStartChild(spec) {
+    const at = now();
+    const graph = await graphOf({
+      processId: spec.processId,
+      definitionVersion: spec.definitionVersion
+    });
+    const base = {
+      instanceId: spec.instanceId,
+      processId: spec.processId,
+      definitionVersion: spec.definitionVersion,
+      status: "running",
+      rev: 0,
+      // ★ INSERT 信号
+      stateSchema: STATE_SCHEMA_VERSION,
+      startedAt: at,
+      updatedAt: at,
+      tokens: [{ id: "tk_start", nodeId: graph.startNodeId, state: "active" }],
+      completedNodes: [],
+      variables: { ...spec.variables },
+      auditTrail: [],
+      starter: spec.starter,
+      parent: spec.parent
+    };
+    if (spec.tenantId !== void 0) base.tenantId = spec.tenantId;
+    const record = { name: "start", actor: spec.starter, at };
+    const built = await buildApply({
+      state: base,
+      graph,
+      at,
+      record,
+      run: (s, ctx) => step(s, ctx, { calls: [] })
+    });
+    const looped = built.apply(cloneState(base));
+    const next = {
+      ...looped,
+      rev: 1,
+      lastAction: record,
+      auditTrail: [{ seq: 1, at, actor: spec.starter, action: "start", nodeId: graph.startNodeId }]
+    };
+    const delta = {
+      rev: next.rev,
+      action: record,
+      added: tasksOf(next, graph),
+      removed: [],
+      changed: [],
+      instance: headerOf(next)
+    };
+    await reconcileTimers(base, next, graph);
+    await store.save(next, 0);
+    if (projection !== void 0) await projection.apply(spec.instanceId, delta);
+    emitAll(sink, [...eventsOf({ before: [], delta, next }), ...built.pendingEvents]);
+    return { next, pendingCalls: built.pendingCalls };
+  }
+  async function resumeParent(child) {
+    const p = child.parent;
+    if (p === void 0) return;
+    const outcome = await queue.run(p.instanceId, () => doResumeParent(child, p));
+    if (outcome !== void 0) await followUp(outcome.next, outcome);
+  }
+  async function doResumeParent(child, p) {
+    const parent = await store.load(p.instanceId);
+    if (parent === null || parent === void 0) throw stateNotFound(p.instanceId);
+    if (isTerminalStatus(parent.status)) return void 0;
+    const token = parent.tokens.find((t) => t.id === p.tokenId);
+    if (token === void 0 || token.state !== "waiting") return void 0;
+    const graph = await graphOf(parent);
+    const to = graph.nextOf(p.nodeId);
+    if (to === void 0) throw definitionMissing(parent.processId, parent.definitionVersion);
+    const at = now();
+    const actor = child.lastAction?.actor ?? child.starter ?? child.instanceId;
+    const record = { name: CALL_RETURN_ACTION, actor, at, nodeId: p.nodeId };
+    const resumed = callReturnOf(parent, p, to);
+    const built = await buildApply({
+      state: resumed,
+      graph,
+      at,
+      record,
+      run: (s, ctx) => step(s, ctx, { calls: [] })
+    });
+    const before = tasksOf(parent, graph);
+    const result = plan(parent, { action: CALL_RETURN_ACTION, actor, at }, {
+      clock,
+      ...maxAuditEntries !== void 0 ? { maxAuditEntries } : {},
+      apply: (draft) => built.apply(callReturnOf(draft, p, to)),
+      tasks: (s) => tasksOf(s, graph)
+    });
+    await reconcileTimers(parent, result.next, graph);
+    await store.save(result.next, parent.rev);
+    if (projection !== void 0) await projection.apply(p.instanceId, result.delta);
+    emitAll(sink, [
+      ...eventsOf({ before, delta: result.delta, next: result.next, previousStatus: parent.status }),
+      ...built.pendingEvents
+    ]);
+    return { next: result.next, pendingCalls: built.pendingCalls };
+  }
+  async function haltLiveChildren(parent) {
+    for (const childId of parent.childInstanceIds ?? []) await haltChild(childId);
+  }
+  async function haltChild(childId) {
+    await queue.run(childId, async () => {
+      const child = await store.load(childId);
+      if (child === null || child === void 0) return;
+      if (isTerminalStatus(child.status)) return;
+      const at = now();
+      const record = {
+        name: "terminate",
+        actor: child.lastAction?.actor ?? child.starter ?? childId,
+        at
+      };
+      const next = {
+        ...cloneState(child),
+        status: "terminated",
+        rev: child.rev + 1,
+        updatedAt: at,
+        endedAt: at,
+        lastAction: record,
+        tokens: child.tokens.map(
+          (t) => LIVE_TOKEN_STATES.includes(t.state) ? { ...t, state: "cancelled" } : t
+        ),
+        auditTrail: appendAudit(child.auditTrail, { at, actor: record.actor, action: record.name })
+      };
+      if (maxAuditEntries !== void 0 && next.auditTrail.length > maxAuditEntries) {
+        next.auditTrail = next.auditTrail.slice(next.auditTrail.length - maxAuditEntries);
+      }
+      const graph = await graphOf(child);
+      const before = tasksOf(child, graph);
+      const delta = {
+        rev: next.rev,
+        action: record,
+        added: [],
+        removed: before.map((t) => t.taskId),
+        changed: [],
+        instance: headerOf(next)
+      };
+      await store.save(next, child.rev);
+      if (projection !== void 0) await projection.apply(childId, delta);
+      emitAll(sink, eventsOf({ before, delta, next, previousStatus: child.status }));
+      await haltLiveChildren(next);
+    });
+  }
+  async function exportTrace(instanceId) {
+    const state = await store.load(instanceId);
+    if (state === null || state === void 0) throw stateNotFound(instanceId);
+    return traceOf(state);
+  }
+  return {
+    start,
+    submit,
+    deliverMessage,
+    deliverSignal,
+    exportTrace,
+    plan: (state, action, options) => plan(state, action, {
+      clock,
+      ...maxAuditEntries !== void 0 ? { maxAuditEntries } : {},
+      ...options
+    })
+  };
+}
+async function resolveEffect(params) {
+  const { nodeId, tokenId, kind, variables, graph, state, record } = params;
+  const { handlers, decisionHandler } = params;
+  if (kind === "manual") return { nodeId, events: manualTaskEvents({ nodeId, tokenId, graph, state, record }) };
+  if (kind === "service" || kind === "script" && !isFeelScriptFormat(graph.scriptFormatOf(nodeId))) {
+    const ref = graph.handlerRefOf(nodeId);
+    const fn = handlers?.get(ref);
+    if (fn === void 0) {
+      const why = kind === "script" ? `scriptTask '${nodeId}' \u7684 scriptFormat '${String(graph.scriptFormatOf(nodeId))}' \u4E0D\u662F FEEL` : `serviceTask '${nodeId}' \u6CA1\u6709\u6CE8\u518C\u5904\u7406\u5668`;
+      throw optionInvalid("handlers", `${why} \u2014\u2014 \u8BF7\u5728 handlers \u8868\u6CE8\u518C ref '${ref}'`, {
+        nodeId,
+        ref,
+        kind,
+        /*
+         * ⚠️ 提示文案**刻意不逐字写**那三个禁用 API 名（`test/tasks.test.ts` 有一道
+         *   「源码扫描」门禁，`src/**` 里出现它们就红，而字符串字面量不在注释剥离范围内）。
+         *   语义照样讲清楚：本引擎没有任何"动态执行宿主代码"的能力，一律由宿主提供实现。
+         */
+        hint: "\u5F15\u64CE\u4E0D\u6267\u884C\u4EFB\u610F JS\uFF08\u65E0\u52A8\u6001\u6C42\u503C\u80FD\u529B\uFF0C\u4E5F\u4E0D\u52A0\u8F7D vm \u7C7B\u6A21\u5757\uFF09\uFF1B\u975E FEEL \u7684\u811A\u672C\u4E0E\u5176\u5B83\u5B9E\u73B0\u4E00\u5F8B\u7531\u5BBF\u4E3B\u63D0\u4F9B"
+      });
+    }
+    const out2 = await fn(variables, {
+      instanceId: state.instanceId,
+      processId: state.processId,
+      definitionVersion: state.definitionVersion,
+      nodeId
+    });
+    return { nodeId, variables: assertVariablePatch(nodeId, kind, out2) };
+  }
+  if (kind === "script") {
+    const source = graph.scriptOf(nodeId);
+    if (source === void 0) {
+      throw stateShapeInvalid(`scriptTask '${nodeId}' has no <script> content`, {
+        nodeId,
+        hint: "\u7ED9\u8BE5\u8282\u70B9\u5199 <bpmn:script>\uFF0C\u6216\u6539\u4E3A\u975E FEEL \u7684 scriptFormat \u5E76\u5728 handlers \u8868\u6CE8\u518C\u5904\u7406\u5668"
+      });
+    }
+    const r = evaluateScript(source, variables);
+    return { nodeId, variables: { [nodeId]: r.value } };
+  }
+  if (decisionHandler === void 0) {
+    throw optionInvalid(
+      "decisionHandler",
+      `businessRuleTask '${nodeId}' \u9700\u8981 decisionHandler \u2014\u2014 \u672A\u6CE8\u5165\u5373\u62A5\u300C\u672A\u914D\u7F6E\u300D`,
+      { nodeId, hint: "\u53EF\u63A5 @floken-io/dmn\uFF0C\u4E5F\u53EF\u4EE5\u76F4\u63A5\u4F20\u4E00\u4E2A (input, ctx) => output \u7684\u51FD\u6570" }
+    );
+  }
+  const out = await decisionHandler.evaluate({ ...variables }, {
+    instanceId: state.instanceId,
+    nodeId,
+    input: { ...variables }
+  });
+  return { nodeId, variables: assertVariablePatch(nodeId, kind, out) };
+}
+function manualTaskEvents(params) {
+  const { nodeId, tokenId, graph, state, record } = params;
+  const base = {
+    at: record.at,
+    instanceId: state.instanceId,
+    processId: state.processId,
+    definitionVersion: state.definitionVersion,
+    action: record
+  };
+  const name = graph.nameOf(nodeId);
+  const formKey = graph.formKeyOf(nodeId);
+  const make = (eventName, taskStatus) => {
+    const e = { ...base, name: eventName, taskId: `${nodeId}:${tokenId}`, nodeId, taskStatus };
+    if (name !== void 0) e.nodeName = name;
+    if (formKey !== void 0) e.formKey = formKey;
+    return e;
+  };
+  return [make("taskCreated", "active"), make("taskCompleted", "done")];
+}
+function appendAudit(trail, entry) {
+  let max = 0;
+  for (const e of trail) {
+    if (typeof e.seq === "number" && e.seq > max) max = e.seq;
+  }
+  return [...trail, { ...entry, seq: max + 1 }];
+}
+function withPayload(state, payload) {
+  if (payload === void 0) return state;
+  return { ...state, variables: { ...state.variables, ...payload } };
+}
+async function resolveAssigneesFor(nodeId, state, graph, approverSource) {
+  const approval = graph.approvalOf(nodeId);
+  if (approval === void 0) {
+    throw approverEmpty(nodeId, "error", {
+      instanceId: state.instanceId,
+      reason: `node '${nodeId}' has no ${"floken:approval"} config`
+    });
+  }
+  const ctx = {
+    instanceId: state.instanceId,
+    processId: state.processId,
+    nodeId,
+    starter: state.starter ?? "",
+    variables: state.variables
+  };
+  const out = [];
+  for (const spec of approval.approvers) {
+    const list = await approverSource.resolve(spec, ctx);
+    for (const id of list ?? []) {
+      if (typeof id === "string" && id.length > 0) out.push(id);
+    }
+  }
+  return [...new Set(out)];
+}
+function resolveSubjectToken(state, input) {
+  return subjectTokenOf(state, input.actor)?.id;
+}
+async function resolveActionAssignees(input, nodeId, state, graph, approverSource) {
+  if (nodeId === void 0) return void 0;
+  const explicit = explicitAssignees(input.payload);
+  if (HANDOVER_ACTIONS.includes(input.action)) {
+    return explicit;
+  }
+  if (SPAWN_ACTIONS.includes(input.action)) {
+    if (explicit !== void 0) return explicit;
+    return await resolveAssigneesFor(nodeId, state, graph, approverSource);
+  }
+  return void 0;
+}
+function explicitAssignees(payload) {
+  if (payload === void 0) return void 0;
+  const one = payload["assignee"];
+  if (typeof one === "string" && one.length > 0) return [one];
+  const many = payload["assignees"];
+  if (Array.isArray(many)) {
+    const list = many.filter((x) => typeof x === "string" && x.length > 0);
+    if (list.length > 0) return list;
+  }
+  return void 0;
+}
+function payloadString(payload, key) {
+  const v = payload?.[key];
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function payloadStringArray(payload, key) {
+  const v = payload?.[key];
+  if (!Array.isArray(v)) return void 0;
+  const list = v.filter((x) => typeof x === "string" && x.length > 0);
+  return list.length > 0 ? list : void 0;
+}
+
+// src/entries/index.ts
+var PACKAGE = "@floken-io/engine";
+
+export { ACTION_NAMES, BOUNDARY_TYPE, CALL_RETURN_ACTION, CATCH_KINDS, DELIVER_ACTIONS, ENGINE_EVENT_NAMES, INSTANCE_EVENT_NAMES, MESSAGE_DELIVER_ACTION, PACKAGE, PRIMITIVE_GROUPS, PRIMITIVE_NAMES, SIGNAL_DELIVER_ACTION, SPI_GROUPS, SPI_NAMES, SYSTEM_AUDIT_ACTIONS, TASK_EVENT_NAMES, TASK_STATUSES, applyPost, armedBoundaries, armedNamesOf, boundaryBindingOf, boundaryTokenIdOf, callReturnOf, cancelTargetsOf, castVote, catchBindingOf, convergeCtxOf, createEngine, createFeelConditionHandler, createInstanceQueue, createMemoryStore, deliverStep, diffTimers, emitAll, enabledActionNames, evaluateCondition, evaluateConvergence, eventsOf, groupTallies, inScopeOf, instanceEventNameOf, isInstanceEvent, isTaskEvent, matchingTokens, plan, promoteSequential, requiredOf, restTokenIds, settleGroups, shouldConverge, shouldTerminate, step, subjectTokenOf, timeoutSpecOf, timerKeyOf, timingKeysOf, traceKindOf, traceOf, waitingNamesOf };