@rivetkit/workflow-engine 2.3.3-rc.1 → 2.3.3-rc.2

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

@@ -670,6 +670,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 +700,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 +750,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 +1199,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 +1288,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}`
@@ -3488,6 +3521,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
@@ -4225,4 +4317,4 @@ export {
   runWorkflow,
   replayWorkflowFromStep
 };
-//# sourceMappingURL=chunk-KA2T56AJ.js.map
+//# sourceMappingURL=chunk-Z3WC5MXC.js.map