@ferricstore/ferricstore 0.1.7 → 0.2.0

package/dist/index.cjs

@@ -33,11 +33,13 @@ __export(index_exports, {
   BitmapStore: () => BitmapStore,
   BloomFilterStore: () => BloomFilterStore,
   COMMAND_OPCODES: () => COMMAND_OPCODES,
-  COMPACT_RESPONSE_OPCODES: () => COMPACT_RESPONSE_OPCODES,
   ClaimHydrationError: () => ClaimHydrationError,
   ConnectionClosedError: () => ConnectionClosedError,
   CountMinSketchStore: () => CountMinSketchStore,
   CuckooFilterStore: () => CuckooFilterStore,
+  FERRICSTORE_MINIMUM_SERVER_VERSION: () => FERRICSTORE_MINIMUM_SERVER_VERSION,
+  FERRICSTORE_NATIVE_PROTOCOL_VERSION: () => FERRICSTORE_NATIVE_PROTOCOL_VERSION,
+  FERRICSTORE_SDK_VERSION: () => FERRICSTORE_SDK_VERSION,
   FerricStoreClient: () => FerricStoreClient,
   FerricStoreError: () => FerricStoreError,
   FlowAlreadyExistsError: () => FlowAlreadyExistsError,
@@ -100,16 +102,22 @@ function assertSafeVariadicDispatch(argumentCount, arrayCapability) {
 // src/native-adapter.ts
 var import_node_net3 = require("net");
 var import_node_tls3 = require("tls");
-var import_node_buffer22 = require("buffer");
+var import_node_buffer25 = require("buffer");
 
 // src/errors.ts
 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 {
@@ -156,11 +164,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;
   }
 };
@@ -178,15 +189,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")) {
@@ -210,7 +227,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) {
@@ -250,8 +267,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;
@@ -424,9 +456,6 @@ function mapDenseResponseArray(value, transform) {
   return result;
 }
 
-// src/auto-partition.ts
-var import_node_buffer2 = require("buffer");
-
 // src/crc32.ts
 var import_node_buffer = require("buffer");
 var table = new Uint32Array(256);
@@ -444,12 +473,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(import_node_buffer2.Buffer.from(id)) % AUTO_PARTITION_BUCKETS}`;
+  return `${AUTO_PARTITION_PREFIX}${crc32Utf8(id) % AUTO_PARTITION_BUCKETS}`;
 }
 
 // src/flow-argument-helpers.ts
@@ -842,7 +908,7 @@ function coerceDiagnosticValue(value) {
 // src/native-connection.ts
 var import_node_net = __toESM(require("net"), 1);
 var import_node_tls = __toESM(require("tls"), 1);
-var import_node_buffer3 = require("buffer");
+var import_node_buffer2 = require("buffer");
 function parseFerricUrl(value) {
   const url = new URL(value);
   if (url.protocol !== "ferric:" && url.protocol !== "ferrics:") {
@@ -968,7 +1034,7 @@ function nonNegativeSafeInteger(value) {
   if (typeof value === "bigint") {
     return value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : void 0;
   }
-  const source = import_node_buffer3.Buffer.isBuffer(value) || value instanceof Uint8Array ? import_node_buffer3.Buffer.from(value).toString("utf8") : value;
+  const source = import_node_buffer2.Buffer.isBuffer(value) || value instanceof Uint8Array ? import_node_buffer2.Buffer.from(value).toString("utf8") : value;
   if (typeof source !== "number" && (typeof source !== "string" || !/^\d+$/u.test(source))) {
     return void 0;
   }
@@ -1202,10 +1268,10 @@ var NativeHeartbeat = class {
 };
 
 // src/protocol.ts
-var import_node_buffer18 = require("buffer");
+var import_node_buffer21 = require("buffer");
 
 // src/command-grammar.ts
-var import_node_buffer4 = require("buffer");
+var import_node_buffer3 = require("buffer");
 
 // src/command-metadata-flow.ts
 var flowStateIdCommands = /* @__PURE__ */ new Set([
@@ -1652,8 +1718,8 @@ var secondKeySubcommands = /* @__PURE__ */ new Map([
 ]);
 function commandToken(value) {
   if (typeof value === "string") return value.toUpperCase();
-  if (import_node_buffer4.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return import_node_buffer4.Buffer.from(value).toString("utf8").toUpperCase();
+  if (import_node_buffer3.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer3.Buffer.from(value).toString("utf8").toUpperCase();
   }
   return void 0;
 }
@@ -1756,7 +1822,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 : import_node_buffer4.Buffer.isBuffer(value) || value instanceof Uint8Array ? import_node_buffer4.Buffer.from(value).toString("utf8") : void 0;
+  const source = typeof value === "string" ? value : import_node_buffer3.Buffer.isBuffer(value) || value instanceof Uint8Array ? import_node_buffer3.Buffer.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;
@@ -1809,10 +1875,10 @@ function hasOwnCommandArgument(args, index, end, section) {
 }
 
 // src/protocol-core.ts
-var import_node_buffer8 = require("buffer");
+var import_node_buffer7 = require("buffer");
 
 // src/protocol-constants.ts
-var import_node_buffer5 = require("buffer");
+var import_node_buffer4 = require("buffer");
 
 // src/native-protocol-manifest.json
 var native_protocol_manifest_default = {
@@ -2017,6 +2083,7 @@ 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"],
@@ -2029,68 +2096,15 @@ var OPCODES = {
   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;
@@ -2160,16 +2174,16 @@ var FLOW_RECORD_FIELD_KEYS = [
 ];
 
 // src/protocol-text.ts
-var import_node_buffer6 = require("buffer");
+var import_node_buffer5 = require("buffer");
 function toBuffer(value) {
-  if (import_node_buffer6.Buffer.isBuffer(value)) return value;
-  if (value instanceof Uint8Array) return import_node_buffer6.Buffer.from(value);
-  if (typeof value === "string") return import_node_buffer6.Buffer.from(value);
+  if (import_node_buffer5.Buffer.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return import_node_buffer5.Buffer.from(value);
+  if (typeof value === "string") return import_node_buffer5.Buffer.from(value);
   if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return import_node_buffer6.Buffer.from(String(value));
+    return import_node_buffer5.Buffer.from(String(value));
   }
-  if (typeof value === "symbol") return import_node_buffer6.Buffer.from(value.description ?? value.toString());
-  if (value == null) return import_node_buffer6.Buffer.alloc(0);
+  if (typeof value === "symbol") return import_node_buffer5.Buffer.from(value.description ?? value.toString());
+  if (value == null) return import_node_buffer5.Buffer.alloc(0);
   throw new FerricStoreError(`unsupported binary command argument type: ${typeof value}`);
 }
 function asText(value) {
@@ -2177,14 +2191,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" || import_node_buffer6.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || import_node_buffer5.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     return asText(value);
   }
   return void 0;
 }
 function commandTokenIs(value, expected) {
   if (typeof value === "string") return value.toUpperCase() === expected;
-  if (import_node_buffer6.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (import_node_buffer5.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     return asText(value).toUpperCase() === expected;
   }
   return false;
@@ -2198,7 +2212,7 @@ function commandNameIs(value, expected) {
 }
 
 // src/request-context.ts
-var import_node_buffer7 = require("buffer");
+var import_node_buffer6 = require("buffer");
 var requestContextCommands = /* @__PURE__ */ new Set([
   "INVOCATION.CREATE",
   "INVOCATION.DEFINITION.GET",
@@ -2253,9 +2267,9 @@ function requestContextCommandToken(value) {
     const upper = value.toUpperCase();
     return isRequestContextCommand(upper) ? upper : void 0;
   }
-  if (import_node_buffer7.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (import_node_buffer6.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     if (value[0] !== 73 && value[0] !== 105) return void 0;
-    const command = import_node_buffer7.Buffer.from(value).toString("utf8").toUpperCase();
+    const command = import_node_buffer6.Buffer.from(value).toString("utf8").toUpperCase();
     return isRequestContextCommand(command) ? command : void 0;
   }
   return void 0;
@@ -2286,12 +2300,12 @@ function requestContextText(context, fieldName) {
   return value;
 }
 function isPlainObject(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer7.Buffer.isBuffer(value) && !(value instanceof Uint8Array);
+  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer6.Buffer.isBuffer(value) && !(value instanceof Uint8Array);
 }
 function commandToken2(value) {
   if (typeof value === "string") return value.toUpperCase();
-  if (import_node_buffer7.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return import_node_buffer7.Buffer.from(value).toString("utf8").toUpperCase();
+  if (import_node_buffer6.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer6.Buffer.from(value).toString("utf8").toUpperCase();
   }
   return "";
 }
@@ -2381,17 +2395,17 @@ function requestFrameTooLarge(maxBytes) {
   );
 }
 function binaryValueByteLength(value) {
-  if (import_node_buffer8.Buffer.isBuffer(value) || value instanceof Uint8Array) return value.byteLength;
-  if (typeof value === "string") return import_node_buffer8.Buffer.byteLength(value);
+  if (import_node_buffer7.Buffer.isBuffer(value) || value instanceof Uint8Array) return value.byteLength;
+  if (typeof value === "string") return import_node_buffer7.Buffer.byteLength(value);
   if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return import_node_buffer8.Buffer.byteLength(String(value));
+    return import_node_buffer7.Buffer.byteLength(String(value));
   }
-  if (typeof value === "symbol") return import_node_buffer8.Buffer.byteLength(value.description ?? value.toString());
+  if (typeof value === "symbol") return import_node_buffer7.Buffer.byteLength(value.description ?? value.toString());
   if (value == null) return 0;
   return toBuffer(value).byteLength;
 }
 function writeCustomPayload(output, offset, value, knownByteLength) {
-  if (import_node_buffer8.Buffer.isBuffer(value)) {
+  if (import_node_buffer7.Buffer.isBuffer(value)) {
     value.copy(output, offset);
     return;
   }
@@ -2400,17 +2414,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 ?? import_node_buffer8.Buffer.byteLength(text2), "utf8");
+  output.write(text3, offset, knownByteLength ?? import_node_buffer7.Buffer.byteLength(text3), "utf8");
 }
 function compactBinaryEncodedLength(value) {
   return 4 + compactBinaryByteLength(value);
@@ -2423,10 +2437,10 @@ function compactBinaryByteLength(value) {
   return byteLength;
 }
 function isCompactBinaryArgument(value) {
-  return typeof value === "string" || import_node_buffer8.Buffer.isBuffer(value) || value instanceof Uint8Array;
+  return typeof value === "string" || import_node_buffer7.Buffer.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" || import_node_buffer8.Buffer.isBuffer(value) || value instanceof Uint8Array;
+  return value == null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || typeof value === "symbol" || import_node_buffer7.Buffer.isBuffer(value) || value instanceof Uint8Array;
 }
 function compactOptionalBinaryEncodedLength(value) {
   return value == null ? 4 : compactBinaryEncodedLength(value);
@@ -2509,13 +2523,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;
@@ -2557,7 +2571,23 @@ function setOwnValue2(target, key, value) {
 }
 
 // src/protocol-flow-options.ts
-var import_node_buffer9 = require("buffer");
+var import_node_buffer8 = require("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",
@@ -2632,7 +2662,7 @@ function normalizeFlowSearchStateMeta(payload) {
   payload.state_meta = { [asText(state)]: stateMeta };
 }
 function isPlainObject2(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer9.Buffer.isBuffer(value) && !(value instanceof Uint8Array);
+  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer8.Buffer.isBuffer(value) && !(value instanceof Uint8Array);
 }
 function parseFlowOptions(args, start, end, config) {
   const payload = {};
@@ -2726,8 +2756,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;
       }
@@ -3017,6 +3048,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",
@@ -3026,7 +3058,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",
@@ -3041,7 +3072,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",
@@ -3178,7 +3208,7 @@ function flowAdminPayload(opcode, args, leadingFields = []) {
 }
 
 // src/protocol-flow-compact.ts
-var import_node_buffer11 = require("buffer");
+var import_node_buffer10 = require("buffer");
 
 // src/protocol-flow-compact-common.ts
 function compactManyRequestTag(value, regularTag, okOnSuccessTag) {
@@ -3287,7 +3317,7 @@ function parseNamedCountMap(values, start) {
 }
 
 // src/protocol-flow-compact-transition.ts
-var import_node_buffer10 = require("buffer");
+var import_node_buffer9 = require("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;
@@ -3339,7 +3369,7 @@ function compactFlowTransitionManyPayload(partition, fromState, toState, rawItem
     total += 4 + idLength + 4 + itemPartitionLength + 8 + 4 + leaseLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer10.Buffer.allocUnsafe(total);
+  const out = import_node_buffer9.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(tag, offset);
   offset += 1;
@@ -3397,7 +3427,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 = import_node_buffer11.Buffer.allocUnsafe(total);
+  const out = import_node_buffer10.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(tag, offset++);
   offset = writeBinary(out, offset, toBuffer(options.type));
@@ -3442,7 +3472,7 @@ function compactFlowClaimDuePayload(type, options, maxBodyBytes) {
     total += 1;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer11.Buffer.allocUnsafe(total);
+  const out = import_node_buffer10.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(COMPACT_FLOW_CLAIM_DUE_REQUEST, offset++);
   offset = writeBinary(out, offset, toBuffer(type));
@@ -3496,7 +3526,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 = import_node_buffer11.Buffer.allocUnsafe(total);
+  const out = import_node_buffer10.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(
     returnMode === "OK_ON_SUCCESS" ? COMPACT_FLOW_COMPLETE_MANY_OK_REQUEST : COMPACT_FLOW_COMPLETE_MANY_REQUEST,
@@ -3543,7 +3573,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 = import_node_buffer11.Buffer.allocUnsafe(total);
+  const out = import_node_buffer10.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(
     returnMode === "OK_ON_SUCCESS" ? COMPACT_FLOW_RETRY_MANY_OK_REQUEST : COMPACT_FLOW_RETRY_MANY_REQUEST,
@@ -3631,7 +3661,7 @@ function compactFlowCancelManyPayload(args, maxBodyBytes) {
     total += 4 + idLength + 4 + itemPartitionLength + 8;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer11.Buffer.allocUnsafe(total);
+  const out = import_node_buffer10.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(tag, offset);
   offset += 1;
@@ -3667,7 +3697,7 @@ function isOptionalSafeIntegerNumber(value) {
 }
 
 // src/protocol-flow-compact-single.ts
-var import_node_buffer12 = require("buffer");
+var import_node_buffer11 = require("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;
@@ -3684,7 +3714,7 @@ function compactFlowValueMGetPayload(refs, maxBytes, maxBodyBytes) {
     total += 4 + byteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer12.Buffer.allocUnsafe(total);
+  const out = import_node_buffer11.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(COMPACT_FLOW_VALUE_MGET_REQUEST, offset);
   offset += 1;
@@ -3727,7 +3757,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 = import_node_buffer12.Buffer.allocUnsafe(total);
+  const out = import_node_buffer11.Buffer.allocUnsafe(total);
   let offset = 0;
   out.writeUInt8(COMPACT_FLOW_LIST_REQUEST, offset);
   offset += 1;
@@ -4170,6 +4200,7 @@ function flowSpawnChildrenPayload(args) {
       "FROM_STATE",
       "ON_CHILD_FAILED",
       "ON_PARENT_CLOSED",
+      "MAX_ACTIVE_MS",
       "VALUE",
       "VALUE_REF"
     ])
@@ -4200,6 +4231,29 @@ 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-connection-policy.ts
 function assertCommandDoesNotRequirePinnedConnection(args) {
   const outer = commandName(args[0]);
@@ -4247,7 +4301,7 @@ function commandRequiresOrderedPipelineExecution(args) {
 }
 
 // src/protocol-compact-request.ts
-var import_node_buffer13 = require("buffer");
+var import_node_buffer12 = require("buffer");
 function compactMsetPayload(args, maxBodyBytes) {
   if (args.length % 2 !== 0) throw new FerricStoreError("MSET requires key/value pairs");
   const minimum = 6 + args.length * 4;
@@ -4266,7 +4320,7 @@ function compactMsetPayload(args, maxBodyBytes) {
     total += 4 + byteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer13.Buffer.allocUnsafe(total);
+  const out = import_node_buffer12.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, 1, args.length / 2);
   for (let index = 0; index < args.length; index += 1) {
     offset = writeBinaryValue(out, offset, args[index], byteLengths[index] ?? 0);
@@ -4290,7 +4344,7 @@ function compactKeyPipelinePayload(opcode, args, mode, maxBodyBytes) {
     total += 4 + byteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer13.Buffer.allocUnsafe(total);
+  const out = import_node_buffer12.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, mode, args.length);
   for (let index = 0; index < args.length; index += 1) {
     offset = writeBinaryValue(out, offset, args[index], byteLengths[index] ?? 0);
@@ -4300,7 +4354,7 @@ function compactKeyPipelinePayload(opcode, args, mode, maxBodyBytes) {
 function compactPipelinePayload(commands, maxBodyBytes) {
   if (commands.length === 0) {
     assertCompactPayloadFits(6, maxBodyBytes);
-    const out = import_node_buffer13.Buffer.allocUnsafe(6);
+    const out = import_node_buffer12.Buffer.allocUnsafe(6);
     writeCompactPipelineHeader(out, 128 | 2, 0);
     return out;
   }
@@ -4342,7 +4396,7 @@ function compactSetPipelinePayload(commands, maxBodyBytes) {
     total += 8 + keyByteLength + valueByteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer13.Buffer.allocUnsafe(total);
+  const out = import_node_buffer12.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, 128 | 1, commands.length);
   for (let index = 0; index < commands.length; index += 1) {
     offset = writeBinaryValue(out, offset, argumentValues[index * 2], argumentByteLengths[index * 2] ?? 0);
@@ -4377,7 +4431,7 @@ function compactGetPipelinePayload(commands, maxBodyBytes) {
     total += 4 + keyByteLength;
   }
   assertCompactPayloadFits(total, maxBodyBytes);
-  const out = import_node_buffer13.Buffer.allocUnsafe(total);
+  const out = import_node_buffer12.Buffer.allocUnsafe(total);
   let offset = writeCompactPipelineHeader(out, 128 | 2, commands.length);
   for (let index = 0; index < commands.length; index += 1) {
     offset = writeBinaryValue(out, offset, keys[index], keyByteLengths[index] ?? 0);
@@ -4418,7 +4472,7 @@ function writeCompactPipelineHeader(out, mode, count) {
 }
 
 // src/protocol-kv.ts
-var import_node_buffer14 = require("buffer");
+var import_node_buffer13 = require("buffer");
 function collectionProtocolCommand(command, args) {
   switch (command) {
     case "CAS":
@@ -4566,15 +4620,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] }
@@ -4660,17 +4719,17 @@ function parsedNumber(value) {
   }
 }
 function isBinaryCommandArgument(value) {
-  return typeof value === "string" || import_node_buffer14.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer13.Buffer.isBuffer(value);
 }
 function isDirectKvValueArgument(value) {
   return isBinaryCommandArgument(value) || typeof value === "object" && value != null;
 }
 function binaryToken(value) {
-  return typeof value === "string" ? value.toUpperCase() : import_node_buffer14.Buffer.isBuffer(value) ? value.toString("utf8").toUpperCase() : void 0;
+  return typeof value === "string" ? value.toUpperCase() : import_node_buffer13.Buffer.isBuffer(value) ? value.toString("utf8").toUpperCase() : void 0;
 }
 
 // src/protocol-value.ts
-var import_node_buffer15 = require("buffer");
+var import_node_buffer14 = require("buffer");
 function planValueWithLimit(value, maxBytes) {
   const budget = {
     maxBytes,
@@ -4725,7 +4784,7 @@ function planContainerValue(value, budget, ancestors, depth) {
     let byteLength = 5;
     let index = 0;
     for (const [key, item] of entries) {
-      const keyByteLength = import_node_buffer15.Buffer.byteLength(key);
+      const keyByteLength = import_node_buffer14.Buffer.byteLength(key);
       consumeEncodeBytes(budget, 4 + keyByteLength);
       const valuePlan = planValueAt(item, budget, ancestors, depth + 1);
       entryPlans[index] = { key, keyByteLength, value: valuePlan };
@@ -4774,7 +4833,7 @@ function planScalarValue(value, budget) {
     consumeEncodeBytes(budget, 9);
     return { byteLength: 9, tag: 7, value };
   }
-  if (typeof value === "string" || import_node_buffer15.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (typeof value === "string" || import_node_buffer14.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     const valueByteLength = binaryValueByteLength(value);
     const byteLength = 5 + valueByteLength;
     consumeEncodeBytes(budget, byteLength);
@@ -4798,7 +4857,7 @@ function writeValuePlan(output, start, plan) {
       offset += 4;
       if (typeof plan.value === "string") {
         output.write(plan.value, offset, plan.valueByteLength, "utf8");
-      } else if (import_node_buffer15.Buffer.isBuffer(plan.value)) {
+      } else if (import_node_buffer14.Buffer.isBuffer(plan.value)) {
         plan.value.copy(output, offset);
       } else {
         output.set(plan.value, offset);
@@ -4931,58 +4990,458 @@ function requireAvailable(data, offset, size) {
   }
 }
 
+// src/key-slot-validation.ts
+var import_node_buffer16 = require("buffer");
+
+// src/topology-utilities.ts
+var import_node_buffer15 = require("buffer");
+function isPlainObject3(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer15.Buffer.isBuffer(value);
+}
+function getField(source, ...keys) {
+  if (source instanceof Map) {
+    for (const key of keys) {
+      if (source.has(key)) return source.get(key);
+      const bufferKey = import_node_buffer15.Buffer.from(key);
+      for (const [itemKey, value] of source.entries()) {
+        if (import_node_buffer15.Buffer.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 (import_node_buffer15.Buffer.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 };
+      }
+    }
+  };
+  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 : import_node_buffer16.Buffer.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" && !import_node_buffer16.Buffer.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
+var import_node_buffer20 = require("buffer");
+
+// src/protocol-compact-response.ts
+var import_node_buffer19 = require("buffer");
+
+// src/native-negotiation.ts
 var import_node_buffer17 = require("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 (import_node_buffer17.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer17.Buffer.from(value).toString("utf8");
+  }
+  return void 0;
+}
+
+// src/protocol-compact-collections.ts
+var import_node_buffer18 = require("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
-var import_node_buffer16 = require("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 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 ? values : values.length === 1 ? "OK" : values };
+    return {
+      found: true,
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(values) : values.length === 1 ? "OK" : values
+    };
   }
-  if (tag === COMPACT_KV_GET && compactResponseOpcodeSupports(opcode, COMPACT_KIND_KV_GET)) {
+  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) && compactResponseOpcodeSupports(opcode, COMPACT_KIND_KV_MGET)) {
+  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: tag === COMPACT_KV_MGET ? decodeCompactMget(body, budget) : decodeCompactMgetFixed(body, budget)
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(values) : values
     };
   }
-  if (tag === COMPACT_PIPELINE_RESPONSE && compactResponseOpcodeSupports(opcode, COMPACT_KIND_PIPELINE)) {
+  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 && compactResponseOpcodeSupports(opcode, COMPACT_KIND_FLOW_CLAIM_JOBS)) {
-    return { found: true, value: decodeCompactClaimJobs(body, budget, hints.compactClaimMode) };
+  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 && compactResponseOpcodeSupports(opcode, COMPACT_KIND_FLOW_RECORD)) {
+  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 && isFlowRecordListOpcode(opcode)) {
+  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: read.value };
+    return {
+      found: true,
+      value: opcode === OPCODES.pipeline ? markCompactPipelineDecoded(read.value) : read.value
+    };
   }
   return { found: false, value: void 0 };
 }
-function isOkListOpcode(opcode) {
-  return compactResponseOpcodeSupports(opcode, COMPACT_KIND_OK_LIST);
-}
-function isFlowRecordListOpcode(opcode) {
-  return compactResponseOpcodeSupports(opcode, COMPACT_KIND_FLOW_RECORD_LIST);
+function supports(hints, codec, opcode) {
+  return compactResponseOpcodeSupports(hints.compactResponseOpcodes, codec, opcode);
 }
 function decodeCompactOkList(data, budget) {
   requireAvailable(data, 0, 5);
   const count = data.readUInt32BE(1);
-  requireCompactContainer(count, budget);
+  requireCompactContainer2(count, budget);
   if (data.byteLength !== 5) throw new FerricStoreError("invalid compact OK list response");
-  return Array.from({ length: count }, () => import_node_buffer16.Buffer.from("OK"));
+  return Array.from({ length: count }, () => import_node_buffer19.Buffer.from("OK"));
 }
 function decodeCompactKvGet(data) {
   requireAvailable(data, 0, 2);
@@ -4999,7 +5458,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) {
@@ -5023,12 +5482,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(import_node_buffer16.Buffer.alloc(0));
+  if (size === 0) return new Array(count).fill(import_node_buffer19.Buffer.alloc(0));
   const values = new Array(count);
   for (let index = 0, offset = 9; index < count; index += 1, offset += size) {
     values[index] = data.subarray(offset, offset + size);
@@ -5038,7 +5497,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");
   }
@@ -5100,13 +5559,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;
@@ -5190,7 +5648,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) {
@@ -5218,7 +5676,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) {
@@ -5228,33 +5686,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);
@@ -5263,7 +5694,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");
   }
@@ -5271,7 +5702,7 @@ function requireCompactContainer(count, budget) {
 }
 function errorMessage(status, value) {
   if (typeof value === "string") return value;
-  if (import_node_buffer16.Buffer.isBuffer(value)) return value.toString("utf8");
+  if (import_node_buffer19.Buffer.isBuffer(value)) return value.toString("utf8");
   if (typeof value === "object" && value != null && Object.hasOwn(value, "message")) {
     const message = value.message;
     return typeof message === "string" ? message : String(message);
@@ -5351,7 +5782,7 @@ function unwrapPipelineResponse(value, options = {}, expectedItems) {
   return out;
 }
 function pipelineStatus(value) {
-  if (typeof value !== "string" && !import_node_buffer17.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return null;
+  if (typeof value !== "string" && !import_node_buffer20.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return null;
   const status = asText(value).toLowerCase();
   return status === "ok" || status === "busy" || status === "error" ? status : null;
 }
@@ -5366,7 +5797,7 @@ function decodeResponseValue(opcode, body, hints) {
 }
 function errorMessage2(status, value) {
   if (typeof value === "string") return value;
-  if (import_node_buffer17.Buffer.isBuffer(value)) return value.toString("utf8");
+  if (import_node_buffer20.Buffer.isBuffer(value)) return value.toString("utf8");
   if (typeof value === "object" && value != null && Object.hasOwn(value, "message")) {
     const message = value.message;
     return typeof message === "string" ? message : String(message);
@@ -5382,7 +5813,7 @@ function encodeRequest(command, requestId, maxBodyBytes = Number.MAX_SAFE_INTEGE
   const bodyLength = customPayload ? binaryValueByteLength(command.payload) : plan?.byteLength ?? 0;
   if (bodyLength > bodyLimit) throw requestFrameTooLarge(bodyLimit);
   const flags = command.flags ?? 0;
-  const frame = import_node_buffer18.Buffer.allocUnsafe(HEADER_SIZE + bodyLength);
+  const frame = import_node_buffer21.Buffer.allocUnsafe(HEADER_SIZE + bodyLength);
   frame.write(MAGIC, 0, "ascii");
   frame.writeUInt8(REQUEST_VERSION, 4);
   frame.writeUInt8(flags, 5);
@@ -5433,6 +5864,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);
@@ -5570,20 +6004,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([
@@ -5752,6 +6173,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"]) {
@@ -5771,7 +6193,7 @@ var import_node_net2 = require("net");
 var import_node_tls2 = require("tls");
 
 // src/client-native-options.ts
-var import_node_buffer19 = require("buffer");
+var import_node_buffer22 = require("buffer");
 
 // src/string-array-snapshot.ts
 function snapshotOwnStringArray(values, name) {
@@ -5854,7 +6276,7 @@ function snapshotTlsOptions(options) {
   return Object.freeze(snapshot);
 }
 function snapshotTlsValue(value, name) {
-  if (import_node_buffer19.Buffer.isBuffer(value)) return import_node_buffer19.Buffer.from(value);
+  if (import_node_buffer22.Buffer.isBuffer(value)) return import_node_buffer22.Buffer.from(value);
   if (value instanceof Uint8Array) return value.slice();
   if (Array.isArray(value)) {
     const snapshot = new Array(value.length);
@@ -6324,6 +6746,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);
@@ -6406,7 +6831,7 @@ var NativeChunkAssembler = class {
 };
 
 // src/native-response-handler.ts
-var import_node_buffer20 = require("buffer");
+var import_node_buffer23 = require("buffer");
 
 // src/native-receive-buffer.ts
 var FRAME_ASSEMBLY_PAGE_BYTES = 64 * 1024;
@@ -6568,12 +6993,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 {
@@ -6655,15 +7086,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;
@@ -6679,7 +7113,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) {
@@ -6688,12 +7122,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,
@@ -6730,7 +7166,7 @@ var NativeRequestScheduler = class {
 };
 
 // src/native-write-queue.ts
-var import_node_buffer21 = require("buffer");
+var import_node_buffer24 = require("buffer");
 var NativeWriteQueue = class {
   constructor(socket, maxQueuedWriteBytes, isClosed, hasPending, rejectPending) {
     this.socket = socket;
@@ -6858,6 +7294,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;
@@ -6866,9 +7336,9 @@ var NativeAdapter = class _NativeAdapter {
   closedWaiters = /* @__PURE__ */ new Set();
   chunkAssembler;
   closed = false;
+  capabilities;
   protocolLanes;
   maxPipelineCommands = Number.MAX_SAFE_INTEGER;
-  maxRequestFrameBytes;
   pendingControlRequests = 0;
   maxPendingControlRequests;
   heartbeat;
@@ -6883,7 +7353,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,
@@ -6910,7 +7380,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);
@@ -6921,6 +7391,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,
@@ -6946,6 +7417,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();
@@ -6963,13 +7435,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
     );
   }
@@ -6991,7 +7463,7 @@ var NativeAdapter = class _NativeAdapter {
       laneId,
       options,
       this.maxPipelineCommands,
-      this.maxRequestFrameBytes
+      this.capabilities.requestFrameBytes
     );
   }
   /** @internal Execute an ordered pipeline on a topology-selected lane. */
@@ -7002,13 +7474,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();
   }
@@ -7026,7 +7496,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) {
@@ -7067,7 +7539,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 }));
@@ -7121,9 +7593,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();
@@ -7189,18 +7659,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;
     }
   }
 };
@@ -7213,7 +7683,7 @@ function executeCommandArgs(executor, args) {
 }
 
 // src/reconnecting-executor.ts
-var import_node_buffer23 = require("buffer");
+var import_node_buffer26 = require("buffer");
 var ReconnectingExecutor = class {
   constructor(createExecutor, options = {}) {
     this.createExecutor = createExecutor;
@@ -7408,217 +7878,11 @@ function normalizeNonNegativeInteger2(value, fallback) {
 }
 
 // src/topology.ts
-var import_node_buffer26 = require("buffer");
+var import_node_buffer28 = require("buffer");
 
 // src/topology-routing.ts
-var import_node_buffer25 = require("buffer");
+var import_node_buffer27 = require("buffer");
 var import_node_crypto = require("crypto");
-
-// src/topology-utilities.ts
-var import_node_buffer24 = require("buffer");
-function isPlainObject3(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer24.Buffer.isBuffer(value);
-}
-function getField(source, ...keys) {
-  if (source instanceof Map) {
-    for (const key of keys) {
-      if (source.has(key)) return source.get(key);
-      const bufferKey = import_node_buffer24.Buffer.from(key);
-      for (const [itemKey, value] of source.entries()) {
-        if (import_node_buffer24.Buffer.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 (import_node_buffer24.Buffer.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 };
-      }
-    }
-  };
-  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))
-  );
-}
-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 flowHashTag(rest, fallbackKey) {
-  const end = rest.indexOf(CLOSE_BRACE);
-  return end > 0 ? rest.subarray(0, end) : hashTagOrKey(fallbackKey);
-}
-var ROUTE_SLOT_MASK = 1023;
-var FLOW_KEY_PREFIX = import_node_buffer24.Buffer.from("f:{");
-var VALUE_REF_FLOW_KEY_PREFIX = import_node_buffer24.Buffer.from("X:f:{");
-function routingSlotForKey(key) {
-  const keyBytes = import_node_buffer24.Buffer.isBuffer(key) ? key : import_node_buffer24.Buffer.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);
-  }
-  return crc32(hashInput) & ROUTE_SLOT_MASK;
-}
-
-// src/topology-routing.ts
 var FLOW_PARTITION_ROUTE_CACHE_MAX = 1024;
 var flowPartitionRouteCache = /* @__PURE__ */ new Map();
 function routingKeyFromProtocolPayload(name, command) {
@@ -7626,9 +7890,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" || import_node_buffer25.Buffer.isBuffer(value)) {
+      if (typeof value === "string" || import_node_buffer27.Buffer.isBuffer(value)) {
         return value;
       }
     }
@@ -7675,9 +7948,9 @@ function flowRoutingData(name, args) {
     if (typeof partition === "string" && partition.toUpperCase() !== "AUTO" && partition.toUpperCase() !== "MIXED") {
       return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
     }
-    if (import_node_buffer25.Buffer.isBuffer(partition)) {
-      const text2 = partition.toString("utf8").toUpperCase();
-      if (text2 !== "AUTO" && text2 !== "MIXED") {
+    if (import_node_buffer27.Buffer.isBuffer(partition)) {
+      const text3 = partition.toString("utf8").toUpperCase();
+      if (text3 !== "AUTO" && text3 !== "MIXED") {
         return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
       }
     }
@@ -7766,22 +8039,22 @@ function flowPartitionRoutingKeyFromCommand(command, claim) {
   return { handled: false };
 }
 function isRoutingKey(value) {
-  return typeof value === "string" || import_node_buffer25.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer27.Buffer.isBuffer(value);
 }
 function flowLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer25.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer27.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bytes2 = import_node_buffer25.Buffer.isBuffer(value) ? value : import_node_buffer25.Buffer.from(value);
-  const text2 = bytes2.toString("utf8");
-  const autoMatch = /^__flow_auto__:(0|[1-9]\d{0,2})$/u.exec(text2);
+  const bytes2 = import_node_buffer27.Buffer.isBuffer(value) ? value : import_node_buffer27.Buffer.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 = `${import_node_buffer25.Buffer.isBuffer(value) ? "b" : "s"}:${bytes2.toString("base64")}`;
+  const cacheKey = `${import_node_buffer27.Buffer.isBuffer(value) ? "b" : "s"}:${bytes2.toString("base64")}`;
   const cached = flowPartitionRouteCache.get(cacheKey);
   if (cached != null) {
     flowPartitionRouteCache.delete(cacheKey);
@@ -7789,7 +8062,7 @@ function flowLogicalPartitionRoutingKey(value) {
     return cached;
   }
   const digest = (0, import_node_crypto.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);
@@ -7798,18 +8071,17 @@ function flowLogicalPartitionRoutingKey(value) {
   return routeKey;
 }
 function flowAutoIdRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer25.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer27.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bytes2 = import_node_buffer25.Buffer.isBuffer(value) ? value : import_node_buffer25.Buffer.from(value);
-  const bucket = crc32(bytes2) & 255;
-  return `f:{fa:${bucket}}:route`;
+  const bucket = (import_node_buffer27.Buffer.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
+  return `{fa:${bucket}}`;
 }
 function flowClaimLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer25.Buffer.isBuffer(value)) return void 0;
+  if (typeof value !== "string" && !import_node_buffer27.Buffer.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) {
@@ -7821,7 +8093,7 @@ function singleShardFlowClaimPartitionKey(values) {
   return keys.some((key) => key == null) ? void 0 : singleShardKey(keys);
 }
 function singleShardKey(keys) {
-  if (keys.length === 0 || keys.some((key) => typeof key !== "string" && !import_node_buffer25.Buffer.isBuffer(key))) {
+  if (keys.length === 0 || keys.some((key) => typeof key !== "string" && !import_node_buffer27.Buffer.isBuffer(key))) {
     return void 0;
   }
   const usable = keys;
@@ -7854,7 +8126,7 @@ function routedKeyGroups(keys, routeKey) {
   const groups = /* @__PURE__ */ new Map();
   for (let index = 0; index < keys.length; index += 1) {
     const key = keys[index];
-    if (typeof key !== "string" && !import_node_buffer25.Buffer.isBuffer(key)) return void 0;
+    if (typeof key !== "string" && !import_node_buffer27.Buffer.isBuffer(key)) return void 0;
     const route = routeKey(key);
     const groupKey = `${route.endpointKey}\0${route.laneId}`;
     const group = groups.get(groupKey);
@@ -8095,7 +8367,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
@@ -8829,7 +9110,9 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
       () => true,
       () => false
     );
-    return refreshed && isExplicitlySafeReroute(error);
+    if (!refreshed || !await waitForExplicitlySafeReroute(error)) return false;
+    this.assertOpen();
+    return true;
   }
   async executePipelineOnRoute(commands, route, options) {
     const adapter = await this.adapterForCurrentRoute(route);
@@ -8919,7 +9202,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
 };
 
 // src/response-map-preservation.ts
-var import_node_buffer27 = require("buffer");
+var import_node_buffer29 = require("buffer");
 function toStringKeyMapPreservingValues(value) {
   if (value == null) return void 0;
   const result = {};
@@ -8929,7 +9212,7 @@ function toStringKeyMapPreservingValues(value) {
     }
     return result;
   }
-  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer27.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer29.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     for (const [key, item] of Object.entries(value)) {
       setOwnValue(result, text(key), normalizeMapStructurePreservingBytes(item));
     }
@@ -8938,7 +9221,7 @@ function toStringKeyMapPreservingValues(value) {
   return void 0;
 }
 function normalizeMapStructurePreservingBytes(value) {
-  if (import_node_buffer27.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
+  if (import_node_buffer29.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
   if (value instanceof Map) {
     const result = {};
     for (const [key, item] of value.entries()) {
@@ -8960,7 +9243,7 @@ function normalizeMapStructurePreservingBytes(value) {
 }
 
 // src/native-kv-responses.ts
-var import_node_buffer28 = require("buffer");
+var import_node_buffer30 = require("buffer");
 function rateLimitResultFromResp(value) {
   if (!Array.isArray(value) || value.length !== 4) {
     throw new TypeError("RATELIMIT.ADD returned an unexpected response");
@@ -9003,30 +9286,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 (import_node_buffer28.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer28.Buffer.from(value));
-  if (typeof value === "string") return codec.decode(import_node_buffer28.Buffer.from(value));
+  if (import_node_buffer30.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer30.Buffer.from(value));
+  if (typeof value === "string") return codec.decode(import_node_buffer30.Buffer.from(value));
   return normalizeRefMeta(value);
 }
 function requiredResponseString(value, context) {
-  if (typeof value !== "string" && !import_node_buffer28.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !import_node_buffer30.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   const result = text(value);
@@ -9043,7 +9323,7 @@ function requiredNonNegativeInteger(value, context) {
   return result;
 }
 function responseBytes(value, context) {
-  if (typeof value !== "string" && !import_node_buffer28.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !import_node_buffer30.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   return bytes(value);
@@ -9128,6 +9408,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"),
@@ -9142,6 +9425,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"),
@@ -9153,6 +9438,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;
@@ -9733,7 +10033,7 @@ function groupAutoPartitionItems(items) {
 }
 
 // src/client-values.ts
-var import_node_buffer29 = require("buffer");
+var import_node_buffer31 = require("buffer");
 async function valueMGetEntries(client, refs, options = {}) {
   const refCount = refs.length;
   if (refCount === 0) {
@@ -9768,12 +10068,12 @@ async function valueMGetEntries(client, refs, options = {}) {
     const item = response[index];
     if (item == null) {
       entries[index] = { found: false };
-    } else if (import_node_buffer29.Buffer.isBuffer(item)) {
+    } else if (import_node_buffer31.Buffer.isBuffer(item)) {
       entries[index] = { found: true, value: client.codec.decode(item) };
     } else if (item instanceof Uint8Array) {
-      entries[index] = { found: true, value: client.codec.decode(import_node_buffer29.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer31.Buffer.from(item)) };
     } else if (typeof item === "string") {
-      entries[index] = { found: true, value: client.codec.decode(import_node_buffer29.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer31.Buffer.from(item)) };
     } else {
       entries[index] = { found: true, value: item };
     }
@@ -9782,10 +10082,10 @@ async function valueMGetEntries(client, refs, options = {}) {
 }
 
 // src/auto-batch.ts
-var import_node_buffer31 = require("buffer");
+var import_node_buffer33 = require("buffer");
 
 // src/auto-batch-ordering.ts
-var import_node_buffer30 = require("buffer");
+var import_node_buffer32 = require("buffer");
 function autoBatchOrderingPlan(batch) {
   const accesses = /* @__PURE__ */ new Map();
   const fallbackDependencies = [];
@@ -9900,13 +10200,13 @@ function flowManyAutoBatchIds(command, name) {
     return fixedFlowItemIds(
       command,
       mixed ? 4 : 3,
-      (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && isFencingToken(command[itemIndex + (mixed ? 2 : 1)]) && import_node_buffer30.Buffer.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
+      (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && isFencingToken(command[itemIndex + (mixed ? 2 : 1)]) && import_node_buffer32.Buffer.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
     );
   }
   return fixedFlowItemIds(
     command,
     mixed ? 4 : 3,
-    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer30.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
+    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer32.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
   );
 }
 function createManyAutoBatchIds(command) {
@@ -9919,7 +10219,7 @@ function createManyAutoBatchIds(command) {
       const ids = fixedFlowItemIds(
         command,
         width,
-        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer30.Buffer.isBuffer(command[itemIndex + width - 1]),
+        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer32.Buffer.isBuffer(command[itemIndex + width - 1]),
         markerIndex
       );
       if (ids != null) return ids;
@@ -9937,7 +10237,7 @@ function extendedCreateManyAutoBatchIds(command, markerIndex) {
   let cursor = markerIndex + 2;
   for (let itemIndex = 0; itemIndex < itemCount; itemIndex += 1) {
     const id = command[cursor];
-    if (!isAutoBatchResourceValue(id) || !isAutoBatchResourceValue(command[cursor + 1]) || !import_node_buffer30.Buffer.isBuffer(command[cursor + 2])) return void 0;
+    if (!isAutoBatchResourceValue(id) || !isAutoBatchResourceValue(command[cursor + 1]) || !import_node_buffer32.Buffer.isBuffer(command[cursor + 2])) return void 0;
     ids.push(id);
     cursor += 3;
     const afterValues = skipExtendedNamedItems(command, cursor, true);
@@ -9956,7 +10256,7 @@ function skipExtendedNamedItems(command, countIndex, encodedValues) {
   for (let index = 0; index < count; index += 1) {
     const name = command[firstItem + index * 2];
     const value = command[firstItem + index * 2 + 1];
-    if (!isAutoBatchResourceValue(name) || (encodedValues ? !import_node_buffer30.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
+    if (!isAutoBatchResourceValue(name) || (encodedValues ? !import_node_buffer32.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
   }
   return firstItem + count * 2;
 }
@@ -9971,7 +10271,7 @@ function runStepsManyAutoBatchIds(command) {
         ids.push(item);
         continue;
       }
-      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer30.Buffer.isBuffer(item)) return void 0;
+      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer32.Buffer.isBuffer(item)) return void 0;
       const id = item.id;
       if (!isAutoBatchResourceValue(id)) return void 0;
       ids.push(id);
@@ -10012,7 +10312,7 @@ function flowValuePutOwner(command, start) {
 }
 var flowValuePutOptionTokens = /* @__PURE__ */ new Set(["NAME", "NOW", "OVERRIDE", "OWNER_FLOW_ID", "PARTITION", "TTL", "TTL_MS"]);
 function isAutoBatchResourceValue(value) {
-  return typeof value === "string" || import_node_buffer30.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer32.Buffer.isBuffer(value);
 }
 function isFencingToken(value) {
   return typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint";
@@ -10021,7 +10321,7 @@ function nonNegativeItemCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
 function autoBatchResourceKey(namespace, value) {
-  return `${namespace}:${import_node_buffer30.Buffer.from(value).toString("base64")}`;
+  return `${namespace}:${import_node_buffer32.Buffer.from(value).toString("base64")}`;
 }
 function autoBatchCommandName(command) {
   return commandView(command).name ?? null;
@@ -10430,15 +10730,15 @@ function claimFailure(error) {
 }
 
 // src/client-flow-support.ts
-var import_node_buffer37 = require("buffer");
+var import_node_buffer39 = require("buffer");
 
 // src/client-core.ts
-var import_node_buffer36 = require("buffer");
+var import_node_buffer38 = require("buffer");
 
 // src/client-core-helpers.ts
-var import_node_buffer32 = require("buffer");
+var import_node_buffer34 = require("buffer");
 function bgsaveResponse(response) {
-  if ((typeof response === "string" || import_node_buffer32.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
+  if ((typeof response === "string" || import_node_buffer34.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
     return true;
   }
   return okResponse(response);
@@ -10449,11 +10749,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 && !import_node_buffer32.Buffer.isBuffer(options.computeToken)) {
-    throw new TypeError("fetch-or-compute computeToken must be a Buffer or explicit null for a legacy lease");
+  if (!import_node_buffer34.Buffer.isBuffer(options.computeToken)) {
+    throw new TypeError("fetch-or-compute computeToken must be a Buffer");
   }
   return options.computeToken;
 }
@@ -10475,10 +10775,10 @@ function unsupportedClientCaching() {
 }
 
 // src/client-base.ts
-var import_node_buffer34 = require("buffer");
+var import_node_buffer36 = require("buffer");
 
 // src/client-executor.ts
-var import_node_buffer33 = require("buffer");
+var import_node_buffer35 = require("buffer");
 var ErrorMappingExecutor = class {
   constructor(executor) {
     this.executor = executor;
@@ -10575,14 +10875,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),
@@ -10809,14 +11112,14 @@ var FerricStoreAdministrationClient = class extends FerricStoreClientBase {
 };
 
 // src/store-utilities.ts
-var import_node_buffer35 = require("buffer");
+var import_node_buffer37 = require("buffer");
 function encode(codec, value) {
   return codec.encode(value);
 }
 function decode(codec, value) {
   if (value == null) return null;
-  if (import_node_buffer35.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer35.Buffer.from(value));
+  if (import_node_buffer37.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer37.Buffer.from(value));
   return value;
 }
 function number(value) {
@@ -11222,12 +11525,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");
+    }
+    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 === 3) {
-      args.push(width, depth, decay);
+    if (tuningCount === 2) {
+      args.push(width, depth);
     }
     return okResponse(await commandArgs(this.client, args));
   }
@@ -11633,10 +11939,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));
@@ -12706,7 +13016,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
     ));
   }
@@ -12715,7 +13026,7 @@ var FerricStoreClientCore = class extends FerricStoreAdministrationClient {
     return okResponse(await this.command(
       "FETCH_OR_COMPUTE_ERROR",
       key,
-      ...computeToken === null ? [] : [computeToken],
+      computeToken,
       message
     ));
   }
@@ -12841,7 +13152,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) {
@@ -13013,7 +13324,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);
@@ -13029,7 +13340,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();
@@ -13294,7 +13605,7 @@ var FerricStoreFlowSupportClient = class extends FerricStoreManagementClient {
 };
 
 // src/flow-many-snapshot.ts
-var import_node_buffer38 = require("buffer");
+var import_node_buffer40 = require("buffer");
 var encodedOptionFields = ["error", "payload", "reason", "result"];
 function snapshotCreateItem(item, codec) {
   const snapshot = {
@@ -13334,7 +13645,7 @@ function snapshotFlowManyOptions(options, codec) {
 }
 function snapshotClaimedItem(item) {
   const wire = item[CLAIMED_ITEM_WIRE];
-  const leaseToken = import_node_buffer38.Buffer.from(wire?.leaseToken ?? item.leaseToken);
+  const leaseToken = import_node_buffer40.Buffer.from(wire?.leaseToken ?? item.leaseToken);
   const snapshot = {
     ...item,
     fencingToken: wire?.fencingToken ?? item.fencingToken,
@@ -13351,15 +13662,15 @@ function snapshotClaimedItem(item) {
 function snapshotFencedItem(item) {
   return Object.freeze({
     ...item,
-    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer38.Buffer.from(item.leaseToken) }
+    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer40.Buffer.from(item.leaseToken) }
   });
 }
 function snapshotClaimedItemWire(wire, leaseToken) {
   return Object.freeze({
     fencingToken: wire.fencingToken,
-    id: import_node_buffer38.Buffer.from(wire.id),
+    id: import_node_buffer40.Buffer.from(wire.id),
     leaseToken,
-    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer38.Buffer.from(wire.partitionKey)
+    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer40.Buffer.from(wire.partitionKey)
   });
 }
 function snapshotArray(values) {
@@ -13370,7 +13681,7 @@ function snapshotArray(values) {
   return Object.freeze(snapshot);
 }
 function snapshotStateMeta(stateMeta) {
-  return snapshotRecord(stateMeta, (value) => import_node_buffer38.Buffer.isBuffer(value) ? import_node_buffer38.Buffer.from(value) : value);
+  return snapshotRecord(stateMeta, (value) => import_node_buffer40.Buffer.isBuffer(value) ? import_node_buffer40.Buffer.from(value) : value);
 }
 function snapshotCommandRecord(values) {
   const seen = /* @__PURE__ */ new WeakMap();
@@ -13388,7 +13699,7 @@ function snapshotRecord(values, capture) {
 }
 function snapshotCommandArgument(value, seen) {
   if (typeof value !== "object" || value == null) return value;
-  if (import_node_buffer38.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer38.Buffer.from(value);
+  if (import_node_buffer40.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer40.Buffer.from(value);
   const objectValue = value;
   const existing = seen.get(objectValue);
   if (existing != null) return existing;
@@ -14186,6 +14497,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);
@@ -14217,7 +14531,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);
   }
@@ -14247,6 +14560,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);
@@ -16352,16 +16666,23 @@ var WorkflowWorker = class {
     );
   }
 };
+
+// src/version.ts
+var FERRICSTORE_SDK_VERSION = "0.2.0";
+var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.8.0";
+var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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,