@bratsos/workflow-engine 0.0.11 → 0.2.0

package/dist/testing/index.js

@@ -0,0 +1,920 @@
+import { StaleVersionError } from '../chunk-SPXBCZLB.js';
+import { randomUUID } from 'crypto';
+
+var InMemoryAICallLogger = class {
+  calls = /* @__PURE__ */ new Map();
+  recordedBatches = /* @__PURE__ */ new Set();
+  // ============================================================================
+  // Core Operations
+  // ============================================================================
+  /**
+   * Log a single AI call (fire and forget)
+   */
+  logCall(call) {
+    const id = randomUUID();
+    const record = {
+      id,
+      createdAt: /* @__PURE__ */ new Date(),
+      topic: call.topic,
+      callType: call.callType,
+      modelKey: call.modelKey,
+      modelId: call.modelId,
+      prompt: call.prompt,
+      response: call.response,
+      inputTokens: call.inputTokens,
+      outputTokens: call.outputTokens,
+      cost: call.cost,
+      metadata: call.metadata ?? null
+    };
+    this.calls.set(id, record);
+  }
+  /**
+   * Log batch results (for recording batch API results)
+   */
+  async logBatchResults(batchId, results) {
+    this.recordedBatches.add(batchId);
+    for (const result of results) {
+      this.logCall({
+        ...result,
+        metadata: {
+          ...result.metadata,
+          batchId
+        }
+      });
+    }
+  }
+  /**
+   * Get aggregated stats for a topic prefix
+   */
+  async getStats(topicPrefix) {
+    const matchingCalls = Array.from(this.calls.values()).filter(
+      (call) => call.topic.startsWith(topicPrefix)
+    );
+    const stats = {
+      totalCalls: matchingCalls.length,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCost: 0,
+      perModel: {}
+    };
+    for (const call of matchingCalls) {
+      stats.totalInputTokens += call.inputTokens;
+      stats.totalOutputTokens += call.outputTokens;
+      stats.totalCost += call.cost;
+      if (!stats.perModel[call.modelKey]) {
+        stats.perModel[call.modelKey] = {
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cost: 0
+        };
+      }
+      stats.perModel[call.modelKey].calls++;
+      stats.perModel[call.modelKey].inputTokens += call.inputTokens;
+      stats.perModel[call.modelKey].outputTokens += call.outputTokens;
+      stats.perModel[call.modelKey].cost += call.cost;
+    }
+    return stats;
+  }
+  /**
+   * Check if batch results are already recorded
+   */
+  async isRecorded(batchId) {
+    return this.recordedBatches.has(batchId);
+  }
+  // ============================================================================
+  // Test Helpers
+  // ============================================================================
+  /**
+   * Clear all data - useful between tests
+   */
+  clear() {
+    this.calls.clear();
+    this.recordedBatches.clear();
+  }
+  /**
+   * Get all calls for inspection
+   */
+  getAllCalls() {
+    return Array.from(this.calls.values()).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by topic for inspection
+   */
+  getCallsByTopic(topic) {
+    return Array.from(this.calls.values()).filter((c) => c.topic === topic).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by topic prefix for inspection
+   */
+  getCallsByTopicPrefix(prefix) {
+    return Array.from(this.calls.values()).filter((c) => c.topic.startsWith(prefix)).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by model for inspection
+   */
+  getCallsByModel(modelKey) {
+    return Array.from(this.calls.values()).filter((c) => c.modelKey === modelKey).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by call type for inspection
+   */
+  getCallsByType(callType) {
+    return Array.from(this.calls.values()).filter((c) => c.callType === callType).map((c) => ({ ...c }));
+  }
+  /**
+   * Get total cost across all calls
+   */
+  getTotalCost() {
+    let total = 0;
+    for (const call of this.calls.values()) {
+      total += call.cost;
+    }
+    return total;
+  }
+  /**
+   * Get total tokens across all calls
+   */
+  getTotalTokens() {
+    let input = 0;
+    let output = 0;
+    for (const call of this.calls.values()) {
+      input += call.inputTokens;
+      output += call.outputTokens;
+    }
+    return { input, output };
+  }
+  /**
+   * Get call count
+   */
+  getCallCount() {
+    return this.calls.size;
+  }
+  /**
+   * Get all recorded batch IDs
+   */
+  getRecordedBatchIds() {
+    return Array.from(this.recordedBatches);
+  }
+  /**
+   * Get the last call made (useful for assertions)
+   */
+  getLastCall() {
+    const calls = Array.from(this.calls.values());
+    if (calls.length === 0) return null;
+    calls.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return { ...calls[0] };
+  }
+  /**
+   * Assert a call was made with specific properties
+   */
+  hasCallMatching(predicate) {
+    return Array.from(this.calls.values()).some(predicate);
+  }
+};
+var InMemoryJobQueue = class {
+  jobs = /* @__PURE__ */ new Map();
+  workerId;
+  defaultMaxAttempts = 3;
+  constructor(workerId) {
+    this.workerId = workerId ?? `worker-${randomUUID().slice(0, 8)}`;
+  }
+  // ============================================================================
+  // Core Operations
+  // ============================================================================
+  async enqueue(options) {
+    const now = /* @__PURE__ */ new Date();
+    const id = randomUUID();
+    const job = {
+      id,
+      createdAt: now,
+      updatedAt: now,
+      workflowRunId: options.workflowRunId,
+      workflowId: options.workflowId,
+      stageId: options.stageId,
+      status: "PENDING",
+      priority: options.priority ?? 5,
+      workerId: null,
+      lockedAt: null,
+      startedAt: null,
+      completedAt: null,
+      attempt: 1,
+      maxAttempts: this.defaultMaxAttempts,
+      lastError: null,
+      nextPollAt: options.scheduledFor ?? null,
+      payload: options.payload ?? {}
+    };
+    this.jobs.set(id, job);
+    return id;
+  }
+  async enqueueParallel(jobs) {
+    const ids = [];
+    for (const job of jobs) {
+      const id = await this.enqueue(job);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async dequeue() {
+    const now = /* @__PURE__ */ new Date();
+    const pendingJobs = Array.from(this.jobs.values()).filter(
+      (j) => j.status === "PENDING" && (j.nextPollAt === null || j.nextPollAt <= now)
+    ).sort((a, b) => {
+      if (b.priority !== a.priority) {
+        return b.priority - a.priority;
+      }
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+    if (pendingJobs.length === 0) {
+      return null;
+    }
+    const job = pendingJobs[0];
+    const updated = {
+      ...job,
+      status: "RUNNING",
+      workerId: this.workerId,
+      lockedAt: now,
+      startedAt: now,
+      updatedAt: now
+    };
+    this.jobs.set(job.id, updated);
+    return {
+      jobId: job.id,
+      workflowRunId: job.workflowRunId,
+      workflowId: job.workflowId,
+      stageId: job.stageId,
+      priority: job.priority,
+      attempt: job.attempt,
+      maxAttempts: job.maxAttempts,
+      payload: job.payload
+    };
+  }
+  async complete(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const updated = {
+      ...job,
+      status: "COMPLETED",
+      completedAt: now,
+      updatedAt: now
+    };
+    this.jobs.set(jobId, updated);
+  }
+  async suspend(jobId, nextPollAt) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    const updated = {
+      ...job,
+      status: "SUSPENDED",
+      nextPollAt,
+      workerId: null,
+      lockedAt: null,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.jobs.set(jobId, updated);
+  }
+  async fail(jobId, error, shouldRetry = true) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (shouldRetry && job.attempt < job.maxAttempts) {
+      const updated = {
+        ...job,
+        status: "PENDING",
+        attempt: job.attempt + 1,
+        lastError: error,
+        workerId: null,
+        lockedAt: null,
+        updatedAt: now
+      };
+      this.jobs.set(jobId, updated);
+    } else {
+      const updated = {
+        ...job,
+        status: "FAILED",
+        lastError: error,
+        completedAt: now,
+        updatedAt: now
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+  async getSuspendedJobsReadyToPoll() {
+    const now = /* @__PURE__ */ new Date();
+    return Array.from(this.jobs.values()).filter(
+      (j) => j.status === "SUSPENDED" && j.nextPollAt && j.nextPollAt <= now
+    ).map((j) => ({
+      jobId: j.id,
+      stageId: j.stageId,
+      workflowRunId: j.workflowRunId
+    }));
+  }
+  async releaseStaleJobs(staleThresholdMs = 6e4) {
+    const now = /* @__PURE__ */ new Date();
+    const threshold = new Date(now.getTime() - staleThresholdMs);
+    let released = 0;
+    for (const job of this.jobs.values()) {
+      if (job.status === "RUNNING" && job.lockedAt && job.lockedAt < threshold) {
+        const updated = {
+          ...job,
+          status: "PENDING",
+          workerId: null,
+          lockedAt: null,
+          updatedAt: now
+        };
+        this.jobs.set(job.id, updated);
+        released++;
+      }
+    }
+    return released;
+  }
+  // ============================================================================
+  // Test Helpers
+  // ============================================================================
+  /**
+   * Clear all jobs - useful between tests
+   */
+  clear() {
+    this.jobs.clear();
+  }
+  /**
+   * Get all jobs for inspection
+   */
+  getAllJobs() {
+    return Array.from(this.jobs.values()).map((j) => ({ ...j }));
+  }
+  /**
+   * Get jobs by status for inspection
+   */
+  getJobsByStatus(status) {
+    return Array.from(this.jobs.values()).filter((j) => j.status === status).map((j) => ({ ...j }));
+  }
+  /**
+   * Get a specific job by ID
+   */
+  getJob(jobId) {
+    const job = this.jobs.get(jobId);
+    return job ? { ...job } : null;
+  }
+  /**
+   * Get the worker ID for this queue instance
+   */
+  getWorkerId() {
+    return this.workerId;
+  }
+  /**
+   * Set max attempts for new jobs
+   */
+  setDefaultMaxAttempts(maxAttempts) {
+    this.defaultMaxAttempts = maxAttempts;
+  }
+  /**
+   * Simulate a worker crash by releasing a job's lock without completing it
+   */
+  simulateCrash(jobId) {
+    const job = this.jobs.get(jobId);
+    if (job && job.status === "RUNNING") ;
+  }
+  /**
+   * Move a suspended job back to pending (for manual resume testing)
+   */
+  resumeJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (job && job.status === "SUSPENDED") {
+      const updated = {
+        ...job,
+        status: "PENDING",
+        nextPollAt: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+  /**
+   * Set lockedAt for testing stale job scenarios
+   */
+  setJobLockedAt(jobId, lockedAt) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      const updated = {
+        ...job,
+        lockedAt
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+  /**
+   * Set nextPollAt for testing suspended job polling
+   */
+  setJobNextPollAt(jobId, nextPollAt) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      const updated = {
+        ...job,
+        nextPollAt
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+};
+var InMemoryWorkflowPersistence = class {
+  runs = /* @__PURE__ */ new Map();
+  stages = /* @__PURE__ */ new Map();
+  logs = /* @__PURE__ */ new Map();
+  artifacts = /* @__PURE__ */ new Map();
+  outbox = [];
+  idempotencyKeys = /* @__PURE__ */ new Map();
+  idempotencyInProgress = /* @__PURE__ */ new Set();
+  outboxSequences = /* @__PURE__ */ new Map();
+  // Helper to generate composite keys for stages
+  stageKey(runId, stageId) {
+    return `${runId}:${stageId}`;
+  }
+  // Helper to generate composite keys for artifacts
+  artifactKey(runId, key) {
+    return `${runId}:${key}`;
+  }
+  idempotencyCompositeKey(commandType, key) {
+    return `${commandType}:${key}`;
+  }
+  async withTransaction(fn) {
+    return fn(this);
+  }
+  // ============================================================================
+  // WorkflowRun Operations
+  // ============================================================================
+  async createRun(data) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: data.id ?? randomUUID(),
+      createdAt: now,
+      updatedAt: now,
+      version: 1,
+      workflowId: data.workflowId,
+      workflowName: data.workflowName,
+      workflowType: data.workflowType,
+      status: "PENDING",
+      startedAt: null,
+      completedAt: null,
+      duration: null,
+      input: data.input,
+      output: null,
+      config: data.config ?? {},
+      totalCost: 0,
+      totalTokens: 0,
+      priority: data.priority ?? 5
+    };
+    this.runs.set(record.id, record);
+    return { ...record };
+  }
+  async updateRun(id, data) {
+    const run = this.runs.get(id);
+    if (!run) {
+      throw new Error(`WorkflowRun not found: ${id}`);
+    }
+    if (data.expectedVersion !== void 0 && run.version !== data.expectedVersion) {
+      throw new StaleVersionError(
+        "WorkflowRun",
+        id,
+        data.expectedVersion,
+        run.version
+      );
+    }
+    const { expectedVersion: _, ...rest } = data;
+    const updated = {
+      ...run,
+      ...rest,
+      updatedAt: /* @__PURE__ */ new Date(),
+      version: run.version + 1
+    };
+    this.runs.set(id, updated);
+  }
+  async getRun(id) {
+    const run = this.runs.get(id);
+    return run ? { ...run } : null;
+  }
+  async getRunStatus(id) {
+    const run = this.runs.get(id);
+    return run?.status ?? null;
+  }
+  async getRunsByStatus(status) {
+    return Array.from(this.runs.values()).filter((run) => run.status === status).map((run) => ({ ...run }));
+  }
+  async claimPendingRun(id) {
+    const run = this.runs.get(id);
+    if (!run || run.status !== "PENDING") {
+      return false;
+    }
+    const updated = {
+      ...run,
+      status: "RUNNING",
+      startedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      version: run.version + 1
+    };
+    this.runs.set(id, updated);
+    return true;
+  }
+  async claimNextPendingRun() {
+    const pendingRuns = Array.from(this.runs.values()).filter((run) => run.status === "PENDING").sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+    if (pendingRuns.length === 0) {
+      return null;
+    }
+    const runToClaim = pendingRuns[0];
+    const currentRun = this.runs.get(runToClaim.id);
+    if (!currentRun || currentRun.status !== "PENDING") {
+      return this.claimNextPendingRun();
+    }
+    const claimed = {
+      ...currentRun,
+      status: "RUNNING",
+      startedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      version: currentRun.version + 1
+    };
+    this.runs.set(claimed.id, claimed);
+    return { ...claimed };
+  }
+  // ============================================================================
+  // WorkflowStage Operations
+  // ============================================================================
+  async createStage(data) {
+    const now = /* @__PURE__ */ new Date();
+    const id = randomUUID();
+    const record = {
+      id,
+      createdAt: now,
+      updatedAt: now,
+      version: 1,
+      workflowRunId: data.workflowRunId,
+      stageId: data.stageId,
+      stageName: data.stageName,
+      stageNumber: data.stageNumber,
+      executionGroup: data.executionGroup,
+      status: data.status ?? "PENDING",
+      startedAt: data.startedAt ?? null,
+      completedAt: null,
+      duration: null,
+      inputData: data.inputData ?? null,
+      outputData: null,
+      config: data.config ?? null,
+      suspendedState: null,
+      resumeData: null,
+      nextPollAt: null,
+      pollInterval: null,
+      maxWaitUntil: null,
+      metrics: null,
+      embeddingInfo: null,
+      errorMessage: null
+    };
+    this.stages.set(id, record);
+    this.stages.set(this.stageKey(data.workflowRunId, data.stageId), record);
+    return { ...record };
+  }
+  async upsertStage(data) {
+    const key = this.stageKey(data.workflowRunId, data.stageId);
+    const existing = this.stages.get(key);
+    if (existing) {
+      const updated = {
+        ...existing,
+        ...data.update,
+        updatedAt: /* @__PURE__ */ new Date(),
+        version: existing.version + 1
+      };
+      this.stages.set(existing.id, updated);
+      this.stages.set(key, updated);
+      return { ...updated };
+    } else {
+      return this.createStage(data.create);
+    }
+  }
+  async updateStage(id, data) {
+    const stage = this.stages.get(id);
+    if (!stage) {
+      throw new Error(`WorkflowStage not found: ${id}`);
+    }
+    if (data.expectedVersion !== void 0 && stage.version !== data.expectedVersion) {
+      throw new StaleVersionError(
+        "WorkflowStage",
+        id,
+        data.expectedVersion,
+        stage.version
+      );
+    }
+    const { expectedVersion: _, ...rest } = data;
+    const updated = {
+      ...stage,
+      ...rest,
+      updatedAt: /* @__PURE__ */ new Date(),
+      version: stage.version + 1
+    };
+    this.stages.set(id, updated);
+    this.stages.set(this.stageKey(stage.workflowRunId, stage.stageId), updated);
+  }
+  async updateStageByRunAndStageId(workflowRunId, stageId, data) {
+    const key = this.stageKey(workflowRunId, stageId);
+    const stage = this.stages.get(key);
+    if (!stage) {
+      throw new Error(`WorkflowStage not found: ${workflowRunId}/${stageId}`);
+    }
+    if (data.expectedVersion !== void 0 && stage.version !== data.expectedVersion) {
+      throw new StaleVersionError(
+        "WorkflowStage",
+        `${workflowRunId}/${stageId}`,
+        data.expectedVersion,
+        stage.version
+      );
+    }
+    const { expectedVersion: _, ...rest } = data;
+    const updated = {
+      ...stage,
+      ...rest,
+      updatedAt: /* @__PURE__ */ new Date(),
+      version: stage.version + 1
+    };
+    this.stages.set(stage.id, updated);
+    this.stages.set(key, updated);
+  }
+  async getStage(runId, stageId) {
+    const key = this.stageKey(runId, stageId);
+    const stage = this.stages.get(key);
+    return stage ? { ...stage } : null;
+  }
+  async getStageById(id) {
+    const stage = this.stages.get(id);
+    return stage ? { ...stage } : null;
+  }
+  async getStagesByRun(runId, options) {
+    const seenIds = /* @__PURE__ */ new Set();
+    let stages = Array.from(this.stages.values()).filter((s) => {
+      if (s.workflowRunId !== runId) return false;
+      if (seenIds.has(s.id)) return false;
+      seenIds.add(s.id);
+      return true;
+    });
+    if (options?.status) {
+      stages = stages.filter((s) => s.status === options.status);
+    }
+    stages.sort((a, b) => {
+      const diff = a.stageNumber - b.stageNumber;
+      return options?.orderBy === "desc" ? -diff : diff;
+    });
+    return stages.map((s) => ({ ...s }));
+  }
+  async getSuspendedStages(beforeDate) {
+    const seenIds = /* @__PURE__ */ new Set();
+    return Array.from(this.stages.values()).filter((s) => {
+      if (seenIds.has(s.id)) return false;
+      seenIds.add(s.id);
+      return s.status === "SUSPENDED" && s.nextPollAt !== null && s.nextPollAt <= beforeDate;
+    }).map((s) => ({ ...s }));
+  }
+  async getFirstSuspendedStageReadyToResume(runId) {
+    const stages = await this.getStagesByRun(runId, { status: "SUSPENDED" });
+    const now = /* @__PURE__ */ new Date();
+    const ready = stages.find((s) => s.nextPollAt && s.nextPollAt <= now);
+    return ready ?? null;
+  }
+  async getFirstFailedStage(runId) {
+    const stages = await this.getStagesByRun(runId, { status: "FAILED" });
+    return stages[0] ?? null;
+  }
+  async getLastCompletedStage(runId) {
+    const stages = await this.getStagesByRun(runId, {
+      status: "COMPLETED",
+      orderBy: "desc"
+    });
+    return stages[0] ?? null;
+  }
+  async getLastCompletedStageBefore(runId, executionGroup) {
+    const stages = await this.getStagesByRun(runId, {
+      status: "COMPLETED",
+      orderBy: "desc"
+    });
+    const before = stages.filter((s) => s.executionGroup < executionGroup);
+    return before[0] ?? null;
+  }
+  async deleteStage(id) {
+    const stage = this.stages.get(id);
+    if (stage) {
+      this.stages.delete(id);
+      this.stages.delete(this.stageKey(stage.workflowRunId, stage.stageId));
+    }
+  }
+  // ============================================================================
+  // WorkflowLog Operations
+  // ============================================================================
+  async createLog(data) {
+    const record = {
+      id: randomUUID(),
+      createdAt: /* @__PURE__ */ new Date(),
+      workflowRunId: data.workflowRunId ?? null,
+      workflowStageId: data.workflowStageId ?? null,
+      level: data.level,
+      message: data.message,
+      metadata: data.metadata ?? null
+    };
+    this.logs.set(record.id, record);
+  }
+  // ============================================================================
+  // Outbox Operations
+  // ============================================================================
+  async appendOutboxEvents(events) {
+    for (const event of events) {
+      const currentSeq = this.outboxSequences.get(event.workflowRunId) ?? 0;
+      const nextSeq = currentSeq + 1;
+      this.outboxSequences.set(event.workflowRunId, nextSeq);
+      const record = {
+        id: randomUUID(),
+        workflowRunId: event.workflowRunId,
+        sequence: nextSeq,
+        eventType: event.eventType,
+        payload: event.payload,
+        causationId: event.causationId,
+        occurredAt: event.occurredAt,
+        publishedAt: null,
+        retryCount: 0,
+        dlqAt: null
+      };
+      this.outbox.push(record);
+    }
+  }
+  async getUnpublishedOutboxEvents(limit) {
+    const effectiveLimit = limit ?? 100;
+    return this.outbox.filter((r) => r.publishedAt === null && r.dlqAt === null).sort((a, b) => {
+      const runCmp = a.workflowRunId.localeCompare(b.workflowRunId);
+      if (runCmp !== 0) return runCmp;
+      return a.sequence - b.sequence;
+    }).slice(0, effectiveLimit).map((r) => ({ ...r }));
+  }
+  async markOutboxEventsPublished(ids) {
+    const idSet = new Set(ids);
+    for (const record of this.outbox) {
+      if (idSet.has(record.id)) {
+        record.publishedAt = /* @__PURE__ */ new Date();
+      }
+    }
+  }
+  async incrementOutboxRetryCount(id) {
+    const record = this.outbox.find((r) => r.id === id);
+    if (!record) throw new Error(`Outbox event not found: ${id}`);
+    record.retryCount++;
+    return record.retryCount;
+  }
+  async moveOutboxEventToDLQ(id) {
+    const record = this.outbox.find((r) => r.id === id);
+    if (!record) throw new Error(`Outbox event not found: ${id}`);
+    record.dlqAt = /* @__PURE__ */ new Date();
+  }
+  async replayDLQEvents(maxEvents) {
+    const dlqEvents = this.outbox.filter((r) => r.dlqAt !== null).slice(0, maxEvents);
+    for (const record of dlqEvents) {
+      record.dlqAt = null;
+      record.retryCount = 0;
+    }
+    return dlqEvents.length;
+  }
+  // ============================================================================
+  // Idempotency Operations
+  // ============================================================================
+  async acquireIdempotencyKey(key, commandType) {
+    const compositeKey = this.idempotencyCompositeKey(commandType, key);
+    const record = this.idempotencyKeys.get(compositeKey);
+    if (record) {
+      return { status: "replay", result: record.result };
+    }
+    if (this.idempotencyInProgress.has(compositeKey)) {
+      return { status: "in_progress" };
+    }
+    this.idempotencyInProgress.add(compositeKey);
+    return { status: "acquired" };
+  }
+  async completeIdempotencyKey(key, commandType, result) {
+    const compositeKey = this.idempotencyCompositeKey(commandType, key);
+    this.idempotencyInProgress.delete(compositeKey);
+    this.idempotencyKeys.set(compositeKey, {
+      key,
+      commandType,
+      result,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  async releaseIdempotencyKey(key, commandType) {
+    this.idempotencyInProgress.delete(
+      this.idempotencyCompositeKey(commandType, key)
+    );
+  }
+  // ============================================================================
+  // WorkflowArtifact Operations
+  // ============================================================================
+  async saveArtifact(data) {
+    const now = /* @__PURE__ */ new Date();
+    const key = this.artifactKey(data.workflowRunId, data.key);
+    const existing = this.artifacts.get(key);
+    const record = {
+      id: existing?.id ?? randomUUID(),
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      workflowRunId: data.workflowRunId,
+      workflowStageId: data.workflowStageId ?? null,
+      key: data.key,
+      type: data.type,
+      data: data.data,
+      size: data.size,
+      metadata: data.metadata ?? null
+    };
+    this.artifacts.set(key, record);
+  }
+  async loadArtifact(runId, key) {
+    const artifact = this.artifacts.get(this.artifactKey(runId, key));
+    if (!artifact) {
+      throw new Error(`Artifact not found: ${runId}/${key}`);
+    }
+    return artifact.data;
+  }
+  async hasArtifact(runId, key) {
+    return this.artifacts.has(this.artifactKey(runId, key));
+  }
+  async deleteArtifact(runId, key) {
+    this.artifacts.delete(this.artifactKey(runId, key));
+  }
+  async listArtifacts(runId) {
+    return Array.from(this.artifacts.values()).filter((a) => a.workflowRunId === runId).map((a) => ({ ...a }));
+  }
+  async getStageIdForArtifact(runId, stageId) {
+    const stage = await this.getStage(runId, stageId);
+    return stage?.id ?? null;
+  }
+  // ============================================================================
+  // Stage Output Convenience Method
+  // ============================================================================
+  async saveStageOutput(runId, workflowType, stageId, output) {
+    const key = `workflow-v2/${workflowType}/${runId}/${stageId}/output.json`;
+    const stageDbId = await this.getStageIdForArtifact(runId, stageId);
+    await this.saveArtifact({
+      workflowRunId: runId,
+      workflowStageId: stageDbId ?? void 0,
+      key,
+      type: "STAGE_OUTPUT",
+      data: output,
+      size: JSON.stringify(output).length
+    });
+    return key;
+  }
+  // ============================================================================
+  // Test Helpers
+  // ============================================================================
+  /**
+   * Clear all data - useful between tests
+   */
+  clear() {
+    this.runs.clear();
+    this.stages.clear();
+    this.logs.clear();
+    this.artifacts.clear();
+    this.outbox = [];
+    this.idempotencyKeys.clear();
+    this.idempotencyInProgress.clear();
+    this.outboxSequences.clear();
+  }
+  /**
+   * Get all runs for inspection
+   */
+  getAllRuns() {
+    return Array.from(this.runs.values()).map((r) => ({ ...r }));
+  }
+  /**
+   * Get all stages for inspection
+   */
+  getAllStages() {
+    return Array.from(this.stages.values()).filter((s) => this.stages.get(s.id) === s).map((s) => ({ ...s }));
+  }
+  /**
+   * Get all logs for inspection
+   */
+  getAllLogs() {
+    return Array.from(this.logs.values()).map((l) => ({ ...l }));
+  }
+  /**
+   * Get all artifacts for inspection
+   */
+  getAllArtifacts() {
+    return Array.from(this.artifacts.values()).map((a) => ({ ...a }));
+  }
+};
+
+export { InMemoryAICallLogger, InMemoryJobQueue, InMemoryWorkflowPersistence };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map