@gravito/flux 3.0.2 → 3.0.3

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

@@ -1,6 +1,6 @@
-"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');
+var _chunkZE2RDS47cjs = require('./chunk-ZE2RDS47.cjs');
 
 // src/errors.ts
 var FluxErrorCode = /* @__PURE__ */ ((FluxErrorCode2) => {
@@ -1544,7 +1544,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;
   }
@@ -1954,6 +1958,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 +1993,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 +2035,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 +2048,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 +2114,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 +2225,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 +2382,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 +2419,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 +2438,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 +2462,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 +2488,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 +2521,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 +2536,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 +2551,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 +2622,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
@@ -2660,7 +2691,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) {
@@ -2676,14 +2707,14 @@ var FluxEngine = class {
       throw workflowDefinitionChanged();
     }
     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);
@@ -2704,7 +2735,7 @@ 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";
+      const isSuspended = _optionalChain([exec, 'optionalAccess', _114 => _114.status]) === "suspended";
       throw new 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 */
@@ -2712,7 +2743,14 @@ var FluxEngine = class {
     }
     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({
@@ -2803,7 +2841,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 +2849,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 +2869,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 +2998,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 +3012,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 +3094,34 @@ 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 Error(
+      `Invalid ${field}: "${value}". Only letters, numbers, and underscores are allowed.`
+    );
+  }
+  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 +3132,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 +3164,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 +3246,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 +3484,7 @@ var OrbitFlux = class _OrbitFlux {
     if (typeof storage === "string") {
       switch (storage) {
         case "sqlite":
-          storageAdapter = new (0, _chunkYXBEYVGYcjs.BunSQLiteStorage)({ path: dbPath });
+          storageAdapter = new (0, _chunkZE2RDS47cjs.BunSQLiteStorage)({ path: dbPath });
           break;
         default:
           storageAdapter = new MemoryStorage();
@@ -3392,7 +3492,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,
@@ -3483,4 +3583,4 @@ 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
+//# sourceMappingURL=chunk-DN7SIQ34.cjs.map