@gravito/flux 3.0.0 → 3.0.2

package/dist/chunk-X3NC7HS4.cjs

@@ -1,1004 +0,0 @@
-"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]),
-      compensate: _optionalChain([options, 'optionalAccess', _5 => _5.compensate]),
-      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', _6 => _6.retries]),
-      timeout: _optionalChain([options, 'optionalAccess', _7 => _7.timeout]),
-      when: _optionalChain([options, 'optionalAccess', _8 => _8.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", "suspended", "rolling_back"],
-  paused: ["running", "failed"],
-  suspended: ["running", "failed"],
-  rolling_back: ["rolled_back", "failed"],
-  rolled_back: ["pending"],
-  // allow retry from scratch
-  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" || this._status === "rolled_back";
-  }
-  /**
-   * 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 {
-        const result = await this.executeWithTimeout(step.handler, ctx, timeout);
-        if (result && typeof result === "object" && "__kind" in result && result.__kind === "flux_wait") {
-          execution.status = "suspended";
-          execution.waitingFor = result.signal;
-          execution.suspendedAt = /* @__PURE__ */ new Date();
-          execution.duration = Date.now() - startTime;
-          return {
-            success: true,
-            suspended: true,
-            waitingFor: result.signal,
-            duration: execution.duration
-          };
-        }
-        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', _9 => _9.onRetry, 'optionalCall', _10 => _10(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', _11 => _11.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);
-      });
-      return 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', _12 => _12.name])) {
-      results = results.filter((s) => s.name === filter.name);
-    }
-    if (_optionalChain([filter, 'optionalAccess', _13 => _13.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', _14 => _14.offset])) {
-      results = results.slice(filter.offset);
-    }
-    if (_optionalChain([filter, 'optionalAccess', _15 => _15.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', _16 => _16.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
-    });
-  }
-  /**
-   * Send a signal to a suspended workflow
-   */
-  async signal(workflow, workflowId, signalName, payload) {
-    const definition = this.resolveDefinition(workflow);
-    const state = await this.storage.load(workflowId);
-    if (!state) {
-      throw new Error("Workflow not found");
-    }
-    if (state.status !== "suspended") {
-      throw new Error(`Workflow is not suspended (status: ${state.status})`);
-    }
-    const ctx = this.contextManager.restore(state);
-    const currentStep = ctx.history[ctx.currentStep];
-    if (!currentStep || currentStep.status !== "suspended") {
-      throw new Error("Workflow state invalid: no suspended step found");
-    }
-    if (currentStep.waitingFor !== signalName) {
-      throw new Error(
-        `Workflow waiting for signal "${currentStep.waitingFor}", received "${signalName}"`
-      );
-    }
-    currentStep.status = "completed";
-    currentStep.completedAt = /* @__PURE__ */ new Date();
-    currentStep.output = payload;
-    const stateMachine = new StateMachine();
-    stateMachine.forceStatus("suspended");
-    await this.emitTrace({
-      type: "signal:received",
-      timestamp: Date.now(),
-      workflowId: ctx.id,
-      workflowName: ctx.name,
-      status: "suspended",
-      input: payload
-    });
-    const nextStepIndex = ctx.currentStep + 1;
-    return this.runFrom(definition, ctx, stateMachine, Date.now(), nextStepIndex, {
-      resume: true,
-      fromStep: nextStepIndex
-    });
-  }
-  /**
-   * 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', _17 => _17.storage, 'access', _18 => _18.init, 'optionalCall', _19 => _19()]);
-  }
-  /**
-   * Shutdown engine (cleanup)
-   */
-  async close() {
-    await _optionalChain([this, 'access', _20 => _20.storage, 'access', _21 => _21.close, 'optionalCall', _22 => _22()]);
-  }
-  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;
-    }
-  }
-  /**
-   * Rollback workflow by executing compensation handlers in reverse order
-   */
-  async rollback(definition, ctx, failedAtIndex, originalError) {
-    Object.assign(ctx, { status: "rolling_back" });
-    await this.emitTrace({
-      type: "workflow:rollback_start",
-      timestamp: Date.now(),
-      workflowId: ctx.id,
-      workflowName: ctx.name,
-      status: "rolling_back",
-      error: originalError.message
-    });
-    let compensatedCount = 0;
-    for (let i = failedAtIndex - 1; i >= 0; i--) {
-      const step = definition.steps[i];
-      const execution = ctx.history[i];
-      if (!step || !step.compensate || !execution || execution.status !== "completed") {
-        continue;
-      }
-      try {
-        execution.status = "compensating";
-        await this.storage.save(this.contextManager.toState(ctx));
-        await step.compensate(ctx);
-        execution.status = "compensated";
-        execution.compensatedAt = /* @__PURE__ */ new Date();
-        compensatedCount++;
-        await this.emitTrace({
-          type: "step:compensate",
-          timestamp: Date.now(),
-          workflowId: ctx.id,
-          workflowName: ctx.name,
-          stepName: step.name,
-          stepIndex: i,
-          status: "compensated"
-        });
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        Object.assign(ctx, { status: "failed" });
-        await this.emitTrace({
-          type: "workflow:error",
-          timestamp: Date.now(),
-          workflowId: ctx.id,
-          workflowName: ctx.name,
-          status: "failed",
-          error: `Compensation failed at step "${step.name}": ${error.message}`
-        });
-        return;
-      }
-      await this.storage.save(this.contextManager.toState(ctx));
-    }
-    if (compensatedCount > 0) {
-      Object.assign(ctx, { status: "rolled_back" });
-      await this.emitTrace({
-        type: "workflow:rollback_complete",
-        timestamp: Date.now(),
-        workflowId: ctx.id,
-        workflowName: ctx.name,
-        status: "rolled_back"
-      });
-    } else {
-      Object.assign(ctx, { status: "failed" });
-    }
-  }
-  async runFrom(definition, ctx, stateMachine, startTime, startIndex, meta) {
-    try {
-      stateMachine.transition("running");
-      Object.assign(ctx, { status: "running" });
-      if (!_optionalChain([meta, 'optionalAccess', _23 => _23.resume])) {
-        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', _24 => _24.config, 'access', _25 => _25.on, 'optionalAccess', _26 => _26.stepStart, 'optionalCall', _27 => _27(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) {
-          if (result.suspended) {
-            stateMachine.transition("suspended");
-            Object.assign(ctx, { status: "suspended" });
-            await this.emitTrace({
-              type: "step:suspend",
-              timestamp: Date.now(),
-              workflowId: ctx.id,
-              workflowName: ctx.name,
-              stepName: step.name,
-              stepIndex: i,
-              meta: { signal: result.waitingFor }
-            });
-            await this.storage.save(this.contextManager.toState(ctx));
-            return {
-              id: ctx.id,
-              status: "suspended",
-              data: ctx.data,
-              history: ctx.history,
-              duration: Date.now() - startTime
-            };
-          }
-          _optionalChain([this, 'access', _28 => _28.config, 'access', _29 => _29.on, 'optionalAccess', _30 => _30.stepComplete, 'optionalCall', _31 => _31(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', _32 => _32.config, 'access', _33 => _33.on, 'optionalAccess', _34 => _34.stepError, 'optionalCall', _35 => _35(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', _36 => _36.error, 'optionalAccess', _37 => _37.message]),
-            status: execution.status,
-            meta
-          });
-          await this.rollback(definition, ctx, i, result.error);
-          const finalStatus = ctx.status;
-          stateMachine.forceStatus(finalStatus);
-          await this.storage.save({
-            ...this.contextManager.toState(ctx),
-            error: _optionalChain([result, 'access', _38 => _38.error, 'optionalAccess', _39 => _39.message])
-          });
-          return {
-            id: ctx.id,
-            status: finalStatus,
-            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', _40 => _40.config, 'access', _41 => _41.on, 'optionalAccess', _42 => _42.workflowComplete, 'optionalCall', _43 => _43(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', _44 => _44.config, 'access', _45 => _45.on, 'optionalAccess', _46 => _46.workflowError, 'optionalCall', _47 => _47(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', _48 => _48.config, 'access', _49 => _49.trace, 'optionalAccess', _50 => _50.emit, 'call', _51 => _51(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', _52 => _52.init, 'optionalCall', _53 => _53()]);
-    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-X3NC7HS4.cjs.map