@bratsos/workflow-engine 0.0.11 → 0.2.0

package/dist/interface-MMqhfQQK.d.ts

@@ -0,0 +1,411 @@
+/**
+ * Persistence Interfaces for Workflow Engine
+ *
+ * These interfaces abstract database operations to enable:
+ * - Testing with mock implementations
+ * - Future extraction into @bratsos/workflow-engine package
+ * - Alternative database backends
+ *
+ * Implementations:
+ * - PrismaWorkflowPersistence (default, in ./prisma/)
+ * - InMemoryPersistence (for testing)
+ */
+/**
+ * Unified status type for workflows, stages, and jobs.
+ *
+ * - PENDING: Not started yet
+ * - RUNNING: Currently executing
+ * - SUSPENDED: Paused, waiting for external event (e.g., batch job completion)
+ * - COMPLETED: Finished successfully
+ * - FAILED: Finished with error
+ * - CANCELLED: Manually stopped by user
+ * - SKIPPED: Stage-specific - bypassed due to condition
+ */
+type Status = "PENDING" | "RUNNING" | "SUSPENDED" | "COMPLETED" | "FAILED" | "CANCELLED" | "SKIPPED";
+/** @deprecated Use Status instead */
+type WorkflowStatus = Status;
+/** @deprecated Use Status instead */
+type WorkflowStageStatus = Status;
+/** @deprecated Use Status instead. Note: PROCESSING is now RUNNING. */
+type JobStatus = Status;
+type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+type ArtifactType = "STAGE_OUTPUT" | "ARTIFACT" | "METADATA";
+declare class StaleVersionError extends Error {
+    readonly entity: string;
+    readonly id: string;
+    readonly expected: number;
+    readonly actual: number;
+    constructor(entity: string, id: string, expected: number, actual: number);
+}
+interface WorkflowRunRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    version: number;
+    workflowId: string;
+    workflowName: string;
+    workflowType: string;
+    status: WorkflowStatus;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    duration: number | null;
+    input: unknown;
+    output: unknown | null;
+    config: unknown;
+    totalCost: number;
+    totalTokens: number;
+    priority: number;
+}
+interface WorkflowStageRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    version: number;
+    workflowRunId: string;
+    stageId: string;
+    stageName: string;
+    stageNumber: number;
+    executionGroup: number;
+    status: WorkflowStageStatus;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    duration: number | null;
+    inputData: unknown | null;
+    outputData: unknown | null;
+    config: unknown | null;
+    suspendedState: unknown | null;
+    resumeData: unknown | null;
+    nextPollAt: Date | null;
+    pollInterval: number | null;
+    maxWaitUntil: Date | null;
+    metrics: unknown | null;
+    embeddingInfo: unknown | null;
+    errorMessage: string | null;
+}
+interface WorkflowLogRecord {
+    id: string;
+    createdAt: Date;
+    workflowStageId: string | null;
+    workflowRunId: string | null;
+    level: LogLevel;
+    message: string;
+    metadata: unknown | null;
+}
+interface WorkflowArtifactRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    workflowRunId: string;
+    workflowStageId: string | null;
+    key: string;
+    type: ArtifactType;
+    data: unknown;
+    size: number;
+    metadata: unknown | null;
+}
+interface OutboxRecord {
+    id: string;
+    workflowRunId: string;
+    sequence: number;
+    eventType: string;
+    payload: unknown;
+    causationId: string;
+    occurredAt: Date;
+    publishedAt: Date | null;
+    retryCount: number;
+    dlqAt: Date | null;
+}
+interface CreateOutboxEventInput {
+    workflowRunId: string;
+    eventType: string;
+    payload: unknown;
+    causationId: string;
+    occurredAt: Date;
+}
+interface IdempotencyRecord {
+    key: string;
+    commandType: string;
+    result: unknown;
+    createdAt: Date;
+}
+interface AICallRecord {
+    id: string;
+    createdAt: Date;
+    topic: string;
+    callType: string;
+    modelKey: string;
+    modelId: string;
+    prompt: string;
+    response: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    metadata: unknown | null;
+}
+interface JobRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    workflowRunId: string;
+    workflowId: string;
+    stageId: string;
+    status: JobStatus;
+    priority: number;
+    workerId: string | null;
+    lockedAt: Date | null;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    attempt: number;
+    maxAttempts: number;
+    lastError: string | null;
+    nextPollAt: Date | null;
+    payload: Record<string, unknown>;
+}
+interface CreateRunInput {
+    id?: string;
+    workflowId: string;
+    workflowName: string;
+    workflowType: string;
+    input: unknown;
+    config?: unknown;
+    priority?: number;
+    /** Optional metadata for domain-specific fields */
+    metadata?: Record<string, unknown>;
+}
+interface UpdateRunInput {
+    status?: WorkflowStatus;
+    startedAt?: Date;
+    completedAt?: Date | null;
+    duration?: number;
+    output?: unknown;
+    totalCost?: number;
+    totalTokens?: number;
+    expectedVersion?: number;
+}
+interface CreateStageInput {
+    workflowRunId: string;
+    stageId: string;
+    stageName: string;
+    stageNumber: number;
+    executionGroup: number;
+    status?: WorkflowStageStatus;
+    startedAt?: Date;
+    config?: unknown;
+    inputData?: unknown;
+}
+interface UpdateStageInput {
+    status?: WorkflowStageStatus;
+    startedAt?: Date;
+    completedAt?: Date;
+    duration?: number;
+    outputData?: unknown;
+    config?: unknown;
+    suspendedState?: unknown;
+    resumeData?: unknown;
+    nextPollAt?: Date | null;
+    pollInterval?: number;
+    maxWaitUntil?: Date;
+    metrics?: unknown;
+    embeddingInfo?: unknown;
+    artifacts?: unknown;
+    errorMessage?: string;
+    expectedVersion?: number;
+}
+interface UpsertStageInput {
+    workflowRunId: string;
+    stageId: string;
+    create: CreateStageInput;
+    update: UpdateStageInput;
+}
+interface CreateLogInput {
+    workflowRunId?: string;
+    workflowStageId?: string;
+    level: LogLevel;
+    message: string;
+    metadata?: unknown;
+}
+interface SaveArtifactInput {
+    workflowRunId: string;
+    workflowStageId?: string;
+    key: string;
+    type: ArtifactType;
+    data: unknown;
+    size: number;
+    metadata?: unknown;
+}
+interface CreateAICallInput {
+    topic: string;
+    callType: string;
+    modelKey: string;
+    modelId: string;
+    prompt: string;
+    response: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    metadata?: unknown;
+}
+interface EnqueueJobInput {
+    workflowRunId: string;
+    workflowId: string;
+    stageId: string;
+    priority?: number;
+    payload?: Record<string, unknown>;
+    scheduledFor?: Date;
+}
+interface DequeueResult {
+    jobId: string;
+    workflowRunId: string;
+    workflowId: string;
+    stageId: string;
+    priority: number;
+    attempt: number;
+    maxAttempts: number;
+    payload: Record<string, unknown>;
+}
+interface WorkflowPersistence {
+    /** Execute operations within a transaction boundary. */
+    withTransaction<T>(fn: (tx: WorkflowPersistence) => Promise<T>): Promise<T>;
+    createRun(data: CreateRunInput): Promise<WorkflowRunRecord>;
+    updateRun(id: string, data: UpdateRunInput): Promise<void>;
+    getRun(id: string): Promise<WorkflowRunRecord | null>;
+    getRunStatus(id: string): Promise<WorkflowStatus | null>;
+    getRunsByStatus(status: WorkflowStatus): Promise<WorkflowRunRecord[]>;
+    /**
+     * Atomically claim a pending workflow run for processing.
+     * Uses atomic update with WHERE status = 'PENDING' to prevent race conditions.
+     *
+     * @param id - The workflow run ID to claim
+     * @returns true if successfully claimed, false if already claimed by another worker
+     */
+    claimPendingRun(id: string): Promise<boolean>;
+    /**
+     * Atomically find and claim the next pending workflow run.
+     * Uses FOR UPDATE SKIP LOCKED pattern (in Postgres) to prevent race conditions
+     * when multiple workers try to claim workflows simultaneously.
+     *
+     * Priority ordering: higher priority first, then oldest (FIFO within same priority).
+     *
+     * @returns The claimed workflow run (now with status RUNNING), or null if no pending runs
+     */
+    claimNextPendingRun(): Promise<WorkflowRunRecord | null>;
+    createStage(data: CreateStageInput): Promise<WorkflowStageRecord>;
+    upsertStage(data: UpsertStageInput): Promise<WorkflowStageRecord>;
+    updateStage(id: string, data: UpdateStageInput): Promise<void>;
+    updateStageByRunAndStageId(workflowRunId: string, stageId: string, data: UpdateStageInput): Promise<void>;
+    getStage(runId: string, stageId: string): Promise<WorkflowStageRecord | null>;
+    getStageById(id: string): Promise<WorkflowStageRecord | null>;
+    getStagesByRun(runId: string, options?: {
+        status?: WorkflowStageStatus;
+        orderBy?: "asc" | "desc";
+    }): Promise<WorkflowStageRecord[]>;
+    getSuspendedStages(beforeDate: Date): Promise<WorkflowStageRecord[]>;
+    getFirstSuspendedStageReadyToResume(runId: string): Promise<WorkflowStageRecord | null>;
+    getFirstFailedStage(runId: string): Promise<WorkflowStageRecord | null>;
+    getLastCompletedStage(runId: string): Promise<WorkflowStageRecord | null>;
+    getLastCompletedStageBefore(runId: string, executionGroup: number): Promise<WorkflowStageRecord | null>;
+    deleteStage(id: string): Promise<void>;
+    createLog(data: CreateLogInput): Promise<void>;
+    saveArtifact(data: SaveArtifactInput): Promise<void>;
+    loadArtifact(runId: string, key: string): Promise<unknown>;
+    hasArtifact(runId: string, key: string): Promise<boolean>;
+    deleteArtifact(runId: string, key: string): Promise<void>;
+    listArtifacts(runId: string): Promise<WorkflowArtifactRecord[]>;
+    getStageIdForArtifact(runId: string, stageId: string): Promise<string | null>;
+    saveStageOutput(runId: string, workflowType: string, stageId: string, output: unknown): Promise<string>;
+    /** Increment retry count for a failed outbox event. Returns new count. */
+    incrementOutboxRetryCount(id: string): Promise<number>;
+    /** Move an outbox event to DLQ (sets dlqAt). */
+    moveOutboxEventToDLQ(id: string): Promise<void>;
+    /** Reset DLQ events so they can be reprocessed by outbox.flush. Returns count reset. */
+    replayDLQEvents(maxEvents: number): Promise<number>;
+    /** Write events to the outbox. Sequences are auto-assigned per workflowRunId. */
+    appendOutboxEvents(events: CreateOutboxEventInput[]): Promise<void>;
+    /** Read unpublished events ordered by (workflowRunId, sequence). */
+    getUnpublishedOutboxEvents(limit?: number): Promise<OutboxRecord[]>;
+    /** Mark events as published. */
+    markOutboxEventsPublished(ids: string[]): Promise<void>;
+    /** Atomically acquire an idempotency key for command execution. */
+    acquireIdempotencyKey(key: string, commandType: string): Promise<{
+        status: "acquired";
+    } | {
+        status: "replay";
+        result: unknown;
+    } | {
+        status: "in_progress";
+    }>;
+    /** Mark an idempotency key as completed and cache the command result. */
+    completeIdempotencyKey(key: string, commandType: string, result: unknown): Promise<void>;
+    /** Release an in-progress idempotency key after command failure. */
+    releaseIdempotencyKey(key: string, commandType: string): Promise<void>;
+}
+interface AIHelperStats {
+    totalCalls: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    perModel: Record<string, {
+        calls: number;
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+    }>;
+}
+interface AICallLogger {
+    /**
+     * Log a single AI call (fire and forget)
+     */
+    logCall(call: CreateAICallInput): void;
+    /**
+     * Log batch results (for recording batch API results)
+     */
+    logBatchResults(batchId: string, results: CreateAICallInput[]): Promise<void>;
+    /**
+     * Get aggregated stats for a topic prefix
+     */
+    getStats(topicPrefix: string): Promise<AIHelperStats>;
+    /**
+     * Check if batch results are already recorded
+     */
+    isRecorded(batchId: string): Promise<boolean>;
+}
+interface JobQueue {
+    /**
+     * Add a new job to the queue
+     */
+    enqueue(options: EnqueueJobInput): Promise<string>;
+    /**
+     * Enqueue multiple stages in parallel (same execution group)
+     */
+    enqueueParallel(jobs: EnqueueJobInput[]): Promise<string[]>;
+    /**
+     * Atomically dequeue the next available job
+     */
+    dequeue(): Promise<DequeueResult | null>;
+    /**
+     * Mark job as completed
+     */
+    complete(jobId: string): Promise<void>;
+    /**
+     * Mark job as suspended (for async-batch)
+     */
+    suspend(jobId: string, nextPollAt: Date): Promise<void>;
+    /**
+     * Mark job as failed
+     */
+    fail(jobId: string, error: string, shouldRetry?: boolean): Promise<void>;
+    /**
+     * Get suspended jobs that are ready to be checked
+     */
+    getSuspendedJobsReadyToPoll(): Promise<Array<{
+        jobId: string;
+        stageId: string;
+        workflowRunId: string;
+    }>>;
+    /**
+     * Release stale locks (for crashed workers)
+     */
+    releaseStaleJobs(staleThresholdMs?: number): Promise<number>;
+}
+
+export { type AICallLogger as A, type CreateOutboxEventInput as C, type DequeueResult as D, type EnqueueJobInput as E, type IdempotencyRecord as I, type JobQueue as J, type LogLevel as L, type OutboxRecord as O, type Status as S, type UpdateRunInput as U, type WorkflowRunRecord as W, type CreateRunInput as a, type CreateStageInput as b, type WorkflowStageRecord as c, type UpsertStageInput as d, type UpdateStageInput as e, type CreateLogInput as f, type CreateAICallInput as g, type AIHelperStats as h, type AICallRecord as i, type JobRecord as j, type JobStatus as k, type WorkflowPersistence as l, type WorkflowStatus as m, type WorkflowStageStatus as n, type SaveArtifactInput as o, type WorkflowArtifactRecord as p, type WorkflowLogRecord as q, type ArtifactType as r, StaleVersionError as s };

package/dist/kernel/index.d.ts

@@ -0,0 +1,26 @@
+import { K as KernelDeps } from '../plugins-BCnDUwIc.js';
+export { C as CommandResult, I as IdempotencyInProgressError, J as JobExecuteCommand, a as JobExecuteResult, b as Kernel, c as KernelCommand, d as KernelCommandType, e as KernelConfig, L as LeaseReapStaleCommand, f as LeaseReapStaleResult, O as OutboxFlushCommand, g as OutboxFlushResult, P as PluginDefinition, h as PluginReplayDLQCommand, i as PluginReplayDLQResult, j as PluginRunner, k as PluginRunnerConfig, R as RunCancelCommand, l as RunCancelResult, m as RunClaimPendingCommand, n as RunClaimPendingResult, o as RunCreateCommand, p as RunCreateResult, q as RunRerunFromCommand, r as RunRerunFromResult, s as RunTransitionCommand, t as RunTransitionResult, S as StagePollSuspendedCommand, u as StagePollSuspendedResult, W as WorkflowRegistry, v as createKernel, w as createPluginRunner, x as definePlugin } from '../plugins-BCnDUwIc.js';
+export { B as BlobStore, C as Clock, E as EventSink, J as JobTransport, K as KernelEvent, a as KernelEventType, P as Persistence, S as Scheduler, b as StageCompletedEvent, c as StageFailedEvent, d as StageProgressEvent, e as StageStartedEvent, f as StageSuspendedEvent, W as WorkflowCancelledEvent, g as WorkflowCompletedEvent, h as WorkflowCreatedEvent, i as WorkflowFailedEvent, j as WorkflowStartedEvent, k as WorkflowSuspendedEvent } from '../ports-tU3rzPXJ.js';
+export { C as CreateOutboxEventInput, I as IdempotencyRecord, O as OutboxRecord } from '../interface-MMqhfQQK.js';
+import 'zod';
+import '../stage-BPw7m9Wx.js';
+
+/**
+ * Load workflow context from completed stages.
+ *
+ * For each completed stage, loads the output from BlobStore using
+ * the _artifactKey stored in stage.outputData.
+ */
+
+declare function loadWorkflowContext(workflowRunId: string, deps: KernelDeps): Promise<Record<string, unknown>>;
+
+/**
+ * Save stage output to BlobStore and return the blob key.
+ *
+ * The key is stored in stage.outputData._artifactKey so that
+ * loadWorkflowContext() can retrieve it later.
+ */
+
+declare function saveStageOutput(runId: string, workflowType: string, stageId: string, output: unknown, deps: KernelDeps): Promise<string>;
+
+export { loadWorkflowContext, saveStageOutput };

package/dist/kernel/index.js

@@ -0,0 +1,3 @@
+export { IdempotencyInProgressError, createKernel, createPluginRunner, definePlugin, loadWorkflowContext, saveStageOutput } from '../chunk-HL3OJG7W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/kernel/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/kernel/testing/index.d.ts

@@ -0,0 +1,44 @@
+import { E as EventSink, K as KernelEvent, a as KernelEventType, C as Clock, B as BlobStore, S as Scheduler } from '../../ports-tU3rzPXJ.js';
+import '../../interface-MMqhfQQK.js';
+
+declare class CollectingEventSink implements EventSink {
+    readonly events: KernelEvent[];
+    emit(event: KernelEvent): Promise<void>;
+    getByType<T extends KernelEventType>(type: T): Extract<KernelEvent, {
+        type: T;
+    }>[];
+    clear(): void;
+    get length(): number;
+}
+
+declare class FakeClock implements Clock {
+    private currentTime;
+    constructor(initialTime?: Date);
+    now(): Date;
+    advance(ms: number): void;
+    set(time: Date): void;
+}
+
+declare class InMemoryBlobStore implements BlobStore {
+    private store;
+    put(key: string, data: unknown): Promise<void>;
+    get(key: string): Promise<unknown>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+    clear(): void;
+    size(): number;
+}
+
+declare class NoopScheduler implements Scheduler {
+    readonly scheduled: Array<{
+        commandType: string;
+        payload: unknown;
+        runAt: Date;
+    }>;
+    schedule(commandType: string, payload: unknown, runAt: Date): Promise<void>;
+    cancel(_commandType: string, _correlationId: string): Promise<void>;
+    clear(): void;
+}
+
+export { CollectingEventSink, FakeClock, InMemoryBlobStore, NoopScheduler };

package/dist/kernel/testing/index.js

@@ -0,0 +1,85 @@
+// src/kernel/testing/collecting-event-sink.ts
+var CollectingEventSink = class {
+  events = [];
+  async emit(event) {
+    this.events.push(event);
+  }
+  getByType(type) {
+    return this.events.filter(
+      (e) => e.type === type
+    );
+  }
+  clear() {
+    this.events.length = 0;
+  }
+  get length() {
+    return this.events.length;
+  }
+};
+
+// src/kernel/testing/fake-clock.ts
+var FakeClock = class {
+  currentTime;
+  constructor(initialTime) {
+    this.currentTime = initialTime ?? /* @__PURE__ */ new Date("2025-01-01T00:00:00Z");
+  }
+  now() {
+    return new Date(this.currentTime.getTime());
+  }
+  advance(ms) {
+    this.currentTime = new Date(this.currentTime.getTime() + ms);
+  }
+  set(time) {
+    this.currentTime = new Date(time.getTime());
+  }
+};
+
+// src/kernel/testing/in-memory-blob-store.ts
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var InMemoryBlobStore = class {
+  store = /* @__PURE__ */ new Map();
+  async put(key, data) {
+    this.store.set(key, deepClone(data));
+  }
+  async get(key) {
+    if (!this.store.has(key)) {
+      throw new Error(`Blob not found: ${key}`);
+    }
+    return deepClone(this.store.get(key));
+  }
+  async has(key) {
+    return this.store.has(key);
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async list(prefix) {
+    return [...this.store.keys()].filter((k) => k.startsWith(prefix));
+  }
+  // Test helpers
+  clear() {
+    this.store.clear();
+  }
+  size() {
+    return this.store.size;
+  }
+};
+
+// src/kernel/testing/noop-scheduler.ts
+var NoopScheduler = class {
+  scheduled = [];
+  async schedule(commandType, payload, runAt) {
+    this.scheduled.push({ commandType, payload, runAt });
+  }
+  async cancel(_commandType, _correlationId) {
+  }
+  clear() {
+    this.scheduled.length = 0;
+  }
+};
+
+export { CollectingEventSink, FakeClock, InMemoryBlobStore, NoopScheduler };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/kernel/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/kernel/testing/collecting-event-sink.ts","../../../src/kernel/testing/fake-clock.ts","../../../src/kernel/testing/in-memory-blob-store.ts","../../../src/kernel/testing/noop-scheduler.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type { KernelEvent, KernelEventType } from \"../events\";\nimport type { EventSink } from \"../ports\";\n\nexport class CollectingEventSink implements EventSink {\n  readonly events: KernelEvent[] = [];\n\n  async emit(event: KernelEvent): Promise<void> {\n    this.events.push(event);\n  }\n\n  getByType<T extends KernelEventType>(\n    type: T,\n  ): Extract<KernelEvent, { type: T }>[] {\n    return this.events.filter(\n      (e): e is Extract<KernelEvent, { type: T }> => e.type === type,\n    );\n  }\n\n  clear(): void {\n    this.events.length = 0;\n  }\n\n  get length(): number {\n    return this.events.length;\n  }\n}\n","import type { Clock } from \"../ports\";\n\nexport class FakeClock implements Clock {\n  private currentTime: Date;\n\n  constructor(initialTime?: Date) {\n    this.currentTime = initialTime ?? new Date(\"2025-01-01T00:00:00Z\");\n  }\n\n  now(): Date {\n    return new Date(this.currentTime.getTime());\n  }\n\n  advance(ms: number): void {\n    this.currentTime = new Date(this.currentTime.getTime() + ms);\n  }\n\n  set(time: Date): void {\n    this.currentTime = new Date(time.getTime());\n  }\n}\n","import type { BlobStore } from \"../ports\";\n\nfunction deepClone<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value)) as T;\n}\n\nexport class InMemoryBlobStore implements BlobStore {\n  private store = new Map<string, unknown>();\n\n  async put(key: string, data: unknown): Promise<void> {\n    this.store.set(key, deepClone(data));\n  }\n\n  async get(key: string): Promise<unknown> {\n    if (!this.store.has(key)) {\n      throw new Error(`Blob not found: ${key}`);\n    }\n    return deepClone(this.store.get(key));\n  }\n\n  async has(key: string): Promise<boolean> {\n    return this.store.has(key);\n  }\n\n  async delete(key: string): Promise<void> {\n    this.store.delete(key);\n  }\n\n  async list(prefix: string): Promise<string[]> {\n    return [...this.store.keys()].filter((k) => k.startsWith(prefix));\n  }\n\n  // Test helpers\n  clear(): void {\n    this.store.clear();\n  }\n\n  size(): number {\n    return this.store.size;\n  }\n}\n","import type { Scheduler } from \"../ports\";\n\nexport class NoopScheduler implements Scheduler {\n  readonly scheduled: Array<{\n    commandType: string;\n    payload: unknown;\n    runAt: Date;\n  }> = [];\n\n  async schedule(\n    commandType: string,\n    payload: unknown,\n    runAt: Date,\n  ): Promise<void> {\n    this.scheduled.push({ commandType, payload, runAt });\n  }\n\n  async cancel(_commandType: string, _correlationId: string): Promise<void> {\n    // No-op in Phase 1\n  }\n\n  clear(): void {\n    this.scheduled.length = 0;\n  }\n}\n"]}

package/dist/persistence/index.d.ts

@@ -0,0 +1,2 @@
+export { A as AICallLogger, i as AICallRecord, h as AIHelperStats, r as ArtifactType, g as CreateAICallInput, f as CreateLogInput, a as CreateRunInput, b as CreateStageInput, D as DequeueResult, E as EnqueueJobInput, J as JobQueue, j as JobRecord, k as JobStatus, L as LogLevel, o as SaveArtifactInput, S as Status, U as UpdateRunInput, e as UpdateStageInput, d as UpsertStageInput, p as WorkflowArtifactRecord, q as WorkflowLogRecord, l as WorkflowPersistence, W as WorkflowRunRecord, c as WorkflowStageRecord, n as WorkflowStageStatus, m as WorkflowStatus } from '../interface-MMqhfQQK.js';
+export { P as PrismaAICallLogger, a as PrismaJobQueue, c as PrismaWorkflowPersistence, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from '../index-DAzCfO1R.js';

package/dist/persistence/index.js

@@ -0,0 +1,6 @@
+import '../chunk-D7RVRRM2.js';
+export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence } from '../chunk-NYKMT46J.js';
+import '../chunk-MUWP5SF2.js';
+import '../chunk-SPXBCZLB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/persistence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/persistence/prisma/index.d.ts

@@ -0,0 +1,37 @@
+export { D as DatabaseType, P as PrismaAICallLogger, a as PrismaJobQueue, b as PrismaJobQueueOptions, c as PrismaWorkflowPersistence, d as PrismaWorkflowPersistenceOptions, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from '../../index-DAzCfO1R.js';
+import '../../interface-MMqhfQQK.js';
+
+/**
+ * Prisma Enum Compatibility Layer
+ *
+ * Provides compatibility between Prisma 6.x (string enums) and Prisma 7.x (typed enums).
+ * Prisma 7.x introduced runtime enum validation, requiring actual enum values instead of strings.
+ *
+ * This utility resolves enum values from the Prisma client's $Enums property when available,
+ * falling back to string values for older Prisma versions.
+ *
+ * @example
+ * ```typescript
+ * const helper = createEnumHelper(prisma);
+ *
+ * // Instead of: status: "PENDING"
+ * // Use: status: helper.status("PENDING")
+ * ```
+ */
+type PrismaClient = any;
+interface PrismaEnumHelper {
+    /** Resolve Status enum value (unified enum for workflows, stages, and jobs) */
+    status(value: string): unknown;
+    /** Resolve ArtifactType enum value */
+    artifactType(value: string): unknown;
+    /** Resolve LogLevel enum value */
+    logLevel(value: string): unknown;
+}
+/**
+ * Creates an enum helper that resolves enum values from the Prisma client.
+ *
+ * Supports both Prisma 6.x (returns string) and Prisma 7.x (returns typed enum).
+ */
+declare function createEnumHelper(prisma: PrismaClient): PrismaEnumHelper;
+
+export { type PrismaEnumHelper, createEnumHelper };

package/dist/persistence/prisma/index.js

@@ -0,0 +1,5 @@
+export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createEnumHelper, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence } from '../../chunk-NYKMT46J.js';
+import '../../chunk-MUWP5SF2.js';
+import '../../chunk-SPXBCZLB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/persistence/prisma/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}