@gravito/flux 3.0.2 → 4.0.0

package/dist/{chunk-WAPZDXSX.cjs → chunk-AVWZYY7U.cjs}

@@ -1,117 +1,17 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _class4; var _class5; var _class6; var _class7; var _class8;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _class4; var _class5; var _class6; var _class7; var _class8; var _class9;
+
+
+
 
-var _chunkYXBEYVGYcjs = require('./chunk-YXBEYVGY.cjs');
 
-// src/errors.ts
-var FluxErrorCode = /* @__PURE__ */ ((FluxErrorCode2) => {
-  FluxErrorCode2["WORKFLOW_NOT_FOUND"] = "WORKFLOW_NOT_FOUND";
-  FluxErrorCode2["WORKFLOW_INVALID_INPUT"] = "WORKFLOW_INVALID_INPUT";
-  FluxErrorCode2["WORKFLOW_DEFINITION_CHANGED"] = "WORKFLOW_DEFINITION_CHANGED";
-  FluxErrorCode2["WORKFLOW_NAME_MISMATCH"] = "WORKFLOW_NAME_MISMATCH";
-  FluxErrorCode2["INVALID_STATE_TRANSITION"] = "INVALID_STATE_TRANSITION";
-  FluxErrorCode2["WORKFLOW_NOT_SUSPENDED"] = "WORKFLOW_NOT_SUSPENDED";
-  FluxErrorCode2["INVALID_STEP_INDEX"] = "INVALID_STEP_INDEX";
-  FluxErrorCode2["STEP_TIMEOUT"] = "STEP_TIMEOUT";
-  FluxErrorCode2["STEP_NOT_FOUND"] = "STEP_NOT_FOUND";
-  FluxErrorCode2["CONCURRENT_MODIFICATION"] = "CONCURRENT_MODIFICATION";
-  FluxErrorCode2["EMPTY_WORKFLOW"] = "EMPTY_WORKFLOW";
-  FluxErrorCode2["NO_RECOVERY_ACTION"] = "NO_RECOVERY_ACTION";
-  FluxErrorCode2["INVALID_JSON_POINTER"] = "INVALID_JSON_POINTER";
-  FluxErrorCode2["INVALID_PATH_TRAVERSAL"] = "INVALID_PATH_TRAVERSAL";
-  FluxErrorCode2["CANNOT_REPLACE_ROOT"] = "CANNOT_REPLACE_ROOT";
-  FluxErrorCode2["CANNOT_REMOVE_ROOT"] = "CANNOT_REMOVE_ROOT";
-  return FluxErrorCode2;
-})(FluxErrorCode || {});
-var FluxError = class extends Error {
-  /**
-   * Creates a new FluxError.
-   *
-   * @param message - Human-readable error description.
-   * @param code - Machine-readable error code.
-   * @param context - Additional metadata related to the error.
-   */
-  constructor(message, code, context) {
-    super(message);
-    this.code = code;
-    this.context = context;
-    this.name = "FluxError";
-  }
-};
-function workflowNotFound(id) {
-  return new FluxError(`Workflow not found: ${id}`, "WORKFLOW_NOT_FOUND" /* WORKFLOW_NOT_FOUND */, {
-    workflowId: id
-  });
-}
-function invalidStateTransition(from, to) {
-  return new FluxError(
-    `Invalid state transition: ${from} \u2192 ${to}`,
-    "INVALID_STATE_TRANSITION" /* INVALID_STATE_TRANSITION */,
-    { from, to }
-  );
-}
-function invalidInput(workflowName) {
-  return new FluxError(
-    `Invalid input for workflow "${workflowName}"`,
-    "WORKFLOW_INVALID_INPUT" /* WORKFLOW_INVALID_INPUT */,
-    { workflowName }
-  );
-}
-function workflowNameMismatch(expected, received) {
-  return new FluxError(
-    `Workflow name mismatch: ${received} !== ${expected}`,
-    "WORKFLOW_NAME_MISMATCH" /* WORKFLOW_NAME_MISMATCH */,
-    { expected, received }
-  );
-}
-function workflowDefinitionChanged() {
-  return new FluxError(
-    "Workflow definition changed; operation is not safe",
-    "WORKFLOW_DEFINITION_CHANGED" /* WORKFLOW_DEFINITION_CHANGED */
-  );
-}
-function workflowNotSuspended(status) {
-  return new FluxError(
-    `Workflow is not suspended (status: ${status})`,
-    "WORKFLOW_NOT_SUSPENDED" /* WORKFLOW_NOT_SUSPENDED */,
-    { status }
-  );
-}
-function stepNotFound(step) {
-  return new FluxError(`Step not found: ${step}`, "STEP_NOT_FOUND" /* STEP_NOT_FOUND */, { step });
-}
-function invalidStepIndex(index) {
-  return new FluxError(`Invalid step index: ${index}`, "INVALID_STEP_INDEX" /* INVALID_STEP_INDEX */, { index });
-}
-function emptyWorkflow(workflowName) {
-  return new FluxError(`Workflow "${workflowName}" has no steps`, "EMPTY_WORKFLOW" /* EMPTY_WORKFLOW */, {
-    workflowName
-  });
-}
-function noRecoveryAction(stepName) {
-  return new FluxError(
-    `No recovery action registered for step: ${stepName}`,
-    "NO_RECOVERY_ACTION" /* NO_RECOVERY_ACTION */,
-    { stepName }
-  );
-}
-function invalidJsonPointer(path) {
-  return new FluxError(`Invalid JSON Pointer: ${path}`, "INVALID_JSON_POINTER" /* INVALID_JSON_POINTER */, {
-    path
-  });
-}
-function invalidPathTraversal(segment, current) {
-  return new FluxError(
-    `Cannot access property '${segment}' on ${current}`,
-    "INVALID_PATH_TRAVERSAL" /* INVALID_PATH_TRAVERSAL */,
-    { segment, currentType: typeof current }
-  );
-}
-function cannotReplaceRoot() {
-  return new FluxError("Cannot replace root object", "CANNOT_REPLACE_ROOT" /* CANNOT_REPLACE_ROOT */);
-}
-function cannotRemoveRoot() {
-  return new FluxError("Cannot remove root object", "CANNOT_REMOVE_ROOT" /* CANNOT_REMOVE_ROOT */);
-}
+
+
+
+
+
+
+
+var _chunkOAJWPPYGcjs = require('./chunk-OAJWPPYG.cjs');
 
 // src/builder/WorkflowBuilder.ts
 var WorkflowBuilder = (_class = class {
@@ -244,7 +144,7 @@ var WorkflowBuilder = (_class = class {
    */
   build() {
     if (this._steps.length === 0) {
-      throw emptyWorkflow(this._name);
+      throw _chunkOAJWPPYGcjs.emptyWorkflow.call(void 0, this._name);
     }
     return {
       name: this._name,
@@ -713,7 +613,7 @@ var StateMachine = (_class3 = class extends EventTarget {constructor(...args2) {
    */
   transition(to) {
     if (!this.canTransition(to)) {
-      throw invalidStateTransition(this._status, to);
+      throw _chunkOAJWPPYGcjs.invalidStateTransition.call(void 0, this._status, to);
     }
     const from = this._status;
     this._status = to;
@@ -1522,14 +1422,14 @@ function resolveDefinition(workflow) {
 function resolveStartIndex(definition, fromStep, fallback) {
   if (typeof fromStep === "number") {
     if (fromStep < 0 || fromStep >= definition.steps.length) {
-      throw invalidStepIndex(fromStep);
+      throw _chunkOAJWPPYGcjs.invalidStepIndex.call(void 0, fromStep);
     }
     return fromStep;
   }
   if (typeof fromStep === "string") {
     const index = definition.steps.findIndex((step) => step.name === fromStep);
     if (index === -1) {
-      throw stepNotFound(fromStep);
+      throw _chunkOAJWPPYGcjs.stepNotFound.call(void 0, fromStep);
     }
     return index;
   }
@@ -1544,7 +1444,11 @@ function resetHistoryFrom(ctx, startIndex) {
     entry.status = "pending";
     entry.startedAt = void 0;
     entry.completedAt = void 0;
+    entry.suspendedAt = void 0;
+    entry.compensatedAt = void 0;
+    entry.waitingFor = void 0;
     entry.duration = void 0;
+    entry.output = void 0;
     entry.error = void 0;
     entry.retries = 0;
   }
@@ -1581,7 +1485,7 @@ async function persistContext(ctx, storage, contextManager, definitionVersion) {
   const state = contextManager.toState(ctx);
   const stored = await storage.load(state.id);
   if (stored && stored.version !== state.version) {
-    throw new FluxError(
+    throw new (0, _chunkOAJWPPYGcjs.FluxError)(
       "Concurrent modification detected",
       "CONCURRENT_MODIFICATION" /* CONCURRENT_MODIFICATION */
     );
@@ -1856,7 +1760,7 @@ var RecoveryManager = (_class6 = class {constructor() { _class6.prototype.__init
   async executeRecovery(stepName) {
     const action = this.actions.get(stepName);
     if (!action) {
-      throw noRecoveryAction(stepName);
+      throw _chunkOAJWPPYGcjs.noRecoveryAction.call(void 0, stepName);
     }
     if (action.type === "manual") {
       await action.handler();
@@ -1954,6 +1858,7 @@ var RollbackManager = class {
       error: originalError.message
     });
     let compensatedCount = 0;
+    let skippedCount = 0;
     for (let i = failedAtIndex - 1; i >= 0; i--) {
       const step = definition.steps[i];
       let execution = currentCtx.history[i];
@@ -1988,11 +1893,36 @@ var RollbackManager = class {
       } catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
         const action = this.recoveryManager.getAction(step.name);
-        if (_optionalChain([action, 'optionalAccess', _58 => _58.type]) === "skip") {
+        if (_optionalChain([action, 'optionalAccess', _58 => _58.type]) === "retry") {
+          const retryResult = await new CompensationRetryPolicy({
+            ...this.retryPolicy.getConfig(),
+            maxAttempts: _nullishCoalesce(action.maxAttempts, () => ( this.retryPolicy.getConfig().maxAttempts))
+          }).execute(async () => {
+            await _optionalChain([step, 'access', _59 => _59.compensate, 'optionalCall', _60 => _60(currentCtx)]);
+          });
+          if (retryResult.success) {
+            execution = { ...execution, status: "compensated", compensatedAt: /* @__PURE__ */ new Date() };
+            currentCtx = updateWorkflowContext(currentCtx, {
+              history: currentCtx.history.map((h, idx) => idx === i ? execution : h)
+            });
+            compensatedCount++;
+            await this.traceEmitter.stepCompensate(currentCtx, step.name, i);
+            currentCtx = await this.persist(currentCtx);
+            continue;
+          }
+        }
+        if (_optionalChain([action, 'optionalAccess', _61 => _61.type]) === "skip") {
+          execution = { ...execution, status: "completed", error: error.message };
+          currentCtx = updateWorkflowContext(currentCtx, {
+            history: currentCtx.history.map((h, idx) => idx === i ? execution : h)
+          });
+          currentCtx = await this.persist(currentCtx);
+          skippedCount++;
           continue;
         }
-        if (_optionalChain([action, 'optionalAccess', _59 => _59.type]) === "abort") {
+        if (_optionalChain([action, 'optionalAccess', _62 => _62.type]) === "abort") {
           currentCtx = updateWorkflowContext(currentCtx, { status: "compensation_failed" });
+          currentCtx = await this.persist(currentCtx);
           await this.traceEmitter.emit({
             type: "workflow:error",
             timestamp: Date.now(),
@@ -2005,6 +1935,7 @@ var RollbackManager = class {
         }
         await this.recoveryManager.notifyRecoveryNeeded(currentCtx, step.name, error);
         currentCtx = updateWorkflowContext(currentCtx, { status: "compensation_failed" });
+        currentCtx = await this.persist(currentCtx);
         await this.traceEmitter.emit({
           type: "workflow:error",
           timestamp: Date.now(),
@@ -2017,7 +1948,7 @@ var RollbackManager = class {
       }
       currentCtx = await this.persist(currentCtx);
     }
-    if (compensatedCount > 0) {
+    if (compensatedCount > 0 || skippedCount > 0) {
       currentCtx = updateWorkflowContext(currentCtx, { status: "rolled_back" });
       await this.traceEmitter.emit({
         type: "workflow:rollback_complete",
@@ -2083,7 +2014,7 @@ var TraceEmitter = class {
    */
   async emit(event) {
     try {
-      await _optionalChain([this, 'access', _60 => _60.traceSink, 'optionalAccess', _61 => _61.emit, 'call', _62 => _62(event)]);
+      await _optionalChain([this, 'access', _63 => _63.traceSink, 'optionalAccess', _64 => _64.emit, 'call', _65 => _65(event)]);
     } catch (e3) {
     }
   }
@@ -2194,7 +2125,7 @@ var TraceEmitter = class {
       stepName,
       stepIndex,
       duration: result.duration,
-      error: _optionalChain([result, 'access', _63 => _63.error, 'optionalAccess', _64 => _64.message]),
+      error: _optionalChain([result, 'access', _66 => _66.error, 'optionalAccess', _67 => _67.message]),
       status: "failed"
     });
   }
@@ -2351,7 +2282,7 @@ var WorkflowExecutor = class {
         stateMachine.transition("running");
         currentCtx = updateWorkflowContext(currentCtx, { status: "running" });
       }
-      if (!_optionalChain([meta, 'optionalAccess', _65 => _65.resume]) && !_optionalChain([meta, 'optionalAccess', _66 => _66.retry])) {
+      if (!_optionalChain([meta, 'optionalAccess', _68 => _68.resume]) && !_optionalChain([meta, 'optionalAccess', _69 => _69.retry])) {
         await this.traceEmitter.workflowStart(currentCtx);
       }
       for (let i = startIndex; i < definition.steps.length; ) {
@@ -2388,7 +2319,7 @@ var WorkflowExecutor = class {
       stateMachine.transition("completed");
       currentCtx = updateWorkflowContext(currentCtx, { status: "completed" });
       currentCtx = await this.persist(currentCtx);
-      _optionalChain([this, 'access', _67 => _67.config, 'access', _68 => _68.on, 'optionalAccess', _69 => _69.workflowComplete, 'optionalCall', _70 => _70(currentCtx)]);
+      _optionalChain([this, 'access', _70 => _70.config, 'access', _71 => _71.on, 'optionalAccess', _72 => _72.workflowComplete, 'optionalCall', _73 => _73(currentCtx)]);
       await this.traceEmitter.workflowComplete(currentCtx, Date.now() - startTime);
       return {
         id: currentCtx.id,
@@ -2407,7 +2338,7 @@ var WorkflowExecutor = class {
       stateMachine.forceStatus("failed");
       currentCtx = updateWorkflowContext(currentCtx, { status: "failed" });
       currentCtx = await this.persist(currentCtx);
-      _optionalChain([this, 'access', _71 => _71.config, 'access', _72 => _72.on, 'optionalAccess', _73 => _73.workflowError, 'optionalCall', _74 => _74(currentCtx, err)]);
+      _optionalChain([this, 'access', _74 => _74.config, 'access', _75 => _75.on, 'optionalAccess', _76 => _76.workflowError, 'optionalCall', _77 => _77(currentCtx, err)]);
       await this.traceEmitter.workflowError(currentCtx, err, Date.now() - startTime);
       return {
         id: currentCtx.id,
@@ -2431,7 +2362,7 @@ var WorkflowExecutor = class {
     currentCtx = this.contextManager.setStepName(currentCtx, index, step.name);
     execution = currentCtx.history[index];
     currentCtx = updateWorkflowContext(currentCtx, { currentStep: index });
-    _optionalChain([this, 'access', _75 => _75.config, 'access', _76 => _76.on, 'optionalAccess', _77 => _77.stepStart, 'optionalCall', _78 => _78(step.name, currentCtx)]);
+    _optionalChain([this, 'access', _78 => _78.config, 'access', _79 => _79.on, 'optionalAccess', _80 => _80.stepStart, 'optionalCall', _81 => _81(step.name, currentCtx)]);
     await this.traceEmitter.stepStart(currentCtx, step.name, index, Boolean(step.commit));
     const { result, execution: updatedExecution } = await this.stepExecutor.execute(
       step,
@@ -2457,7 +2388,7 @@ var WorkflowExecutor = class {
         };
         return { updatedCtx: currentCtx, shouldReturn: true, result: suspendedResult };
       }
-      _optionalChain([this, 'access', _79 => _79.config, 'access', _80 => _80.on, 'optionalAccess', _81 => _81.stepComplete, 'optionalCall', _82 => _82(step.name, currentCtx, result)]);
+      _optionalChain([this, 'access', _82 => _82.config, 'access', _83 => _83.on, 'optionalAccess', _84 => _84.stepComplete, 'optionalCall', _85 => _85(step.name, currentCtx, result)]);
       await this.traceEmitter.stepComplete(currentCtx, step.name, index, result);
     } else {
       await this.traceEmitter.stepError(currentCtx, step.name, index, result);
@@ -2490,14 +2421,14 @@ var WorkflowExecutor = class {
         break;
       }
     }
-    const lastIndex = _optionalChain([groupSteps, 'access', _83 => _83[groupSteps.length - 1], 'optionalAccess', _84 => _84.index]);
+    const lastIndex = _optionalChain([groupSteps, 'access', _86 => _86[groupSteps.length - 1], 'optionalAccess', _87 => _87.index]);
     let currentCtx = ctx;
     const executeStepWrapper = async (step, stepCtx) => {
-      const stepIndex = _optionalChain([groupSteps, 'access', _85 => _85.find, 'call', _86 => _86((gs) => gs.step === step), 'optionalAccess', _87 => _87.index]);
+      const stepIndex = _optionalChain([groupSteps, 'access', _88 => _88.find, 'call', _89 => _89((gs) => gs.step === step), 'optionalAccess', _90 => _90.index]);
       let execution = stepCtx.history[stepIndex];
       const localCtx = this.contextManager.setStepName(stepCtx, stepIndex, step.name);
       execution = localCtx.history[stepIndex];
-      _optionalChain([this, 'access', _88 => _88.config, 'access', _89 => _89.on, 'optionalAccess', _90 => _90.stepStart, 'optionalCall', _91 => _91(step.name, localCtx)]);
+      _optionalChain([this, 'access', _91 => _91.config, 'access', _92 => _92.on, 'optionalAccess', _93 => _93.stepStart, 'optionalCall', _94 => _94(step.name, localCtx)]);
       await this.traceEmitter.stepStart(localCtx, step.name, stepIndex, Boolean(step.commit));
       const { result, execution: updatedExecution } = await this.stepExecutor.execute(
         step,
@@ -2505,7 +2436,7 @@ var WorkflowExecutor = class {
         execution
       );
       if (result.success) {
-        _optionalChain([this, 'access', _92 => _92.config, 'access', _93 => _93.on, 'optionalAccess', _94 => _94.stepComplete, 'optionalCall', _95 => _95(step.name, localCtx, result)]);
+        _optionalChain([this, 'access', _95 => _95.config, 'access', _96 => _96.on, 'optionalAccess', _97 => _97.stepComplete, 'optionalCall', _98 => _98(step.name, localCtx, result)]);
         await this.traceEmitter.stepComplete(localCtx, step.name, stepIndex, result);
       } else {
         await this.traceEmitter.stepError(localCtx, step.name, stepIndex, result);
@@ -2520,13 +2451,13 @@ var WorkflowExecutor = class {
         executeStepWrapper
       );
       for (const execution of parallelResult.successes) {
-        const stepIndex = _optionalChain([groupSteps, 'access', _96 => _96.find, 'call', _97 => _97((gs) => gs.step.name === execution.name), 'optionalAccess', _98 => _98.index]);
+        const stepIndex = _optionalChain([groupSteps, 'access', _99 => _99.find, 'call', _100 => _100((gs) => gs.step.name === execution.name), 'optionalAccess', _101 => _101.index]);
         currentCtx = updateWorkflowContext(currentCtx, {
           history: currentCtx.history.map((h, idx) => idx === stepIndex ? execution : h)
         });
       }
       for (const failure of parallelResult.failures) {
-        const stepIndex = _optionalChain([groupSteps, 'access', _99 => _99.find, 'call', _100 => _100((gs) => gs.step.name === failure.step.name), 'optionalAccess', _101 => _101.index]);
+        const stepIndex = _optionalChain([groupSteps, 'access', _102 => _102.find, 'call', _103 => _103((gs) => gs.step.name === failure.step.name), 'optionalAccess', _104 => _104.index]);
         currentCtx = updateWorkflowContext(currentCtx, {
           history: currentCtx.history.map((h, idx) => idx === stepIndex ? failure.execution : h)
         });
@@ -2591,7 +2522,7 @@ var FluxEngine = class {
     this.storage = _nullishCoalesce(config.storage, () => ( new MemoryStorage()));
     this.contextManager = new ContextManager();
     this.traceEmitter = new TraceEmitter(config.trace);
-    if (_optionalChain([config, 'access', _102 => _102.optimizer, 'optionalAccess', _103 => _103.enabled])) {
+    if (_optionalChain([config, 'access', _105 => _105.optimizer, 'optionalAccess', _106 => _106.enabled])) {
       this.dataOptimizer = new DataOptimizer({
         threshold: config.optimizer.threshold,
         defaultLocation: config.optimizer.defaultLocation
@@ -2626,7 +2557,7 @@ var FluxEngine = class {
   async execute(workflow, input) {
     const definition = resolveDefinition(workflow);
     if (definition.validateInput && !definition.validateInput(input)) {
-      throw invalidInput(definition.name);
+      throw _chunkOAJWPPYGcjs.invalidInput.call(void 0, definition.name);
     }
     let ctx = this.contextManager.create(
       definition.name,
@@ -2660,7 +2591,7 @@ var FluxEngine = class {
         this.storage
       );
     } finally {
-      await _optionalChain([lock, 'optionalAccess', _104 => _104.release, 'call', _105 => _105()]);
+      await _optionalChain([lock, 'optionalAccess', _107 => _107.release, 'call', _108 => _108()]);
     }
   }
   async resume(workflow, workflowId, options) {
@@ -2670,20 +2601,20 @@ var FluxEngine = class {
       if (!state) {
         return null;
       }
-      throw workflowNameMismatch(definition.name, state.name);
+      throw _chunkOAJWPPYGcjs.workflowNameMismatch.call(void 0, definition.name, state.name);
     }
     if (state.history.length !== definition.steps.length) {
-      throw workflowDefinitionChanged();
+      throw _chunkOAJWPPYGcjs.workflowDefinitionChanged.call(void 0, );
     }
     if (state.definitionVersion && definition.version && state.definitionVersion !== definition.version) {
-      _optionalChain([this, 'access', _106 => _106.config, 'access', _107 => _107.logger, 'optionalAccess', _108 => _108.warn, 'call', _109 => _109(
+      _optionalChain([this, 'access', _109 => _109.config, 'access', _110 => _110.logger, 'optionalAccess', _111 => _111.warn, 'call', _112 => _112(
         `Workflow version mismatch: instance was created with v${state.definitionVersion}, but current definition is v${definition.version}. Continuing execution.`
       )]);
     }
     let ctx = this.contextManager.restore(
       state
     );
-    const startIndex = resolveStartIndex(definition, _optionalChain([options, 'optionalAccess', _110 => _110.fromStep]), ctx.currentStep);
+    const startIndex = resolveStartIndex(definition, _optionalChain([options, 'optionalAccess', _113 => _113.fromStep]), ctx.currentStep);
     resetHistoryFrom(ctx, startIndex);
     ctx = updateWorkflowContext(ctx, { status: "pending", currentStep: startIndex });
     ctx = await this.persist(ctx);
@@ -2693,10 +2624,10 @@ var FluxEngine = class {
     const definition = resolveDefinition(workflow);
     const state = await this.storage.load(workflowId);
     if (!state) {
-      throw workflowNotFound(workflowId);
+      throw _chunkOAJWPPYGcjs.workflowNotFound.call(void 0, workflowId);
     }
     if (state.status !== "suspended") {
-      throw workflowNotSuspended(state.status);
+      throw _chunkOAJWPPYGcjs.workflowNotSuspended.call(void 0, state.status);
     }
     let ctx = this.contextManager.restore(
       state
@@ -2704,15 +2635,22 @@ var FluxEngine = class {
     const idx = ctx.currentStep;
     const exec = ctx.history[idx];
     if (!exec || exec.status !== "suspended" || exec.waitingFor !== signalName) {
-      const isSuspended = _optionalChain([exec, 'optionalAccess', _111 => _111.status]) === "suspended";
-      throw new FluxError(
+      const isSuspended = _optionalChain([exec, 'optionalAccess', _114 => _114.status]) === "suspended";
+      throw new (0, _chunkOAJWPPYGcjs.FluxError)(
         isSuspended ? `Workflow waiting for signal "${exec.waitingFor}", received "${signalName}"` : "Workflow state invalid: no suspended step found",
         isSuspended ? "INVALID_STATE_TRANSITION" /* INVALID_STATE_TRANSITION */ : "STEP_NOT_FOUND" /* STEP_NOT_FOUND */
       );
     }
     ctx = updateWorkflowContext(ctx, {
       history: ctx.history.map(
-        (h, i) => i === idx ? { ...h, status: "completed", completedAt: /* @__PURE__ */ new Date(), output: payload } : h
+        (h, i) => i === idx ? {
+          ...h,
+          status: "completed",
+          completedAt: /* @__PURE__ */ new Date(),
+          suspendedAt: void 0,
+          waitingFor: void 0,
+          output: payload
+        } : h
       )
     });
     await this.traceEmitter.emit({
@@ -2732,10 +2670,10 @@ var FluxEngine = class {
       if (!state) {
         return null;
       }
-      throw workflowNameMismatch(definition.name, state.name);
+      throw _chunkOAJWPPYGcjs.workflowNameMismatch.call(void 0, definition.name, state.name);
     }
     if (state.history.length !== definition.steps.length) {
-      throw workflowDefinitionChanged();
+      throw _chunkOAJWPPYGcjs.workflowDefinitionChanged.call(void 0, );
     }
     let ctx = this.contextManager.restore(
       state
@@ -2758,7 +2696,7 @@ var FluxEngine = class {
   async saveState(state) {
     const stored = await this.storage.load(state.id);
     if (stored && stored.version !== state.version) {
-      throw new FluxError(
+      throw new (0, _chunkOAJWPPYGcjs.FluxError)(
         "Concurrent modification detected",
         "CONCURRENT_MODIFICATION" /* CONCURRENT_MODIFICATION */
       );
@@ -2803,7 +2741,7 @@ var FluxEngine = class {
    * Initializes the engine and its underlying storage, and starts the scheduler.
    */
   async init() {
-    await _optionalChain([this, 'access', _112 => _112.storage, 'access', _113 => _113.init, 'optionalCall', _114 => _114()]);
+    await _optionalChain([this, 'access', _115 => _115.storage, 'access', _116 => _116.init, 'optionalCall', _117 => _117()]);
     this.cronTrigger.start();
   }
   /**
@@ -2811,7 +2749,7 @@ var FluxEngine = class {
    */
   async close() {
     this.cronTrigger.stop();
-    await _optionalChain([this, 'access', _115 => _115.storage, 'access', _116 => _116.close, 'optionalCall', _117 => _117()]);
+    await _optionalChain([this, 'access', _118 => _118.storage, 'access', _119 => _119.close, 'optionalCall', _120 => _120()]);
   }
   async persist(ctx, definitionVersion) {
     return persistContext(ctx, this.storage, this.contextManager, definitionVersion);
@@ -2831,7 +2769,7 @@ var PostgreSQLStorage = (_class7 = class {
    */
   constructor(options = {}) {;_class7.prototype.__init13.call(this);
     this.options = options;
-    this.tableName = _nullishCoalesce(options.tableName, () => ( "flux_workflows"));
+    this.tableName = validateSqlIdentifier(_nullishCoalesce(options.tableName, () => ( "flux_workflows")), "tableName");
   }
   /**
    * Initializes the database connection pool and schema.
@@ -2960,11 +2898,11 @@ var PostgreSQLStorage = (_class7 = class {
     let query = `SELECT * FROM ${this.tableName} WHERE 1=1`;
     const params = [];
     let paramIndex = 1;
-    if (_optionalChain([filter, 'optionalAccess', _118 => _118.name])) {
+    if (_optionalChain([filter, 'optionalAccess', _121 => _121.name])) {
       query += ` AND name = $${paramIndex++}`;
       params.push(filter.name);
     }
-    if (_optionalChain([filter, 'optionalAccess', _119 => _119.status])) {
+    if (_optionalChain([filter, 'optionalAccess', _122 => _122.status])) {
       if (Array.isArray(filter.status)) {
         const placeholders = filter.status.map(() => `$${paramIndex++}`).join(", ");
         query += ` AND status IN (${placeholders})`;
@@ -2974,16 +2912,16 @@ var PostgreSQLStorage = (_class7 = class {
         params.push(filter.status);
       }
     }
-    if (_optionalChain([filter, 'optionalAccess', _120 => _120.version])) {
+    if (_optionalChain([filter, 'optionalAccess', _123 => _123.version])) {
       query += ` AND definition_version = $${paramIndex++}`;
       params.push(filter.version);
     }
     query += " ORDER BY created_at DESC";
-    if (_optionalChain([filter, 'optionalAccess', _121 => _121.limit])) {
+    if (_optionalChain([filter, 'optionalAccess', _124 => _124.limit])) {
       query += ` LIMIT $${paramIndex++}`;
       params.push(filter.limit);
     }
-    if (_optionalChain([filter, 'optionalAccess', _122 => _122.offset])) {
+    if (_optionalChain([filter, 'optionalAccess', _125 => _125.offset])) {
       query += ` OFFSET $${paramIndex++}`;
       params.push(filter.offset);
     }
@@ -3056,20 +2994,36 @@ var PostgreSQLStorage = (_class7 = class {
     await this.pool.query("VACUUM ANALYZE");
   }
 }, _class7);
+function validateSqlIdentifier(value, field) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new (0, _chunkOAJWPPYGcjs.FluxError)(
+      `Invalid ${field}: "${value}". Only letters, numbers, and underscores are allowed.`,
+      "WORKFLOW_INVALID_INPUT" /* WORKFLOW_INVALID_INPUT */,
+      { field, value }
+    );
+  }
+  return value;
+}
 
 // src/trace/JsonFileTraceSink.ts
 var _promises = require('fs/promises');
 var _path = require('path');
-var JsonFileTraceSink = class {
+var _core = require('@gravito/core');
+var JsonFileTraceSink = (_class8 = class {
   
   
+  __init14() {this.fileSink = null}
+  __init15() {this.buffer = []}
+  
+  __init16() {this.adapter = _core.getDefaultRuntimeAdapter.call(void 0, )}
   /**
-   * Creates a new JSON file trace sink.
+   * Creates a new JSON file trace sink with buffering support.
    *
    * @param options - Configuration options for the sink.
    */
-  constructor(options) {
+  constructor(options) {;_class8.prototype.__init14.call(this);_class8.prototype.__init15.call(this);_class8.prototype.__init16.call(this);
     this.path = options.path;
+    this.bufferSize = _nullishCoalesce(options.bufferSize, () => ( 50));
     this.ready = this.init(_nullishCoalesce(options.reset, () => ( true)));
   }
   /**
@@ -3080,14 +3034,22 @@ var JsonFileTraceSink = class {
    */
   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");
+    if (this.adapter.createFileSink) {
+      this.fileSink = await _optionalChain([this, 'access', _126 => _126.adapter, 'access', _127 => _127.createFileSink, 'optionalCall', _128 => _128(this.path)]);
+    }
+    if (reset && !this.fileSink) {
+      if (this.adapter.writeFile) {
+        await this.adapter.writeFile(this.path, "");
+      }
+    } else if (reset && this.fileSink) {
+      this.fileSink.write("");
     }
   }
   /**
    * Appends a trace event to the file in NDJSON format.
    *
-   * Waits for initialization to complete before writing.
+   * Events are buffered and written in batches using FileSink
+   * for improved I/O efficiency. Waits for initialization to complete before writing.
    *
    * @param event - The trace event to record.
    * @throws {Error} If writing to the file fails.
@@ -3104,14 +3066,54 @@ var JsonFileTraceSink = class {
    */
   async emit(event) {
     await this.ready;
-    await _promises.appendFile.call(void 0, this.path, `${JSON.stringify(event)}
-`, "utf8");
+    const eventLine = `${JSON.stringify(event)}
+`;
+    if (this.fileSink) {
+      this.buffer.push(eventLine);
+      if (this.buffer.length >= this.bufferSize) {
+        await this.flushBuffer();
+      }
+    } else {
+      if (this.adapter.appendFile) {
+        await this.adapter.appendFile(this.path, eventLine);
+      }
+    }
   }
-};
+  /**
+   * Flushes buffered events to disk.
+   *
+   * This is called automatically when the buffer reaches the configured size.
+   * Can also be called manually to ensure all events are written.
+   *
+   * @throws {Error} If flushing fails.
+   */
+  async flushBuffer() {
+    if (!this.fileSink || this.buffer.length === 0) {
+      return;
+    }
+    const content = this.buffer.join("");
+    this.fileSink.write(content);
+    this.buffer = [];
+    await this.fileSink.flush();
+  }
+  /**
+   * Closes the sink and flushes any remaining buffered events.
+   *
+   * Should be called before process exit to ensure all events are persisted.
+   *
+   * @throws {Error} If closing or flushing fails.
+   */
+  async close() {
+    await this.flushBuffer();
+    if (this.fileSink) {
+      await this.fileSink.end();
+    }
+  }
+}, _class8);
 
 // src/core/LockProvider.ts
-var MemoryLockProvider = (_class8 = class {constructor() { _class8.prototype.__init14.call(this); }
-  __init14() {this.locks = /* @__PURE__ */ new Map()}
+var MemoryLockProvider = (_class9 = class {constructor() { _class9.prototype.__init17.call(this); }
+  __init17() {this.locks = /* @__PURE__ */ new Map()}
   async acquire(resourceId, owner, ttl) {
     const now = Date.now();
     const existing = this.locks.get(resourceId);
@@ -3146,7 +3148,7 @@ var MemoryLockProvider = (_class8 = class {constructor() { _class8.prototype.__i
       release: () => this.release(id)
     };
   }
-}, _class8);
+}, _class9);
 
 // src/core/RedisLockProvider.ts
 var RELEASE_LOCK_SCRIPT = `
@@ -3384,7 +3386,7 @@ var OrbitFlux = class _OrbitFlux {
     if (typeof storage === "string") {
       switch (storage) {
         case "sqlite":
-          storageAdapter = new (0, _chunkYXBEYVGYcjs.BunSQLiteStorage)({ path: dbPath });
+          storageAdapter = new (0, _chunkOAJWPPYGcjs.BunSQLiteStorage)({ path: dbPath });
           break;
         default:
           storageAdapter = new MemoryStorage();
@@ -3392,7 +3394,7 @@ var OrbitFlux = class _OrbitFlux {
     } else {
       storageAdapter = storage;
     }
-    await _optionalChain([storageAdapter, 'access', _123 => _123.init, 'optionalCall', _124 => _124()]);
+    await _optionalChain([storageAdapter, 'access', _129 => _129.init, 'optionalCall', _130 => _130()]);
     const engineConfig = {
       storage: storageAdapter,
       defaultRetries,
@@ -3423,6 +3425,16 @@ var OrbitFlux = class _OrbitFlux {
     };
     this.engine = new FluxEngine(engineConfig);
     core.container.instance(exposeAs, this.engine);
+    const health = core.container.make("health");
+    if (health) {
+      const engine = this.engine;
+      health.register("flux", async () => ({
+        status: engine ? "healthy" : "unhealthy",
+        details: {
+          storage: typeof storage === "string" ? storage : "custom"
+        }
+      }));
+    }
     core.logger.info(
       `[OrbitFlux] Initialized (Storage: ${typeof storage === "string" ? storage : "custom"})`
     );
@@ -3466,21 +3478,5 @@ var OrbitFlux = class _OrbitFlux {
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.FluxErrorCode = FluxErrorCode; exports.FluxError = FluxError; exports.workflowNotFound = workflowNotFound; exports.invalidStateTransition = invalidStateTransition; exports.invalidInput = invalidInput; exports.workflowNameMismatch = workflowNameMismatch; exports.workflowDefinitionChanged = workflowDefinitionChanged; exports.workflowNotSuspended = workflowNotSuspended; exports.stepNotFound = stepNotFound; exports.invalidStepIndex = invalidStepIndex; exports.emptyWorkflow = emptyWorkflow; exports.noRecoveryAction = noRecoveryAction; exports.invalidJsonPointer = invalidJsonPointer; exports.invalidPathTraversal = invalidPathTraversal; exports.cannotReplaceRoot = cannotReplaceRoot; exports.cannotRemoveRoot = cannotRemoveRoot; exports.WorkflowBuilder = WorkflowBuilder; exports.createWorkflow = createWorkflow; exports.BatchExecutor = BatchExecutor; exports.ContextManager = ContextManager; exports.StateMachine = StateMachine; exports.CronTrigger = CronTrigger; exports.MemoryStorage = MemoryStorage; exports.StepExecutor = StepExecutor; exports.FluxEngine = FluxEngine; exports.PostgreSQLStorage = PostgreSQLStorage; exports.JsonFileTraceSink = JsonFileTraceSink; exports.MemoryLockProvider = MemoryLockProvider; exports.RedisLockProvider = RedisLockProvider; exports.FluxConsoleLogger = FluxConsoleLogger; exports.FluxSilentLogger = FluxSilentLogger; exports.OrbitFlux = OrbitFlux;
-//# sourceMappingURL=chunk-WAPZDXSX.cjs.map
+exports.WorkflowBuilder = WorkflowBuilder; exports.createWorkflow = createWorkflow; exports.BatchExecutor = BatchExecutor; exports.ContextManager = ContextManager; exports.StateMachine = StateMachine; exports.CronTrigger = CronTrigger; exports.MemoryStorage = MemoryStorage; exports.StepExecutor = StepExecutor; exports.FluxEngine = FluxEngine; exports.PostgreSQLStorage = PostgreSQLStorage; exports.JsonFileTraceSink = JsonFileTraceSink; exports.MemoryLockProvider = MemoryLockProvider; exports.RedisLockProvider = RedisLockProvider; exports.FluxConsoleLogger = FluxConsoleLogger; exports.FluxSilentLogger = FluxSilentLogger; exports.OrbitFlux = OrbitFlux;
+//# sourceMappingURL=chunk-AVWZYY7U.cjs.map