@ferricstore/ferricstore 0.1.7 → 0.3.0

package/dist/index.js

@@ -16,10 +16,16 @@ import "buffer";
 var FerricStoreError = class extends Error {
   code = "ferricstore_error";
   raw;
+  retryable;
+  safeToRetry;
+  retryAfterMs;
   constructor(message, options = {}) {
     super(message, { cause: options.cause });
     this.name = new.target.name;
     this.raw = options.raw;
+    this.retryable = options.retryable ?? structuredBooleanField(options.raw, "retryable");
+    this.safeToRetry = options.safeToRetry ?? structuredBooleanField(options.raw, "safe_to_retry");
+    this.retryAfterMs = options.retryAfterMs ?? structuredIntegerField(options.raw, "retry_after_ms");
   }
 };
 var ConnectionClosedError = class extends FerricStoreError {
@@ -52,6 +58,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";
 };
@@ -66,11 +75,14 @@ var InvalidCommandError = class extends FerricStoreError {
 };
 var OverloadedError = class extends FerricStoreError {
   code = "overloaded";
-  retryAfterMs;
   reason;
   constructor(message, options = {}) {
-    super(message, options);
-    this.retryAfterMs = options.retryAfterMs;
+    const local = options.raw == null;
+    super(message, {
+      ...options,
+      retryable: options.retryable ?? (local ? true : void 0),
+      safeToRetry: options.safeToRetry ?? (local ? true : void 0)
+    });
     this.reason = options.reason;
   }
 };
@@ -88,15 +100,21 @@ function classifyServerError(message, raw, cause, status) {
   const lower = message.toLowerCase();
   const structuredCode = structuredStringField(raw, "code");
   const code = structuredCode?.toLowerCase();
+  const retry2 = {
+    retryable: structuredBooleanField(raw, "retryable"),
+    safeToRetry: structuredBooleanField(raw, "safe_to_retry"),
+    retryAfterMs: structuredIntegerField(raw, "retry_after_ms") ?? intField(lower, "retry_after_ms")
+  };
   if (isRerouteStatus(status) || code === "reroute") {
-    return new RerouteError(message, { cause, raw });
+    return new RerouteError(message, { cause, raw, ...definedRetryMetadata(retry2) });
   }
   if (isBusyStatus(status) || isOverloadCode(structuredCode) || overloadMessage(lower)) {
     return new OverloadedError(message, {
       cause,
       raw,
+      ...definedRetryMetadata(retry2),
       reason: structuredStringField(raw, "reason") ?? structuredCode ?? stringField(lower, "reason"),
-      retryAfterMs: structuredIntegerField(raw, "retry_after_ms") ?? intField(lower, "retry_after_ms")
+      retryAfterMs: retry2.retryAfterMs
     });
   }
   if (code === "flow_already_exists" || lower.includes("flow") && lower.includes("already exists")) {
@@ -108,6 +126,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 });
   }
@@ -120,7 +141,7 @@ function classifyServerError(message, raw, cause, status) {
   if (code === "invalid_command" || lower.includes("wrong number of arguments") || lower.includes("syntax error")) {
     return new InvalidCommandError(message, { cause, raw });
   }
-  return new FerricStoreError(message, { cause, raw });
+  return new FerricStoreError(message, { cause, raw, ...definedRetryMetadata(retry2) });
 }
 function mapException(error) {
   if (error instanceof FerricStoreError) {
@@ -160,8 +181,23 @@ function structuredIntegerField(raw, name) {
   if (typeof value === "bigint") {
     return value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : void 0;
   }
-  const text2 = binaryText(value);
-  return text2 == null ? void 0 : nonNegativeSafeIntegerText(text2);
+  const text3 = binaryText(value);
+  return text3 == null ? void 0 : nonNegativeSafeIntegerText(text3);
+}
+function structuredBooleanField(raw, name) {
+  const value = structuredField(raw, name);
+  if (typeof value === "boolean") return value;
+  const text3 = binaryText(value)?.toLowerCase();
+  if (text3 === "true" || text3 === "1") return true;
+  if (text3 === "false" || text3 === "0") return false;
+  return void 0;
+}
+function definedRetryMetadata(metadata) {
+  return {
+    ...metadata.retryable == null ? {} : { retryable: metadata.retryable },
+    ...metadata.safeToRetry == null ? {} : { safeToRetry: metadata.safeToRetry },
+    ...metadata.retryAfterMs == null ? {} : { retryAfterMs: metadata.retryAfterMs }
+  };
 }
 function nonNegativeSafeIntegerText(value) {
   if (!/^[0-9]+$/u.test(value)) return void 0;
@@ -334,9 +370,6 @@ function mapDenseResponseArray(value, transform) {
   return result;
 }
 
-// src/auto-partition.ts
-import { Buffer as Buffer3 } from "buffer";
-
 // src/crc32.ts
 import "buffer";
 var table = new Uint32Array(256);
@@ -354,12 +387,49 @@ function crc32(buffer) {
   }
   return (value ^ 4294967295) >>> 0;
 }
+function crc32Utf8(text3, start = 0, end = text3.length) {
+  let value = 4294967295;
+  for (let index = start; index < end; index += 1) {
+    const first = text3.charCodeAt(index);
+    let point = first;
+    if (first >= 55296 && first <= 56319) {
+      const second = index + 1 < end ? text3.charCodeAt(index + 1) : 0;
+      if (second >= 56320 && second <= 57343) {
+        point = 65536 + (first - 55296 << 10) + second - 56320;
+        index += 1;
+      } else {
+        point = 65533;
+      }
+    } else if (first >= 56320 && first <= 57343) {
+      point = 65533;
+    }
+    if (point < 128) {
+      value = updateCrc32(value, point);
+    } else if (point < 2048) {
+      value = updateCrc32(value, 192 | point >>> 6);
+      value = updateCrc32(value, 128 | point & 63);
+    } else if (point < 65536) {
+      value = updateCrc32(value, 224 | point >>> 12);
+      value = updateCrc32(value, 128 | point >>> 6 & 63);
+      value = updateCrc32(value, 128 | point & 63);
+    } else {
+      value = updateCrc32(value, 240 | point >>> 18);
+      value = updateCrc32(value, 128 | point >>> 12 & 63);
+      value = updateCrc32(value, 128 | point >>> 6 & 63);
+      value = updateCrc32(value, 128 | point & 63);
+    }
+  }
+  return (value ^ 4294967295) >>> 0;
+}
+function updateCrc32(value, byte) {
+  return value >>> 8 ^ (table[(value ^ byte) & 255] ?? 0);
+}
 
 // src/auto-partition.ts
 var AUTO_PARTITION_PREFIX = "__flow_auto__:";
 var AUTO_PARTITION_BUCKETS = 256;
 function autoPartitionKeyForId(id) {
-  return `${AUTO_PARTITION_PREFIX}${crc32(Buffer3.from(id)) % AUTO_PARTITION_BUCKETS}`;
+  return `${AUTO_PARTITION_PREFIX}${crc32Utf8(id) % AUTO_PARTITION_BUCKETS}`;
 }
 
 // src/flow-argument-helpers.ts
@@ -752,7 +822,7 @@ function coerceDiagnosticValue(value) {
 // src/native-connection.ts
 import net from "net";
 import tls from "tls";
-import { Buffer as Buffer4 } from "buffer";
+import { Buffer as Buffer3 } from "buffer";
 function parseFerricUrl(value) {
   const url = new URL(value);
   if (url.protocol !== "ferric:" && url.protocol !== "ferrics:") {
@@ -878,7 +948,7 @@ function nonNegativeSafeInteger(value) {
   if (typeof value === "bigint") {
     return value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : void 0;
   }
-  const source = Buffer4.isBuffer(value) || value instanceof Uint8Array ? Buffer4.from(value).toString("utf8") : value;
+  const source = Buffer3.isBuffer(value) || value instanceof Uint8Array ? Buffer3.from(value).toString("utf8") : value;
   if (typeof source !== "number" && (typeof source !== "string" || !/^\d+$/u.test(source))) {
     return void 0;
   }
@@ -1112,10 +1182,10 @@ var NativeHeartbeat = class {
 };
 
 // src/protocol.ts
-import { Buffer as Buffer19 } from "buffer";
+import { Buffer as Buffer23 } from "buffer";
 
 // src/command-grammar.ts
-import { Buffer as Buffer5 } from "buffer";
+import { Buffer as Buffer4 } from "buffer";
 
 // src/command-metadata-flow.ts
 var flowStateIdCommands = /* @__PURE__ */ new Set([
@@ -1562,8 +1632,8 @@ var secondKeySubcommands = /* @__PURE__ */ new Map([
 ]);
 function commandToken(value) {
   if (typeof value === "string") return value.toUpperCase();
-  if (Buffer5.isBuffer(value) || value instanceof Uint8Array) {
-    return Buffer5.from(value).toString("utf8").toUpperCase();
+  if (Buffer4.isBuffer(value) || value instanceof Uint8Array) {
+    return Buffer4.from(value).toString("utf8").toUpperCase();
   }
   return void 0;
 }
@@ -1666,7 +1736,7 @@ function safeIntegerArgument(value) {
   if (typeof value === "bigint") {
     return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : void 0;
   }
-  const source = typeof value === "string" ? value : Buffer5.isBuffer(value) || value instanceof Uint8Array ? Buffer5.from(value).toString("utf8") : void 0;
+  const source = typeof value === "string" ? value : Buffer4.isBuffer(value) || value instanceof Uint8Array ? Buffer4.from(value).toString("utf8") : void 0;
   if (source == null || !/^[+-]?\d+$/u.test(source)) return void 0;
   const parsed = BigInt(source);
   return parsed >= BigInt(Number.MIN_SAFE_INTEGER) && parsed <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(parsed) : void 0;
@@ -1719,7 +1789,7 @@ function hasOwnCommandArgument(args, index, end, section) {
 }
 
 // src/protocol-core.ts
-import { Buffer as Buffer9 } from "buffer";
+import { Buffer as Buffer8 } from "buffer";
 
 // src/protocol-constants.ts
 import "buffer";
@@ -1927,80 +1997,30 @@ var OPCODES = {
   flowFail: COMMAND_OPCODES["FLOW.FAIL"],
   flowValuePut: COMMAND_OPCODES["FLOW.VALUE.PUT"],
   flowValueMGet: COMMAND_OPCODES["FLOW.VALUE.MGET"],
+  flowSignal: COMMAND_OPCODES["FLOW.SIGNAL"],
   flowCreateMany: COMMAND_OPCODES["FLOW.CREATE_MANY"],
   flowCompleteMany: COMMAND_OPCODES["FLOW.COMPLETE_MANY"],
   flowTransitionMany: COMMAND_OPCODES["FLOW.TRANSITION_MANY"],
   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"],
   flowRunStepsMany: COMMAND_OPCODES["FLOW.RUN_STEPS_MANY"],
   flowSearch: COMMAND_OPCODES["FLOW.SEARCH"]
 };
-var COMPACT_RESPONSE_OPCODES = {
-  flow_claim_jobs_v1: [COMMAND_OPCODES["FLOW.CLAIM_DUE"]],
-  flow_record_list_v1: [
-    COMMAND_OPCODES["FLOW.LIST"],
-    COMMAND_OPCODES["FLOW.TERMINALS"],
-    COMMAND_OPCODES["FLOW.FAILURES"],
-    COMMAND_OPCODES["FLOW.BY_PARENT"],
-    COMMAND_OPCODES["FLOW.BY_ROOT"],
-    COMMAND_OPCODES["FLOW.BY_CORRELATION"],
-    COMMAND_OPCODES["FLOW.STUCK"]
-  ],
-  flow_record_v1: [COMMAND_OPCODES["FLOW.GET"]],
-  kv_get_v1: [COMMAND_OPCODES.GET],
-  kv_mget_v1: [COMMAND_OPCODES.MGET, COMMAND_OPCODES["FLOW.VALUE.MGET"]],
-  ok_list_v1: [
-    COMMAND_OPCODES.SET,
-    COMMAND_OPCODES.MSET,
-    COMMAND_OPCODES["FLOW.CREATE_MANY"],
-    COMMAND_OPCODES["FLOW.COMPLETE_MANY"],
-    COMMAND_OPCODES["FLOW.RETRY_MANY"],
-    COMMAND_OPCODES["FLOW.FAIL_MANY"],
-    COMMAND_OPCODES["FLOW.CANCEL_MANY"]
-  ],
-  pipeline_v1: [COMMAND_OPCODES.PIPELINE]
-};
-var COMPACT_KIND_FLOW_CLAIM_JOBS = 1 << 0;
-var COMPACT_KIND_FLOW_RECORD = 1 << 1;
-var COMPACT_KIND_FLOW_RECORD_LIST = 1 << 2;
-var COMPACT_KIND_KV_GET = 1 << 3;
-var COMPACT_KIND_KV_MGET = 1 << 4;
-var COMPACT_KIND_OK_LIST = 1 << 5;
-var COMPACT_KIND_PIPELINE = 1 << 6;
-var compactResponseOpcodeKinds = new Uint8Array(
-  Math.max(...Object.values(COMPACT_RESPONSE_OPCODES).flat()) + 1
-);
-registerCompactResponseOpcodes(COMPACT_KIND_FLOW_CLAIM_JOBS, COMPACT_RESPONSE_OPCODES.flow_claim_jobs_v1);
-registerCompactResponseOpcodes(COMPACT_KIND_FLOW_RECORD, COMPACT_RESPONSE_OPCODES.flow_record_v1);
-registerCompactResponseOpcodes(COMPACT_KIND_FLOW_RECORD_LIST, COMPACT_RESPONSE_OPCODES.flow_record_list_v1);
-registerCompactResponseOpcodes(COMPACT_KIND_KV_GET, COMPACT_RESPONSE_OPCODES.kv_get_v1);
-registerCompactResponseOpcodes(COMPACT_KIND_KV_MGET, [
-  ...COMPACT_RESPONSE_OPCODES.kv_mget_v1,
-  COMMAND_OPCODES.PIPELINE
-]);
-registerCompactResponseOpcodes(COMPACT_KIND_OK_LIST, [
-  ...COMPACT_RESPONSE_OPCODES.ok_list_v1,
-  COMMAND_OPCODES.PIPELINE
-]);
-registerCompactResponseOpcodes(COMPACT_KIND_PIPELINE, COMPACT_RESPONSE_OPCODES.pipeline_v1);
-function registerCompactResponseOpcodes(kind, opcodes) {
-  for (const opcode of opcodes) {
-    compactResponseOpcodeKinds[opcode] = (compactResponseOpcodeKinds[opcode] ?? 0) | kind;
-  }
-}
-function compactResponseOpcodeSupports(opcode, kind) {
-  return ((compactResponseOpcodeKinds[opcode] ?? 0) & kind) !== 0;
-}
 var COMPACT_FLOW_CLAIM_JOBS = 128;
 var COMPACT_OK_LIST = 129;
 var COMPACT_KV_GET = 130;
 var COMPACT_KV_MGET = 131;
 var COMPACT_FLOW_RECORD = 132;
 var COMPACT_FLOW_RECORD_LIST = 133;
+var COMPACT_BINARY_LIST_LIST = 134;
+var COMPACT_BINARY_MAP_LIST = 135;
+var COMPACT_INTEGER_LIST = 136;
 var COMPACT_KV_MGET_FIXED = 137;
 var COMPACT_FLOW_CREATE_MANY_REQUEST = 144;
 var COMPACT_FLOW_CLAIM_DUE_REQUEST = 145;
@@ -2070,16 +2090,16 @@ var FLOW_RECORD_FIELD_KEYS = [
 ];
 
 // src/protocol-text.ts
-import { Buffer as Buffer7 } from "buffer";
+import { Buffer as Buffer6 } from "buffer";
 function toBuffer(value) {
-  if (Buffer7.isBuffer(value)) return value;
-  if (value instanceof Uint8Array) return Buffer7.from(value);
-  if (typeof value === "string") return Buffer7.from(value);
+  if (Buffer6.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return Buffer6.from(value);
+  if (typeof value === "string") return Buffer6.from(value);
   if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return Buffer7.from(String(value));
+    return Buffer6.from(String(value));
   }
-  if (typeof value === "symbol") return Buffer7.from(value.description ?? value.toString());
-  if (value == null) return Buffer7.alloc(0);
+  if (typeof value === "symbol") return Buffer6.from(value.description ?? value.toString());
+  if (value == null) return Buffer6.alloc(0);
   throw new FerricStoreError(`unsupported binary command argument type: ${typeof value}`);
 }
 function asText(value) {
@@ -2087,14 +2107,14 @@ function asText(value) {
 }
 function optionalText(value) {
   if (value == null || value === "") return void 0;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || Buffer7.isBuffer(value) || value instanceof Uint8Array) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || Buffer6.isBuffer(value) || value instanceof Uint8Array) {
     return asText(value);
   }
   return void 0;
 }
 function commandTokenIs(value, expected) {
   if (typeof value === "string") return value.toUpperCase() === expected;
-  if (Buffer7.isBuffer(value) || value instanceof Uint8Array) {
+  if (Buffer6.isBuffer(value) || value instanceof Uint8Array) {
     return asText(value).toUpperCase() === expected;
   }
   return false;
@@ -2108,7 +2128,7 @@ function commandNameIs(value, expected) {
 }
 
 // src/request-context.ts
-import { Buffer as Buffer8 } from "buffer";
+import { Buffer as Buffer7 } from "buffer";
 var requestContextCommands = /* @__PURE__ */ new Set([
   "INVOCATION.CREATE",
   "INVOCATION.DEFINITION.GET",
@@ -2163,9 +2183,9 @@ function requestContextCommandToken(value) {
     const upper = value.toUpperCase();
     return isRequestContextCommand(upper) ? upper : void 0;
   }
-  if (Buffer8.isBuffer(value) || value instanceof Uint8Array) {
+  if (Buffer7.isBuffer(value) || value instanceof Uint8Array) {
     if (value[0] !== 73 && value[0] !== 105) return void 0;
-    const command = Buffer8.from(value).toString("utf8").toUpperCase();
+    const command = Buffer7.from(value).toString("utf8").toUpperCase();
     return isRequestContextCommand(command) ? command : void 0;
   }
   return void 0;
@@ -2196,12 +2216,12 @@ function requestContextText(context, fieldName) {
   return value;
 }
 function isPlainObject(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !Buffer8.isBuffer(value) && !(value instanceof Uint8Array);
+  return typeof value === "object" && value != null && !Array.isArray(value) && !Buffer7.isBuffer(value) && !(value instanceof Uint8Array);
 }
 function commandToken2(value) {
   if (typeof value === "string") return value.toUpperCase();
-  if (Buffer8.isBuffer(value) || value instanceof Uint8Array) {
-    return Buffer8.from(value).toString("utf8").toUpperCase();
+  if (Buffer7.isBuffer(value) || value instanceof Uint8Array) {
+    return Buffer7.from(value).toString("utf8").toUpperCase();
   }
   return "";
 }
@@ -2291,17 +2311,17 @@ function requestFrameTooLarge(maxBytes) {
   );
 }
 function binaryValueByteLength(value) {
-  if (Buffer9.isBuffer(value) || value instanceof Uint8Array) return value.byteLength;
-  if (typeof value === "string") return Buffer9.byteLength(value);
+  if (Buffer8.isBuffer(value) || value instanceof Uint8Array) return value.byteLength;
+  if (typeof value === "string") return Buffer8.byteLength(value);
   if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return Buffer9.byteLength(String(value));
+    return Buffer8.byteLength(String(value));
   }
-  if (typeof value === "symbol") return Buffer9.byteLength(value.description ?? value.toString());
+  if (typeof value === "symbol") return Buffer8.byteLength(value.description ?? value.toString());
   if (value == null) return 0;
   return toBuffer(value).byteLength;
 }
 function writeCustomPayload(output, offset, value, knownByteLength) {
-  if (Buffer9.isBuffer(value)) {
+  if (Buffer8.isBuffer(value)) {
     value.copy(output, offset);
     return;
   }
@@ -2310,17 +2330,17 @@ function writeCustomPayload(output, offset, value, knownByteLength) {
     return;
   }
   if (value == null) return;
-  let text2;
+  let text3;
   if (typeof value === "string") {
-    text2 = value;
+    text3 = value;
   } else if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    text2 = String(value);
+    text3 = String(value);
   } else if (typeof value === "symbol") {
-    text2 = value.description ?? value.toString();
+    text3 = value.description ?? value.toString();
   } else {
     throw new FerricStoreError(`unsupported binary command argument type: ${typeof value}`);
   }
-  output.write(text2, offset, knownByteLength ?? Buffer9.byteLength(text2), "utf8");
+  output.write(text3, offset, knownByteLength ?? Buffer8.byteLength(text3), "utf8");
 }
 function compactBinaryEncodedLength(value) {
   return 4 + compactBinaryByteLength(value);
@@ -2333,10 +2353,10 @@ function compactBinaryByteLength(value) {
   return byteLength;
 }
 function isCompactBinaryArgument(value) {
-  return typeof value === "string" || Buffer9.isBuffer(value) || value instanceof Uint8Array;
+  return typeof value === "string" || Buffer8.isBuffer(value) || value instanceof Uint8Array;
 }
 function isCompactBinaryScalar(value) {
-  return value == null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || typeof value === "symbol" || Buffer9.isBuffer(value) || value instanceof Uint8Array;
+  return value == null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || typeof value === "symbol" || Buffer8.isBuffer(value) || value instanceof Uint8Array;
 }
 function compactOptionalBinaryEncodedLength(value) {
   return value == null ? 4 : compactBinaryEncodedLength(value);
@@ -2419,13 +2439,13 @@ function i64Arg(value) {
 }
 function boolArg(value) {
   if (typeof value === "boolean") return value;
-  const text2 = asText(value).toUpperCase();
-  return text2 === "1" || text2 === "TRUE" || text2 === "YES" || text2 === "ON";
+  const text3 = asText(value).toUpperCase();
+  return text3 === "1" || text3 === "TRUE" || text3 === "YES" || text3 === "ON";
 }
 function isBoolToken(value) {
   if (typeof value === "boolean") return true;
-  const text2 = asText(value).toUpperCase();
-  return text2 === "1" || text2 === "0" || text2 === "TRUE" || text2 === "FALSE" || text2 === "YES" || text2 === "NO" || text2 === "ON" || text2 === "OFF";
+  const text3 = asText(value).toUpperCase();
+  return text3 === "1" || text3 === "0" || text3 === "TRUE" || text3 === "FALSE" || text3 === "YES" || text3 === "NO" || text3 === "ON" || text3 === "OFF";
 }
 function independentMode(value) {
   if (value === true) return 2;
@@ -2467,7 +2487,23 @@ function setOwnValue2(target, key, value) {
 }
 
 // src/protocol-flow-options.ts
-import { Buffer as Buffer10 } from "buffer";
+import { Buffer as Buffer9 } from "buffer";
+
+// src/protocol-flow-option-value.ts
+function setFlowOptionValue(payload, field2, value, repeat) {
+  if (!repeat || !Object.hasOwn(payload, field2)) {
+    setOwnValue2(payload, field2, value);
+    return;
+  }
+  const previous = payload[field2];
+  setOwnValue2(
+    payload,
+    field2,
+    Array.isArray(previous) ? [...previous, value] : [previous, value]
+  );
+}
+
+// src/protocol-flow-options.ts
 var OPTION_FIELDS = {
   CONSISTENT_PROJECTION: "consistent_projection",
   COUNT: "count",
@@ -2542,7 +2578,7 @@ function normalizeFlowSearchStateMeta(payload) {
   payload.state_meta = { [asText(state)]: stateMeta };
 }
 function isPlainObject2(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !Buffer10.isBuffer(value) && !(value instanceof Uint8Array);
+  return typeof value === "object" && value != null && !Array.isArray(value) && !Buffer9.isBuffer(value) && !(value instanceof Uint8Array);
 }
 function parseFlowOptions(args, start, end, config) {
   const payload = {};
@@ -2636,8 +2672,9 @@ function parseFlowOptions(args, start, end, config) {
       case "TRANSITION_TO":
       case "TO_EVENT":
       case "EXPECT_STATE": {
-        const field2 = token.toLowerCase();
-        if (!putScalar(payload, field2, args, index + 1, end)) return void 0;
+        const field2 = token === "IDEMPOTENCY" ? "idempotency_key" : token.toLowerCase();
+        if (!hasOwnCommandArgument(args, index + 1, end, "Flow options")) return void 0;
+        setFlowOptionValue(payload, field2, args[index + 1], token === "IF_STATE");
         index += 2;
         break;
       }
@@ -2927,6 +2964,7 @@ var FLOW_ADMIN_FIELDS = {
   LEASE_MS: "lease_ms",
   LEASE_TOKEN: "lease_token",
   LIMIT: "limit",
+  MAX_ACTIVE_MS: "max_active_ms",
   MAX_FIRES: "max_fires",
   MAXBYTES: "payload_max_bytes",
   NOW: "now_ms",
@@ -2936,7 +2974,6 @@ var FLOW_ADMIN_FIELDS = {
   OVERLAP_RETRY_MS: "overlap_retry_ms",
   OVERWRITE: "overwrite",
   PARENT_FLOW_ID: "parent_flow_id",
-  PARENT_ID: "parent_id",
   PARTITION: "partition_key",
   PAYLOAD: "payload",
   PAYLOAD_MAX_BYTES: "payload_max_bytes",
@@ -2951,7 +2988,6 @@ var FLOW_ADMIN_FIELDS = {
   REV: "rev",
   RETURN: "return",
   ROOT_FLOW_ID: "root_flow_id",
-  ROOT_ID: "root_id",
   SCOPE: "scope",
   SHARD_ID: "shard_id",
   START_AT_MS: "start_at_ms",
@@ -3088,7 +3124,7 @@ function flowAdminPayload(opcode, args, leadingFields = []) {
 }
 
 // src/protocol-flow-compact.ts
-import { Buffer as Buffer12 } from "buffer";
+import { Buffer as Buffer11 } from "buffer";
 
 // src/protocol-flow-compact-common.ts
 function compactManyRequestTag(value, regularTag, okOnSuccessTag) {
@@ -3197,7 +3233,7 @@ function parseNamedCountMap(values, start) {
 }
 
 // src/protocol-flow-compact-transition.ts
-import { Buffer as Buffer11 } from "buffer";
+import { Buffer as Buffer10 } from "buffer";
 function compactFlowTransitionManyPayload(partition, fromState, toState, rawItems, mixed, options, maxBodyBytes) {
   if ("payload" in options || "priority" in options || "state_meta" in options || "values" in options || "value_refs" in options || "drop_values" in options || "override_values" in options || "attributes_merge" in options || "attributes_delete" in options || typeof options.now_ms !== "number" || !Number.isSafeInteger(options.now_ms) || options.now_ms < 0) {
     return void 0;
@@ -3249,7 +3285,7 @@ function compactFlowTransitionManyPayload(partition, fromState, toState, rawItem
     total += 4 + idLength + 4 + itemPartitionLength + 8 + 4 + leaseLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer11.allocUnsafe(total);
+  const out = Buffer10.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(tag, offset);
   offset += 1;
@@ -3307,7 +3343,7 @@ function compactFlowCreateManyPayload(partition, rawItems, mixed, auto, options,
   }
   assertCompactPayloadFits(total, maxBodyBytes);
   const tag = mixed ? COMPACT_FLOW_CREATE_MANY_MIXED_REQUEST : auto ? COMPACT_FLOW_CREATE_MANY_REQUEST : COMPACT_FLOW_CREATE_MANY_PARTITION_REQUEST;
-  const out = Buffer12.allocUnsafe(total);
+  const out = Buffer11.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(tag, offset++);
   offset = writeBinary(out, offset, toBuffer(options.type));
@@ -3352,7 +3388,7 @@ function compactFlowClaimDuePayload(type, options, maxBodyBytes) {
     total += 1;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer12.allocUnsafe(total);
+  const out = Buffer11.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(COMPACT_FLOW_CLAIM_DUE_REQUEST, offset++);
   offset = writeBinary(out, offset, toBuffer(type));
@@ -3406,7 +3442,7 @@ function compactFlowCompleteManyPayload(opcode, partition, rawItems, mixed, auto
     total += compactBinaryEncodedLength(rawItems[rawIndex]) + compactOptionalBinaryEncodedLength(mixed ? rawItems[rawIndex + 1] : null) + compactBinaryEncodedLength(rawItems[rawIndex + width - 2]) + 8;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer12.allocUnsafe(total);
+  const out = Buffer11.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(
     returnMode === "OK_ON_SUCCESS" ? COMPACT_FLOW_COMPLETE_MANY_OK_REQUEST : COMPACT_FLOW_COMPLETE_MANY_REQUEST,
@@ -3453,7 +3489,7 @@ function compactFlowRetryManyPayload(partition, rawItems, mixed, auto, options,
     total += compactBinaryEncodedLength(rawItems[rawIndex]) + compactOptionalBinaryEncodedLength(mixed ? rawItems[rawIndex + 1] : null) + compactBinaryEncodedLength(rawItems[rawIndex + width - 2]) + 8;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer12.allocUnsafe(total);
+  const out = Buffer11.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(
     returnMode === "OK_ON_SUCCESS" ? COMPACT_FLOW_RETRY_MANY_OK_REQUEST : COMPACT_FLOW_RETRY_MANY_REQUEST,
@@ -3541,7 +3577,7 @@ function compactFlowCancelManyPayload(args, maxBodyBytes) {
     total += 4 + idLength + 4 + itemPartitionLength + 8;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer12.allocUnsafe(total);
+  const out = Buffer11.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(tag, offset);
   offset += 1;
@@ -3577,7 +3613,7 @@ function isOptionalSafeIntegerNumber(value) {
 }
 
 // src/protocol-flow-compact-single.ts
-import { Buffer as Buffer13 } from "buffer";
+import { Buffer as Buffer12 } from "buffer";
 function compactFlowValueMGetPayload(refs, maxBytes, maxBodyBytes) {
   if (refs.length > 4294967295 || maxBytes != null && (typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 0)) return void 0;
   const minimum = 13 + refs.length * 4;
@@ -3594,7 +3630,7 @@ function compactFlowValueMGetPayload(refs, maxBytes, maxBodyBytes) {
     total += 4 + byteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer13.allocUnsafe(total);
+  const out = Buffer12.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(COMPACT_FLOW_VALUE_MGET_REQUEST, offset);
   offset += 1;
@@ -3637,7 +3673,7 @@ function compactFlowListPayload(args, maxBodyBytes) {
   const stateLength = state == null ? 0 : compactBinaryByteLength(state);
   const total = 1 + 4 + typeLength + 4 + stateLength + 8 + 1;
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = Buffer13.allocUnsafe(total);
+  const out = Buffer12.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(COMPACT_FLOW_LIST_REQUEST, offset);
   offset += 1;
@@ -4080,6 +4116,7 @@ function flowSpawnChildrenPayload(args) {
       "FROM_STATE",
       "ON_CHILD_FAILED",
       "ON_PARENT_CLOSED",
+      "MAX_ACTIVE_MS",
       "VALUE",
       "VALUE_REF"
     ])
@@ -4110,6 +4147,185 @@ function flowSearchPayload(args) {
   return { opcode: OPCODES.flowSearch, payload: { type: args[0], ...payload } };
 }
 
+// src/protocol-flow-signal.ts
+function flowSignalPayload(args) {
+  if (args.length < 3) return void 0;
+  const options = parseFlowOptions(args, 1, args.length, {
+    allowed: /* @__PURE__ */ new Set([
+      "SIGNAL",
+      "PARTITION",
+      "IDEMPOTENCY",
+      "IF_STATE",
+      "TRANSITION_TO",
+      "RUN_AT",
+      "NOW",
+      "VALUE",
+      "VALUE_REF",
+      "DROP_VALUE",
+      "OVERRIDE_VALUE"
+    ]),
+    required: /* @__PURE__ */ new Set(["SIGNAL"])
+  });
+  if (options == null) return void 0;
+  return { opcode: OPCODES.flowSignal, payload: { id: args[0], ...options } };
+}
+
+// src/protocol-flow-policy.ts
+import { Buffer as Buffer13 } from "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" || Buffer13.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 +4517,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)) {
@@ -4313,7 +4529,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;
     }
@@ -4476,15 +4692,20 @@ function fetchOrComputeCommand(args) {
   };
 }
 function fetchOrComputeResultCommand(args) {
-  if (args.length !== 4 || !isBinaryCommandArgument(args[0]) || !isBinaryCommandArgument(args[1])) return void 0;
+  if (args.length !== 4 || !isBinaryCommandArgument(args[0]) || !isBinaryCommandArgument(args[1])) {
+    throw new FerricStoreError("FETCH_OR_COMPUTE_RESULT requires key, ownership token, value, and ttl_ms");
+  }
   const ttlMs = positiveSafeInteger2(args[3]);
-  return ttlMs == null ? void 0 : {
+  if (ttlMs == null) throw new FerricStoreError("FETCH_OR_COMPUTE_RESULT ttl_ms must be positive");
+  return {
     opcode: COMMAND_OPCODES.FETCH_OR_COMPUTE_RESULT,
     payload: { key: args[0], token: args[1], ttl_ms: ttlMs, value: args[2] }
   };
 }
 function fetchOrComputeErrorCommand(args) {
-  if (args.length !== 3 || !isBinaryCommandArgument(args[0]) || !isBinaryCommandArgument(args[1]) || !isBinaryCommandArgument(args[2])) return void 0;
+  if (args.length !== 3 || !isBinaryCommandArgument(args[0]) || !isBinaryCommandArgument(args[1]) || !isBinaryCommandArgument(args[2])) {
+    throw new FerricStoreError("FETCH_OR_COMPUTE_ERROR requires key, ownership token, and message");
+  }
   return {
     opcode: COMMAND_OPCODES.FETCH_OR_COMPUTE_ERROR,
     payload: { key: args[0], message: args[2], token: args[1] }
@@ -4841,62 +5062,462 @@ function requireAvailable(data, offset, size) {
   }
 }
 
-// src/protocol-response.ts
+// src/key-slot-validation.ts
 import { Buffer as Buffer18 } from "buffer";
 
-// src/protocol-compact-response.ts
+// src/topology-utilities.ts
 import { Buffer as Buffer17 } from "buffer";
-function tryDecodeCompactResponse(opcode, body, hints) {
-  if (body.byteLength === 0) return { found: false, value: void 0 };
-  const budget = { remainingItems: DEFAULT_MAX_VALUE_ITEMS };
-  const tag = body.readUInt8(0);
-  if (tag === COMPACT_OK_LIST && isOkListOpcode(opcode)) {
-    const values = decodeCompactOkList(body, budget);
-    return { found: true, value: opcode === OPCODES.pipeline ? values : values.length === 1 ? "OK" : values };
-  }
-  if (tag === COMPACT_KV_GET && compactResponseOpcodeSupports(opcode, COMPACT_KIND_KV_GET)) {
-    return { found: true, value: decodeCompactKvGet(body) };
+function isPlainObject3(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value) && !Buffer17.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 = Buffer17.from(key);
+      for (const [itemKey, value] of source.entries()) {
+        if (Buffer17.isBuffer(itemKey) && itemKey.equals(bufferKey)) return value;
+      }
+    }
+    return void 0;
   }
-  if ((tag === COMPACT_KV_MGET || tag === COMPACT_KV_MGET_FIXED) && compactResponseOpcodeSupports(opcode, COMPACT_KIND_KV_MGET)) {
-    return {
-      found: true,
-      value: tag === COMPACT_KV_MGET ? decodeCompactMget(body, budget) : decodeCompactMgetFixed(body, budget)
-    };
+  if (isPlainObject3(source)) {
+    for (const key of keys) {
+      if (Object.hasOwn(source, key)) return source[key];
+    }
   }
-  if (tag === COMPACT_PIPELINE_RESPONSE && compactResponseOpcodeSupports(opcode, COMPACT_KIND_PIPELINE)) {
-    return { found: true, value: decodeCompactPipeline(body, budget, hints.pipelineClaimModes) };
+  return void 0;
+}
+function textOrUndefined(value) {
+  if (typeof value === "string") return value;
+  if (Buffer17.isBuffer(value)) return value.toString("utf8");
+  return void 0;
+}
+function numberOrUndefined(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : void 0;
+}
+function nativeEventName(event) {
+  return textOrUndefined(getField(event.value, "event"))?.toUpperCase();
+}
+function endpointFromRange(item) {
+  const endpointValue = getField(item, "endpoint");
+  if (endpointValue != null && !isPlainObject3(endpointValue) && !(endpointValue instanceof Map)) {
+    throw new FerricStoreError("invalid SHARDS endpoint", { raw: item });
   }
-  if (tag === COMPACT_FLOW_CLAIM_JOBS && compactResponseOpcodeSupports(opcode, COMPACT_KIND_FLOW_CLAIM_JOBS)) {
-    return { found: true, value: decodeCompactClaimJobs(body, budget, hints.compactClaimMode) };
+  const raw = endpointValue ?? item;
+  const host = textOrUndefined(getField(raw, "host", "native_host"));
+  const nativePort = numberOrUndefined(getField(raw, "native_port"));
+  if (host == null || !validEndpointHost(host) || nativePort == null || nativePort <= 0 || nativePort > 65535) {
+    throw new FerricStoreError("invalid SHARDS endpoint", { raw: item });
   }
-  if (tag === COMPACT_FLOW_RECORD && compactResponseOpcodeSupports(opcode, COMPACT_KIND_FLOW_RECORD)) {
-    const read = readCompactFlowRecord(body, 0, budget);
-    if (read.offset !== body.byteLength) throw new FerricStoreError("trailing compact Flow record bytes");
-    return { found: true, value: read.value };
+  const nativeTlsPortValue = getField(raw, "native_tls_port");
+  const nativeTlsPort = numberOrUndefined(nativeTlsPortValue);
+  if (nativeTlsPortValue != null && (nativeTlsPort == null || nativeTlsPort <= 0 || nativeTlsPort > 65535)) {
+    throw new FerricStoreError("invalid SHARDS endpoint", { raw: item });
   }
-  if (tag === COMPACT_FLOW_RECORD_LIST && isFlowRecordListOpcode(opcode)) {
-    const read = readCompactFlowRecordList(body, 0, budget);
-    if (read.offset !== body.byteLength) throw new FerricStoreError("trailing compact Flow record list bytes");
-    return { found: true, value: read.value };
+  return {
+    host,
+    nativePort,
+    node: textOrUndefined(getField(raw, "node", "leader_node", "owner_node")) ?? host,
+    ...nativeTlsPort == null ? {} : { nativeTlsPort }
+  };
+}
+function validEndpointHost(host) {
+  if (host.length === 0 || host.trim() !== host || /[\s\\/?#@]/u.test(host)) return false;
+  const authorityHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  try {
+    const url = new URL(`ferric://${authorityHost}:6388`);
+    return url.hostname !== "" && url.port === "6388" && url.username === "" && url.password === "";
+  } catch {
+    return false;
   }
-  return { found: false, value: void 0 };
 }
-function isOkListOpcode(opcode) {
-  return compactResponseOpcodeSupports(opcode, COMPACT_KIND_OK_LIST);
+function sameEndpoint(left, right) {
+  return normalizedEndpointHost(left.host) === normalizedEndpointHost(right.host) && left.nativePort === right.nativePort && left.nativeTlsPort === right.nativeTlsPort && left.node === right.node;
 }
-function isFlowRecordListOpcode(opcode) {
-  return compactResponseOpcodeSupports(opcode, COMPACT_KIND_FLOW_RECORD_LIST);
+function parseFerricUrl2(value) {
+  const url = new URL(value);
+  if (url.protocol !== "ferric:" && url.protocol !== "ferrics:") {
+    throw new FerricStoreError(`unsupported FerricStore URL scheme: ${url.protocol}`);
+  }
+  return {
+    host: normalizeFerricUrlHost(url.hostname),
+    ...url.password === "" ? {} : { password: decodeURIComponent(url.password) },
+    port: Number(url.port || (url.protocol === "ferrics:" ? 6389 : 6388)),
+    tls: url.protocol === "ferrics:",
+    ...url.username === "" ? {} : { username: decodeURIComponent(url.username) }
+  };
 }
-function decodeCompactOkList(data, budget) {
-  requireAvailable(data, 0, 5);
-  const count = data.readUInt32BE(1);
-  requireCompactContainer(count, budget);
-  if (data.byteLength !== 5) throw new FerricStoreError("invalid compact OK list response");
-  return Array.from({ length: count }, () => Buffer17.from("OK"));
+function endpointKeyFor(endpoint) {
+  return `${normalizedEndpointHost(endpoint.host)}:${endpoint.nativePort}`;
 }
-function decodeCompactKvGet(data) {
-  requireAvailable(data, 0, 2);
-  const present = data.readUInt8(1);
+function connectionKeyForEndpoint(endpoint, useTls) {
+  const port = useTls && endpoint.nativeTlsPort != null ? endpoint.nativeTlsPort : endpoint.nativePort;
+  return `${useTls ? "ferrics" : "ferric"}://${normalizedEndpointHost(endpoint.host)}:${port}`;
+}
+function connectionKeyFromUrl(url) {
+  const parsed = parseFerricUrl2(url);
+  return `${parsed.tls ? "ferrics" : "ferric"}://${normalizedEndpointHost(parsed.host)}:${parsed.port}`;
+}
+function normalizedEndpointHost(host) {
+  const lower = host.toLowerCase();
+  return lower.startsWith("[") && lower.endsWith("]") ? lower.slice(1, -1) : lower;
+}
+function urlFromEndpoint(endpoint, useTls) {
+  const port = useTls && endpoint.nativeTlsPort != null ? endpoint.nativeTlsPort : endpoint.nativePort;
+  const host = endpoint.host.includes(":") && !endpoint.host.startsWith("[") ? `[${endpoint.host}]` : endpoint.host;
+  return `${useTls ? "ferrics" : "ferric"}://${host}:${port}`;
+}
+async function mapSettledWithConcurrency(items, concurrency, operation) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      const item = items[index];
+      try {
+        results[index] = { status: "fulfilled", value: await operation(item, index) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  await Promise.all(Array.from(
+    { length: Math.min(concurrency, items.length) },
+    async () => await worker()
+  ));
+  return results;
+}
+function throwFirstRejected(results) {
+  for (const result of results) {
+    if (result.status === "rejected") throw result.reason;
+  }
+}
+var TaskConcurrencyLimiter = class {
+  constructor(concurrency) {
+    this.concurrency = concurrency;
+  }
+  concurrency;
+  active = 0;
+  head = 0;
+  pending = [];
+  async run(operation) {
+    await this.acquire();
+    try {
+      return await operation();
+    } finally {
+      this.release();
+    }
+  }
+  acquire() {
+    if (this.active < this.concurrency) {
+      this.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => this.pending.push(resolve));
+  }
+  release() {
+    const next = this.pending[this.head];
+    if (next == null) {
+      this.active -= 1;
+      return;
+    }
+    this.head += 1;
+    next();
+    if (this.head === this.pending.length) {
+      this.pending.length = 0;
+      this.head = 0;
+    } else if (this.head >= 1024 && this.head * 2 >= this.pending.length) {
+      this.pending.splice(0, this.head);
+      this.head = 0;
+    }
+  }
+};
+function normalizedHostSet(hosts) {
+  return new Set(
+    hosts.filter((host) => host != null && host !== "").map((host) => normalizedEndpointHost(host))
+  );
+}
+var OPEN_BRACE = "{".charCodeAt(0);
+var CLOSE_BRACE = "}".charCodeAt(0);
+function hashTagOrKey(key) {
+  const start = key.indexOf(OPEN_BRACE);
+  if (start < 0) return key;
+  const end = key.indexOf(CLOSE_BRACE, start + 1);
+  return end > start + 1 ? key.subarray(start + 1, end) : key;
+}
+var ROUTE_SLOT_MASK = 1023;
+function routingSlotForKey(key) {
+  if (typeof key === "string") {
+    const [start, end] = stringHashRange(key);
+    return crc32Utf8(key, start, end) & ROUTE_SLOT_MASK;
+  }
+  const keyBytes = key;
+  return crc32(hashTagOrKey(keyBytes)) & ROUTE_SLOT_MASK;
+}
+function stringHashRange(key) {
+  const startBrace = key.indexOf("{");
+  const endBrace = startBrace < 0 ? -1 : key.indexOf("}", startBrace + 1);
+  return endBrace > startBrace + 1 ? [startBrace + 1, endBrace] : [0, key.length];
+}
+
+// src/key-slot-validation.ts
+var validatedCommands = /* @__PURE__ */ new WeakSet();
+function assertAtomicKeyValueCommandSharesSlot(args) {
+  const value = args[0];
+  const command = (typeof value === "string" ? value : Buffer18.isBuffer(value) ? value.toString("utf8") : "").toUpperCase();
+  if (command === "MSET" || command === "MSETNX") {
+    assertKeyValueCommandSharesSlot(args, command);
+  }
+}
+function assertKeyValueCommandSharesSlot(args, command) {
+  if (validatedCommands.has(args) || args.length < 3 || args.length % 2 === 0) return;
+  let expectedSlot;
+  for (let index = 1; index < args.length; index += 2) {
+    const key = args[index];
+    if (typeof key !== "string" && !Buffer18.isBuffer(key)) return;
+    const slot = routingSlotForKey(key);
+    expectedSlot ??= slot;
+    if (slot !== expectedSlot) {
+      throw new TypeError(`${command} keys must share a slot`);
+    }
+  }
+  validatedCommands.add(args);
+}
+
+// src/protocol-response.ts
+import { Buffer as Buffer22 } from "buffer";
+
+// src/protocol-compact-response.ts
+import { Buffer as Buffer21 } from "buffer";
+
+// src/native-negotiation.ts
+import { Buffer as Buffer19 } from "buffer";
+var EMPTY_COMPACT_RESPONSE_OPCODES = /* @__PURE__ */ new Map();
+function nativeNegotiation(value) {
+  const capabilities = field(value, "capabilities") ?? value;
+  const limits = field(capabilities, "limits");
+  const responseCodecs = field(capabilities, "response_codecs");
+  const maxResponseBytes = positiveSafeInteger3(field(limits, "max_response_bytes"));
+  return {
+    compactResponseOpcodes: parseCompactResponseOpcodes(
+      field(responseCodecs, "compact_response_opcodes")
+    ),
+    ...maxResponseBytes == null ? {} : { maxResponseBytes }
+  };
+}
+function compactResponseOpcodeSupports(capabilities, codec, opcode) {
+  return capabilities?.get(codec)?.has(opcode) === true;
+}
+function parseCompactResponseOpcodes(value) {
+  const entries = mapEntries(value);
+  if (entries == null) return EMPTY_COMPACT_RESPONSE_OPCODES;
+  const result = /* @__PURE__ */ new Map();
+  for (const [rawName, rawOpcodes] of entries) {
+    const name = text2(rawName);
+    if (name == null || name.length === 0 || !Array.isArray(rawOpcodes)) continue;
+    const opcodes = /* @__PURE__ */ new Set();
+    let valid = true;
+    for (let index = 0; index < rawOpcodes.length; index += 1) {
+      if (!Object.hasOwn(rawOpcodes, index)) {
+        valid = false;
+        break;
+      }
+      const opcode = unsigned16(rawOpcodes[index]);
+      if (opcode == null) {
+        valid = false;
+        break;
+      }
+      opcodes.add(opcode);
+    }
+    if (valid) result.set(name, opcodes);
+  }
+  return result;
+}
+function mapEntries(value) {
+  if (value instanceof Map) return [...value.entries()];
+  if (typeof value !== "object" || value == null || Array.isArray(value)) return void 0;
+  return Object.entries(value);
+}
+function unsigned16(value) {
+  const parsed = nonNegativeSafeInteger2(value);
+  return parsed != null && parsed <= 65535 ? parsed : void 0;
+}
+function positiveSafeInteger3(value) {
+  const parsed = nonNegativeSafeInteger2(value);
+  return parsed != null && parsed > 0 ? parsed : void 0;
+}
+function nonNegativeSafeInteger2(value) {
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : void 0;
+  }
+  const source = text2(value) ?? value;
+  if (typeof source !== "number" && (typeof source !== "string" || !/^\d+$/u.test(source))) {
+    return void 0;
+  }
+  const parsed = Number(source);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function text2(value) {
+  if (typeof value === "string") return value;
+  if (Buffer19.isBuffer(value) || value instanceof Uint8Array) {
+    return Buffer19.from(value).toString("utf8");
+  }
+  return void 0;
+}
+
+// src/protocol-compact-collections.ts
+import "buffer";
+function decodeCompactIntegerList(data, budget) {
+  requireAvailable(data, 0, 5);
+  const count = data.readUInt32BE(1);
+  requireCompactContainer(count, budget);
+  if (data.byteLength !== 5 + count * 8) {
+    throw new FerricStoreError("invalid compact integer list response");
+  }
+  const values = new Array(count);
+  for (let index = 0, offset = 5; index < count; index += 1, offset += 8) {
+    const value = data.readBigInt64BE(offset);
+    values[index] = value <= MAX_SAFE_INTEGER_BIGINT && value >= MIN_SAFE_INTEGER_BIGINT ? Number(value) : value;
+  }
+  return values;
+}
+function decodeCompactBinaryListList(data, budget) {
+  requireAvailable(data, 0, 5);
+  const count = data.readUInt32BE(1);
+  requireCompactContainer(count, budget);
+  let offset = 5;
+  const values = new Array(count);
+  for (let index = 0; index < count; index += 1) {
+    const read = readCompactBinaryList(data, offset, budget);
+    values[index] = read.value;
+    offset = read.offset;
+  }
+  if (offset !== data.byteLength) throw new FerricStoreError("trailing compact binary list-list bytes");
+  return values;
+}
+function decodeCompactBinaryMapList(data, budget) {
+  requireAvailable(data, 0, 5);
+  const count = data.readUInt32BE(1);
+  requireCompactContainer(count, budget);
+  let offset = 5;
+  const values = new Array(count);
+  for (let index = 0; index < count; index += 1) {
+    const read = readCompactBinaryMap(data, offset, budget);
+    values[index] = read.value;
+    offset = read.offset;
+  }
+  if (offset !== data.byteLength) throw new FerricStoreError("trailing compact binary map-list bytes");
+  return values;
+}
+function readCompactBinaryList(data, offset, budget) {
+  requireAvailable(data, offset, 4);
+  const count = data.readUInt32BE(offset);
+  requireCompactContainer(count, budget);
+  offset += 4;
+  const values = new Array(count);
+  for (let index = 0; index < count; index += 1) {
+    const read = readBinary(data, offset);
+    values[index] = read.value;
+    offset = read.offset;
+  }
+  return { value: values, offset };
+}
+function readCompactBinaryMap(data, offset, budget) {
+  requireAvailable(data, offset, 4);
+  const count = data.readUInt32BE(offset);
+  requireCompactContainer(count, budget);
+  offset += 4;
+  const values = {};
+  for (let index = 0; index < count; index += 1) {
+    const key = readBinary(data, offset);
+    const value = readBinary(data, key.offset);
+    setOwnValue2(values, key.value.toString("utf8"), value.value);
+    offset = value.offset;
+  }
+  return { value: values, offset };
+}
+function markCompactPipelineDecoded(values) {
+  Object.defineProperty(values, COMPACT_PIPELINE_DECODED, { value: true });
+  return values;
+}
+function requireCompactContainer(count, budget) {
+  if (count > DEFAULT_MAX_VALUE_ITEMS) {
+    throw new FerricStoreError("native compact response container exceeds max items");
+  }
+  consumeDecodeItems(count, budget);
+}
+
+// src/protocol-compact-response.ts
+function tryDecodeCompactResponse(opcode, body, hints) {
+  if (body.byteLength === 0) return { found: false, value: void 0 };
+  const budget = { remainingItems: DEFAULT_MAX_VALUE_ITEMS };
+  const tag = body.readUInt8(0);
+  const pipelineValues = opcode === OPCODES.pipeline && supports(hints, "pipeline_v1", opcode);
+  if (tag === COMPACT_OK_LIST && (supports(hints, "ok_list_v1", opcode) || pipelineValues)) {
+    const values = decodeCompactOkList(body, budget);
+    return {
+      found: true,
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(values) : values.length === 1 ? "OK" : values
+    };
+  }
+  if (tag === COMPACT_KV_GET && supports(hints, "kv_get_v1", opcode)) {
+    return { found: true, value: decodeCompactKvGet(body) };
+  }
+  if ((tag === COMPACT_KV_MGET || tag === COMPACT_KV_MGET_FIXED) && (supports(hints, "kv_mget_v1", opcode) || pipelineValues)) {
+    const values = tag === COMPACT_KV_MGET ? decodeCompactMget(body, budget) : decodeCompactMgetFixed(body, budget);
+    return {
+      found: true,
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(values) : values
+    };
+  }
+  if (tag === COMPACT_INTEGER_LIST && pipelineValues) {
+    return { found: true, value: markCompactPipelineDecoded(decodeCompactIntegerList(body, budget)) };
+  }
+  if (tag === COMPACT_BINARY_LIST_LIST && pipelineValues) {
+    return { found: true, value: markCompactPipelineDecoded(decodeCompactBinaryListList(body, budget)) };
+  }
+  if (tag === COMPACT_BINARY_MAP_LIST && pipelineValues) {
+    return { found: true, value: markCompactPipelineDecoded(decodeCompactBinaryMapList(body, budget)) };
+  }
+  if (tag === COMPACT_PIPELINE_RESPONSE && pipelineValues) {
+    return { found: true, value: decodeCompactPipeline(body, budget, hints.pipelineClaimModes) };
+  }
+  if (tag === COMPACT_FLOW_CLAIM_JOBS && (supports(hints, "flow_claim_jobs_v1", opcode) || pipelineValues)) {
+    const values = decodeCompactClaimJobs(body, budget, hints.compactClaimMode);
+    return {
+      found: true,
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(values) : values
+    };
+  }
+  if (tag === COMPACT_FLOW_RECORD && supports(hints, "flow_record_v1", opcode)) {
+    const read = readCompactFlowRecord(body, 0, budget);
+    if (read.offset !== body.byteLength) throw new FerricStoreError("trailing compact Flow record bytes");
+    return { found: true, value: read.value };
+  }
+  if (tag === COMPACT_FLOW_RECORD_LIST && (supports(hints, "flow_record_list_v1", opcode) || pipelineValues)) {
+    const read = readCompactFlowRecordList(body, 0, budget);
+    if (read.offset !== body.byteLength) throw new FerricStoreError("trailing compact Flow record list bytes");
+    return {
+      found: true,
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(read.value) : read.value
+    };
+  }
+  return { found: false, value: void 0 };
+}
+function supports(hints, codec, opcode) {
+  return compactResponseOpcodeSupports(hints.compactResponseOpcodes, codec, opcode);
+}
+function decodeCompactOkList(data, budget) {
+  requireAvailable(data, 0, 5);
+  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 }, () => Buffer21.from("OK"));
+}
+function decodeCompactKvGet(data) {
+  requireAvailable(data, 0, 2);
+  const present = data.readUInt8(1);
   if (present === 0) {
     if (data.byteLength !== 2) throw new FerricStoreError("trailing compact GET bytes");
     return null;
@@ -4909,7 +5530,7 @@ function decodeCompactKvGet(data) {
 function decodeCompactMget(data, budget) {
   requireAvailable(data, 0, 5);
   const count = data.readUInt32BE(1);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   let offset = 5;
   const values = [];
   for (let index = 0; index < count; index += 1) {
@@ -4933,12 +5554,12 @@ function decodeCompactMgetFixed(data, budget) {
   requireAvailable(data, 0, 9);
   const count = data.readUInt32BE(1);
   const size = data.readUInt32BE(5);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   const expected = 9 + count * size;
   if (size === NULL_U32 || data.byteLength !== expected) {
     throw new FerricStoreError("invalid compact fixed MGET response");
   }
-  if (size === 0) return new Array(count).fill(Buffer17.alloc(0));
+  if (size === 0) return new Array(count).fill(Buffer21.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);
@@ -4948,7 +5569,7 @@ function decodeCompactMgetFixed(data, budget) {
 function decodeCompactPipeline(data, budget, claimModes) {
   requireAvailable(data, 0, 5);
   const count = data.readUInt32BE(1);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   if (count > Math.floor((data.byteLength - 5) / 2)) {
     throw new FerricStoreError("compact pipeline item count exceeds response bytes");
   }
@@ -5010,13 +5631,12 @@ function decodeCompactPipeline(data, budget, claimModes) {
     }
   }
   if (offset !== data.byteLength) throw new FerricStoreError("trailing compact pipeline bytes");
-  Object.defineProperty(values, COMPACT_PIPELINE_DECODED, { value: true });
-  return values;
+  return markCompactPipelineDecoded(values);
 }
 function decodeCompactClaimJobs(data, budget, mode) {
   requireAvailable(data, 0, 5);
   const count = data.readUInt32BE(1);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   if (mode != null) {
     const values = [];
     let offset = 5;
@@ -5100,7 +5720,7 @@ function readCompactFlowRecord(data, offset, budget = { remainingItems: DEFAULT_
   if (data.readUInt8(offset) !== COMPACT_FLOW_RECORD) throw new FerricStoreError("expected compact Flow record");
   offset += 1;
   const count = data.readUInt32BE(offset);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   offset += 4;
   const record = {};
   for (let index = 0; index < count; index += 1) {
@@ -5128,7 +5748,7 @@ function readCompactFlowRecordList(data, offset, budget = { remainingItems: DEFA
   }
   offset += 1;
   const count = data.readUInt32BE(offset);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   offset += 4;
   const records = [];
   for (let index = 0; index < count; index += 1) {
@@ -5138,33 +5758,6 @@ function readCompactFlowRecordList(data, offset, budget = { remainingItems: DEFA
   }
   return { value: records, offset };
 }
-function readCompactBinaryList(data, offset, budget) {
-  requireAvailable(data, offset, 4);
-  const count = data.readUInt32BE(offset);
-  requireCompactContainer(count, budget);
-  offset += 4;
-  const values = [];
-  for (let index = 0; index < count; index += 1) {
-    const read = readBinary(data, offset);
-    values.push(read.value);
-    offset = read.offset;
-  }
-  return { value: values, offset };
-}
-function readCompactBinaryMap(data, offset, budget) {
-  requireAvailable(data, offset, 4);
-  const count = data.readUInt32BE(offset);
-  requireCompactContainer(count, budget);
-  offset += 4;
-  const values = {};
-  for (let index = 0; index < count; index += 1) {
-    const key = readBinary(data, offset);
-    const value = readBinary(data, key.offset);
-    setOwnValue2(values, key.value.toString("utf8"), value.value);
-    offset = value.offset;
-  }
-  return { value: values, offset };
-}
 function readOptionalBinary(data, offset) {
   requireAvailable(data, offset, 4);
   const size = data.readUInt32BE(offset);
@@ -5173,7 +5766,7 @@ function readOptionalBinary(data, offset) {
   requireAvailable(data, offset, size);
   return { value: data.subarray(offset, offset + size), offset: offset + size };
 }
-function requireCompactContainer(count, budget) {
+function requireCompactContainer2(count, budget) {
   if (count > DEFAULT_MAX_VALUE_ITEMS) {
     throw new FerricStoreError("native compact response container exceeds max items");
   }
@@ -5181,7 +5774,7 @@ function requireCompactContainer(count, budget) {
 }
 function errorMessage(status, value) {
   if (typeof value === "string") return value;
-  if (Buffer17.isBuffer(value)) return value.toString("utf8");
+  if (Buffer21.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);
@@ -5261,7 +5854,7 @@ function unwrapPipelineResponse(value, options = {}, expectedItems) {
   return out;
 }
 function pipelineStatus(value) {
-  if (typeof value !== "string" && !Buffer18.isBuffer(value) && !(value instanceof Uint8Array)) return null;
+  if (typeof value !== "string" && !Buffer22.isBuffer(value) && !(value instanceof Uint8Array)) return null;
   const status = asText(value).toLowerCase();
   return status === "ok" || status === "busy" || status === "error" ? status : null;
 }
@@ -5276,7 +5869,7 @@ function decodeResponseValue(opcode, body, hints) {
 }
 function errorMessage2(status, value) {
   if (typeof value === "string") return value;
-  if (Buffer18.isBuffer(value)) return value.toString("utf8");
+  if (Buffer22.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);
@@ -5292,7 +5885,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 = Buffer19.allocUnsafe(HEADER_SIZE + bodyLength);
+  const frame = Buffer23.allocUnsafe(HEADER_SIZE + bodyLength);
   frame.write(MAGIC, 0, "ascii");
   frame.writeUInt8(REQUEST_VERSION, 4);
   frame.writeUInt8(flags, 5);
@@ -5343,6 +5936,9 @@ function buildProtocolCommand(args, maxBodyBytes = Number.MAX_SAFE_INTEGER, allo
   }
   const command = asText(args[0]).toUpperCase();
   assertNormalizedCommandDoesNotRequirePinnedConnection(args, command);
+  if (command === "MSET" || command === "MSETNX") {
+    assertKeyValueCommandSharesSlot(args, command);
+  }
   const commandArgs2 = args.slice(1);
   if (command === "COMMAND_EXEC" && commandArgs2.length >= 1) {
     return commandExec(commandArgs2);
@@ -5414,6 +6010,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);
@@ -5480,20 +6082,7 @@ function buildProtocolCommand(args, maxBodyBytes = Number.MAX_SAFE_INTEGER, allo
     ])) ?? commandExec(args);
   }
   if (command === "FLOW.SIGNAL") {
-    return flowCommandExecWithRouting(command, commandArgs2, 1, /* @__PURE__ */ new Set([
-      "SIGNAL",
-      "PARTITION",
-      "IDEMPOTENCY",
-      "IF_STATE",
-      "TRANSITION_TO",
-      "RUN_AT",
-      "NOW",
-      "PRIORITY",
-      "VALUE",
-      "VALUE_REF",
-      "DROP_VALUE",
-      "OVERRIDE_VALUE"
-    ]));
+    return flowSignalPayload(commandArgs2) ?? commandExec(args);
   }
   if (command === "FLOW.CANCEL") {
     return flowCommandExecWithRouting(command, commandArgs2, 1, /* @__PURE__ */ new Set([
@@ -5662,6 +6251,7 @@ var DEFAULT_MAX_PENDING_CONTROL_REQUESTS = 4096;
 var DEFAULT_MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
 var DEFAULT_MAX_QUEUED_REQUESTS = 65536;
 var DEFAULT_MAX_QUEUED_WRITE_BYTES = 64 * 1024 * 1024;
+var UNAUTHENTICATED_MAX_FRAME_BYTES = 64 * 1024;
 function assertNativeAdapterOptions(options) {
   const supplied = options;
   for (const name of ["autoReconnect", "haRouting", "seeds"]) {
@@ -5681,7 +6271,7 @@ import "net";
 import "tls";
 
 // src/client-native-options.ts
-import { Buffer as Buffer20 } from "buffer";
+import { Buffer as Buffer24 } from "buffer";
 
 // src/string-array-snapshot.ts
 function snapshotOwnStringArray(values, name) {
@@ -5764,7 +6354,7 @@ function snapshotTlsOptions(options) {
   return Object.freeze(snapshot);
 }
 function snapshotTlsValue(value, name) {
-  if (Buffer20.isBuffer(value)) return Buffer20.from(value);
+  if (Buffer24.isBuffer(value)) return Buffer24.from(value);
   if (value instanceof Uint8Array) return value.slice();
   if (Array.isArray(value)) {
     const snapshot = new Array(value.length);
@@ -6234,6 +6824,9 @@ var NativeChunkAssembler = class {
   framesByKey = /* @__PURE__ */ new Map();
   totalBytes = 0;
   totalFrames = 0;
+  updateMaxResponseBytes(limit) {
+    this.maxResponseBytes = Math.min(this.maxResponseBytes, limit);
+  }
   assemble(frame) {
     const key = `${frame.requestId}:${frame.opcode}:${frame.laneId}`;
     const previous = this.chunks.get(key);
@@ -6478,12 +7071,18 @@ var NativeReceiveBuffer = class {
 var NativeResponseHandler = class {
   constructor(options) {
     this.options = options;
+    this.maxResponseBytes = options.maxResponseBytes;
   }
   options;
   receiveBuffer = new NativeReceiveBuffer();
   drainScheduled = false;
   paused = false;
   stopped = false;
+  maxResponseBytes;
+  updateMaxResponseBytes(limit) {
+    this.maxResponseBytes = Math.min(this.maxResponseBytes, limit);
+    this.options.chunkAssembler.updateMaxResponseBytes(this.maxResponseBytes);
+  }
   onData(chunk) {
     if (this.stopped) return;
     try {
@@ -6565,15 +7164,18 @@ var NativeResponseHandler = class {
     }
     const completeFrame = this.options.chunkAssembler.assemble(frame);
     if (completeFrame == null) return;
-    if (completeFrame.body.byteLength > this.options.maxResponseBytes) {
+    if (completeFrame.body.byteLength > this.maxResponseBytes) {
       throw new FerricStoreError(
-        `native protocol response exceeded ${this.options.maxResponseBytes} bytes`
+        `native protocol response exceeded ${this.maxResponseBytes} bytes`
       );
     }
     let value;
     let responseError;
     try {
-      value = decodeResponse(completeFrame, pending.opcode, pending);
+      value = decodeResponse(completeFrame, pending.opcode, {
+        ...pending,
+        compactResponseOpcodes: this.options.compactResponseOpcodes?.() ?? EMPTY_COMPACT_RESPONSE_OPCODES
+      });
       if (pending.opcode === OPCODES.windowUpdate) this.options.applyFlowControlLimits(value);
     } catch (error) {
       responseError = error;
@@ -6589,7 +7191,7 @@ var NativeResponseHandler = class {
     pending.discardedResponseBytes = discardedResponseBytes;
     pending.discardedResponseFrames = discardedResponseFrames;
     const chunked = discardedResponseFrames > 1 || (frame.flags & FLAG_MORE_CHUNKS) !== 0;
-    if (discardedResponseBytes > this.options.maxResponseBytes || chunked && discardedResponseBytes > this.options.maxChunkBytes) {
+    if (discardedResponseBytes > this.maxResponseBytes || chunked && discardedResponseBytes > this.options.maxChunkBytes) {
       throw new FerricStoreError("native protocol discarded response exceeded configured byte limits");
     }
     if (discardedResponseFrames > this.options.maxChunkFrames) {
@@ -6598,12 +7200,14 @@ var NativeResponseHandler = class {
     if ((frame.flags & FLAG_MORE_CHUNKS) === 0) this.options.takePending(frame.requestId);
   }
   handleManagementFrame(frame) {
-    if (frame.body.byteLength > this.options.maxResponseBytes) {
+    if (frame.body.byteLength > this.maxResponseBytes) {
       throw new FerricStoreError(
-        `native protocol response exceeded ${this.options.maxResponseBytes} bytes`
+        `native protocol response exceeded ${this.maxResponseBytes} bytes`
       );
     }
-    const value = decodeResponse(frame, frame.opcode);
+    const value = decodeResponse(frame, frame.opcode, {
+      compactResponseOpcodes: this.options.compactResponseOpcodes?.() ?? EMPTY_COMPACT_RESPONSE_OPCODES
+    });
     if (frame.opcode === OPCODES.windowUpdate) this.options.applyFlowControlLimits(value);
     const event = {
       flags: frame.flags,
@@ -6768,6 +7372,40 @@ var NativeWriteQueue = class {
   }
 };
 
+// src/native-connection-capabilities.ts
+var NativeConnectionCapabilities = class {
+  constructor(configuredRequestFrameBytes) {
+    this.configuredRequestFrameBytes = configuredRequestFrameBytes;
+    this.negotiatedRequestFrameBytes = configuredRequestFrameBytes;
+    this.requestFrameBytes = Math.min(configuredRequestFrameBytes, UNAUTHENTICATED_MAX_FRAME_BYTES);
+  }
+  configuredRequestFrameBytes;
+  compactResponseOpcodes = EMPTY_COMPACT_RESPONSE_OPCODES;
+  requestFrameBytes;
+  negotiatedRequestFrameBytes;
+  apply(value) {
+    const limits = startupLimits(value);
+    const negotiation = nativeNegotiation(value);
+    this.compactResponseOpcodes = negotiation.compactResponseOpcodes;
+    if (limits.frameBytes != null) {
+      this.negotiatedRequestFrameBytes = Math.min(
+        this.configuredRequestFrameBytes,
+        limits.frameBytes
+      );
+      this.requestFrameBytes = Math.min(this.requestFrameBytes, this.negotiatedRequestFrameBytes);
+    }
+    return {
+      ...limits.laneQueue == null ? {} : { laneQueue: limits.laneQueue },
+      ...limits.lanes == null ? {} : { lanes: limits.lanes },
+      ...negotiation.maxResponseBytes == null ? {} : { maxResponseBytes: negotiation.maxResponseBytes },
+      ...limits.pipelineCommands == null ? {} : { pipelineCommands: limits.pipelineCommands }
+    };
+  }
+  activateAuthenticated() {
+    this.requestFrameBytes = this.negotiatedRequestFrameBytes;
+  }
+};
+
 // src/native-adapter.ts
 var NativeAdapter = class _NativeAdapter {
   socket;
@@ -6776,9 +7414,9 @@ var NativeAdapter = class _NativeAdapter {
   closedWaiters = /* @__PURE__ */ new Set();
   chunkAssembler;
   closed = false;
+  capabilities;
   protocolLanes;
   maxPipelineCommands = Number.MAX_SAFE_INTEGER;
-  maxRequestFrameBytes;
   pendingControlRequests = 0;
   maxPendingControlRequests;
   heartbeat;
@@ -6793,7 +7431,7 @@ var NativeAdapter = class _NativeAdapter {
     const normalizedMaxChunkBytes = normalizePositiveLimit(maxChunkBytes, DEFAULT_MAX_CHUNK_BYTES);
     const normalizedMaxChunkFrames = normalizePositiveLimit(maxChunkFrames, DEFAULT_MAX_CHUNK_FRAMES);
     const normalizedMaxFrameBytes = normalizePositiveLimit(maxFrameBytes, DEFAULT_MAX_FRAME_BYTES);
-    this.maxRequestFrameBytes = normalizedMaxFrameBytes;
+    this.capabilities = new NativeConnectionCapabilities(normalizedMaxFrameBytes);
     const normalizedMaxResponseBytes = normalizePositiveLimit(maxResponseBytes, DEFAULT_MAX_RESPONSE_BYTES);
     this.chunkAssembler = new NativeChunkAssembler(
       normalizedMaxChunkBytes,
@@ -6820,7 +7458,7 @@ var NativeAdapter = class _NativeAdapter {
     this.heartbeat = new NativeHeartbeat(
       this.heartbeatIntervalMs,
       async () => {
-        await this.request(buildProtocolCommand(["PING"], this.maxRequestFrameBytes), true);
+        await this.request(buildProtocolCommand(["PING"], this.capabilities.requestFrameBytes), true);
       },
       (error) => {
         this.failAll(new FerricStoreError("FerricStore protocol heartbeat failed", { cause: error }), true);
@@ -6831,6 +7469,7 @@ var NativeAdapter = class _NativeAdapter {
       applyFlowControlLimits: (value) => this.applyFlowControlLimits(value),
       beginDraining: () => this.beginDraining(),
       chunkAssembler: this.chunkAssembler,
+      compactResponseOpcodes: () => this.capabilities.compactResponseOpcodes,
       destroy: (error) => this.socket.destroy(error),
       failAll: (reason, connectionClosed, message) => this.failAll(reason, connectionClosed, message),
       heartbeat: this.heartbeat,
@@ -6856,6 +7495,7 @@ var NativeAdapter = class _NativeAdapter {
         adapter,
         auth: async (username, password) => {
           await adapter.request({ laneId: 0, opcode: OPCODES.auth, payload: { password, username } });
+          adapter.capabilities.activateAuthenticated();
         },
         close: async () => {
           await adapter.close();
@@ -6873,13 +7513,13 @@ var NativeAdapter = class _NativeAdapter {
     return await this.executeCommandArgs(args);
   }
   async executeCommandArgs(args) {
-    const command = buildProtocolCommand(args, this.maxRequestFrameBytes);
+    const command = buildProtocolCommand(args, this.capabilities.requestFrameBytes);
     return await this.request(command);
   }
   /** @internal Execute raw command arguments on a topology-selected lane. */
   async executeCommandOnLane(args, laneId) {
     return await this.executeProtocolCommand(
-      buildProtocolCommand(args, this.maxRequestFrameBytes),
+      buildProtocolCommand(args, this.capabilities.requestFrameBytes),
       laneId
     );
   }
@@ -6901,7 +7541,7 @@ var NativeAdapter = class _NativeAdapter {
       laneId,
       options,
       this.maxPipelineCommands,
-      this.maxRequestFrameBytes
+      this.capabilities.requestFrameBytes
     );
   }
   /** @internal Execute an ordered pipeline on a topology-selected lane. */
@@ -6912,13 +7552,11 @@ var NativeAdapter = class _NativeAdapter {
       laneId,
       options,
       this.maxPipelineCommands,
-      this.maxRequestFrameBytes
+      this.capabilities.requestFrameBytes
     );
   }
   async close() {
-    if (this.closed) {
-      return;
-    }
+    if (this.closed) return;
     this.failAll(new FerricStoreError("FerricStore connection closed"), true);
     this.socket.destroy();
   }
@@ -6936,7 +7574,9 @@ var NativeAdapter = class _NativeAdapter {
     });
     this.applyStartupLimits(response);
     const authRequired = field(response, "auth_required");
-    return authRequired == null ? false : booleanResponse(authRequired);
+    const required = authRequired == null ? false : booleanResponse(authRequired);
+    if (authRequired != null && !required) this.capabilities.activateAuthenticated();
+    return required;
   }
   request(command, allowWhileDraining = false) {
     if (this.closed || this.draining && !allowWhileDraining) {
@@ -6977,7 +7617,7 @@ var NativeAdapter = class _NativeAdapter {
     let frame;
     try {
       requestId = this.requestScheduler.nextRequestId();
-      frame = encodeRequest(command, requestId, this.maxRequestFrameBytes);
+      frame = encodeRequest(command, requestId, this.capabilities.requestFrameBytes);
     } catch (error) {
       if (hasFlowControlCredit) this.flowControl.release(laneId);
       return Promise.reject(error instanceof Error ? error : new FerricStoreError(String(error), { raw: error }));
@@ -7031,9 +7671,7 @@ var NativeAdapter = class _NativeAdapter {
     this.resolveClosedWaiters();
   }
   failAll(reason, connectionClosed = false, dispatchedMessage) {
-    if (this.closed) {
-      return;
-    }
+    if (this.closed) return;
     this.closed = true;
     this.responseHandler.stop();
     this.resolveClosedWaiters();
@@ -7099,18 +7737,18 @@ var NativeAdapter = class _NativeAdapter {
   }
   applyStartupLimits(value) {
     this.applyFlowControlLimits(value);
-    const limits = startupLimits(value);
-    if (limits.laneQueue != null) {
-      this.flowControl.updateLaneQueueLimit(limits.laneQueue);
+    const capabilities = this.capabilities.apply(value);
+    if (capabilities.maxResponseBytes != null) {
+      this.responseHandler.updateMaxResponseBytes(capabilities.maxResponseBytes);
     }
-    if (limits.lanes != null) {
-      this.protocolLanes = Math.min(this.protocolLanes, limits.lanes);
+    if (capabilities.laneQueue != null) {
+      this.flowControl.updateLaneQueueLimit(capabilities.laneQueue);
     }
-    if (limits.pipelineCommands != null) {
-      this.maxPipelineCommands = limits.pipelineCommands;
+    if (capabilities.lanes != null) {
+      this.protocolLanes = Math.min(this.protocolLanes, capabilities.lanes);
     }
-    if (limits.frameBytes != null) {
-      this.maxRequestFrameBytes = Math.min(this.maxRequestFrameBytes, limits.frameBytes);
+    if (capabilities.pipelineCommands != null) {
+      this.maxPipelineCommands = capabilities.pipelineCommands;
     }
   }
 };
@@ -7124,6 +7762,29 @@ function executeCommandArgs(executor, args) {
 
 // src/reconnecting-executor.ts
 import "buffer";
+
+// src/command-retry-policy.ts
+import { Buffer as Buffer28 } from "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 (Buffer28.isBuffer(value) || value instanceof Uint8Array) {
+    return Buffer28.from(value).toString("utf8").toUpperCase();
+  }
+  return void 0;
+}
+
+// src/reconnecting-executor.ts
 var ReconnectingExecutor = class {
   constructor(createExecutor, options = {}) {
     this.createExecutor = createExecutor;
@@ -7154,7 +7815,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;
@@ -7202,333 +7868,134 @@ var ReconnectingExecutor = class {
   async refreshTopology() {
     return await this.withReconnect(async (executor) => {
       if (executor.refreshTopology == null) {
-        throw new FerricStoreError("topology refresh requires a topology-aware native executor");
-      }
-      return await executor.refreshTopology();
-    }, isReadOnlyReconnectableClosedConnectionError);
-  }
-  async route(key) {
-    return await this.withReconnect(async (executor) => {
-      if (executor.route == null) {
-        throw new FerricStoreError("route lookup requires a topology-aware native executor");
-      }
-      return await executor.route(key);
-    }, isReadOnlyReconnectableClosedConnectionError);
-  }
-  async close() {
-    if (this.closePromise != null) {
-      await this.closePromise;
-      return;
-    }
-    this.closed = true;
-    this.retryAbortController.abort(new FerricStoreError("FerricStore client is closed"));
-    const executorPromise = this.executorPromise;
-    const reconnectPromise = this.reconnectPromise;
-    this.closePromise = (async () => {
-      let closeError;
-      let closeFailed = false;
-      const executor = await executorPromise.catch(() => void 0);
-      try {
-        await Promise.resolve(executor?.close?.());
-      } catch (error) {
-        closeFailed = true;
-        closeError = error;
-      }
-      await reconnectPromise?.catch(() => void 0);
-      if (closeFailed) throw closeError;
-    })();
-    await this.closePromise;
-  }
-  async withReconnect(operation, reconnectable = isReconnectableClosedConnectionError) {
-    let executor = await this.executorPromise;
-    let retries = 0;
-    for (; ; ) {
-      if (this.closed) throw new FerricStoreError("FerricStore client is closed");
-      try {
-        return await operation(executor);
-      } catch (error) {
-        if (this.closed || retries >= this.maxRetries || !reconnectable(error)) throw error;
-        for (; ; ) {
-          retries += 1;
-          try {
-            executor = await this.reconnect(executor);
-            break;
-          } catch (reconnectError) {
-            if (this.closed || retries >= this.maxRetries) throw reconnectError;
-            await this.waitBeforeReconnect(retries);
-          }
-        }
-      }
-    }
-  }
-  async waitBeforeReconnect(failedAttempts) {
-    const exponent = Math.min(30, Math.max(0, failedAttempts - 1));
-    const base = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** exponent);
-    const jitter = base * (this.jitterPct / 100) * Math.random();
-    try {
-      await sleep(Math.min(this.maxDelayMs, base + jitter), this.retryAbortController.signal);
-    } catch (error) {
-      if (this.closed) throw new FerricStoreError("FerricStore client is closed", { cause: error });
-      throw error;
-    }
-  }
-  async reconnect(staleExecutor) {
-    if (this.closed) throw new FerricStoreError("FerricStore client is closed");
-    const competingReconnect = this.reconnectPromise;
-    if (competingReconnect != null) return await competingReconnect;
-    const observedExecutorPromise = this.executorPromise;
-    const currentExecutor = await observedExecutorPromise.catch(() => void 0);
-    if (this.closed) throw new FerricStoreError("FerricStore client is closed");
-    if (this.reconnectPromise != null) return await this.reconnectPromise;
-    if (this.executorPromise !== observedExecutorPromise) return await this.executorPromise;
-    if (currentExecutor != null && currentExecutor !== staleExecutor) return currentExecutor;
-    this.reconnectPromise = (async () => {
-      await Promise.resolve(staleExecutor.close?.()).catch(() => void 0);
-      const nextExecutor = await this.createExecutor(this.retryAbortController.signal);
-      if (this.closed) {
-        await Promise.resolve(nextExecutor.close?.()).catch(() => void 0);
-        throw new FerricStoreError("FerricStore client is closed");
-      }
-      this.executorPromise = Promise.resolve(nextExecutor);
-      return nextExecutor;
-    })().finally(() => {
-      this.reconnectPromise = void 0;
-    });
-    return await this.reconnectPromise;
-  }
-};
-function isReconnectableClosedConnectionError(error) {
-  return error instanceof ConnectionClosedError && error.requestDisposition === "unsent";
-}
-function isReadOnlyReconnectableClosedConnectionError(error) {
-  const pending = [error];
-  const seen = /* @__PURE__ */ new Set();
-  for (let visited = 0; visited < 16 && pending.length > 0; visited += 1) {
-    const current = pending.pop();
-    if (isReconnectableClosedConnectionError(current)) return true;
-    if (current == null || typeof current !== "object" && typeof current !== "function" || seen.has(current)) continue;
-    seen.add(current);
-    if (current instanceof Error && current.cause != null) pending.push(current.cause);
-    if (current instanceof FerricStoreError && current.raw != null) pending.push(current.raw);
-  }
-  return false;
-}
-function normalizeNonNegativeInteger2(value, fallback) {
-  return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : fallback;
-}
-
-// src/topology.ts
-import "buffer";
-
-// src/topology-routing.ts
-import { Buffer as Buffer26 } from "buffer";
-import { createHash } from "crypto";
-
-// src/topology-utilities.ts
-import { Buffer as Buffer25 } from "buffer";
-function isPlainObject3(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !Buffer25.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 = Buffer25.from(key);
-      for (const [itemKey, value] of source.entries()) {
-        if (Buffer25.isBuffer(itemKey) && itemKey.equals(bufferKey)) return value;
-      }
-    }
-    return void 0;
-  }
-  if (isPlainObject3(source)) {
-    for (const key of keys) {
-      if (Object.hasOwn(source, key)) return source[key];
-    }
-  }
-  return void 0;
-}
-function textOrUndefined(value) {
-  if (typeof value === "string") return value;
-  if (Buffer25.isBuffer(value)) return value.toString("utf8");
-  return void 0;
-}
-function numberOrUndefined(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) ? value : void 0;
-}
-function nativeEventName(event) {
-  return textOrUndefined(getField(event.value, "event"))?.toUpperCase();
-}
-function endpointFromRange(item) {
-  const endpointValue = getField(item, "endpoint");
-  if (endpointValue != null && !isPlainObject3(endpointValue) && !(endpointValue instanceof Map)) {
-    throw new FerricStoreError("invalid SHARDS endpoint", { raw: item });
-  }
-  const raw = endpointValue ?? item;
-  const host = textOrUndefined(getField(raw, "host", "native_host"));
-  const nativePort = numberOrUndefined(getField(raw, "native_port"));
-  if (host == null || !validEndpointHost(host) || nativePort == null || nativePort <= 0 || nativePort > 65535) {
-    throw new FerricStoreError("invalid SHARDS endpoint", { raw: item });
-  }
-  const nativeTlsPortValue = getField(raw, "native_tls_port");
-  const nativeTlsPort = numberOrUndefined(nativeTlsPortValue);
-  if (nativeTlsPortValue != null && (nativeTlsPort == null || nativeTlsPort <= 0 || nativeTlsPort > 65535)) {
-    throw new FerricStoreError("invalid SHARDS endpoint", { raw: item });
-  }
-  return {
-    host,
-    nativePort,
-    node: textOrUndefined(getField(raw, "node", "leader_node", "owner_node")) ?? host,
-    ...nativeTlsPort == null ? {} : { nativeTlsPort }
-  };
-}
-function validEndpointHost(host) {
-  if (host.length === 0 || host.trim() !== host || /[\s\\/?#@]/u.test(host)) return false;
-  const authorityHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-  try {
-    const url = new URL(`ferric://${authorityHost}:6388`);
-    return url.hostname !== "" && url.port === "6388" && url.username === "" && url.password === "";
-  } catch {
-    return false;
-  }
-}
-function sameEndpoint(left, right) {
-  return normalizedEndpointHost(left.host) === normalizedEndpointHost(right.host) && left.nativePort === right.nativePort && left.nativeTlsPort === right.nativeTlsPort && left.node === right.node;
-}
-function parseFerricUrl2(value) {
-  const url = new URL(value);
-  if (url.protocol !== "ferric:" && url.protocol !== "ferrics:") {
-    throw new FerricStoreError(`unsupported FerricStore URL scheme: ${url.protocol}`);
-  }
-  return {
-    host: normalizeFerricUrlHost(url.hostname),
-    ...url.password === "" ? {} : { password: decodeURIComponent(url.password) },
-    port: Number(url.port || (url.protocol === "ferrics:" ? 6389 : 6388)),
-    tls: url.protocol === "ferrics:",
-    ...url.username === "" ? {} : { username: decodeURIComponent(url.username) }
-  };
-}
-function endpointKeyFor(endpoint) {
-  return `${normalizedEndpointHost(endpoint.host)}:${endpoint.nativePort}`;
-}
-function connectionKeyForEndpoint(endpoint, useTls) {
-  const port = useTls && endpoint.nativeTlsPort != null ? endpoint.nativeTlsPort : endpoint.nativePort;
-  return `${useTls ? "ferrics" : "ferric"}://${normalizedEndpointHost(endpoint.host)}:${port}`;
-}
-function connectionKeyFromUrl(url) {
-  const parsed = parseFerricUrl2(url);
-  return `${parsed.tls ? "ferrics" : "ferric"}://${normalizedEndpointHost(parsed.host)}:${parsed.port}`;
-}
-function normalizedEndpointHost(host) {
-  const lower = host.toLowerCase();
-  return lower.startsWith("[") && lower.endsWith("]") ? lower.slice(1, -1) : lower;
-}
-function urlFromEndpoint(endpoint, useTls) {
-  const port = useTls && endpoint.nativeTlsPort != null ? endpoint.nativeTlsPort : endpoint.nativePort;
-  const host = endpoint.host.includes(":") && !endpoint.host.startsWith("[") ? `[${endpoint.host}]` : endpoint.host;
-  return `${useTls ? "ferrics" : "ferric"}://${host}:${port}`;
-}
-async function mapSettledWithConcurrency(items, concurrency, operation) {
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  const worker = async () => {
-    while (nextIndex < items.length) {
-      const index = nextIndex++;
-      const item = items[index];
-      try {
-        results[index] = { status: "fulfilled", value: await operation(item, index) };
-      } catch (reason) {
-        results[index] = { status: "rejected", reason };
+        throw new FerricStoreError("topology refresh requires a topology-aware native executor");
       }
-    }
-  };
-  await Promise.all(Array.from(
-    { length: Math.min(concurrency, items.length) },
-    async () => await worker()
-  ));
-  return results;
-}
-function throwFirstRejected(results) {
-  for (const result of results) {
-    if (result.status === "rejected") throw result.reason;
+      return await executor.refreshTopology();
+    }, isReadOnlyReconnectableClosedConnectionError);
   }
-}
-var TaskConcurrencyLimiter = class {
-  constructor(concurrency) {
-    this.concurrency = concurrency;
+  async route(key) {
+    return await this.withReconnect(async (executor) => {
+      if (executor.route == null) {
+        throw new FerricStoreError("route lookup requires a topology-aware native executor");
+      }
+      return await executor.route(key);
+    }, isReadOnlyReconnectableClosedConnectionError);
   }
-  concurrency;
-  active = 0;
-  head = 0;
-  pending = [];
-  async run(operation) {
-    await this.acquire();
-    try {
-      return await operation();
-    } finally {
-      this.release();
+  async close() {
+    if (this.closePromise != null) {
+      await this.closePromise;
+      return;
     }
+    this.closed = true;
+    this.retryAbortController.abort(new FerricStoreError("FerricStore client is closed"));
+    const executorPromise = this.executorPromise;
+    const reconnectPromise = this.reconnectPromise;
+    this.closePromise = (async () => {
+      let closeError;
+      let closeFailed = false;
+      const executor = await executorPromise.catch(() => void 0);
+      try {
+        await Promise.resolve(executor?.close?.());
+      } catch (error) {
+        closeFailed = true;
+        closeError = error;
+      }
+      await reconnectPromise?.catch(() => void 0);
+      if (closeFailed) throw closeError;
+    })();
+    await this.closePromise;
   }
-  acquire() {
-    if (this.active < this.concurrency) {
-      this.active += 1;
-      return Promise.resolve();
+  async withReconnect(operation, reconnectable = isReconnectableClosedConnectionError, replayAllowed = true) {
+    let executor = await this.executorPromise;
+    let retries = 0;
+    for (; ; ) {
+      if (this.closed) throw new FerricStoreError("FerricStore client is closed");
+      try {
+        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 {
+            executor = await this.reconnect(executor);
+            break;
+          } catch (reconnectError) {
+            if (this.closed || retries >= this.maxRetries) throw reconnectError;
+            await this.waitBeforeReconnect(retries);
+          }
+        }
+      }
     }
-    return new Promise((resolve) => this.pending.push(resolve));
   }
-  release() {
-    const next = this.pending[this.head];
-    if (next == null) {
-      this.active -= 1;
-      return;
-    }
-    this.head += 1;
-    next();
-    if (this.head === this.pending.length) {
-      this.pending.length = 0;
-      this.head = 0;
-    } else if (this.head >= 1024 && this.head * 2 >= this.pending.length) {
-      this.pending.splice(0, this.head);
-      this.head = 0;
+  async waitBeforeReconnect(failedAttempts) {
+    const exponent = Math.min(30, Math.max(0, failedAttempts - 1));
+    const base = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** exponent);
+    const jitter = base * (this.jitterPct / 100) * Math.random();
+    try {
+      await sleep(Math.min(this.maxDelayMs, base + jitter), this.retryAbortController.signal);
+    } catch (error) {
+      if (this.closed) throw new FerricStoreError("FerricStore client is closed", { cause: error });
+      throw error;
     }
   }
+  async reconnect(staleExecutor) {
+    if (this.closed) throw new FerricStoreError("FerricStore client is closed");
+    const competingReconnect = this.reconnectPromise;
+    if (competingReconnect != null) return await competingReconnect;
+    const observedExecutorPromise = this.executorPromise;
+    const currentExecutor = await observedExecutorPromise.catch(() => void 0);
+    if (this.closed) throw new FerricStoreError("FerricStore client is closed");
+    if (this.reconnectPromise != null) return await this.reconnectPromise;
+    if (this.executorPromise !== observedExecutorPromise) return await this.executorPromise;
+    if (currentExecutor != null && currentExecutor !== staleExecutor) return currentExecutor;
+    this.reconnectPromise = (async () => {
+      await Promise.resolve(staleExecutor.close?.()).catch(() => void 0);
+      const nextExecutor = await this.createExecutor(this.retryAbortController.signal);
+      if (this.closed) {
+        await Promise.resolve(nextExecutor.close?.()).catch(() => void 0);
+        throw new FerricStoreError("FerricStore client is closed");
+      }
+      this.executorPromise = Promise.resolve(nextExecutor);
+      return nextExecutor;
+    })().finally(() => {
+      this.reconnectPromise = void 0;
+    });
+    return await this.reconnectPromise;
+  }
 };
-function normalizedHostSet(hosts) {
-  return new Set(
-    hosts.filter((host) => host != null && host !== "").map((host) => normalizedEndpointHost(host))
-  );
-}
-function bufferStartsWith(value, prefix) {
-  return value.byteLength >= prefix.byteLength && value.subarray(0, prefix.byteLength).equals(prefix);
-}
-var OPEN_BRACE = "{".charCodeAt(0);
-var CLOSE_BRACE = "}".charCodeAt(0);
-function hashTagOrKey(key) {
-  const start = key.indexOf(OPEN_BRACE);
-  if (start < 0) return key;
-  const end = key.indexOf(CLOSE_BRACE, start + 1);
-  return end > start + 1 ? key.subarray(start + 1, end) : key;
+function isReconnectableClosedConnectionError(error) {
+  return error instanceof ConnectionClosedError && error.requestDisposition === "unsent";
 }
-function flowHashTag(rest, fallbackKey) {
-  const end = rest.indexOf(CLOSE_BRACE);
-  return end > 0 ? rest.subarray(0, end) : hashTagOrKey(fallbackKey);
+function isClosedConnectionError(error) {
+  return error instanceof ConnectionClosedError;
 }
-var ROUTE_SLOT_MASK = 1023;
-var FLOW_KEY_PREFIX = Buffer25.from("f:{");
-var VALUE_REF_FLOW_KEY_PREFIX = Buffer25.from("X:f:{");
-function routingSlotForKey(key) {
-  const keyBytes = Buffer25.isBuffer(key) ? key : Buffer25.from(key);
-  let hashInput;
-  if (bufferStartsWith(keyBytes, FLOW_KEY_PREFIX)) {
-    hashInput = flowHashTag(keyBytes.subarray(FLOW_KEY_PREFIX.byteLength), keyBytes);
-  } else if (bufferStartsWith(keyBytes, VALUE_REF_FLOW_KEY_PREFIX)) {
-    hashInput = flowHashTag(keyBytes.subarray(VALUE_REF_FLOW_KEY_PREFIX.byteLength), keyBytes);
-  } else {
-    hashInput = hashTagOrKey(keyBytes);
+function isReadOnlyReconnectableClosedConnectionError(error) {
+  const pending = [error];
+  const seen = /* @__PURE__ */ new Set();
+  for (let visited = 0; visited < 16 && pending.length > 0; visited += 1) {
+    const current = pending.pop();
+    if (isReconnectableClosedConnectionError(current)) return true;
+    if (current == null || typeof current !== "object" && typeof current !== "function" || seen.has(current)) continue;
+    seen.add(current);
+    if (current instanceof Error && current.cause != null) pending.push(current.cause);
+    if (current instanceof FerricStoreError && current.raw != null) pending.push(current.raw);
   }
-  return crc32(hashInput) & ROUTE_SLOT_MASK;
+  return false;
+}
+function normalizeNonNegativeInteger2(value, fallback) {
+  return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : fallback;
 }
 
+// src/topology.ts
+import "buffer";
+
 // src/topology-routing.ts
+import { Buffer as Buffer30 } from "buffer";
+import { createHash } from "crypto";
 var FLOW_PARTITION_ROUTE_CACHE_MAX = 1024;
 var flowPartitionRouteCache = /* @__PURE__ */ new Map();
 function routingKeyFromProtocolPayload(name, command) {
@@ -7536,9 +8003,18 @@ function routingKeyFromProtocolPayload(name, command) {
     return void 0;
   }
   if (isPlainObject3(command.payload)) {
-    for (const field2 of ["key", "partition_key", "id", "owner_flow_id", "parent_id", "root_id", "correlation_id", "scope"]) {
+    for (const field2 of [
+      "key",
+      "partition_key",
+      "id",
+      "owner_flow_id",
+      "parent_flow_id",
+      "root_flow_id",
+      "correlation_id",
+      "scope"
+    ]) {
       const value = getField(command.payload, field2);
-      if (typeof value === "string" || Buffer26.isBuffer(value)) {
+      if (typeof value === "string" || Buffer30.isBuffer(value)) {
         return value;
       }
     }
@@ -7585,9 +8061,9 @@ function flowRoutingData(name, args) {
     if (typeof partition === "string" && partition.toUpperCase() !== "AUTO" && partition.toUpperCase() !== "MIXED") {
       return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
     }
-    if (Buffer26.isBuffer(partition)) {
-      const text2 = partition.toString("utf8").toUpperCase();
-      if (text2 !== "AUTO" && text2 !== "MIXED") {
+    if (Buffer30.isBuffer(partition)) {
+      const text3 = partition.toString("utf8").toUpperCase();
+      if (text3 !== "AUTO" && text3 !== "MIXED") {
         return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
       }
     }
@@ -7676,22 +8152,22 @@ function flowPartitionRoutingKeyFromCommand(command, claim) {
   return { handled: false };
 }
 function isRoutingKey(value) {
-  return typeof value === "string" || Buffer26.isBuffer(value);
+  return typeof value === "string" || Buffer30.isBuffer(value);
 }
 function flowLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !Buffer26.isBuffer(value)) {
+  if (typeof value !== "string" && !Buffer30.isBuffer(value)) {
     return void 0;
   }
-  const bytes2 = Buffer26.isBuffer(value) ? value : Buffer26.from(value);
-  const text2 = bytes2.toString("utf8");
-  const autoMatch = /^__flow_auto__:(0|[1-9]\d{0,2})$/u.exec(text2);
+  const bytes2 = Buffer30.isBuffer(value) ? value : Buffer30.from(value);
+  const text3 = bytes2.toString("utf8");
+  const autoMatch = /^__flow_auto__:(0|[1-9]\d{0,2})$/u.exec(text3);
   if (autoMatch != null) {
     const bucket = Number(autoMatch[1]);
     if (bucket < 256) {
-      return `f:{fa:${bucket}}:route`;
+      return `{fa:${bucket}}`;
     }
   }
-  const cacheKey = `${Buffer26.isBuffer(value) ? "b" : "s"}:${bytes2.toString("base64")}`;
+  const cacheKey = `${Buffer30.isBuffer(value) ? "b" : "s"}:${bytes2.toString("base64")}`;
   const cached = flowPartitionRouteCache.get(cacheKey);
   if (cached != null) {
     flowPartitionRouteCache.delete(cacheKey);
@@ -7699,7 +8175,7 @@ function flowLogicalPartitionRoutingKey(value) {
     return cached;
   }
   const digest = createHash("sha256").update(bytes2).digest("base64url");
-  const routeKey = `f:{f:${digest}}:route`;
+  const routeKey = `{f:${digest}}`;
   if (flowPartitionRouteCache.size >= FLOW_PARTITION_ROUTE_CACHE_MAX) {
     const oldest = flowPartitionRouteCache.keys().next().value;
     if (oldest != null) flowPartitionRouteCache.delete(oldest);
@@ -7708,18 +8184,17 @@ function flowLogicalPartitionRoutingKey(value) {
   return routeKey;
 }
 function flowAutoIdRoutingKey(value) {
-  if (typeof value !== "string" && !Buffer26.isBuffer(value)) {
+  if (typeof value !== "string" && !Buffer30.isBuffer(value)) {
     return void 0;
   }
-  const bytes2 = Buffer26.isBuffer(value) ? value : Buffer26.from(value);
-  const bucket = crc32(bytes2) & 255;
-  return `f:{fa:${bucket}}:route`;
+  const bucket = (Buffer30.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
+  return `{fa:${bucket}}`;
 }
 function flowClaimLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !Buffer26.isBuffer(value)) return void 0;
+  if (typeof value !== "string" && !Buffer30.isBuffer(value)) return void 0;
   const selector = commandPart(value);
   if (selector === "AUTO" || selector === "ANY") return void 0;
-  if (selector === "GLOBAL") return "f:{f}:route";
+  if (selector === "GLOBAL") return "{f}";
   return flowLogicalPartitionRoutingKey(value);
 }
 function singleShardFlowPartitionKey(values) {
@@ -7731,7 +8206,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" && !Buffer26.isBuffer(key))) {
+  if (keys.length === 0 || keys.some((key) => typeof key !== "string" && !Buffer30.isBuffer(key))) {
     return void 0;
   }
   const usable = keys;
@@ -7742,7 +8217,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;
@@ -7764,7 +8239,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" && !Buffer26.isBuffer(key)) return void 0;
+    if (typeof key !== "string" && !Buffer30.isBuffer(key)) return void 0;
     const route = routeKey(key);
     const groupKey = `${route.endpointKey}\0${route.laneId}`;
     const group = groups.get(groupKey);
@@ -8005,7 +8480,16 @@ function isExplicitlySafeReroute(error) {
   if (error instanceof ConnectionClosedError) {
     return error.requestDisposition === "unsent";
   }
-  return error instanceof RerouteError && getField(error.raw, "safe_to_retry") === true;
+  return error instanceof RerouteError && error.retryable === true && error.safeToRetry === true;
+}
+function retryAfterMs(error) {
+  return error instanceof FerricStoreError ? error.retryAfterMs ?? 0 : 0;
+}
+async function waitForExplicitlySafeReroute(error) {
+  if (!isExplicitlySafeReroute(error)) return false;
+  const delayMs = retryAfterMs(error);
+  if (delayMs > 0) await sleep(delayMs);
+  return true;
 }
 
 // src/topology-endpoint-trust.ts
@@ -8147,7 +8631,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);
@@ -8363,7 +8847,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 : {
@@ -8392,7 +8876,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 };
@@ -8474,6 +8958,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;
@@ -8659,6 +9155,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);
@@ -8674,7 +9171,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;
         }
@@ -8716,6 +9213,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;
@@ -8724,7 +9222,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;
         }
@@ -8733,13 +9231,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()
     );
-    return refreshed && isExplicitlySafeReroute(error);
   }
   async executePipelineOnRoute(commands, route, options) {
     const adapter = await this.adapterForCurrentRoute(route);
@@ -8829,7 +9328,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
 };
 
 // src/response-map-preservation.ts
-import { Buffer as Buffer28 } from "buffer";
+import { Buffer as Buffer32 } from "buffer";
 function toStringKeyMapPreservingValues(value) {
   if (value == null) return void 0;
   const result = {};
@@ -8839,7 +9338,7 @@ function toStringKeyMapPreservingValues(value) {
     }
     return result;
   }
-  if (typeof value === "object" && !Array.isArray(value) && !Buffer28.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value === "object" && !Array.isArray(value) && !Buffer32.isBuffer(value) && !(value instanceof Uint8Array)) {
     for (const [key, item] of Object.entries(value)) {
       setOwnValue(result, text(key), normalizeMapStructurePreservingBytes(item));
     }
@@ -8848,7 +9347,7 @@ function toStringKeyMapPreservingValues(value) {
   return void 0;
 }
 function normalizeMapStructurePreservingBytes(value) {
-  if (Buffer28.isBuffer(value) || value instanceof Uint8Array) return value;
+  if (Buffer32.isBuffer(value) || value instanceof Uint8Array) return value;
   if (value instanceof Map) {
     const result = {};
     for (const [key, item] of value.entries()) {
@@ -8870,7 +9369,7 @@ function normalizeMapStructurePreservingBytes(value) {
 }
 
 // src/native-kv-responses.ts
-import { Buffer as Buffer29 } from "buffer";
+import { Buffer as Buffer33 } from "buffer";
 function rateLimitResultFromResp(value) {
   if (!Array.isArray(value) || value.length !== 4) {
     throw new TypeError("RATELIMIT.ADD returned an unexpected response");
@@ -8913,30 +9412,27 @@ function fetchOrComputeResultFromResp(value, codec) {
       shouldCompute: false
     };
   }
-  if (status !== "compute") throw new TypeError("FETCH_OR_COMPUTE returned an unexpected response");
+  if (status !== "compute" || value.length !== 3) {
+    throw new TypeError("FETCH_OR_COMPUTE returned an unexpected response");
+  }
   return {
     status,
     computeHint: responseBytes(value[1], "FETCH_OR_COMPUTE"),
-    ...value.length === 3 ? {
-      computeMode: "fenced",
-      computeToken: responseBytes(value[2], "FETCH_OR_COMPUTE")
-    } : {
-      computeMode: "legacy",
-      computeToken: null
-    },
+    computeMode: "fenced",
+    computeToken: responseBytes(value[2], "FETCH_OR_COMPUTE"),
     hit: false,
     shouldCompute: true
   };
 }
 function decodePayload(codec, value) {
   if (value == null) return null;
-  if (Buffer29.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(Buffer29.from(value));
-  if (typeof value === "string") return codec.decode(Buffer29.from(value));
+  if (Buffer33.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(Buffer33.from(value));
+  if (typeof value === "string") return codec.decode(Buffer33.from(value));
   return normalizeRefMeta(value);
 }
 function requiredResponseString(value, context) {
-  if (typeof value !== "string" && !Buffer29.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !Buffer33.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   const result = text(value);
@@ -8953,7 +9449,7 @@ function requiredNonNegativeInteger(value, context) {
   return result;
 }
 function responseBytes(value, context) {
-  if (typeof value !== "string" && !Buffer29.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !Buffer33.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   return bytes(value);
@@ -9038,6 +9534,9 @@ function flowRecordFromResp(value, codec) {
     field(value, "max_active_ms"),
     "FLOW record max_active_ms"
   );
+  const rawError = field(value, "error");
+  const error = flowError(rawError, codec);
+  const failureReason = optionalResponseString(field(rawError, "reason"), "FLOW record error reason");
   return {
     id: requiredTextField(value, "id", "FLOW record"),
     type: requiredTextField(value, "type", "FLOW record"),
@@ -9052,6 +9551,8 @@ function flowRecordFromResp(value, codec) {
     rootFlowId: optionalResponseString(field(value, "root_flow_id"), "FLOW record root_flow_id"),
     correlationId: optionalResponseString(field(value, "correlation_id"), "FLOW record correlation_id"),
     ...maxActiveMs == null ? {} : { maxActiveMs },
+    ...error == null ? {} : { error },
+    ...failureReason == null ? {} : { failureReason },
     valueRefs: optionalMapField(value, "value_refs", "FLOW record"),
     values,
     valueSizes: optionalMapField(value, "value_sizes", "FLOW record"),
@@ -9063,6 +9564,21 @@ function flowRecordFromResp(value, codec) {
     raw: value
   };
 }
+function flowError(value, codec) {
+  if (value == null) return void 0;
+  const reason = optionalResponseString(field(value, "reason"), "FLOW record error reason");
+  if (reason === "max_active_ms") {
+    const maxActiveMs = optionalPositiveResponseInteger(
+      field(value, "max_active_ms"),
+      "FLOW record error max_active_ms"
+    );
+    if (maxActiveMs == null) {
+      throw new TypeError("FLOW record error max_active_ms returned an unexpected response");
+    }
+    return { maxActiveMs, reason };
+  }
+  return decodePayload2(codec, value);
+}
 function decodePayload2(codec, value) {
   if (value == null) {
     return null;
@@ -9643,7 +10159,7 @@ function groupAutoPartitionItems(items) {
 }
 
 // src/client-values.ts
-import { Buffer as Buffer30 } from "buffer";
+import { Buffer as Buffer34 } from "buffer";
 async function valueMGetEntries(client, refs, options = {}) {
   const refCount = refs.length;
   if (refCount === 0) {
@@ -9678,12 +10194,12 @@ async function valueMGetEntries(client, refs, options = {}) {
     const item = response[index];
     if (item == null) {
       entries[index] = { found: false };
-    } else if (Buffer30.isBuffer(item)) {
+    } else if (Buffer34.isBuffer(item)) {
       entries[index] = { found: true, value: client.codec.decode(item) };
     } else if (item instanceof Uint8Array) {
-      entries[index] = { found: true, value: client.codec.decode(Buffer30.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(Buffer34.from(item)) };
     } else if (typeof item === "string") {
-      entries[index] = { found: true, value: client.codec.decode(Buffer30.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(Buffer34.from(item)) };
     } else {
       entries[index] = { found: true, value: item };
     }
@@ -9695,7 +10211,7 @@ async function valueMGetEntries(client, refs, options = {}) {
 import "buffer";
 
 // src/auto-batch-ordering.ts
-import { Buffer as Buffer31 } from "buffer";
+import { Buffer as Buffer35 } from "buffer";
 function autoBatchOrderingPlan(batch) {
   const accesses = /* @__PURE__ */ new Map();
   const fallbackDependencies = [];
@@ -9810,13 +10326,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)]) && Buffer31.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
+      (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && isFencingToken(command[itemIndex + (mixed ? 2 : 1)]) && Buffer35.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
     );
   }
   return fixedFlowItemIds(
     command,
     mixed ? 4 : 3,
-    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && Buffer31.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
+    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && Buffer35.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
   );
 }
 function createManyAutoBatchIds(command) {
@@ -9829,7 +10345,7 @@ function createManyAutoBatchIds(command) {
       const ids = fixedFlowItemIds(
         command,
         width,
-        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && Buffer31.isBuffer(command[itemIndex + width - 1]),
+        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && Buffer35.isBuffer(command[itemIndex + width - 1]),
         markerIndex
       );
       if (ids != null) return ids;
@@ -9847,7 +10363,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]) || !Buffer31.isBuffer(command[cursor + 2])) return void 0;
+    if (!isAutoBatchResourceValue(id) || !isAutoBatchResourceValue(command[cursor + 1]) || !Buffer35.isBuffer(command[cursor + 2])) return void 0;
     ids.push(id);
     cursor += 3;
     const afterValues = skipExtendedNamedItems(command, cursor, true);
@@ -9866,7 +10382,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 ? !Buffer31.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
+    if (!isAutoBatchResourceValue(name) || (encodedValues ? !Buffer35.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
   }
   return firstItem + count * 2;
 }
@@ -9881,7 +10397,7 @@ function runStepsManyAutoBatchIds(command) {
         ids.push(item);
         continue;
       }
-      if (typeof item !== "object" || item == null || Array.isArray(item) || Buffer31.isBuffer(item)) return void 0;
+      if (typeof item !== "object" || item == null || Array.isArray(item) || Buffer35.isBuffer(item)) return void 0;
       const id = item.id;
       if (!isAutoBatchResourceValue(id)) return void 0;
       ids.push(id);
@@ -9922,7 +10438,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" || Buffer31.isBuffer(value);
+  return typeof value === "string" || Buffer35.isBuffer(value);
 }
 function isFencingToken(value) {
   return typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint";
@@ -9931,7 +10447,7 @@ function nonNegativeItemCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
 function autoBatchResourceKey(namespace, value) {
-  return `${namespace}:${Buffer31.from(value).toString("base64")}`;
+  return `${namespace}:${Buffer35.from(value).toString("base64")}`;
 }
 function autoBatchCommandName(command) {
   return commandView(command).name ?? null;
@@ -10346,9 +10862,9 @@ import "buffer";
 import "buffer";
 
 // src/client-core-helpers.ts
-import { Buffer as Buffer33 } from "buffer";
+import { Buffer as Buffer37 } from "buffer";
 function bgsaveResponse(response) {
-  if ((typeof response === "string" || Buffer33.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
+  if ((typeof response === "string" || Buffer37.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
     return true;
   }
   return okResponse(response);
@@ -10359,11 +10875,11 @@ function clientNameResponse(response) {
 function fetchOrComputeCompletionToken(options) {
   if (options == null || !Object.hasOwn(options, "computeToken") || options.computeToken === void 0) {
     throw new TypeError(
-      "fetch-or-compute completion requires computeToken; pass null only for a legacy tokenless lease"
+      "fetch-or-compute completion requires computeToken"
     );
   }
-  if (options.computeToken !== null && !Buffer33.isBuffer(options.computeToken)) {
-    throw new TypeError("fetch-or-compute computeToken must be a Buffer or explicit null for a legacy lease");
+  if (!Buffer37.isBuffer(options.computeToken)) {
+    throw new TypeError("fetch-or-compute computeToken must be a Buffer");
   }
   return options.computeToken;
 }
@@ -10485,14 +11001,17 @@ var FerricStoreClientBase = class {
     };
   }
   async command(...args) {
+    assertAtomicKeyValueCommandSharesSlot(args);
     return await executeCommandArgs(this.executor, args);
   }
   /** Execute an already-built command without a JavaScript variadic-call limit. */
   async commandArgs(args) {
+    assertAtomicKeyValueCommandSharesSlot(args);
     return await executeCommandArgs(this.executor, args);
   }
   async pipeline(commands, options) {
     const snapshot = snapshotPipelineCommands(commands);
+    for (const command of snapshot) assertAtomicKeyValueCommandSharesSlot(command);
     const snapshotOptions = snapshotPipelineOptions(options);
     const results = this.executor.executePipeline != null ? await this.executor.executePipeline(snapshot, snapshotOptions) : await executeCommandArraysIndividually(
       async (command) => await this.commandArgs(command),
@@ -10719,14 +11238,14 @@ var FerricStoreAdministrationClient = class extends FerricStoreClientBase {
 };
 
 // src/store-utilities.ts
-import { Buffer as Buffer36 } from "buffer";
+import { Buffer as Buffer40 } from "buffer";
 function encode(codec, value) {
   return codec.encode(value);
 }
 function decode(codec, value) {
   if (value == null) return null;
-  if (Buffer36.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(Buffer36.from(value));
+  if (Buffer40.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(Buffer40.from(value));
   return value;
 }
 function number(value) {
@@ -10787,7 +11306,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) {
@@ -10802,7 +11321,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) {
@@ -10812,7 +11331,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;
@@ -10834,7 +11353,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) {
@@ -10848,7 +11367,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) {
@@ -10862,7 +11381,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) {
@@ -11132,12 +11651,15 @@ var TopKStore = class {
     const width = ownOption(options, "width");
     const depth = ownOption(options, "depth");
     const decay = ownOption(options, "decay");
-    const tuningCount = [width, depth, decay].filter((value) => value != null).length;
-    if (tuningCount !== 0 && tuningCount !== 3) {
-      throw new TypeError("TOPK.RESERVE width, depth, and decay must be provided together");
+    if (decay != null || Object.hasOwn(options, "decay")) {
+      throw new TypeError("TOPK.RESERVE decay is not supported by FerricStore 0.8");
     }
-    if (tuningCount === 3) {
-      args.push(width, depth, decay);
+    const tuningCount = [width, depth].filter((value) => value != null).length;
+    if (tuningCount !== 0 && tuningCount !== 2) {
+      throw new TypeError("TOPK.RESERVE width and depth must be provided together");
+    }
+    if (tuningCount === 2) {
+      args.push(width, depth);
     }
     return okResponse(await commandArgs(this.client, args));
   }
@@ -11543,10 +12065,14 @@ var KeyValueStore = class {
     );
   }
   async mset(entries) {
-    return okResponse(await commandArgs(this.client, keyValueArgs(["MSET"], this.client.codec, entries)));
+    const args = keyValueArgs(["MSET"], this.client.codec, entries);
+    assertKeyValueCommandSharesSlot(args, "MSET");
+    return okResponse(await commandArgs(this.client, args));
   }
   async msetnx(entries) {
-    return binaryBooleanResponse(await commandArgs(this.client, keyValueArgs(["MSETNX"], this.client.codec, entries)));
+    const args = keyValueArgs(["MSETNX"], this.client.codec, entries);
+    assertKeyValueCommandSharesSlot(args, "MSETNX");
+    return binaryBooleanResponse(await commandArgs(this.client, args));
   }
   async incr(key) {
     return integerReply(await this.client.command("INCR", key));
@@ -12616,7 +13142,8 @@ var FerricStoreClientCore = class extends FerricStoreAdministrationClient {
     return okResponse(await this.command(
       "FETCH_OR_COMPUTE_RESULT",
       key,
-      ...computeToken === null ? [encoded] : [computeToken, encoded],
+      computeToken,
+      encoded,
       options.ttlMs
     ));
   }
@@ -12625,7 +13152,7 @@ var FerricStoreClientCore = class extends FerricStoreAdministrationClient {
     return okResponse(await this.command(
       "FETCH_OR_COMPUTE_ERROR",
       key,
-      ...computeToken === null ? [] : [computeToken],
+      computeToken,
       message
     ));
   }
@@ -12751,7 +13278,7 @@ var FerricStoreManagementClient = class extends FerricStoreClientCore {
   }
   async effectGet(id, effectKey, options = {}) {
     const args = ["FLOW.EFFECT.GET", id, "EFFECT_KEY", effectKey];
-    append(args, "PARTITION", options.partitionKey ?? autoPartitionKeyForId(id));
+    append(args, "PARTITION", options.partitionKey);
     return optionalAdminRecord(await this.commandArgs(args), "FLOW.EFFECT.GET");
   }
   async effectStatus(command, id, effectKey, options) {
@@ -12923,7 +13450,7 @@ var FerricStoreManagementClient = class extends FerricStoreClientCore {
   }
   async governanceLedger(id, options = {}) {
     const args = ["FLOW.GOVERNANCE.LEDGER", id];
-    append(args, "PARTITION", options.partitionKey ?? autoPartitionKeyForId(id));
+    append(args, "PARTITION", options.partitionKey);
     append(args, "LIMIT", options.limit);
     append(args, "FROM_MS", options.fromMs);
     append(args, "TO_MS", options.toMs);
@@ -12939,7 +13466,7 @@ async function executeProducerWriteWithBackpressure(execute, policy, signal) {
     try {
       return await execute();
     } catch (error) {
-      if (!(error instanceof OverloadedError) || attempt >= policy.maxRetries) throw error;
+      if (!(error instanceof OverloadedError) || error.retryable !== true || error.safeToRetry !== true || attempt >= policy.maxRetries) throw error;
       const exponential = Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** attempt);
       const base = Math.min(policy.maxDelayMs, error.retryAfterMs ?? exponential);
       const jitter = base * (policy.jitterPct / 100) * Math.random();
@@ -12953,6 +13480,165 @@ function throwIfClosed(signal) {
   throw new FerricStoreError("FerricStore client is closed", { raw: signal.reason });
 }
 
+// src/flow-policy.ts
+import { Buffer as Buffer42 } from "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) && !Buffer42.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 (Buffer42.isBuffer(value) || value instanceof Uint8Array) {
+    return Buffer42.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 = {}) {
@@ -13095,27 +13781,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"));
@@ -13204,7 +13899,7 @@ var FerricStoreFlowSupportClient = class extends FerricStoreManagementClient {
 };
 
 // src/flow-many-snapshot.ts
-import { Buffer as Buffer39 } from "buffer";
+import { Buffer as Buffer44 } from "buffer";
 var encodedOptionFields = ["error", "payload", "reason", "result"];
 function snapshotCreateItem(item, codec) {
   const snapshot = {
@@ -13244,7 +13939,7 @@ function snapshotFlowManyOptions(options, codec) {
 }
 function snapshotClaimedItem(item) {
   const wire = item[CLAIMED_ITEM_WIRE];
-  const leaseToken = Buffer39.from(wire?.leaseToken ?? item.leaseToken);
+  const leaseToken = Buffer44.from(wire?.leaseToken ?? item.leaseToken);
   const snapshot = {
     ...item,
     fencingToken: wire?.fencingToken ?? item.fencingToken,
@@ -13261,15 +13956,15 @@ function snapshotClaimedItem(item) {
 function snapshotFencedItem(item) {
   return Object.freeze({
     ...item,
-    ...item.leaseToken == null ? {} : { leaseToken: Buffer39.from(item.leaseToken) }
+    ...item.leaseToken == null ? {} : { leaseToken: Buffer44.from(item.leaseToken) }
   });
 }
 function snapshotClaimedItemWire(wire, leaseToken) {
   return Object.freeze({
     fencingToken: wire.fencingToken,
-    id: Buffer39.from(wire.id),
+    id: Buffer44.from(wire.id),
     leaseToken,
-    partitionKey: wire.partitionKey == null ? wire.partitionKey : Buffer39.from(wire.partitionKey)
+    partitionKey: wire.partitionKey == null ? wire.partitionKey : Buffer44.from(wire.partitionKey)
   });
 }
 function snapshotArray(values) {
@@ -13280,7 +13975,7 @@ function snapshotArray(values) {
   return Object.freeze(snapshot);
 }
 function snapshotStateMeta(stateMeta) {
-  return snapshotRecord(stateMeta, (value) => Buffer39.isBuffer(value) ? Buffer39.from(value) : value);
+  return snapshotRecord(stateMeta, (value) => Buffer44.isBuffer(value) ? Buffer44.from(value) : value);
 }
 function snapshotCommandRecord(values) {
   const seen = /* @__PURE__ */ new WeakMap();
@@ -13298,7 +13993,7 @@ function snapshotRecord(values, capture) {
 }
 function snapshotCommandArgument(value, seen) {
   if (typeof value !== "object" || value == null) return value;
-  if (Buffer39.isBuffer(value) || value instanceof Uint8Array) return Buffer39.from(value);
+  if (Buffer44.isBuffer(value) || value instanceof Uint8Array) return Buffer44.from(value);
   const objectValue = value;
   const existing = seen.get(objectValue);
   if (existing != null) return existing;
@@ -14096,6 +14791,9 @@ var FerricStoreClient = class _FerricStoreClient extends FerricStoreProducerClie
     return new _FerricStoreClient(executor, clientOptions);
   }
   async valuePut(value, options = {}) {
+    if (options.ownerFlowId != null && options.name != null && options.ttlMs != null) {
+      throw new TypeError("named Flow values cannot have a TTL");
+    }
     const args = ["FLOW.VALUE.PUT", this.codec.encode(value), "NOW", options.nowMs ?? nowMs()];
     append(args, "PARTITION", options.partitionKey);
     append(args, "OWNER_FLOW_ID", options.ownerFlowId);
@@ -14127,7 +14825,6 @@ var FerricStoreClient = class _FerricStoreClient extends FerricStoreProducerClie
     append(args, "TRANSITION_TO", options.transitionTo);
     append(args, "RUN_AT", options.runAtMs);
     append(args, "NOW", options.nowMs ?? nowMs());
-    append(args, "PRIORITY", options.priority);
     appendNamedValues(args, this.codec, options);
     return await this.commandArgs(args);
   }
@@ -14157,6 +14854,7 @@ var FerricStoreClient = class _FerricStoreClient extends FerricStoreProducerClie
     append(args, "CORRELATION_ID", options.correlationId);
     append(args, "PRIORITY", options.priority);
     append(args, "RETENTION_TTL_MS", options.retentionTtlMs);
+    append(args, "MAX_ACTIVE_MS", options.maxActiveMs);
     appendAttributes(args, options.attributes);
     appendStateMeta(args, options.stateMeta);
     appendNamedValues(args, this.codec, options);
@@ -14517,7 +15215,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;
@@ -14636,7 +15334,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) {
@@ -16052,6 +16750,7 @@ var Workflow = class {
     }
     return await this.client.installPolicy(this.type, {
       ...options,
+      replace: Object.hasOwn(options, "replace") ? options.replace ?? true : true,
       states
     });
   }
@@ -16262,15 +16961,22 @@ var WorkflowWorker = class {
     );
   }
 };
+
+// src/version.ts
+var FERRICSTORE_SDK_VERSION = "0.3.0";
+var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.9.1";
+var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 export {
   BitmapStore,
   BloomFilterStore,
   COMMAND_OPCODES,
-  COMPACT_RESPONSE_OPCODES,
   ClaimHydrationError,
   ConnectionClosedError,
   CountMinSketchStore,
   CuckooFilterStore,
+  FERRICSTORE_MINIMUM_SERVER_VERSION,
+  FERRICSTORE_NATIVE_PROTOCOL_VERSION,
+  FERRICSTORE_SDK_VERSION,
   FerricStoreClient,
   FerricStoreError,
   FlowAlreadyExistsError,
@@ -16287,6 +16993,7 @@ export {
   ListStore,
   LockHeldError,
   LockNotOwnedError,
+  MAX_FLOW_POLICY_GENERATION,
   NativeAdapter,
   OverloadedError,
   Queue,
@@ -16301,6 +17008,7 @@ export {
   SetStore,
   SortedSetStore,
   StaleLeaseError,
+  StalePolicyGenerationError,
   StreamStore,
   TDigestStore,
   TopKStore,