@gravito/flux 1.0.0-alpha.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"StepExecutor.d.ts","sourceRoot":"","sources":["../../src/core/StepExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1F;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,cAAc,CAAQ;gBAElB,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAO;IAK9E;;OAEG;IACG,OAAO,CACX,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,UAAU,CAAC;IA0DtB;;OAEG;YACW,kBAAkB;IAYhC;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export { ContextManager } from './ContextManager';
+export { StateMachine } from './StateMachine';
+export { StepExecutor } from './StepExecutor';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/engine/FluxEngine.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Flux Engine - Main workflow execution engine
+ *
+ * Orchestrates workflow execution with storage and event handling.
+ *
+ * @module @gravito/flux
+ */
+import { WorkflowBuilder } from '../builder/WorkflowBuilder';
+import type { FluxConfig, FluxResult, WorkflowDefinition, WorkflowStorage } from '../types';
+/**
+ * Flux Engine
+ *
+ * Main workflow execution engine.
+ *
+ * @example
+ * ```typescript
+ * const engine = new FluxEngine({ storage: new MemoryStorage() })
+ *
+ * const workflow = createWorkflow('process-order')
+ *   .input<{ orderId: string }>()
+ *   .step('fetch', async (ctx) => { ... })
+ *   .step('validate', async (ctx) => { ... })
+ *   .commit('save', async (ctx) => { ... })
+ *
+ * const result = await engine.execute(workflow, { orderId: '123' })
+ * ```
+ */
+export declare class FluxEngine {
+    private storage;
+    private executor;
+    private contextManager;
+    private config;
+    constructor(config?: FluxConfig);
+    /**
+     * Execute a workflow with input data
+     *
+     * @param workflow - Workflow builder or definition
+     * @param input - Input data for the workflow
+     * @returns Execution result
+     */
+    execute<TInput, TData = Record<string, unknown>>(workflow: WorkflowBuilder<TInput> | WorkflowDefinition<TInput>, input: TInput): Promise<FluxResult<TData>>;
+    /**
+     * Resume a paused or failed workflow
+     *
+     * @param workflowId - Workflow instance ID
+     * @returns Execution result or null if not found
+     */
+    resume<TData = Record<string, unknown>>(workflowId: string): Promise<FluxResult<TData> | null>;
+    /**
+     * Get workflow state by ID
+     */
+    get(workflowId: string): Promise<import("..").WorkflowState | null>;
+    /**
+     * List workflows
+     */
+    list(filter?: Parameters<WorkflowStorage['list']>[0]): Promise<import("..").WorkflowState[]>;
+    /**
+     * Initialize engine (init storage)
+     */
+    init(): Promise<void>;
+    /**
+     * Shutdown engine (cleanup)
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=FluxEngine.d.ts.map

package/dist/engine/FluxEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluxEngine.d.ts","sourceRoot":"","sources":["../../src/engine/FluxEngine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAK5D,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EAEV,kBAAkB,EAClB,eAAe,EAChB,MAAM,UAAU,CAAA;AAEjB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,MAAM,CAAY;gBAEd,MAAM,GAAE,UAAe;IAUnC;;;;;;OAMG;IACG,OAAO,CAAC,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnD,QAAQ,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,kBAAkB,CAAC,MAAM,CAAC,EAC9D,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAoH7B;;;;;OAKG;IACG,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAUpC;;OAEG;IACG,GAAG,CAAC,UAAU,EAAE,MAAM;IAI5B;;OAEG;IACG,IAAI,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAI1D;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/engine/index.d.ts

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

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

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

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview @gravito/flux - Platform-agnostic Workflow Engine
+ *
+ * High-performance, type-safe workflow engine with Bun optimizations.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { FluxEngine, createWorkflow } from '@gravito/flux'
+ *
+ * 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 processPayment(ctx.data.order)
+ *   })
+ *   .commit('notify', async (ctx) => {
+ *     await sendEmail(ctx.data.order.email)
+ *   })
+ *
+ * const engine = new FluxEngine()
+ * const result = await engine.execute(workflow, { orderId: '123' })
+ * ```
+ *
+ * @module @gravito/flux
+ */
+export { createWorkflow, WorkflowBuilder } from './builder/WorkflowBuilder';
+export { ContextManager } from './core/ContextManager';
+export { StateMachine } from './core/StateMachine';
+export { StepExecutor } from './core/StepExecutor';
+export { FluxEngine } from './engine/FluxEngine';
+export { FluxConsoleLogger, FluxSilentLogger } from './logger/FluxLogger';
+export { OrbitFlux, type OrbitFluxOptions } from './orbit/OrbitFlux';
+export { BunSQLiteStorage, type BunSQLiteStorageOptions } from './storage/BunSQLiteStorage';
+export { MemoryStorage } from './storage/MemoryStorage';
+export type { FluxConfig, FluxLogger, FluxResult, StepDefinition, StepExecution, StepResult, WorkflowContext, WorkflowDefinition, WorkflowFilter, WorkflowState, WorkflowStatus, WorkflowStorage, } from './types';
+//# 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAEhD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAEzE,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAE3F,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAGvD,YAAY,EAEV,UAAU,EAEV,UAAU,EACV,UAAU,EAEV,cAAc,EACd,aAAa,EACb,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,aAAa,EAEb,cAAc,EAEd,eAAe,GAChB,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,479 @@
+// @bun
+import {
+  BunSQLiteStorage
+} from "./chunk-qjdtqchy.js";
+
+// src/builder/WorkflowBuilder.ts
+class WorkflowBuilder {
+  _name;
+  _steps = [];
+  _validateInput;
+  constructor(name) {
+    this._name = name;
+  }
+  input() {
+    return this;
+  }
+  validate(validator) {
+    this._validateInput = validator;
+    return this;
+  }
+  step(name, handler, options) {
+    this._steps.push({
+      name,
+      handler,
+      retries: options?.retries,
+      timeout: options?.timeout,
+      when: options?.when,
+      commit: false
+    });
+    return this;
+  }
+  commit(name, handler, options) {
+    this._steps.push({
+      name,
+      handler,
+      retries: options?.retries,
+      timeout: options?.timeout,
+      when: options?.when,
+      commit: true
+    });
+    return this;
+  }
+  build() {
+    if (this._steps.length === 0) {
+      throw new Error(`Workflow "${this._name}" has no steps`);
+    }
+    return {
+      name: this._name,
+      steps: [...this._steps],
+      validateInput: this._validateInput
+    };
+  }
+  get name() {
+    return this._name;
+  }
+  get stepCount() {
+    return this._steps.length;
+  }
+}
+function createWorkflow(name) {
+  return new WorkflowBuilder(name);
+}
+// src/core/ContextManager.ts
+function generateId() {
+  return crypto.randomUUID();
+}
+
+class ContextManager {
+  create(name, input, stepCount) {
+    const history = Array.from({ length: stepCount }, (_, _i) => ({
+      name: "",
+      status: "pending",
+      retries: 0
+    }));
+    return {
+      id: generateId(),
+      name,
+      input,
+      data: {},
+      status: "pending",
+      currentStep: 0,
+      history
+    };
+  }
+  restore(state) {
+    return {
+      id: state.id,
+      name: state.name,
+      input: state.input,
+      data: { ...state.data },
+      status: state.status,
+      currentStep: state.currentStep,
+      history: state.history.map((h) => ({ ...h }))
+    };
+  }
+  toState(ctx) {
+    return {
+      id: ctx.id,
+      name: ctx.name,
+      status: ctx.status,
+      input: ctx.input,
+      data: { ...ctx.data },
+      currentStep: ctx.currentStep,
+      history: ctx.history.map((h) => ({ ...h })),
+      createdAt: new Date,
+      updatedAt: new Date
+    };
+  }
+  updateStatus(ctx, status) {
+    return {
+      ...ctx,
+      status
+    };
+  }
+  advanceStep(ctx) {
+    return {
+      ...ctx,
+      currentStep: ctx.currentStep + 1
+    };
+  }
+  setStepName(ctx, index, name) {
+    if (ctx.history[index]) {
+      ctx.history[index].name = name;
+    }
+  }
+}
+// src/core/StateMachine.ts
+var TRANSITIONS = {
+  pending: ["running", "failed"],
+  running: ["paused", "completed", "failed"],
+  paused: ["running", "failed"],
+  completed: [],
+  failed: ["pending"]
+};
+
+class StateMachine extends EventTarget {
+  _status = "pending";
+  get status() {
+    return this._status;
+  }
+  canTransition(to) {
+    return TRANSITIONS[this._status].includes(to);
+  }
+  transition(to) {
+    if (!this.canTransition(to)) {
+      throw new Error(`Invalid state transition: ${this._status} \u2192 ${to}`);
+    }
+    const from = this._status;
+    this._status = to;
+    this.dispatchEvent(new CustomEvent("transition", {
+      detail: { from, to }
+    }));
+  }
+  forceStatus(status) {
+    this._status = status;
+  }
+  isTerminal() {
+    return this._status === "completed" || this._status === "failed";
+  }
+  canExecute() {
+    return this._status === "pending" || this._status === "paused";
+  }
+}
+// src/core/StepExecutor.ts
+class StepExecutor {
+  defaultRetries;
+  defaultTimeout;
+  constructor(options = {}) {
+    this.defaultRetries = options.defaultRetries ?? 3;
+    this.defaultTimeout = options.defaultTimeout ?? 30000;
+  }
+  async execute(step, ctx, execution) {
+    const maxRetries = step.retries ?? this.defaultRetries;
+    const timeout = step.timeout ?? this.defaultTimeout;
+    const startTime = Date.now();
+    if (step.when && !step.when(ctx)) {
+      execution.status = "skipped";
+      return {
+        success: true,
+        duration: 0
+      };
+    }
+    execution.status = "running";
+    execution.startedAt = new Date;
+    let lastError;
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      execution.retries = attempt;
+      try {
+        await this.executeWithTimeout(step.handler, ctx, timeout);
+        execution.status = "completed";
+        execution.completedAt = new Date;
+        execution.duration = Date.now() - startTime;
+        return {
+          success: true,
+          duration: execution.duration
+        };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxRetries) {
+          await this.sleep(Math.min(1000 * 2 ** attempt, 1e4));
+        }
+      }
+    }
+    execution.status = "failed";
+    execution.completedAt = new Date;
+    execution.duration = Date.now() - startTime;
+    execution.error = lastError?.message;
+    return {
+      success: false,
+      error: lastError,
+      duration: execution.duration
+    };
+  }
+  async executeWithTimeout(handler, ctx, timeout) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Step timeout")), timeout);
+    });
+    await Promise.race([Promise.resolve(handler(ctx)), timeoutPromise]);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+// src/storage/MemoryStorage.ts
+class MemoryStorage {
+  store = new Map;
+  async save(state) {
+    this.store.set(state.id, {
+      ...state,
+      updatedAt: new Date
+    });
+  }
+  async load(id) {
+    return this.store.get(id) ?? null;
+  }
+  async list(filter) {
+    let results = Array.from(this.store.values());
+    if (filter?.name) {
+      results = results.filter((s) => s.name === filter.name);
+    }
+    if (filter?.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      results = results.filter((s) => statuses.includes(s.status));
+    }
+    results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    if (filter?.offset) {
+      results = results.slice(filter.offset);
+    }
+    if (filter?.limit) {
+      results = results.slice(0, filter.limit);
+    }
+    return results;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async init() {}
+  async close() {
+    this.store.clear();
+  }
+  size() {
+    return this.store.size;
+  }
+}
+
+// src/engine/FluxEngine.ts
+class FluxEngine {
+  storage;
+  executor;
+  contextManager;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.storage = config.storage ?? new MemoryStorage;
+    this.executor = new StepExecutor({
+      defaultRetries: config.defaultRetries,
+      defaultTimeout: config.defaultTimeout
+    });
+    this.contextManager = new ContextManager;
+  }
+  async execute(workflow, input) {
+    const startTime = Date.now();
+    const definition = workflow instanceof WorkflowBuilder ? workflow.build() : workflow;
+    if (definition.validateInput && !definition.validateInput(input)) {
+      throw new Error(`Invalid input for workflow "${definition.name}"`);
+    }
+    const ctx = this.contextManager.create(definition.name, input, definition.steps.length);
+    const stateMachine = new StateMachine;
+    await this.storage.save(this.contextManager.toState(ctx));
+    try {
+      stateMachine.transition("running");
+      Object.assign(ctx, { status: "running" });
+      for (let i = 0;i < definition.steps.length; i++) {
+        const step = definition.steps[i];
+        const execution = ctx.history[i];
+        this.contextManager.setStepName(ctx, i, step.name);
+        Object.assign(ctx, { currentStep: i });
+        this.config.on?.stepStart?.(step.name, ctx);
+        const result = await this.executor.execute(step, ctx, execution);
+        if (result.success) {
+          this.config.on?.stepComplete?.(step.name, ctx, result);
+        } else {
+          this.config.on?.stepError?.(step.name, ctx, result.error);
+          stateMachine.transition("failed");
+          Object.assign(ctx, { status: "failed" });
+          await this.storage.save({
+            ...this.contextManager.toState(ctx),
+            error: result.error?.message
+          });
+          return {
+            id: ctx.id,
+            status: "failed",
+            data: ctx.data,
+            history: ctx.history,
+            duration: Date.now() - startTime,
+            error: result.error
+          };
+        }
+        await this.storage.save(this.contextManager.toState(ctx));
+      }
+      stateMachine.transition("completed");
+      Object.assign(ctx, { status: "completed" });
+      await this.storage.save({
+        ...this.contextManager.toState(ctx),
+        completedAt: new Date
+      });
+      this.config.on?.workflowComplete?.(ctx);
+      return {
+        id: ctx.id,
+        status: "completed",
+        data: ctx.data,
+        history: ctx.history,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.config.on?.workflowError?.(ctx, err);
+      stateMachine.forceStatus("failed");
+      Object.assign(ctx, { status: "failed" });
+      await this.storage.save({
+        ...this.contextManager.toState(ctx),
+        error: err.message
+      });
+      return {
+        id: ctx.id,
+        status: "failed",
+        data: ctx.data,
+        history: ctx.history,
+        duration: Date.now() - startTime,
+        error: err
+      };
+    }
+  }
+  async resume(workflowId) {
+    const state = await this.storage.load(workflowId);
+    if (!state) {
+      return null;
+    }
+    throw new Error("Resume not yet implemented");
+  }
+  async get(workflowId) {
+    return this.storage.load(workflowId);
+  }
+  async list(filter) {
+    return this.storage.list(filter);
+  }
+  async init() {
+    await this.storage.init?.();
+  }
+  async close() {
+    await this.storage.close?.();
+  }
+}
+// src/logger/FluxLogger.ts
+class FluxConsoleLogger {
+  prefix;
+  constructor(prefix = "[Flux]") {
+    this.prefix = prefix;
+  }
+  debug(message, ...args) {
+    console.debug(`${this.prefix} ${message}`, ...args);
+  }
+  info(message, ...args) {
+    console.info(`${this.prefix} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(`${this.prefix} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.error(`${this.prefix} ${message}`, ...args);
+  }
+}
+
+class FluxSilentLogger {
+  debug() {}
+  info() {}
+  warn() {}
+  error() {}
+}
+// src/orbit/OrbitFlux.ts
+class OrbitFlux {
+  options;
+  engine;
+  constructor(options = {}) {
+    this.options = {
+      storage: "memory",
+      exposeAs: "flux",
+      defaultRetries: 3,
+      defaultTimeout: 30000,
+      ...options
+    };
+  }
+  static configure(options = {}) {
+    return new OrbitFlux(options);
+  }
+  async install(core) {
+    const { storage, dbPath, exposeAs, defaultRetries, defaultTimeout, logger } = this.options;
+    let storageAdapter;
+    if (typeof storage === "string") {
+      switch (storage) {
+        case "sqlite":
+          storageAdapter = new BunSQLiteStorage({ path: dbPath });
+          break;
+        default:
+          storageAdapter = new MemoryStorage;
+      }
+    } else {
+      storageAdapter = storage;
+    }
+    await storageAdapter.init?.();
+    const engineConfig = {
+      storage: storageAdapter,
+      defaultRetries,
+      defaultTimeout,
+      logger: logger ?? {
+        debug: (msg) => core.logger.debug(`[Flux] ${msg}`),
+        info: (msg) => core.logger.info(`[Flux] ${msg}`),
+        warn: (msg) => core.logger.warn(`[Flux] ${msg}`),
+        error: (msg) => core.logger.error(`[Flux] ${msg}`)
+      },
+      on: {
+        stepStart: (step) => {
+          core.hooks.doAction("flux:step:start", { step });
+        },
+        stepComplete: (step, ctx, result) => {
+          core.hooks.doAction("flux:step:complete", { step, ctx, result });
+        },
+        stepError: (step, ctx, error) => {
+          core.hooks.doAction("flux:step:error", { step, ctx, error });
+        },
+        workflowComplete: (ctx) => {
+          core.hooks.doAction("flux:workflow:complete", { ctx });
+        },
+        workflowError: (ctx, error) => {
+          core.hooks.doAction("flux:workflow:error", { ctx, error });
+        }
+      }
+    };
+    this.engine = new FluxEngine(engineConfig);
+    core.services.set(exposeAs, this.engine);
+    core.logger.info(`[OrbitFlux] Initialized (Storage: ${typeof storage === "string" ? storage : "custom"})`);
+  }
+  getEngine() {
+    return this.engine;
+  }
+}
+export {
+  createWorkflow,
+  WorkflowBuilder,
+  StepExecutor,
+  StateMachine,
+  OrbitFlux,
+  MemoryStorage,
+  FluxSilentLogger,
+  FluxEngine,
+  FluxConsoleLogger,
+  ContextManager,
+  BunSQLiteStorage
+};

package/dist/index.node.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Node.js compatible entry point
+ *
+ * This entry exports only platform-agnostic components.
+ * BunSQLiteStorage is NOT included (use main entry for Bun).
+ *
+ * @module @gravito/flux
+ */
+export { createWorkflow, WorkflowBuilder } from './builder/WorkflowBuilder';
+export { FluxEngine } from './engine/FluxEngine';
+export { MemoryStorage } from './storage/MemoryStorage';
+export { ContextManager } from './core/ContextManager';
+export { StateMachine } from './core/StateMachine';
+export { StepExecutor } from './core/StepExecutor';
+export { FluxConsoleLogger, FluxSilentLogger } from './logger/FluxLogger';
+export { OrbitFlux, type OrbitFluxOptions } from './orbit/OrbitFlux';
+export type { FluxConfig, FluxLogger, FluxResult, StepDefinition, StepExecution, StepResult, WorkflowContext, WorkflowDefinition, WorkflowFilter, WorkflowState, WorkflowStatus, WorkflowStorage, } from './types';
+//# sourceMappingURL=index.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../src/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAE3E,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAGhD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAIvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAEzE,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAGpE,YAAY,EAEV,UAAU,EAEV,UAAU,EACV,UAAU,EAEV,cAAc,EACd,aAAa,EACb,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,aAAa,EAEb,cAAc,EAEd,eAAe,GAChB,MAAM,SAAS,CAAA"}

package/dist/logger/FluxLogger.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Console Logger for FluxEngine
+ *
+ * Default logger implementation using console.
+ *
+ * @module @gravito/flux
+ */
+import type { FluxLogger } from '../types';
+/**
+ * Console Logger
+ *
+ * Default logger that outputs to console.
+ *
+ * @example
+ * ```typescript
+ * const engine = new FluxEngine({
+ *   logger: new FluxConsoleLogger()
+ * })
+ * ```
+ */
+export declare class FluxConsoleLogger implements FluxLogger {
+    private prefix;
+    constructor(prefix?: string);
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Silent Logger
+ *
+ * Logger that outputs nothing (for testing or production).
+ */
+export declare class FluxSilentLogger implements FluxLogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+//# sourceMappingURL=FluxLogger.d.ts.map

package/dist/logger/FluxLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluxLogger.d.ts","sourceRoot":"","sources":["../../src/logger/FluxLogger.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAkB,YAAW,UAAU;IAClD,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,SAAW;IAI7B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAIhD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI/C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI/C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;CAGjD;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,UAAU;IACjD,KAAK,IAAI,IAAI;IACb,IAAI,IAAI,IAAI;IACZ,IAAI,IAAI,IAAI;IACZ,KAAK,IAAI,IAAI;CACd"}

package/dist/logger/index.d.ts

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

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

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