@gravito/flux 1.0.0-alpha.1

package/README.md

@@ -0,0 +1,295 @@
+# @gravito/flux
+
+> ⚡ Platform-agnostic, high-performance workflow engine for Gravito
+
+## Features
+
+- **Pure State Machine** - No runtime dependencies, Web Standard APIs only
+- **Fluent Builder API** - Type-safe, chainable workflow definitions
+- **Storage Adapters** - Memory, SQLite (Bun), PostgreSQL (coming soon)
+- **Retry & Timeout** - Automatic retry with exponential backoff
+- **Event Hooks** - Subscribe to workflow/step lifecycle events
+- **Dual Platform** - Works with both Bun and Node.js
+
+## Installation
+
+```bash
+# Bun
+bun add @gravito/flux
+
+# npm
+npm install @gravito/flux
+```
+
+## Quick Start
+
+```typescript
+import { FluxEngine, createWorkflow } from '@gravito/flux'
+
+// 1. Define workflow
+const orderFlow = createWorkflow('order-process')
+  .input<{ orderId: string }>()
+  .step('fetch', async (ctx) => {
+    ctx.data.order = await db.orders.find(ctx.input.orderId)
+  })
+  .step('validate', async (ctx) => {
+    if (!ctx.data.order.isPaid) throw new Error('Unpaid order')
+  })
+  .commit('fulfill', async (ctx) => {
+    await fulfillment.ship(ctx.data.order)
+  })
+
+// 2. Execute
+const engine = new FluxEngine()
+const result = await engine.execute(orderFlow, { orderId: '123' })
+
+if (result.status === 'completed') {
+  console.log('Order processed:', result.data)
+}
+```
+
+## Examples
+
+### 📦 Order Fulfillment
+
+```typescript
+const orderWorkflow = createWorkflow('order-fulfillment')
+  .input<{ orderId: string; items: Item[] }>()
+  .step('validate', async (ctx) => {
+    for (const item of ctx.input.items) {
+      const stock = await db.products.getStock(item.productId)
+      if (stock < item.qty) throw new Error(`Out of stock: ${item.productId}`)
+    }
+  })
+  .step('reserve', async (ctx) => {
+    ctx.data.reservationIds = await inventory.reserve(ctx.input.items)
+  })
+  .step('payment', async (ctx) => {
+    ctx.data.payment = await payment.charge(ctx.input.orderId)
+  }, { retries: 3, timeout: 30000 })
+  .commit('deduct', async (ctx) => {
+    await inventory.deduct(ctx.data.reservationIds)
+  })
+  .commit('notify', async (ctx) => {
+    await email.send(ctx.input.userId, 'order-confirmed', ctx.data)
+  })
+```
+
+### 🖼️ Image Processing
+
+```typescript
+const uploadWorkflow = createWorkflow('image-processing')
+  .input<{ fileBuffer: Buffer; fileName: string; userId: string }>()
+  .step('validate', async (ctx) => {
+    if (ctx.input.fileBuffer.length > 10 * 1024 * 1024) {
+      throw new Error('File size exceeds 10MB')
+    }
+    ctx.data.mimeType = await detectMimeType(ctx.input.fileBuffer)
+  })
+  .step('scan', async (ctx) => {
+    const result = await virusScanner.scan(ctx.input.fileBuffer)
+    if (!result.clean) throw new Error('Malicious file detected')
+  })
+  .step('resize', async (ctx) => {
+    ctx.data.thumbnail = await sharp(ctx.input.fileBuffer).resize(200).toBuffer()
+  })
+  .commit('upload', async (ctx) => {
+    ctx.data.url = await s3.upload(ctx.input.fileName, ctx.data.compressed)
+  })
+```
+
+### 👤 User Signup
+
+```typescript
+const signupWorkflow = createWorkflow('user-signup')
+  .input<{ email: string; password: string; name: string }>()
+  .step('validate', async (ctx) => {
+    const exists = await db.users.findByEmail(ctx.input.email)
+    if (exists) throw new Error('Email already in use')
+  })
+  .step('hash', async (ctx) => {
+    ctx.data.hashedPassword = await bcrypt.hash(ctx.input.password, 12)
+  })
+  .commit('create', async (ctx) => {
+    ctx.data.user = await db.users.create({
+      email: ctx.input.email,
+      password: ctx.data.hashedPassword,
+      name: ctx.input.name,
+    })
+  })
+  .commit('sendVerification', async (ctx) => {
+    const token = await generateToken(ctx.data.user.id)
+    await email.send(ctx.input.email, 'verify-email', { token })
+  })
+```
+
+### 📈 Report Generation
+
+```typescript
+const reportWorkflow = createWorkflow('generate-report')
+  .input<{ reportType: string; dateRange: DateRange; requestedBy: string }>()
+  .step('fetch-data', async (ctx) => {
+    ctx.data.sales = await db.orders.aggregate(ctx.input.dateRange)
+    ctx.data.users = await db.users.getMetrics(ctx.input.dateRange)
+  }, { timeout: 60000 })
+  .step('calculate', async (ctx) => {
+    ctx.data.metrics = {
+      revenue: ctx.data.sales.reduce((sum, s) => sum + s.total, 0),
+      orders: ctx.data.sales.length,
+    }
+  })
+  .step('generate-pdf', async (ctx) => {
+    ctx.data.pdf = await pdfGenerator.create(ctx.data.metrics)
+  })
+  .commit('upload', async (ctx) => {
+    ctx.data.url = await s3.upload(`reports/${ctx.id}.pdf`, ctx.data.pdf)
+  })
+  .commit('notify', async (ctx) => {
+    await email.send(ctx.input.requestedBy, 'report-ready', { url: ctx.data.url })
+  })
+```
+
+## API
+
+### `createWorkflow(name)`
+
+Create a workflow builder.
+
+```typescript
+const flow = createWorkflow('my-workflow')
+  .input<{ value: number }>()   // Define input type
+  .step('step1', handler)        // Add step
+  .step('step2', handler, opts)  // With options
+  .commit('save', handler)       // Commit step (always runs)
+```
+
+### `FluxEngine`
+
+Execute workflows.
+
+```typescript
+const engine = new FluxEngine({
+  storage: new MemoryStorage(),   // Default
+  defaultRetries: 3,              // Default retry count
+  defaultTimeout: 30000,          // Default 30s timeout
+  logger: new FluxConsoleLogger(),
+  on: {
+    stepStart: (step, ctx) => {},
+    stepComplete: (step, ctx, result) => {},
+    stepError: (step, ctx, error) => {},
+    workflowComplete: (ctx) => {},
+    workflowError: (ctx, error) => {},
+  }
+})
+
+const result = await engine.execute(workflow, input)
+```
+
+### Step Options
+
+```typescript
+.step('name', handler, {
+  retries: 5,                    // Override retry count
+  timeout: 60000,                // Override timeout (ms)
+  when: (ctx) => ctx.data.x > 0, // Conditional execution
+})
+```
+
+### Commit Steps
+
+Commit steps are marked to always execute, even on workflow replay:
+
+```typescript
+.commit('save-to-db', async (ctx) => {
+  await db.insert(ctx.data)  // Side effect
+})
+```
+
+## Storage Adapters
+
+### MemoryStorage (Default)
+
+In-memory, for development:
+
+```typescript
+import { MemoryStorage } from '@gravito/flux'
+const engine = new FluxEngine({ storage: new MemoryStorage() })
+```
+
+### BunSQLiteStorage (Bun only)
+
+High-performance SQLite:
+
+```typescript
+import { FluxEngine } from '@gravito/flux'
+import { BunSQLiteStorage } from '@gravito/flux/bun'
+
+const engine = new FluxEngine({
+  storage: new BunSQLiteStorage({ path: './data/workflows.db' })
+})
+```
+
+### Custom Storage
+
+Implement `WorkflowStorage` interface:
+
+```typescript
+interface WorkflowStorage {
+  save(state: WorkflowState): Promise<void>
+  load(id: string): Promise<WorkflowState | null>
+  list(filter?: WorkflowFilter): Promise<WorkflowState[]>
+  delete(id: string): Promise<void>
+  init?(): Promise<void>
+  close?(): Promise<void>
+}
+```
+
+## Gravito Integration
+
+```typescript
+import { OrbitFlux } from '@gravito/flux'
+
+const core = await PlanetCore.boot({
+  orbits: [
+    new OrbitFlux({
+      storage: 'sqlite',
+      dbPath: './data/workflows.db',
+    })
+  ]
+})
+
+// Access via services
+const flux = core.services.get<FluxEngine>('flux')
+await flux.execute(myWorkflow, input)
+```
+
+## Platform Support
+
+| Feature | Bun | Node.js |
+|---------|-----|---------|
+| FluxEngine | ✅ | ✅ |
+| MemoryStorage | ✅ | ✅ |
+| BunSQLiteStorage | ✅ | ❌ |
+| OrbitFlux | ✅ | ✅ |
+
+## Run Examples
+
+```bash
+cd packages/flux
+
+# Order fulfillment
+bun run examples/order-fulfillment.ts
+
+# Image processing
+bun run examples/image-processing.ts
+
+# User signup
+bun run examples/user-signup.ts
+
+# Report generation
+bun run examples/report-generation.ts
+```
+
+## License
+
+MIT

package/dist/builder/WorkflowBuilder.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Workflow Builder - Fluent API for defining workflows
+ *
+ * Type-safe, chainable workflow definition.
+ *
+ * @module @gravito/flux/builder
+ */
+import type { WorkflowContext, WorkflowDefinition } from '../types';
+/**
+ * Step options
+ */
+interface StepOptions {
+    retries?: number;
+    timeout?: number;
+    when?: (ctx: WorkflowContext) => boolean;
+}
+/**
+ * Workflow Builder
+ *
+ * Provides fluent API for defining workflows with type inference.
+ *
+ * @example
+ * ```typescript
+ * const workflow = createWorkflow('order-process')
+ *   .input<{ orderId: string }>()
+ *   .step('validate', async (ctx) => {
+ *     ctx.data.order = await fetchOrder(ctx.input.orderId)
+ *   })
+ *   .step('process', async (ctx) => {
+ *     await processOrder(ctx.data.order)
+ *   })
+ *   .commit('notify', async (ctx) => {
+ *     await sendEmail(ctx.data.order.email)
+ *   })
+ * ```
+ */
+export declare class WorkflowBuilder<TInput = unknown> {
+    private _name;
+    private _steps;
+    private _validateInput?;
+    constructor(name: string);
+    /**
+     * Define input type
+     *
+     * This method is used for TypeScript type inference.
+     */
+    input<T>(): WorkflowBuilder<T>;
+    /**
+     * Add input validator
+     */
+    validate(validator: (input: unknown) => input is TInput): this;
+    /**
+     * Add a step to the workflow
+     */
+    step(name: string, handler: (ctx: WorkflowContext<TInput>) => Promise<void> | void, options?: StepOptions): this;
+    /**
+     * Add a commit step (always executes, even on replay)
+     *
+     * Commit steps are for side effects that should not be skipped,
+     * such as database writes or external API calls.
+     */
+    commit(name: string, handler: (ctx: WorkflowContext<TInput>) => Promise<void> | void, options?: StepOptions): this;
+    /**
+     * Build the workflow definition
+     */
+    build(): WorkflowDefinition<TInput>;
+    /**
+     * Get workflow name
+     */
+    get name(): string;
+    /**
+     * Get step count
+     */
+    get stepCount(): number;
+}
+/**
+ * Create a new workflow builder
+ *
+ * @param name - Unique workflow name
+ * @returns WorkflowBuilder instance
+ *
+ * @example
+ * ```typescript
+ * const uploadFlow = createWorkflow('image-upload')
+ *   .input<{ file: Buffer }>()
+ *   .step('resize', async (ctx) => {
+ *     ctx.data.resized = await sharp(ctx.input.file).resize(200).toBuffer()
+ *   })
+ *   .commit('save', async (ctx) => {
+ *     await storage.put(ctx.data.resized)
+ *   })
+ * ```
+ */
+export declare function createWorkflow(name: string): WorkflowBuilder;
+export {};
+//# sourceMappingURL=WorkflowBuilder.d.ts.map

package/dist/builder/WorkflowBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkflowBuilder.d.ts","sourceRoot":"","sources":["../../src/builder/WorkflowBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAkB,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAEnF;;GAEG;AACH,UAAU,WAAW;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAA;CACzC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAe,CAAC,MAAM,GAAG,OAAO;IAC3C,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,cAAc,CAAC,CAAqC;gBAEhD,IAAI,EAAE,MAAM;IAIxB;;;;OAIG;IACH,KAAK,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC;IAI9B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,MAAM,GAAG,IAAI;IAK9D;;OAEG;IACH,IAAI,CACF,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAC/D,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI;IAYP;;;;;OAKG;IACH,MAAM,CACJ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAC/D,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI;IAYP;;OAEG;IACH,KAAK,IAAI,kBAAkB,CAAC,MAAM,CAAC;IAYnC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAE5D"}

package/dist/builder/index.d.ts

@@ -0,0 +1,2 @@
+export { createWorkflow, WorkflowBuilder } from './WorkflowBuilder';
+//# sourceMappingURL=index.d.ts.map

package/dist/builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/builder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/bun.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Bun-specific exports
+ *
+ * This entry exports Bun-optimized components.
+ *
+ * @module @gravito/flux/bun
+ */
+export { BunSQLiteStorage, type BunSQLiteStorageOptions } from './storage/BunSQLiteStorage';
+//# sourceMappingURL=bun.d.ts.map

package/dist/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../src/bun.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/bun.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  BunSQLiteStorage
+} from "./chunk-qjdtqchy.js";
+export {
+  BunSQLiteStorage
+};

package/dist/chunk-qjdtqchy.js

@@ -0,0 +1,145 @@
+// @bun
+// src/storage/BunSQLiteStorage.ts
+import { Database } from "bun:sqlite";
+
+class BunSQLiteStorage {
+  db;
+  tableName;
+  initialized = false;
+  constructor(options = {}) {
+    this.db = new Database(options.path ?? ":memory:");
+    this.tableName = options.tableName ?? "flux_workflows";
+  }
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        status TEXT NOT NULL,
+        input TEXT NOT NULL,
+        data TEXT NOT NULL,
+        current_step INTEGER NOT NULL,
+        history TEXT NOT NULL,
+        error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        completed_at TEXT
+      )
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_name 
+      ON ${this.tableName}(name)
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_status 
+      ON ${this.tableName}(status)
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_created 
+      ON ${this.tableName}(created_at DESC)
+    `);
+    this.initialized = true;
+  }
+  async save(state) {
+    await this.init();
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO ${this.tableName} 
+      (id, name, status, input, data, current_step, history, error, created_at, updated_at, completed_at)
+      VALUES ($id, $name, $status, $input, $data, $currentStep, $history, $error, $createdAt, $updatedAt, $completedAt)
+    `);
+    stmt.run({
+      $id: state.id,
+      $name: state.name,
+      $status: state.status,
+      $input: JSON.stringify(state.input),
+      $data: JSON.stringify(state.data),
+      $currentStep: state.currentStep,
+      $history: JSON.stringify(state.history),
+      $error: state.error ?? null,
+      $createdAt: state.createdAt.toISOString(),
+      $updatedAt: state.updatedAt.toISOString(),
+      $completedAt: state.completedAt?.toISOString() ?? null
+    });
+  }
+  async load(id) {
+    await this.init();
+    const stmt = this.db.prepare(`
+      SELECT * FROM ${this.tableName} WHERE id = $id
+    `);
+    const row = stmt.get({ $id: id });
+    if (!row) {
+      return null;
+    }
+    return this.rowToState(row);
+  }
+  async list(filter) {
+    await this.init();
+    let query = `SELECT * FROM ${this.tableName} WHERE 1=1`;
+    const params = {};
+    if (filter?.name) {
+      query += " AND name = $name";
+      params.$name = filter.name;
+    }
+    if (filter?.status) {
+      if (Array.isArray(filter.status)) {
+        const placeholders = filter.status.map((_, i) => `$status${i}`).join(", ");
+        query += ` AND status IN (${placeholders})`;
+        filter.status.forEach((s, i) => {
+          params[`$status${i}`] = s;
+        });
+      } else {
+        query += " AND status = $status";
+        params.$status = filter.status;
+      }
+    }
+    query += " ORDER BY created_at DESC";
+    if (filter?.limit) {
+      query += " LIMIT $limit";
+      params.$limit = filter.limit;
+    }
+    if (filter?.offset) {
+      query += " OFFSET $offset";
+      params.$offset = filter.offset;
+    }
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(params);
+    return rows.map((row) => this.rowToState(row));
+  }
+  async delete(id) {
+    await this.init();
+    const stmt = this.db.prepare(`
+      DELETE FROM ${this.tableName} WHERE id = $id
+    `);
+    stmt.run({ $id: id });
+  }
+  async close() {
+    this.db.close();
+    this.initialized = false;
+  }
+  rowToState(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      status: row.status,
+      input: JSON.parse(row.input),
+      data: JSON.parse(row.data),
+      currentStep: row.current_step,
+      history: JSON.parse(row.history),
+      error: row.error ?? undefined,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+      completedAt: row.completed_at ? new Date(row.completed_at) : undefined
+    };
+  }
+  getDatabase() {
+    return this.db;
+  }
+  vacuum() {
+    this.db.run("VACUUM");
+  }
+}
+
+export { BunSQLiteStorage };

package/dist/core/ContextManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Context Manager for workflow execution
+ *
+ * Manages workflow context lifecycle and state snapshots.
+ *
+ * @module @gravito/flux/core
+ */
+import type { WorkflowContext, WorkflowState, WorkflowStatus } from '../types';
+/**
+ * Context Manager
+ *
+ * Creates and manages workflow execution contexts.
+ */
+export declare class ContextManager {
+    /**
+     * Create a new workflow context
+     */
+    create<TInput>(name: string, input: TInput, stepCount: number): WorkflowContext<TInput>;
+    /**
+     * Restore context from saved state
+     */
+    restore<TInput>(state: WorkflowState): WorkflowContext<TInput>;
+    /**
+     * Convert context to serializable state
+     */
+    toState(ctx: WorkflowContext): WorkflowState;
+    /**
+     * Update context status (returns new context for immutability)
+     */
+    updateStatus(ctx: WorkflowContext, status: WorkflowStatus): WorkflowContext;
+    /**
+     * Advance to next step
+     */
+    advanceStep(ctx: WorkflowContext): WorkflowContext;
+    /**
+     * Update step name in history
+     */
+    setStepName(ctx: WorkflowContext, index: number, name: string): void;
+}
+//# sourceMappingURL=ContextManager.d.ts.map

package/dist/core/ContextManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/core/ContextManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAiB,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAS7F;;;;GAIG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC;IAkBvF;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,eAAe,CAAC,MAAM,CAAC;IAY9D;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa;IAc5C;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,cAAc,GAAG,eAAe;IAO3E;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,eAAe,GAAG,eAAe;IAOlD;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAKrE"}

package/dist/core/StateMachine.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview State Machine for workflow status transitions
+ *
+ * Pure state machine with no runtime dependencies.
+ *
+ * @module @gravito/flux/core
+ */
+import type { WorkflowStatus } from '../types';
+/**
+ * State Machine for workflow status management
+ *
+ * Provides validated state transitions using EventTarget for events.
+ */
+export declare class StateMachine extends EventTarget {
+    private _status;
+    /**
+     * Current status
+     */
+    get status(): WorkflowStatus;
+    /**
+     * Check if transition to target status is allowed
+     */
+    canTransition(to: WorkflowStatus): boolean;
+    /**
+     * Transition to a new status
+     *
+     * @throws {Error} If transition is not allowed
+     */
+    transition(to: WorkflowStatus): void;
+    /**
+     * Force set status (for replay/restore)
+     */
+    forceStatus(status: WorkflowStatus): void;
+    /**
+     * Check if workflow is in terminal state
+     */
+    isTerminal(): boolean;
+    /**
+     * Check if workflow can be executed
+     */
+    canExecute(): boolean;
+}
+//# sourceMappingURL=StateMachine.d.ts.map

package/dist/core/StateMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachine.d.ts","sourceRoot":"","sources":["../../src/core/StateMachine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAa9C;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,OAAO,CAAC,OAAO,CAA4B;IAE3C;;OAEG;IACH,IAAI,MAAM,IAAI,cAAc,CAE3B;IAED;;OAEG;IACH,aAAa,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO;IAI1C;;;;OAIG;IACH,UAAU,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI;IAgBpC;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIzC;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,UAAU,IAAI,OAAO;CAGtB"}

package/dist/core/StepExecutor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Step Executor for workflow steps
+ *
+ * Handles step execution with retry and timeout support.
+ *
+ * @module @gravito/flux/core
+ */
+import type { StepDefinition, StepExecution, StepResult, WorkflowContext } from '../types';
+/**
+ * Step Executor
+ *
+ * Executes individual workflow steps with retry and timeout support.
+ */
+export declare class StepExecutor {
+    private defaultRetries;
+    private defaultTimeout;
+    constructor(options?: {
+        defaultRetries?: number;
+        defaultTimeout?: number;
+    });
+    /**
+     * Execute a step with retry and timeout
+     */
+    execute(step: StepDefinition, ctx: WorkflowContext, execution: StepExecution): Promise<StepResult>;
+    /**
+     * Execute handler with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+}
+//# sourceMappingURL=StepExecutor.d.ts.map