agentic-workflow-architecture 1.0.0

package/dist/index.js

@@ -0,0 +1,3070 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccessDirection: () => AccessDirection,
+  AccessMode: () => AccessMode,
+  AccessRightQuery: () => AccessRightQuery,
+  AccessRightSchema: () => AccessRightSchema,
+  ActivityQuery: () => ActivityQuery,
+  ActivitySchema: () => ActivitySchema,
+  ActorType: () => ActorType,
+  AnalyticsSchema: () => AnalyticsSchema,
+  AnimationConfigSchema: () => AnimationConfigSchema,
+  AnimationEasing: () => AnimationEasing,
+  AutoLayoutConfigSchema: () => AutoLayoutConfigSchema,
+  CameraSettings2DSchema: () => CameraSettings2DSchema,
+  CameraSettings3DSchema: () => CameraSettings3DSchema,
+  CameraType: () => CameraType,
+  CheckpointManager: () => CheckpointManager,
+  CollectionSchema: () => CollectionSchema,
+  ColorSchema: () => ColorSchema,
+  ContextBindingQuery: () => ContextBindingQuery,
+  ContextBindingSchema: () => ContextBindingSchema,
+  ContextManager: () => ContextManager,
+  ContextQuery: () => ContextQuery,
+  ContextSchema: () => ContextSchema,
+  ContextType: () => ContextType,
+  ControlSchema: () => ControlSchema,
+  ControlType: () => ControlType,
+  CurveType: () => CurveType,
+  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
+  DataObjectSchema: () => DataObjectSchema,
+  DateTimeTz: () => DateTimeTz,
+  DeadLetterQueue: () => DeadLetterQueue,
+  DecisionEvaluator: () => DecisionEvaluator,
+  DecisionNodeSchema: () => DecisionNodeSchema,
+  DecisionRuleSchema: () => DecisionRuleSchema,
+  DecisionTableSchema: () => DecisionTableSchema,
+  Duration: () => Duration,
+  EdgeRoutingSchema: () => EdgeRoutingSchema,
+  EdgeSchema: () => EdgeSchema,
+  EdgeStyleSchema: () => EdgeStyleSchema,
+  EndpointSchema: () => EndpointSchema,
+  Enforcement: () => Enforcement,
+  EventSchema: () => EventSchema,
+  FilePersistenceAdapter: () => FilePersistenceAdapter,
+  HitPolicy: () => HitPolicy,
+  HumanAgent: () => HumanAgent,
+  HumanTaskPriority: () => HumanTaskPriority,
+  HumanTaskSchema: () => HumanTaskSchema,
+  HumanTaskStatus: () => HumanTaskStatus,
+  InMemoryPersistenceAdapter: () => InMemoryPersistenceAdapter,
+  LaneOrientation: () => LaneOrientation,
+  LaneSchema: () => LaneSchema,
+  LayoutAlgorithm: () => LayoutAlgorithm,
+  LayoutDirection: () => LayoutDirection,
+  Lifecycle: () => Lifecycle,
+  MachineSchema: () => MachineSchema,
+  NodeMaterial3DSchema: () => NodeMaterial3DSchema,
+  NodePosition2DSchema: () => NodePosition2DSchema,
+  NodePosition3DSchema: () => NodePosition3DSchema,
+  NodeShape: () => NodeShape,
+  NodeStyle2DSchema: () => NodeStyle2DSchema,
+  NodeType: () => NodeType,
+  ParameterSchema: () => ParameterSchema,
+  Permission: () => Permission,
+  ProgramSchema: () => ProgramSchema,
+  QuaternionSchema: () => QuaternionSchema,
+  ResourceType: () => ResourceType,
+  RobotAgent: () => RobotAgent,
+  RoleSchema: () => RoleSchema,
+  SLASchema: () => SLASchema,
+  SkillBindingSchema: () => SkillBindingSchema,
+  SkillType: () => SkillType,
+  SyncPattern: () => SyncPattern,
+  SystemSchema: () => SystemSchema,
+  TableColumnSchema: () => TableColumnSchema,
+  ThemeConfigSchema: () => ThemeConfigSchema,
+  Token: () => Token,
+  ToolRequirementSchema: () => ToolRequirementSchema,
+  ToolRequirementType: () => ToolRequirementType,
+  UUID: () => UUID,
+  Vector2DSchema: () => Vector2DSchema,
+  Vector3DSchema: () => Vector3DSchema,
+  ViewType: () => ViewType,
+  Visibility: () => Visibility,
+  VisualizationConfigSchema: () => VisualizationConfigSchema,
+  VisualizationEngine: () => VisualizationEngine,
+  WasteCategory: () => WasteCategory,
+  WorkflowBuilder: () => WorkflowBuilder,
+  WorkflowEngine: () => WorkflowEngine,
+  WorkflowQuery: () => WorkflowQuery,
+  WorkflowSchema: () => WorkflowSchema,
+  calculate_retry_delay: () => calculate_retry_delay,
+  create_file_checkpoint_manager: () => create_file_checkpoint_manager,
+  create_retryable_executor: () => create_retryable_executor,
+  deserialize_token: () => deserialize_token,
+  evaluate_decision: () => evaluate_decision,
+  get_checkpoint_manager: () => get_checkpoint_manager,
+  get_dead_letter_queue: () => get_dead_letter_queue,
+  is_retryable_error: () => is_retryable_error,
+  parse_activity: () => parse_activity,
+  parse_context: () => parse_context,
+  parse_workflow: () => parse_workflow,
+  query: () => query,
+  serialize_token: () => serialize_token,
+  set_checkpoint_manager: () => set_checkpoint_manager,
+  set_dead_letter_queue: () => set_dead_letter_queue,
+  sleep: () => sleep,
+  validate_activity: () => validate_activity,
+  validate_context: () => validate_context,
+  validate_workflow: () => validate_workflow,
+  validate_workflow_integrity: () => validate_workflow_integrity,
+  with_retry: () => with_retry,
+  workflow: () => workflow
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/index.ts
+var import_zod2 = require("zod");
+
+// src/types/visualization.ts
+var import_zod = require("zod");
+var ViewType = import_zod.z.enum(["2d", "3d"]);
+var LayoutAlgorithm = import_zod.z.enum(["dagre", "elk", "d3_hierarchy", "manual"]);
+var LayoutDirection = import_zod.z.enum(["tb", "bt", "lr", "rl"]);
+var LaneOrientation = import_zod.z.enum(["horizontal", "vertical"]);
+var CurveType = import_zod.z.enum(["bezier", "step", "smoothstep", "straight"]);
+var NodeShape = import_zod.z.enum(["rectangle", "rounded", "circle", "diamond", "hexagon", "cylinder", "cube", "sphere"]);
+var CameraType = import_zod.z.enum(["arc_rotate", "free", "follow", "fly"]);
+var AnimationEasing = import_zod.z.enum(["linear", "ease", "ease_in", "ease_out", "ease_in_out", "bounce", "elastic"]);
+var VisualizationEngine = import_zod.z.enum(["reactflow", "babylonjs", "custom"]);
+var Vector2DSchema = import_zod.z.object({
+  x: import_zod.z.number(),
+  y: import_zod.z.number()
+});
+var Vector3DSchema = import_zod.z.object({
+  x: import_zod.z.number(),
+  y: import_zod.z.number(),
+  z: import_zod.z.number()
+});
+var QuaternionSchema = import_zod.z.object({
+  x: import_zod.z.number(),
+  y: import_zod.z.number(),
+  z: import_zod.z.number(),
+  w: import_zod.z.number()
+});
+var ColorSchema = import_zod.z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$|^rgba?\(/);
+var NodeStyle2DSchema = import_zod.z.object({
+  background_color: ColorSchema.optional(),
+  border_color: ColorSchema.optional(),
+  border_width: import_zod.z.number().optional(),
+  border_radius: import_zod.z.number().optional(),
+  opacity: import_zod.z.number().min(0).max(1).optional()
+}).passthrough();
+var NodeMaterial3DSchema = import_zod.z.object({
+  diffuse_color: ColorSchema.optional(),
+  emissive_color: ColorSchema.optional(),
+  alpha: import_zod.z.number().min(0).max(1).optional(),
+  metallic: import_zod.z.number().min(0).max(1).optional(),
+  roughness: import_zod.z.number().min(0).max(1).optional()
+}).passthrough();
+var NodePosition2DSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid().optional(),
+  node_id: import_zod.z.string().uuid(),
+  node_type: import_zod.z.enum(["activity", "event", "decision"]),
+  position: Vector2DSchema,
+  width: import_zod.z.number().min(0).optional(),
+  height: import_zod.z.number().min(0).optional(),
+  z_index: import_zod.z.number().int().optional(),
+  shape: NodeShape.optional(),
+  style: NodeStyle2DSchema.optional(),
+  collapsed: import_zod.z.boolean().default(false)
+});
+var NodePosition3DSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid().optional(),
+  node_id: import_zod.z.string().uuid(),
+  node_type: import_zod.z.enum(["activity", "event", "decision"]),
+  position: Vector3DSchema,
+  rotation: QuaternionSchema.optional(),
+  scale: Vector3DSchema.optional(),
+  shape: NodeShape.optional(),
+  material: NodeMaterial3DSchema.optional(),
+  visible: import_zod.z.boolean().default(true)
+});
+var EdgeStyleSchema = import_zod.z.object({
+  stroke_color: ColorSchema.optional(),
+  stroke_width: import_zod.z.number().optional(),
+  stroke_dasharray: import_zod.z.string().optional(),
+  marker_start: import_zod.z.string().optional(),
+  marker_end: import_zod.z.string().optional()
+}).passthrough();
+var EdgeRoutingSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid().optional(),
+  edge_id: import_zod.z.string().uuid(),
+  curve_type: CurveType.default("bezier"),
+  control_points_2d: import_zod.z.array(Vector2DSchema).optional(),
+  control_points_3d: import_zod.z.array(Vector3DSchema).optional(),
+  animated: import_zod.z.boolean().default(false),
+  animation_speed: import_zod.z.number().min(0).optional(),
+  style: EdgeStyleSchema.optional()
+});
+var LaneSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  name: import_zod.z.string(),
+  label: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  orientation: LaneOrientation.default("horizontal"),
+  order_index: import_zod.z.number().int().optional(),
+  node_ids: import_zod.z.array(import_zod.z.string().uuid()).default([]),
+  role_id: import_zod.z.string().uuid().optional(),
+  organization_id: import_zod.z.string().uuid().optional(),
+  color: ColorSchema.optional(),
+  collapsed: import_zod.z.boolean().default(false)
+});
+var AutoLayoutConfigSchema = import_zod.z.object({
+  algorithm: LayoutAlgorithm.default("dagre"),
+  direction: LayoutDirection.default("lr"),
+  node_spacing: import_zod.z.number().min(0).default(50),
+  rank_spacing: import_zod.z.number().min(0).default(100),
+  edge_spacing: import_zod.z.number().min(0).default(10),
+  align: import_zod.z.enum(["ul", "ur", "dl", "dr"]).optional(),
+  elk_options: import_zod.z.record(import_zod.z.unknown()).optional(),
+  respect_lanes: import_zod.z.boolean().default(true)
+});
+var CameraSettings2DSchema = import_zod.z.object({
+  center: Vector2DSchema.optional(),
+  zoom: import_zod.z.number().min(0.1).max(10).default(1),
+  min_zoom: import_zod.z.number().min(0.1).default(0.1),
+  max_zoom: import_zod.z.number().max(10).default(4),
+  fit_view: import_zod.z.boolean().default(true),
+  fit_padding: import_zod.z.number().default(50)
+});
+var CameraSettings3DSchema = import_zod.z.object({
+  type: CameraType.default("arc_rotate"),
+  position: Vector3DSchema.optional(),
+  target: Vector3DSchema.optional(),
+  fov: import_zod.z.number().min(10).max(120).default(45),
+  near_clip: import_zod.z.number().min(0.01).default(0.1),
+  far_clip: import_zod.z.number().default(1e3),
+  alpha: import_zod.z.number().optional(),
+  beta: import_zod.z.number().optional(),
+  radius: import_zod.z.number().optional()
+});
+var AnimationConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  transition_duration: import_zod.z.number().int().min(0).default(300),
+  easing: AnimationEasing.default("ease_in_out"),
+  edge_flow_enabled: import_zod.z.boolean().default(false),
+  edge_flow_speed: import_zod.z.number().default(1),
+  highlight_active_path: import_zod.z.boolean().default(true),
+  playback_speed: import_zod.z.number().min(0.1).max(10).default(1)
+});
+var ThemeConfigSchema = import_zod.z.object({
+  background_color: ColorSchema.optional(),
+  grid_enabled: import_zod.z.boolean().default(true),
+  grid_size: import_zod.z.number().default(20),
+  grid_color: ColorSchema.optional(),
+  minimap_enabled: import_zod.z.boolean().default(true),
+  controls_enabled: import_zod.z.boolean().default(true)
+}).passthrough();
+var VisualizationConfigSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  workflow_id: import_zod.z.string().uuid(),
+  name: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  is_default: import_zod.z.boolean().default(false),
+  view_type: ViewType,
+  engine: VisualizationEngine.optional(),
+  auto_layout: AutoLayoutConfigSchema.optional(),
+  node_positions_2d: import_zod.z.array(NodePosition2DSchema).default([]),
+  node_positions_3d: import_zod.z.array(NodePosition3DSchema).default([]),
+  edge_routings: import_zod.z.array(EdgeRoutingSchema).default([]),
+  lanes: import_zod.z.array(LaneSchema).default([]),
+  camera_2d: CameraSettings2DSchema.optional(),
+  camera_3d: CameraSettings3DSchema.optional(),
+  animation: AnimationConfigSchema.optional(),
+  theme: ThemeConfigSchema.optional(),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional(),
+  created_at: import_zod.z.string().datetime().optional(),
+  updated_at: import_zod.z.string().datetime().optional()
+});
+
+// src/types/index.ts
+var ActorType = import_zod2.z.enum(["human", "ai_agent", "robot", "application"]);
+var AccessMode = import_zod2.z.enum(["read", "write", "read_write", "subscribe", "publish"]);
+var SyncPattern = import_zod2.z.enum(["shared_state", "message_passing", "blackboard", "event_sourcing"]);
+var ContextType = import_zod2.z.enum(["document", "data", "config", "state", "memory", "artifact"]);
+var Visibility = import_zod2.z.enum(["private", "workflow", "collection", "global"]);
+var Permission = import_zod2.z.enum(["read", "write", "execute", "admin", "delete", "create"]);
+var ResourceType = import_zod2.z.enum(["system", "api", "database", "file", "service", "secret"]);
+var AccessDirection = import_zod2.z.enum(["requires", "provisions"]);
+var HitPolicy = import_zod2.z.enum(["unique", "first", "priority", "any", "collect", "rule_order"]);
+var WasteCategory = import_zod2.z.enum([
+  "defects",
+  "overproduction",
+  "waiting",
+  "non_utilized_talent",
+  "transport",
+  "inventory",
+  "motion",
+  "extra_processing"
+]);
+var NodeType = import_zod2.z.enum(["activity", "event", "decision"]);
+var ControlType = import_zod2.z.enum(["authorization", "validation", "audit", "compliance", "security", "rate_limit"]);
+var Enforcement = import_zod2.z.enum(["mandatory", "advisory", "informational"]);
+var Lifecycle = import_zod2.z.enum(["transient", "persistent", "cached"]);
+var SkillType = import_zod2.z.enum(["ai_context", "human_competency"]);
+var ToolRequirementType = import_zod2.z.enum(["mcp", "rest_api", "graphql", "grpc", "software_package", "hardware_interface"]);
+var UUID = import_zod2.z.string().uuid();
+var Duration = import_zod2.z.string().regex(/^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/);
+var DateTimeTz = import_zod2.z.string().datetime();
+var SkillBindingSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  type: SkillType,
+  description: import_zod2.z.string().optional(),
+  min_level: import_zod2.z.string().optional(),
+  reference: import_zod2.z.string().url().optional()
+});
+var ToolRequirementSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  type: ToolRequirementType,
+  description: import_zod2.z.string().optional(),
+  version: import_zod2.z.string().optional(),
+  reference: import_zod2.z.string().url().optional()
+});
+var DataObjectSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  schema: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  required: import_zod2.z.boolean().default(true)
+});
+var ParameterSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  type: import_zod2.z.string(),
+  required: import_zod2.z.boolean().default(true),
+  default: import_zod2.z.unknown().optional()
+});
+var ProgramSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  language: import_zod2.z.enum(["python", "typescript", "javascript", "java", "sql", "mcp_tool", "rest_api", "graphql", "shell"]),
+  code: import_zod2.z.string().optional(),
+  code_uri: import_zod2.z.string().url().optional(),
+  parameters: import_zod2.z.array(ParameterSchema).default([]),
+  mcp_server: import_zod2.z.string().optional()
+});
+var ControlSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  type: ControlType,
+  expression: import_zod2.z.string().optional(),
+  enforcement: Enforcement
+});
+var ContextBindingSchema = import_zod2.z.object({
+  id: UUID.optional(),
+  context_id: UUID,
+  activity_id: UUID.optional(),
+  access_mode: AccessMode,
+  required: import_zod2.z.boolean().default(true),
+  transforms: import_zod2.z.object({
+    on_read: import_zod2.z.string().optional(),
+    on_write: import_zod2.z.string().optional()
+  }).optional()
+});
+var AccessRightSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  activity_id: UUID.optional(),
+  direction: AccessDirection,
+  resource_type: ResourceType,
+  resource_id: import_zod2.z.string().optional(),
+  permission: Permission,
+  scope: import_zod2.z.string().optional(),
+  conditions: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var ContextSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  type: ContextType,
+  schema: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  initial_value: import_zod2.z.unknown().optional(),
+  sync_pattern: SyncPattern,
+  visibility: Visibility.default("workflow"),
+  owner_workflow_id: UUID.optional(),
+  lifecycle: Lifecycle.default("persistent"),
+  ttl: Duration.optional()
+});
+var SLASchema = import_zod2.z.object({
+  id: UUID.optional(),
+  name: import_zod2.z.string().optional(),
+  target_time: Duration.optional(),
+  max_time: Duration.optional(),
+  escalation_policy: import_zod2.z.object({
+    warning_threshold: Duration.optional(),
+    warning_action: import_zod2.z.string().optional(),
+    breach_action: import_zod2.z.string().optional(),
+    notify_roles: import_zod2.z.array(UUID).optional()
+  }).optional(),
+  metrics: import_zod2.z.array(import_zod2.z.object({
+    name: import_zod2.z.string(),
+    target: import_zod2.z.number(),
+    unit: import_zod2.z.string().optional(),
+    comparison: import_zod2.z.enum(["lt", "lte", "eq", "gte", "gt"]).optional()
+  })).optional()
+});
+var AnalyticsSchema = import_zod2.z.object({
+  process_time: Duration.optional(),
+  cycle_time: Duration.optional(),
+  lead_time: Duration.optional(),
+  wait_time: Duration.optional(),
+  value_added: import_zod2.z.boolean().optional(),
+  waste_categories: import_zod2.z.array(WasteCategory).optional(),
+  cost: import_zod2.z.object({
+    amount: import_zod2.z.number(),
+    currency: import_zod2.z.string().length(3)
+  }).optional(),
+  resource_utilization: import_zod2.z.number().min(0).max(1).optional(),
+  error_rate: import_zod2.z.number().min(0).max(1).optional(),
+  throughput: import_zod2.z.object({
+    value: import_zod2.z.number(),
+    unit: import_zod2.z.string(),
+    period: Duration.optional()
+  }).optional(),
+  process_cycle_efficiency: import_zod2.z.number().min(0).max(1).optional()
+});
+var ActivitySchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  role_id: UUID,
+  actor_type: ActorType,
+  system_id: UUID.optional(),
+  machine_id: UUID.optional(),
+  endpoint_id: UUID.optional(),
+  organization_id: UUID.optional(),
+  inputs: import_zod2.z.array(DataObjectSchema).default([]),
+  outputs: import_zod2.z.array(DataObjectSchema).default([]),
+  context_bindings: import_zod2.z.array(ContextBindingSchema).default([]),
+  access_rights: import_zod2.z.array(AccessRightSchema).default([]),
+  programs: import_zod2.z.array(ProgramSchema).default([]),
+  controls: import_zod2.z.array(ControlSchema).default([]),
+  sla: SLASchema.optional(),
+  analytics: AnalyticsSchema.optional(),
+  is_expandable: import_zod2.z.boolean().default(false),
+  expansion_workflow_id: UUID.optional(),
+  skills: import_zod2.z.array(SkillBindingSchema).default([]),
+  tool_requirements: import_zod2.z.array(ToolRequirementSchema).default([])
+});
+var EdgeSchema = import_zod2.z.object({
+  id: UUID,
+  source_id: UUID,
+  target_id: UUID,
+  source_type: NodeType.optional(),
+  target_type: NodeType.optional(),
+  condition: import_zod2.z.string().optional(),
+  label: import_zod2.z.string().optional(),
+  is_default: import_zod2.z.boolean().default(false),
+  skills: import_zod2.z.array(SkillBindingSchema).default([]),
+  tool_requirements: import_zod2.z.array(ToolRequirementSchema).default([])
+});
+var EventSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  event_type: import_zod2.z.string(),
+  event_definition: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var DecisionRuleSchema = import_zod2.z.object({
+  id: UUID.optional(),
+  description: import_zod2.z.string().optional(),
+  input_entries: import_zod2.z.array(import_zod2.z.string()),
+  output_entries: import_zod2.z.array(import_zod2.z.unknown()),
+  output_edge_id: UUID.optional()
+});
+var TableColumnSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  label: import_zod2.z.string().optional(),
+  type: import_zod2.z.enum(["string", "number", "boolean", "date", "datetime"]),
+  allowed_values: import_zod2.z.array(import_zod2.z.unknown()).optional()
+});
+var DecisionTableSchema = import_zod2.z.object({
+  hit_policy: HitPolicy,
+  inputs: import_zod2.z.array(TableColumnSchema).min(1),
+  outputs: import_zod2.z.array(TableColumnSchema).min(1),
+  rules: import_zod2.z.array(DecisionRuleSchema)
+});
+var DecisionNodeSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  decision_table: DecisionTableSchema,
+  default_output_edge_id: UUID.optional()
+});
+var WorkflowSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string().regex(/^\d+\.\d+\.\d+$/),
+  description: import_zod2.z.string().optional(),
+  owner_id: UUID.optional(),
+  organization_id: UUID.optional(),
+  parent_workflow_id: UUID.optional(),
+  expansion_activity_id: UUID.optional(),
+  activities: import_zod2.z.array(ActivitySchema),
+  edges: import_zod2.z.array(EdgeSchema),
+  events: import_zod2.z.array(EventSchema).default([]),
+  decision_nodes: import_zod2.z.array(DecisionNodeSchema).default([]),
+  contexts: import_zod2.z.array(ContextSchema).default([]),
+  sla: SLASchema.optional(),
+  analytics: AnalyticsSchema.optional(),
+  metadata: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  created_at: DateTimeTz.optional(),
+  updated_at: DateTimeTz.optional()
+});
+var CollectionSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  workflow_ids: import_zod2.z.array(UUID).default([]),
+  shared_contexts: import_zod2.z.array(ContextSchema).default([]),
+  owner_id: UUID.optional(),
+  organization_id: UUID.optional(),
+  tags: import_zod2.z.array(import_zod2.z.string()).default([]),
+  created_at: DateTimeTz.optional(),
+  updated_at: DateTimeTz.optional()
+});
+var RoleSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  actor_type: ActorType,
+  organization_id: UUID.optional(),
+  capabilities: import_zod2.z.array(import_zod2.z.string()).default([]),
+  is_embedded: import_zod2.z.boolean().default(false),
+  ai_model_config: import_zod2.z.object({
+    model_id: import_zod2.z.string().optional(),
+    temperature: import_zod2.z.number().min(0).max(2).optional(),
+    max_tokens: import_zod2.z.number().optional(),
+    system_prompt: import_zod2.z.string().optional()
+  }).optional(),
+  mcp_tools: import_zod2.z.array(import_zod2.z.object({
+    server_name: import_zod2.z.string(),
+    tool_name: import_zod2.z.string()
+  })).default([])
+});
+var SystemSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  vendor: import_zod2.z.string().optional(),
+  version: import_zod2.z.string().optional(),
+  type: import_zod2.z.enum(["erp", "crm", "hrm", "scm", "custom", "saas", "database", "messaging", "storage"]),
+  description: import_zod2.z.string().optional(),
+  base_url: import_zod2.z.string().url().optional(),
+  auth_config: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var MachineSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  type: import_zod2.z.enum(["robot", "sensor", "actuator", "printer", "scanner", "vehicle", "camera", "conveyor"]),
+  manufacturer: import_zod2.z.string().optional(),
+  model: import_zod2.z.string().optional(),
+  serial_number: import_zod2.z.string().optional(),
+  location: import_zod2.z.string().optional(),
+  protocol: import_zod2.z.enum(["mqtt", "opcua", "modbus", "http", "grpc", "ros"]).optional(),
+  connection_string: import_zod2.z.string().optional()
+});
+var EndpointSchema = import_zod2.z.object({
+  id: UUID,
+  name: import_zod2.z.string(),
+  url: import_zod2.z.string(),
+  method: import_zod2.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "GRPC", "WEBSOCKET", "GRAPHQL"]).optional(),
+  auth_type: import_zod2.z.enum(["none", "api_key", "oauth2", "jwt", "basic", "mtls"]).optional(),
+  openapi_ref: import_zod2.z.string().optional(),
+  request_schema: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  response_schema: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var HumanTaskStatus = import_zod2.z.enum(["pending", "assigned", "in_progress", "completed", "rejected", "expired"]);
+var HumanTaskPriority = import_zod2.z.enum(["low", "normal", "high", "critical"]);
+var HumanTaskSchema = import_zod2.z.object({
+  id: UUID,
+  activity_id: UUID,
+  activity_name: import_zod2.z.string(),
+  token_id: UUID,
+  workflow_id: UUID,
+  status: HumanTaskStatus,
+  priority: HumanTaskPriority,
+  assignee_id: import_zod2.z.string().optional(),
+  role_id: UUID,
+  creator_id: import_zod2.z.string().optional(),
+  creator_type: ActorType.optional(),
+  assigner_id: import_zod2.z.string().optional(),
+  assigner_type: ActorType.optional(),
+  inputs: import_zod2.z.record(import_zod2.z.unknown()),
+  outputs: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  created_at: DateTimeTz,
+  updated_at: DateTimeTz,
+  due_at: DateTimeTz.optional(),
+  completed_at: DateTimeTz.optional(),
+  description: import_zod2.z.string().optional(),
+  form_schema: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  tags: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+
+// src/runtime/token.ts
+var import_uuid = require("uuid");
+var Token = class {
+  id;
+  activityId;
+  status;
+  contextData;
+  history;
+  parentTokenId;
+  workflowId;
+  createdAt;
+  updatedAt;
+  constructor(activityId, initialData = {}, parentTokenId, workflowId) {
+    this.id = (0, import_uuid.v4)();
+    this.activityId = activityId;
+    this.status = "active";
+    this.contextData = { ...initialData };
+    this.history = [];
+    this.parentTokenId = parentTokenId;
+    this.workflowId = workflowId;
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.addToHistory(activityId, "created");
+  }
+  move(nextActivityId, analytics) {
+    this.addToHistory(this.activityId, "exited", void 0, analytics);
+    this.activityId = nextActivityId;
+    this.status = "active";
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.addToHistory(nextActivityId, "entered");
+  }
+  updateStatus(status, analytics) {
+    this.status = status;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.addToHistory(this.activityId, `status_change:${status}`, void 0, analytics);
+  }
+  setData(key, value) {
+    this.contextData[key] = value;
+    this.updatedAt = /* @__PURE__ */ new Date();
+  }
+  getData(key) {
+    return this.contextData[key];
+  }
+  mergeData(data) {
+    this.contextData = { ...this.contextData, ...data };
+    this.updatedAt = /* @__PURE__ */ new Date();
+  }
+  addToHistory(nodeId, action, metrics, analytics) {
+    this.history.push({
+      nodeId,
+      timestamp: /* @__PURE__ */ new Date(),
+      action,
+      metrics,
+      analytics
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      activityId: this.activityId,
+      status: this.status,
+      contextData: this.contextData,
+      history: this.history,
+      parentTokenId: this.parentTokenId,
+      workflowId: this.workflowId,
+      createdAt: this.createdAt.toISOString(),
+      updatedAt: this.updatedAt.toISOString()
+    };
+  }
+};
+
+// src/runtime/context_manager.ts
+var ContextManager = class {
+  contexts;
+  values;
+  constructor() {
+    this.contexts = /* @__PURE__ */ new Map();
+    this.values = /* @__PURE__ */ new Map();
+  }
+  register(context) {
+    this.contexts.set(context.id, context);
+    if (context.initial_value !== void 0) {
+      this.values.set(context.id, JSON.parse(JSON.stringify(context.initial_value)));
+    }
+  }
+  get(contextId) {
+    if (!this.contexts.has(contextId)) {
+      throw new Error(`Context with ID ${contextId} not found`);
+    }
+    return this.values.get(contextId);
+  }
+  set(contextId, value) {
+    if (!this.contexts.has(contextId)) {
+      throw new Error(`Context with ID ${contextId} not found`);
+    }
+    this.values.set(contextId, value);
+  }
+  update(contextId, partialValue) {
+    if (!this.contexts.has(contextId)) {
+      throw new Error(`Context with ID ${contextId} not found`);
+    }
+    const currentValue = this.values.get(contextId) || {};
+    if (typeof currentValue === "object" && currentValue !== null && !Array.isArray(currentValue)) {
+      this.values.set(contextId, { ...currentValue, ...partialValue });
+    } else {
+      this.values.set(contextId, partialValue);
+    }
+  }
+  delete(contextId) {
+    if (!this.contexts.has(contextId)) {
+      throw new Error(`Context with ID ${contextId} not found`);
+    }
+    this.contexts.delete(contextId);
+    this.values.delete(contextId);
+  }
+  getContextDefinition(contextId) {
+    return this.contexts.get(contextId);
+  }
+};
+
+// src/validator/index.ts
+function formatZodError(error) {
+  return error.errors.map((e) => ({
+    path: e.path.join("."),
+    message: e.message,
+    code: e.code
+  }));
+}
+function validate_workflow(data) {
+  const result = WorkflowSchema.safeParse(data);
+  if (result.success) {
+    return { valid: true, errors: [] };
+  }
+  return { valid: false, errors: formatZodError(result.error) };
+}
+function validate_activity(data) {
+  const result = ActivitySchema.safeParse(data);
+  if (result.success) {
+    return { valid: true, errors: [] };
+  }
+  return { valid: false, errors: formatZodError(result.error) };
+}
+function validate_context(data) {
+  const result = ContextSchema.safeParse(data);
+  if (result.success) {
+    return { valid: true, errors: [] };
+  }
+  return { valid: false, errors: formatZodError(result.error) };
+}
+function parse_workflow(data) {
+  return WorkflowSchema.parse(data);
+}
+function parse_activity(data) {
+  return ActivitySchema.parse(data);
+}
+function parse_context(data) {
+  return ContextSchema.parse(data);
+}
+function validate_workflow_integrity(workflow2) {
+  const errors = [];
+  const nodeIds = /* @__PURE__ */ new Set([
+    ...workflow2.activities.map((a) => a.id),
+    ...workflow2.events.map((e) => e.id),
+    ...workflow2.decision_nodes.map((d) => d.id)
+  ]);
+  for (const edge of workflow2.edges) {
+    if (!nodeIds.has(edge.source_id)) {
+      errors.push({
+        path: `edges[${edge.id}].source_id`,
+        message: `Source node '${edge.source_id}' not found`,
+        code: "invalid_reference"
+      });
+    }
+    if (!nodeIds.has(edge.target_id)) {
+      errors.push({
+        path: `edges[${edge.id}].target_id`,
+        message: `Target node '${edge.target_id}' not found`,
+        code: "invalid_reference"
+      });
+    }
+  }
+  const contextIds = new Set(workflow2.contexts.map((c) => c.id));
+  for (const activity of workflow2.activities) {
+    for (const binding of activity.context_bindings) {
+      if (!contextIds.has(binding.context_id)) {
+        errors.push({
+          path: `activities[${activity.id}].context_bindings`,
+          message: `Context '${binding.context_id}' not found`,
+          code: "invalid_reference"
+        });
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/runtime/actors/software_agent.ts
+var SoftwareAgent = class {
+  async execute(activity, inputs) {
+    console.log(`[SoftwareAgent] Executing activity: ${activity.name} (${activity.id})`);
+    if (activity.programs && activity.programs.length > 0) {
+      for (const program of activity.programs) {
+        if (program.language === "rest_api") {
+          return this.executeRestApi(program, inputs);
+        }
+      }
+    }
+    return {
+      status: "success",
+      message: "Executed via SoftwareAgent",
+      ...inputs
+    };
+  }
+  async executeRestApi(program, inputs) {
+    console.log(`[SoftwareAgent] Executing REST API: ${program.name}`);
+    return {
+      status: 200,
+      data: {
+        mock_response: "from_rest_api",
+        inputs_received: inputs
+      }
+    };
+  }
+};
+
+// src/runtime/actors/ai_agent.ts
+var import_generative_ai = require("@google/generative-ai");
+var AIAgent = class {
+  genAI;
+  model;
+  role;
+  constructor(apiKey, role) {
+    this.genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    this.model = this.genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+    this.role = role;
+  }
+  async execute(activity, inputs) {
+    console.log(`[AIAgent] Executing activity: ${activity.name} (${activity.id})`);
+    const systemPrompt = this.generateSystemPrompt(activity);
+    const userMessage = this.generateUserMessage(activity, inputs);
+    try {
+      const generationConfig = {
+        temperature: this.role?.ai_model_config?.temperature ?? 0.7,
+        maxOutputTokens: this.role?.ai_model_config?.max_tokens ?? 1024
+      };
+      const result = await this.model.generateContent({
+        contents: [
+          { role: "user", parts: [{ text: systemPrompt + "\n\n" + userMessage }] }
+        ]
+        // Note: System instructions are supported in newer API versions, 
+        // but combining into prompt is a safe fallback for all client versions.
+        // If the client supports systemInstruction, we could use that.
+        // generationConfig: generationConfig
+      });
+      const responseText = result.response.text();
+      try {
+        const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          return JSON.parse(jsonMatch[0]);
+        }
+      } catch (e) {
+      }
+      return {
+        output: responseText,
+        status: "complex_completed"
+      };
+    } catch (error) {
+      console.error("[AIAgent] Execution failed:", error);
+      throw new Error(`AIAgent execution failed: ${error.message}`);
+    }
+  }
+  generateSystemPrompt(activity) {
+    const lines = [];
+    if (this.role) {
+      lines.push(`You are a ${this.role.name}.`);
+      if (this.role.description) {
+        lines.push(this.role.description);
+      }
+      if (this.role.capabilities && this.role.capabilities.length > 0) {
+        lines.push(` Your capabilities are: ${this.role.capabilities.join(", ")}.`);
+      }
+    } else {
+      lines.push("You are an intelligent AI agent.");
+    }
+    lines.push(`
+You are responding to a request to perform the activity: "${activity.name}".`);
+    if (activity.description) {
+      lines.push(`Description: ${activity.description}`);
+    }
+    lines.push("\nPlease provide your output in a structured JSON format if the activity implies structured data, otherwise provide a clear textual response.");
+    return lines.join("\n");
+  }
+  generateUserMessage(activity, inputs) {
+    const lines = [];
+    lines.push("## Input Context");
+    if (Object.keys(inputs).length > 0) {
+      lines.push(JSON.stringify(inputs, null, 2));
+    } else {
+      lines.push("No specific input data provided.");
+    }
+    if (activity.controls && activity.controls.length > 0) {
+      lines.push("\n## Controls & Constraints");
+      activity.controls.forEach((c) => {
+        lines.push(`- ${c.name}: ${c.description || ""} (${c.enforcement})`);
+      });
+    }
+    lines.push("\nBased on the above, please perform the activity and generate the output.");
+    return lines.join("\n");
+  }
+};
+
+// src/runtime/actors/robot_agent.ts
+var RobotAgent = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      simulation_mode: true,
+      // Default to simulation for safety
+      timeout_ms: 3e4,
+      ...config
+    };
+  }
+  async execute(activity, inputs) {
+    console.log(`[RobotAgent] Executing activity: ${activity.name} (${activity.id})`);
+    const start_time = Date.now();
+    if (this.config.simulation_mode) {
+      return this.simulate_execution(activity, inputs, start_time);
+    }
+    return this.execute_robot_command(activity, inputs, start_time);
+  }
+  /**
+   * Simulate robot execution for testing/development
+   */
+  async simulate_execution(activity, inputs, start_time) {
+    console.log("[RobotAgent] Running in SIMULATION mode");
+    const simulated_delay = Math.random() * 400 + 100;
+    await new Promise((resolve) => setTimeout(resolve, simulated_delay));
+    const execution_time_ms = Date.now() - start_time;
+    const activity_type = this.infer_robot_activity_type(activity);
+    switch (activity_type) {
+      case "pick":
+        return {
+          status: "completed",
+          action: "pick",
+          execution_time_ms,
+          result: {
+            item_picked: true,
+            position: { x: 100, y: 50, z: 0 },
+            gripper_state: "closed"
+          },
+          ...inputs
+        };
+      case "place":
+        return {
+          status: "completed",
+          action: "place",
+          execution_time_ms,
+          result: {
+            item_placed: true,
+            position: { x: 200, y: 100, z: 0 },
+            gripper_state: "open"
+          },
+          ...inputs
+        };
+      case "move":
+        return {
+          status: "completed",
+          action: "move",
+          execution_time_ms,
+          result: {
+            movement_complete: true,
+            current_position: { x: 150, y: 75, z: 25 }
+          },
+          ...inputs
+        };
+      case "scan":
+        return {
+          status: "completed",
+          action: "scan",
+          execution_time_ms,
+          result: {
+            scan_complete: true,
+            barcode: `SIM-${Date.now()}`,
+            item_detected: true
+          },
+          ...inputs
+        };
+      case "assemble":
+        return {
+          status: "completed",
+          action: "assemble",
+          execution_time_ms,
+          result: {
+            assembly_complete: true,
+            quality_check: "passed",
+            torque_values: [2.5, 2.7, 2.6]
+          },
+          ...inputs
+        };
+      default:
+        return {
+          status: "completed",
+          action: "generic_robot_task",
+          execution_time_ms,
+          result: {
+            task_complete: true
+          },
+          ...inputs
+        };
+    }
+  }
+  /**
+   * Execute actual robot command (placeholder for real implementation)
+   */
+  async execute_robot_command(activity, inputs, start_time) {
+    throw new Error(
+      `Real robot execution not yet implemented. Protocol: ${this.config.protocol}, Connection: ${this.config.connection_string}. Enable simulation_mode for testing.`
+    );
+  }
+  /**
+   * Infer robot activity type from activity name/description
+   */
+  infer_robot_activity_type(activity) {
+    const name_lower = activity.name.toLowerCase();
+    const desc_lower = (activity.description || "").toLowerCase();
+    const combined = `${name_lower} ${desc_lower}`;
+    if (combined.includes("pick") || combined.includes("grab") || combined.includes("grasp")) {
+      return "pick";
+    }
+    if (combined.includes("place") || combined.includes("drop") || combined.includes("release")) {
+      return "place";
+    }
+    if (combined.includes("move") || combined.includes("transport") || combined.includes("transfer")) {
+      return "move";
+    }
+    if (combined.includes("scan") || combined.includes("read") || combined.includes("identify")) {
+      return "scan";
+    }
+    if (combined.includes("assemble") || combined.includes("attach") || combined.includes("mount")) {
+      return "assemble";
+    }
+    return "generic";
+  }
+};
+
+// src/runtime/actors/human_agent.ts
+var import_uuid2 = require("uuid");
+
+// src/runtime/persistence/db.ts
+var import_client = require("@prisma/client");
+var globalForPrisma = global;
+var db = globalForPrisma.prisma || new import_client.PrismaClient();
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;
+
+// src/runtime/services/task_service.ts
+var TaskService = class {
+  /**
+   * Map Prisma Task to Domain Task
+   */
+  static mapToDomain(task) {
+    return {
+      ...task,
+      status: task.status,
+      // Cast to enum
+      priority: task.priority,
+      // Cast to enum
+      assignee_id: task.assignee_id || void 0,
+      creator_id: task.creator_id || void 0,
+      creator_type: task.creator_type || void 0,
+      assigner_id: task.assigner_id || void 0,
+      assigner_type: task.assigner_type || void 0,
+      description: task.description || void 0,
+      inputs: JSON.parse(task.inputs),
+      outputs: task.outputs ? JSON.parse(task.outputs) : void 0,
+      tags: task.tags ? JSON.parse(task.tags) : void 0,
+      form_schema: task.form_schema ? JSON.parse(task.form_schema) : void 0,
+      created_at: task.created_at.toISOString(),
+      updated_at: task.updated_at.toISOString(),
+      due_at: task.due_at?.toISOString(),
+      completed_at: task.completed_at?.toISOString()
+    };
+  }
+  /**
+   * Create a new task
+   */
+  static async create(data) {
+    const task = await db.humanTask.create({
+      data: {
+        ...data,
+        inputs: JSON.stringify(data.inputs),
+        outputs: data.outputs ? JSON.stringify(data.outputs) : void 0,
+        tags: data.tags ? JSON.stringify(data.tags) : void 0,
+        form_schema: data.form_schema ? JSON.stringify(data.form_schema) : void 0
+      }
+    });
+    return this.mapToDomain(task);
+  }
+  /**
+   * Get a task by ID
+   */
+  static async get(id) {
+    const task = await db.humanTask.findUnique({
+      where: { id }
+    });
+    return task ? this.mapToDomain(task) : null;
+  }
+  /**
+   * List tasks with optional filters
+   */
+  static async list(filters) {
+    const where = {};
+    if (filters?.assignee_id) where.assignee_id = filters.assignee_id;
+    if (filters?.role_id) where.role_id = filters.role_id;
+    if (filters?.status) where.status = filters.status;
+    if (filters?.workflow_id) where.workflow_id = filters.workflow_id;
+    const tasks = await db.humanTask.findMany({
+      where,
+      orderBy: { created_at: "desc" }
+    });
+    return tasks.map(this.mapToDomain);
+  }
+  /**
+   * Assign a task
+   */
+  static async assign(id, assignee_id, assigner_id, assigner_type) {
+    const task = await db.humanTask.update({
+      where: { id },
+      data: {
+        assignee_id,
+        assigner_id,
+        assigner_type,
+        status: "assigned",
+        updated_at: /* @__PURE__ */ new Date()
+      }
+    });
+    return this.mapToDomain(task);
+  }
+  /**
+   * Start a task
+   */
+  static async start(id) {
+    const task = await db.humanTask.update({
+      where: { id },
+      data: {
+        status: "in_progress",
+        updated_at: /* @__PURE__ */ new Date()
+      }
+    });
+    return this.mapToDomain(task);
+  }
+  /**
+   * Complete a task
+   */
+  static async complete(id, outputs) {
+    const task = await db.humanTask.update({
+      where: { id },
+      data: {
+        status: "completed",
+        outputs: JSON.stringify(outputs),
+        completed_at: /* @__PURE__ */ new Date(),
+        updated_at: /* @__PURE__ */ new Date()
+      }
+    });
+    return this.mapToDomain(task);
+  }
+  /**
+   * Reject a task
+   */
+  static async reject(id, reason) {
+    const task = await db.humanTask.update({
+      where: { id },
+      data: {
+        status: "rejected",
+        outputs: reason ? JSON.stringify({ rejection_reason: reason }) : void 0,
+        updated_at: /* @__PURE__ */ new Date()
+      }
+    });
+    return this.mapToDomain(task);
+  }
+  /**
+   * Get pending tasks by role (Sorted by Priority)
+   */
+  static async get_pending_by_role(role_id) {
+    const tasks = await db.humanTask.findMany({
+      where: {
+        role_id,
+        status: "pending"
+      }
+    });
+    const priorityOrder = {
+      "critical": 0,
+      "high": 1,
+      "normal": 2,
+      "low": 3
+    };
+    const sortedTasks = tasks.sort((a, b) => {
+      const pA = priorityOrder[a.priority] ?? 2;
+      const pB = priorityOrder[b.priority] ?? 2;
+      if (pA !== pB) return pA - pB;
+      return a.created_at.getTime() - b.created_at.getTime();
+    });
+    return sortedTasks.map(this.mapToDomain);
+  }
+};
+
+// src/runtime/actors/human_agent.ts
+var HumanAgent = class {
+  wait_for_completion;
+  default_priority;
+  constructor(options = {}) {
+    this.wait_for_completion = options.wait_for_completion ?? false;
+    this.default_priority = options.default_priority ?? "normal";
+  }
+  async execute(activity, inputs) {
+    console.log(`[HumanAgent] Creating persistent task for activity: ${activity.name} (${activity.id})`);
+    const token_id = inputs._token_id || (0, import_uuid2.v4)();
+    const workflow_id = inputs._workflow_id || (0, import_uuid2.v4)();
+    let priority = this.default_priority;
+    if (activity.sla?.escalation_policy) {
+      priority = "high";
+    }
+    const task = await TaskService.create({
+      activity_id: activity.id,
+      activity_name: activity.name,
+      token_id,
+      workflow_id,
+      priority,
+      role_id: activity.role_id || "user",
+      // Ensure role_id exists
+      creator_id: inputs._last_actor_id || "system",
+      creator_type: inputs._last_actor_type || "application",
+      inputs,
+      description: activity.description,
+      due_at: this.calculate_due_date(activity) ? new Date(this.calculate_due_date(activity)) : void 0,
+      tags: []
+    });
+    console.log(`[HumanAgent] Task created in DB: ${task.id}`);
+    if (this.wait_for_completion) {
+      console.log(`[HumanAgent] Waiting for task ${task.id} completion...`);
+      const completed_task = await this.wait_for_task_completion(task.id);
+      if (completed_task.status === "rejected") {
+        const outputs2 = completed_task.outputs ? JSON.parse(completed_task.outputs) : {};
+        throw new Error(`Human task rejected: ${outputs2.rejection_reason || "No reason provided"}`);
+      }
+      const outputs = completed_task.outputs ? JSON.parse(completed_task.outputs) : {};
+      return {
+        ...inputs,
+        ...outputs,
+        _human_task_id: task.id,
+        _human_task_status: "completed"
+      };
+    }
+    return {
+      ...inputs,
+      _human_task_id: task.id,
+      _human_task_status: "pending",
+      _requires_human_action: true
+    };
+  }
+  /**
+   * Poll for task completion
+   */
+  async wait_for_task_completion(task_id) {
+    return new Promise((resolve) => {
+      const check = async () => {
+        const task = await TaskService.get(task_id);
+        if (task && (task.status === "completed" || task.status === "rejected")) {
+          resolve(task);
+        } else {
+          setTimeout(check, 2e3);
+        }
+      };
+      check();
+    });
+  }
+  /**
+   * Calculate due date from activity SLA
+   */
+  calculate_due_date(activity) {
+    if (!activity.sla?.max_time) {
+      return void 0;
+    }
+    const duration = activity.sla.max_time;
+    const match = duration.match(/PT?(\d+)([HMSD])/);
+    if (!match) return void 0;
+    const [, value, unit] = match;
+    const ms_multipliers = {
+      "S": 1e3,
+      "M": 60 * 1e3,
+      "H": 60 * 60 * 1e3,
+      "D": 24 * 60 * 60 * 1e3
+    };
+    const offset_ms = parseInt(value) * (ms_multipliers[unit] || 0);
+    return new Date(Date.now() + offset_ms).toISOString();
+  }
+};
+
+// src/runtime/decision_evaluator.ts
+function evaluate_feel_expression(expression, value) {
+  const expr = expression.trim();
+  if (expr === "" || expr === "-" || expr === "*") {
+    return true;
+  }
+  if (expr === "true") return value === true;
+  if (expr === "false") return value === false;
+  if (expr === "null") return value === null || value === void 0;
+  if (expr === "not null") return value !== null && value !== void 0;
+  if (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) {
+    const literal = expr.slice(1, -1);
+    return String(value) === literal;
+  }
+  const range_match = expr.match(/^([\[\(])([^.]+)\.\.([^.\])]+)([\]\)])$/);
+  if (range_match) {
+    const [, start_bracket, start_val, end_val, end_bracket] = range_match;
+    const num_value = Number(value);
+    const start_num = Number(start_val);
+    const end_num = Number(end_val);
+    if (isNaN(num_value)) return false;
+    const start_inclusive = start_bracket === "[";
+    const end_inclusive = end_bracket === "]";
+    const above_start = start_inclusive ? num_value >= start_num : num_value > start_num;
+    const below_end = end_inclusive ? num_value <= end_num : num_value < end_num;
+    return above_start && below_end;
+  }
+  if (expr.startsWith(">=")) {
+    return Number(value) >= Number(expr.slice(2).trim());
+  }
+  if (expr.startsWith("<=")) {
+    return Number(value) <= Number(expr.slice(2).trim());
+  }
+  if (expr.startsWith("!=") || expr.startsWith("<>")) {
+    const compare_val = expr.slice(2).trim();
+    return String(value) !== compare_val && Number(value) !== Number(compare_val);
+  }
+  if (expr.startsWith("==")) {
+    const compare_val = expr.slice(2).trim();
+    return String(value) === compare_val || Number(value) === Number(compare_val);
+  }
+  if (expr.startsWith(">")) {
+    return Number(value) > Number(expr.slice(1).trim());
+  }
+  if (expr.startsWith("<")) {
+    return Number(value) < Number(expr.slice(1).trim());
+  }
+  if (expr.startsWith("=")) {
+    const compare_val = expr.slice(1).trim();
+    return String(value) === compare_val || Number(value) === Number(compare_val);
+  }
+  if (expr.toLowerCase().startsWith("in ") || expr.startsWith("in(")) {
+    const list_match = expr.match(/in\s*\(([^)]+)\)/i);
+    if (list_match) {
+      const items = list_match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      return items.includes(String(value));
+    }
+  }
+  if (expr.toLowerCase().startsWith("not in ") || expr.toLowerCase().startsWith("not in(")) {
+    const list_match = expr.match(/not\s+in\s*\(([^)]+)\)/i);
+    if (list_match) {
+      const items = list_match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      return !items.includes(String(value));
+    }
+  }
+  if (expr.toLowerCase().startsWith("contains(")) {
+    const match = expr.match(/contains\s*\(\s*["']([^"']+)["']\s*\)/i);
+    if (match) {
+      return String(value).includes(match[1]);
+    }
+  }
+  if (expr.toLowerCase().startsWith("starts with ")) {
+    const pattern = expr.slice(12).trim().replace(/^["']|["']$/g, "");
+    return String(value).startsWith(pattern);
+  }
+  if (expr.toLowerCase().startsWith("ends with ")) {
+    const pattern = expr.slice(10).trim().replace(/^["']|["']$/g, "");
+    return String(value).endsWith(pattern);
+  }
+  if (expr.toLowerCase().startsWith("matches(")) {
+    const match = expr.match(/matches\s*\(\s*["']([^"']+)["']\s*\)/i);
+    if (match) {
+      try {
+        const regex = new RegExp(match[1]);
+        return regex.test(String(value));
+      } catch {
+        return false;
+      }
+    }
+  }
+  const num_expr = Number(expr);
+  if (!isNaN(num_expr)) {
+    return Number(value) === num_expr;
+  }
+  return String(value) === expr;
+}
+function evaluate_rule(rule, table, context) {
+  for (let i = 0; i < table.inputs.length; i++) {
+    const input_col = table.inputs[i];
+    const expression = rule.input_entries[i] || "-";
+    const value = context[input_col.name];
+    if (!evaluate_feel_expression(expression, value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function extract_outputs(rule, table) {
+  const outputs = {};
+  for (let i = 0; i < table.outputs.length; i++) {
+    const output_col = table.outputs[i];
+    outputs[output_col.name] = rule.output_entries[i];
+  }
+  return outputs;
+}
+function evaluate_decision(node, context) {
+  const table = node.decision_table;
+  const matched_rules = [];
+  for (const rule of table.rules) {
+    if (evaluate_rule(rule, table, context)) {
+      matched_rules.push(rule);
+      if (table.hit_policy === "first" || table.hit_policy === "unique") {
+        break;
+      }
+    }
+  }
+  if (matched_rules.length === 0) {
+    return {
+      matched: false,
+      output_edge_id: node.default_output_edge_id,
+      outputs: {},
+      matched_rules: []
+    };
+  }
+  let result_outputs = {};
+  let result_edge_id;
+  switch (table.hit_policy) {
+    case "unique":
+    case "first":
+      result_outputs = extract_outputs(matched_rules[0], table);
+      result_edge_id = matched_rules[0].output_edge_id;
+      break;
+    case "any":
+      result_outputs = extract_outputs(matched_rules[0], table);
+      result_edge_id = matched_rules[0].output_edge_id;
+      break;
+    case "priority":
+      result_outputs = extract_outputs(matched_rules[0], table);
+      result_edge_id = matched_rules[0].output_edge_id;
+      break;
+    case "collect":
+      for (const output_col of table.outputs) {
+        result_outputs[output_col.name] = matched_rules.map(
+          (r) => r.output_entries[table.outputs.indexOf(output_col)]
+        );
+      }
+      result_edge_id = matched_rules[0].output_edge_id;
+      break;
+    case "rule_order":
+      for (const output_col of table.outputs) {
+        result_outputs[output_col.name] = matched_rules.map(
+          (r) => r.output_entries[table.outputs.indexOf(output_col)]
+        );
+      }
+      result_edge_id = matched_rules[0].output_edge_id;
+      break;
+    default:
+      result_outputs = extract_outputs(matched_rules[0], table);
+      result_edge_id = matched_rules[0].output_edge_id;
+  }
+  return {
+    matched: true,
+    output_edge_id: result_edge_id || node.default_output_edge_id,
+    outputs: result_outputs,
+    matched_rules
+  };
+}
+var DecisionEvaluator = class {
+  decision_nodes = /* @__PURE__ */ new Map();
+  constructor(nodes) {
+    if (nodes) {
+      for (const node of nodes) {
+        this.register(node);
+      }
+    }
+  }
+  /**
+   * Register a decision node
+   */
+  register(node) {
+    this.decision_nodes.set(node.id, node);
+  }
+  /**
+   * Get a decision node by ID
+   */
+  get(node_id) {
+    return this.decision_nodes.get(node_id);
+  }
+  /**
+   * Evaluate a decision node by ID
+   */
+  evaluate(node_id, context) {
+    const node = this.decision_nodes.get(node_id);
+    if (!node) {
+      throw new Error(`Decision node not found: ${node_id}`);
+    }
+    return evaluate_decision(node, context);
+  }
+  /**
+   * Get the next edge ID for a decision node given a context
+   */
+  get_next_edge(node_id, context) {
+    return this.evaluate(node_id, context).output_edge_id;
+  }
+};
+
+// src/runtime/duration_utils.ts
+function format_iso_duration(ms) {
+  if (ms < 0) ms = 0;
+  const seconds = ms / 1e3 % 60;
+  const minutes = Math.floor(ms / (1e3 * 60) % 60);
+  const hours = Math.floor(ms / (1e3 * 60 * 60) % 24);
+  const days = Math.floor(ms / (1e3 * 60 * 60 * 24));
+  let result = "P";
+  if (days > 0) result += `${days}D`;
+  result += "T";
+  if (hours > 0) result += `${hours}H`;
+  if (minutes > 0) result += `${minutes}M`;
+  if (seconds > 0 || result === "PT") {
+    result += `${seconds.toFixed(1)}S`;
+  }
+  return result;
+}
+function calculate_duration(start, end = /* @__PURE__ */ new Date()) {
+  return format_iso_duration(end.getTime() - start.getTime());
+}
+
+// src/runtime/workflow_engine.ts
+var WorkflowEngine = class {
+  workflow;
+  tokens;
+  contextManager;
+  status;
+  activityMap;
+  edgeMap;
+  // Source ID -> Edges
+  decisionNodeMap;
+  options;
+  roleMap;
+  decisionEvaluator;
+  constructor(workflowDef, options = {}) {
+    const validation = validate_workflow_integrity(workflowDef);
+    if (!validation.valid) {
+      throw new Error(`Invalid workflow definition: ${validation.errors.map((e) => e.message).join(", ")}`);
+    }
+    this.workflow = workflowDef;
+    this.options = {
+      ...options,
+      // Support legacy option name
+      gemini_api_key: options.gemini_api_key || options.geminiApiKey
+    };
+    this.tokens = [];
+    this.contextManager = new ContextManager();
+    this.status = "idle";
+    this.activityMap = /* @__PURE__ */ new Map();
+    this.edgeMap = /* @__PURE__ */ new Map();
+    this.decisionNodeMap = /* @__PURE__ */ new Map();
+    this.roleMap = /* @__PURE__ */ new Map();
+    this.decisionEvaluator = new DecisionEvaluator(workflowDef.decision_nodes);
+    this.initializeMaps();
+    this.initializeContexts();
+  }
+  initializeMaps() {
+    for (const activity of this.workflow.activities) {
+      this.activityMap.set(activity.id, activity);
+    }
+    for (const edge of this.workflow.edges) {
+      if (!this.edgeMap.has(edge.source_id)) {
+        this.edgeMap.set(edge.source_id, []);
+      }
+      this.edgeMap.get(edge.source_id)?.push(edge);
+    }
+    for (const decisionNode of this.workflow.decision_nodes) {
+      this.decisionNodeMap.set(decisionNode.id, decisionNode);
+    }
+    if (this.options.roles) {
+      for (const role of this.options.roles) {
+        this.roleMap.set(role.id, role);
+      }
+    }
+  }
+  initializeContexts() {
+    for (const context of this.workflow.contexts) {
+      this.contextManager.register(context);
+    }
+  }
+  log(message) {
+    if (this.options.verbose) {
+      console.log(`[WorkflowEngine] ${message}`);
+    }
+  }
+  async start(initialData = {}) {
+    if (this.status === "running") {
+      throw new Error("Workflow is already running");
+    }
+    if (this.workflow.activities.length === 0) {
+      throw new Error("Workflow has no activities");
+    }
+    let startNodeId;
+    const targetIds = new Set(this.workflow.edges.map((e) => e.target_id));
+    const startActivities = this.workflow.activities.filter((a) => !targetIds.has(a.id));
+    if (startActivities.length > 0) {
+      startNodeId = startActivities[0].id;
+    } else {
+      startNodeId = this.workflow.activities[0].id;
+    }
+    const tokenData = {
+      ...initialData,
+      _workflow_id: this.workflow.id,
+      _workflow_name: this.workflow.name,
+      _started_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const token = new Token(startNodeId, tokenData, void 0, this.workflow.id);
+    this.tokens.push(token);
+    this.status = "running";
+    this.log(`Started workflow "${this.workflow.name}" with token ${token.id}`);
+    return token.id;
+  }
+  async runStep() {
+    if (this.status !== "running" && this.status !== "waiting_human") return;
+    const activeTokens = this.tokens.filter((t) => t.status === "active");
+    if (activeTokens.length === 0) {
+      const waitingTokens = this.tokens.filter((t) => t.status === "waiting");
+      if (waitingTokens.length > 0) {
+        this.status = "waiting_human";
+        return;
+      }
+      this.status = "completed";
+      return;
+    }
+    for (const token of activeTokens) {
+      await this.processToken(token);
+    }
+    const allDone = this.tokens.every(
+      (t) => t.status === "completed" || t.status === "failed" || t.status === "cancelled"
+    );
+    if (allDone) {
+      this.status = "completed";
+    }
+  }
+  /**
+   * Run workflow to completion (or until paused/failed)
+   */
+  async run(maxSteps = 1e3) {
+    let steps = 0;
+    while (this.status === "running" && steps < maxSteps) {
+      await this.runStep();
+      steps++;
+    }
+    this.log(`Workflow completed after ${steps} steps with status: ${this.status}`);
+    return this.status;
+  }
+  async processToken(token) {
+    const currentNodeId = token.activityId;
+    const decisionNode = this.decisionNodeMap.get(currentNodeId);
+    if (decisionNode) {
+      await this.processDecisionNode(token, decisionNode);
+      return;
+    }
+    const activity = this.activityMap.get(currentNodeId);
+    if (!activity) {
+      this.log(`Activity not found: ${currentNodeId}`);
+      token.updateStatus("failed");
+      return;
+    }
+    const startTime = /* @__PURE__ */ new Date();
+    try {
+      const actor = this.createActor(activity);
+      if (actor) {
+        const inputs = {
+          ...token.contextData,
+          _token_id: token.id,
+          _workflow_id: this.workflow.id,
+          _activity_id: activity.id,
+          _activity_name: activity.name
+        };
+        this.log(`Executing activity "${activity.name}" with ${activity.actor_type} actor`);
+        const output = await actor.execute(activity, inputs);
+        const endTime = /* @__PURE__ */ new Date();
+        const processTime = calculate_duration(startTime, endTime);
+        const analytics = {
+          process_time: processTime,
+          cycle_time: processTime,
+          lead_time: processTime,
+          value_added: activity.analytics?.value_added ?? true,
+          waste_categories: []
+        };
+        if (output._requires_human_action && this.options.wait_for_human_tasks) {
+          analytics.waste_categories?.push("waiting");
+          token.updateStatus("waiting", analytics);
+          token.mergeData({
+            ...output,
+            _waiting_since: endTime.toISOString()
+          });
+          this.log(`Token paused waiting for human task ${output._human_task_id}`);
+          return;
+        }
+        token.mergeData({
+          ...output,
+          _last_actor_id: activity.id,
+          _last_actor_type: activity.actor_type
+        });
+        await this.advanceToken(token, currentNodeId, analytics);
+      } else {
+        await this.advanceToken(token, currentNodeId);
+      }
+    } catch (error) {
+      const endTime = /* @__PURE__ */ new Date();
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : void 0;
+      console.error(`Error processing activity ${activity.name}:`, error);
+      const analytics = {
+        process_time: calculate_duration(startTime, endTime),
+        waste_categories: ["defects"],
+        error_rate: 1
+      };
+      token.updateStatus("failed", analytics);
+      token.mergeData({ _error: errorMessage, _stack: errorStack });
+    }
+  }
+  /**
+   * Process a decision node
+   */
+  async processDecisionNode(token, decision) {
+    this.log(`Evaluating decision node "${decision.name}"`);
+    const result = evaluate_decision(decision, token.contextData);
+    this.log(`Decision result: matched=${result.matched}, outputs=${JSON.stringify(result.outputs)}`);
+    token.mergeData({
+      _decision_node_id: decision.id,
+      _decision_matched: result.matched,
+      _decision_outputs: result.outputs
+    });
+    if (result.output_edge_id) {
+      token.move(this.getEdgeTarget(result.output_edge_id) || result.output_edge_id);
+    } else {
+      if (decision.default_output_edge_id) {
+        token.move(this.getEdgeTarget(decision.default_output_edge_id) || decision.default_output_edge_id);
+      } else {
+        this.log(`No matching rule and no default edge for decision "${decision.name}"`);
+        token.updateStatus("failed");
+        token.mergeData({ _error: "No matching decision rule and no default path" });
+      }
+    }
+  }
+  /**
+   * Get the target node ID for an edge ID
+   */
+  getEdgeTarget(edgeId) {
+    for (const edge of this.workflow.edges) {
+      if (edge.id === edgeId) {
+        return edge.target_id;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Advance token to next node(s) based on outgoing edges
+   */
+  async advanceToken(token, currentNodeId, analytics) {
+    const outgoingEdges = this.edgeMap.get(currentNodeId) || [];
+    if (outgoingEdges.length === 0) {
+      token.updateStatus("completed", analytics);
+      this.log(`Token ${token.id} completed (no outgoing edges)`);
+      return;
+    }
+    const nextEdge = this.selectNextEdge(outgoingEdges, token.contextData);
+    if (nextEdge) {
+      token.move(nextEdge.target_id, analytics);
+      this.log(`Token ${token.id} moved to ${nextEdge.target_id}`);
+    } else {
+      token.updateStatus("failed", analytics);
+      token.mergeData({ _error: "No valid outgoing edge found" });
+    }
+  }
+  /**
+   * Select the next edge based on conditions
+   */
+  selectNextEdge(edges, context) {
+    for (const edge of edges) {
+      if (edge.condition) {
+        if (this.evaluateEdgeCondition(edge.condition, context)) {
+          return edge;
+        }
+      }
+    }
+    const defaultEdge = edges.find((e) => e.is_default);
+    if (defaultEdge) {
+      return defaultEdge;
+    }
+    return edges[0];
+  }
+  /**
+   * Evaluate a simple edge condition
+   * Supports: property == value, property != value, property (truthy check)
+   */
+  evaluateEdgeCondition(condition, context) {
+    try {
+      const eqMatch = condition.match(/^(\w+)\s*==\s*(.+)$/);
+      if (eqMatch) {
+        const [, prop, val] = eqMatch;
+        const contextVal = context[prop];
+        const compareVal = val.trim().replace(/^["']|["']$/g, "");
+        return String(contextVal) === compareVal || contextVal === JSON.parse(val);
+      }
+      const neqMatch = condition.match(/^(\w+)\s*!=\s*(.+)$/);
+      if (neqMatch) {
+        const [, prop, val] = neqMatch;
+        const contextVal = context[prop];
+        const compareVal = val.trim().replace(/^["']|["']$/g, "");
+        return String(contextVal) !== compareVal && contextVal !== JSON.parse(val);
+      }
+      const gtMatch = condition.match(/^(\w+)\s*>\s*(\d+(?:\.\d+)?)$/);
+      if (gtMatch) {
+        const [, prop, val] = gtMatch;
+        return Number(context[prop]) > Number(val);
+      }
+      const ltMatch = condition.match(/^(\w+)\s*<\s*(\d+(?:\.\d+)?)$/);
+      if (ltMatch) {
+        const [, prop, val] = ltMatch;
+        return Number(context[prop]) < Number(val);
+      }
+      if (/^\w+$/.test(condition)) {
+        return Boolean(context[condition]);
+      }
+      return Boolean(context[condition]);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Create the appropriate actor for an activity
+   */
+  createActor(activity) {
+    switch (activity.actor_type) {
+      case "application":
+        return new SoftwareAgent();
+      case "ai_agent":
+        if (!this.options.gemini_api_key) {
+          throw new Error("Gemini API Key required for AI Agent. Set gemini_api_key in options.");
+        }
+        const role = this.roleMap.get(activity.role_id);
+        return new AIAgent(this.options.gemini_api_key, role);
+      case "robot":
+        return new RobotAgent(this.options.robot_config);
+      case "human":
+        return new HumanAgent({
+          wait_for_completion: false
+          // Engine will handle waiting state
+        });
+      default:
+        this.log(`Unknown actor type: ${activity.actor_type}`);
+        return void 0;
+    }
+  }
+  /**
+   * Resume a token that was waiting for human input
+   */
+  resumeToken(tokenId, output) {
+    const token = this.tokens.find((t) => t.id === tokenId);
+    if (!token || token.status !== "waiting") {
+      return false;
+    }
+    const waitingSince = token.getData("_waiting_since");
+    let analytics;
+    if (waitingSince) {
+      const waitTime = calculate_duration(new Date(waitingSince), /* @__PURE__ */ new Date());
+      analytics = {
+        wait_time: waitTime,
+        waste_categories: ["waiting"]
+      };
+    }
+    token.mergeData(output);
+    token.updateStatus("active", analytics);
+    if (this.status === "waiting_human") {
+      this.status = "running";
+    }
+    return true;
+  }
+  getStatus() {
+    return this.status;
+  }
+  getContext(contextId) {
+    return this.contextManager.get(contextId);
+  }
+  getTokens() {
+    return this.tokens;
+  }
+  getWorkflow() {
+    return this.workflow;
+  }
+};
+
+// src/server/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LOG_LEVEL_COLORS = {
+  debug: "\x1B[36m",
+  // Cyan
+  info: "\x1B[32m",
+  // Green
+  warn: "\x1B[33m",
+  // Yellow
+  error: "\x1B[31m"
+  // Red
+};
+var RESET_COLOR = "\x1B[0m";
+var Logger = class _Logger {
+  config;
+  correlation_id;
+  context = {};
+  constructor(config = {}) {
+    this.config = {
+      level: config.level ?? "info",
+      format: config.format ?? "json",
+      timestamps: config.timestamps ?? true,
+      output: config.output
+    };
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(context) {
+    const child = new _Logger(this.config);
+    child.context = { ...this.context, ...context };
+    child.correlation_id = this.correlation_id;
+    return child;
+  }
+  /**
+   * Set correlation ID for request tracing
+   */
+  set_correlation_id(id) {
+    this.correlation_id = id;
+  }
+  /**
+   * Get current correlation ID
+   */
+  get_correlation_id() {
+    return this.correlation_id;
+  }
+  /**
+   * Generate new correlation ID
+   */
+  generate_correlation_id() {
+    this.correlation_id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    return this.correlation_id;
+  }
+  /**
+   * Check if a log level should be output
+   */
+  should_log(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.config.level];
+  }
+  /**
+   * Format and output a log entry
+   */
+  log(level, message, metadata) {
+    if (!this.should_log(level)) return;
+    const entry = {
+      timestamp: this.config.timestamps ? (/* @__PURE__ */ new Date()).toISOString() : "",
+      level,
+      message,
+      correlation_id: this.correlation_id,
+      ...this.context,
+      metadata
+    };
+    if (this.config.output) {
+      this.config.output(entry);
+      return;
+    }
+    if (this.config.format === "json") {
+      const clean_entry = Object.fromEntries(
+        Object.entries(entry).filter(([_, v]) => v !== void 0 && v !== "")
+      );
+      console.log(JSON.stringify(clean_entry));
+    } else {
+      this.log_text(entry);
+    }
+  }
+  /**
+   * Human-readable text format
+   */
+  log_text(entry) {
+    const color = LOG_LEVEL_COLORS[entry.level];
+    const parts = [];
+    if (entry.timestamp) {
+      parts.push(`[${entry.timestamp}]`);
+    }
+    parts.push(`${color}${entry.level.toUpperCase().padEnd(5)}${RESET_COLOR}`);
+    if (entry.correlation_id) {
+      parts.push(`[${entry.correlation_id}]`);
+    }
+    parts.push(entry.message);
+    if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+      parts.push(JSON.stringify(entry.metadata));
+    }
+    console.log(parts.join(" "));
+    if (entry.error?.stack) {
+      console.log(entry.error.stack);
+    }
+  }
+  // Log level methods
+  debug(message, metadata) {
+    this.log("debug", message, metadata);
+  }
+  info(message, metadata) {
+    this.log("info", message, metadata);
+  }
+  warn(message, metadata) {
+    this.log("warn", message, metadata);
+  }
+  error(message, error, metadata) {
+    const error_info = error instanceof Error ? {
+      message: error.message,
+      stack: error.stack,
+      code: error.code
+    } : error ? { message: String(error) } : void 0;
+    this.log("error", message, {
+      ...metadata,
+      error: error_info
+    });
+  }
+  /**
+   * Log workflow event
+   */
+  workflow(event, workflow_id, metadata) {
+    this.info(`[Workflow] ${event}`, { workflow_id, ...metadata });
+  }
+  /**
+   * Log activity event
+   */
+  activity(event, activity_id, metadata) {
+    this.info(`[Activity] ${event}`, { activity_id, ...metadata });
+  }
+  /**
+   * Log with timing
+   */
+  timed(label, fn) {
+    const start = Date.now();
+    try {
+      const result = fn();
+      this.debug(`${label} completed`, { duration_ms: Date.now() - start });
+      return result;
+    } catch (error) {
+      this.error(`${label} failed`, error, { duration_ms: Date.now() - start });
+      throw error;
+    }
+  }
+  /**
+   * Async version of timed
+   */
+  async timed_async(label, fn) {
+    const start = Date.now();
+    try {
+      const result = await fn();
+      this.debug(`${label} completed`, { duration_ms: Date.now() - start });
+      return result;
+    } catch (error) {
+      this.error(`${label} failed`, error, { duration_ms: Date.now() - start });
+      throw error;
+    }
+  }
+};
+var global_logger;
+function get_logger() {
+  if (!global_logger) {
+    global_logger = new Logger({
+      level: process.env.LOG_LEVEL || "info",
+      format: process.env.LOG_FORMAT === "text" ? "text" : "json"
+    });
+  }
+  return global_logger;
+}
+
+// src/runtime/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  max_retries: 3,
+  initial_delay_ms: 1e3,
+  max_delay_ms: 3e4,
+  backoff_multiplier: 2,
+  jitter: true,
+  non_retryable_errors: [
+    "VALIDATION_ERROR",
+    "AUTHENTICATION_ERROR",
+    "PERMISSION_DENIED",
+    "NOT_FOUND"
+  ]
+};
+function calculate_retry_delay(config, attempt) {
+  let delay = config.initial_delay_ms * Math.pow(config.backoff_multiplier, attempt);
+  delay = Math.min(delay, config.max_delay_ms);
+  if (config.jitter) {
+    const jitter_range = delay * 0.25;
+    delay += Math.random() * jitter_range * 2 - jitter_range;
+  }
+  return Math.round(delay);
+}
+function is_retryable_error(error, config) {
+  const error_code = error.code;
+  if (error_code && config.non_retryable_errors?.includes(error_code)) {
+    return false;
+  }
+  const non_retryable_patterns = [
+    /validation/i,
+    /invalid/i,
+    /unauthorized/i,
+    /forbidden/i,
+    /not found/i,
+    /permission/i
+  ];
+  for (const pattern of non_retryable_patterns) {
+    if (pattern.test(error.message)) {
+      return false;
+    }
+  }
+  return true;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function with_retry(fn, config = {}, logger) {
+  const full_config = { ...DEFAULT_RETRY_CONFIG, ...config };
+  const log = logger || get_logger();
+  let last_error;
+  for (let attempt = 0; attempt <= full_config.max_retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      last_error = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= full_config.max_retries) {
+        log.error(`All ${full_config.max_retries} retry attempts exhausted`, last_error, { attempt });
+        throw last_error;
+      }
+      if (!is_retryable_error(last_error, full_config)) {
+        log.warn("Error is not retryable", { error: last_error.message });
+        throw last_error;
+      }
+      const delay = calculate_retry_delay(full_config, attempt);
+      log.warn(`Retry attempt ${attempt + 1}/${full_config.max_retries} after ${delay}ms`, {
+        error: last_error.message,
+        attempt: attempt + 1,
+        delay_ms: delay
+      });
+      await sleep(delay);
+    }
+  }
+  throw last_error;
+}
+var DeadLetterQueue = class {
+  entries = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger) {
+    this.logger = logger || get_logger();
+  }
+  /**
+   * Add a failed token to the dead letter queue
+   */
+  add(token, workflow_id, activity_id, error, retry_state, metadata) {
+    const entry = {
+      id: token.id,
+      token,
+      workflow_id,
+      activity_id,
+      error: {
+        message: error.message,
+        stack: error.stack,
+        code: error.code
+      },
+      retry_state,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    this.entries.set(token.id, entry);
+    this.logger.error("Token added to dead letter queue", error, {
+      token_id: token.id,
+      workflow_id,
+      activity_id,
+      attempts: retry_state.attempt
+    });
+    return entry;
+  }
+  /**
+   * Get an entry by token ID
+   */
+  get(token_id) {
+    return this.entries.get(token_id);
+  }
+  /**
+   * List all entries
+   */
+  list() {
+    return Array.from(this.entries.values());
+  }
+  /**
+   * List entries by workflow
+   */
+  list_by_workflow(workflow_id) {
+    return this.list().filter((e) => e.workflow_id === workflow_id);
+  }
+  /**
+   * Remove an entry (e.g., after manual resolution)
+   */
+  remove(token_id) {
+    const removed = this.entries.delete(token_id);
+    if (removed) {
+      this.logger.info("Token removed from dead letter queue", { token_id });
+    }
+    return removed;
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.logger.info("Dead letter queue cleared", { count });
+    return count;
+  }
+  /**
+   * Get queue statistics
+   */
+  stats() {
+    const by_workflow = {};
+    for (const entry of this.entries.values()) {
+      by_workflow[entry.workflow_id] = (by_workflow[entry.workflow_id] || 0) + 1;
+    }
+    return { total: this.entries.size, by_workflow };
+  }
+};
+var global_dlq;
+function get_dead_letter_queue() {
+  if (!global_dlq) {
+    global_dlq = new DeadLetterQueue();
+  }
+  return global_dlq;
+}
+function set_dead_letter_queue(dlq) {
+  global_dlq = dlq;
+}
+function create_retryable_executor(executor, config, on_retry) {
+  return async () => {
+    const full_config = { ...DEFAULT_RETRY_CONFIG, ...config };
+    const logger = get_logger();
+    let last_error;
+    for (let attempt = 0; attempt <= full_config.max_retries; attempt++) {
+      try {
+        return await executor();
+      } catch (error) {
+        last_error = error instanceof Error ? error : new Error(String(error));
+        if (attempt >= full_config.max_retries || !is_retryable_error(last_error, full_config)) {
+          throw last_error;
+        }
+        if (on_retry) {
+          on_retry(attempt + 1, last_error);
+        }
+        const delay = calculate_retry_delay(full_config, attempt);
+        logger.debug(`Retry ${attempt + 1}/${full_config.max_retries}`, { delay_ms: delay });
+        await sleep(delay);
+      }
+    }
+    throw last_error;
+  };
+}
+
+// src/runtime/persistence.ts
+var InMemoryPersistenceAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  async save(workflow_id, state) {
+    this.storage.set(workflow_id, state);
+  }
+  async load(workflow_id) {
+    return this.storage.get(workflow_id) || null;
+  }
+  async delete(workflow_id) {
+    this.storage.delete(workflow_id);
+  }
+  async list() {
+    return Array.from(this.storage.keys());
+  }
+};
+var FilePersistenceAdapter = class {
+  directory;
+  fs = null;
+  path = null;
+  constructor(directory) {
+    this.directory = directory;
+  }
+  async ensure_deps() {
+    if (!this.fs) {
+      this.fs = await import("fs/promises");
+      this.path = await import("path");
+    }
+  }
+  state_path(workflow_id) {
+    return this.path.join(this.directory, `${workflow_id}.state.json`);
+  }
+  async save(workflow_id, state) {
+    await this.ensure_deps();
+    await this.fs.mkdir(this.directory, { recursive: true });
+    await this.fs.writeFile(
+      this.state_path(workflow_id),
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    );
+  }
+  async load(workflow_id) {
+    await this.ensure_deps();
+    try {
+      const content = await this.fs.readFile(this.state_path(workflow_id), "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async delete(workflow_id) {
+    await this.ensure_deps();
+    try {
+      await this.fs.unlink(this.state_path(workflow_id));
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async list() {
+    await this.ensure_deps();
+    try {
+      const files = await this.fs.readdir(this.directory);
+      return files.filter((f) => f.endsWith(".state.json")).map((f) => f.replace(".state.json", ""));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+};
+function serialize_token(token) {
+  return {
+    id: token.id,
+    activity_id: token.activityId,
+    status: token.status,
+    context_data: token.contextData,
+    created_at: token.createdAt.toISOString(),
+    updated_at: token.updatedAt.toISOString()
+  };
+}
+function deserialize_token(data, workflow_id) {
+  const token = new Token(
+    data.activity_id,
+    data.context_data,
+    void 0,
+    // parentTokenId
+    workflow_id
+  );
+  token.id = data.id;
+  token.updateStatus(data.status);
+  return token;
+}
+var CheckpointManager = class {
+  adapter;
+  logger;
+  auto_checkpoint_interval;
+  constructor(adapter, logger) {
+    this.adapter = adapter;
+    this.logger = logger || get_logger();
+  }
+  /**
+   * Create a checkpoint of the current workflow state
+   */
+  async checkpoint(workflow2, engine_status, tokens, contexts, metadata) {
+    const state = {
+      version: "1.0",
+      workflow_id: workflow2.id,
+      workflow_name: workflow2.name,
+      workflow_version: workflow2.version,
+      engine_status,
+      tokens: tokens.map(serialize_token),
+      contexts,
+      checkpoint_at: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    await this.adapter.save(workflow2.id, state);
+    this.logger.info("Workflow checkpoint created", {
+      workflow_id: workflow2.id,
+      token_count: tokens.length,
+      engine_status
+    });
+    return state;
+  }
+  /**
+   * Load a workflow checkpoint
+   */
+  async load(workflow_id) {
+    const state = await this.adapter.load(workflow_id);
+    if (state) {
+      this.logger.info("Workflow checkpoint loaded", {
+        workflow_id,
+        checkpoint_at: state.checkpoint_at,
+        token_count: state.tokens.length
+      });
+    }
+    return state;
+  }
+  /**
+   * Delete a workflow checkpoint
+   */
+  async delete(workflow_id) {
+    await this.adapter.delete(workflow_id);
+    this.logger.info("Workflow checkpoint deleted", { workflow_id });
+  }
+  /**
+   * List all checkpointed workflows
+   */
+  async list() {
+    return this.adapter.list();
+  }
+  /**
+   * Restore tokens from a checkpoint
+   */
+  restore_tokens(state) {
+    return state.tokens.map((t) => deserialize_token(t, state.workflow_id));
+  }
+  /**
+   * Enable auto-checkpointing at intervals
+   */
+  enable_auto_checkpoint(interval_ms, get_state) {
+    this.disable_auto_checkpoint();
+    this.auto_checkpoint_interval = setInterval(async () => {
+      try {
+        const { workflow: workflow2, engine_status, tokens, contexts } = await get_state();
+        if (engine_status === "running" || engine_status === "waiting_human") {
+          await this.checkpoint(workflow2, engine_status, tokens, contexts);
+        }
+      } catch (error) {
+        this.logger.error("Auto-checkpoint failed", error);
+      }
+    }, interval_ms);
+    this.logger.info("Auto-checkpoint enabled", { interval_ms });
+  }
+  /**
+   * Disable auto-checkpointing
+   */
+  disable_auto_checkpoint() {
+    if (this.auto_checkpoint_interval) {
+      clearInterval(this.auto_checkpoint_interval);
+      this.auto_checkpoint_interval = void 0;
+      this.logger.info("Auto-checkpoint disabled");
+    }
+  }
+};
+var global_checkpoint_manager;
+function get_checkpoint_manager() {
+  if (!global_checkpoint_manager) {
+    global_checkpoint_manager = new CheckpointManager(new InMemoryPersistenceAdapter());
+  }
+  return global_checkpoint_manager;
+}
+function set_checkpoint_manager(manager) {
+  global_checkpoint_manager = manager;
+}
+function create_file_checkpoint_manager(directory, logger) {
+  return new CheckpointManager(new FilePersistenceAdapter(directory), logger);
+}
+
+// src/builder/index.ts
+var import_uuid3 = require("uuid");
+var WorkflowBuilder = class {
+  workflow;
+  activityMap = /* @__PURE__ */ new Map();
+  contextMap = /* @__PURE__ */ new Map();
+  constructor(name, version = "1.0.0") {
+    this.workflow = {
+      id: (0, import_uuid3.v4)(),
+      name,
+      version,
+      activities: [],
+      edges: [],
+      events: [],
+      decision_nodes: [],
+      contexts: [],
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Set workflow description
+   */
+  description(description) {
+    this.workflow.description = description;
+    return this;
+  }
+  /**
+   * Set workflow owner
+   */
+  owner(owner_id) {
+    this.workflow.owner_id = owner_id;
+    return this;
+  }
+  /**
+   * Set owning organization
+   */
+  organization(organization_id) {
+    this.workflow.organization_id = organization_id;
+    return this;
+  }
+  /**
+   * Add a context for agent collaboration
+   */
+  context(name, config) {
+    const context = {
+      id: (0, import_uuid3.v4)(),
+      name,
+      type: config.type,
+      sync_pattern: config.sync_pattern,
+      description: config.description,
+      schema: config.schema,
+      initial_value: config.initial_value,
+      visibility: config.visibility || "workflow",
+      owner_workflow_id: this.workflow.id,
+      lifecycle: "persistent"
+    };
+    this.contextMap.set(name, context);
+    this.workflow.contexts.push(context);
+    return this;
+  }
+  /**
+   * Add an activity to the workflow
+   */
+  activity(name, config) {
+    const activityId = (0, import_uuid3.v4)();
+    const contextBindings = (config.contexts || []).map((ctx) => {
+      const contextObj = this.contextMap.get(ctx.id);
+      return {
+        id: (0, import_uuid3.v4)(),
+        context_id: contextObj?.id || ctx.id,
+        activity_id: activityId,
+        access_mode: ctx.access_mode,
+        required: ctx.required ?? true
+      };
+    });
+    const accessRights = (config.access_rights || []).map((ar) => ({
+      id: (0, import_uuid3.v4)(),
+      name: ar.name,
+      activity_id: activityId,
+      direction: ar.direction || "requires",
+      resource_type: ar.resource_type,
+      resource_id: ar.resource_id,
+      permission: ar.permission,
+      scope: ar.scope
+    }));
+    const activity = {
+      id: activityId,
+      name,
+      description: config.description,
+      role_id: config.role_id,
+      actor_type: config.actor_type,
+      system_id: config.system_id,
+      machine_id: config.machine_id,
+      endpoint_id: config.endpoint_id,
+      organization_id: config.organization_id,
+      inputs: [],
+      outputs: [],
+      context_bindings: contextBindings,
+      access_rights: accessRights,
+      programs: [],
+      controls: [],
+      sla: config.sla,
+      analytics: config.analytics,
+      is_expandable: false,
+      skills: [],
+      tool_requirements: []
+    };
+    this.activityMap.set(name, activity);
+    this.workflow.activities.push(activity);
+    return this;
+  }
+  /**
+   * Add an edge between two activities
+   */
+  edge(sourceName, targetName, options) {
+    const source = this.activityMap.get(sourceName);
+    const target = this.activityMap.get(targetName);
+    if (!source) {
+      throw new Error(`Source activity '${sourceName}' not found`);
+    }
+    if (!target) {
+      throw new Error(`Target activity '${targetName}' not found`);
+    }
+    const edge = {
+      id: (0, import_uuid3.v4)(),
+      source_id: source.id,
+      target_id: target.id,
+      source_type: "activity",
+      target_type: "activity",
+      condition: options?.condition,
+      label: options?.label,
+      is_default: false,
+      skills: [],
+      tool_requirements: []
+    };
+    this.workflow.edges.push(edge);
+    return this;
+  }
+  /**
+   * Set workflow-level SLA
+   */
+  sla(sla) {
+    this.workflow.sla = sla;
+    return this;
+  }
+  /**
+   * Set workflow-level analytics
+   */
+  analytics(analytics) {
+    this.workflow.analytics = analytics;
+    return this;
+  }
+  /**
+   * Add metadata
+   */
+  metadata(key, value) {
+    if (!this.workflow.metadata) {
+      this.workflow.metadata = {};
+    }
+    this.workflow.metadata[key] = value;
+    return this;
+  }
+  /**
+   * Build and return the workflow
+   */
+  build() {
+    this.workflow.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    return this.workflow;
+  }
+  /**
+   * Get activity by name
+   */
+  getActivity(name) {
+    return this.activityMap.get(name);
+  }
+  /**
+   * Get context by name
+   */
+  getContext(name) {
+    return this.contextMap.get(name);
+  }
+};
+function workflow(name, version) {
+  return new WorkflowBuilder(name, version);
+}
+
+// src/client/query.ts
+var WorkflowQuery = class {
+  constructor(workflow2) {
+    this.workflow = workflow2;
+  }
+  /**
+   * Query activities
+   */
+  activities() {
+    return new ActivityQuery(this.workflow.activities);
+  }
+  /**
+   * Query contexts
+   */
+  contexts() {
+    return new ContextQuery(this.workflow.contexts);
+  }
+  /**
+   * Query all access rights across activities
+   */
+  access_rights() {
+    const allRights = this.workflow.activities.flatMap((a) => a.access_rights);
+    return new AccessRightQuery(allRights);
+  }
+  /**
+   * Query context bindings across activities
+   */
+  context_bindings() {
+    const allBindings = this.workflow.activities.flatMap((a) => a.context_bindings);
+    return new ContextBindingQuery(allBindings);
+  }
+};
+var ActivityQuery = class {
+  constructor(activities) {
+    this.activities = activities;
+  }
+  /**
+   * Filter by actor type
+   */
+  by_actor_type(type) {
+    this.activities = this.activities.filter((a) => a.actor_type === type);
+    return this;
+  }
+  /**
+   * Filter by system
+   */
+  by_system(system_id) {
+    this.activities = this.activities.filter((a) => a.system_id === system_id);
+    return this;
+  }
+  /**
+   * Filter by role
+   */
+  by_role(role_id) {
+    this.activities = this.activities.filter((a) => a.role_id === role_id);
+    return this;
+  }
+  /**
+   * Filter activities that have access rights
+   */
+  with_access_rights() {
+    this.activities = this.activities.filter((a) => a.access_rights.length > 0);
+    return this;
+  }
+  /**
+   * Filter activities bound to a specific context
+   */
+  bound_to_context(context_id) {
+    this.activities = this.activities.filter(
+      (a) => a.context_bindings.some((b) => b.context_id === context_id)
+    );
+    return this;
+  }
+  /**
+   * Custom filter
+   */
+  where(predicate) {
+    this.activities = this.activities.filter(predicate);
+    return this;
+  }
+  /**
+   * Get first result
+   */
+  first() {
+    return this.activities[0];
+  }
+  /**
+   * Get all results
+   */
+  list() {
+    return [...this.activities];
+  }
+  /**
+   * Count results
+   */
+  count() {
+    return this.activities.length;
+  }
+};
+var ContextQuery = class {
+  constructor(contexts) {
+    this.contexts = contexts;
+  }
+  /**
+   * Filter by type
+   */
+  by_type(type) {
+    this.contexts = this.contexts.filter((c) => c.type === type);
+    return this;
+  }
+  /**
+   * Filter by sync pattern
+   */
+  by_sync_pattern(pattern) {
+    this.contexts = this.contexts.filter((c) => c.sync_pattern === pattern);
+    return this;
+  }
+  /**
+   * Filter by visibility
+   */
+  by_visibility(visibility) {
+    this.contexts = this.contexts.filter((c) => c.visibility === visibility);
+    return this;
+  }
+  /**
+   * Custom filter
+   */
+  where(predicate) {
+    this.contexts = this.contexts.filter(predicate);
+    return this;
+  }
+  /**
+   * Get first result
+   */
+  first() {
+    return this.contexts[0];
+  }
+  /**
+   * Get all results
+   */
+  list() {
+    return [...this.contexts];
+  }
+  /**
+   * Count results
+   */
+  count() {
+    return this.contexts.length;
+  }
+};
+var AccessRightQuery = class {
+  constructor(rights) {
+    this.rights = rights;
+  }
+  /**
+   * Filter by permission
+   */
+  by_permission(permission) {
+    this.rights = this.rights.filter((r) => r.permission === permission);
+    return this;
+  }
+  /**
+   * Filter by resource type
+   */
+  by_resource_type(type) {
+    this.rights = this.rights.filter((r) => r.resource_type === type);
+    return this;
+  }
+  /**
+   * Filter by direction (requires/provisions)
+   */
+  by_direction(direction) {
+    this.rights = this.rights.filter((r) => r.direction === direction);
+    return this;
+  }
+  /**
+   * Filter by resource ID
+   */
+  by_resource_id(resource_id) {
+    this.rights = this.rights.filter((r) => r.resource_id === resource_id);
+    return this;
+  }
+  /**
+   * Custom filter
+   */
+  where(predicate) {
+    this.rights = this.rights.filter(predicate);
+    return this;
+  }
+  /**
+   * Get first result
+   */
+  first() {
+    return this.rights[0];
+  }
+  /**
+   * Get all results
+   */
+  list() {
+    return [...this.rights];
+  }
+  /**
+   * Count results
+   */
+  count() {
+    return this.rights.length;
+  }
+};
+var ContextBindingQuery = class {
+  constructor(bindings) {
+    this.bindings = bindings;
+  }
+  /**
+   * Filter by access mode
+   */
+  by_access_mode(mode) {
+    this.bindings = this.bindings.filter((b) => b.access_mode === mode);
+    return this;
+  }
+  /**
+   * Filter by context
+   */
+  by_context(context_id) {
+    this.bindings = this.bindings.filter((b) => b.context_id === context_id);
+    return this;
+  }
+  /**
+   * Custom filter
+   */
+  where(predicate) {
+    this.bindings = this.bindings.filter(predicate);
+    return this;
+  }
+  /**
+   * Get first result
+   */
+  first() {
+    return this.bindings[0];
+  }
+  /**
+   * Get all results
+   */
+  list() {
+    return [...this.bindings];
+  }
+  /**
+   * Count results
+   */
+  count() {
+    return this.bindings.length;
+  }
+};
+function query(workflow2) {
+  return new WorkflowQuery(workflow2);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDirection,
+  AccessMode,
+  AccessRightQuery,
+  AccessRightSchema,
+  ActivityQuery,
+  ActivitySchema,
+  ActorType,
+  AnalyticsSchema,
+  AnimationConfigSchema,
+  AnimationEasing,
+  AutoLayoutConfigSchema,
+  CameraSettings2DSchema,
+  CameraSettings3DSchema,
+  CameraType,
+  CheckpointManager,
+  CollectionSchema,
+  ColorSchema,
+  ContextBindingQuery,
+  ContextBindingSchema,
+  ContextManager,
+  ContextQuery,
+  ContextSchema,
+  ContextType,
+  ControlSchema,
+  ControlType,
+  CurveType,
+  DEFAULT_RETRY_CONFIG,
+  DataObjectSchema,
+  DateTimeTz,
+  DeadLetterQueue,
+  DecisionEvaluator,
+  DecisionNodeSchema,
+  DecisionRuleSchema,
+  DecisionTableSchema,
+  Duration,
+  EdgeRoutingSchema,
+  EdgeSchema,
+  EdgeStyleSchema,
+  EndpointSchema,
+  Enforcement,
+  EventSchema,
+  FilePersistenceAdapter,
+  HitPolicy,
+  HumanAgent,
+  HumanTaskPriority,
+  HumanTaskSchema,
+  HumanTaskStatus,
+  InMemoryPersistenceAdapter,
+  LaneOrientation,
+  LaneSchema,
+  LayoutAlgorithm,
+  LayoutDirection,
+  Lifecycle,
+  MachineSchema,
+  NodeMaterial3DSchema,
+  NodePosition2DSchema,
+  NodePosition3DSchema,
+  NodeShape,
+  NodeStyle2DSchema,
+  NodeType,
+  ParameterSchema,
+  Permission,
+  ProgramSchema,
+  QuaternionSchema,
+  ResourceType,
+  RobotAgent,
+  RoleSchema,
+  SLASchema,
+  SkillBindingSchema,
+  SkillType,
+  SyncPattern,
+  SystemSchema,
+  TableColumnSchema,
+  ThemeConfigSchema,
+  Token,
+  ToolRequirementSchema,
+  ToolRequirementType,
+  UUID,
+  Vector2DSchema,
+  Vector3DSchema,
+  ViewType,
+  Visibility,
+  VisualizationConfigSchema,
+  VisualizationEngine,
+  WasteCategory,
+  WorkflowBuilder,
+  WorkflowEngine,
+  WorkflowQuery,
+  WorkflowSchema,
+  calculate_retry_delay,
+  create_file_checkpoint_manager,
+  create_retryable_executor,
+  deserialize_token,
+  evaluate_decision,
+  get_checkpoint_manager,
+  get_dead_letter_queue,
+  is_retryable_error,
+  parse_activity,
+  parse_context,
+  parse_workflow,
+  query,
+  serialize_token,
+  set_checkpoint_manager,
+  set_dead_letter_queue,
+  sleep,
+  validate_activity,
+  validate_context,
+  validate_workflow,
+  validate_workflow_integrity,
+  with_retry,
+  workflow
+});