@gravito/flux 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/chunk-RPECIW7O.cjs

@@ -0,0 +1,858 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+
+var _chunkSJSPR4ZUcjs = require('./chunk-SJSPR4ZU.cjs');
+
+// src/builder/WorkflowBuilder.ts
+var WorkflowBuilder = (_class = class {
+  
+  __init() {this._steps = []}
+  
+  constructor(name) {;_class.prototype.__init.call(this);
+    this._name = name;
+  }
+  /**
+   * Define input type
+   *
+   * This method is used for TypeScript type inference.
+   */
+  input() {
+    return this;
+  }
+  /**
+   * Define workflow data (state) type
+   *
+   * This method is used for TypeScript type inference.
+   */
+  data() {
+    return this;
+  }
+  /**
+   * Add input validator
+   */
+  validate(validator) {
+    this._validateInput = validator;
+    return this;
+  }
+  /**
+   * Add a step to the workflow
+   */
+  step(name, handler, options) {
+    this._steps.push({
+      name,
+      handler,
+      retries: _optionalChain([options, 'optionalAccess', _2 => _2.retries]),
+      timeout: _optionalChain([options, 'optionalAccess', _3 => _3.timeout]),
+      when: _optionalChain([options, 'optionalAccess', _4 => _4.when]),
+      commit: false
+    });
+    return 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, handler, options) {
+    this._steps.push({
+      name,
+      handler,
+      retries: _optionalChain([options, 'optionalAccess', _5 => _5.retries]),
+      timeout: _optionalChain([options, 'optionalAccess', _6 => _6.timeout]),
+      when: _optionalChain([options, 'optionalAccess', _7 => _7.when]),
+      commit: true
+    });
+    return this;
+  }
+  /**
+   * Build the workflow definition
+   */
+  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
+    };
+  }
+  /**
+   * Describe workflow (serializable metadata)
+   */
+  describe() {
+    const steps = this._steps.map((step) => ({
+      name: step.name,
+      commit: Boolean(step.commit),
+      retries: step.retries,
+      timeout: step.timeout,
+      hasCondition: Boolean(step.when)
+    }));
+    return {
+      name: this._name,
+      steps
+    };
+  }
+  /**
+   * Get workflow name
+   */
+  get name() {
+    return this._name;
+  }
+  /**
+   * Get step count
+   */
+  get stepCount() {
+    return this._steps.length;
+  }
+}, _class);
+function createWorkflow(name) {
+  return new WorkflowBuilder(name);
+}
+
+// src/core/ContextManager.ts
+function generateId() {
+  return crypto.randomUUID();
+}
+var ContextManager = class {
+  /**
+   * Create a new workflow context
+   */
+  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 context from saved state
+   */
+  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 }))
+    };
+  }
+  /**
+   * Convert context to serializable state
+   */
+  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: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Update context status (returns new context for immutability)
+   */
+  updateStatus(ctx, status) {
+    return {
+      ...ctx,
+      status
+    };
+  }
+  /**
+   * Advance to next step
+   */
+  advanceStep(ctx) {
+    return {
+      ...ctx,
+      currentStep: ctx.currentStep + 1
+    };
+  }
+  /**
+   * Update step name in history
+   */
+  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: [],
+  // terminal state
+  failed: ["pending"]
+  // allow retry
+};
+var StateMachine = (_class2 = class extends EventTarget {constructor(...args2) { super(...args2); _class2.prototype.__init2.call(this); }
+  __init2() {this._status = "pending"}
+  /**
+   * Current status
+   */
+  get status() {
+    return this._status;
+  }
+  /**
+   * Check if transition to target status is allowed
+   */
+  canTransition(to) {
+    return TRANSITIONS[this._status].includes(to);
+  }
+  /**
+   * Transition to a new status
+   *
+   * @throws {Error} If transition is not allowed
+   */
+  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 }
+      })
+    );
+  }
+  /**
+   * Force set status (for replay/restore)
+   */
+  forceStatus(status) {
+    this._status = status;
+  }
+  /**
+   * Check if workflow is in terminal state
+   */
+  isTerminal() {
+    return this._status === "completed" || this._status === "failed";
+  }
+  /**
+   * Check if workflow can be executed
+   */
+  canExecute() {
+    return this._status === "pending" || this._status === "paused";
+  }
+}, _class2);
+
+// src/core/StepExecutor.ts
+var StepExecutor = class {
+  
+  
+  
+  constructor(options = {}) {
+    this.defaultRetries = _nullishCoalesce(options.defaultRetries, () => ( 3));
+    this.defaultTimeout = _nullishCoalesce(options.defaultTimeout, () => ( 3e4));
+    this.onRetry = options.onRetry;
+  }
+  /**
+   * Execute a step with retry and timeout
+   */
+  async execute(step, ctx, execution) {
+    const maxRetries = _nullishCoalesce(step.retries, () => ( this.defaultRetries));
+    const timeout = _nullishCoalesce(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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 _optionalChain([this, 'access', _8 => _8.onRetry, 'optionalCall', _9 => _9(step, ctx, lastError, attempt + 1, maxRetries)]);
+          await this.sleep(Math.min(1e3 * 2 ** attempt, 1e4));
+        }
+      }
+    }
+    execution.status = "failed";
+    execution.completedAt = /* @__PURE__ */ new Date();
+    execution.duration = Date.now() - startTime;
+    execution.error = _optionalChain([lastError, 'optionalAccess', _10 => _10.message]);
+    return {
+      success: false,
+      error: lastError,
+      duration: execution.duration
+    };
+  }
+  /**
+   * Execute handler with timeout
+   */
+  async executeWithTimeout(handler, ctx, timeout) {
+    let timer = null;
+    try {
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Step timeout")), timeout);
+      });
+      await Promise.race([Promise.resolve(handler(ctx)), timeoutPromise]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/storage/MemoryStorage.ts
+var MemoryStorage = (_class3 = class {constructor() { _class3.prototype.__init3.call(this); }
+  __init3() {this.store = /* @__PURE__ */ new Map()}
+  async save(state) {
+    this.store.set(state.id, {
+      ...state,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  async load(id) {
+    return _nullishCoalesce(this.store.get(id), () => ( null));
+  }
+  async list(filter) {
+    let results = Array.from(this.store.values());
+    if (_optionalChain([filter, 'optionalAccess', _11 => _11.name])) {
+      results = results.filter((s) => s.name === filter.name);
+    }
+    if (_optionalChain([filter, 'optionalAccess', _12 => _12.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 (_optionalChain([filter, 'optionalAccess', _13 => _13.offset])) {
+      results = results.slice(filter.offset);
+    }
+    if (_optionalChain([filter, 'optionalAccess', _14 => _14.limit])) {
+      results = results.slice(0, filter.limit);
+    }
+    return results;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async init() {
+  }
+  async close() {
+    this.store.clear();
+  }
+  /**
+   * Get store size (for testing)
+   */
+  size() {
+    return this.store.size;
+  }
+}, _class3);
+
+// src/engine/FluxEngine.ts
+var FluxEngine = class {
+  
+  
+  
+  
+  constructor(config = {}) {
+    this.config = config;
+    this.storage = _nullishCoalesce(config.storage, () => ( new MemoryStorage()));
+    this.executor = new StepExecutor({
+      defaultRetries: config.defaultRetries,
+      defaultTimeout: config.defaultTimeout,
+      onRetry: async (step, ctx, error, attempt, maxRetries) => {
+        await this.emitTrace({
+          type: "step:retry",
+          timestamp: Date.now(),
+          workflowId: ctx.id,
+          workflowName: ctx.name,
+          stepName: step.name,
+          stepIndex: ctx.currentStep,
+          commit: Boolean(step.commit),
+          retries: attempt,
+          maxRetries,
+          error: error.message,
+          status: "running"
+        });
+      }
+    });
+    this.contextManager = new ContextManager();
+  }
+  /**
+   * Execute a workflow with input data
+   *
+   * @param workflow - Workflow builder or definition
+   * @param input - Input data for the workflow
+   * @returns Execution result
+   */
+  async execute(workflow, input) {
+    const startTime = Date.now();
+    const definition = this.resolveDefinition(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));
+    return this.runFrom(definition, ctx, stateMachine, startTime, 0);
+  }
+  /**
+   * Resume a paused or failed workflow
+   *
+   * @param workflowId - Workflow instance ID
+   * @returns Execution result or null if not found
+   */
+  async resume(workflow, workflowId, options) {
+    const definition = this.resolveDefinition(workflow);
+    const state = await this.storage.load(workflowId);
+    if (!state) {
+      return null;
+    }
+    if (state.name !== definition.name) {
+      throw new Error(`Workflow name mismatch: ${state.name} !== ${definition.name}`);
+    }
+    if (state.history.length !== definition.steps.length) {
+      throw new Error("Workflow definition changed; resume is not safe");
+    }
+    const ctx = this.contextManager.restore(state);
+    const stateMachine = new StateMachine();
+    stateMachine.forceStatus("pending");
+    const startIndex = this.resolveStartIndex(definition, _optionalChain([options, 'optionalAccess', _15 => _15.fromStep]), ctx.currentStep);
+    this.resetHistoryFrom(ctx, startIndex);
+    Object.assign(ctx, { status: "pending", currentStep: startIndex });
+    await this.storage.save(this.contextManager.toState(ctx));
+    return this.runFrom(definition, ctx, stateMachine, Date.now(), startIndex, {
+      resume: true,
+      fromStep: startIndex
+    });
+  }
+  /**
+   * Retry a specific step (replays from that step onward)
+   */
+  async retryStep(workflow, workflowId, stepName) {
+    const definition = this.resolveDefinition(workflow);
+    const state = await this.storage.load(workflowId);
+    if (!state) {
+      return null;
+    }
+    if (state.name !== definition.name) {
+      throw new Error(`Workflow name mismatch: ${state.name} !== ${definition.name}`);
+    }
+    if (state.history.length !== definition.steps.length) {
+      throw new Error("Workflow definition changed; retry is not safe");
+    }
+    const ctx = this.contextManager.restore(state);
+    const stateMachine = new StateMachine();
+    stateMachine.forceStatus("pending");
+    const startIndex = this.resolveStartIndex(definition, stepName, ctx.currentStep);
+    this.resetHistoryFrom(ctx, startIndex);
+    Object.assign(ctx, { status: "pending", currentStep: startIndex });
+    await this.storage.save(this.contextManager.toState(ctx));
+    return this.runFrom(definition, ctx, stateMachine, Date.now(), startIndex, {
+      retry: true,
+      fromStep: startIndex
+    });
+  }
+  /**
+   * Get workflow state by ID
+   */
+  async get(workflowId) {
+    return this.storage.load(workflowId);
+  }
+  /**
+   * Save workflow state manually (e.g., for external updates)
+   */
+  async saveState(state) {
+    return this.storage.save(state);
+  }
+  /**
+   * List workflows
+   */
+  async list(filter) {
+    return this.storage.list(filter);
+  }
+  /**
+   * Initialize engine (init storage)
+   */
+  async init() {
+    await _optionalChain([this, 'access', _16 => _16.storage, 'access', _17 => _17.init, 'optionalCall', _18 => _18()]);
+  }
+  /**
+   * Shutdown engine (cleanup)
+   */
+  async close() {
+    await _optionalChain([this, 'access', _19 => _19.storage, 'access', _20 => _20.close, 'optionalCall', _21 => _21()]);
+  }
+  resolveDefinition(workflow) {
+    return workflow instanceof WorkflowBuilder ? workflow.build() : workflow;
+  }
+  resolveStartIndex(definition, fromStep, fallback) {
+    if (typeof fromStep === "number") {
+      if (fromStep < 0 || fromStep >= definition.steps.length) {
+        throw new Error(`Invalid step index: ${fromStep}`);
+      }
+      return fromStep;
+    }
+    if (typeof fromStep === "string") {
+      const index = definition.steps.findIndex((step) => step.name === fromStep);
+      if (index === -1) {
+        throw new Error(`Step not found: ${fromStep}`);
+      }
+      return index;
+    }
+    return Math.max(0, Math.min(fallback, definition.steps.length - 1));
+  }
+  resetHistoryFrom(ctx, startIndex) {
+    for (let i = startIndex; i < ctx.history.length; i++) {
+      const entry = ctx.history[i];
+      if (!entry) {
+        continue;
+      }
+      entry.status = "pending";
+      entry.startedAt = void 0;
+      entry.completedAt = void 0;
+      entry.duration = void 0;
+      entry.error = void 0;
+      entry.retries = 0;
+    }
+  }
+  async runFrom(definition, ctx, stateMachine, startTime, startIndex, meta) {
+    try {
+      stateMachine.transition("running");
+      Object.assign(ctx, { status: "running" });
+      await this.emitTrace({
+        type: "workflow:start",
+        timestamp: Date.now(),
+        workflowId: ctx.id,
+        workflowName: ctx.name,
+        status: ctx.status,
+        input: ctx.input,
+        meta
+      });
+      for (let i = startIndex; 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 });
+        _optionalChain([this, 'access', _22 => _22.config, 'access', _23 => _23.on, 'optionalAccess', _24 => _24.stepStart, 'optionalCall', _25 => _25(step.name, ctx)]);
+        await this.emitTrace({
+          type: "step:start",
+          timestamp: Date.now(),
+          workflowId: ctx.id,
+          workflowName: ctx.name,
+          stepName: step.name,
+          stepIndex: i,
+          commit: Boolean(step.commit),
+          retries: execution.retries,
+          status: execution.status,
+          meta
+        });
+        const result = await this.executor.execute(step, ctx, execution);
+        if (result.success) {
+          _optionalChain([this, 'access', _26 => _26.config, 'access', _27 => _27.on, 'optionalAccess', _28 => _28.stepComplete, 'optionalCall', _29 => _29(step.name, ctx, result)]);
+          if (execution.status === "skipped") {
+            await this.emitTrace({
+              type: "step:skipped",
+              timestamp: Date.now(),
+              workflowId: ctx.id,
+              workflowName: ctx.name,
+              stepName: step.name,
+              stepIndex: i,
+              commit: Boolean(step.commit),
+              retries: execution.retries,
+              duration: result.duration,
+              status: execution.status,
+              meta
+            });
+          } else {
+            await this.emitTrace({
+              type: "step:complete",
+              timestamp: Date.now(),
+              workflowId: ctx.id,
+              workflowName: ctx.name,
+              stepName: step.name,
+              stepIndex: i,
+              commit: Boolean(step.commit),
+              retries: execution.retries,
+              duration: result.duration,
+              status: execution.status,
+              meta
+            });
+          }
+        } else {
+          _optionalChain([this, 'access', _30 => _30.config, 'access', _31 => _31.on, 'optionalAccess', _32 => _32.stepError, 'optionalCall', _33 => _33(step.name, ctx, result.error)]);
+          await this.emitTrace({
+            type: "step:error",
+            timestamp: Date.now(),
+            workflowId: ctx.id,
+            workflowName: ctx.name,
+            stepName: step.name,
+            stepIndex: i,
+            commit: Boolean(step.commit),
+            retries: execution.retries,
+            duration: result.duration,
+            error: _optionalChain([result, 'access', _34 => _34.error, 'optionalAccess', _35 => _35.message]),
+            status: execution.status,
+            meta
+          });
+          stateMachine.transition("failed");
+          Object.assign(ctx, { status: "failed" });
+          await this.storage.save({
+            ...this.contextManager.toState(ctx),
+            error: _optionalChain([result, 'access', _36 => _36.error, 'optionalAccess', _37 => _37.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: /* @__PURE__ */ new Date()
+      });
+      _optionalChain([this, 'access', _38 => _38.config, 'access', _39 => _39.on, 'optionalAccess', _40 => _40.workflowComplete, 'optionalCall', _41 => _41(ctx)]);
+      await this.emitTrace({
+        type: "workflow:complete",
+        timestamp: Date.now(),
+        workflowId: ctx.id,
+        workflowName: ctx.name,
+        status: ctx.status,
+        duration: Date.now() - startTime,
+        data: ctx.data,
+        meta
+      });
+      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));
+      _optionalChain([this, 'access', _42 => _42.config, 'access', _43 => _43.on, 'optionalAccess', _44 => _44.workflowError, 'optionalCall', _45 => _45(ctx, err)]);
+      await this.emitTrace({
+        type: "workflow:error",
+        timestamp: Date.now(),
+        workflowId: ctx.id,
+        workflowName: ctx.name,
+        status: "failed",
+        duration: Date.now() - startTime,
+        error: err.message,
+        meta
+      });
+      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 emitTrace(event) {
+    try {
+      await _optionalChain([this, 'access', _46 => _46.config, 'access', _47 => _47.trace, 'optionalAccess', _48 => _48.emit, 'call', _49 => _49(event)]);
+    } catch (e) {
+    }
+  }
+};
+
+// src/trace/JsonFileTraceSink.ts
+var _promises = require('fs/promises');
+var _path = require('path');
+var JsonFileTraceSink = class {
+  
+  
+  constructor(options) {
+    this.path = options.path;
+    this.ready = this.init(_nullishCoalesce(options.reset, () => ( true)));
+  }
+  async init(reset) {
+    await _promises.mkdir.call(void 0, _path.dirname.call(void 0, this.path), { recursive: true });
+    if (reset) {
+      await _promises.writeFile.call(void 0, this.path, "", "utf8");
+    }
+  }
+  async emit(event) {
+    await this.ready;
+    await _promises.appendFile.call(void 0, this.path, `${JSON.stringify(event)}
+`, "utf8");
+  }
+};
+
+// src/logger/FluxLogger.ts
+var FluxConsoleLogger = class {
+  
+  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);
+  }
+};
+var FluxSilentLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+
+// src/orbit/OrbitFlux.ts
+var OrbitFlux = class _OrbitFlux {
+  
+  
+  constructor(options = {}) {
+    this.options = {
+      storage: "memory",
+      exposeAs: "flux",
+      defaultRetries: 3,
+      defaultTimeout: 3e4,
+      ...options
+    };
+  }
+  /**
+   * Create OrbitFlux with configuration
+   */
+  static configure(options = {}) {
+    return new _OrbitFlux(options);
+  }
+  /**
+   * Install into PlanetCore
+   *
+   * @param core - The PlanetCore instance
+   */
+  async install(core) {
+    const { storage, dbPath, exposeAs, defaultRetries, defaultTimeout, logger } = this.options;
+    let storageAdapter;
+    if (typeof storage === "string") {
+      switch (storage) {
+        case "sqlite":
+          storageAdapter = new (0, _chunkSJSPR4ZUcjs.BunSQLiteStorage)({ path: dbPath });
+          break;
+        default:
+          storageAdapter = new MemoryStorage();
+      }
+    } else {
+      storageAdapter = storage;
+    }
+    await _optionalChain([storageAdapter, 'access', _50 => _50.init, 'optionalCall', _51 => _51()]);
+    const engineConfig = {
+      storage: storageAdapter,
+      defaultRetries,
+      defaultTimeout,
+      logger: _nullishCoalesce(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"})`
+    );
+  }
+  /**
+   * Get the FluxEngine instance
+   */
+  getEngine() {
+    return this.engine;
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.WorkflowBuilder = WorkflowBuilder; exports.createWorkflow = createWorkflow; exports.ContextManager = ContextManager; exports.StateMachine = StateMachine; exports.StepExecutor = StepExecutor; exports.MemoryStorage = MemoryStorage; exports.FluxEngine = FluxEngine; exports.JsonFileTraceSink = JsonFileTraceSink; exports.FluxConsoleLogger = FluxConsoleLogger; exports.FluxSilentLogger = FluxSilentLogger; exports.OrbitFlux = OrbitFlux;
+//# sourceMappingURL=chunk-RPECIW7O.cjs.map