@contractspec/example.workflow-system 1.57.0 → 1.58.0

package/dist/browser/index.js

@@ -0,0 +1,3120 @@
+// src/approval/approval.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var ApprovalStatusEnum = defineEnum("ApprovalStatus", [
+  "PENDING",
+  "APPROVED",
+  "REJECTED",
+  "DELEGATED",
+  "ESCALATED",
+  "WITHDRAWN",
+  "EXPIRED"
+]);
+var ApprovalDecisionEnum = defineEnum("ApprovalDecision", [
+  "APPROVE",
+  "REJECT",
+  "REQUEST_CHANGES",
+  "DELEGATE",
+  "ABSTAIN"
+]);
+
+// src/approval/approval.event.ts
+import { defineEvent, defineSchemaModel } from "@contractspec/lib.contracts";
+import { ScalarTypeEnum } from "@contractspec/lib.schema";
+var ApprovalRequestedPayload = defineSchemaModel({
+  name: "ApprovalRequestedEventPayload",
+  description: "Payload when approval is requested",
+  fields: {
+    requestId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    instanceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    approverId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    approverRole: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    dueAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ApprovalDecidedPayload = defineSchemaModel({
+  name: "ApprovalDecidedEventPayload",
+  description: "Payload when approval decision is made",
+  fields: {
+    requestId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    instanceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    decision: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    decidedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    comment: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ApprovalDelegatedPayload = defineSchemaModel({
+  name: "ApprovalDelegatedEventPayload",
+  description: "Payload when approval is delegated",
+  fields: {
+    requestId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    instanceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fromUserId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toUserId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    reason: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ApprovalEscalatedPayload = defineSchemaModel({
+  name: "ApprovalEscalatedEventPayload",
+  description: "Payload when approval is escalated",
+  fields: {
+    requestId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    instanceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    escalationLevel: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false
+    },
+    escalatedTo: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    reason: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ApprovalRequestedEvent = defineEvent({
+  meta: {
+    key: "workflow.approval.requested",
+    version: "1.0.0",
+    description: "An approval has been requested.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "requested"]
+  },
+  payload: ApprovalRequestedPayload
+});
+var ApprovalDecidedEvent = defineEvent({
+  meta: {
+    key: "workflow.approval.decided",
+    version: "1.0.0",
+    description: "An approval decision has been made.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "decided"]
+  },
+  payload: ApprovalDecidedPayload
+});
+var ApprovalDelegatedEvent = defineEvent({
+  meta: {
+    key: "workflow.approval.delegated",
+    version: "1.0.0",
+    description: "An approval has been delegated.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "delegated"]
+  },
+  payload: ApprovalDelegatedPayload
+});
+var ApprovalEscalatedEvent = defineEvent({
+  meta: {
+    key: "workflow.approval.escalated",
+    version: "1.0.0",
+    description: "An approval has been escalated.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "escalated"]
+  },
+  payload: ApprovalEscalatedPayload
+});
+
+// src/shared/mock-data.ts
+var mockDataStore = {
+  workflows: new Map,
+  steps: new Map,
+  instances: new Map,
+  approvals: new Map,
+  stepExecutions: new Map
+};
+
+// src/state-machine/index.ts
+class BasicStateMachineEngine {
+  canTransition(definition, state, action, context) {
+    if (state.status !== "RUNNING" && state.status !== "WAITING") {
+      return {
+        allowed: false,
+        reason: `Workflow is ${state.status}, cannot transition`
+      };
+    }
+    const currentStep = definition.steps[state.currentStepKey];
+    if (!currentStep) {
+      return {
+        allowed: false,
+        reason: `Step ${state.currentStepKey} not found`
+      };
+    }
+    const transition = currentStep.transitions[action];
+    if (!transition) {
+      return {
+        allowed: false,
+        reason: `Action ${action} not available in step ${state.currentStepKey}`
+      };
+    }
+    if (currentStep.allowedRoles && currentStep.allowedRoles.length > 0) {
+      const hasRole = currentStep.allowedRoles.some((role) => context.userRoles.includes(role));
+      if (!hasRole) {
+        return {
+          allowed: false,
+          reason: `User lacks required role for this action`
+        };
+      }
+    }
+    if (typeof transition === "object" && transition.allowedRoles && transition.allowedRoles.length > 0) {
+      const hasRole = transition.allowedRoles.some((role) => context.userRoles.includes(role));
+      if (!hasRole) {
+        return {
+          allowed: false,
+          reason: `User lacks required role for action ${action}`
+        };
+      }
+    }
+    return { allowed: true };
+  }
+  getAvailableActions(definition, state, context) {
+    if (state.status !== "RUNNING" && state.status !== "WAITING") {
+      return [];
+    }
+    const currentStep = definition.steps[state.currentStepKey];
+    if (!currentStep) {
+      return [];
+    }
+    return Object.keys(currentStep.transitions).filter((action) => {
+      const result = this.canTransition(definition, state, action, context);
+      return result.allowed;
+    });
+  }
+  transition(definition, state, action, context) {
+    const validation = this.canTransition(definition, state, action, context);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: validation.reason
+      };
+    }
+    const currentStep = definition.steps[state.currentStepKey];
+    if (!currentStep) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: `Current step ${state.currentStepKey} not found`
+      };
+    }
+    const transition = currentStep.transitions[action];
+    if (!transition) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: `Transition for action ${action} not found`
+      };
+    }
+    const targetStepKey = typeof transition === "string" ? transition : transition.targetStepKey;
+    const targetStep = definition.steps[targetStepKey];
+    if (!targetStep) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: `Target step ${targetStepKey} not found`
+      };
+    }
+    let newStatus = "RUNNING";
+    if (targetStep.type === "END") {
+      newStatus = "COMPLETED";
+    } else if (targetStep.type === "APPROVAL" || targetStep.type === "WAIT") {
+      newStatus = "WAITING";
+    }
+    return {
+      success: true,
+      previousStepKey: state.currentStepKey,
+      currentStepKey: targetStepKey,
+      status: newStatus
+    };
+  }
+  evaluateCondition(expression, contextData) {
+    try {
+      const match = expression.match(/^(\w+)\s*(>=|<=|>|<|===|!==|==|!=)\s*(.+)$/);
+      if (match) {
+        const [, prop, operator, value] = match;
+        if (!prop || !operator || value === undefined) {
+          return false;
+        }
+        const propValue = contextData[prop];
+        const compareValue = JSON.parse(value);
+        switch (operator) {
+          case ">":
+            return Number(propValue) > Number(compareValue);
+          case "<":
+            return Number(propValue) < Number(compareValue);
+          case ">=":
+            return Number(propValue) >= Number(compareValue);
+          case "<=":
+            return Number(propValue) <= Number(compareValue);
+          case "===":
+          case "==":
+            return propValue === compareValue;
+          case "!==":
+          case "!=":
+            return propValue !== compareValue;
+        }
+      }
+      if (expression in contextData) {
+        return Boolean(contextData[expression]);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+}
+function createStateMachineEngine() {
+  return new BasicStateMachineEngine;
+}
+function buildStateMachineDefinition(workflow, steps) {
+  const stepMap = {};
+  for (const step of steps) {
+    stepMap[step.key] = {
+      key: step.key,
+      name: step.name,
+      type: step.type,
+      transitions: step.transitions,
+      approvalMode: step.approvalMode,
+      allowedRoles: step.approverRoles,
+      timeoutSeconds: step.timeoutSeconds,
+      conditionExpression: step.conditionExpression
+    };
+  }
+  const startStep = steps.find((s) => s.type === "START");
+  const initialStepKey = startStep?.key ?? steps[0]?.key ?? "";
+  return {
+    key: workflow.key,
+    name: workflow.name,
+    version: workflow.version,
+    initialStepKey,
+    steps: stepMap
+  };
+}
+function createInitialState(definition, contextData = {}) {
+  return {
+    currentStepKey: definition.initialStepKey,
+    status: "RUNNING",
+    contextData,
+    history: []
+  };
+}
+
+// src/approval/approval.schema.ts
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var ApprovalRequestModel = defineSchemaModel2({
+  name: "ApprovalRequestModel",
+  description: "An approval request",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    workflowInstanceId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    stepExecutionId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    approverId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    approverRole: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    title: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    status: { type: ApprovalStatusEnum, isOptional: false },
+    decision: { type: ApprovalDecisionEnum, isOptional: true },
+    decisionComment: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    decidedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    dueAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    contextSnapshot: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    sequenceOrder: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var ApprovalCommentModel = defineSchemaModel2({
+  name: "ApprovalCommentModel",
+  description: "A comment on an approval",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    approvalRequestId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    authorId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    content: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    isInternal: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+
+// src/approval/approval.operations.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var OWNERS = ["@example.workflow-system"];
+var SubmitDecisionContract = defineCommand({
+  meta: {
+    key: "workflow.approval.decide",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "approval", "decision"],
+    description: "Submit an approval decision (approve/reject).",
+    goal: "Allow approvers to make decisions on requests.",
+    context: "Approval inbox, workflow detail."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "ApproveRejectInput",
+      fields: {
+        requestId: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        },
+        decision: { type: ApprovalDecisionEnum, isOptional: false },
+        comment: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        data: { type: ScalarTypeEnum3.JSON(), isOptional: true }
+      }
+    }),
+    output: ApprovalRequestModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.approval.decided",
+        version: "1.0.0",
+        when: "Decision is made",
+        payload: ApprovalRequestModel
+      }
+    ],
+    audit: ["workflow.approval.decided"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "approve-request-happy-path",
+        given: ["Approval request is pending", "User is assignee"],
+        when: ["User approves request"],
+        then: ["Request is approved", "ApprovalDecided event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "approve-basic",
+        input: {
+          requestId: "req-123",
+          decision: "approve",
+          comment: "Looks good"
+        },
+        output: { id: "req-123", status: "approved" }
+      }
+    ]
+  }
+});
+var DelegateApprovalContract = defineCommand({
+  meta: {
+    key: "workflow.approval.delegate",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "approval", "delegate"],
+    description: "Delegate an approval request to another user.",
+    goal: "Allow approvers to pass approval to others.",
+    context: "Approval inbox."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "DelegateInput",
+      fields: {
+        requestId: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        },
+        delegateTo: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        },
+        reason: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: ApprovalRequestModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.approval.delegated",
+        version: "1.0.0",
+        when: "Approval is delegated",
+        payload: ApprovalRequestModel
+      }
+    ],
+    audit: ["workflow.approval.delegated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "delegate-approval-happy-path",
+        given: ["Approval request is pending", "User is assignee"],
+        when: ["User delegates to another user"],
+        then: ["Assignee is updated", "ApprovalDelegated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "delegate-to-manager",
+        input: {
+          requestId: "req-123",
+          delegateTo: "user-456",
+          reason: "Out of office"
+        },
+        output: { id: "req-123", assigneeId: "user-456" }
+      }
+    ]
+  }
+});
+var AddApprovalCommentContract = defineCommand({
+  meta: {
+    key: "workflow.approval.comment.add",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "approval", "comment"],
+    description: "Add a comment to an approval request.",
+    goal: "Allow discussion on approval requests.",
+    context: "Approval detail view."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "AddCommentInput",
+      fields: {
+        requestId: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        },
+        content: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
+        isInternal: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+      }
+    }),
+    output: ApprovalCommentModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.approval.comment.added",
+        version: "1.0.0",
+        when: "Comment is added",
+        payload: ApprovalCommentModel
+      }
+    ]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "add-comment-happy-path",
+        given: ["Approval request exists"],
+        when: ["User adds a comment"],
+        then: ["Comment is added", "CommentAdded event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "add-question",
+        input: {
+          requestId: "req-123",
+          content: "Can you clarify budget?",
+          isInternal: false
+        },
+        output: { id: "com-789", content: "Can you clarify budget?" }
+      }
+    ]
+  }
+});
+var ListMyApprovalsContract = defineQuery({
+  meta: {
+    key: "workflow.approval.list.mine",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "approval", "list", "inbox"],
+    description: "List approval requests assigned to current user.",
+    goal: "Show pending approvals in user inbox.",
+    context: "Approval inbox, dashboard widget."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "ListMyApprovalsInput",
+      fields: {
+        status: { type: ApprovalStatusEnum, isOptional: true },
+        limit: {
+          type: ScalarTypeEnum3.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum3.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel3({
+      name: "ListMyApprovalsOutput",
+      fields: {
+        requests: {
+          type: ApprovalRequestModel,
+          isArray: true,
+          isOptional: false
+        },
+        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+        pendingCount: {
+          type: ScalarTypeEnum3.Int_unsecure(),
+          isOptional: false
+        }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-approvals-happy-path",
+        given: ["User has assigned approvals"],
+        when: ["User lists approvals"],
+        then: ["List of requests is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-pending",
+        input: { status: "pending", limit: 10 },
+        output: { requests: [], total: 2, pendingCount: 2 }
+      }
+    ]
+  }
+});
+var GetApprovalContract = defineQuery({
+  meta: {
+    key: "workflow.approval.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "approval", "get"],
+    description: "Get an approval request with details.",
+    goal: "View approval request details.",
+    context: "Approval detail view."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "GetApprovalInput",
+      fields: {
+        requestId: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: ApprovalRequestModel
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-approval-happy-path",
+        given: ["Approval request exists"],
+        when: ["User requests approval details"],
+        then: ["Approval details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-basic",
+        input: { requestId: "req-123" },
+        output: { id: "req-123", status: "pending" }
+      }
+    ]
+  }
+});
+// src/handlers/workflow.handlers.ts
+import { web } from "@contractspec/lib.runtime-sandbox";
+var { generateId } = web;
+function rowToDefinition(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    organizationId: row.organizationId,
+    name: row.name,
+    description: row.description ?? undefined,
+    type: row.type,
+    status: row.status,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+function rowToStep(row) {
+  return {
+    id: row.id,
+    definitionId: row.definitionId,
+    name: row.name,
+    description: row.description ?? undefined,
+    stepOrder: row.stepOrder,
+    type: row.type,
+    requiredRoles: row.requiredRoles ? JSON.parse(row.requiredRoles) : [],
+    autoApproveCondition: row.autoApproveCondition ?? undefined,
+    timeoutHours: row.timeoutHours ?? undefined,
+    createdAt: new Date(row.createdAt)
+  };
+}
+function rowToInstance(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    definitionId: row.definitionId,
+    status: row.status,
+    currentStepId: row.currentStepId ?? undefined,
+    data: row.data ? JSON.parse(row.data) : undefined,
+    requestedBy: row.requestedBy,
+    startedAt: new Date(row.startedAt),
+    completedAt: row.completedAt ? new Date(row.completedAt) : undefined
+  };
+}
+function rowToApproval(row) {
+  return {
+    id: row.id,
+    instanceId: row.instanceId,
+    stepId: row.stepId,
+    status: row.status,
+    actorId: row.actorId ?? undefined,
+    comment: row.comment ?? undefined,
+    decidedAt: row.decidedAt ? new Date(row.decidedAt) : undefined,
+    createdAt: new Date(row.createdAt)
+  };
+}
+function createWorkflowHandlers(db) {
+  async function listDefinitions(input) {
+    const { projectId, status, search, limit = 20, offset = 0 } = input;
+    let whereClause = "WHERE projectId = ?";
+    const params = [projectId];
+    if (status && status !== "all") {
+      whereClause += " AND status = ?";
+      params.push(status);
+    }
+    if (search) {
+      whereClause += " AND name LIKE ?";
+      params.push(`%${search}%`);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM workflow_definition ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT * FROM workflow_definition ${whereClause} ORDER BY updatedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      definitions: rows.map(rowToDefinition),
+      total
+    };
+  }
+  async function createDefinition(input, context) {
+    const id = generateId("wfdef");
+    const now = new Date().toISOString();
+    await db.execute(`INSERT INTO workflow_definition (id, projectId, organizationId, name, description, type, status, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      context.projectId,
+      context.organizationId,
+      input.name,
+      input.description ?? null,
+      input.type ?? "APPROVAL",
+      "DRAFT",
+      now,
+      now
+    ]);
+    const rows = (await db.query(`SELECT * FROM workflow_definition WHERE id = ?`, [id])).rows;
+    return rowToDefinition(rows[0]);
+  }
+  async function addStep(input) {
+    const id = generateId("wfstep");
+    const now = new Date().toISOString();
+    const maxOrderResult = (await db.query(`SELECT MAX(stepOrder) as maxOrder FROM workflow_step WHERE definitionId = ?`, [input.definitionId])).rows;
+    const nextOrder = (maxOrderResult[0]?.maxOrder ?? 0) + 1;
+    await db.execute(`INSERT INTO workflow_step (id, definitionId, name, description, stepOrder, type, requiredRoles, autoApproveCondition, timeoutHours, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      input.definitionId,
+      input.name,
+      input.description ?? null,
+      nextOrder,
+      input.type ?? "APPROVAL",
+      JSON.stringify(input.requiredRoles),
+      input.autoApproveCondition ?? null,
+      input.timeoutHours ?? null,
+      now
+    ]);
+    const rows = (await db.query(`SELECT * FROM workflow_step WHERE id = ?`, [id])).rows;
+    return rowToStep(rows[0]);
+  }
+  async function getSteps(definitionId) {
+    const rows = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? ORDER BY stepOrder`, [definitionId])).rows;
+    return rows.map(rowToStep);
+  }
+  async function listInstances(input) {
+    const {
+      projectId,
+      definitionId,
+      status,
+      requestedBy,
+      limit = 20,
+      offset = 0
+    } = input;
+    let whereClause = "WHERE projectId = ?";
+    const params = [projectId];
+    if (definitionId) {
+      whereClause += " AND definitionId = ?";
+      params.push(definitionId);
+    }
+    if (status && status !== "all") {
+      whereClause += " AND status = ?";
+      params.push(status);
+    }
+    if (requestedBy) {
+      whereClause += " AND requestedBy = ?";
+      params.push(requestedBy);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM workflow_instance ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT * FROM workflow_instance ${whereClause} ORDER BY startedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      instances: rows.map(rowToInstance),
+      total
+    };
+  }
+  async function startInstance(input, context) {
+    const id = generateId("wfinst");
+    const now = new Date().toISOString();
+    const steps = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? ORDER BY stepOrder LIMIT 1`, [input.definitionId])).rows;
+    const firstStepId = steps[0]?.id ?? null;
+    await db.execute(`INSERT INTO workflow_instance (id, projectId, definitionId, status, currentStepId, data, requestedBy, startedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      context.projectId,
+      input.definitionId,
+      firstStepId ? "IN_PROGRESS" : "PENDING",
+      firstStepId,
+      input.data ? JSON.stringify(input.data) : null,
+      context.requestedBy,
+      now
+    ]);
+    if (firstStepId) {
+      await db.execute(`INSERT INTO workflow_approval (id, instanceId, stepId, status, createdAt)
+         VALUES (?, ?, ?, ?, ?)`, [generateId("wfappr"), id, firstStepId, "PENDING", now]);
+    }
+    const rows = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [id])).rows;
+    return rowToInstance(rows[0]);
+  }
+  async function approveStep(input, context) {
+    const now = new Date().toISOString();
+    const instances = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
+      input.instanceId
+    ])).rows;
+    if (!instances[0]) {
+      throw new Error("NOT_FOUND");
+    }
+    const instance = instances[0];
+    await db.execute(`UPDATE workflow_approval SET status = 'APPROVED', actorId = ?, comment = ?, decidedAt = ? 
+       WHERE instanceId = ? AND stepId = ? AND status = 'PENDING'`, [
+      context.actorId,
+      input.comment ?? null,
+      now,
+      input.instanceId,
+      instance.currentStepId
+    ]);
+    const currentStep = (await db.query(`SELECT * FROM workflow_step WHERE id = ?`, [
+      instance.currentStepId
+    ])).rows;
+    const nextSteps = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? AND stepOrder > ? ORDER BY stepOrder LIMIT 1`, [instance.definitionId, currentStep[0]?.stepOrder ?? 0])).rows;
+    if (nextSteps[0]) {
+      await db.execute(`UPDATE workflow_instance SET currentStepId = ? WHERE id = ?`, [nextSteps[0].id, input.instanceId]);
+      await db.execute(`INSERT INTO workflow_approval (id, instanceId, stepId, status, createdAt)
+         VALUES (?, ?, ?, ?, ?)`, [
+        generateId("wfappr"),
+        input.instanceId,
+        nextSteps[0].id,
+        "PENDING",
+        now
+      ]);
+    } else {
+      await db.execute(`UPDATE workflow_instance SET status = 'COMPLETED', currentStepId = NULL, completedAt = ? WHERE id = ?`, [now, input.instanceId]);
+    }
+    const updated = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
+      input.instanceId
+    ])).rows;
+    return rowToInstance(updated[0]);
+  }
+  async function rejectStep(input, context) {
+    const now = new Date().toISOString();
+    const instances = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
+      input.instanceId
+    ])).rows;
+    if (!instances[0]) {
+      throw new Error("NOT_FOUND");
+    }
+    await db.execute(`UPDATE workflow_approval SET status = 'REJECTED', actorId = ?, comment = ?, decidedAt = ? 
+       WHERE instanceId = ? AND stepId = ? AND status = 'PENDING'`, [
+      context.actorId,
+      input.reason,
+      now,
+      input.instanceId,
+      instances[0].currentStepId
+    ]);
+    await db.execute(`UPDATE workflow_instance SET status = 'REJECTED', completedAt = ? WHERE id = ?`, [now, input.instanceId]);
+    const updated = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
+      input.instanceId
+    ])).rows;
+    return rowToInstance(updated[0]);
+  }
+  async function getApprovals(instanceId) {
+    const rows = (await db.query(`SELECT * FROM workflow_approval WHERE instanceId = ? ORDER BY createdAt`, [instanceId])).rows;
+    return rows.map(rowToApproval);
+  }
+  return {
+    listDefinitions,
+    createDefinition,
+    addStep,
+    getSteps,
+    listInstances,
+    startInstance,
+    approveStep,
+    rejectStep,
+    getApprovals
+  };
+}
+
+// src/workflow/workflow.enum.ts
+import { defineEnum as defineEnum2 } from "@contractspec/lib.schema";
+var WorkflowStatusEnum = defineEnum2("WorkflowStatus", [
+  "DRAFT",
+  "ACTIVE",
+  "DEPRECATED",
+  "ARCHIVED"
+]);
+var TriggerTypeEnum = defineEnum2("WorkflowTriggerType", [
+  "MANUAL",
+  "EVENT",
+  "SCHEDULED",
+  "API"
+]);
+var StepTypeEnum = defineEnum2("StepType", [
+  "START",
+  "APPROVAL",
+  "TASK",
+  "CONDITION",
+  "PARALLEL",
+  "WAIT",
+  "ACTION",
+  "END"
+]);
+var ApprovalModeEnum = defineEnum2("ApprovalMode", [
+  "ANY",
+  "ALL",
+  "MAJORITY",
+  "SEQUENTIAL"
+]);
+
+// src/workflow/workflow.schema.ts
+import { defineSchemaModel as defineSchemaModel4, ScalarTypeEnum as ScalarTypeEnum4 } from "@contractspec/lib.schema";
+var WorkflowStepModel = defineSchemaModel4({
+  name: "WorkflowStepModel",
+  description: "A step in a workflow definition",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    key: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    type: { type: StepTypeEnum, isOptional: false },
+    position: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    transitions: { type: ScalarTypeEnum4.JSON(), isOptional: false },
+    approvalMode: { type: ApprovalModeEnum, isOptional: true },
+    approverRoles: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var WorkflowDefinitionModel = defineSchemaModel4({
+  name: "WorkflowDefinitionModel",
+  description: "A workflow definition",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    key: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    version: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    status: { type: WorkflowStatusEnum, isOptional: false },
+    triggerType: { type: TriggerTypeEnum, isOptional: false },
+    initialStepId: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: true
+    },
+    featureFlagKey: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: true
+    },
+    organizationId: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: false
+    },
+    createdAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    steps: { type: WorkflowStepModel, isArray: true, isOptional: true }
+  }
+});
+var CreateWorkflowInputModel = defineSchemaModel4({
+  name: "CreateWorkflowInput",
+  description: "Input for creating a workflow definition",
+  fields: {
+    name: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    key: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    triggerType: { type: TriggerTypeEnum, isOptional: true },
+    triggerConfig: { type: ScalarTypeEnum4.JSON(), isOptional: true },
+    featureFlagKey: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: true
+    },
+    settings: { type: ScalarTypeEnum4.JSON(), isOptional: true }
+  }
+});
+var UpdateWorkflowInputModel = defineSchemaModel4({
+  name: "UpdateWorkflowInput",
+  description: "Input for updating a workflow definition",
+  fields: {
+    workflowId: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    triggerType: { type: TriggerTypeEnum, isOptional: true },
+    triggerConfig: { type: ScalarTypeEnum4.JSON(), isOptional: true },
+    featureFlagKey: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: true
+    },
+    settings: { type: ScalarTypeEnum4.JSON(), isOptional: true }
+  }
+});
+var AddStepInputModel = defineSchemaModel4({
+  name: "AddStepInput",
+  description: "Input for adding a step to a workflow",
+  fields: {
+    workflowId: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: false
+    },
+    key: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    name: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    type: { type: StepTypeEnum, isOptional: false },
+    position: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
+    transitions: { type: ScalarTypeEnum4.JSON(), isOptional: false },
+    approvalMode: { type: ApprovalModeEnum, isOptional: true },
+    approverRoles: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    approverUserIds: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    timeoutSeconds: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
+    slaSeconds: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true }
+  }
+});
+
+// src/workflow/workflow.operations.ts
+import {
+  defineCommand as defineCommand2,
+  defineQuery as defineQuery2
+} from "@contractspec/lib.contracts/operations";
+import { defineSchemaModel as defineSchemaModel5, ScalarTypeEnum as ScalarTypeEnum5 } from "@contractspec/lib.schema";
+var OWNERS2 = ["@example.workflow-system"];
+var CreateWorkflowContract = defineCommand2({
+  meta: {
+    key: "workflow.definition.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "definition", "create"],
+    description: "Create a new workflow definition.",
+    goal: "Allow users to define new workflow blueprints.",
+    context: "Workflow designer, admin panel."
+  },
+  io: {
+    input: CreateWorkflowInputModel,
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.definition.created",
+        version: "1.0.0",
+        when: "Workflow is created",
+        payload: WorkflowDefinitionModel
+      }
+    ],
+    audit: ["workflow.definition.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-workflow-happy-path",
+        given: ["User is admin"],
+        when: ["User creates new workflow definition"],
+        then: [
+          "Definition is created",
+          "WorkflowDefinitionCreated event is emitted"
+        ]
+      }
+    ],
+    examples: [
+      {
+        key: "create-onboarding",
+        input: {
+          key: "onboarding-v1",
+          name: "Employee Onboarding",
+          version: "1.0.0"
+        },
+        output: { id: "def-123", status: "draft" }
+      }
+    ]
+  }
+});
+var UpdateWorkflowContract = defineCommand2({
+  meta: {
+    key: "workflow.definition.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "definition", "update"],
+    description: "Update an existing workflow definition.",
+    goal: "Allow users to modify workflow blueprints.",
+    context: "Workflow designer."
+  },
+  io: {
+    input: UpdateWorkflowInputModel,
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.definition.updated",
+        version: "1.0.0",
+        when: "Workflow is updated",
+        payload: WorkflowDefinitionModel
+      }
+    ],
+    audit: ["workflow.definition.updated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "update-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User updates definition"],
+        then: [
+          "Definition is updated",
+          "WorkflowDefinitionUpdated event is emitted"
+        ]
+      }
+    ],
+    examples: [
+      {
+        key: "update-name",
+        input: { workflowId: "def-123", name: "New Employee Onboarding" },
+        output: { id: "def-123", name: "New Employee Onboarding" }
+      }
+    ]
+  }
+});
+var AddStepContract = defineCommand2({
+  meta: {
+    key: "workflow.step.add",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "step", "add"],
+    description: "Add a step to a workflow definition.",
+    goal: "Build workflow structure step by step.",
+    context: "Workflow designer."
+  },
+  io: {
+    input: AddStepInputModel,
+    output: WorkflowStepModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.step.added",
+        version: "1.0.0",
+        when: "Step is added",
+        payload: WorkflowStepModel
+      }
+    ],
+    audit: ["workflow.step.added"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "add-step-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User adds a step"],
+        then: ["Step is added", "StepAdded event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "add-approval-step",
+        input: {
+          workflowId: "def-123",
+          stepKey: "approve-contract",
+          type: "approval"
+        },
+        output: { id: "step-456", key: "approve-contract" }
+      }
+    ]
+  }
+});
+var PublishWorkflowContract = defineCommand2({
+  meta: {
+    key: "workflow.definition.publish",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "definition", "publish"],
+    description: "Publish a workflow definition to make it available for use.",
+    goal: "Activate workflow for production use.",
+    context: "Workflow designer, deployment."
+  },
+  io: {
+    input: defineSchemaModel5({
+      name: "PublishWorkflowInput",
+      fields: {
+        workflowId: {
+          type: ScalarTypeEnum5.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.definition.published",
+        version: "1.0.0",
+        when: "Workflow is published",
+        payload: WorkflowDefinitionModel
+      }
+    ],
+    audit: ["workflow.definition.published"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "publish-workflow-happy-path",
+        given: ["Workflow definition is valid"],
+        when: ["User publishes workflow"],
+        then: ["Workflow becomes active", "WorkflowPublished event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "publish-onboarding",
+        input: { workflowId: "def-123" },
+        output: { id: "def-123", status: "published" }
+      }
+    ]
+  }
+});
+var ListWorkflowsContract = defineQuery2({
+  meta: {
+    key: "workflow.definition.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "definition", "list"],
+    description: "List workflow definitions with filtering.",
+    goal: "Browse and search available workflows.",
+    context: "Workflow list, search."
+  },
+  io: {
+    input: defineSchemaModel5({
+      name: "ListWorkflowsInput",
+      fields: {
+        status: { type: WorkflowStatusEnum, isOptional: true },
+        search: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel5({
+      name: "ListWorkflowsOutput",
+      fields: {
+        workflows: {
+          type: WorkflowDefinitionModel,
+          isArray: true,
+          isOptional: false
+        },
+        total: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-workflows-happy-path",
+        given: ["Workflow definitions exist"],
+        when: ["User lists workflows"],
+        then: ["List of workflows is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-all",
+        input: { limit: 10 },
+        output: { workflows: [], total: 5 }
+      }
+    ]
+  }
+});
+var GetWorkflowContract = defineQuery2({
+  meta: {
+    key: "workflow.definition.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "definition", "get"],
+    description: "Get a workflow definition with all steps.",
+    goal: "View workflow details.",
+    context: "Workflow designer, detail view."
+  },
+  io: {
+    input: defineSchemaModel5({
+      name: "GetWorkflowInput",
+      fields: {
+        workflowId: {
+          type: ScalarTypeEnum5.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User requests workflow details"],
+        then: ["Workflow details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-details",
+        input: { workflowId: "def-123" },
+        output: { id: "def-123", name: "Employee Onboarding" }
+      }
+    ]
+  }
+});
+
+// src/workflow/workflow.event.ts
+import { defineEvent as defineEvent2, defineSchemaModel as defineSchemaModel6 } from "@contractspec/lib.contracts";
+import { ScalarTypeEnum as ScalarTypeEnum6 } from "@contractspec/lib.schema";
+var WorkflowDefinitionPayload = defineSchemaModel6({
+  name: "WorkflowDefinitionEventPayload",
+  description: "Payload for workflow definition events",
+  fields: {
+    workflowId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    key: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    version: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isOptional: false
+    },
+    createdBy: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
+  }
+});
+var StepAddedPayload = defineSchemaModel6({
+  name: "StepAddedEventPayload",
+  description: "Payload when a step is added",
+  fields: {
+    stepId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    stepKey: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    stepType: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    position: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
+  }
+});
+var WorkflowCreatedEvent = defineEvent2({
+  meta: {
+    key: "workflow.definition.created",
+    version: "1.0.0",
+    description: "A new workflow definition has been created.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "definition", "created"]
+  },
+  payload: WorkflowDefinitionPayload
+});
+var WorkflowUpdatedEvent = defineEvent2({
+  meta: {
+    key: "workflow.definition.updated",
+    version: "1.0.0",
+    description: "A workflow definition has been updated.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "definition", "updated"]
+  },
+  payload: WorkflowDefinitionPayload
+});
+var WorkflowPublishedEvent = defineEvent2({
+  meta: {
+    key: "workflow.definition.published",
+    version: "1.0.0",
+    description: "A workflow definition has been published and is now active.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "definition", "published"]
+  },
+  payload: WorkflowDefinitionPayload
+});
+var StepAddedEvent = defineEvent2({
+  meta: {
+    key: "workflow.step.added",
+    version: "1.0.0",
+    description: "A step has been added to a workflow definition.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "added"]
+  },
+  payload: StepAddedPayload
+});
+// src/instance/instance.enum.ts
+import { defineEnum as defineEnum3 } from "@contractspec/lib.schema";
+var InstanceStatusEnum = defineEnum3("InstanceStatus", [
+  "PENDING",
+  "RUNNING",
+  "WAITING",
+  "PAUSED",
+  "COMPLETED",
+  "CANCELLED",
+  "FAILED",
+  "TIMEOUT"
+]);
+
+// src/instance/instance.schema.ts
+import { defineSchemaModel as defineSchemaModel7, ScalarTypeEnum as ScalarTypeEnum7 } from "@contractspec/lib.schema";
+var WorkflowInstanceModel = defineSchemaModel7({
+  name: "WorkflowInstanceModel",
+  description: "A running workflow instance",
+  fields: {
+    id: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    workflowDefinitionId: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: false
+    },
+    referenceId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    status: { type: InstanceStatusEnum, isOptional: false },
+    currentStepId: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    contextData: { type: ScalarTypeEnum7.JSON(), isOptional: true },
+    triggeredBy: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: false
+    },
+    priority: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
+    dueAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true },
+    outcome: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    resultData: { type: ScalarTypeEnum7.JSON(), isOptional: true },
+    errorMessage: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    createdAt: { type: ScalarTypeEnum7.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true }
+  }
+});
+var StartWorkflowInputModel = defineSchemaModel7({
+  name: "StartWorkflowInput",
+  description: "Input for starting a workflow",
+  fields: {
+    workflowKey: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+    contextData: { type: ScalarTypeEnum7.JSON(), isOptional: true },
+    referenceId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    priority: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: true },
+    dueAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true }
+  }
+});
+var TransitionInputModel = defineSchemaModel7({
+  name: "TransitionInput",
+  description: "Input for transitioning a workflow",
+  fields: {
+    instanceId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    action: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+    data: { type: ScalarTypeEnum7.JSON(), isOptional: true },
+    comment: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true }
+  }
+});
+var TransitionResultModel = defineSchemaModel7({
+  name: "TransitionResult",
+  description: "Result of a workflow transition",
+  fields: {
+    success: { type: ScalarTypeEnum7.Boolean(), isOptional: false },
+    instance: { type: WorkflowInstanceModel, isOptional: false },
+    previousStepKey: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    currentStepKey: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    message: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true }
+  }
+});
+
+// src/instance/instance.operations.ts
+import {
+  defineCommand as defineCommand3,
+  defineQuery as defineQuery3
+} from "@contractspec/lib.contracts/operations";
+import { defineSchemaModel as defineSchemaModel8, ScalarTypeEnum as ScalarTypeEnum8 } from "@contractspec/lib.schema";
+var OWNERS3 = ["@example.workflow-system"];
+var StartWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.instance.start",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "start"],
+    description: "Start a new workflow instance.",
+    goal: "Initiate a workflow for a business process.",
+    context: "Order creation, request submission, etc."
+  },
+  io: {
+    input: StartWorkflowInputModel,
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.started",
+        version: "1.0.0",
+        when: "Workflow starts",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.step.entered",
+        version: "1.0.0",
+        when: "First step entered",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.started"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "start-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User starts workflow"],
+        then: ["Instance is created and started"]
+      }
+    ],
+    examples: [
+      {
+        key: "start-onboarding",
+        input: {
+          workflowKey: "onboarding-v1",
+          context: { employeeId: "emp-123" }
+        },
+        output: { id: "inst-456", status: "running" }
+      }
+    ]
+  }
+});
+var TransitionWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.instance.transition",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "transition", "state-machine"],
+    description: "Transition a workflow instance to the next step.",
+    goal: "Move workflow forward based on action.",
+    context: "Task completion, approval decisions."
+  },
+  io: {
+    input: TransitionInputModel,
+    output: TransitionResultModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.step.exited",
+        version: "1.0.0",
+        when: "Step is exited",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.step.entered",
+        version: "1.0.0",
+        when: "New step is entered",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.instance.completed",
+        version: "1.0.0",
+        when: "Workflow reaches end",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.transitioned"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "transition-workflow-happy-path",
+        given: ["Workflow instance is waiting at step"],
+        when: ["User provides input"],
+        then: ["Instance moves to next step"]
+      }
+    ],
+    examples: [
+      {
+        key: "complete-task",
+        input: {
+          instanceId: "inst-456",
+          action: "complete",
+          data: { approved: true }
+        },
+        output: { success: true, nextStep: "notify-hr" }
+      }
+    ]
+  }
+});
+var PauseWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.instance.pause",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "pause"],
+    description: "Pause a running workflow instance.",
+    goal: "Temporarily halt workflow execution.",
+    context: "Administrative action, emergency stop."
+  },
+  io: {
+    input: defineSchemaModel8({
+      name: "PauseResumeInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: false
+        },
+        reason: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.paused",
+        version: "1.0.0",
+        when: "Workflow is paused",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.paused"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "pause-workflow-happy-path",
+        given: ["Workflow is running"],
+        when: ["Admin pauses workflow"],
+        then: ["Instance status becomes PAUSED"]
+      }
+    ],
+    examples: [
+      {
+        key: "pause-maintenance",
+        input: { instanceId: "inst-456", reason: "System maintenance" },
+        output: { id: "inst-456", status: "paused" }
+      }
+    ]
+  }
+});
+var ResumeWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.instance.resume",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "resume"],
+    description: "Resume a paused workflow instance.",
+    goal: "Continue workflow execution.",
+    context: "Administrative action."
+  },
+  io: {
+    input: defineSchemaModel8({
+      name: "PauseResumeInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: false
+        },
+        reason: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.resumed",
+        version: "1.0.0",
+        when: "Workflow is resumed",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.resumed"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "resume-workflow-happy-path",
+        given: ["Workflow is paused"],
+        when: ["Admin resumes workflow"],
+        then: ["Instance status becomes RUNNING"]
+      }
+    ],
+    examples: [
+      {
+        key: "resume-normal",
+        input: { instanceId: "inst-456", reason: "Issue resolved" },
+        output: { id: "inst-456", status: "running" }
+      }
+    ]
+  }
+});
+var CancelWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.instance.cancel",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "cancel"],
+    description: "Cancel a workflow instance.",
+    goal: "Terminate workflow without completion.",
+    context: "User request, system cancellation."
+  },
+  io: {
+    input: defineSchemaModel8({
+      name: "CancelWorkflowInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: false
+        },
+        reason: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.cancelled",
+        version: "1.0.0",
+        when: "Workflow is cancelled",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.cancelled"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "cancel-workflow-happy-path",
+        given: ["Workflow is running"],
+        when: ["User cancels workflow"],
+        then: ["Instance status becomes CANCELLED"]
+      }
+    ],
+    examples: [
+      {
+        key: "cancel-mistake",
+        input: { instanceId: "inst-456", reason: "Created by mistake" },
+        output: { id: "inst-456", status: "cancelled" }
+      }
+    ]
+  }
+});
+var ListInstancesContract = defineQuery3({
+  meta: {
+    key: "workflow.instance.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "list"],
+    description: "List workflow instances with filtering.",
+    goal: "Browse and search running workflows.",
+    context: "Dashboard, monitoring."
+  },
+  io: {
+    input: defineSchemaModel8({
+      name: "ListInstancesInput",
+      fields: {
+        workflowKey: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: true
+        },
+        status: { type: InstanceStatusEnum, isOptional: true },
+        referenceType: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: true
+        },
+        referenceId: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: true
+        },
+        triggeredBy: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: true
+        },
+        limit: {
+          type: ScalarTypeEnum8.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum8.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel8({
+      name: "ListInstancesOutput",
+      fields: {
+        instances: {
+          type: WorkflowInstanceModel,
+          isArray: true,
+          isOptional: false
+        },
+        total: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-instances-happy-path",
+        given: ["Workflow instances exist"],
+        when: ["User lists instances"],
+        then: ["List of instances is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-running",
+        input: { status: "running", limit: 10 },
+        output: { instances: [], total: 5 }
+      }
+    ]
+  }
+});
+var GetInstanceContract = defineQuery3({
+  meta: {
+    key: "workflow.instance.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "instance", "get"],
+    description: "Get a workflow instance with details.",
+    goal: "View workflow instance details.",
+    context: "Instance detail view."
+  },
+  io: {
+    input: defineSchemaModel8({
+      name: "GetInstanceInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum8.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-instance-happy-path",
+        given: ["Instance exists"],
+        when: ["User requests instance details"],
+        then: ["Instance details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-details",
+        input: { instanceId: "inst-456" },
+        output: { id: "inst-456", workflowKey: "onboarding-v1" }
+      }
+    ]
+  }
+});
+
+// src/instance/instance.event.ts
+import { defineEvent as defineEvent3, defineSchemaModel as defineSchemaModel9 } from "@contractspec/lib.contracts";
+import { ScalarTypeEnum as ScalarTypeEnum9 } from "@contractspec/lib.schema";
+var InstanceEventPayload = defineSchemaModel9({
+  name: "InstanceEventPayload",
+  description: "Base payload for instance events",
+  fields: {
+    instanceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    referenceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum9.String_unsecure(),
+      isOptional: true
+    },
+    triggeredBy: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum9.String_unsecure(),
+      isOptional: false
+    },
+    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
+  }
+});
+var StepTransitionPayload = defineSchemaModel9({
+  name: "StepTransitionEventPayload",
+  description: "Payload for step transition events",
+  fields: {
+    instanceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    fromStepKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    toStepKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    action: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    executedBy: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
+  }
+});
+var InstanceCompletedPayload = defineSchemaModel9({
+  name: "InstanceCompletedEventPayload",
+  description: "Payload when instance completes",
+  fields: {
+    instanceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    outcome: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    referenceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum9.String_unsecure(),
+      isOptional: true
+    },
+    duration: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
+  }
+});
+var InstanceStartedEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.started",
+    version: "1.0.0",
+    description: "A new workflow instance has been started.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "started"]
+  },
+  payload: InstanceEventPayload
+});
+var StepEnteredEvent = defineEvent3({
+  meta: {
+    key: "workflow.step.entered",
+    version: "1.0.0",
+    description: "A workflow instance has entered a new step.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "entered"]
+  },
+  payload: StepTransitionPayload
+});
+var StepExitedEvent = defineEvent3({
+  meta: {
+    key: "workflow.step.exited",
+    version: "1.0.0",
+    description: "A workflow instance has exited a step.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "exited"]
+  },
+  payload: StepTransitionPayload
+});
+var InstanceCompletedEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.completed",
+    version: "1.0.0",
+    description: "A workflow instance has completed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "completed"]
+  },
+  payload: InstanceCompletedPayload
+});
+var InstanceCancelledEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.cancelled",
+    version: "1.0.0",
+    description: "A workflow instance has been cancelled.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "cancelled"]
+  },
+  payload: InstanceEventPayload
+});
+var InstancePausedEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.paused",
+    version: "1.0.0",
+    description: "A workflow instance has been paused.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "paused"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceResumedEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.resumed",
+    version: "1.0.0",
+    description: "A workflow instance has been resumed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "resumed"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceFailedEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.failed",
+    version: "1.0.0",
+    description: "A workflow instance has failed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "failed"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceTimedOutEvent = defineEvent3({
+  meta: {
+    key: "workflow.instance.timedOut",
+    version: "1.0.0",
+    description: "A workflow instance has timed out.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "timeout"]
+  },
+  payload: InstanceEventPayload
+});
+// src/presentations/index.ts
+import { definePresentation, StabilityEnum } from "@contractspec/lib.contracts";
+var WorkflowDesignerPresentation = definePresentation({
+  meta: {
+    key: "workflow.designer",
+    version: "1.0.0",
+    title: "Workflow Designer",
+    description: "Visual workflow designer with drag-and-drop steps",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "designer", "admin"],
+    stability: StabilityEnum.Experimental,
+    goal: "Building and modifying workflow definitions",
+    context: "Workflow administration and setup"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDesigner",
+    props: WorkflowDefinitionModel
+  },
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.designer.enabled"]
+  }
+});
+var WorkflowListPresentation = definePresentation({
+  meta: {
+    key: "workflow.definition.viewList",
+    version: "1.0.0",
+    title: "Workflow List",
+    description: "List of workflow definitions with status and actions",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "list", "admin"],
+    stability: StabilityEnum.Experimental,
+    goal: "Overview of all defined workflows",
+    context: "Workflow management dashboard"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDefinitionList",
+    props: WorkflowDefinitionModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
+  }
+});
+var WorkflowDetailPresentation = definePresentation({
+  meta: {
+    key: "workflow.definition.detail",
+    version: "1.0.0",
+    title: "Workflow Details",
+    description: "Detailed view of a workflow definition with steps",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "detail"],
+    stability: StabilityEnum.Experimental,
+    goal: "Viewing technical details of a workflow definition",
+    context: "Workflow inspection and debugging"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDefinitionDetail",
+    props: WorkflowDefinitionModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
+  }
+});
+var InstanceListPresentation = definePresentation({
+  meta: {
+    key: "workflow.instance.viewList",
+    version: "1.0.0",
+    title: "Instance List",
+    description: "List of workflow instances with status and progress",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "list"],
+    stability: StabilityEnum.Experimental,
+    goal: "Monitoring active and past workflow executions",
+    context: "Operations monitoring"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowInstanceList",
+    props: WorkflowInstanceModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
+  }
+});
+var InstanceDetailPresentation = definePresentation({
+  meta: {
+    key: "workflow.instance.detail",
+    version: "1.0.0",
+    title: "Instance Details",
+    description: "Detailed view of a workflow instance with step timeline",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "detail", "timeline"],
+    stability: StabilityEnum.Experimental,
+    goal: "Detailed inspection of a specific workflow instance",
+    context: "Case management and troubleshooting"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowInstanceDetail",
+    props: WorkflowInstanceModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
+  }
+});
+var ProgressTrackerPresentation = definePresentation({
+  meta: {
+    key: "workflow.instance.progress",
+    version: "1.0.0",
+    title: "Progress Tracker",
+    description: "Visual progress tracker showing current step in workflow",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "progress", "widget"],
+    stability: StabilityEnum.Experimental,
+    goal: "Quick view of current progress for a workflow",
+    context: "Embedded progress indicator in entity views"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowProgressTracker",
+    props: WorkflowInstanceModel
+  },
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.enabled"]
+  }
+});
+var ApprovalInboxPresentation = definePresentation({
+  meta: {
+    key: "workflow.approval.inbox",
+    version: "1.0.0",
+    title: "Approval Inbox",
+    description: "Inbox showing pending approval requests for current user",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "inbox"],
+    stability: StabilityEnum.Experimental,
+    goal: "Managing personal workload of approval requests",
+    context: "Personal task management"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ApprovalInbox",
+    props: ApprovalRequestModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
+  }
+});
+var ApprovalDetailPresentation = definePresentation({
+  meta: {
+    key: "workflow.approval.detail",
+    version: "1.0.0",
+    title: "Approval Details",
+    description: "Detailed approval request view with context and actions",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "detail"],
+    stability: StabilityEnum.Experimental,
+    goal: "Decision support for an approval request",
+    context: "Specific approval action"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ApprovalRequestDetail",
+    props: ApprovalRequestModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
+  }
+});
+var ApprovalFormPresentation = definePresentation({
+  meta: {
+    key: "workflow.approval.form",
+    version: "1.0.0",
+    title: "Approval Form",
+    description: "Form for submitting approval decisions",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "form"],
+    stability: StabilityEnum.Experimental,
+    goal: "Submitting a decision on an approval request",
+    context: "Approval decision dialog"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ApprovalDecisionForm"
+  },
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
+  }
+});
+var PendingApprovalsBadgePresentation = definePresentation({
+  meta: {
+    key: "workflow.approval.badge",
+    version: "1.0.0",
+    title: "Pending Approvals Badge",
+    description: "Badge showing count of pending approvals",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "badge", "widget"],
+    stability: StabilityEnum.Experimental,
+    goal: "Visual notification of pending approvals",
+    context: "Global navigation or sidebar"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "PendingApprovalsBadge"
+  },
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
+  }
+});
+var WorkflowMetricsPresentation = definePresentation({
+  meta: {
+    key: "workflow.metrics",
+    version: "1.0.0",
+    title: "Workflow Metrics",
+    description: "Dashboard widget showing workflow metrics and statistics",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "metrics", "dashboard"],
+    stability: StabilityEnum.Experimental,
+    goal: "Monitoring throughput and bottlenecks",
+    context: "System performance dashboard"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowMetricsDashboard"
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.metrics.enabled"]
+  }
+});
+var WorkflowSystemPresentations = {
+  WorkflowDesignerPresentation,
+  WorkflowListPresentation,
+  WorkflowDetailPresentation,
+  InstanceListPresentation,
+  InstanceDetailPresentation,
+  ProgressTrackerPresentation,
+  ApprovalInboxPresentation,
+  ApprovalDetailPresentation,
+  ApprovalFormPresentation,
+  PendingApprovalsBadgePresentation,
+  WorkflowMetricsPresentation
+};
+
+// src/workflow-system.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts";
+var WorkflowSystemFeature = defineFeature({
+  meta: {
+    key: "workflow-system",
+    title: "Workflow & Approval System",
+    description: "State machine-based workflow engine with role-based approvals, delegation, and escalation",
+    domain: "workflow",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "state-machine", "automation"],
+    stability: "experimental",
+    version: "1.0.0"
+  },
+  operations: [
+    { key: "workflow.definition.create", version: "1.0.0" },
+    { key: "workflow.definition.update", version: "1.0.0" },
+    { key: "workflow.step.add", version: "1.0.0" },
+    { key: "workflow.definition.publish", version: "1.0.0" },
+    { key: "workflow.definition.list", version: "1.0.0" },
+    { key: "workflow.definition.get", version: "1.0.0" },
+    { key: "workflow.instance.start", version: "1.0.0" },
+    { key: "workflow.instance.transition", version: "1.0.0" },
+    { key: "workflow.instance.pause", version: "1.0.0" },
+    { key: "workflow.instance.resume", version: "1.0.0" },
+    { key: "workflow.instance.cancel", version: "1.0.0" },
+    { key: "workflow.instance.list", version: "1.0.0" },
+    { key: "workflow.instance.get", version: "1.0.0" },
+    { key: "workflow.approval.decide", version: "1.0.0" },
+    { key: "workflow.approval.delegate", version: "1.0.0" },
+    { key: "workflow.approval.comment.add", version: "1.0.0" },
+    { key: "workflow.approval.list.mine", version: "1.0.0" },
+    { key: "workflow.approval.get", version: "1.0.0" }
+  ],
+  events: [
+    { key: "workflow.definition.created", version: "1.0.0" },
+    { key: "workflow.definition.updated", version: "1.0.0" },
+    { key: "workflow.definition.published", version: "1.0.0" },
+    { key: "workflow.step.added", version: "1.0.0" },
+    { key: "workflow.instance.started", version: "1.0.0" },
+    { key: "workflow.step.entered", version: "1.0.0" },
+    { key: "workflow.step.exited", version: "1.0.0" },
+    { key: "workflow.instance.completed", version: "1.0.0" },
+    { key: "workflow.instance.cancelled", version: "1.0.0" },
+    { key: "workflow.instance.paused", version: "1.0.0" },
+    { key: "workflow.instance.resumed", version: "1.0.0" },
+    { key: "workflow.instance.failed", version: "1.0.0" },
+    { key: "workflow.instance.timedOut", version: "1.0.0" },
+    { key: "workflow.approval.requested", version: "1.0.0" },
+    { key: "workflow.approval.decided", version: "1.0.0" },
+    { key: "workflow.approval.delegated", version: "1.0.0" },
+    { key: "workflow.approval.escalated", version: "1.0.0" }
+  ],
+  presentations: [
+    { key: "workflow.designer", version: "1.0.0" },
+    { key: "workflow.definition.viewList", version: "1.0.0" },
+    { key: "workflow.definition.detail", version: "1.0.0" },
+    { key: "workflow.instance.viewList", version: "1.0.0" },
+    { key: "workflow.instance.detail", version: "1.0.0" },
+    { key: "workflow.instance.progress", version: "1.0.0" },
+    { key: "workflow.approval.inbox", version: "1.0.0" },
+    { key: "workflow.approval.detail", version: "1.0.0" },
+    { key: "workflow.approval.form", version: "1.0.0" },
+    { key: "workflow.approval.badge", version: "1.0.0" },
+    { key: "workflow.metrics", version: "1.0.0" }
+  ],
+  opToPresentation: [
+    {
+      op: { key: "workflow.definition.list", version: "1.0.0" },
+      pres: { key: "workflow.definition.viewList", version: "1.0.0" }
+    },
+    {
+      op: { key: "workflow.instance.list", version: "1.0.0" },
+      pres: { key: "workflow.instance.viewList", version: "1.0.0" }
+    },
+    {
+      op: { key: "workflow.approval.list.mine", version: "1.0.0" },
+      pres: { key: "workflow.approval.inbox", version: "1.0.0" }
+    },
+    {
+      op: { key: "workflow.approval.decide", version: "1.0.0" },
+      pres: { key: "workflow.approval.form", version: "1.0.0" }
+    }
+  ],
+  presentationsTargets: [
+    { key: "workflow.designer", version: "1.0.0", targets: ["react"] },
+    {
+      key: "workflow.definition.viewList",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.definition.detail",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.instance.viewList",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.instance.detail",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    { key: "workflow.instance.progress", version: "1.0.0", targets: ["react"] },
+    {
+      key: "workflow.approval.inbox",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.approval.detail",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.metrics",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    }
+  ],
+  capabilities: {
+    requires: [
+      { key: "identity", version: "1.0.0" },
+      { key: "audit-trail", version: "1.0.0" },
+      { key: "notifications", version: "1.0.0" },
+      { key: "feature-flags", version: "1.0.0" }
+    ],
+    provides: [
+      { key: "workflow", version: "1.0.0" },
+      { key: "approval", version: "1.0.0" },
+      { key: "state-machine", version: "1.0.0" }
+    ]
+  }
+});
+
+// src/ui/renderers/workflow.markdown.ts
+var mockWorkflowDefinitions = [
+  {
+    id: "wf-1",
+    name: "Purchase Approval",
+    type: "APPROVAL",
+    steps: [
+      {
+        id: "s1",
+        name: "Manager Review",
+        order: 1,
+        requiredRoles: ["manager"]
+      },
+      {
+        id: "s2",
+        name: "Finance Review",
+        order: 2,
+        requiredRoles: ["finance"]
+      },
+      { id: "s3", name: "Final Approval", order: 3, requiredRoles: ["admin"] }
+    ],
+    status: "ACTIVE"
+  },
+  {
+    id: "wf-2",
+    name: "Leave Request",
+    type: "APPROVAL",
+    steps: [
+      {
+        id: "s1",
+        name: "Supervisor Approval",
+        order: 1,
+        requiredRoles: ["supervisor"]
+      },
+      { id: "s2", name: "HR Review", order: 2, requiredRoles: ["hr"] }
+    ],
+    status: "ACTIVE"
+  },
+  {
+    id: "wf-3",
+    name: "Document Review",
+    type: "SEQUENTIAL",
+    steps: [
+      { id: "s1", name: "Author Review", order: 1, requiredRoles: ["author"] },
+      { id: "s2", name: "Peer Review", order: 2, requiredRoles: ["reviewer"] },
+      { id: "s3", name: "Publish", order: 3, requiredRoles: ["publisher"] }
+    ],
+    status: "DRAFT"
+  }
+];
+var mockWorkflowInstances = [
+  {
+    id: "inst-1",
+    definitionId: "wf-1",
+    definitionName: "Purchase Approval",
+    status: "IN_PROGRESS",
+    currentStepId: "s2",
+    startedAt: "2024-01-15T10:00:00Z",
+    requestedBy: "John Doe"
+  },
+  {
+    id: "inst-2",
+    definitionId: "wf-1",
+    definitionName: "Purchase Approval",
+    status: "COMPLETED",
+    currentStepId: null,
+    startedAt: "2024-01-10T09:00:00Z",
+    completedAt: "2024-01-12T14:00:00Z",
+    requestedBy: "Jane Smith"
+  },
+  {
+    id: "inst-3",
+    definitionId: "wf-2",
+    definitionName: "Leave Request",
+    status: "PENDING",
+    currentStepId: "s1",
+    startedAt: "2024-01-16T08:00:00Z",
+    requestedBy: "Bob Wilson"
+  }
+];
+var workflowDashboardMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowDashboard") {
+      throw new Error("workflowDashboardMarkdownRenderer: not WorkflowDashboard");
+    }
+    const definitions = mockWorkflowDefinitions;
+    const instances = mockWorkflowInstances;
+    const activeDefinitions = definitions.filter((d) => d.status === "ACTIVE");
+    const pendingInstances = instances.filter((i) => i.status === "PENDING");
+    const inProgressInstances = instances.filter((i) => i.status === "IN_PROGRESS");
+    const completedInstances = instances.filter((i) => i.status === "COMPLETED");
+    const lines = [
+      "# Workflow Dashboard",
+      "",
+      "> Workflow and approval management overview",
+      "",
+      "## Summary",
+      "",
+      "| Metric | Value |",
+      "|--------|-------|",
+      `| Active Workflows | ${activeDefinitions.length} |`,
+      `| Pending Approvals | ${pendingInstances.length} |`,
+      `| In Progress | ${inProgressInstances.length} |`,
+      `| Completed | ${completedInstances.length} |`,
+      "",
+      "## Active Workflow Definitions",
+      ""
+    ];
+    if (activeDefinitions.length === 0) {
+      lines.push("_No active workflow definitions._");
+    } else {
+      lines.push("| Name | Type | Steps | Status |");
+      lines.push("|------|------|-------|--------|");
+      for (const def of activeDefinitions) {
+        lines.push(`| ${def.name} | ${def.type} | ${def.steps.length} | ${def.status} |`);
+      }
+    }
+    lines.push("");
+    lines.push("## Recent Instances");
+    lines.push("");
+    if (instances.length === 0) {
+      lines.push("_No workflow instances._");
+    } else {
+      lines.push("| Workflow | Requested By | Status | Started |");
+      lines.push("|----------|--------------|--------|---------|");
+      for (const inst of instances.slice(0, 10)) {
+        const startedDate = new Date(inst.startedAt).toLocaleDateString();
+        lines.push(`| ${inst.definitionName} | ${inst.requestedBy} | ${inst.status} | ${startedDate} |`);
+      }
+    }
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+var workflowDefinitionListMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowDefinitionList") {
+      throw new Error("workflowDefinitionListMarkdownRenderer: not WorkflowDefinitionList");
+    }
+    const definitions = mockWorkflowDefinitions;
+    const lines = [
+      "# Workflow Definitions",
+      "",
+      "> Configure automated approval and process workflows",
+      ""
+    ];
+    for (const def of definitions) {
+      lines.push(`## ${def.name}`);
+      lines.push("");
+      lines.push(`**Type:** ${def.type} | **Status:** ${def.status}`);
+      lines.push("");
+      lines.push("### Steps");
+      lines.push("");
+      for (const step of def.steps) {
+        lines.push(`${step.order}. **${step.name}** - Roles: ${step.requiredRoles.join(", ")}`);
+      }
+      lines.push("");
+    }
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+var workflowInstanceDetailMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowInstanceDetail") {
+      throw new Error("workflowInstanceDetailMarkdownRenderer: not WorkflowInstanceDetail");
+    }
+    const instance = mockWorkflowInstances[0];
+    if (!instance) {
+      return {
+        mimeType: "text/markdown",
+        body: `# No Workflow Instances
+
+No workflow instances available.`
+      };
+    }
+    const definition = mockWorkflowDefinitions.find((d) => d.id === instance.definitionId);
+    const lines = [
+      `# Workflow: ${instance.definitionName}`,
+      "",
+      `**Instance ID:** ${instance.id}`,
+      `**Status:** ${instance.status}`,
+      `**Requested By:** ${instance.requestedBy}`,
+      `**Started:** ${new Date(instance.startedAt).toLocaleString()}`,
+      "",
+      "## Steps Progress",
+      ""
+    ];
+    if (definition) {
+      for (const step of definition.steps) {
+        const isCurrent = step.id === instance.currentStepId;
+        const isCompleted = definition.steps.indexOf(step) < definition.steps.findIndex((s) => s.id === instance.currentStepId);
+        let status = "⬜ Pending";
+        if (isCompleted)
+          status = "✅ Completed";
+        if (isCurrent)
+          status = "\uD83D\uDD04 In Progress";
+        lines.push(`- ${status} **${step.name}**`);
+      }
+    }
+    lines.push("");
+    lines.push("## Actions");
+    lines.push("");
+    lines.push("- **Approve** - Move to next step");
+    lines.push("- **Reject** - Reject and return");
+    lines.push("- **Delegate** - Assign to another approver");
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+// src/ui/hooks/useWorkflowList.ts
+import { useCallback, useEffect, useState } from "react";
+import { useTemplateRuntime } from "@contractspec/lib.example-shared-ui";
+"use client";
+function useWorkflowList(projectId = "local-project") {
+  const { handlers } = useTemplateRuntime();
+  const workflow = handlers.workflow;
+  const [definitions, setDefinitions] = useState([]);
+  const [instances, setInstances] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchData = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const [defResult, instResult] = await Promise.all([
+        workflow.listDefinitions({ projectId, limit: 100 }),
+        workflow.listInstances({ projectId, limit: 100 })
+      ]);
+      setDefinitions(defResult.definitions);
+      setInstances(instResult.instances);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to load workflows"));
+    } finally {
+      setLoading(false);
+    }
+  }, [handlers, projectId]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  const stats = {
+    totalDefinitions: definitions.length,
+    activeDefinitions: definitions.filter((d) => d.status === "ACTIVE").length,
+    totalInstances: instances.length,
+    pendingInstances: instances.filter((i) => i.status === "PENDING").length,
+    completedInstances: instances.filter((i) => i.status === "COMPLETED").length,
+    rejectedInstances: instances.filter((i) => i.status === "REJECTED").length
+  };
+  return {
+    definitions,
+    instances,
+    loading,
+    error,
+    stats,
+    refetch: fetchData
+  };
+}
+
+// src/ui/WorkflowDashboard.tsx
+import { useState as useState2 } from "react";
+import {
+  Button,
+  ErrorState,
+  LoaderBlock,
+  StatCard,
+  StatCardGroup
+} from "@contractspec/lib.design-system";
+import { jsxDEV } from "react/jsx-dev-runtime";
+"use client";
+var STATUS_COLORS = {
+  ACTIVE: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+  DRAFT: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400",
+  ARCHIVED: "bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
+  PENDING: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+  IN_PROGRESS: "bg-indigo-100 text-indigo-700 dark:bg-indigo-900/30 dark:text-indigo-400",
+  COMPLETED: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+  REJECTED: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
+  CANCELLED: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400"
+};
+function WorkflowDashboard() {
+  const [activeTab, setActiveTab] = useState2("definitions");
+  const { definitions, instances, loading, error, stats, refetch } = useWorkflowList();
+  const tabs = [
+    { id: "definitions", label: "Definitions", icon: "\uD83D\uDCCB" },
+    { id: "instances", label: "Instances", icon: "\uD83D\uDD04" }
+  ];
+  if (loading) {
+    return /* @__PURE__ */ jsxDEV(LoaderBlock, {
+      label: "Loading Workflows..."
+    }, undefined, false, undefined, this);
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxDEV(ErrorState, {
+      title: "Failed to load Workflows",
+      description: error.message,
+      onRetry: refetch,
+      retryLabel: "Retry"
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV("div", {
+    className: "space-y-6",
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        className: "flex items-center justify-between",
+        children: [
+          /* @__PURE__ */ jsxDEV("h2", {
+            className: "text-2xl font-bold",
+            children: "Workflow System"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Button, {
+            onClick: () => alert("Create workflow modal"),
+            children: [
+              /* @__PURE__ */ jsxDEV("span", {
+                className: "mr-2",
+                children: "+"
+              }, undefined, false, undefined, this),
+              " New Workflow"
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV(StatCardGroup, {
+        children: [
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Workflows",
+            value: stats.totalDefinitions,
+            hint: `${stats.activeDefinitions} active`
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Instances",
+            value: stats.totalInstances,
+            hint: "total runs"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Pending",
+            value: stats.pendingInstances,
+            hint: "awaiting action"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Completed",
+            value: stats.completedInstances,
+            hint: "finished"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV("nav", {
+        className: "bg-muted flex gap-1 rounded-lg p-1",
+        role: "tablist",
+        children: tabs.map((tab) => /* @__PURE__ */ jsxDEV(Button, {
+          type: "button",
+          role: "tab",
+          "aria-selected": activeTab === tab.id,
+          onClick: () => setActiveTab(tab.id),
+          className: `flex flex-1 items-center justify-center gap-2 rounded-md px-4 py-2 text-sm font-medium transition-colors ${activeTab === tab.id ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"}`,
+          children: [
+            /* @__PURE__ */ jsxDEV("span", {
+              children: tab.icon
+            }, undefined, false, undefined, this),
+            tab.label
+          ]
+        }, tab.id, true, undefined, this))
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("div", {
+        className: "min-h-[400px]",
+        role: "tabpanel",
+        children: [
+          activeTab === "definitions" && /* @__PURE__ */ jsxDEV("div", {
+            className: "border-border rounded-lg border",
+            children: /* @__PURE__ */ jsxDEV("table", {
+              className: "w-full",
+              children: [
+                /* @__PURE__ */ jsxDEV("thead", {
+                  className: "border-border bg-muted/30 border-b",
+                  children: /* @__PURE__ */ jsxDEV("tr", {
+                    children: [
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Name"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Type"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Status"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Created"
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("tbody", {
+                  className: "divide-border divide-y",
+                  children: [
+                    definitions.map((def) => /* @__PURE__ */ jsxDEV("tr", {
+                      className: "hover:bg-muted/50",
+                      children: [
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: [
+                            /* @__PURE__ */ jsxDEV("div", {
+                              className: "font-medium",
+                              children: def.name
+                            }, undefined, false, undefined, this),
+                            /* @__PURE__ */ jsxDEV("div", {
+                              className: "text-muted-foreground text-sm",
+                              children: def.description
+                            }, undefined, false, undefined, this)
+                          ]
+                        }, undefined, true, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3 font-mono text-sm",
+                          children: def.type
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: /* @__PURE__ */ jsxDEV("span", {
+                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[def.status] ?? ""}`,
+                            children: def.status
+                          }, undefined, false, undefined, this)
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "text-muted-foreground px-4 py-3 text-sm",
+                          children: def.createdAt.toLocaleDateString()
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, def.id, true, undefined, this)),
+                    definitions.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
+                      children: /* @__PURE__ */ jsxDEV("td", {
+                        colSpan: 4,
+                        className: "text-muted-foreground px-4 py-8 text-center",
+                        children: "No workflow definitions found"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          activeTab === "instances" && /* @__PURE__ */ jsxDEV("div", {
+            className: "border-border rounded-lg border",
+            children: /* @__PURE__ */ jsxDEV("table", {
+              className: "w-full",
+              children: [
+                /* @__PURE__ */ jsxDEV("thead", {
+                  className: "border-border bg-muted/30 border-b",
+                  children: /* @__PURE__ */ jsxDEV("tr", {
+                    children: [
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Instance ID"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Status"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Requested By"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Started"
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("tbody", {
+                  className: "divide-border divide-y",
+                  children: [
+                    instances.map((inst) => /* @__PURE__ */ jsxDEV("tr", {
+                      className: "hover:bg-muted/50",
+                      children: [
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3 font-mono text-sm",
+                          children: inst.id
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: /* @__PURE__ */ jsxDEV("span", {
+                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[inst.status] ?? ""}`,
+                            children: inst.status
+                          }, undefined, false, undefined, this)
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3 text-sm",
+                          children: inst.requestedBy
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "text-muted-foreground px-4 py-3 text-sm",
+                          children: inst.startedAt.toLocaleDateString()
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, inst.id, true, undefined, this)),
+                    instances.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
+                      children: /* @__PURE__ */ jsxDEV("td", {
+                        colSpan: 4,
+                        className: "text-muted-foreground px-4 py-8 text-center",
+                        children: "No workflow instances found"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/ui/hooks/index.ts
+"use client";
+export {
+  workflowInstanceDetailMarkdownRenderer,
+  workflowDefinitionListMarkdownRenderer,
+  workflowDashboardMarkdownRenderer,
+  useWorkflowList,
+  mockDataStore,
+  createWorkflowHandlers,
+  createStateMachineEngine,
+  createInitialState,
+  buildStateMachineDefinition,
+  WorkflowUpdatedEvent,
+  WorkflowSystemPresentations,
+  WorkflowSystemFeature,
+  WorkflowStepModel,
+  WorkflowStatusEnum,
+  WorkflowPublishedEvent,
+  WorkflowMetricsPresentation,
+  WorkflowListPresentation,
+  WorkflowInstanceModel,
+  WorkflowDetailPresentation,
+  WorkflowDesignerPresentation,
+  WorkflowDefinitionModel,
+  WorkflowDashboard,
+  WorkflowCreatedEvent,
+  UpdateWorkflowInputModel,
+  UpdateWorkflowContract,
+  TriggerTypeEnum,
+  TransitionWorkflowContract,
+  TransitionResultModel,
+  TransitionInputModel,
+  SubmitDecisionContract,
+  StepTypeEnum,
+  StepExitedEvent,
+  StepEnteredEvent,
+  StepAddedEvent,
+  StartWorkflowInputModel,
+  StartWorkflowContract,
+  ResumeWorkflowContract,
+  PublishWorkflowContract,
+  ProgressTrackerPresentation,
+  PendingApprovalsBadgePresentation,
+  PauseWorkflowContract,
+  ListWorkflowsContract,
+  ListMyApprovalsContract,
+  ListInstancesContract,
+  InstanceTimedOutEvent,
+  InstanceStatusEnum,
+  InstanceStartedEvent,
+  InstanceResumedEvent,
+  InstancePausedEvent,
+  InstanceListPresentation,
+  InstanceFailedEvent,
+  InstanceDetailPresentation,
+  InstanceCompletedEvent,
+  InstanceCancelledEvent,
+  GetWorkflowContract,
+  GetInstanceContract,
+  GetApprovalContract,
+  DelegateApprovalContract,
+  CreateWorkflowInputModel,
+  CreateWorkflowContract,
+  CancelWorkflowContract,
+  BasicStateMachineEngine,
+  ApprovalStatusEnum,
+  ApprovalRequestedEvent,
+  ApprovalRequestModel,
+  ApprovalModeEnum,
+  ApprovalInboxPresentation,
+  ApprovalFormPresentation,
+  ApprovalEscalatedEvent,
+  ApprovalDetailPresentation,
+  ApprovalDelegatedEvent,
+  ApprovalDecisionEnum,
+  ApprovalDecidedEvent,
+  ApprovalCommentModel,
+  AddStepInputModel,
+  AddStepContract,
+  AddApprovalCommentContract
+};