@ferricstore/ferricstore 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   ListStore: () => ListStore,
   LockHeldError: () => LockHeldError,
   LockNotOwnedError: () => LockNotOwnedError,
+  MAX_FLOW_POLICY_GENERATION: () => MAX_FLOW_POLICY_GENERATION,
   NativeAdapter: () => NativeAdapter,
   OverloadedError: () => OverloadedError,
   Queue: () => Queue,
@@ -70,6 +71,7 @@ __export(index_exports, {
   SetStore: () => SetStore,
   SortedSetStore: () => SortedSetStore,
   StaleLeaseError: () => StaleLeaseError,
+  StalePolicyGenerationError: () => StalePolicyGenerationError,
   StreamStore: () => StreamStore,
   TDigestStore: () => TDigestStore,
   TopKStore: () => TopKStore,
@@ -102,7 +104,7 @@ function assertSafeVariadicDispatch(argumentCount, arrayCapability) {
 // src/native-adapter.ts
 var import_node_net3 = require("net");
 var import_node_tls3 = require("tls");
-var import_node_buffer25 = require("buffer");
+var import_node_buffer26 = require("buffer");
 
 // src/errors.ts
 var FerricStoreError = class extends Error {
@@ -150,6 +152,9 @@ var FlowWrongStateError = class extends FerricStoreError {
 var StaleLeaseError = class extends FerricStoreError {
   code = "stale_lease";
 };
+var StalePolicyGenerationError = class extends FerricStoreError {
+  code = "stale_policy_generation";
+};
 var FlowAlreadyExistsError = class extends FerricStoreError {
   code = "flow_already_exists";
 };
@@ -215,6 +220,9 @@ function classifyServerError(message, raw, cause, status) {
   if (code === "stale_lease" || code === "stale_flow_lease" || lower.includes("stale flow lease") || lower.includes("stale lease") || lower.includes("stale token")) {
     return new StaleLeaseError(message, { cause, raw });
   }
+  if (code === "stale_generation" || code === "stale_policy_generation" || code === "stale_flow_policy_generation" || lower.includes("stale flow policy generation") || lower.includes("stale policy generation")) {
+    return new StalePolicyGenerationError(message, { cause, raw });
+  }
   if (code === "flow_not_found" || lower.includes("flow") && (lower.includes("not found") || lower.includes("does not exist"))) {
     return new FlowNotFoundError(message, { cause, raw });
   }
@@ -1268,7 +1276,7 @@ var NativeHeartbeat = class {
 };
 
 // src/protocol.ts
-var import_node_buffer21 = require("buffer");
+var import_node_buffer22 = require("buffer");
 
 // src/command-grammar.ts
 var import_node_buffer3 = require("buffer");
@@ -2090,6 +2098,8 @@ var OPCODES = {
   flowRetryMany: COMMAND_OPCODES["FLOW.RETRY_MANY"],
   flowFailMany: COMMAND_OPCODES["FLOW.FAIL_MANY"],
   flowReclaim: COMMAND_OPCODES["FLOW.RECLAIM"],
+  flowPolicySet: COMMAND_OPCODES["FLOW.POLICY.SET"],
+  flowPolicyGet: COMMAND_OPCODES["FLOW.POLICY.GET"],
   flowSpawnChildren: COMMAND_OPCODES["FLOW.SPAWN_CHILDREN"],
   flowStepContinue: COMMAND_OPCODES["FLOW.STEP_CONTINUE"],
   flowStartAndClaim: COMMAND_OPCODES["FLOW.START_AND_CLAIM"],
@@ -4254,6 +4264,162 @@ function flowSignalPayload(args) {
   return { opcode: OPCODES.flowSignal, payload: { id: args[0], ...options } };
 }
 
+// src/protocol-flow-policy.ts
+var import_node_buffer12 = require("buffer");
+var BACKOFF_FIELDS = {
+  BASE_MS: "base_ms",
+  MAX_MS: "max_ms",
+  JITTER_PCT: "jitter_pct"
+};
+var RETENTION_FIELDS = {
+  RETENTION_TTL: "ttl_ms",
+  RETENTION_TTL_MS: "ttl_ms",
+  HISTORY_MAX_EVENTS: "history_max_events"
+};
+function flowPolicySetPayload(args) {
+  if (!hasOwnCommandArgument(args, 0, args.length, "Flow policy arguments")) return void 0;
+  if (!isBinaryArgument(args[0])) return void 0;
+  const payload = { type: args[0] };
+  const states = {};
+  let target = payload;
+  for (let index = 1; index < args.length; index += 2) {
+    if (!hasOwnCommandArgument(args, index, args.length, "Flow policy arguments") || !hasOwnCommandArgument(args, index + 1, args.length, "Flow policy arguments")) return void 0;
+    const token = optionalText(args[index])?.toUpperCase();
+    const value = args[index + 1];
+    if (token == null || value == null) return void 0;
+    if (token === "STATE") {
+      if (!isBinaryArgument(value)) return void 0;
+      const state = asText(value);
+      target = {};
+      setOwnValue2(states, state, target);
+      setOwnValue2(payload, "states", states);
+      continue;
+    }
+    if (token === "MODE") {
+      if (!isBinaryArgument(value)) return void 0;
+      const mode = optionalText(value)?.toLowerCase();
+      if (target === payload || mode !== "fifo" && mode !== "parallel") return void 0;
+      setOwnValue2(target, "mode", mode);
+      continue;
+    }
+    if (token === "EXPECTED_GENERATION") {
+      if (target !== payload) return void 0;
+      const generation = integerOption(value);
+      if (generation == null || generation < 0) return void 0;
+      setOwnValue2(payload, "expected_generation", generation);
+      continue;
+    }
+    if (token === "REPLACE") {
+      if (target !== payload || !isBoolToken(value)) return void 0;
+      setOwnValue2(payload, "replace", boolArg(value));
+      continue;
+    }
+    if (token === "MAX_ACTIVE_MS") {
+      if (target !== payload) return void 0;
+      const maxActiveMs = maxActiveOption(value);
+      if (maxActiveMs == null) return void 0;
+      setOwnValue2(payload, "max_active_ms", maxActiveMs);
+      continue;
+    }
+    if (token === "INDEXED_STATE_META") {
+      if (target !== payload || !isBinaryArgument(value)) return void 0;
+      setOwnValue2(payload, "indexed_state_meta", value);
+      continue;
+    }
+    if (token === "INDEXED_ATTRIBUTES") {
+      if (target !== payload) return void 0;
+      const names = indexedAttributes(value);
+      if (names == null) return void 0;
+      setOwnValue2(payload, "indexed_attributes", names);
+      continue;
+    }
+    if (token === "MAX_RETRIES") {
+      const parsed = integerOption(value);
+      if (parsed == null) return void 0;
+      setOwnValue2(objectField(target, "retry"), "max_retries", parsed);
+      continue;
+    }
+    if (token === "EXHAUSTED_TO") {
+      if (!isBinaryArgument(value)) return void 0;
+      setOwnValue2(objectField(target, "retry"), "exhausted_to", value);
+      continue;
+    }
+    const backoffField = BACKOFF_FIELDS[token];
+    if (backoffField != null) {
+      const parsed = integerOption(value);
+      if (parsed == null) return void 0;
+      setOwnValue2(objectField(objectField(target, "retry"), "backoff"), backoffField, parsed);
+      continue;
+    }
+    if (token === "BACKOFF") {
+      if (!isBinaryArgument(value)) return void 0;
+      const kind = optionalText(value)?.toLowerCase();
+      if (kind == null) return void 0;
+      setOwnValue2(objectField(objectField(target, "retry"), "backoff"), "kind", kind);
+      continue;
+    }
+    const retentionField = RETENTION_FIELDS[token];
+    if (retentionField != null) {
+      if (target === payload) return void 0;
+      const parsed = integerOption(value);
+      if (parsed == null) return void 0;
+      setOwnValue2(objectField(target, "retention"), retentionField, parsed);
+      continue;
+    }
+    return void 0;
+  }
+  return { opcode: OPCODES.flowPolicySet, payload };
+}
+function flowPolicyGetPayload(args) {
+  if (!hasOwnCommandArgument(args, 0, args.length, "Flow policy arguments")) return void 0;
+  if (!isBinaryArgument(args[0])) return void 0;
+  if (args.length !== 1 && args.length !== 3) return void 0;
+  const payload = { type: args[0] };
+  if (args.length === 3) {
+    if (!hasOwnCommandArgument(args, 1, args.length, "Flow policy arguments") || !hasOwnCommandArgument(args, 2, args.length, "Flow policy arguments") || optionalText(args[1])?.toUpperCase() !== "STATE" || !isBinaryArgument(args[2])) return void 0;
+    setOwnValue2(payload, "state", args[2]);
+  }
+  return { opcode: OPCODES.flowPolicyGet, payload };
+}
+function integerOption(value) {
+  try {
+    return safeIntegerNumberArg(value);
+  } catch {
+    return void 0;
+  }
+}
+function maxActiveOption(value) {
+  if (isBinaryArgument(value) && asText(value).toLowerCase() === "infinity") {
+    return "infinity";
+  }
+  return integerOption(value);
+}
+function isBinaryArgument(value) {
+  return typeof value === "string" || import_node_buffer12.Buffer.isBuffer(value) || value instanceof Uint8Array;
+}
+function objectField(target, name) {
+  const existing = Object.hasOwn(target, name) ? target[name] : void 0;
+  if (typeof existing === "object" && existing != null && !Array.isArray(existing)) {
+    return existing;
+  }
+  const value = {};
+  setOwnValue2(target, name, value);
+  return value;
+}
+function indexedAttributes(value) {
+  if (Array.isArray(value)) {
+    return value.every((item) => typeof item === "string") ? value : void 0;
+  }
+  const source = optionalText(value);
+  if (source == null) return void 0;
+  try {
+    const parsed = JSON.parse(source);
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === "string") ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/protocol-connection-policy.ts
 function assertCommandDoesNotRequirePinnedConnection(args) {
   const outer = commandName(args[0]);
@@ -4301,7 +4467,7 @@ function commandRequiresOrderedPipelineExecution(args) {
 }
 
 // src/protocol-compact-request.ts
-var import_node_buffer12 = require("buffer");
+var import_node_buffer13 = require("buffer");
 function compactMsetPayload(args, maxBodyBytes) {
   if (args.length % 2 !== 0) throw new FerricStoreError("MSET requires key/value pairs");
   const minimum = 6 + args.length * 4;
@@ -4320,7 +4486,7 @@ function compactMsetPayload(args, maxBodyBytes) {
     total += 4 + byteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer12.Buffer.allocUnsafe(total);
+  const out = import_node_buffer13.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, 1, args.length / 2);
   for (let index = 0; index < args.length; index += 1) {
     offset = writeBinaryValue(out, offset, args[index], byteLengths[index] ?? 0);
@@ -4344,7 +4510,7 @@ function compactKeyPipelinePayload(opcode, args, mode, maxBodyBytes) {
     total += 4 + byteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer12.Buffer.allocUnsafe(total);
+  const out = import_node_buffer13.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, mode, args.length);
   for (let index = 0; index < args.length; index += 1) {
     offset = writeBinaryValue(out, offset, args[index], byteLengths[index] ?? 0);
@@ -4354,7 +4520,7 @@ function compactKeyPipelinePayload(opcode, args, mode, maxBodyBytes) {
 function compactPipelinePayload(commands, maxBodyBytes) {
   if (commands.length === 0) {
     assertCompactPayloadFits(6, maxBodyBytes);
-    const out = import_node_buffer12.Buffer.allocUnsafe(6);
+    const out = import_node_buffer13.Buffer.allocUnsafe(6);
     writeCompactPipelineHeader(out, 128 | 2, 0);
     return out;
   }
@@ -4396,7 +4562,7 @@ function compactSetPipelinePayload(commands, maxBodyBytes) {
     total += 8 + keyByteLength + valueByteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer12.Buffer.allocUnsafe(total);
+  const out = import_node_buffer13.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, 128 | 1, commands.length);
   for (let index = 0; index < commands.length; index += 1) {
     offset = writeBinaryValue(out, offset, argumentValues[index * 2], argumentByteLengths[index * 2] ?? 0);
@@ -4431,7 +4597,7 @@ function compactGetPipelinePayload(commands, maxBodyBytes) {
     total += 4 + keyByteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer12.Buffer.allocUnsafe(total);
+  const out = import_node_buffer13.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, 128 | 2, commands.length);
   for (let index = 0; index < commands.length; index += 1) {
     offset = writeBinaryValue(out, offset, keys[index], keyByteLengths[index] ?? 0);
@@ -4445,7 +4611,7 @@ function compactArgumentsEligible(args, sparseMessage) {
   }
   return true;
 }
-function compactPipelineEligible(commands, commandName4, argumentCount) {
+function compactPipelineEligible(commands, commandName5, argumentCount) {
   for (let index = 0; index < commands.length; index += 1) {
     const command = commands[index];
     if (!Object.hasOwn(commands, index) || !Array.isArray(command)) {
@@ -4457,7 +4623,7 @@ function compactPipelineEligible(commands, commandName4, argumentCount) {
         throw new TypeError("pipeline command arguments must be dense");
       }
     }
-    if (!commandNameIs(command[0], commandName4)) return false;
+    if (!commandNameIs(command[0], commandName5)) return false;
     for (let argumentIndex = 1; argumentIndex < argumentCount; argumentIndex += 1) {
       if (!isCompactBinaryScalar(command[argumentIndex])) return false;
     }
@@ -4472,7 +4638,7 @@ function writeCompactPipelineHeader(out, mode, count) {
 }
 
 // src/protocol-kv.ts
-var import_node_buffer13 = require("buffer");
+var import_node_buffer14 = require("buffer");
 function collectionProtocolCommand(command, args) {
   switch (command) {
     case "CAS":
@@ -4719,17 +4885,17 @@ function parsedNumber(value) {
   }
 }
 function isBinaryCommandArgument(value) {
-  return typeof value === "string" || import_node_buffer13.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer14.Buffer.isBuffer(value);
 }
 function isDirectKvValueArgument(value) {
   return isBinaryCommandArgument(value) || typeof value === "object" && value != null;
 }
 function binaryToken(value) {
-  return typeof value === "string" ? value.toUpperCase() : import_node_buffer13.Buffer.isBuffer(value) ? value.toString("utf8").toUpperCase() : void 0;
+  return typeof value === "string" ? value.toUpperCase() : import_node_buffer14.Buffer.isBuffer(value) ? value.toString("utf8").toUpperCase() : void 0;
 }
 
 // src/protocol-value.ts
-var import_node_buffer14 = require("buffer");
+var import_node_buffer15 = require("buffer");
 function planValueWithLimit(value, maxBytes) {
   const budget = {
     maxBytes,
@@ -4784,7 +4950,7 @@ function planContainerValue(value, budget, ancestors, depth) {
     let byteLength = 5;
     let index = 0;
     for (const [key, item] of entries) {
-      const keyByteLength = import_node_buffer14.Buffer.byteLength(key);
+      const keyByteLength = import_node_buffer15.Buffer.byteLength(key);
       consumeEncodeBytes(budget, 4 + keyByteLength);
       const valuePlan = planValueAt(item, budget, ancestors, depth + 1);
       entryPlans[index] = { key, keyByteLength, value: valuePlan };
@@ -4833,7 +4999,7 @@ function planScalarValue(value, budget) {
     consumeEncodeBytes(budget, 9);
     return { byteLength: 9, tag: 7, value };
   }
-  if (typeof value === "string" || import_node_buffer14.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (typeof value === "string" || import_node_buffer15.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     const valueByteLength = binaryValueByteLength(value);
     const byteLength = 5 + valueByteLength;
     consumeEncodeBytes(budget, byteLength);
@@ -4857,7 +5023,7 @@ function writeValuePlan(output, start, plan) {
       offset += 4;
       if (typeof plan.value === "string") {
         output.write(plan.value, offset, plan.valueByteLength, "utf8");
-      } else if (import_node_buffer14.Buffer.isBuffer(plan.value)) {
+      } else if (import_node_buffer15.Buffer.isBuffer(plan.value)) {
         plan.value.copy(output, offset);
       } else {
         output.set(plan.value, offset);
@@ -4991,20 +5157,20 @@ function requireAvailable(data, offset, size) {
 }
 
 // src/key-slot-validation.ts
-var import_node_buffer16 = require("buffer");
+var import_node_buffer17 = require("buffer");
 
 // src/topology-utilities.ts
-var import_node_buffer15 = require("buffer");
+var import_node_buffer16 = require("buffer");
 function isPlainObject3(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer15.Buffer.isBuffer(value);
+  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer16.Buffer.isBuffer(value);
 }
 function getField(source, ...keys) {
   if (source instanceof Map) {
     for (const key of keys) {
       if (source.has(key)) return source.get(key);
-      const bufferKey = import_node_buffer15.Buffer.from(key);
+      const bufferKey = import_node_buffer16.Buffer.from(key);
       for (const [itemKey, value] of source.entries()) {
-        if (import_node_buffer15.Buffer.isBuffer(itemKey) && itemKey.equals(bufferKey)) return value;
+        if (import_node_buffer16.Buffer.isBuffer(itemKey) && itemKey.equals(bufferKey)) return value;
       }
     }
     return void 0;
@@ -5018,7 +5184,7 @@ function getField(source, ...keys) {
 }
 function textOrUndefined(value) {
   if (typeof value === "string") return value;
-  if (import_node_buffer15.Buffer.isBuffer(value)) return value.toString("utf8");
+  if (import_node_buffer16.Buffer.isBuffer(value)) return value.toString("utf8");
   return void 0;
 }
 function numberOrUndefined(value) {
@@ -5193,7 +5359,7 @@ function stringHashRange(key) {
 var validatedCommands = /* @__PURE__ */ new WeakSet();
 function assertAtomicKeyValueCommandSharesSlot(args) {
   const value = args[0];
-  const command = (typeof value === "string" ? value : import_node_buffer16.Buffer.isBuffer(value) ? value.toString("utf8") : "").toUpperCase();
+  const command = (typeof value === "string" ? value : import_node_buffer17.Buffer.isBuffer(value) ? value.toString("utf8") : "").toUpperCase();
   if (command === "MSET" || command === "MSETNX") {
     assertKeyValueCommandSharesSlot(args, command);
   }
@@ -5203,7 +5369,7 @@ function assertKeyValueCommandSharesSlot(args, command) {
   let expectedSlot;
   for (let index = 1; index < args.length; index += 2) {
     const key = args[index];
-    if (typeof key !== "string" && !import_node_buffer16.Buffer.isBuffer(key)) return;
+    if (typeof key !== "string" && !import_node_buffer17.Buffer.isBuffer(key)) return;
     const slot = routingSlotForKey(key);
     expectedSlot ??= slot;
     if (slot !== expectedSlot) {
@@ -5214,13 +5380,13 @@ function assertKeyValueCommandSharesSlot(args, command) {
 }
 
 // src/protocol-response.ts
-var import_node_buffer20 = require("buffer");
+var import_node_buffer21 = require("buffer");
 
 // src/protocol-compact-response.ts
-var import_node_buffer19 = require("buffer");
+var import_node_buffer20 = require("buffer");
 
 // src/native-negotiation.ts
-var import_node_buffer17 = require("buffer");
+var import_node_buffer18 = require("buffer");
 var EMPTY_COMPACT_RESPONSE_OPCODES = /* @__PURE__ */ new Map();
 function nativeNegotiation(value) {
   const capabilities = field(value, "capabilities") ?? value;
@@ -5288,14 +5454,14 @@ function nonNegativeSafeInteger2(value) {
 }
 function text2(value) {
   if (typeof value === "string") return value;
-  if (import_node_buffer17.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return import_node_buffer17.Buffer.from(value).toString("utf8");
+  if (import_node_buffer18.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer18.Buffer.from(value).toString("utf8");
   }
   return void 0;
 }
 
 // src/protocol-compact-collections.ts
-var import_node_buffer18 = require("buffer");
+var import_node_buffer19 = require("buffer");
 function decodeCompactIntegerList(data, budget) {
   requireAvailable(data, 0, 5);
   const count = data.readUInt32BE(1);
@@ -5441,7 +5607,7 @@ function decodeCompactOkList(data, budget) {
   const count = data.readUInt32BE(1);
   requireCompactContainer2(count, budget);
   if (data.byteLength !== 5) throw new FerricStoreError("invalid compact OK list response");
-  return Array.from({ length: count }, () => import_node_buffer19.Buffer.from("OK"));
+  return Array.from({ length: count }, () => import_node_buffer20.Buffer.from("OK"));
 }
 function decodeCompactKvGet(data) {
   requireAvailable(data, 0, 2);
@@ -5487,7 +5653,7 @@ function decodeCompactMgetFixed(data, budget) {
   if (size === NULL_U32 || data.byteLength !== expected) {
     throw new FerricStoreError("invalid compact fixed MGET response");
   }
-  if (size === 0) return new Array(count).fill(import_node_buffer19.Buffer.alloc(0));
+  if (size === 0) return new Array(count).fill(import_node_buffer20.Buffer.alloc(0));
   const values = new Array(count);
   for (let index = 0, offset = 9; index < count; index += 1, offset += size) {
     values[index] = data.subarray(offset, offset + size);
@@ -5702,7 +5868,7 @@ function requireCompactContainer2(count, budget) {
 }
 function errorMessage(status, value) {
   if (typeof value === "string") return value;
-  if (import_node_buffer19.Buffer.isBuffer(value)) return value.toString("utf8");
+  if (import_node_buffer20.Buffer.isBuffer(value)) return value.toString("utf8");
   if (typeof value === "object" && value != null && Object.hasOwn(value, "message")) {
     const message = value.message;
     return typeof message === "string" ? message : String(message);
@@ -5782,7 +5948,7 @@ function unwrapPipelineResponse(value, options = {}, expectedItems) {
   return out;
 }
 function pipelineStatus(value) {
-  if (typeof value !== "string" && !import_node_buffer20.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return null;
+  if (typeof value !== "string" && !import_node_buffer21.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return null;
   const status = asText(value).toLowerCase();
   return status === "ok" || status === "busy" || status === "error" ? status : null;
 }
@@ -5797,7 +5963,7 @@ function decodeResponseValue(opcode, body, hints) {
 }
 function errorMessage2(status, value) {
   if (typeof value === "string") return value;
-  if (import_node_buffer20.Buffer.isBuffer(value)) return value.toString("utf8");
+  if (import_node_buffer21.Buffer.isBuffer(value)) return value.toString("utf8");
   if (typeof value === "object" && value != null && Object.hasOwn(value, "message")) {
     const message = value.message;
     return typeof message === "string" ? message : String(message);
@@ -5813,7 +5979,7 @@ function encodeRequest(command, requestId, maxBodyBytes = Number.MAX_SAFE_INTEGE
   const bodyLength = customPayload ? binaryValueByteLength(command.payload) : plan?.byteLength ?? 0;
   if (bodyLength > bodyLimit) throw requestFrameTooLarge(bodyLimit);
   const flags = command.flags ?? 0;
-  const frame = import_node_buffer21.Buffer.allocUnsafe(HEADER_SIZE + bodyLength);
+  const frame = import_node_buffer22.Buffer.allocUnsafe(HEADER_SIZE + bodyLength);
   frame.write(MAGIC, 0, "ascii");
   frame.writeUInt8(REQUEST_VERSION, 4);
   frame.writeUInt8(flags, 5);
@@ -5938,6 +6104,12 @@ function buildProtocolCommand(args, maxBodyBytes = Number.MAX_SAFE_INTEGER, allo
   if (command === "FLOW.LIST") {
     return (allowCustomPayload ? compactFlowListPayload(commandArgs2, maxBodyBytes) : void 0) ?? commandExec(args);
   }
+  if (command === "FLOW.POLICY.SET") {
+    return flowPolicySetPayload(commandArgs2) ?? commandExec(args);
+  }
+  if (command === "FLOW.POLICY.GET") {
+    return flowPolicyGetPayload(commandArgs2) ?? commandExec(args);
+  }
   const flowAdmin = FLOW_ADMIN_COMMANDS[command];
   if (flowAdmin != null) {
     return flowAdminPayload(flowAdmin.opcode, commandArgs2, flowAdmin.leadingFields) ?? commandExec(args);
@@ -6193,7 +6365,7 @@ var import_node_net2 = require("net");
 var import_node_tls2 = require("tls");
 
 // src/client-native-options.ts
-var import_node_buffer22 = require("buffer");
+var import_node_buffer23 = require("buffer");
 
 // src/string-array-snapshot.ts
 function snapshotOwnStringArray(values, name) {
@@ -6276,7 +6448,7 @@ function snapshotTlsOptions(options) {
   return Object.freeze(snapshot);
 }
 function snapshotTlsValue(value, name) {
-  if (import_node_buffer22.Buffer.isBuffer(value)) return import_node_buffer22.Buffer.from(value);
+  if (import_node_buffer23.Buffer.isBuffer(value)) return import_node_buffer23.Buffer.from(value);
   if (value instanceof Uint8Array) return value.slice();
   if (Array.isArray(value)) {
     const snapshot = new Array(value.length);
@@ -6831,7 +7003,7 @@ var NativeChunkAssembler = class {
 };
 
 // src/native-response-handler.ts
-var import_node_buffer23 = require("buffer");
+var import_node_buffer24 = require("buffer");
 
 // src/native-receive-buffer.ts
 var FRAME_ASSEMBLY_PAGE_BYTES = 64 * 1024;
@@ -7166,7 +7338,7 @@ var NativeRequestScheduler = class {
 };
 
 // src/native-write-queue.ts
-var import_node_buffer24 = require("buffer");
+var import_node_buffer25 = require("buffer");
 var NativeWriteQueue = class {
   constructor(socket, maxQueuedWriteBytes, isClosed, hasPending, rejectPending) {
     this.socket = socket;
@@ -7683,7 +7855,30 @@ function executeCommandArgs(executor, args) {
 }
 
 // src/reconnecting-executor.ts
-var import_node_buffer26 = require("buffer");
+var import_node_buffer28 = require("buffer");
+
+// src/command-retry-policy.ts
+var import_node_buffer27 = require("buffer");
+function isCasMutation(args) {
+  const offset = commandName2(args[0]) === "COMMAND_EXEC" ? 1 : 0;
+  const name = commandName2(args[offset]);
+  if (name === "CAS") return true;
+  if (name !== "FLOW.POLICY.SET") return false;
+  for (let index = offset + 2; index < args.length; index += 2) {
+    if (!Object.hasOwn(args, index)) return false;
+    if (commandName2(args[index]) === "EXPECTED_GENERATION") return true;
+  }
+  return false;
+}
+function commandName2(value) {
+  if (typeof value === "string") return value.toUpperCase();
+  if (import_node_buffer27.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer27.Buffer.from(value).toString("utf8").toUpperCase();
+  }
+  return void 0;
+}
+
+// src/reconnecting-executor.ts
 var ReconnectingExecutor = class {
   constructor(createExecutor, options = {}) {
     this.createExecutor = createExecutor;
@@ -7714,7 +7909,12 @@ var ReconnectingExecutor = class {
   async executeCommandArgs(args) {
     const snapshot = snapshotCommandArguments(args);
     assertCommandHasStableConnectionState(snapshot);
-    return await this.withReconnect((executor) => executeCommandArgs(executor, snapshot));
+    const casMutation = isCasMutation(snapshot);
+    return await this.withReconnect(
+      (executor) => executeCommandArgs(executor, snapshot),
+      casMutation ? isClosedConnectionError : isReconnectableClosedConnectionError,
+      !casMutation
+    );
   }
   async ready() {
     await this.executorPromise;
@@ -7799,7 +7999,7 @@ var ReconnectingExecutor = class {
     })();
     await this.closePromise;
   }
-  async withReconnect(operation, reconnectable = isReconnectableClosedConnectionError) {
+  async withReconnect(operation, reconnectable = isReconnectableClosedConnectionError, replayAllowed = true) {
     let executor = await this.executorPromise;
     let retries = 0;
     for (; ; ) {
@@ -7808,6 +8008,10 @@ var ReconnectingExecutor = class {
         return await operation(executor);
       } catch (error) {
         if (this.closed || retries >= this.maxRetries || !reconnectable(error)) throw error;
+        if (!replayAllowed) {
+          await this.reconnect(executor).catch(() => void 0);
+          throw error;
+        }
         for (; ; ) {
           retries += 1;
           try {
@@ -7860,6 +8064,9 @@ var ReconnectingExecutor = class {
 function isReconnectableClosedConnectionError(error) {
   return error instanceof ConnectionClosedError && error.requestDisposition === "unsent";
 }
+function isClosedConnectionError(error) {
+  return error instanceof ConnectionClosedError;
+}
 function isReadOnlyReconnectableClosedConnectionError(error) {
   const pending = [error];
   const seen = /* @__PURE__ */ new Set();
@@ -7878,10 +8085,10 @@ function normalizeNonNegativeInteger2(value, fallback) {
 }
 
 // src/topology.ts
-var import_node_buffer28 = require("buffer");
+var import_node_buffer30 = require("buffer");
 
 // src/topology-routing.ts
-var import_node_buffer27 = require("buffer");
+var import_node_buffer29 = require("buffer");
 var import_node_crypto = require("crypto");
 var FLOW_PARTITION_ROUTE_CACHE_MAX = 1024;
 var flowPartitionRouteCache = /* @__PURE__ */ new Map();
@@ -7901,7 +8108,7 @@ function routingKeyFromProtocolPayload(name, command) {
       "scope"
     ]) {
       const value = getField(command.payload, field2);
-      if (typeof value === "string" || import_node_buffer27.Buffer.isBuffer(value)) {
+      if (typeof value === "string" || import_node_buffer29.Buffer.isBuffer(value)) {
         return value;
       }
     }
@@ -7948,7 +8155,7 @@ function flowRoutingData(name, args) {
     if (typeof partition === "string" && partition.toUpperCase() !== "AUTO" && partition.toUpperCase() !== "MIXED") {
       return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
     }
-    if (import_node_buffer27.Buffer.isBuffer(partition)) {
+    if (import_node_buffer29.Buffer.isBuffer(partition)) {
       const text3 = partition.toString("utf8").toUpperCase();
       if (text3 !== "AUTO" && text3 !== "MIXED") {
         return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
@@ -8039,13 +8246,13 @@ function flowPartitionRoutingKeyFromCommand(command, claim) {
   return { handled: false };
 }
 function isRoutingKey(value) {
-  return typeof value === "string" || import_node_buffer27.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer29.Buffer.isBuffer(value);
 }
 function flowLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer27.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer29.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bytes2 = import_node_buffer27.Buffer.isBuffer(value) ? value : import_node_buffer27.Buffer.from(value);
+  const bytes2 = import_node_buffer29.Buffer.isBuffer(value) ? value : import_node_buffer29.Buffer.from(value);
   const text3 = bytes2.toString("utf8");
   const autoMatch = /^__flow_auto__:(0|[1-9]\d{0,2})$/u.exec(text3);
   if (autoMatch != null) {
@@ -8054,7 +8261,7 @@ function flowLogicalPartitionRoutingKey(value) {
       return `{fa:${bucket}}`;
     }
   }
-  const cacheKey = `${import_node_buffer27.Buffer.isBuffer(value) ? "b" : "s"}:${bytes2.toString("base64")}`;
+  const cacheKey = `${import_node_buffer29.Buffer.isBuffer(value) ? "b" : "s"}:${bytes2.toString("base64")}`;
   const cached = flowPartitionRouteCache.get(cacheKey);
   if (cached != null) {
     flowPartitionRouteCache.delete(cacheKey);
@@ -8071,14 +8278,14 @@ function flowLogicalPartitionRoutingKey(value) {
   return routeKey;
 }
 function flowAutoIdRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer27.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer29.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bucket = (import_node_buffer27.Buffer.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
+  const bucket = (import_node_buffer29.Buffer.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
   return `{fa:${bucket}}`;
 }
 function flowClaimLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer27.Buffer.isBuffer(value)) return void 0;
+  if (typeof value !== "string" && !import_node_buffer29.Buffer.isBuffer(value)) return void 0;
   const selector = commandPart(value);
   if (selector === "AUTO" || selector === "ANY") return void 0;
   if (selector === "GLOBAL") return "{f}";
@@ -8093,7 +8300,7 @@ function singleShardFlowClaimPartitionKey(values) {
   return keys.some((key) => key == null) ? void 0 : singleShardKey(keys);
 }
 function singleShardKey(keys) {
-  if (keys.length === 0 || keys.some((key) => typeof key !== "string" && !import_node_buffer27.Buffer.isBuffer(key))) {
+  if (keys.length === 0 || keys.some((key) => typeof key !== "string" && !import_node_buffer29.Buffer.isBuffer(key))) {
     return void 0;
   }
   const usable = keys;
@@ -8104,7 +8311,7 @@ function singleShardKey(keys) {
   const firstSlot = routingSlotForKey(first);
   return usable.every((key) => routingSlotForKey(key) === firstSlot) ? first : void 0;
 }
-function commandName2(args) {
+function commandName3(args) {
   return commandView(args).name;
 }
 var commandPart = commandToken;
@@ -8126,7 +8333,7 @@ function routedKeyGroups(keys, routeKey) {
   const groups = /* @__PURE__ */ new Map();
   for (let index = 0; index < keys.length; index += 1) {
     const key = keys[index];
-    if (typeof key !== "string" && !import_node_buffer27.Buffer.isBuffer(key)) return void 0;
+    if (typeof key !== "string" && !import_node_buffer29.Buffer.isBuffer(key)) return void 0;
     const route = routeKey(key);
     const groupKey = `${route.endpointKey}\0${route.laneId}`;
     const group = groups.get(groupKey);
@@ -8518,7 +8725,7 @@ var TopologyPipelineExecutor = class {
     commands.forEach((command, index) => {
       const routed = this.context.routeData(command);
       if (routed == null) {
-        if (decomposableCommandNames.has(commandName2(command) ?? "")) standalone.push({ command, index });
+        if (decomposableCommandNames.has(commandName3(command) ?? "")) standalone.push({ command, index });
         else {
           controlCommands.push(command);
           controlIndices.push(index);
@@ -8734,7 +8941,7 @@ function topologyRouteIsCurrent(topology, route) {
 // src/topology-route-planner.ts
 function topologyRouteData(args, route) {
   if (args.length === 0) return void 0;
-  const name = commandName2(args);
+  const name = commandName3(args);
   if (name?.startsWith("FLOW.") === true) {
     const routed = flowRoutingData(name, args);
     return routed == null ? void 0 : {
@@ -8763,7 +8970,7 @@ var TopologyScatterExecutor = class {
   }
   dependencies;
   async execute(args) {
-    const name = commandName2(args);
+    const name = commandName3(args);
     if (name === "MGET") {
       const value = await this.scatterArray(name, args.slice(1));
       return value == null ? { handled: false } : { handled: true, value };
@@ -8845,6 +9052,18 @@ var TopologyScatterExecutor = class {
   }
 };
 
+// src/topology-reroute-retry.ts
+async function canRetrySafeReroute(error, attempt, retryAllowed, refresh, assertOpen) {
+  if (attempt !== 0 || !isRetryableRouteError(error)) return false;
+  const refreshed = await refresh().then(
+    () => true,
+    () => false
+  );
+  if (!refreshed || !retryAllowed || !await waitForExplicitlySafeReroute(error)) return false;
+  assertOpen();
+  return true;
+}
+
 // src/topology.ts
 var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
   adapterOptions;
@@ -9030,6 +9249,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
     this.assertOpen();
     const snapshot = snapshotCommandArguments(args);
     assertCommandHasStableConnectionState(snapshot);
+    const casMutation = isCasMutation(snapshot);
     let rerouteAttempt = 0;
     for (let planningAttempt = 0; planningAttempt < MAX_TOPOLOGY_PLANNING_ATTEMPTS; planningAttempt += 1) {
       const routed = this.routeData(snapshot);
@@ -9045,7 +9265,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
       try {
         return routed.command == null ? await adapter.executeCommandOnLane(snapshot, routed.route.laneId) : await adapter.executeProtocolCommand(routed.command, routed.route.laneId);
       } catch (error) {
-        if (await this.refreshAndCanRetrySafeReroute(error, rerouteAttempt)) {
+        if (await this.refreshAndCanRetrySafeReroute(error, rerouteAttempt, !casMutation)) {
           rerouteAttempt += 1;
           continue;
         }
@@ -9087,6 +9307,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
       assertCommandHasStableConnectionState(command);
     }
     let rerouteAttempt = 0;
+    const containsCasMutation = snapshot.some(isCasMutation);
     for (let planningAttempt = 0; planningAttempt < MAX_TOPOLOGY_PLANNING_ATTEMPTS; planningAttempt += 1) {
       const route = singleRouteForCommands(snapshot, (command) => this.routeData(command));
       if (route == null) return void 0;
@@ -9095,7 +9316,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
       try {
         return await adapter.executeFusedPipelineOnLane(snapshot, route.laneId, snapshotOptions);
       } catch (error) {
-        if (await this.refreshAndCanRetrySafeReroute(error, rerouteAttempt)) {
+        if (await this.refreshAndCanRetrySafeReroute(error, rerouteAttempt, !containsCasMutation)) {
           rerouteAttempt += 1;
           continue;
         }
@@ -9104,15 +9325,14 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
     }
     throw new StaleTopologyRouteError();
   }
-  async refreshAndCanRetrySafeReroute(error, attempt) {
-    if (attempt !== 0 || !isRetryableRouteError(error)) return false;
-    const refreshed = await this.refreshTopology().then(
-      () => true,
-      () => false
+  async refreshAndCanRetrySafeReroute(error, attempt, retryAllowed = true) {
+    return await canRetrySafeReroute(
+      error,
+      attempt,
+      retryAllowed,
+      async () => await this.refreshTopology(),
+      () => this.assertOpen()
     );
-    if (!refreshed || !await waitForExplicitlySafeReroute(error)) return false;
-    this.assertOpen();
-    return true;
   }
   async executePipelineOnRoute(commands, route, options) {
     const adapter = await this.adapterForCurrentRoute(route);
@@ -9202,7 +9422,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
 };
 
 // src/response-map-preservation.ts
-var import_node_buffer29 = require("buffer");
+var import_node_buffer31 = require("buffer");
 function toStringKeyMapPreservingValues(value) {
   if (value == null) return void 0;
   const result = {};
@@ -9212,7 +9432,7 @@ function toStringKeyMapPreservingValues(value) {
     }
     return result;
   }
-  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer29.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer31.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     for (const [key, item] of Object.entries(value)) {
       setOwnValue(result, text(key), normalizeMapStructurePreservingBytes(item));
     }
@@ -9221,7 +9441,7 @@ function toStringKeyMapPreservingValues(value) {
   return void 0;
 }
 function normalizeMapStructurePreservingBytes(value) {
-  if (import_node_buffer29.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
+  if (import_node_buffer31.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
   if (value instanceof Map) {
     const result = {};
     for (const [key, item] of value.entries()) {
@@ -9243,7 +9463,7 @@ function normalizeMapStructurePreservingBytes(value) {
 }
 
 // src/native-kv-responses.ts
-var import_node_buffer30 = require("buffer");
+var import_node_buffer32 = require("buffer");
 function rateLimitResultFromResp(value) {
   if (!Array.isArray(value) || value.length !== 4) {
     throw new TypeError("RATELIMIT.ADD returned an unexpected response");
@@ -9300,13 +9520,13 @@ function fetchOrComputeResultFromResp(value, codec) {
 }
 function decodePayload(codec, value) {
   if (value == null) return null;
-  if (import_node_buffer30.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer30.Buffer.from(value));
-  if (typeof value === "string") return codec.decode(import_node_buffer30.Buffer.from(value));
+  if (import_node_buffer32.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer32.Buffer.from(value));
+  if (typeof value === "string") return codec.decode(import_node_buffer32.Buffer.from(value));
   return normalizeRefMeta(value);
 }
 function requiredResponseString(value, context) {
-  if (typeof value !== "string" && !import_node_buffer30.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !import_node_buffer32.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   const result = text(value);
@@ -9323,7 +9543,7 @@ function requiredNonNegativeInteger(value, context) {
   return result;
 }
 function responseBytes(value, context) {
-  if (typeof value !== "string" && !import_node_buffer30.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !import_node_buffer32.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   return bytes(value);
@@ -10033,7 +10253,7 @@ function groupAutoPartitionItems(items) {
 }
 
 // src/client-values.ts
-var import_node_buffer31 = require("buffer");
+var import_node_buffer33 = require("buffer");
 async function valueMGetEntries(client, refs, options = {}) {
   const refCount = refs.length;
   if (refCount === 0) {
@@ -10068,12 +10288,12 @@ async function valueMGetEntries(client, refs, options = {}) {
     const item = response[index];
     if (item == null) {
       entries[index] = { found: false };
-    } else if (import_node_buffer31.Buffer.isBuffer(item)) {
+    } else if (import_node_buffer33.Buffer.isBuffer(item)) {
       entries[index] = { found: true, value: client.codec.decode(item) };
     } else if (item instanceof Uint8Array) {
-      entries[index] = { found: true, value: client.codec.decode(import_node_buffer31.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer33.Buffer.from(item)) };
     } else if (typeof item === "string") {
-      entries[index] = { found: true, value: client.codec.decode(import_node_buffer31.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer33.Buffer.from(item)) };
     } else {
       entries[index] = { found: true, value: item };
     }
@@ -10082,10 +10302,10 @@ async function valueMGetEntries(client, refs, options = {}) {
 }
 
 // src/auto-batch.ts
-var import_node_buffer33 = require("buffer");
+var import_node_buffer35 = require("buffer");
 
 // src/auto-batch-ordering.ts
-var import_node_buffer32 = require("buffer");
+var import_node_buffer34 = require("buffer");
 function autoBatchOrderingPlan(batch) {
   const accesses = /* @__PURE__ */ new Map();
   const fallbackDependencies = [];
@@ -10200,13 +10420,13 @@ function flowManyAutoBatchIds(command, name) {
     return fixedFlowItemIds(
       command,
       mixed ? 4 : 3,
-      (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && isFencingToken(command[itemIndex + (mixed ? 2 : 1)]) && import_node_buffer32.Buffer.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
+      (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && isFencingToken(command[itemIndex + (mixed ? 2 : 1)]) && import_node_buffer34.Buffer.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
     );
   }
   return fixedFlowItemIds(
     command,
     mixed ? 4 : 3,
-    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer32.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
+    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer34.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
   );
 }
 function createManyAutoBatchIds(command) {
@@ -10219,7 +10439,7 @@ function createManyAutoBatchIds(command) {
       const ids = fixedFlowItemIds(
         command,
         width,
-        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer32.Buffer.isBuffer(command[itemIndex + width - 1]),
+        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer34.Buffer.isBuffer(command[itemIndex + width - 1]),
         markerIndex
       );
       if (ids != null) return ids;
@@ -10237,7 +10457,7 @@ function extendedCreateManyAutoBatchIds(command, markerIndex) {
   let cursor = markerIndex + 2;
   for (let itemIndex = 0; itemIndex < itemCount; itemIndex += 1) {
     const id = command[cursor];
-    if (!isAutoBatchResourceValue(id) || !isAutoBatchResourceValue(command[cursor + 1]) || !import_node_buffer32.Buffer.isBuffer(command[cursor + 2])) return void 0;
+    if (!isAutoBatchResourceValue(id) || !isAutoBatchResourceValue(command[cursor + 1]) || !import_node_buffer34.Buffer.isBuffer(command[cursor + 2])) return void 0;
     ids.push(id);
     cursor += 3;
     const afterValues = skipExtendedNamedItems(command, cursor, true);
@@ -10256,7 +10476,7 @@ function skipExtendedNamedItems(command, countIndex, encodedValues) {
   for (let index = 0; index < count; index += 1) {
     const name = command[firstItem + index * 2];
     const value = command[firstItem + index * 2 + 1];
-    if (!isAutoBatchResourceValue(name) || (encodedValues ? !import_node_buffer32.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
+    if (!isAutoBatchResourceValue(name) || (encodedValues ? !import_node_buffer34.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
   }
   return firstItem + count * 2;
 }
@@ -10271,7 +10491,7 @@ function runStepsManyAutoBatchIds(command) {
         ids.push(item);
         continue;
       }
-      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer32.Buffer.isBuffer(item)) return void 0;
+      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer34.Buffer.isBuffer(item)) return void 0;
       const id = item.id;
       if (!isAutoBatchResourceValue(id)) return void 0;
       ids.push(id);
@@ -10312,7 +10532,7 @@ function flowValuePutOwner(command, start) {
 }
 var flowValuePutOptionTokens = /* @__PURE__ */ new Set(["NAME", "NOW", "OVERRIDE", "OWNER_FLOW_ID", "PARTITION", "TTL", "TTL_MS"]);
 function isAutoBatchResourceValue(value) {
-  return typeof value === "string" || import_node_buffer32.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer34.Buffer.isBuffer(value);
 }
 function isFencingToken(value) {
   return typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint";
@@ -10321,7 +10541,7 @@ function nonNegativeItemCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
 function autoBatchResourceKey(namespace, value) {
-  return `${namespace}:${import_node_buffer32.Buffer.from(value).toString("base64")}`;
+  return `${namespace}:${import_node_buffer34.Buffer.from(value).toString("base64")}`;
 }
 function autoBatchCommandName(command) {
   return commandView(command).name ?? null;
@@ -10730,15 +10950,15 @@ function claimFailure(error) {
 }
 
 // src/client-flow-support.ts
-var import_node_buffer39 = require("buffer");
+var import_node_buffer42 = require("buffer");
 
 // src/client-core.ts
-var import_node_buffer38 = require("buffer");
+var import_node_buffer40 = require("buffer");
 
 // src/client-core-helpers.ts
-var import_node_buffer34 = require("buffer");
+var import_node_buffer36 = require("buffer");
 function bgsaveResponse(response) {
-  if ((typeof response === "string" || import_node_buffer34.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
+  if ((typeof response === "string" || import_node_buffer36.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
     return true;
   }
   return okResponse(response);
@@ -10752,7 +10972,7 @@ function fetchOrComputeCompletionToken(options) {
       "fetch-or-compute completion requires computeToken"
     );
   }
-  if (!import_node_buffer34.Buffer.isBuffer(options.computeToken)) {
+  if (!import_node_buffer36.Buffer.isBuffer(options.computeToken)) {
     throw new TypeError("fetch-or-compute computeToken must be a Buffer");
   }
   return options.computeToken;
@@ -10775,10 +10995,10 @@ function unsupportedClientCaching() {
 }
 
 // src/client-base.ts
-var import_node_buffer36 = require("buffer");
+var import_node_buffer38 = require("buffer");
 
 // src/client-executor.ts
-var import_node_buffer35 = require("buffer");
+var import_node_buffer37 = require("buffer");
 var ErrorMappingExecutor = class {
   constructor(executor) {
     this.executor = executor;
@@ -11112,14 +11332,14 @@ var FerricStoreAdministrationClient = class extends FerricStoreClientBase {
 };
 
 // src/store-utilities.ts
-var import_node_buffer37 = require("buffer");
+var import_node_buffer39 = require("buffer");
 function encode(codec, value) {
   return codec.encode(value);
 }
 function decode(codec, value) {
   if (value == null) return null;
-  if (import_node_buffer37.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer37.Buffer.from(value));
+  if (import_node_buffer39.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer39.Buffer.from(value));
   return value;
 }
 function number(value) {
@@ -11180,7 +11400,7 @@ function requireNonEmpty(values, command, noun = "argument") {
   if (values.length === 0) throw new TypeError(`${command} requires at least one ${noun}`);
   return values;
 }
-function commandName3(args) {
+function commandName4(args) {
   return typeof args[0] === "string" ? args[0] : "command";
 }
 function commandArgs(client, args) {
@@ -11195,7 +11415,7 @@ function arrayOrRest(values) {
 function appendXReadStreams(args, streams) {
   const offset = args.length;
   const streamCount = streams.length;
-  requireNonEmpty(streams, commandName3(args), "stream");
+  requireNonEmpty(streams, commandName4(args), "stream");
   args.length = offset + 1 + streamCount * 2;
   args[offset] = "STREAMS";
   for (let index = 0; index < streamCount; index += 1) {
@@ -11205,7 +11425,7 @@ function appendXReadStreams(args, streams) {
     const stream = streams[index];
     if (stream == null) throw new TypeError("XREAD streams must contain only stream descriptors");
     if (!Object.hasOwn(stream, "key") || !Object.hasOwn(stream, "id")) {
-      throw new TypeError(`${commandName3(args)} streams require own key and id fields`);
+      throw new TypeError(`${commandName4(args)} streams require own key and id fields`);
     }
     args[offset + 1 + index] = stream.key;
     args[offset + 1 + streamCount + index] = stream.id;
@@ -11227,7 +11447,7 @@ function concatArgs(...parts) {
   return args;
 }
 function encodedArgs(prefix, codec, values, allowEmpty = false) {
-  if (!allowEmpty) requireNonEmpty(values, commandName3(prefix));
+  if (!allowEmpty) requireNonEmpty(values, commandName4(prefix));
   const args = new Array(prefix.length + values.length);
   for (let index = 0; index < prefix.length; index += 1) args[index] = prefix[index];
   for (let index = 0; index < values.length; index += 1) {
@@ -11241,7 +11461,7 @@ function encodedArgs(prefix, codec, values, allowEmpty = false) {
 function keyValueArgs(prefix, codec, entries) {
   const validateTuples = Array.isArray(entries);
   const pairs = validateTuples ? entries : Object.entries(entries);
-  requireNonEmpty(pairs, commandName3(prefix), "entry");
+  requireNonEmpty(pairs, commandName4(prefix), "entry");
   const args = new Array(prefix.length + pairs.length * 2);
   for (let index = 0; index < prefix.length; index += 1) args[index] = prefix[index];
   for (let index = 0; index < pairs.length; index += 1) {
@@ -11255,7 +11475,7 @@ function keyValueArgs(prefix, codec, entries) {
   return args;
 }
 function encodedEntryArgs(prefix, codec, entries) {
-  requireNonEmpty(entries, commandName3(prefix), "entry");
+  requireNonEmpty(entries, commandName4(prefix), "entry");
   const args = new Array(prefix.length + entries.length * 2);
   for (let index = 0; index < prefix.length; index += 1) args[index] = prefix[index];
   for (let index = 0; index < entries.length; index += 1) {
@@ -13354,6 +13574,165 @@ function throwIfClosed(signal) {
   throw new FerricStoreError("FerricStore client is closed", { raw: signal.reason });
 }
 
+// src/flow-policy.ts
+var import_node_buffer41 = require("buffer");
+var MAX_FLOW_POLICY_GENERATION = Number.MAX_SAFE_INTEGER;
+function assertFlowPolicyGeneration(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError("expectedGeneration must be a nonnegative safe integer");
+  }
+}
+function flowPolicySnapshotFromResp(value) {
+  const policy = requiredRecord(value, "FLOW policy snapshot");
+  const maxActiveMs = optionalPositiveInteger(field(policy, "max_active_ms"), "max_active_ms");
+  const state = optionalText2(field(policy, "state"), "state");
+  const mode = optionalMode(field(policy, "mode"), "mode");
+  const version = optionalVersion(field(policy, "version"));
+  const indexedStateMeta = optionalText2(field(policy, "indexed_state_meta"), "indexed_state_meta");
+  const governance = optionalRecord(field(policy, "governance"), "governance");
+  const states = optionalStates(field(policy, "states"));
+  return {
+    type: requiredText(field(policy, "type"), "type"),
+    generation: nonNegativeInteger(field(policy, "generation"), "generation"),
+    ...state == null ? {} : { state },
+    ...version == null ? {} : { version },
+    ...mode == null ? {} : { mode },
+    ...maxActiveMs == null ? {} : { maxActiveMs },
+    retry: retrySnapshot(field(policy, "retry"), "retry"),
+    retention: retentionSnapshot(field(policy, "retention"), "retention"),
+    indexedAttributes: stringArray(field(policy, "indexed_attributes"), "indexed_attributes"),
+    ...indexedStateMeta == null ? {} : { indexedStateMeta },
+    ...governance == null ? {} : { governance },
+    ...states == null ? {} : { states },
+    raw: value
+  };
+}
+function retrySnapshot(value, context) {
+  const retry2 = requiredRecord(value, `FLOW policy ${context}`);
+  const backoff = requiredRecord(field(retry2, "backoff"), `FLOW policy ${context}.backoff`);
+  return {
+    maxRetries: nonNegativeInteger(field(retry2, "max_retries"), `${context}.max_retries`),
+    backoff: {
+      kind: backoffKind(field(backoff, "kind"), `${context}.backoff.kind`),
+      baseMs: nonNegativeInteger(field(backoff, "base_ms"), `${context}.backoff.base_ms`),
+      maxMs: nonNegativeInteger(field(backoff, "max_ms"), `${context}.backoff.max_ms`),
+      jitterPct: nonNegativeInteger(field(backoff, "jitter_pct"), `${context}.backoff.jitter_pct`)
+    },
+    exhaustedTo: requiredText(field(retry2, "exhausted_to"), `${context}.exhausted_to`)
+  };
+}
+function retentionSnapshot(value, context) {
+  const retention = requiredRecord(value, `FLOW policy ${context}`);
+  return {
+    ttlMs: nonNegativeInteger(field(retention, "ttl_ms"), `${context}.ttl_ms`),
+    historyMaxEvents: nonNegativeInteger(
+      field(retention, "history_max_events"),
+      `${context}.history_max_events`
+    )
+  };
+}
+function optionalStates(value) {
+  if (value == null) return void 0;
+  const source = requiredRecord(value, "FLOW policy states");
+  const result = {};
+  for (const [state, raw] of Object.entries(source)) {
+    const policy = requiredRecord(raw, `FLOW policy state ${state}`);
+    const maxActiveMs = optionalPositiveInteger(
+      field(policy, "max_active_ms"),
+      `states.${state}.max_active_ms`
+    );
+    const governance = optionalRecord(field(policy, "governance"), `states.${state}.governance`);
+    Object.defineProperty(result, state, {
+      configurable: true,
+      enumerable: true,
+      value: {
+        mode: requiredMode(field(policy, "mode"), `states.${state}.mode`),
+        ...maxActiveMs == null ? {} : { maxActiveMs },
+        retry: retrySnapshot(field(policy, "retry"), `states.${state}.retry`),
+        retention: retentionSnapshot(field(policy, "retention"), `states.${state}.retention`),
+        ...governance == null ? {} : { governance }
+      },
+      writable: true
+    });
+  }
+  return result;
+}
+function requiredRecord(value, context) {
+  if (value instanceof Map) {
+    const result = {};
+    for (const [key, item] of value.entries()) {
+      setOwnValue(result, requiredText(key, `${context} key`), item);
+    }
+    return result;
+  }
+  if (typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer41.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return value;
+  throw new TypeError(`${context} returned an unexpected response`);
+}
+function optionalRecord(value, context) {
+  return value == null ? void 0 : requiredRecord(value, `FLOW policy ${context}`);
+}
+function stringArray(value, context) {
+  if (!Array.isArray(value)) {
+    throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+  }
+  const result = new Array(value.length);
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index)) {
+      throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+    }
+    result[index] = requiredText(value[index], `${context}[${index}]`);
+  }
+  return result;
+}
+function requiredText(value, context) {
+  if (typeof value === "string") return value;
+  if (import_node_buffer41.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer41.Buffer.from(value).toString("utf8");
+  }
+  throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+}
+function optionalText2(value, context) {
+  return value == null ? void 0 : requiredText(value, context);
+}
+function nonNegativeInteger(value, context) {
+  let parsed;
+  try {
+    parsed = integer(value);
+  } catch {
+    throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+  }
+  if (parsed < 0) throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+  return parsed;
+}
+function optionalPositiveInteger(value, context) {
+  if (value == null) return void 0;
+  const parsed = nonNegativeInteger(value, context);
+  if (parsed === 0) throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+  return parsed;
+}
+function optionalVersion(value) {
+  if (value == null) return void 0;
+  if (typeof value === "number" || typeof value === "bigint") {
+    return nonNegativeInteger(value, "version");
+  }
+  return requiredText(value, "version");
+}
+function backoffKind(value, context) {
+  const kind = requiredText(value, context).toLowerCase();
+  if (kind === "none" || kind === "fixed" || kind === "linear" || kind === "exponential") {
+    return kind;
+  }
+  throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+}
+function requiredMode(value, context) {
+  const mode = requiredText(value, context).toLowerCase();
+  if (mode === "fifo" || mode === "parallel") return mode;
+  throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
+}
+function optionalMode(value, context) {
+  return value == null ? void 0 : requiredMode(value, context);
+}
+
 // src/client-flow-support.ts
 var FerricStoreFlowSupportClient = class extends FerricStoreManagementClient {
   async rewind(id, options = {}) {
@@ -13496,27 +13875,36 @@ var FerricStoreFlowSupportClient = class extends FerricStoreManagementClient {
   }
   async installPolicy(type, options = {}) {
     const args = ["FLOW.POLICY.SET", type];
+    const expectedGeneration = Object.hasOwn(options, "expectedGeneration") ? options.expectedGeneration : void 0;
+    const replace = Object.hasOwn(options, "replace") ? options.replace : void 0;
+    if (expectedGeneration != null) assertFlowPolicyGeneration(expectedGeneration);
+    if (replace != null && typeof replace !== "boolean") {
+      throw new TypeError("replace must be a boolean");
+    }
+    append(args, "EXPECTED_GENERATION", expectedGeneration);
+    appendBool(args, "REPLACE", replace);
     if (options.indexedAttributes != null) {
       args.push("INDEXED_ATTRIBUTES", JSON.stringify(options.indexedAttributes));
     }
     append(args, "INDEXED_STATE_META", options.indexedStateMeta);
     append(args, "MAX_ACTIVE_MS", options.maxActiveMs);
+    if (options.state == null) append(args, "RETENTION_TTL_MS", options.retentionTtlMs);
     append(args, "STATE", options.state);
     appendPolicyMode(args, options.state, options.mode);
     if (options.retry != null) {
       appendRetryPolicy(args, options.retry);
     }
+    if (options.state != null) append(args, "RETENTION_TTL_MS", options.retentionTtlMs);
     for (const [state, policy] of Object.entries(options.states ?? {})) {
       args.push("STATE", state);
       appendFlowStatePolicy(args, policy);
     }
-    append(args, "RETENTION_TTL_MS", options.retentionTtlMs);
-    return await this.commandArgs(args);
+    return flowPolicySnapshotFromResp(await this.commandArgs(args));
   }
   async policyGet(type, options = {}) {
     const args = ["FLOW.POLICY.GET", type];
     append(args, "STATE", options.state);
-    return parseKvResponse(await this.commandArgs(args));
+    return flowPolicySnapshotFromResp(await this.commandArgs(args));
   }
   async retentionCleanup() {
     return parseKvResponse(await this.command("FLOW.RETENTION_CLEANUP"));
@@ -13605,7 +13993,7 @@ var FerricStoreFlowSupportClient = class extends FerricStoreManagementClient {
 };
 
 // src/flow-many-snapshot.ts
-var import_node_buffer40 = require("buffer");
+var import_node_buffer43 = require("buffer");
 var encodedOptionFields = ["error", "payload", "reason", "result"];
 function snapshotCreateItem(item, codec) {
   const snapshot = {
@@ -13645,7 +14033,7 @@ function snapshotFlowManyOptions(options, codec) {
 }
 function snapshotClaimedItem(item) {
   const wire = item[CLAIMED_ITEM_WIRE];
-  const leaseToken = import_node_buffer40.Buffer.from(wire?.leaseToken ?? item.leaseToken);
+  const leaseToken = import_node_buffer43.Buffer.from(wire?.leaseToken ?? item.leaseToken);
   const snapshot = {
     ...item,
     fencingToken: wire?.fencingToken ?? item.fencingToken,
@@ -13662,15 +14050,15 @@ function snapshotClaimedItem(item) {
 function snapshotFencedItem(item) {
   return Object.freeze({
     ...item,
-    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer40.Buffer.from(item.leaseToken) }
+    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer43.Buffer.from(item.leaseToken) }
   });
 }
 function snapshotClaimedItemWire(wire, leaseToken) {
   return Object.freeze({
     fencingToken: wire.fencingToken,
-    id: import_node_buffer40.Buffer.from(wire.id),
+    id: import_node_buffer43.Buffer.from(wire.id),
     leaseToken,
-    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer40.Buffer.from(wire.partitionKey)
+    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer43.Buffer.from(wire.partitionKey)
   });
 }
 function snapshotArray(values) {
@@ -13681,7 +14069,7 @@ function snapshotArray(values) {
   return Object.freeze(snapshot);
 }
 function snapshotStateMeta(stateMeta) {
-  return snapshotRecord(stateMeta, (value) => import_node_buffer40.Buffer.isBuffer(value) ? import_node_buffer40.Buffer.from(value) : value);
+  return snapshotRecord(stateMeta, (value) => import_node_buffer43.Buffer.isBuffer(value) ? import_node_buffer43.Buffer.from(value) : value);
 }
 function snapshotCommandRecord(values) {
   const seen = /* @__PURE__ */ new WeakMap();
@@ -13699,7 +14087,7 @@ function snapshotRecord(values, capture) {
 }
 function snapshotCommandArgument(value, seen) {
   if (typeof value !== "object" || value == null) return value;
-  if (import_node_buffer40.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer40.Buffer.from(value);
+  if (import_node_buffer43.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer43.Buffer.from(value);
   const objectValue = value;
   const existing = seen.get(objectValue);
   if (existing != null) return existing;
@@ -14921,7 +15309,7 @@ async function runContinuousWorkerPool(options) {
     initialIdleSleepMs,
     nonNegativeDuration(options.maxIdleSleepMs, 5e3)
   );
-  const refillDelayMs = nonNegativeInteger(options.refillDelayMs, 0);
+  const refillDelayMs = nonNegativeInteger2(options.refillDelayMs, 0);
   const active = /* @__PURE__ */ new Set();
   const pending = [];
   let pendingIndex = 0;
@@ -15040,7 +15428,7 @@ function normalizeWorkflowWorkerConfig(options) {
 function positiveInteger(value, fallback) {
   return value == null || !Number.isFinite(value) ? fallback : Math.max(1, Math.trunc(value));
 }
-function nonNegativeInteger(value, fallback) {
+function nonNegativeInteger2(value, fallback) {
   return value == null || !Number.isFinite(value) ? fallback : Math.max(0, Math.trunc(value));
 }
 function nonNegativeDuration(value, fallback) {
@@ -16456,6 +16844,7 @@ var Workflow = class {
     }
     return await this.client.installPolicy(this.type, {
       ...options,
+      replace: Object.hasOwn(options, "replace") ? options.replace ?? true : true,
       states
     });
   }
@@ -16668,8 +17057,8 @@ var WorkflowWorker = class {
 };
 
 // src/version.ts
-var FERRICSTORE_SDK_VERSION = "0.2.0";
-var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.8.0";
+var FERRICSTORE_SDK_VERSION = "0.3.0";
+var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.9.1";
 var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -16699,6 +17088,7 @@ var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
   ListStore,
   LockHeldError,
   LockNotOwnedError,
+  MAX_FLOW_POLICY_GENERATION,
   NativeAdapter,
   OverloadedError,
   Queue,
@@ -16713,6 +17103,7 @@ var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
   SetStore,
   SortedSetStore,
   StaleLeaseError,
+  StalePolicyGenerationError,
   StreamStore,
   TDigestStore,
   TopKStore,