@rivetkit/workflow-engine 0.0.0-sqlite-profiling-compat.87d61c0 → 0.0.0-sqlite-sync-3x-release.a00b07f

package/dist/schemas/v1.ts

@@ -446,6 +446,23 @@ export function writeRemovedEntry(bc: bare.ByteCursor, x: RemovedEntry): void {
     write1(bc, x.originalName)
 }
 
+export type VersionCheckEntry = {
+    readonly resolved: u32,
+    readonly latest: u32,
+}
+
+export function readVersionCheckEntry(bc: bare.ByteCursor): VersionCheckEntry {
+    return {
+        resolved: bare.readU32(bc),
+        latest: bare.readU32(bc),
+    }
+}
+
+export function writeVersionCheckEntry(bc: bare.ByteCursor, x: VersionCheckEntry): void {
+    bare.writeU32(bc, x.resolved)
+    bare.writeU32(bc, x.latest)
+}
+
 export type EntryKind =
     | { readonly tag: "StepEntry", readonly val: StepEntry }
     | { readonly tag: "LoopEntry", readonly val: LoopEntry }
@@ -455,6 +472,7 @@ export type EntryKind =
     | { readonly tag: "JoinEntry", readonly val: JoinEntry }
     | { readonly tag: "RaceEntry", readonly val: RaceEntry }
     | { readonly tag: "RemovedEntry", readonly val: RemovedEntry }
+    | { readonly tag: "VersionCheckEntry", readonly val: VersionCheckEntry }
 
 export function readEntryKind(bc: bare.ByteCursor): EntryKind {
     const offset = bc.offset
@@ -476,6 +494,8 @@ export function readEntryKind(bc: bare.ByteCursor): EntryKind {
             return { tag: "RaceEntry", val: readRaceEntry(bc) }
         case 7:
             return { tag: "RemovedEntry", val: readRemovedEntry(bc) }
+        case 8:
+            return { tag: "VersionCheckEntry", val: readVersionCheckEntry(bc) }
         default: {
             bc.offset = offset
             throw new bare.BareError(offset, "invalid tag")
@@ -525,6 +545,11 @@ export function writeEntryKind(bc: bare.ByteCursor, x: EntryKind): void {
             writeRemovedEntry(bc, x.val)
             break
         }
+        case "VersionCheckEntry": {
+            bare.writeU8(bc, 8)
+            writeVersionCheckEntry(bc, x.val)
+            break
+        }
     }
 }
 

package/dist/tsup/{chunk-KA2T56AJ.js → chunk-AAAPEYGX.js}

@@ -163,6 +163,7 @@ var KEY_PREFIX = {
   // Workflow metadata: [3, field]
   ENTRY_METADATA: 4
   // Entry metadata: [4, entryId]
+  // 5 is reserved for RivetKit's workflow trace context.
 };
 var WORKFLOW_FIELD = {
   STATE: 1,
@@ -670,6 +671,16 @@ function writeRemovedEntry(bc, x) {
   bare.writeString(bc, x.originalType);
   write1(bc, x.originalName);
 }
+function readVersionCheckEntry(bc) {
+  return {
+    resolved: bare.readU32(bc),
+    latest: bare.readU32(bc)
+  };
+}
+function writeVersionCheckEntry(bc, x) {
+  bare.writeU32(bc, x.resolved);
+  bare.writeU32(bc, x.latest);
+}
 function readEntryKind(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -690,6 +701,8 @@ function readEntryKind(bc) {
       return { tag: "RaceEntry", val: readRaceEntry(bc) };
     case 7:
       return { tag: "RemovedEntry", val: readRemovedEntry(bc) };
+    case 8:
+      return { tag: "VersionCheckEntry", val: readVersionCheckEntry(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -738,6 +751,11 @@ function writeEntryKind(bc, x) {
       writeRemovedEntry(bc, x.val);
       break;
     }
+    case "VersionCheckEntry": {
+      bare.writeU8(bc, 8);
+      writeVersionCheckEntry(bc, x.val);
+      break;
+    }
   }
 }
 function readEntry(bc) {
@@ -1182,6 +1200,14 @@ function entryKindToBare(kind) {
           originalName: kind.data.originalName ?? null
         }
       };
+    case "version_check":
+      return {
+        tag: "VersionCheckEntry",
+        val: {
+          resolved: kind.data.resolved,
+          latest: kind.data.latest
+        }
+      };
   }
 }
 function entryKindFromBare(kind) {
@@ -1263,6 +1289,14 @@ function entryKindFromBare(kind) {
           originalName: kind.val.originalName ?? void 0
         }
       };
+    case "VersionCheckEntry":
+      return {
+        type: "version_check",
+        data: {
+          resolved: kind.val.resolved,
+          latest: kind.val.latest
+        }
+      };
     default:
       throw new Error(
         `Unknown entry kind: ${kind.tag}`
@@ -1404,6 +1438,7 @@ function deserializeName(bytes) {
 // src/storage.ts
 var MAX_KV_BATCH_ENTRIES = 128;
 var MAX_KV_BATCH_PAYLOAD_BYTES = 976 * 1024;
+var MAX_CONCURRENT_DELETES = 64;
 function createStorage() {
   return {
     nameRegistry: [],
@@ -1574,23 +1609,17 @@ async function flush(storage, driver, onHistoryUpdated, pendingDeletions) {
     });
   }
   if (writes.length > 0) {
-    for (const chunk of splitBatchWrites(writes)) {
-      await driver.batch(chunk);
+    if (driver.atomicBatch) {
+      await driver.batch(writes);
+    } else {
+      for (const chunk of splitBatchWrites(writes)) {
+        await driver.batch(chunk);
+      }
     }
   }
   if (pendingDeletions) {
-    const deleteOps = [];
-    for (const prefix of pendingDeletions.prefixes) {
-      deleteOps.push(driver.deletePrefix(prefix));
-    }
-    for (const range of pendingDeletions.ranges) {
-      deleteOps.push(driver.deleteRange(range.start, range.end));
-    }
-    for (const key of pendingDeletions.keys) {
-      deleteOps.push(driver.delete(key));
-    }
-    if (deleteOps.length > 0) {
-      await Promise.all(deleteOps);
+    const didChange = await runDeletes(driver, pendingDeletions);
+    if (didChange) {
       historyUpdated = true;
     }
   }
@@ -1632,10 +1661,38 @@ function splitBatchWrites(writes) {
   }
   return chunks;
 }
+function splitBatchDeletes(keys) {
+  const chunks = [];
+  for (let i = 0; i < keys.length; i += MAX_KV_BATCH_ENTRIES) {
+    chunks.push(keys.slice(i, i + MAX_KV_BATCH_ENTRIES));
+  }
+  return chunks;
+}
+async function runDeletes(driver, deletions) {
+  const ops = [
+    ...deletions.prefixes.map(
+      (prefix) => () => driver.deletePrefix(prefix)
+    ),
+    ...deletions.ranges.map(
+      (range) => () => driver.deleteRange(range.start, range.end)
+    ),
+    ...splitBatchDeletes(deletions.keys).map(
+      (chunk) => () => driver.batchDelete(chunk)
+    )
+  ];
+  if (ops.length === 0) {
+    return false;
+  }
+  for (let i = 0; i < ops.length; i += MAX_CONCURRENT_DELETES) {
+    await Promise.all(
+      ops.slice(i, i + MAX_CONCURRENT_DELETES).map((op) => op())
+    );
+  }
+  return true;
+}
 async function deleteEntriesWithPrefix(storage, driver, prefixLocation, onHistoryUpdated) {
   const deletions = collectDeletionsForPrefix(storage, prefixLocation);
-  await driver.deletePrefix(deletions.prefixes[0]);
-  await Promise.all(deletions.keys.map((key) => driver.delete(key)));
+  await runDeletes(driver, deletions);
   if (deletions.keys.length > 0 && onHistoryUpdated) {
     onHistoryUpdated();
   }
@@ -1817,7 +1874,7 @@ function selectControlFlowError(current, candidate) {
   return controlFlowErrorPriority(candidate) < controlFlowErrorPriority(current) ? candidate : current;
 }
 var WorkflowContextImpl = class _WorkflowContextImpl {
-  constructor(workflowId, storage, driver, messageDriver, location = emptyLocation(), abortController, mode = "forward", rollbackActions, rollbackCheckpointSet = false, historyNotifier, onError, logger, visitedKeys) {
+  constructor(workflowId, storage, driver, messageDriver, location = emptyLocation(), abortController, mode = "forward", rollbackActions, rollbackCheckpointSet = false, historyNotifier, onError, logger, visitedKeys, runSpan) {
     this.workflowId = workflowId;
     this.storage = storage;
     this.driver = driver;
@@ -1831,11 +1888,13 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     this.onError = onError;
     this.logger = logger;
     this.visitedKeys = visitedKeys ?? /* @__PURE__ */ new Set();
+    this.runSpan = runSpan;
   }
   entryInProgress = false;
   abortController;
   currentLocation;
   visitedKeys;
+  runSpan;
   mode;
   rollbackActions;
   rollbackCheckpointSet;
@@ -1888,7 +1947,8 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       this.historyNotifier,
       this.onError,
       this.logger,
-      this.visitedKeys
+      this.visitedKeys,
+      this.runSpan
     );
   }
   /**
@@ -2155,6 +2215,7 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     }
   }
   async executeStep(config2) {
+    var _a;
     this.ensureRollbackCheckpoint(config2);
     if (this.mode === "rollback") {
       return await this.executeStepRollback(config2);
@@ -2246,9 +2307,13 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     metadata.lastAttemptAt = Date.now();
     metadata.dirty = true;
     const timeout = config2.timeout ?? DEFAULT_STEP_TIMEOUT;
+    const stepSpan = (_a = this.runSpan) == null ? void 0 : _a.startStep(
+      config2.name,
+      metadata.attempts
+    );
     try {
       const output = await this.executeWithTimeout(
-        config2.run(),
+        stepSpan ? stepSpan.run(() => config2.run()) : config2.run(),
         timeout,
         config2.name
       );
@@ -2267,6 +2332,7 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         });
         await this.flushStorage();
       }
+      stepSpan == null ? void 0 : stepSpan.finish("ok");
       this.log("debug", {
         msg: "step completed",
         step: config2.name,
@@ -2279,6 +2345,7 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       }
       entry.dirty = true;
       if (error instanceof StepTimeoutError && !config2.retryOnTimeout) {
+        stepSpan == null ? void 0 : stepSpan.finish("failed", error);
         metadata.status = "exhausted";
         metadata.error = String(error);
         await this.notifyStepError(config2, metadata.attempts, error, {
@@ -2294,6 +2361,7 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         );
       }
       if (error instanceof CriticalError || error instanceof RollbackError) {
+        stepSpan == null ? void 0 : stepSpan.finish("failed", error);
         metadata.status = "exhausted";
         metadata.error = String(error);
         await this.notifyStepError(config2, metadata.attempts, error, {
@@ -2309,6 +2377,7 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         );
       }
       const willRetry = metadata.attempts <= maxRetries;
+      stepSpan == null ? void 0 : stepSpan.finish(willRetry ? "retry" : "failed", error);
       metadata.status = willRetry ? "failed" : "exhausted";
       metadata.error = String(error);
       if (willRetry) {
@@ -3488,6 +3557,65 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     setEntry(this.storage, location, entry);
     await this.flushStorage();
   }
+  // === Version ===
+  async getVersion(name, latest) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      return await this.executeGetVersion(name, latest);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeGetVersion(name, latest) {
+    if (!Number.isInteger(latest) || latest < 1) {
+      throw new Error(
+        `getVersion("${name}", ${latest}): latest must be an integer >= 1`
+      );
+    }
+    this.checkDuplicateName(name);
+    const location = appendName(this.storage, this.currentLocation, name);
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    this.stopRollbackIfMissing(existing);
+    if (existing) {
+      if (existing.kind.type !== "version_check") {
+        throw new HistoryDivergedError(
+          `Expected version_check at ${key}, found ${existing.kind.type}`
+        );
+      }
+      return existing.kind.data.resolved;
+    }
+    const resolved = this.hasUnvisitedUnderCurrentScope(key) ? 1 : latest;
+    const entry = createEntry(location, {
+      type: "version_check",
+      data: { resolved, latest }
+    });
+    setEntry(this.storage, location, entry);
+    await this.flushStorage();
+    return resolved;
+  }
+  /**
+   * Returns true if any history entry under the current location scope
+   * (other than `excludeKey`) has not yet been visited this run. Used by
+   * getVersion to detect an old in-flight instance whose scope was already
+   * executed by code that predates a version gate.
+   */
+  hasUnvisitedUnderCurrentScope(excludeKey) {
+    const prefix = locationToKey(this.storage, this.currentLocation);
+    for (const key of this.storage.history.entries.keys()) {
+      if (key === excludeKey) {
+        continue;
+      }
+      const isUnderPrefix = prefix === "" ? true : key.startsWith(`${prefix}/`) || key === prefix;
+      if (isUnderPrefix && !this.visitedKeys.has(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
 };
 
 // src/utils.ts
@@ -3569,7 +3697,7 @@ async function awaitWithEviction(promise, abortSignal) {
     cleanup();
   }
 }
-async function executeRollback(workflowId, workflowFn, input, driver, messageDriver, abortController, storage, historyNotifier, onError, logger) {
+async function executeRollback(workflowId, workflowFn, input, driver, messageDriver, abortController, storage, historyNotifier, onError, logger, runSpan) {
   const rollbackActions = [];
   const ctx = new WorkflowContextImpl(
     workflowId,
@@ -3583,7 +3711,9 @@ async function executeRollback(workflowId, workflowFn, input, driver, messageDri
     false,
     historyNotifier,
     onError,
-    logger
+    logger,
+    void 0,
+    runSpan
   );
   try {
     await workflowFn(ctx, input);
@@ -3719,16 +3849,20 @@ async function waitForSleep(runtime, deadline, abortSignal) {
 async function executeLiveWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, runtime, onHistoryUpdated, onError, logger) {
   let lastResult;
   while (true) {
-    const result = await executeWorkflow(
-      workflowId,
-      workflowFn,
-      input,
+    const result = await traceRun(
       driver,
-      messageDriver,
-      abortController,
-      onHistoryUpdated,
-      onError,
-      logger
+      (runSpan) => executeWorkflow(
+        workflowId,
+        workflowFn,
+        input,
+        driver,
+        messageDriver,
+        abortController,
+        onHistoryUpdated,
+        onError,
+        logger,
+        runSpan
+      )
     );
     lastResult = result;
     if (result.state !== "sleeping") {
@@ -3827,16 +3961,20 @@ function runWorkflow(workflowId, workflowFn, input, driver, options = {}) {
     options.onHistoryUpdated,
     options.onError,
     logger
-  ) : executeWorkflow(
-    workflowId,
-    workflowFn,
-    input,
+  ) : traceRun(
     driver,
-    messageDriver,
-    abortController,
-    options.onHistoryUpdated,
-    options.onError,
-    logger
+    (runSpan) => executeWorkflow(
+      workflowId,
+      workflowFn,
+      input,
+      driver,
+      messageDriver,
+      abortController,
+      options.onHistoryUpdated,
+      options.onError,
+      logger,
+      runSpan
+    )
   );
   return {
     workflowId,
@@ -4012,7 +4150,42 @@ function findReplayBoundaryEntry(entries, target) {
   }
   return boundary;
 }
-async function executeWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, onHistoryUpdated, onError, logger) {
+function runOutcomeFromState(state) {
+  switch (state) {
+    case "completed":
+      return "completed";
+    case "sleeping":
+      return "sleeping";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    case "pending":
+    case "running":
+    case "rolling_back":
+      return "evicted";
+  }
+}
+async function traceRun(driver, run) {
+  if (!driver.telemetry) {
+    return await run();
+  }
+  const span = await driver.telemetry.startSpan();
+  let outcome = "failed";
+  try {
+    const result = await span.run(() => run(span));
+    outcome = runOutcomeFromState(result.state);
+    return result;
+  } catch (error) {
+    if (error instanceof EvictedError) {
+      outcome = "cancelled";
+    }
+    throw error;
+  } finally {
+    await span.finish(outcome);
+  }
+}
+async function executeWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, onHistoryUpdated, onError, logger, runSpan) {
   var _a;
   const storage = await loadStorage(driver);
   const historyNotifier = onHistoryUpdated ? () => onHistoryUpdated(createHistorySnapshot(storage)) : void 0;
@@ -4055,7 +4228,8 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
         storage,
         historyNotifier,
         onError,
-        logger
+        logger,
+        runSpan
       );
     } catch (error) {
       if (error instanceof EvictedError) {
@@ -4083,7 +4257,9 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
     false,
     historyNotifier,
     onError,
-    logger
+    logger,
+    void 0,
+    runSpan
   );
   storage.state = "running";
   try {
@@ -4150,7 +4326,8 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
         storage,
         historyNotifier,
         onError,
-        logger
+        logger,
+        runSpan
       );
     } catch (rollbackError) {
       if (rollbackError instanceof EvictedError) {
@@ -4225,4 +4402,4 @@ export {
   runWorkflow,
   replayWorkflowFromStep
 };
-//# sourceMappingURL=chunk-KA2T56AJ.js.map
+//# sourceMappingURL=chunk-AAAPEYGX.js.map