@cyoda/workflow-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2004 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArrayCriterionSchema: () => ArrayCriterionSchema,
+  CriterionSchema: () => CriterionSchema,
+  ExecutionModeSchema: () => ExecutionModeSchema,
+  ExportPayloadSchema: () => ExportPayloadSchema,
+  ExternalizedProcessorSchema: () => ExternalizedProcessorSchema,
+  FunctionConfigSchema: () => FunctionConfigSchema,
+  FunctionCriterionSchema: () => FunctionCriterionSchema,
+  GroupCriterionSchema: () => GroupCriterionSchema,
+  ImportPayloadSchema: () => ImportPayloadSchema,
+  LifecycleCriterionSchema: () => LifecycleCriterionSchema,
+  NAME_REGEX: () => NAME_REGEX,
+  NameSchema: () => NameSchema,
+  OPERATOR_TYPES: () => OPERATOR_TYPES,
+  OperatorEnum: () => OperatorEnum,
+  ParseJsonError: () => ParseJsonError,
+  ProcessorSchema: () => ProcessorSchema,
+  ScheduledProcessorSchema: () => ScheduledProcessorSchema,
+  SchemaError: () => SchemaError,
+  SimpleCriterionSchema: () => SimpleCriterionSchema,
+  StateSchema: () => StateSchema,
+  TransitionSchema: () => TransitionSchema,
+  WorkflowApiConflictError: () => WorkflowApiConflictError,
+  WorkflowApiTransportError: () => WorkflowApiTransportError,
+  WorkflowSchema: () => WorkflowSchema,
+  applyPatch: () => applyPatch,
+  applyPatches: () => applyPatches,
+  assignSyntheticIds: () => assignSyntheticIds,
+  findMigrationPath: () => findMigrationPath,
+  idFor: () => idFor2,
+  invertPatch: () => invertPatch,
+  listMigrations: () => listMigrations,
+  lookupById: () => lookupById,
+  migrateSession: () => migrateSession,
+  mintCriterionIds: () => mintCriterionIds,
+  normalizeCriterion: () => normalizeCriterion,
+  normalizeOperatorAlias: () => normalizeOperatorAlias,
+  normalizeProcessor: () => normalizeProcessor,
+  normalizeWorkflowInput: () => normalizeWorkflowInput,
+  outputCriterion: () => outputCriterion,
+  outputFunctionConfig: () => outputFunctionConfig,
+  outputProcessor: () => outputProcessor,
+  outputTransition: () => outputTransition,
+  outputWorkflow: () => outputWorkflow,
+  parseEditorDocument: () => parseEditorDocument,
+  parseExportPayload: () => parseExportPayload,
+  parseImportPayload: () => parseImportPayload,
+  prettyStringify: () => prettyStringify,
+  registerMigration: () => registerMigration,
+  serializeEditorDocument: () => serializeEditorDocument,
+  serializeExportPayload: () => serializeExportPayload,
+  serializeImportPayload: () => serializeImportPayload,
+  validateAfterPatch: () => validateAfterPatch,
+  validateAll: () => validateAll,
+  validateExportSchema: () => validateExportSchema,
+  validateImportSchema: () => validateImportSchema,
+  validateSemantics: () => validateSemantics,
+  validateSession: () => validateSession,
+  zodErrorToIssues: () => zodErrorToIssues
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/operator.ts
+var OPERATOR_TYPES = /* @__PURE__ */ new Set([
+  "EQUALS",
+  "NOT_EQUAL",
+  "IS_NULL",
+  "NOT_NULL",
+  "GREATER_THAN",
+  "LESS_THAN",
+  "GREATER_OR_EQUAL",
+  "LESS_OR_EQUAL",
+  "BETWEEN",
+  "BETWEEN_INCLUSIVE",
+  "CONTAINS",
+  "NOT_CONTAINS",
+  "STARTS_WITH",
+  "NOT_STARTS_WITH",
+  "ENDS_WITH",
+  "NOT_ENDS_WITH",
+  "MATCHES_PATTERN",
+  "LIKE",
+  "IEQUALS",
+  "INOT_EQUAL",
+  "ICONTAINS",
+  "INOT_CONTAINS",
+  "ISTARTS_WITH",
+  "INOT_STARTS_WITH",
+  "IENDS_WITH",
+  "INOT_ENDS_WITH",
+  "IS_UNCHANGED",
+  "IS_CHANGED"
+]);
+
+// src/types/api.ts
+var WorkflowApiConflictError = class extends Error {
+  constructor(entity, serverConcurrencyToken, message = "Workflow save conflict: server state has changed.") {
+    super(message);
+    this.entity = entity;
+    this.serverConcurrencyToken = serverConcurrencyToken;
+  }
+  entity;
+  serverConcurrencyToken;
+  name = "WorkflowApiConflictError";
+};
+var WorkflowApiTransportError = class extends Error {
+  constructor(cause, message = "Workflow API transport error.") {
+    super(message);
+    this.cause = cause;
+  }
+  cause;
+  name = "WorkflowApiTransportError";
+};
+
+// src/schema/name.ts
+var import_zod = require("zod");
+var NAME_REGEX = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var NameSchema = import_zod.z.string().regex(NAME_REGEX, "Invalid name: must start with a letter and contain only letters, digits, _ or -");
+
+// src/schema/operator.ts
+var import_zod2 = require("zod");
+var OperatorEnum = import_zod2.z.enum([
+  "EQUALS",
+  "NOT_EQUAL",
+  "IS_NULL",
+  "NOT_NULL",
+  "GREATER_THAN",
+  "LESS_THAN",
+  "GREATER_OR_EQUAL",
+  "LESS_OR_EQUAL",
+  "BETWEEN",
+  "BETWEEN_INCLUSIVE",
+  "CONTAINS",
+  "NOT_CONTAINS",
+  "STARTS_WITH",
+  "NOT_STARTS_WITH",
+  "ENDS_WITH",
+  "NOT_ENDS_WITH",
+  "MATCHES_PATTERN",
+  "LIKE",
+  "IEQUALS",
+  "INOT_EQUAL",
+  "ICONTAINS",
+  "INOT_CONTAINS",
+  "ISTARTS_WITH",
+  "INOT_STARTS_WITH",
+  "IENDS_WITH",
+  "INOT_ENDS_WITH",
+  "IS_UNCHANGED",
+  "IS_CHANGED"
+]);
+
+// src/schema/criterion.ts
+var import_zod3 = require("zod");
+var FunctionConfigSchema = import_zod3.z.object({
+  attachEntity: import_zod3.z.boolean().optional(),
+  calculationNodesTags: import_zod3.z.string().optional(),
+  responseTimeoutMs: import_zod3.z.number().int().nonnegative().optional(),
+  retryPolicy: import_zod3.z.string().optional(),
+  context: import_zod3.z.string().optional()
+});
+var SimpleCriterionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("simple"),
+  jsonPath: import_zod3.z.string().min(1),
+  operation: OperatorEnum,
+  value: import_zod3.z.unknown().optional()
+});
+var LifecycleCriterionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("lifecycle"),
+  field: import_zod3.z.enum(["state", "creationDate", "previousTransition"]),
+  operation: OperatorEnum,
+  value: import_zod3.z.unknown().optional()
+});
+var ArrayCriterionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("array"),
+  jsonPath: import_zod3.z.string().min(1),
+  operation: OperatorEnum,
+  value: import_zod3.z.array(import_zod3.z.string())
+});
+var CriterionSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([
+    SimpleCriterionSchema,
+    GroupCriterionSchema,
+    FunctionCriterionSchema,
+    LifecycleCriterionSchema,
+    ArrayCriterionSchema
+  ])
+);
+var GroupCriterionSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("group"),
+    operator: import_zod3.z.enum(["AND", "OR", "NOT"]),
+    conditions: import_zod3.z.array(CriterionSchema).min(1)
+  })
+);
+var FunctionCriterionSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("function"),
+    function: import_zod3.z.object({
+      name: NameSchema,
+      config: FunctionConfigSchema.optional(),
+      criterion: CriterionSchema.optional()
+    })
+  })
+);
+
+// src/schema/processor.ts
+var import_zod4 = require("zod");
+var ExecutionModeSchema = import_zod4.z.enum(["SYNC", "ASYNC_SAME_TX", "ASYNC_NEW_TX"]);
+var ExternalizedProcessorSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("externalized"),
+  name: NameSchema,
+  executionMode: ExecutionModeSchema.optional(),
+  config: FunctionConfigSchema.and(
+    import_zod4.z.object({
+      asyncResult: import_zod4.z.boolean().optional(),
+      crossoverToAsyncMs: import_zod4.z.number().int().nonnegative().optional()
+    })
+  ).optional()
+});
+var ScheduledProcessorSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("scheduled"),
+  name: NameSchema,
+  config: import_zod4.z.object({
+    delayMs: import_zod4.z.number().int().nonnegative(),
+    transition: import_zod4.z.string().min(1),
+    timeoutMs: import_zod4.z.number().int().nonnegative().optional()
+  })
+});
+var ProcessorSchema = import_zod4.z.discriminatedUnion("type", [
+  ExternalizedProcessorSchema,
+  ScheduledProcessorSchema
+]);
+
+// src/schema/workflow.ts
+var import_zod5 = require("zod");
+var TransitionSchema = import_zod5.z.object({
+  name: NameSchema,
+  next: NameSchema,
+  manual: import_zod5.z.boolean(),
+  disabled: import_zod5.z.boolean(),
+  criterion: CriterionSchema.optional(),
+  processors: import_zod5.z.array(ProcessorSchema).optional()
+});
+var StateSchema = import_zod5.z.object({
+  transitions: import_zod5.z.array(TransitionSchema)
+});
+var WorkflowSchema = import_zod5.z.object({
+  version: import_zod5.z.string().min(1),
+  name: NameSchema,
+  desc: import_zod5.z.string().optional(),
+  initialState: NameSchema,
+  active: import_zod5.z.boolean(),
+  criterion: CriterionSchema.optional(),
+  states: import_zod5.z.record(NameSchema, StateSchema).refine((s) => Object.keys(s).length > 0, "Workflow must have at least one state")
+});
+
+// src/schema/payload.ts
+var import_zod6 = require("zod");
+var ImportPayloadSchema = import_zod6.z.object({
+  importMode: import_zod6.z.enum(["MERGE", "REPLACE", "ACTIVATE"]),
+  workflows: import_zod6.z.array(WorkflowSchema).min(1)
+});
+var ExportPayloadSchema = import_zod6.z.object({
+  entityName: NameSchema,
+  modelVersion: import_zod6.z.number().int().positive(),
+  workflows: import_zod6.z.array(WorkflowSchema).min(1)
+});
+
+// src/parse/errors.ts
+var SchemaError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "SchemaError";
+  }
+  path;
+};
+var ParseJsonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseJsonError";
+  }
+};
+
+// src/parse/operator-alias.ts
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function normalizeOperatorAlias(raw) {
+  if (Array.isArray(raw)) {
+    return raw.map((item) => normalizeOperatorAlias(item));
+  }
+  if (!isObject(raw)) return raw;
+  const result = {};
+  for (const [k, v] of Object.entries(raw)) {
+    result[k] = normalizeOperatorAlias(v);
+  }
+  const type = result["type"];
+  const needsAlias = type === "simple" || type === "lifecycle" || type === "array" || type === void 0;
+  if (needsAlias && "operatorType" in result) {
+    const alias = result["operatorType"];
+    const existing = result["operation"];
+    if (existing !== void 0 && existing !== alias) {
+      throw new SchemaError(
+        `Conflicting "operation" and "operatorType" values: ${JSON.stringify(existing)} vs ${JSON.stringify(alias)}`
+      );
+    }
+    result["operation"] = existing ?? alias;
+    delete result["operatorType"];
+  }
+  return result;
+}
+
+// src/identity/assign.ts
+var import_uuid = require("uuid");
+function emptyIds() {
+  return {
+    workflows: {},
+    states: {},
+    transitions: {},
+    processors: {},
+    criteria: {}
+  };
+}
+function indexPriorStates(prior) {
+  if (!prior) return {};
+  const out = {};
+  for (const [uuid, ptr] of Object.entries(prior.ids.states)) {
+    out[`${ptr.workflow}:${ptr.state}`] = uuid;
+  }
+  return out;
+}
+function indexPriorTransitions(prior) {
+  if (!prior) return {};
+  const out = {};
+  for (const [uuid, ptr] of Object.entries(prior.ids.transitions)) {
+    const key = `${ptr.workflow}:${ptr.state}`;
+    (out[key] ??= []).push(uuid);
+  }
+  return out;
+}
+function indexPriorProcessors(prior) {
+  if (!prior) return {};
+  const out = {};
+  for (const [uuid, ptr] of Object.entries(prior.ids.processors)) {
+    const key = ptr.transitionUuid;
+    (out[key] ??= []).push(uuid);
+  }
+  return out;
+}
+function assignSyntheticIds(session, prior) {
+  const ids = emptyIds();
+  const priorWorkflowIds = prior?.ids.workflows ?? {};
+  const priorStatesByKey = indexPriorStates(prior);
+  const priorTransitionsByKey = indexPriorTransitions(prior);
+  const priorProcessorsByTransition = indexPriorProcessors(prior);
+  const workflowUi = prior?.workflowUi ?? {};
+  for (const wf of session.workflows) {
+    const wfUuid = priorWorkflowIds[wf.name] ?? (0, import_uuid.v4)();
+    ids.workflows[wf.name] = wfUuid;
+    assignForWorkflow(
+      wf,
+      ids,
+      priorStatesByKey,
+      priorTransitionsByKey,
+      priorProcessorsByTransition
+    );
+  }
+  return {
+    revision: prior?.revision ?? 0,
+    ids,
+    workflowUi,
+    ...prior?.lastValidJsonHash !== void 0 ? { lastValidJsonHash: prior.lastValidJsonHash } : {}
+  };
+}
+function assignForWorkflow(wf, ids, priorStatesByKey, priorTransitionsByKey, priorProcessorsByTransition) {
+  for (const stateCode of Object.keys(wf.states)) {
+    const key = `${wf.name}:${stateCode}`;
+    const uuid = priorStatesByKey[key] ?? (0, import_uuid.v4)();
+    const ptr = { workflow: wf.name, state: stateCode };
+    ids.states[uuid] = ptr;
+  }
+  for (const [stateCode, state] of Object.entries(wf.states)) {
+    const priorTs = priorTransitionsByKey[`${wf.name}:${stateCode}`] ?? [];
+    state.transitions.forEach((t, idx) => {
+      const tUuid = priorTs[idx] ?? (0, import_uuid.v4)();
+      const tPtr = {
+        workflow: wf.name,
+        state: stateCode,
+        transitionUuid: tUuid
+      };
+      ids.transitions[tUuid] = tPtr;
+      if (t.processors) {
+        const priorPs = priorProcessorsByTransition[tUuid] ?? [];
+        t.processors.forEach((_p, pIdx) => {
+          const pUuid = priorPs[pIdx] ?? (0, import_uuid.v4)();
+          const pPtr = {
+            workflow: wf.name,
+            state: stateCode,
+            transitionUuid: tUuid,
+            processorUuid: pUuid
+          };
+          ids.processors[pUuid] = pPtr;
+        });
+      }
+      if (t.criterion) {
+        mintCriterionIds(
+          t.criterion,
+          {
+            kind: "transition",
+            workflow: wf.name,
+            state: stateCode,
+            transitionUuid: tUuid
+          },
+          ["criterion"],
+          ids
+        );
+      }
+    });
+  }
+  if (wf.criterion) {
+    mintCriterionIds(
+      wf.criterion,
+      { kind: "workflow", workflow: wf.name },
+      ["criterion"],
+      ids
+    );
+  }
+}
+function mintCriterionIds(c, host, path, ids) {
+  const uuid = (0, import_uuid.v4)();
+  const ptr = { host, path: [...path] };
+  ids.criteria[uuid] = ptr;
+  switch (c.type) {
+    case "group":
+      c.conditions.forEach((child, idx) => {
+        mintCriterionIds(child, host, [...path, "conditions", String(idx)], ids);
+      });
+      return;
+    case "function":
+      if (c.function.criterion) {
+        mintCriterionIds(
+          c.function.criterion,
+          host,
+          [...path, "function", "criterion"],
+          ids
+        );
+      }
+      return;
+    default:
+      return;
+  }
+}
+
+// src/normalize/input.ts
+function normalizeWorkflowInput(workflow) {
+  const out = {
+    ...workflow,
+    name: workflow.name.trim(),
+    version: workflow.version.trim(),
+    initialState: workflow.initialState.trim(),
+    states: {}
+  };
+  if (workflow.desc !== void 0) {
+    const trimmed = workflow.desc;
+    if (trimmed.length === 0) {
+      delete out.desc;
+    } else {
+      out.desc = trimmed;
+    }
+  }
+  if (workflow.criterion !== void 0) {
+    out.criterion = normalizeCriterion(workflow.criterion);
+  }
+  for (const [code, state] of Object.entries(workflow.states)) {
+    const trimmedCode = code.trim();
+    const normTransitions = state.transitions.map((t) => {
+      const nt = {
+        ...t,
+        name: t.name.trim(),
+        next: t.next.trim()
+      };
+      if (t.criterion !== void 0) nt.criterion = normalizeCriterion(t.criterion);
+      if (t.processors !== void 0) {
+        if (t.processors.length === 0) {
+          delete nt.processors;
+        } else {
+          nt.processors = t.processors.map(normalizeProcessor);
+        }
+      }
+      return nt;
+    });
+    out.states[trimmedCode] = { transitions: normTransitions };
+  }
+  return out;
+}
+function normalizeCriterion(criterion) {
+  switch (criterion.type) {
+    case "simple":
+      return criterion;
+    case "group":
+      return { ...criterion, conditions: criterion.conditions.map(normalizeCriterion) };
+    case "function": {
+      const fn = criterion.function;
+      const out = {
+        type: "function",
+        function: {
+          name: fn.name.trim(),
+          ...fn.config !== void 0 ? { config: fn.config } : {},
+          ...fn.criterion !== void 0 ? { criterion: normalizeCriterion(fn.criterion) } : {}
+        }
+      };
+      return out;
+    }
+    case "lifecycle":
+      return criterion;
+    case "array":
+      return criterion;
+  }
+}
+function normalizeProcessor(p) {
+  if (p.type === "externalized") {
+    return { ...p, name: p.name.trim() };
+  }
+  return {
+    ...p,
+    name: p.name.trim(),
+    config: { ...p.config, transition: p.config.transition.trim() }
+  };
+}
+
+// src/validate/helpers.ts
+function isValidName(name) {
+  return NAME_REGEX.test(name);
+}
+function* walkCriteria(session) {
+  for (const wf of session.workflows) {
+    if (wf.criterion) {
+      yield* walkInner(wf.criterion, { kind: "workflow", workflow: wf.name });
+    }
+    for (const [stateCode, state] of Object.entries(wf.states)) {
+      for (let i = 0; i < state.transitions.length; i++) {
+        const t = state.transitions[i];
+        if (t.criterion) {
+          yield* walkInner(t.criterion, {
+            kind: "transition",
+            workflow: wf.name,
+            state: stateCode,
+            transitionIndex: i,
+            transitionName: t.name
+          });
+        }
+      }
+    }
+  }
+}
+function* walkInner(c, where) {
+  yield { criterion: c, where };
+  if (c.type === "group") {
+    for (const child of c.conditions) yield* walkInner(child, where);
+  } else if (c.type === "function" && c.function.criterion) {
+    yield* walkInner(c.function.criterion, where);
+  }
+}
+
+// src/validate/semantic.ts
+var LIFECYCLE_FIELDS = /* @__PURE__ */ new Set(["state", "creationDate", "previousTransition"]);
+function validateSemantics(session, doc) {
+  const issues = [];
+  issues.push(...duplicateWorkflowNames(session));
+  for (const wf of session.workflows) {
+    issues.push(...validateWorkflow(wf, doc));
+  }
+  issues.push(...criterionRules(session));
+  if (session.workflows.length === 1) {
+    const only = session.workflows[0];
+    if (only && only.criterion !== void 0) {
+      issues.push({
+        severity: "info",
+        code: "unused-workflow-criterion",
+        message: "Workflow-level criterion is set but the session has only one workflow."
+      });
+    }
+  }
+  return issues;
+}
+function duplicateWorkflowNames(session) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const wf of session.workflows) {
+    seen.set(wf.name, (seen.get(wf.name) ?? 0) + 1);
+  }
+  const out = [];
+  for (const [name, count] of seen) {
+    if (count > 1) {
+      out.push({
+        severity: "error",
+        code: "duplicate-workflow-name",
+        message: `Duplicate workflow name: "${name}" (appears ${count}\xD7)`,
+        detail: { name, count }
+      });
+    }
+  }
+  return out;
+}
+function validateWorkflow(wf, doc) {
+  const issues = [];
+  if (!wf.initialState || wf.initialState.length === 0) {
+    issues.push({
+      severity: "error",
+      code: "missing-initial-state",
+      message: `Workflow "${wf.name}" has no initialState.`,
+      ...idFor(doc, wf.name, "workflow")
+    });
+  } else if (!(wf.initialState in wf.states)) {
+    issues.push({
+      severity: "error",
+      code: "unknown-initial-state",
+      message: `Workflow "${wf.name}" initialState "${wf.initialState}" is not a state.`,
+      ...idFor(doc, wf.name, "workflow")
+    });
+  }
+  if (!isValidName(wf.name)) {
+    issues.push({
+      severity: "error",
+      code: "name-regex-violation",
+      message: `Workflow name "${wf.name}" is invalid.`
+    });
+  }
+  for (const [stateCode, state] of Object.entries(wf.states)) {
+    if (!isValidName(stateCode)) {
+      issues.push({
+        severity: "error",
+        code: "name-regex-violation",
+        message: `State code "${stateCode}" is invalid.`
+      });
+    }
+    const transitionSeen = /* @__PURE__ */ new Map();
+    for (const t of state.transitions) {
+      transitionSeen.set(t.name, (transitionSeen.get(t.name) ?? 0) + 1);
+      if (!isValidName(t.name)) {
+        issues.push({
+          severity: "error",
+          code: "name-regex-violation",
+          message: `Transition name "${t.name}" is invalid.`
+        });
+      }
+      if (!(t.next in wf.states)) {
+        issues.push({
+          severity: "error",
+          code: "unknown-transition-target",
+          message: `Transition "${t.name}" on "${stateCode}" targets unknown state "${t.next}".`
+        });
+      }
+      if (t.processors) {
+        const pSeen = /* @__PURE__ */ new Map();
+        for (const p of t.processors) {
+          pSeen.set(p.name, (pSeen.get(p.name) ?? 0) + 1);
+          if (!isValidName(p.name)) {
+            issues.push({
+              severity: "error",
+              code: "name-regex-violation",
+              message: `Processor name "${p.name}" is invalid.`
+            });
+          }
+          if (p.type === "scheduled" && p.config.transition.length === 0) {
+            issues.push({
+              severity: "error",
+              code: "scheduled-missing-target",
+              message: `Scheduled processor "${p.name}" has empty target transition.`
+            });
+          }
+          if (p.type === "externalized" && p.config) {
+            if (p.config.crossoverToAsyncMs !== void 0 && p.config.asyncResult !== true) {
+              issues.push({
+                severity: "warning",
+                code: "crossover-without-async-result",
+                message: `Processor "${p.name}" sets crossoverToAsyncMs but asyncResult is not true.`
+              });
+            }
+          }
+        }
+        for (const [name, count] of pSeen) {
+          if (count > 1) {
+            issues.push({
+              severity: "error",
+              code: "duplicate-processor-name",
+              message: `Duplicate processor name "${name}" on transition "${t.name}".`
+            });
+          }
+        }
+        if (t.processors.length > 5) {
+          issues.push({
+            severity: "warning",
+            code: "processor-overload",
+            message: `Transition "${t.name}" has ${t.processors.length} processors (>5).`
+          });
+        }
+      }
+      if (t.disabled && wf.active) {
+        issues.push({
+          severity: "warning",
+          code: "disabled-transition-on-active-workflow",
+          message: `Transition "${t.name}" is disabled in active workflow "${wf.name}".`
+        });
+      }
+      if (t.processors) {
+        for (const p of t.processors) {
+          if (p.type === "scheduled") {
+            const names = collectTransitionNames(wf);
+            if (!names.has(p.config.transition)) {
+              issues.push({
+                severity: "warning",
+                code: "scheduled-target-unresolved",
+                message: `Scheduled processor "${p.name}" targets unknown transition "${p.config.transition}" in workflow.`
+              });
+            }
+          }
+        }
+      }
+    }
+    for (const [name, count] of transitionSeen) {
+      if (count > 1) {
+        issues.push({
+          severity: "error",
+          code: "duplicate-transition-name",
+          message: `Duplicate transition name "${name}" on state "${stateCode}".`
+        });
+      }
+    }
+    if (state.transitions.length > 8) {
+      issues.push({
+        severity: "warning",
+        code: "excessive-fan-out",
+        message: `State "${stateCode}" has ${state.transitions.length} outgoing transitions (>8).`
+      });
+    }
+    if (state.transitions.length > 0 && state.transitions.every((t) => t.manual === true)) {
+      issues.push({
+        severity: "warning",
+        code: "all-transitions-manual",
+        message: `State "${stateCode}" has only manual transitions.`
+      });
+    }
+    if (state.transitions.length === 0 && stateCode !== wf.initialState) {
+      issues.push({
+        severity: "info",
+        code: "terminal-state-derived",
+        message: `State "${stateCode}" is terminal.`
+      });
+    }
+  }
+  const reachable = reachableStates(wf);
+  for (const stateCode of Object.keys(wf.states)) {
+    if (!reachable.has(stateCode) && stateCode !== wf.initialState) {
+      issues.push({
+        severity: "warning",
+        code: "unreachable-state",
+        message: `State "${stateCode}" is unreachable from the initial state.`
+      });
+    }
+  }
+  if (!wf.active) {
+    issues.push({
+      severity: "info",
+      code: "workflow-inactive",
+      message: `Workflow "${wf.name}" is inactive.`
+    });
+  }
+  const reachableAuto = reachableAutoStates(wf);
+  for (const [stateCode, state] of Object.entries(wf.states)) {
+    if (!reachableAuto.has(stateCode)) continue;
+    for (const t of state.transitions) {
+      if (t.manual) continue;
+      if (!t.processors) continue;
+      for (const p of t.processors) {
+        if (p.type === "externalized" && p.executionMode === "SYNC") {
+          issues.push({
+            severity: "warning",
+            code: "sync-on-likely-bottleneck-transition",
+            message: `SYNC processor "${p.name}" on auto-reachable transition "${t.name}" may block the main path.`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function criterionRules(session) {
+  const issues = [];
+  for (const { criterion, where } of walkCriteria(session)) {
+    switch (criterion.type) {
+      case "function":
+        if (!criterion.function.name || criterion.function.name.length === 0) {
+          issues.push({
+            severity: "error",
+            code: "function-missing-name",
+            message: `Function criterion has empty name (at ${describe(where)}).`
+          });
+        } else if (!isValidName(criterion.function.name)) {
+          issues.push({
+            severity: "error",
+            code: "name-regex-violation",
+            message: `Function criterion name "${criterion.function.name}" is invalid.`
+          });
+        }
+        if (!criterion.function.criterion) {
+          issues.push({
+            severity: "warning",
+            code: "function-without-quick-exit",
+            message: `Function criterion "${criterion.function.name}" has no local quick-exit criterion.`
+          });
+        }
+        break;
+      case "array":
+        for (const v of criterion.value) {
+          if (typeof v !== "string") {
+            issues.push({
+              severity: "error",
+              code: "array-non-string-value",
+              message: `Array criterion value contains a non-string element.`
+            });
+            break;
+          }
+        }
+        break;
+      case "lifecycle":
+        if (!LIFECYCLE_FIELDS.has(criterion.field)) {
+          issues.push({
+            severity: "error",
+            code: "lifecycle-invalid-field",
+            message: `Lifecycle criterion field "${criterion.field}" is invalid.`
+          });
+        }
+        break;
+      case "group":
+        if (criterion.operator === "NOT" && criterion.conditions.length > 1) {
+          issues.push({
+            severity: "warning",
+            code: "not-with-multiple-conditions",
+            message: `NOT group has ${criterion.conditions.length} conditions; should have exactly one.`
+          });
+        }
+        break;
+      case "simple":
+        break;
+    }
+  }
+  return issues;
+}
+function reachableStates(wf) {
+  const visited = /* @__PURE__ */ new Set();
+  if (!(wf.initialState in wf.states)) return visited;
+  const queue = [wf.initialState];
+  visited.add(wf.initialState);
+  while (queue.length) {
+    const cur = queue.shift();
+    const state = wf.states[cur];
+    if (!state) continue;
+    for (const t of state.transitions) {
+      if (!visited.has(t.next) && t.next in wf.states) {
+        visited.add(t.next);
+        queue.push(t.next);
+      }
+    }
+  }
+  return visited;
+}
+function reachableAutoStates(wf) {
+  const visited = /* @__PURE__ */ new Set();
+  if (!(wf.initialState in wf.states)) return visited;
+  const queue = [wf.initialState];
+  visited.add(wf.initialState);
+  while (queue.length) {
+    const cur = queue.shift();
+    const state = wf.states[cur];
+    if (!state) continue;
+    for (const t of state.transitions) {
+      if (t.manual) continue;
+      if (!visited.has(t.next) && t.next in wf.states) {
+        visited.add(t.next);
+        queue.push(t.next);
+      }
+    }
+  }
+  return visited;
+}
+function collectTransitionNames(wf) {
+  const out = /* @__PURE__ */ new Set();
+  for (const state of Object.values(wf.states)) {
+    for (const t of state.transitions) out.add(t.name);
+  }
+  return out;
+}
+function describe(w) {
+  if (w.kind === "workflow") return `workflow "${w.workflow}"`;
+  return `transition "${w.transitionName}" on "${w.workflow}:${w.state}"`;
+}
+function idFor(doc, workflowName, _kind) {
+  if (!doc) return {};
+  const id = doc.meta.ids.workflows[workflowName];
+  return id ? { targetId: id } : {};
+}
+
+// src/validate/schema.ts
+function zodErrorToIssues(err) {
+  return err.issues.map((issue) => ({
+    severity: "error",
+    code: `schema-${issue.code}`,
+    message: issue.message,
+    detail: {
+      path: issue.path
+    }
+  }));
+}
+
+// src/parse/parse-import.ts
+function parseJsonSafe(json) {
+  try {
+    return { ok: true, value: JSON.parse(json) };
+  } catch (e) {
+    return { ok: false, err: e.message };
+  }
+}
+function parseImportPayload(json, prior) {
+  const parsed = parseJsonSafe(json);
+  if (!parsed.ok) {
+    throw new ParseJsonError(`Invalid JSON: ${parsed.err}`);
+  }
+  let aliased;
+  try {
+    aliased = normalizeOperatorAlias(parsed.value);
+  } catch (e) {
+    return {
+      ok: false,
+      issues: [
+        {
+          severity: "error",
+          code: "operator-alias-conflict",
+          message: e.message
+        }
+      ]
+    };
+  }
+  const schemaResult = ImportPayloadSchema.safeParse(aliased);
+  if (!schemaResult.success) {
+    return { ok: false, issues: zodErrorToIssues(schemaResult.error) };
+  }
+  const normalizedWorkflows = schemaResult.data.workflows.map(normalizeWorkflowInput);
+  const session = {
+    entity: null,
+    importMode: schemaResult.data.importMode,
+    workflows: normalizedWorkflows
+  };
+  const meta = assignSyntheticIds(session, prior);
+  const document = { session, meta };
+  const issues = validateSemantics(session, document);
+  const hasError = issues.some((i) => i.severity === "error");
+  return {
+    ok: !hasError,
+    value: { importMode: session.importMode, workflows: session.workflows },
+    document,
+    issues
+  };
+}
+
+// src/parse/parse-export.ts
+function parseExportPayload(json, prior) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    throw new ParseJsonError(`Invalid JSON: ${e.message}`);
+  }
+  let aliased;
+  try {
+    aliased = normalizeOperatorAlias(parsed);
+  } catch (e) {
+    return {
+      ok: false,
+      issues: [
+        {
+          severity: "error",
+          code: "operator-alias-conflict",
+          message: e.message
+        }
+      ]
+    };
+  }
+  const schemaResult = ExportPayloadSchema.safeParse(aliased);
+  if (!schemaResult.success) {
+    return { ok: false, issues: zodErrorToIssues(schemaResult.error) };
+  }
+  const normalizedWorkflows = schemaResult.data.workflows.map(normalizeWorkflowInput);
+  const session = {
+    entity: {
+      entityName: schemaResult.data.entityName,
+      modelVersion: schemaResult.data.modelVersion
+    },
+    importMode: "MERGE",
+    workflows: normalizedWorkflows
+  };
+  const meta = assignSyntheticIds(session, prior);
+  const document = { session, meta };
+  const issues = validateSemantics(session, document);
+  const hasError = issues.some((i) => i.severity === "error");
+  return {
+    ok: !hasError,
+    value: {
+      entityName: schemaResult.data.entityName,
+      modelVersion: schemaResult.data.modelVersion,
+      workflows: session.workflows
+    },
+    document,
+    issues
+  };
+}
+
+// src/parse/parse-editor-document.ts
+var import_zod7 = require("zod");
+var EditorDocumentSchema = import_zod7.z.object({
+  session: import_zod7.z.object({
+    entity: import_zod7.z.object({
+      entityName: import_zod7.z.string(),
+      modelVersion: import_zod7.z.number().int().positive()
+    }).nullable(),
+    importMode: import_zod7.z.enum(["MERGE", "REPLACE", "ACTIVATE"]),
+    workflows: import_zod7.z.array(import_zod7.z.unknown())
+  }),
+  meta: import_zod7.z.object({
+    revision: import_zod7.z.number().int().nonnegative(),
+    ids: import_zod7.z.unknown(),
+    workflowUi: import_zod7.z.record(import_zod7.z.unknown()),
+    lastValidJsonHash: import_zod7.z.string().optional()
+  }).passthrough()
+});
+function parseEditorDocument(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    throw new ParseJsonError(`Invalid JSON: ${e.message}`);
+  }
+  const outerResult = EditorDocumentSchema.safeParse(parsed);
+  if (!outerResult.success) {
+    return { ok: false, issues: zodErrorToIssues(outerResult.error) };
+  }
+  const aliased = normalizeOperatorAlias(outerResult.data.session);
+  const inner = ImportPayloadSchema.omit({ importMode: true }).extend({
+    importMode: import_zod7.z.enum(["MERGE", "REPLACE", "ACTIVATE"])
+  });
+  const sessionResult = inner.safeParse({
+    importMode: outerResult.data.session.importMode,
+    workflows: aliased.workflows
+  });
+  if (!sessionResult.success) {
+    return { ok: false, issues: zodErrorToIssues(sessionResult.error) };
+  }
+  const normalizedWorkflows = sessionResult.data.workflows.map(normalizeWorkflowInput);
+  const session = {
+    entity: outerResult.data.session.entity,
+    importMode: sessionResult.data.importMode,
+    workflows: normalizedWorkflows
+  };
+  const meta = assignSyntheticIds(
+    session,
+    outerResult.data.meta
+  );
+  const document = { session, meta };
+  const issues = validateSemantics(session, document);
+  const hasError = issues.some((i) => i.severity === "error");
+  return { ok: !hasError, document, value: document, issues };
+}
+
+// src/normalize/output.ts
+function outputWorkflow(w) {
+  const out = {
+    version: w.version,
+    name: w.name
+  };
+  if (w.desc !== void 0) out["desc"] = w.desc;
+  out["initialState"] = w.initialState;
+  out["active"] = w.active;
+  if (w.criterion !== void 0) out["criterion"] = outputCriterion(w.criterion);
+  out["states"] = outputStates(w.states);
+  return out;
+}
+function outputStates(states) {
+  const out = {};
+  for (const [code, state] of Object.entries(states)) {
+    out[code] = { transitions: state.transitions.map(outputTransition) };
+  }
+  return out;
+}
+function outputTransition(t) {
+  const out = {
+    name: t.name,
+    next: t.next,
+    manual: t.manual,
+    disabled: t.disabled
+  };
+  if (t.criterion !== void 0) out["criterion"] = outputCriterion(t.criterion);
+  if (t.processors !== void 0 && t.processors.length > 0) {
+    out["processors"] = t.processors.map(outputProcessor);
+  }
+  return out;
+}
+function outputCriterion(c) {
+  switch (c.type) {
+    case "simple": {
+      const out = {
+        type: "simple",
+        jsonPath: c.jsonPath,
+        operation: c.operation
+      };
+      if (c.value !== void 0) out["value"] = c.value;
+      return out;
+    }
+    case "group":
+      return {
+        type: "group",
+        operator: c.operator,
+        conditions: c.conditions.map(outputCriterion)
+      };
+    case "function": {
+      const fn = { name: c.function.name };
+      if (c.function.config !== void 0) {
+        const config = outputFunctionConfig(c.function.config);
+        if (Object.keys(config).length > 0) fn["config"] = config;
+      }
+      if (c.function.criterion !== void 0) {
+        fn["criterion"] = outputCriterion(c.function.criterion);
+      }
+      return { type: "function", function: fn };
+    }
+    case "lifecycle": {
+      const out = {
+        type: "lifecycle",
+        field: c.field,
+        operation: c.operation
+      };
+      if (c.value !== void 0) out["value"] = c.value;
+      return out;
+    }
+    case "array":
+      return {
+        type: "array",
+        jsonPath: c.jsonPath,
+        operation: c.operation,
+        value: c.value
+      };
+  }
+}
+function outputProcessor(p) {
+  if (p.type === "externalized") return outputExternalizedProcessor(p);
+  return {
+    type: "scheduled",
+    name: p.name,
+    config: outputScheduledConfig(p.config)
+  };
+}
+function outputScheduledConfig(cfg) {
+  const out = {
+    delayMs: cfg.delayMs,
+    transition: cfg.transition
+  };
+  if (cfg.timeoutMs !== void 0) out["timeoutMs"] = cfg.timeoutMs;
+  return out;
+}
+function outputExternalizedProcessor(p) {
+  const out = {
+    type: "externalized",
+    name: p.name
+  };
+  if (p.executionMode !== void 0 && p.executionMode !== "ASYNC_NEW_TX") {
+    out["executionMode"] = p.executionMode;
+  }
+  if (p.config !== void 0) {
+    const cfg = outputExternalizedConfig(p.config);
+    if (Object.keys(cfg).length > 0) out["config"] = cfg;
+  }
+  return out;
+}
+function outputExternalizedConfig(cfg) {
+  const out = {};
+  if (cfg.attachEntity === true) out["attachEntity"] = true;
+  if (cfg.calculationNodesTags !== void 0 && cfg.calculationNodesTags !== "") {
+    out["calculationNodesTags"] = cfg.calculationNodesTags;
+  }
+  if (cfg.responseTimeoutMs !== void 0) out["responseTimeoutMs"] = cfg.responseTimeoutMs;
+  if (cfg.retryPolicy !== void 0 && cfg.retryPolicy !== "") {
+    out["retryPolicy"] = cfg.retryPolicy;
+  }
+  if (cfg.context !== void 0 && cfg.context !== "") out["context"] = cfg.context;
+  if (cfg.asyncResult === true) out["asyncResult"] = true;
+  if (cfg.asyncResult === true && cfg.crossoverToAsyncMs !== void 0) {
+    out["crossoverToAsyncMs"] = cfg.crossoverToAsyncMs;
+  }
+  return out;
+}
+function outputFunctionConfig(cfg) {
+  const c = cfg;
+  const out = {};
+  if (c.attachEntity === true) out["attachEntity"] = true;
+  if (c.calculationNodesTags !== void 0 && c.calculationNodesTags !== "") {
+    out["calculationNodesTags"] = c.calculationNodesTags;
+  }
+  if (c.responseTimeoutMs !== void 0) out["responseTimeoutMs"] = c.responseTimeoutMs;
+  if (c.retryPolicy !== void 0 && c.retryPolicy !== "") out["retryPolicy"] = c.retryPolicy;
+  if (c.context !== void 0 && c.context !== "") out["context"] = c.context;
+  return out;
+}
+
+// src/serialize/stringify.ts
+function prettyStringify(value) {
+  const body = JSON.stringify(value, null, 2);
+  const lfOnly = body.replace(/\r\n/g, "\n");
+  return lfOnly + "\n";
+}
+
+// src/serialize/payload.ts
+function serializeImportPayload(doc) {
+  const payload = {
+    importMode: doc.session.importMode,
+    workflows: doc.session.workflows.map(outputWorkflow)
+  };
+  return prettyStringify(payload);
+}
+function serializeExportPayload(doc, entity) {
+  const e = entity ?? doc.session.entity;
+  if (e == null) {
+    throw new Error("serializeExportPayload requires an entity identity");
+  }
+  const payload = {
+    entityName: e.entityName,
+    modelVersion: e.modelVersion,
+    workflows: doc.session.workflows.map(outputWorkflow)
+  };
+  return prettyStringify(payload);
+}
+function serializeEditorDocument(doc) {
+  return prettyStringify({
+    session: {
+      entity: doc.session.entity,
+      importMode: doc.session.importMode,
+      workflows: doc.session.workflows.map(outputWorkflow)
+    },
+    meta: doc.meta
+  });
+}
+
+// src/identity/lookup.ts
+function lookupById(doc, uuid) {
+  const { ids } = doc.meta;
+  const session = doc.session;
+  for (const [name, wfUuid] of Object.entries(ids.workflows)) {
+    if (wfUuid === uuid) {
+      const workflow = session.workflows.find((w) => w.name === name);
+      if (workflow) return { kind: "workflow", workflow };
+    }
+  }
+  const statePtr = ids.states[uuid];
+  if (statePtr) {
+    const workflow = session.workflows.find((w) => w.name === statePtr.workflow);
+    if (!workflow) return null;
+    const state = workflow.states[statePtr.state];
+    if (!state) return null;
+    return { kind: "state", workflow, state, stateCode: statePtr.state };
+  }
+  const tPtr = ids.transitions[uuid];
+  if (tPtr) {
+    const workflow = session.workflows.find((w) => w.name === tPtr.workflow);
+    if (!workflow) return null;
+    const state = workflow.states[tPtr.state];
+    if (!state) return null;
+    const transition = findTransitionByUuid(doc, tPtr.workflow, tPtr.state, uuid);
+    if (!transition) return null;
+    return { kind: "transition", workflow, state, transition };
+  }
+  const pPtr = ids.processors[uuid];
+  if (pPtr) {
+    const transition = findTransitionByUuid(
+      doc,
+      pPtr.workflow,
+      pPtr.state,
+      pPtr.transitionUuid
+    );
+    if (!transition) return null;
+    const processor = findProcessorByUuid(doc, uuid);
+    if (!processor) return null;
+    return { kind: "processor", transition, processor };
+  }
+  const cPtr = ids.criteria[uuid];
+  if (cPtr) {
+    const host = resolveHost(doc, cPtr.host);
+    if (host === null) return null;
+    const criterion = walkPath(host, cPtr.path);
+    if (!criterion) return null;
+    return {
+      kind: "criterion",
+      criterion,
+      parent: { host: cPtr.host, path: cPtr.path }
+    };
+  }
+  return null;
+}
+function findTransitionByUuid(doc, workflowName, stateCode, transitionUuid) {
+  const workflow = doc.session.workflows.find((w) => w.name === workflowName);
+  if (!workflow) return null;
+  const state = workflow.states[stateCode];
+  if (!state) return null;
+  const orderedUuids = listTransitionUuidsForState(doc, workflowName, stateCode);
+  const idx = orderedUuids.indexOf(transitionUuid);
+  if (idx < 0) return null;
+  return state.transitions[idx] ?? null;
+}
+function listTransitionUuidsForState(doc, workflowName, stateCode) {
+  const out = [];
+  for (const [uuid, ptr] of Object.entries(doc.meta.ids.transitions)) {
+    if (ptr.workflow === workflowName && ptr.state === stateCode) {
+      out.push(uuid);
+    }
+  }
+  return out;
+}
+function findProcessorByUuid(doc, processorUuid) {
+  const ptr = doc.meta.ids.processors[processorUuid];
+  if (!ptr) return null;
+  const transition = findTransitionByUuid(
+    doc,
+    ptr.workflow,
+    ptr.state,
+    ptr.transitionUuid
+  );
+  if (!transition || !transition.processors) return null;
+  const orderedUuids = [];
+  for (const [uuid, pPtr] of Object.entries(doc.meta.ids.processors)) {
+    if (pPtr.transitionUuid === ptr.transitionUuid) orderedUuids.push(uuid);
+  }
+  const idx = orderedUuids.indexOf(processorUuid);
+  if (idx < 0) return null;
+  return transition.processors[idx] ?? null;
+}
+function resolveHost(doc, host) {
+  const workflow = doc.session.workflows.find((w) => w.name === host.workflow);
+  if (!workflow) return null;
+  if (host.kind === "workflow") return workflow;
+  if (host.kind === "transition") {
+    const state = workflow.states[host.state];
+    if (!state) return null;
+    return findTransitionByUuid(doc, host.workflow, host.state, host.transitionUuid);
+  }
+  return null;
+}
+function walkPath(root, path) {
+  let node = root;
+  for (const segment of path) {
+    if (node == null || typeof node !== "object") return null;
+    node = node[segment];
+    if (node == null) return null;
+    if (Array.isArray(node)) continue;
+  }
+  if (!node || typeof node !== "object") return null;
+  const maybe = node;
+  if (maybe.type === "simple" || maybe.type === "group" || maybe.type === "function" || maybe.type === "lifecycle" || maybe.type === "array") {
+    return node;
+  }
+  return null;
+}
+
+// src/identity/id-for.ts
+function idFor2(meta, ref) {
+  switch (ref.kind) {
+    case "workflow":
+      return meta.ids.workflows[ref.workflow] ?? null;
+    case "state": {
+      for (const [uuid, ptr] of Object.entries(meta.ids.states)) {
+        if (ptr.workflow === ref.workflow && ptr.state === ref.state) return uuid;
+      }
+      return null;
+    }
+    case "transition": {
+      const matches = [];
+      for (const [uuid, ptr] of Object.entries(meta.ids.transitions)) {
+        if (ptr.workflow === ref.workflow && ptr.state === ref.state) {
+          matches.push(uuid);
+        }
+      }
+      return matches[ref.ordinal] ?? null;
+    }
+    case "processor": {
+      const matches = [];
+      for (const [uuid, ptr] of Object.entries(meta.ids.processors)) {
+        if (ptr.transitionUuid === ref.transitionUuid) matches.push(uuid);
+      }
+      return matches[ref.ordinal] ?? null;
+    }
+    case "criterion": {
+      const target = JSON.stringify(ref.path);
+      for (const [uuid, ptr] of Object.entries(meta.ids.criteria)) {
+        if (JSON.stringify(ptr.host) === JSON.stringify(ref.host) && JSON.stringify(ptr.path) === target) {
+          return uuid;
+        }
+      }
+      return null;
+    }
+  }
+}
+
+// src/validate/index.ts
+function validateImportSchema(raw) {
+  const parsed = ImportPayloadSchema.safeParse(raw);
+  return parsed.success ? [] : zodErrorToIssues(parsed.error);
+}
+function validateExportSchema(raw) {
+  const parsed = ExportPayloadSchema.safeParse(raw);
+  return parsed.success ? [] : zodErrorToIssues(parsed.error);
+}
+function validateAll(doc) {
+  return validateSemantics(doc.session, doc);
+}
+function validateSession(session) {
+  return validateSemantics(session);
+}
+
+// src/patch/apply.ts
+var import_immer = require("immer");
+function applyPatch(doc, patch) {
+  if (patch.op === "setEdgeAnchors") {
+    return applySetEdgeAnchors(doc, patch);
+  }
+  const nextSession = (0, import_immer.produce)(doc.session, (d) => {
+    const draft = d;
+    switch (patch.op) {
+      case "addWorkflow":
+        draft.workflows.push(patch.workflow);
+        return;
+      case "removeWorkflow":
+        draft.workflows = draft.workflows.filter((w) => w.name !== patch.workflow);
+        return;
+      case "updateWorkflowMeta": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        Object.assign(wf, patch.updates);
+        return;
+      }
+      case "renameWorkflow": {
+        const wf = draft.workflows.find((w) => w.name === patch.from);
+        if (!wf) return;
+        wf.name = patch.to;
+        return;
+      }
+      case "setInitialState": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        wf.initialState = patch.stateCode;
+        return;
+      }
+      case "setWorkflowCriterion": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        if (patch.criterion === void 0) delete wf.criterion;
+        else wf.criterion = patch.criterion;
+        return;
+      }
+      case "addState": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        if (!(patch.stateCode in wf.states)) {
+          wf.states[patch.stateCode] = { transitions: [] };
+        }
+        return;
+      }
+      case "renameState": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        renameStateCascading(wf, patch.from, patch.to);
+        return;
+      }
+      case "removeState": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        removeStateCascading(wf, patch.stateCode);
+        return;
+      }
+      case "addTransition": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        if (!wf) return;
+        const state = wf.states[patch.fromState];
+        if (!state) return;
+        state.transitions.push(patch.transition);
+        return;
+      }
+      case "updateTransition": {
+        const loc = locateTransition(doc, patch.transitionUuid);
+        if (!loc) return;
+        const wf = draft.workflows.find((w) => w.name === loc.workflow);
+        const state = wf?.states[loc.state];
+        const transition = state?.transitions[loc.index];
+        if (!transition) return;
+        Object.assign(transition, patch.updates);
+        return;
+      }
+      case "removeTransition": {
+        const loc = locateTransition(doc, patch.transitionUuid);
+        if (!loc) return;
+        const wf = draft.workflows.find((w) => w.name === loc.workflow);
+        const state = wf?.states[loc.state];
+        if (!state) return;
+        state.transitions.splice(loc.index, 1);
+        return;
+      }
+      case "reorderTransition": {
+        const wf = draft.workflows.find((w) => w.name === patch.workflow);
+        const state = wf?.states[patch.fromState];
+        if (!state) return;
+        const loc = locateTransition(doc, patch.transitionUuid);
+        if (!loc) return;
+        const [item] = state.transitions.splice(loc.index, 1);
+        if (!item) return;
+        state.transitions.splice(patch.toIndex, 0, item);
+        return;
+      }
+      case "addProcessor": {
+        const loc = locateTransition(doc, patch.transitionUuid);
+        if (!loc) return;
+        const wf = draft.workflows.find((w) => w.name === loc.workflow);
+        const state = wf?.states[loc.state];
+        const transition = state?.transitions[loc.index];
+        if (!transition) return;
+        if (!transition.processors) transition.processors = [];
+        const idx = patch.index ?? transition.processors.length;
+        transition.processors.splice(idx, 0, patch.processor);
+        return;
+      }
+      case "updateProcessor": {
+        const procLoc = locateProcessor(doc, patch.processorUuid);
+        if (!procLoc) return;
+        const wf = draft.workflows.find((w) => w.name === procLoc.workflow);
+        const state = wf?.states[procLoc.state];
+        const transition = state?.transitions[procLoc.transitionIndex];
+        const processor = transition?.processors?.[procLoc.processorIndex];
+        if (!processor) return;
+        Object.assign(processor, patch.updates);
+        return;
+      }
+      case "removeProcessor": {
+        const procLoc = locateProcessor(doc, patch.processorUuid);
+        if (!procLoc) return;
+        const wf = draft.workflows.find((w) => w.name === procLoc.workflow);
+        const state = wf?.states[procLoc.state];
+        const transition = state?.transitions[procLoc.transitionIndex];
+        if (!transition?.processors) return;
+        transition.processors.splice(procLoc.processorIndex, 1);
+        if (transition.processors.length === 0) delete transition.processors;
+        return;
+      }
+      case "reorderProcessor": {
+        const procLoc = locateProcessor(doc, patch.processorUuid);
+        if (!procLoc) return;
+        const wf = draft.workflows.find((w) => w.name === procLoc.workflow);
+        const state = wf?.states[procLoc.state];
+        const transition = state?.transitions[procLoc.transitionIndex];
+        if (!transition?.processors) return;
+        const [item] = transition.processors.splice(procLoc.processorIndex, 1);
+        if (!item) return;
+        transition.processors.splice(patch.toIndex, 0, item);
+        return;
+      }
+      case "setCriterion": {
+        const host = patch.host;
+        const wf = draft.workflows.find((w) => w.name === host.workflow);
+        if (!wf) return;
+        let container;
+        if (host.kind === "workflow") container = wf;
+        else if (host.kind === "transition") {
+          const state = wf.states[host.state];
+          if (!state) return;
+          const loc = locateTransition(doc, host.transitionUuid);
+          if (!loc) return;
+          container = state.transitions[loc.index];
+        } else {
+          return;
+        }
+        applyCriterionAtPath(
+          container,
+          patch.path,
+          patch.criterion
+        );
+        return;
+      }
+      case "setImportMode":
+        draft.importMode = patch.mode;
+        return;
+      case "setEntity":
+        draft.entity = patch.entity;
+        return;
+      case "replaceSession":
+        draft.workflows = patch.session.workflows;
+        draft.importMode = patch.session.importMode;
+        draft.entity = patch.session.entity;
+        return;
+    }
+  });
+  const nextMeta = assignSyntheticIds(nextSession, doc.meta);
+  return {
+    session: nextSession,
+    meta: { ...nextMeta, revision: doc.meta.revision + 1 }
+  };
+}
+function applyPatches(doc, patches) {
+  return patches.reduce((d, p) => applyPatch(d, p), doc);
+}
+function validateAfterPatch(doc) {
+  return validateSemantics(doc.session, doc);
+}
+function applySetEdgeAnchors(doc, patch) {
+  const ptr = doc.meta.ids.transitions[patch.transitionUuid];
+  if (!ptr) return { ...doc, meta: { ...doc.meta, revision: doc.meta.revision + 1 } };
+  const workflowUi = { ...doc.meta.workflowUi };
+  const current = workflowUi[ptr.workflow] ?? {};
+  const edgeAnchors = { ...current.edgeAnchors ?? {} };
+  if (patch.anchors === null) {
+    delete edgeAnchors[patch.transitionUuid];
+  } else {
+    edgeAnchors[patch.transitionUuid] = { ...patch.anchors };
+  }
+  workflowUi[ptr.workflow] = {
+    ...current,
+    edgeAnchors: Object.keys(edgeAnchors).length > 0 ? edgeAnchors : void 0
+  };
+  return {
+    session: doc.session,
+    meta: {
+      ...doc.meta,
+      workflowUi,
+      revision: doc.meta.revision + 1
+    }
+  };
+}
+function renameStateCascading(wf, from, to) {
+  if (!(from in wf.states) || from === to) return;
+  wf.states[to] = wf.states[from];
+  delete wf.states[from];
+  for (const state of Object.values(wf.states)) {
+    for (const t of state.transitions) {
+      if (t.next === from) t.next = to;
+    }
+  }
+  if (wf.initialState === from) wf.initialState = to;
+}
+function removeStateCascading(wf, stateCode) {
+  if (!(stateCode in wf.states)) return;
+  delete wf.states[stateCode];
+  for (const state of Object.values(wf.states)) {
+    state.transitions = state.transitions.filter((t) => t.next !== stateCode);
+  }
+  if (wf.initialState === stateCode) wf.initialState = "";
+}
+function locateTransition(doc, transitionUuid) {
+  const ptr = doc.meta.ids.transitions[transitionUuid];
+  if (!ptr) return null;
+  const ordered = [];
+  for (const [uuid, p] of Object.entries(doc.meta.ids.transitions)) {
+    if (p.workflow === ptr.workflow && p.state === ptr.state) ordered.push(uuid);
+  }
+  const idx = ordered.indexOf(transitionUuid);
+  if (idx < 0) return null;
+  return { workflow: ptr.workflow, state: ptr.state, index: idx };
+}
+function locateProcessor(doc, processorUuid) {
+  const ptr = doc.meta.ids.processors[processorUuid];
+  if (!ptr) return null;
+  const tLoc = locateTransition(doc, ptr.transitionUuid);
+  if (!tLoc) return null;
+  const ordered = [];
+  for (const [uuid, p] of Object.entries(doc.meta.ids.processors)) {
+    if (p.transitionUuid === ptr.transitionUuid) ordered.push(uuid);
+  }
+  const pIdx = ordered.indexOf(processorUuid);
+  if (pIdx < 0) return null;
+  return {
+    workflow: tLoc.workflow,
+    state: tLoc.state,
+    transitionIndex: tLoc.index,
+    processorIndex: pIdx
+  };
+}
+function applyCriterionAtPath(container, path, criterion) {
+  if (path.length === 0) return;
+  let node = container;
+  for (let i = 0; i < path.length - 1; i++) {
+    const seg = path[i];
+    const next = node[seg];
+    if (next === void 0 || next === null) return;
+    if (Array.isArray(next)) {
+      const idx = Number(path[i + 1]);
+      const arr = next;
+      const target = arr[idx];
+      if (target === void 0 || typeof target !== "object") return;
+      node = target;
+      i++;
+    } else if (typeof next === "object") {
+      node = next;
+    } else {
+      return;
+    }
+  }
+  const lastSeg = path[path.length - 1];
+  if (criterion === void 0) {
+    delete node[lastSeg];
+  } else {
+    node[lastSeg] = criterion;
+  }
+}
+
+// src/patch/invert.ts
+function invertPatch(doc, patch) {
+  switch (patch.op) {
+    case "addWorkflow":
+      return { op: "removeWorkflow", workflow: patch.workflow.name };
+    case "removeWorkflow":
+    case "renameWorkflow":
+    case "removeState":
+    case "renameState":
+    case "replaceSession":
+      return { op: "replaceSession", session: cloneSession(doc) };
+    case "updateWorkflowMeta": {
+      const wf = findWorkflow(doc, patch.workflow);
+      if (!wf) return noop();
+      const prior = {};
+      for (const key of Object.keys(patch.updates)) {
+        prior[key] = wf[key];
+      }
+      return { op: "updateWorkflowMeta", workflow: patch.workflow, updates: prior };
+    }
+    case "setInitialState": {
+      const wf = findWorkflow(doc, patch.workflow);
+      if (!wf) return noop();
+      return {
+        op: "setInitialState",
+        workflow: patch.workflow,
+        stateCode: wf.initialState
+      };
+    }
+    case "setWorkflowCriterion": {
+      const wf = findWorkflow(doc, patch.workflow);
+      if (!wf) return noop();
+      return wf.criterion ? {
+        op: "setWorkflowCriterion",
+        workflow: patch.workflow,
+        criterion: cloneCriterion(wf.criterion)
+      } : { op: "setWorkflowCriterion", workflow: patch.workflow };
+    }
+    case "addState":
+      return {
+        op: "removeState",
+        workflow: patch.workflow,
+        stateCode: patch.stateCode
+      };
+    case "addTransition": {
+      return { op: "replaceSession", session: cloneSession(doc) };
+    }
+    case "updateTransition": {
+      const t = findTransition(doc, patch.transitionUuid);
+      if (!t) return noop();
+      const prior = {};
+      for (const key of Object.keys(patch.updates)) {
+        prior[key] = t[key];
+      }
+      return {
+        op: "updateTransition",
+        transitionUuid: patch.transitionUuid,
+        updates: prior
+      };
+    }
+    case "removeTransition":
+    case "reorderTransition":
+      return { op: "replaceSession", session: cloneSession(doc) };
+    case "addProcessor":
+      return { op: "replaceSession", session: cloneSession(doc) };
+    case "updateProcessor": {
+      const p = findProcessor(doc, patch.processorUuid);
+      if (!p) return noop();
+      const prior = {};
+      for (const key of Object.keys(patch.updates)) {
+        prior[key] = p[key];
+      }
+      return {
+        op: "updateProcessor",
+        processorUuid: patch.processorUuid,
+        updates: prior
+      };
+    }
+    case "removeProcessor":
+    case "reorderProcessor":
+      return { op: "replaceSession", session: cloneSession(doc) };
+    case "setCriterion": {
+      const prior = readCriterionAt(doc, patch.host, patch.path);
+      return prior === void 0 ? { op: "setCriterion", host: patch.host, path: patch.path } : {
+        op: "setCriterion",
+        host: patch.host,
+        path: patch.path,
+        criterion: cloneCriterion(prior)
+      };
+    }
+    case "setImportMode":
+      return { op: "setImportMode", mode: doc.session.importMode };
+    case "setEntity":
+      return { op: "setEntity", entity: doc.session.entity };
+    case "setEdgeAnchors": {
+      const ptr = doc.meta.ids.transitions[patch.transitionUuid];
+      if (!ptr) return noop();
+      const prior = doc.meta.workflowUi[ptr.workflow]?.edgeAnchors?.[patch.transitionUuid];
+      return {
+        op: "setEdgeAnchors",
+        transitionUuid: patch.transitionUuid,
+        anchors: prior ? { ...prior } : null
+      };
+    }
+  }
+}
+function noop() {
+  return { op: "setImportMode", mode: "MERGE" };
+}
+function findWorkflow(doc, name) {
+  return doc.session.workflows.find((w) => w.name === name);
+}
+function findTransition(doc, transitionUuid) {
+  const ptr = doc.meta.ids.transitions[transitionUuid];
+  if (!ptr) return void 0;
+  const wf = findWorkflow(doc, ptr.workflow);
+  const state = wf?.states[ptr.state];
+  if (!state) return void 0;
+  const ordered = [];
+  for (const [uuid, p] of Object.entries(doc.meta.ids.transitions)) {
+    if (p.workflow === ptr.workflow && p.state === ptr.state) ordered.push(uuid);
+  }
+  const idx = ordered.indexOf(transitionUuid);
+  return state.transitions[idx];
+}
+function findProcessor(doc, processorUuid) {
+  const ptr = doc.meta.ids.processors[processorUuid];
+  if (!ptr) return void 0;
+  const t = findTransition(doc, ptr.transitionUuid);
+  if (!t?.processors) return void 0;
+  const ordered = [];
+  for (const [uuid, p] of Object.entries(doc.meta.ids.processors)) {
+    if (p.transitionUuid === ptr.transitionUuid) ordered.push(uuid);
+  }
+  const idx = ordered.indexOf(processorUuid);
+  return t.processors[idx];
+}
+function readCriterionAt(doc, host, path) {
+  const wf = findWorkflow(doc, host.workflow);
+  if (!wf) return void 0;
+  let container;
+  if (host.kind === "workflow") {
+    container = wf;
+  } else if (host.kind === "transition" && host.transitionUuid) {
+    const t = findTransition(doc, host.transitionUuid);
+    if (!t) return void 0;
+    container = t;
+  } else {
+    return void 0;
+  }
+  let node = container;
+  for (const seg of path) {
+    if (node === null || node === void 0) return void 0;
+    if (Array.isArray(node)) {
+      node = node[Number(seg)];
+    } else if (typeof node === "object") {
+      node = node[seg];
+    } else {
+      return void 0;
+    }
+  }
+  return node;
+}
+function cloneSession(doc) {
+  return structuredClone(doc.session);
+}
+function cloneCriterion(c) {
+  return structuredClone(c);
+}
+
+// src/migrate/registry.ts
+var registry = [];
+function registerMigration(entry) {
+  const dup = registry.find((e) => e.from === entry.from && e.to === entry.to);
+  if (dup) return;
+  registry.push(entry);
+}
+function listMigrations() {
+  return registry;
+}
+function findMigrationPath(from, to) {
+  if (from === to) return [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [
+    { version: from, path: [] }
+  ];
+  while (queue.length > 0) {
+    const head = queue.shift();
+    if (head.version === to) return head.path;
+    if (visited.has(head.version)) continue;
+    visited.add(head.version);
+    for (const entry of registry) {
+      if (entry.from === head.version) {
+        queue.push({ version: entry.to, path: [...head.path, entry] });
+      }
+    }
+  }
+  return null;
+}
+function migrateSession(session, from, to) {
+  const path = findMigrationPath(from, to);
+  if (!path) {
+    throw new Error(`No migration path from ${from} to ${to}`);
+  }
+  return path.reduce((s, entry) => entry.migrate(s), session);
+}
+registerMigration({ from: "1.0", to: "1.0", migrate: (s) => s });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayCriterionSchema,
+  CriterionSchema,
+  ExecutionModeSchema,
+  ExportPayloadSchema,
+  ExternalizedProcessorSchema,
+  FunctionConfigSchema,
+  FunctionCriterionSchema,
+  GroupCriterionSchema,
+  ImportPayloadSchema,
+  LifecycleCriterionSchema,
+  NAME_REGEX,
+  NameSchema,
+  OPERATOR_TYPES,
+  OperatorEnum,
+  ParseJsonError,
+  ProcessorSchema,
+  ScheduledProcessorSchema,
+  SchemaError,
+  SimpleCriterionSchema,
+  StateSchema,
+  TransitionSchema,
+  WorkflowApiConflictError,
+  WorkflowApiTransportError,
+  WorkflowSchema,
+  applyPatch,
+  applyPatches,
+  assignSyntheticIds,
+  findMigrationPath,
+  idFor,
+  invertPatch,
+  listMigrations,
+  lookupById,
+  migrateSession,
+  mintCriterionIds,
+  normalizeCriterion,
+  normalizeOperatorAlias,
+  normalizeProcessor,
+  normalizeWorkflowInput,
+  outputCriterion,
+  outputFunctionConfig,
+  outputProcessor,
+  outputTransition,
+  outputWorkflow,
+  parseEditorDocument,
+  parseExportPayload,
+  parseImportPayload,
+  prettyStringify,
+  registerMigration,
+  serializeEditorDocument,
+  serializeExportPayload,
+  serializeImportPayload,
+  validateAfterPatch,
+  validateAll,
+  validateExportSchema,
+  validateImportSchema,
+  validateSemantics,
+  validateSession,
+  zodErrorToIssues
+});
+//# sourceMappingURL=index.cjs.map