@cascade-flow/client 0.1.0

package/README.md

@@ -0,0 +1,114 @@
+# @cascadeflow/client
+
+Type-safe programmatic client for submitting and managing workflow runs.
+
+## Installation
+
+The client requires a backend implementation to persist workflow state. Install the client along with your chosen backend:
+
+### With Filesystem Backend (Recommended for Development)
+
+```bash
+npm install @cascadeflow/client @cascadeflow/backend-filesystem
+```
+
+### With PostgreSQL Backend (Production)
+
+```bash
+npm install @cascadeflow/client @cascadeflow/backend-postgres
+```
+
+## Usage
+
+```typescript
+import { WorkflowClient } from "@cascadeflow/client";
+import { FileSystemBackend } from "@cascadeflow/backend-filesystem";
+
+const client = new WorkflowClient(new FileSystemBackend("./.runs"));
+
+// Submit run
+const { runId } = await client.submit({
+  workflow: "my-workflow",
+  input: { userId: "123", count: 42 },
+  priority: 10,
+  timeout: 300000
+});
+
+// Wait for completion
+const output = await client.waitForCompletion(runId, {
+  timeout: 60000,
+  exponentialBackoff: true
+});
+
+// Check status
+const info = await client.getRun(runId);
+
+// Cancel
+await client.cancel(runId, "reason");
+```
+
+## Type Safety
+
+```typescript
+interface MyInput { userId: string; count: number; }
+interface MyOutput { results: string[]; }
+
+const { runId } = await client.submit<MyInput>({
+  workflow: "my-workflow",
+  input: { userId: "123", count: 42 }  // Type-checked
+});
+
+const output = await client.waitForCompletion<MyOutput>(runId);
+console.log(output.results);  // Type-safe access
+```
+
+## Methods
+
+```typescript
+// Submit run
+submit<TInput>(params: {
+  workflow: string;
+  input?: TInput;
+  priority?: number;
+  timeout?: number;
+  idempotencyKey?: string;
+  metadata?: Record<string, unknown>;
+  tags?: string[];
+}): Promise<{ runId: string; isNew: boolean }>;
+
+// Get status
+getStatus(runId: string): Promise<RunStatus>;
+
+// Get detailed info
+getRun(runId: string): Promise<RunState | null>;
+
+// Wait for completion
+waitForCompletion<TOutput>(runId: string, options?: {
+  interval?: number;
+  exponentialBackoff?: boolean;
+  maxBackoff?: number;
+  timeout?: number;
+}): Promise<TOutput>;
+
+// List runs
+listRuns(options?: { status?: RunStatus; limit?: number }): Promise<RunState[]>;
+
+// Cancel run
+cancel(runId: string, reason?: string): Promise<void>;
+```
+
+## Timeouts
+
+**3-tier fallback for step execution:**
+1. Step-level: `defineStep({ timeoutMs })`
+2. **Submission-level: `submit({ timeout })`** ← This package
+3. System default: 300000ms (5 min)
+
+Submission timeout sets workflow-wide execution limit for steps without their own `timeoutMs`.
+
+## CLI Integration
+
+Used internally by:
+- `cf submit` → `client.submit()`
+- `cf status` → `client.getRun()`
+- `cf cancel` → `client.cancel()`

package/dist/index.d.ts

@@ -0,0 +1,613 @@
+import type { Backend, RunState, WorkflowMetadata, AnalyticsOptions, ErrorAnalysis, RetryAnalysis, SchedulingLatency, StepDuration, WorkflowDuration, WorkerStability, Throughput, QueueDepth, QueueDepthByWorkflow, SuccessRate, AnalyticsSummary, StepEvent, StepState, LogEntry } from "@cascade-flow/backend-interface";
+import { type AttemptMetadata } from "@cascade-flow/backend-interface";
+import type { PollOptions, ListRunsOptions, RunInfo } from "./types.ts";
+/**
+ * WorkflowClient - submit and manage workflow runs via queue
+ *
+ * Features:
+ * - Type-safe submission with generic input types
+ * - Status checking and polling
+ * - Wait for completion with timeout
+ * - List and filter runs
+ * - Cancellation support
+ */
+export declare class WorkflowClient {
+    private backend;
+    constructor(backend: Backend);
+    /**
+     * Submit a workflow run to the queue
+     *
+     * Generic type TInput provides type safety for workflow input
+     *
+     * @example
+     * ```typescript
+     * import type { WorkflowInput } from './workflows/my-workflow/input-schema';
+     *
+     * const { runId } = await client.submit<WorkflowInput>({
+     *   workflow: 'my-workflow',
+     *   input: { userId: "123", count: 42 }  // Fully typed!
+     * });
+     * ```
+     */
+    submit<TInput = unknown>(params: {
+        workflow: string;
+        input?: TInput;
+        runId?: string;
+        availableAt?: number;
+        priority?: number;
+        timeout?: number;
+        idempotencyKey?: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+    }): Promise<{
+        runId: string;
+        isNew: boolean;
+    }>;
+    /**
+     * Get the current status of a run
+     *
+     * @param runId - The run ID to query
+     * @returns Run state or null if not found
+     */
+    getStatus(runId: string): Promise<RunState | null>;
+    /**
+     * Get detailed run information including output/error
+     *
+     * @param runId - The run ID to query
+     * @returns Extended run info or null if not found
+     */
+    getRun(runId: string): Promise<RunInfo | null>;
+    /**
+     * Wait for a run to complete
+     *
+     * Polls the backend until the run reaches a terminal state (completed/failed/cancelled)
+     *
+     * @param runId - The run ID to wait for
+     * @param options - Polling options
+     * @returns Run info when complete
+     * @throws Error if timeout or run fails
+     */
+    waitForCompletion<TOutput = unknown>(runId: string, options?: PollOptions): Promise<TOutput>;
+    /**
+     * List runs matching filters
+     *
+     * @param options - Filter options
+     * @returns Array of run states
+     */
+    listRuns(options?: ListRunsOptions): Promise<RunState[]>;
+    /**
+     * Cancel a run
+     *
+     * Can cancel runs in pending, claimed, or running status
+     *
+     * @param runId - The run to cancel
+     * @param reason - Optional cancellation reason
+     */
+    cancel(runId: string, reason?: string): Promise<void>;
+    /**
+     * Retry a failed workflow
+     *
+     * Retries all failed steps in the workflow, keeping successful steps from the original run.
+     * Step attempt numbers are reset to 1 for each retried step.
+     *
+     * @param runId - The run ID to retry
+     * @param reason - Optional reason for retry
+     * @returns Retry information including new workflow attempt number
+     * @throws Error if run is not in failed status
+     */
+    retry(runId: string, reason?: string): Promise<{
+        runId: string;
+        workflowAttemptNumber: number;
+        retriedSteps: string[];
+    }>;
+    /**
+     * List all available workflows
+     *
+     * @returns Array of workflow metadata
+     */
+    listWorkflows(): Promise<WorkflowMetadata[]>;
+    /**
+     * Get metadata for a specific workflow
+     *
+     * @param workflowSlug - Workflow identifier (directory name)
+     * @returns Workflow metadata or null if not found
+     */
+    getWorkflowMetadata(workflowSlug: string): Promise<WorkflowMetadata | null>;
+    /**
+     * Get step definitions for a specific workflow
+     *
+     * @param workflowSlug - Workflow identifier (directory name)
+     * @returns Array of step definitions or empty array if workflow not found
+     */
+    getWorkflowSteps(workflowSlug: string): Promise<any[]>;
+    /**
+     * Get the JSON Schema for a workflow's input
+     *
+     * @param workflowSlug - Workflow identifier (directory name)
+     * @returns JSON Schema object or null if workflow has no input schema
+     */
+    getWorkflowSchema(workflowSlug: string): Promise<any | null>;
+    /**
+     * Helper to sleep
+     */
+    private sleep;
+    /**
+     * Get error analysis for workflows and steps
+     *
+     * Analyzes failure patterns, error types, and common error messages.
+     *
+     * @param options - Optional filters for time range, workflow, or step
+     * @returns Error analysis data
+     *
+     * @example
+     * ```typescript
+     * // Get errors for last 24 hours (default)
+     * const errors = await client.getErrorAnalysis();
+     *
+     * // Get errors for specific workflow
+     * const errors = await client.getErrorAnalysis({
+     *   workflowSlug: 'my-workflow',
+     *   startUs: Date.now() * 1000 - 7 * 24 * 60 * 60 * 1000 * 1000 // Last 7 days
+     * });
+     * ```
+     */
+    getErrorAnalysis(options?: AnalyticsOptions): Promise<ErrorAnalysis>;
+    /**
+     * Get retry analysis metrics
+     *
+     * Analyzes retry patterns, success rates after retries, and retry effectiveness.
+     *
+     * @param options - Optional filters for time range, workflow, or step
+     * @returns Retry analysis data
+     */
+    getRetryAnalysis(options?: AnalyticsOptions): Promise<RetryAnalysis>;
+    /**
+     * Get scheduling latency metrics
+     *
+     * Measures time between step being scheduled and actually starting execution.
+     * High latency indicates worker starvation or queue congestion.
+     *
+     * @param options - Optional filters for time range, workflow, or step
+     * @returns Scheduling latency statistics
+     *
+     * @example
+     * ```typescript
+     * const latency = await client.getSchedulingLatency({ workflowSlug: 'my-workflow' });
+     * console.log(`Average wait time: ${latency.averageUs / 1000}ms`);
+     * console.log(`P95 wait time: ${latency.p95Us / 1000}ms`);
+     * ```
+     */
+    getSchedulingLatency(options?: AnalyticsOptions): Promise<SchedulingLatency>;
+    /**
+     * Get step duration metrics
+     *
+     * Analyzes how long steps take to execute.
+     *
+     * @param options - Optional filters for time range, workflow, or step
+     * @returns Step duration statistics
+     */
+    getStepDuration(options?: AnalyticsOptions): Promise<StepDuration>;
+    /**
+     * Get workflow duration metrics
+     *
+     * Analyzes end-to-end workflow execution time (from submission to completion).
+     *
+     * @param options - Optional filters for time range or workflow
+     * @returns Workflow duration statistics
+     */
+    getWorkflowDuration(options?: AnalyticsOptions): Promise<WorkflowDuration>;
+    /**
+     * Get worker stability metrics
+     *
+     * Analyzes worker crashes, reclamations, and stale heartbeats.
+     *
+     * @param options - Optional filters for time range
+     * @returns Worker stability data
+     */
+    getWorkerStability(options?: AnalyticsOptions): Promise<WorkerStability>;
+    /**
+     * Get throughput metrics
+     *
+     * Analyzes how many runs/steps are being completed per unit time.
+     *
+     * @param options - Optional filters for time range or workflow
+     * @returns Throughput data
+     */
+    getThroughput(options?: AnalyticsOptions): Promise<Throughput>;
+    /**
+     * Get current queue depth
+     *
+     * Real-time snapshot of pending/running runs and steps.
+     *
+     * @param options - Optional filter for workflow
+     * @returns Queue depth data
+     *
+     * @example
+     * ```typescript
+     * const depth = await client.getQueueDepth();
+     * console.log(`Pending runs: ${depth.pendingRuns}`);
+     * console.log(`Scheduled steps: ${depth.scheduledSteps}`);
+     * ```
+     */
+    getQueueDepth(options?: Pick<AnalyticsOptions, "workflowSlug">): Promise<QueueDepth>;
+    /**
+     * Get queue depth broken down by workflow
+     *
+     * Real-time snapshot showing per-workflow queue statistics.
+     * Useful for identifying which workflows have pending work.
+     *
+     * @returns Array of per-workflow queue depth data
+     *
+     * @example
+     * ```typescript
+     * const breakdown = await client.getQueueDepthByWorkflow();
+     * for (const workflow of breakdown) {
+     *   console.log(`${workflow.workflowName}: ${workflow.pendingRuns} pending, ${workflow.scheduledSteps} scheduled`);
+     * }
+     * ```
+     */
+    getQueueDepthByWorkflow(): Promise<QueueDepthByWorkflow>;
+    /**
+     * Get success/failure rate metrics
+     *
+     * Analyzes overall health of workflows and steps.
+     *
+     * @param options - Optional filters for time range, workflow, or step
+     * @returns Success rate data
+     */
+    getSuccessRate(options?: AnalyticsOptions): Promise<SuccessRate>;
+    /**
+     * Get comprehensive analytics summary
+     *
+     * Combines all analytics metrics into a single response.
+     * Useful for dashboard views.
+     *
+     * @param options - Optional filters for time range or workflow
+     * @returns Complete analytics summary
+     *
+     * @example
+     * ```typescript
+     * // Get full analytics for last 24 hours
+     * const summary = await client.getAnalyticsSummary();
+     *
+     * // Get analytics for specific workflow over last week
+     * const summary = await client.getAnalyticsSummary({
+     *   workflowSlug: 'my-workflow',
+     *   startUs: Date.now() * 1000 - 7 * 24 * 60 * 60 * 1000 * 1000
+     * });
+     * ```
+     */
+    getAnalyticsSummary(options?: AnalyticsOptions): Promise<AnalyticsSummary>;
+    /**
+     * Get paginated list of errors grouped by fingerprint
+     *
+     * @param options - Filtering and pagination options
+     * @returns Paginated list of error groups
+     *
+     * @example
+     * ```typescript
+     * // Get errors for last 24h
+     * const { errors, total } = await client.getErrorsList({
+     *   timeRange: { start: Date.now() * 1000 - 86400000000, end: Date.now() * 1000 },
+     *   groupingStrategy: 'exact',
+     *   limit: 50,
+     *   offset: 0
+     * });
+     * ```
+     */
+    getErrorsList(options?: {
+        timeRange?: {
+            start: number;
+            end: number;
+        };
+        workflowSlug?: string;
+        groupingStrategy?: 'exact' | 'normalized' | 'portable';
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        errors: Array<{
+            fingerprint: string;
+            errorMessage: string;
+            errorName: string;
+            sampleStack: string;
+            count: number;
+            affectedRuns: number;
+            firstSeen: number;
+            lastSeen: number;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Get detailed information about a specific error by fingerprint
+     *
+     * @param fingerprint - Composite fingerprint (nameHash:messageHash:stackHash)
+     * @param groupingStrategy - Which stack hash variant to use
+     * @param options - Filtering and pagination options
+     * @returns Error details with all occurrences
+     *
+     * @example
+     * ```typescript
+     * const detail = await client.getErrorDetail(
+     *   'abc123:def456:ghi789',
+     *   'exact',
+     *   { limit: 100, offset: 0 }
+     * );
+     * ```
+     */
+    getErrorDetail(fingerprint: string, groupingStrategy: 'exact' | 'normalized' | 'portable', options?: {
+        timeRange?: {
+            start: number;
+            end: number;
+        };
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        fingerprint: string;
+        errorMessage: string;
+        errorName: string;
+        sampleStack: string;
+        totalCount: number;
+        affectedRuns: number;
+        firstSeen: number;
+        lastSeen: number;
+        occurrences: Array<{
+            workflowSlug: string;
+            runId: string;
+            stepId: string;
+            attemptNumber: number;
+            timestampUs: number;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Get the state of all steps for a run
+     * Projects step events to compute current state
+     */
+    getStepStates(workflowSlug: string, runId: string): Promise<StepState[]>;
+    /**
+     * Get all events for a specific run (both workflow and step events)
+     */
+    getRunEvents(workflowSlug: string, runId: string): Promise<({
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepStarted";
+        workerId: string;
+        dependencies: string[];
+        attemptNumber: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepCompleted";
+        output: string;
+        durationUs: number;
+        attemptNumber: number;
+        exportOutput: boolean;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepFailed";
+        error: {
+            message: string;
+            stack?: string | undefined;
+            name?: string | undefined;
+        };
+        errorFingerprints: {
+            nameHash: string;
+            messageHash: string;
+            stackExactHash: string;
+            stackNormalizedHash: string;
+            stackPortableHash: string;
+        };
+        durationUs: number;
+        attemptNumber: number;
+        terminal: boolean;
+        failureReason: "timeout" | "cancelled" | "worker-crash" | "exhausted-retries" | "execution-error";
+        nextRetryAtUs?: number | undefined;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "LogEntry";
+        stream: "stdout" | "stderr";
+        message: string;
+        attemptNumber: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepRetrying";
+        attemptNumber: number;
+        nextAttempt: number;
+        error: {
+            message: string;
+            stack?: string | undefined;
+            name?: string | undefined;
+        };
+        maxRetries: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepScheduled";
+        availableAtUs: number;
+        reason: "retry" | "initial" | "dependency-satisfied";
+        attemptNumber: number;
+        retryDelayMs?: number | undefined;
+    } | {
+        eventId: string;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepHeartbeat";
+        workerId: string;
+        timestampUs: number;
+        attemptNumber: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepReclaimed";
+        originalWorkerId: string;
+        reclaimedBy: string;
+        lastHeartbeatUs: number;
+        staleThresholdUs: number;
+        staleDurationUs: number;
+        attemptNumber: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "step";
+        stepId: string;
+        type: "StepSkipped";
+        skipType: "primary" | "cascade";
+        reason: string;
+        durationUs: number;
+        attemptNumber: number;
+        metadata?: Record<string, any> | undefined;
+        cascadedFrom?: string | undefined;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "RunSubmitted";
+        availableAtUs: number;
+        priority: number;
+        hasInputSchema: boolean;
+        input?: string | undefined;
+        timeoutUs?: number | undefined;
+        idempotencyKey?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+        tags?: string[] | undefined;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowStarted";
+        workflowAttemptNumber: number;
+        hasInputSchema: boolean;
+        hasInput: boolean;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowInputValidation";
+        workflowAttemptNumber: number;
+        hasSchema: boolean;
+        success: boolean;
+        error?: {
+            message: string;
+            stack?: string | undefined;
+            name?: string | undefined;
+        } | undefined;
+        validationErrors?: {
+            path: string;
+            message: string;
+        }[] | undefined;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowCompleted";
+        workflowAttemptNumber: number;
+        output: string;
+        durationUs: number;
+        totalSteps: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowFailed";
+        workflowAttemptNumber: number;
+        error: {
+            message: string;
+            stack?: string | undefined;
+            name?: string | undefined;
+        };
+        durationUs: number;
+        completedSteps: number;
+        failureReason: "timeout" | "cancelled" | "worker-crash" | "step-failed";
+        failedStep?: string | undefined;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowResumed";
+        originalRunId: string;
+        resumedSteps: number;
+        pendingSteps: number;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowCancelled";
+        workflowAttemptNumber: number;
+        durationUs: number;
+        completedSteps: number;
+        reason?: string | undefined;
+    } | {
+        eventId: string;
+        timestampUs: number;
+        workflowSlug: string;
+        runId: string;
+        category: "workflow";
+        type: "WorkflowRetryStarted";
+        workflowAttemptNumber: number;
+        previousAttemptNumber: number;
+        retriedSteps: string[];
+        reason?: string | undefined;
+    })[]>;
+    /**
+     * Get detailed information for a specific step
+     * Includes state, events, and logs
+     */
+    getStepDetail(workflowSlug: string, runId: string, stepName: string): Promise<{
+        state: StepState;
+        events: StepEvent[];
+        logs: LogEntry[];
+        attempts: AttemptMetadata[];
+    } | null>;
+}
+export type { PollOptions, ListRunsOptions, RunInfo } from "./types.ts";
+export type { AnalyticsOptions, ErrorAnalysis, RetryAnalysis, SchedulingLatency, StepDuration, WorkflowDuration, WorkerStability, Throughput, QueueDepth, QueueDepthByWorkflow, SuccessRate, AnalyticsSummary, } from "@cascade-flow/backend-interface";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,247 @@
+// src/index.ts
+import {
+  projectStepState,
+  extractLogsFromEvents,
+  extractAttemptMetadata
+} from "@cascade-flow/backend-interface";
+
+class WorkflowClient {
+  backend;
+  constructor(backend) {
+    this.backend = backend;
+  }
+  async submit(params) {
+    const submission = {
+      workflowSlug: params.workflow,
+      input: params.input,
+      runId: params.runId,
+      availableAt: params.availableAt,
+      priority: params.priority,
+      timeout: params.timeout,
+      idempotencyKey: params.idempotencyKey,
+      metadata: params.metadata,
+      tags: params.tags
+    };
+    return this.backend.submitRun(submission);
+  }
+  async getStatus(runId) {
+    return this.backend.getRun(runId);
+  }
+  async getRun(runId) {
+    const runState = await this.backend.getRun(runId);
+    if (!runState)
+      return null;
+    const info = { ...runState };
+    if (runState.status === "completed" || runState.status === "failed") {
+      try {
+        const events = await this.backend.loadEvents(runState.workflowSlug, runId, {
+          category: "workflow"
+        });
+        for (const event of events) {
+          if (event.category === "workflow") {
+            if (event.type === "WorkflowCompleted") {
+              info.output = JSON.parse(event.output);
+            } else if (event.type === "WorkflowFailed") {
+              info.error = event.error;
+            }
+          }
+        }
+      } catch (err) {}
+    }
+    return info;
+  }
+  async waitForCompletion(runId, options = {}) {
+    const {
+      interval = 1000,
+      maxAttempts = 60,
+      timeout,
+      exponentialBackoff = false,
+      maxBackoff = 1e4
+    } = options;
+    const startTime = Date.now();
+    const effectiveTimeout = timeout || maxAttempts * interval;
+    let currentInterval = interval;
+    let attempts = 0;
+    while (true) {
+      attempts++;
+      if (Date.now() - startTime > effectiveTimeout) {
+        throw new Error(`Timeout waiting for run ${runId} after ${effectiveTimeout}ms`);
+      }
+      const run = await this.getRun(runId);
+      if (!run) {
+        throw new Error(`Run ${runId} not found`);
+      }
+      if (run.status === "completed") {
+        return run.output;
+      } else if (run.status === "failed") {
+        const errorMsg = run.error?.message || "Run failed";
+        throw new Error(`Run ${runId} failed: ${errorMsg}`);
+      } else if (run.status === "cancelled") {
+        throw new Error(`Run ${runId} was cancelled`);
+      }
+      await this.sleep(currentInterval);
+      if (exponentialBackoff) {
+        currentInterval = Math.min(currentInterval * 2, maxBackoff);
+      }
+    }
+  }
+  async listRuns(options = {}) {
+    const { workflowSlug, status, tags, limit } = options;
+    let statuses;
+    if (status) {
+      statuses = Array.isArray(status) ? status : [status];
+    }
+    return this.backend.listRuns({
+      workflowSlug,
+      status: statuses,
+      tags,
+      limit
+    });
+  }
+  async cancel(runId, reason) {
+    await this.backend.cancelRun(runId, reason);
+  }
+  async retry(runId, reason) {
+    const runState = await this.backend.getRun(runId);
+    if (!runState) {
+      throw new Error(`Run ${runId} not found`);
+    }
+    if (runState.status !== "failed") {
+      throw new Error(`Cannot retry run ${runId} - status is ${runState.status}, expected 'failed'`);
+    }
+    const workflowSlug = runState.workflowSlug;
+    const failedSteps = await this.backend.getFailedSteps(workflowSlug, runId);
+    if (failedSteps.length === 0) {
+      throw new Error(`No failed steps found in run ${runId}`);
+    }
+    const previousAttemptNumber = runState.workflowAttemptNumber || 1;
+    const workflowAttemptNumber = previousAttemptNumber + 1;
+    const retriedStepIds = failedSteps.map((s) => s.stepId);
+    await this.backend.saveWorkflowRetryStarted(workflowSlug, runId, {
+      workflowAttemptNumber,
+      previousAttemptNumber,
+      retriedSteps: retriedStepIds,
+      reason
+    });
+    const now = Date.now() * 1000;
+    for (const step of failedSteps) {
+      await this.backend.saveStepScheduled(workflowSlug, runId, step.stepId, {
+        availableAt: now,
+        reason: "retry",
+        attemptNumber: 1,
+        retryDelayMs: 0
+      });
+    }
+    return {
+      runId,
+      workflowAttemptNumber,
+      retriedSteps: retriedStepIds
+    };
+  }
+  async listWorkflows() {
+    return this.backend.listWorkflowMetadata();
+  }
+  async getWorkflowMetadata(workflowSlug) {
+    return this.backend.getWorkflowMetadata(workflowSlug);
+  }
+  async getWorkflowSteps(workflowSlug) {
+    return this.backend.getWorkflowSteps(workflowSlug);
+  }
+  async getWorkflowSchema(workflowSlug) {
+    const metadata = await this.backend.getWorkflowMetadata(workflowSlug);
+    return metadata?.inputSchemaJSON ?? null;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async getErrorAnalysis(options) {
+    return this.backend.getErrorAnalysis(options);
+  }
+  async getRetryAnalysis(options) {
+    return this.backend.getRetryAnalysis(options);
+  }
+  async getSchedulingLatency(options) {
+    return this.backend.getSchedulingLatency(options);
+  }
+  async getStepDuration(options) {
+    return this.backend.getStepDuration(options);
+  }
+  async getWorkflowDuration(options) {
+    return this.backend.getWorkflowDuration(options);
+  }
+  async getWorkerStability(options) {
+    return this.backend.getWorkerStability(options);
+  }
+  async getThroughput(options) {
+    return this.backend.getThroughput(options);
+  }
+  async getQueueDepth(options) {
+    return this.backend.getQueueDepth(options);
+  }
+  async getQueueDepthByWorkflow() {
+    return this.backend.getQueueDepthByWorkflow();
+  }
+  async getSuccessRate(options) {
+    return this.backend.getSuccessRate(options);
+  }
+  async getAnalyticsSummary(options) {
+    return this.backend.getAnalyticsSummary(options);
+  }
+  async getErrorsList(options) {
+    return this.backend.getErrorsList(options);
+  }
+  async getErrorDetail(fingerprint, groupingStrategy, options) {
+    return this.backend.getErrorDetail(fingerprint, groupingStrategy, options);
+  }
+  async getStepStates(workflowSlug, runId) {
+    const events = await this.backend.loadEvents(workflowSlug, runId, {
+      category: "step"
+    });
+    const stepGroups = new Map;
+    for (const event of events) {
+      if (event.category === "step") {
+        if (!stepGroups.has(event.stepId)) {
+          stepGroups.set(event.stepId, []);
+        }
+        stepGroups.get(event.stepId).push(event);
+      }
+    }
+    const states = [];
+    for (const [stepId, stepEvents] of stepGroups) {
+      try {
+        const state = projectStepState(stepEvents, workflowSlug);
+        states.push(state);
+      } catch (err) {
+        console.error(`Failed to project state for step ${stepId}:`, err);
+      }
+    }
+    return states;
+  }
+  async getRunEvents(workflowSlug, runId) {
+    return this.backend.loadEvents(workflowSlug, runId);
+  }
+  async getStepDetail(workflowSlug, runId, stepName) {
+    const events = await this.backend.loadEvents(workflowSlug, runId, {
+      category: "step",
+      stepId: stepName
+    });
+    const stepEvents = events.filter((e) => e.category === "step");
+    if (stepEvents.length === 0) {
+      return null;
+    }
+    const state = projectStepState(stepEvents, workflowSlug);
+    const logs = extractLogsFromEvents(stepEvents);
+    const attempts = extractAttemptMetadata(stepEvents);
+    return {
+      state,
+      events: stepEvents,
+      logs,
+      attempts
+    };
+  }
+}
+export {
+  WorkflowClient
+};
+
+//# debugId=092C4E0F5E8FB25364756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": [
+    "import type {\n  Backend,\n  RunSubmission,\n  RunState,\n  WorkflowMetadata,\n  AnalyticsOptions,\n  ErrorAnalysis,\n  RetryAnalysis,\n  SchedulingLatency,\n  StepDuration,\n  WorkflowDuration,\n  WorkerStability,\n  Throughput,\n  QueueDepth,\n  QueueDepthByWorkflow,\n  SuccessRate,\n  AnalyticsSummary,\n  StepEvent,\n  StepState,\n  LogEntry,\n} from \"@cascade-flow/backend-interface\";\nimport {\n  projectStepState,\n  extractLogsFromEvents,\n  extractAttemptMetadata,\n  type AttemptMetadata,\n} from \"@cascade-flow/backend-interface\";\nimport type { PollOptions, ListRunsOptions, RunInfo } from \"./types.ts\";\n\n/**\n * WorkflowClient - submit and manage workflow runs via queue\n *\n * Features:\n * - Type-safe submission with generic input types\n * - Status checking and polling\n * - Wait for completion with timeout\n * - List and filter runs\n * - Cancellation support\n */\nexport class WorkflowClient {\n  constructor(private backend: Backend) {}\n\n  /**\n   * Submit a workflow run to the queue\n   *\n   * Generic type TInput provides type safety for workflow input\n   *\n   * @example\n   * ```typescript\n   * import type { WorkflowInput } from './workflows/my-workflow/input-schema';\n   *\n   * const { runId } = await client.submit<WorkflowInput>({\n   *   workflow: 'my-workflow',\n   *   input: { userId: \"123\", count: 42 }  // Fully typed!\n   * });\n   * ```\n   */\n  async submit<TInput = unknown>(params: {\n    workflow: string;\n    input?: TInput;\n    runId?: string;\n    availableAt?: number;\n    priority?: number;\n    timeout?: number;\n    idempotencyKey?: string;\n    metadata?: Record<string, unknown>;\n    tags?: string[];\n  }): Promise<{ runId: string; isNew: boolean }> {\n    const submission: RunSubmission = {\n      workflowSlug: params.workflow,\n      input: params.input,\n      runId: params.runId,\n      availableAt: params.availableAt,\n      priority: params.priority,\n      timeout: params.timeout,\n      idempotencyKey: params.idempotencyKey,\n      metadata: params.metadata,\n      tags: params.tags,\n    };\n\n    return this.backend.submitRun(submission);\n  }\n\n  /**\n   * Get the current status of a run\n   *\n   * @param runId - The run ID to query\n   * @returns Run state or null if not found\n   */\n  async getStatus(runId: string): Promise<RunState | null> {\n    return this.backend.getRun(runId);\n  }\n\n  /**\n   * Get detailed run information including output/error\n   *\n   * @param runId - The run ID to query\n   * @returns Extended run info or null if not found\n   */\n  async getRun(runId: string): Promise<RunInfo | null> {\n    const runState = await this.backend.getRun(runId);\n    if (!runState) return null;\n\n    const info: RunInfo = { ...runState };\n\n    // Load output or error if run is completed/failed\n    if (runState.status === \"completed\" || runState.status === \"failed\") {\n      try {\n        // Load workflow events to get output/error\n        const events = await this.backend.loadEvents(runState.workflowSlug, runId, {\n          category: \"workflow\",\n        });\n\n        // Find WorkflowCompleted or WorkflowFailed event\n        for (const event of events) {\n          if (event.category === \"workflow\") {\n            if (event.type === \"WorkflowCompleted\") {\n              info.output = JSON.parse(event.output);\n            } else if (event.type === \"WorkflowFailed\") {\n              info.error = event.error;\n            }\n          }\n        }\n      } catch (err) {\n        // Failed to load output/error, return state only\n      }\n    }\n\n    return info;\n  }\n\n  /**\n   * Wait for a run to complete\n   *\n   * Polls the backend until the run reaches a terminal state (completed/failed/cancelled)\n   *\n   * @param runId - The run ID to wait for\n   * @param options - Polling options\n   * @returns Run info when complete\n   * @throws Error if timeout or run fails\n   */\n  async waitForCompletion<TOutput = unknown>(\n    runId: string,\n    options: PollOptions = {}\n  ): Promise<TOutput> {\n    const {\n      interval = 1000,\n      maxAttempts = 60,\n      timeout,\n      exponentialBackoff = false,\n      maxBackoff = 10000,\n    } = options;\n\n    const startTime = Date.now();\n    const effectiveTimeout = timeout || maxAttempts * interval;\n\n    let currentInterval = interval;\n    let attempts = 0;\n\n    while (true) {\n      attempts++;\n\n      // Check timeout\n      if (Date.now() - startTime > effectiveTimeout) {\n        throw new Error(`Timeout waiting for run ${runId} after ${effectiveTimeout}ms`);\n      }\n\n      // Get run status\n      const run = await this.getRun(runId);\n\n      if (!run) {\n        throw new Error(`Run ${runId} not found`);\n      }\n\n      // Check if run reached terminal state\n      if (run.status === \"completed\") {\n        return run.output as TOutput;\n      } else if (run.status === \"failed\") {\n        const errorMsg = run.error?.message || \"Run failed\";\n        throw new Error(`Run ${runId} failed: ${errorMsg}`);\n      } else if (run.status === \"cancelled\") {\n        throw new Error(`Run ${runId} was cancelled`);\n      }\n\n      // Sleep before next poll\n      await this.sleep(currentInterval);\n\n      // Apply exponential backoff if enabled\n      if (exponentialBackoff) {\n        currentInterval = Math.min(currentInterval * 2, maxBackoff);\n      }\n    }\n  }\n\n  /**\n   * List runs matching filters\n   *\n   * @param options - Filter options\n   * @returns Array of run states\n   */\n  async listRuns(options: ListRunsOptions = {}): Promise<RunState[]> {\n    const { workflowSlug, status, tags, limit } = options;\n\n    // Convert status to array for backend (if provided)\n    let statuses: RunState[\"status\"][] | undefined;\n    if (status) {\n      statuses = Array.isArray(status) ? status : [status];\n    }\n\n    return this.backend.listRuns({\n      workflowSlug,\n      status: statuses,\n      tags,\n      limit,\n    });\n  }\n\n  /**\n   * Cancel a run\n   *\n   * Can cancel runs in pending, claimed, or running status\n   *\n   * @param runId - The run to cancel\n   * @param reason - Optional cancellation reason\n   */\n  async cancel(runId: string, reason?: string): Promise<void> {\n    await this.backend.cancelRun(runId, reason);\n  }\n\n  /**\n   * Retry a failed workflow\n   *\n   * Retries all failed steps in the workflow, keeping successful steps from the original run.\n   * Step attempt numbers are reset to 1 for each retried step.\n   *\n   * @param runId - The run ID to retry\n   * @param reason - Optional reason for retry\n   * @returns Retry information including new workflow attempt number\n   * @throws Error if run is not in failed status\n   */\n  async retry(\n    runId: string,\n    reason?: string\n  ): Promise<{\n    runId: string;\n    workflowAttemptNumber: number;\n    retriedSteps: string[];\n  }> {\n    // Get run state\n    const runState = await this.backend.getRun(runId);\n    if (!runState) {\n      throw new Error(`Run ${runId} not found`);\n    }\n\n    // Verify run is failed\n    if (runState.status !== \"failed\") {\n      throw new Error(`Cannot retry run ${runId} - status is ${runState.status}, expected 'failed'`);\n    }\n\n    const workflowSlug = runState.workflowSlug;\n\n    // Get failed steps\n    const failedSteps = await this.backend.getFailedSteps(workflowSlug, runId);\n    if (failedSteps.length === 0) {\n      throw new Error(`No failed steps found in run ${runId}`);\n    }\n\n    // Calculate new workflow attempt number\n    const previousAttemptNumber = runState.workflowAttemptNumber || 1;\n    const workflowAttemptNumber = previousAttemptNumber + 1;\n\n    const retriedStepIds = failedSteps.map((s) => s.stepId);\n\n    // Emit WorkflowRetryStarted event\n    await this.backend.saveWorkflowRetryStarted(workflowSlug, runId, {\n      workflowAttemptNumber,\n      previousAttemptNumber,\n      retriedSteps: retriedStepIds,\n      reason,\n    });\n\n    // Schedule each failed step for retry with fresh attempt number\n    const now = Date.now() * 1000; // Convert to microseconds\n    for (const step of failedSteps) {\n      await this.backend.saveStepScheduled(workflowSlug, runId, step.stepId, {\n        availableAt: now,\n        reason: \"retry\",\n        attemptNumber: 1, // Reset to 1 for workflow retry\n        retryDelayMs: 0,\n      });\n    }\n\n    return {\n      runId,\n      workflowAttemptNumber,\n      retriedSteps: retriedStepIds,\n    };\n  }\n\n  /**\n   * List all available workflows\n   *\n   * @returns Array of workflow metadata\n   */\n  async listWorkflows(): Promise<WorkflowMetadata[]> {\n    return this.backend.listWorkflowMetadata();\n  }\n\n  /**\n   * Get metadata for a specific workflow\n   *\n   * @param workflowSlug - Workflow identifier (directory name)\n   * @returns Workflow metadata or null if not found\n   */\n  async getWorkflowMetadata(workflowSlug: string): Promise<WorkflowMetadata | null> {\n    return this.backend.getWorkflowMetadata(workflowSlug);\n  }\n\n  /**\n   * Get step definitions for a specific workflow\n   *\n   * @param workflowSlug - Workflow identifier (directory name)\n   * @returns Array of step definitions or empty array if workflow not found\n   */\n  async getWorkflowSteps(workflowSlug: string): Promise<any[]> {\n    return this.backend.getWorkflowSteps(workflowSlug);\n  }\n\n  /**\n   * Get the JSON Schema for a workflow's input\n   *\n   * @param workflowSlug - Workflow identifier (directory name)\n   * @returns JSON Schema object or null if workflow has no input schema\n   */\n  async getWorkflowSchema(workflowSlug: string): Promise<any | null> {\n    const metadata = await this.backend.getWorkflowMetadata(workflowSlug);\n    return metadata?.inputSchemaJSON ?? null;\n  }\n\n  /**\n   * Helper to sleep\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n\n  // ============================================================================\n  // Analytics Methods\n  // ============================================================================\n\n  /**\n   * Get error analysis for workflows and steps\n   *\n   * Analyzes failure patterns, error types, and common error messages.\n   *\n   * @param options - Optional filters for time range, workflow, or step\n   * @returns Error analysis data\n   *\n   * @example\n   * ```typescript\n   * // Get errors for last 24 hours (default)\n   * const errors = await client.getErrorAnalysis();\n   *\n   * // Get errors for specific workflow\n   * const errors = await client.getErrorAnalysis({\n   *   workflowSlug: 'my-workflow',\n   *   startUs: Date.now() * 1000 - 7 * 24 * 60 * 60 * 1000 * 1000 // Last 7 days\n   * });\n   * ```\n   */\n  async getErrorAnalysis(options?: AnalyticsOptions): Promise<ErrorAnalysis> {\n    return this.backend.getErrorAnalysis(options);\n  }\n\n  /**\n   * Get retry analysis metrics\n   *\n   * Analyzes retry patterns, success rates after retries, and retry effectiveness.\n   *\n   * @param options - Optional filters for time range, workflow, or step\n   * @returns Retry analysis data\n   */\n  async getRetryAnalysis(options?: AnalyticsOptions): Promise<RetryAnalysis> {\n    return this.backend.getRetryAnalysis(options);\n  }\n\n  /**\n   * Get scheduling latency metrics\n   *\n   * Measures time between step being scheduled and actually starting execution.\n   * High latency indicates worker starvation or queue congestion.\n   *\n   * @param options - Optional filters for time range, workflow, or step\n   * @returns Scheduling latency statistics\n   *\n   * @example\n   * ```typescript\n   * const latency = await client.getSchedulingLatency({ workflowSlug: 'my-workflow' });\n   * console.log(`Average wait time: ${latency.averageUs / 1000}ms`);\n   * console.log(`P95 wait time: ${latency.p95Us / 1000}ms`);\n   * ```\n   */\n  async getSchedulingLatency(options?: AnalyticsOptions): Promise<SchedulingLatency> {\n    return this.backend.getSchedulingLatency(options);\n  }\n\n  /**\n   * Get step duration metrics\n   *\n   * Analyzes how long steps take to execute.\n   *\n   * @param options - Optional filters for time range, workflow, or step\n   * @returns Step duration statistics\n   */\n  async getStepDuration(options?: AnalyticsOptions): Promise<StepDuration> {\n    return this.backend.getStepDuration(options);\n  }\n\n  /**\n   * Get workflow duration metrics\n   *\n   * Analyzes end-to-end workflow execution time (from submission to completion).\n   *\n   * @param options - Optional filters for time range or workflow\n   * @returns Workflow duration statistics\n   */\n  async getWorkflowDuration(options?: AnalyticsOptions): Promise<WorkflowDuration> {\n    return this.backend.getWorkflowDuration(options);\n  }\n\n  /**\n   * Get worker stability metrics\n   *\n   * Analyzes worker crashes, reclamations, and stale heartbeats.\n   *\n   * @param options - Optional filters for time range\n   * @returns Worker stability data\n   */\n  async getWorkerStability(options?: AnalyticsOptions): Promise<WorkerStability> {\n    return this.backend.getWorkerStability(options);\n  }\n\n  /**\n   * Get throughput metrics\n   *\n   * Analyzes how many runs/steps are being completed per unit time.\n   *\n   * @param options - Optional filters for time range or workflow\n   * @returns Throughput data\n   */\n  async getThroughput(options?: AnalyticsOptions): Promise<Throughput> {\n    return this.backend.getThroughput(options);\n  }\n\n  /**\n   * Get current queue depth\n   *\n   * Real-time snapshot of pending/running runs and steps.\n   *\n   * @param options - Optional filter for workflow\n   * @returns Queue depth data\n   *\n   * @example\n   * ```typescript\n   * const depth = await client.getQueueDepth();\n   * console.log(`Pending runs: ${depth.pendingRuns}`);\n   * console.log(`Scheduled steps: ${depth.scheduledSteps}`);\n   * ```\n   */\n  async getQueueDepth(options?: Pick<AnalyticsOptions, \"workflowSlug\">): Promise<QueueDepth> {\n    return this.backend.getQueueDepth(options);\n  }\n\n  /**\n   * Get queue depth broken down by workflow\n   *\n   * Real-time snapshot showing per-workflow queue statistics.\n   * Useful for identifying which workflows have pending work.\n   *\n   * @returns Array of per-workflow queue depth data\n   *\n   * @example\n   * ```typescript\n   * const breakdown = await client.getQueueDepthByWorkflow();\n   * for (const workflow of breakdown) {\n   *   console.log(`${workflow.workflowName}: ${workflow.pendingRuns} pending, ${workflow.scheduledSteps} scheduled`);\n   * }\n   * ```\n   */\n  async getQueueDepthByWorkflow(): Promise<QueueDepthByWorkflow> {\n    return this.backend.getQueueDepthByWorkflow();\n  }\n\n  /**\n   * Get success/failure rate metrics\n   *\n   * Analyzes overall health of workflows and steps.\n   *\n   * @param options - Optional filters for time range, workflow, or step\n   * @returns Success rate data\n   */\n  async getSuccessRate(options?: AnalyticsOptions): Promise<SuccessRate> {\n    return this.backend.getSuccessRate(options);\n  }\n\n  /**\n   * Get comprehensive analytics summary\n   *\n   * Combines all analytics metrics into a single response.\n   * Useful for dashboard views.\n   *\n   * @param options - Optional filters for time range or workflow\n   * @returns Complete analytics summary\n   *\n   * @example\n   * ```typescript\n   * // Get full analytics for last 24 hours\n   * const summary = await client.getAnalyticsSummary();\n   *\n   * // Get analytics for specific workflow over last week\n   * const summary = await client.getAnalyticsSummary({\n   *   workflowSlug: 'my-workflow',\n   *   startUs: Date.now() * 1000 - 7 * 24 * 60 * 60 * 1000 * 1000\n   * });\n   * ```\n   */\n  async getAnalyticsSummary(options?: AnalyticsOptions): Promise<AnalyticsSummary> {\n    return this.backend.getAnalyticsSummary(options);\n  }\n\n  /**\n   * Get paginated list of errors grouped by fingerprint\n   *\n   * @param options - Filtering and pagination options\n   * @returns Paginated list of error groups\n   *\n   * @example\n   * ```typescript\n   * // Get errors for last 24h\n   * const { errors, total } = await client.getErrorsList({\n   *   timeRange: { start: Date.now() * 1000 - 86400000000, end: Date.now() * 1000 },\n   *   groupingStrategy: 'exact',\n   *   limit: 50,\n   *   offset: 0\n   * });\n   * ```\n   */\n  async getErrorsList(options?: {\n    timeRange?: { start: number; end: number };\n    workflowSlug?: string;\n    groupingStrategy?: 'exact' | 'normalized' | 'portable';\n    limit?: number;\n    offset?: number;\n  }): Promise<{\n    errors: Array<{\n      fingerprint: string;\n      errorMessage: string;\n      errorName: string;\n      sampleStack: string;\n      count: number;\n      affectedRuns: number;\n      firstSeen: number;\n      lastSeen: number;\n    }>;\n    total: number;\n  }> {\n    return this.backend.getErrorsList(options);\n  }\n\n  /**\n   * Get detailed information about a specific error by fingerprint\n   *\n   * @param fingerprint - Composite fingerprint (nameHash:messageHash:stackHash)\n   * @param groupingStrategy - Which stack hash variant to use\n   * @param options - Filtering and pagination options\n   * @returns Error details with all occurrences\n   *\n   * @example\n   * ```typescript\n   * const detail = await client.getErrorDetail(\n   *   'abc123:def456:ghi789',\n   *   'exact',\n   *   { limit: 100, offset: 0 }\n   * );\n   * ```\n   */\n  async getErrorDetail(\n    fingerprint: string,\n    groupingStrategy: 'exact' | 'normalized' | 'portable',\n    options?: {\n      timeRange?: { start: number; end: number };\n      limit?: number;\n      offset?: number;\n    }\n  ): Promise<{\n    fingerprint: string;\n    errorMessage: string;\n    errorName: string;\n    sampleStack: string;\n    totalCount: number;\n    affectedRuns: number;\n    firstSeen: number;\n    lastSeen: number;\n    occurrences: Array<{\n      workflowSlug: string;\n      runId: string;\n      stepId: string;\n      attemptNumber: number;\n      timestampUs: number;\n    }>;\n    total: number;\n  }> {\n    return this.backend.getErrorDetail(fingerprint, groupingStrategy, options);\n  }\n\n  /**\n   * Get the state of all steps for a run\n   * Projects step events to compute current state\n   */\n  async getStepStates(workflowSlug: string, runId: string): Promise<StepState[]> {\n    const events = await this.backend.loadEvents(workflowSlug, runId, {\n      category: 'step',\n    });\n\n    // Group events by step ID\n    const stepGroups = new Map<string, StepEvent[]>();\n    for (const event of events) {\n      if (event.category === 'step') {\n        if (!stepGroups.has(event.stepId)) {\n          stepGroups.set(event.stepId, []);\n        }\n        stepGroups.get(event.stepId)!.push(event as StepEvent);\n      }\n    }\n\n    // Project each step's state\n    const states: StepState[] = [];\n    for (const [stepId, stepEvents] of stepGroups) {\n      try {\n        const state = projectStepState(stepEvents, workflowSlug);\n        states.push(state);\n      } catch (err) {\n        console.error(`Failed to project state for step ${stepId}:`, err);\n      }\n    }\n\n    return states;\n  }\n\n  /**\n   * Get all events for a specific run (both workflow and step events)\n   */\n  async getRunEvents(workflowSlug: string, runId: string) {\n    return this.backend.loadEvents(workflowSlug, runId);\n  }\n\n  /**\n   * Get detailed information for a specific step\n   * Includes state, events, and logs\n   */\n  async getStepDetail(\n    workflowSlug: string,\n    runId: string,\n    stepName: string\n  ): Promise<{\n    state: StepState;\n    events: StepEvent[];\n    logs: LogEntry[];\n    attempts: AttemptMetadata[];\n  } | null> {\n    // Load all events for this specific step\n    const events = await this.backend.loadEvents(workflowSlug, runId, {\n      category: 'step',\n      stepId: stepName,\n    });\n\n    // Filter to only step events\n    const stepEvents = events.filter((e): e is StepEvent => e.category === 'step');\n\n    if (stepEvents.length === 0) {\n      return null;\n    }\n\n    // Project events to current state\n    const state = projectStepState(stepEvents, workflowSlug);\n\n    // Extract logs from events\n    const logs = extractLogsFromEvents(stepEvents);\n\n    // Extract attempt metadata\n    const attempts = extractAttemptMetadata(stepEvents);\n\n    return {\n      state,\n      events: stepEvents,\n      logs,\n      attempts,\n    };\n  }\n}\n\n// Export types\nexport type { PollOptions, ListRunsOptions, RunInfo } from \"./types.ts\";\nexport type {\n  AnalyticsOptions,\n  ErrorAnalysis,\n  RetryAnalysis,\n  SchedulingLatency,\n  StepDuration,\n  WorkflowDuration,\n  WorkerStability,\n  Throughput,\n  QueueDepth,\n  QueueDepthByWorkflow,\n  SuccessRate,\n  AnalyticsSummary,\n} from \"@cascade-flow/backend-interface\";\n"
+  ],
+  "mappings": "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",
+  "debugId": "092C4E0F5E8FB25364756E2164756E21",
+  "names": []
+}

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+import type { RunState } from "@cascade-flow/backend-interface";
+/**
+ * Options for polling and waiting
+ */
+export type PollOptions = {
+    /** Interval between polls (ms, default: 1000) */
+    interval?: number;
+    /** Maximum number of poll attempts (default: 60) */
+    maxAttempts?: number;
+    /** Timeout in milliseconds (overrides maxAttempts if provided) */
+    timeout?: number;
+    /** Use exponential backoff (default: false) */
+    exponentialBackoff?: boolean;
+    /** Maximum backoff interval (ms, default: 10000) */
+    maxBackoff?: number;
+};
+/**
+ * Options for listing runs
+ */
+export type ListRunsOptions = {
+    /** Filter by workflow slug */
+    workflowSlug?: string;
+    /** Filter by status (single status or array of statuses) */
+    status?: RunState["status"] | RunState["status"][];
+    /** Filter by tags (runs must have all tags) */
+    tags?: string[];
+    /** Limit results */
+    limit?: number;
+};
+/**
+ * Extended run information with output
+ */
+export type RunInfo = RunState & {
+    output?: any;
+    error?: {
+        message: string;
+        stack?: string;
+        name?: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,iCAAiC,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,+CAA+C;IAC/C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,8BAA8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;IAEnD,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB,oBAAoB;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG;IAC/B,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D,CAAC"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@cascade-flow/client",
+  "version": "0.1.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build src/index.ts --outdir dist --target node --sourcemap=external --external=@cascade-flow/* && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@cascade-flow/backend-interface": "0.1.0",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "peerDependenciesMeta": {
+    "@cascadeflow/backend-filesystem": {
+      "optional": true
+    },
+    "@cascadeflow/backend-postgres": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cascadeflow/cascadeflow.git",
+    "directory": "packages/client"
+  },
+  "license": "MIT",
+  "description": "Type-safe programmatic client for CascadeFlow workflow orchestrator",
+  "keywords": [
+    "workflow",
+    "orchestrator",
+    "client",
+    "api",
+    "typescript"
+  ]
+}