@ferricstore/ferricstore 0.11.9 → 0.11.11

package/dist/index.cjs

@@ -1556,6 +1556,7 @@ var neverAutoBatchCommandPrefixes = /* @__PURE__ */ new Set([
   "BLPOP",
   "BRPOP",
   "BRPOPLPUSH",
+  "BZMPOP",
   "BZPOPMAX",
   "BZPOPMIN",
   "CLIENT",
@@ -1667,6 +1668,9 @@ var connectionBlockingCommands = /* @__PURE__ */ new Set([
   "BLPOP",
   "BRPOP",
   "BRPOPLPUSH",
+  "BZMPOP",
+  "BZPOPMAX",
+  "BZPOPMIN",
   "XREAD",
   "XREADGROUP"
 ]);
@@ -2535,8 +2539,10 @@ function serverBlockMetadata(args) {
     serverBlockMs = blockDurationMs(args[3], 1e3);
   } else if (command === "BLMOVE" && args.length >= 6) {
     serverBlockMs = blockDurationMs(args[args.length - 1], 1e3);
-  } else if (command === "BLMPOP" && args.length >= 2) {
+  } else if ((command === "BLMPOP" || command === "BZMPOP") && args.length >= 2) {
     serverBlockMs = blockDurationMs(args[1], 1e3);
+  } else if ((command === "BZPOPMAX" || command === "BZPOPMIN") && args.length >= 3) {
+    serverBlockMs = blockDurationMs(args[args.length - 1], 1e3);
   } else if (command === "XREAD" || command === "XREADGROUP") {
     serverBlockMs = optionBlockDurationMs(args, ["BLOCK"], "STREAMS");
   } else if (command === "WAIT" && args.length === 3) {
@@ -7596,6 +7602,24 @@ async function executeIndividually(host, commands, laneId, options) {
   }, commands, options);
 }
 
+// src/server-response-timeout.ts
+function serverResponseTimeoutMs(requestTimeoutMs, serverBlockMs) {
+  if (serverBlockMs == null) return requestTimeoutMs;
+  if (serverBlockMs === 0) return void 0;
+  return saturatingAdd(requestTimeoutMs, serverBlockMs);
+}
+function combinedServerBlockMs(values) {
+  let total;
+  for (const value of values) {
+    if (value === 0) return 0;
+    if (value != null) total = saturatingAdd(total ?? 0, value);
+  }
+  return total;
+}
+function saturatingAdd(left, right) {
+  return Math.min(Number.MAX_SAFE_INTEGER, left + right);
+}
+
 // src/native-pending-timeout.ts
 function timeoutNativePendingRequest(operations, requestId, timeoutMs) {
   const pending = operations.getPending(requestId);
@@ -7624,10 +7648,7 @@ function timeoutNativePendingRequest(operations, requestId, timeoutMs) {
   pending.reject(new RequestTimeoutError(timeoutMs, "possibly_sent"));
 }
 function nativeResponseTimeoutMs(command, requestTimeoutMs) {
-  const blockMs = command.serverBlockMs;
-  if (blockMs == null) return requestTimeoutMs;
-  if (blockMs === 0) return void 0;
-  return Math.min(Number.MAX_SAFE_INTEGER, requestTimeoutMs + blockMs);
+  return serverResponseTimeoutMs(requestTimeoutMs, command.serverBlockMs);
 }
 
 // src/native-chunk-assembler.ts
@@ -8655,12 +8676,14 @@ var NativeAdapter = class _NativeAdapter {
 };
 
 // src/http-command-policy.ts
+var import_node_buffer33 = require("buffer");
 var nativeOnlyCommands = /* @__PURE__ */ new Set([
   "AUTH",
   "BACKPRESSURE",
   "CLIENT",
   "CLIENT.INFO",
   "CLIENT.SETNAME",
+  "COMMAND_EXEC",
   "EVENT",
   "GOAWAY",
   "HELLO",
@@ -8676,84 +8699,139 @@ var nativeOnlyCommands = /* @__PURE__ */ new Set([
   "WINDOW_UPDATE"
 ]);
 var sessionOnlyCommands = /* @__PURE__ */ new Set([
+  "ASKING",
   "AUTH",
-  "BLMOVE",
-  "BLMPOP",
-  "BLPOP",
-  "BRPOP",
   "CLIENT",
   "DISCARD",
   "EXEC",
+  "FETCH_OR_COMPUTE",
+  "FETCH_OR_COMPUTE_ERROR",
+  "FETCH_OR_COMPUTE_RESULT",
   "HELLO",
+  "MONITOR",
   "MULTI",
   "PSUBSCRIBE",
+  "PSYNC",
   "PUNSUBSCRIBE",
   "QUIT",
+  "READONLY",
+  "READWRITE",
+  "REPLCONF",
+  "RESET",
+  "SANDBOX",
   "SELECT",
+  "SSUBSCRIBE",
   "SUBSCRIBE",
+  "SUNSUBSCRIBE",
+  "SYNC",
   "UNSUBSCRIBE",
   "UNWATCH",
-  "WATCH",
-  "XREAD",
-  "XREADGROUP"
+  "WATCH"
 ]);
 function httpCommandDisposition(name) {
   const normalized = name.toUpperCase();
   return nativeOnlyCommands.has(normalized) || sessionOnlyCommands.has(normalized) ? "native_only" : "supported";
 }
 function assertHTTPCommandSupported(name) {
-  if (typeof name !== "string" || name === "") throw new TypeError("HTTP command must have a name");
-  if (sessionOnlyCommands.has(name.toUpperCase())) {
-    throw new Error(`${name.toUpperCase()} requires a persistent native TCP session`);
+  const normalized = normalizedCommandName(name);
+  if (normalized == null || normalized === "") throw new TypeError("HTTP command must have a name");
+  if (sessionOnlyCommands.has(normalized)) {
+    throw new InvalidCommandError(`${normalized} requires a persistent native TCP session`);
+  }
+  if (nativeOnlyCommands.has(normalized)) {
+    throw new InvalidCommandError(`${normalized} is a native TCP transport control command`);
+  }
+}
+function normalizedCommandName(value) {
+  if (typeof value === "string") return value.toUpperCase();
+  if (import_node_buffer33.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer33.Buffer.from(value).toString("utf8").toUpperCase();
   }
+  return void 0;
 }
 
 // src/http-envelope.ts
-var import_node_buffer33 = require("buffer");
+var import_node_buffer34 = require("buffer");
 var encoding = "ferricstore-json-v1";
 var bytesMarker = "$ferricstore_bytes";
 var mapMarker = "$ferricstore_map";
 var maxDepth = 64;
-function encodeHTTPCommands(commands) {
-  return import_node_buffer33.Buffer.from(JSON.stringify({
+var integerJSON = /^-?(?:0|[1-9][0-9]*)$/u;
+var bytesMarkerBaseBytes = import_node_buffer34.Buffer.byteLength(bytesMarker) + 7;
+var mapMarkerBaseBytes = import_node_buffer34.Buffer.byteLength(mapMarker) + 7;
+function encodeHTTPCommands(commands, maxBytes = Number.MAX_SAFE_INTEGER) {
+  const budget = { remaining: maxBytes };
+  return import_node_buffer34.Buffer.from(JSON.stringify({
     encoding,
-    commands: commands.map((command) => encodeValue(command, 0))
+    commands: commands.map((command) => encodeValue(command, 0, budget))
   }));
 }
 function decodeHTTPEnvelope(source) {
   let parsed;
   try {
-    parsed = JSON.parse(source.toString("utf8"));
+    parsed = JSON.parse(source.toString("utf8"), preserveIntegerPrecision);
   } catch (error) {
     throw new TypeError("invalid HTTP command response JSON", { cause: error });
   }
   if (!isRecord(parsed)) throw new TypeError("HTTP command response must be an object");
   return decodePlainRecord(parsed, 0);
 }
-function encodeValue(value, depth) {
+function preserveIntegerPrecision(_key, value, context) {
+  if (typeof value !== "number" || Number.isSafeInteger(value) || !Number.isInteger(value)) {
+    return value;
+  }
+  const literal = context?.source;
+  return literal != null && integerJSON.test(literal) ? BigInt(literal) : value;
+}
+function encodeValue(value, depth, budget) {
   if (depth > maxDepth) throw new TypeError("HTTP command value exceeds maximum depth");
-  if (value == null || typeof value === "string" || typeof value === "boolean") return value;
-  if (import_node_buffer33.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return { [bytesMarker]: import_node_buffer33.Buffer.from(value).toString("base64") };
+  if (value == null) {
+    consumeBudget(budget, 1);
+    return value;
+  }
+  if (typeof value === "string") {
+    consumeBudget(budget, import_node_buffer34.Buffer.byteLength(value) + 2);
+    return value;
+  }
+  if (typeof value === "boolean") {
+    consumeBudget(budget, 1);
+    return value;
+  }
+  if (import_node_buffer34.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    consumeBudget(budget, bytesMarkerBaseBytes + 4 * Math.ceil(value.byteLength / 3));
+    return { [bytesMarker]: import_node_buffer34.Buffer.from(value).toString("base64") };
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new TypeError("HTTP command numbers must be finite");
+    consumeBudget(budget, 1);
     return value;
   }
   if (typeof value === "bigint") {
-    return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
+    const encoded = value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
+    consumeBudget(budget, typeof encoded === "number" ? 1 : import_node_buffer34.Buffer.byteLength(encoded) + 2);
+    return encoded;
+  }
+  if (Array.isArray(value)) {
+    consumeBudget(budget, 2 + Math.max(0, value.length - 1));
+    return denseArray(value, depth + 1, (item, itemDepth) => encodeValue(item, itemDepth, budget));
   }
-  if (Array.isArray(value)) return denseArray(value, depth + 1, encodeValue);
   if (value instanceof Map) {
-    return { [mapMarker]: [...value.entries()].map(([key, item]) => [
-      encodeValue(key, depth + 1),
-      encodeValue(item, depth + 1)
-    ]) };
+    consumeBudget(budget, mapMarkerBaseBytes + value.size);
+    const pairs = [];
+    for (const [key, item] of value.entries()) {
+      pairs.push([
+        encodeValue(key, depth + 1, budget),
+        encodeValue(item, depth + 1, budget)
+      ]);
+    }
+    return { [mapMarker]: pairs };
   }
   if (isRecord(value)) {
-    return { [mapMarker]: Object.entries(value).map(([key, item]) => [
-      encodeValue(key, depth + 1),
-      encodeValue(item, depth + 1)
+    const keys = Object.keys(value);
+    consumeBudget(budget, mapMarkerBaseBytes + keys.length);
+    return { [mapMarker]: keys.map((key) => [
+      encodeValue(key, depth + 1, budget),
+      encodeValue(value[key], depth + 1, budget)
     ]) };
   }
   throw new TypeError(`unsupported HTTP command value: ${typeof value}`);
@@ -8779,15 +8857,28 @@ function decodeBase64(value) {
   if (value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
     throw new TypeError("invalid HTTP bytes marker");
   }
-  const decoded = import_node_buffer33.Buffer.from(value, "base64");
+  const decoded = import_node_buffer34.Buffer.from(value, "base64");
   if (decoded.toString("base64") !== value) throw new TypeError("invalid HTTP bytes marker");
   return decoded;
 }
 function decodePlainRecord(value, depth) {
   const result = {};
-  for (const [key, item] of Object.entries(value)) result[key] = decodeValue2(item, depth);
+  for (const [key, item] of Object.entries(value)) {
+    Object.defineProperty(result, key, {
+      configurable: true,
+      enumerable: true,
+      value: decodeValue2(item, depth),
+      writable: true
+    });
+  }
   return result;
 }
+function consumeBudget(budget, amount) {
+  if (amount > budget.remaining) {
+    throw new HTTPTransportError("HTTP command request exceeds maxRequestBytes");
+  }
+  budget.remaining -= amount;
+}
 function denseArray(values, depth, transform) {
   const result = new Array(values.length);
   for (let index = 0; index < values.length; index += 1) {
@@ -8797,10 +8888,12 @@ function denseArray(values, depth, transform) {
   return result;
 }
 function isRecord(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer33.Buffer.isBuffer(value);
+  return typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer34.Buffer.isBuffer(value);
 }
 
 // src/http-options.ts
+var import_node_buffer35 = require("buffer");
+var import_node_http = require("http");
 function normalizeHTTPOptions(value, options) {
   const url = new URL(value);
   if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -8826,10 +8919,10 @@ function normalizeHTTPOptions(value, options) {
   });
 }
 function normalizedHeaders(source) {
-  const headers = {};
+  const headers = /* @__PURE__ */ Object.create(null);
   for (const [rawName, value] of Object.entries(source)) {
     const name = rawName.toLowerCase();
-    if (name === "" || !safeHeader(name) || !safeHeader(value)) {
+    if (typeof value !== "string" || !validHeader(name, value)) {
       throw new TypeError(`invalid HTTP header: ${rawName}`);
     }
     headers[name] = value;
@@ -8841,7 +8934,9 @@ function authorizationHeader(url, options, custom) {
   const count = Number(custom != null) + Number(options.bearerToken != null) + Number(basic);
   if (count > 1) throw new TypeError("HTTP credentials are mutually exclusive");
   if (options.bearerToken != null) {
-    if (!safeHeader(options.bearerToken)) throw new TypeError("invalid bearer token");
+    if (options.bearerToken === "" || !validHeader("authorization", `Bearer ${options.bearerToken}`)) {
+      throw new TypeError("invalid bearer token");
+    }
     return `Bearer ${options.bearerToken}`;
   }
   if (!basic) return custom;
@@ -8851,7 +8946,7 @@ function authorizationHeader(url, options, custom) {
   if (username === "" || username.includes(":") || !safeHeader(username) || !safeHeader(options.password)) {
     throw new TypeError("invalid Basic authentication credentials");
   }
-  return `Basic ${Buffer.from(`${username}:${options.password}`).toString("base64")}`;
+  return `Basic ${import_node_buffer35.Buffer.from(`${username}:${options.password}`).toString("base64")}`;
 }
 function positiveInteger(value, fallback, name) {
   const result = value ?? fallback;
@@ -8871,36 +8966,167 @@ function booleanOption(value, fallback, name) {
 function safeHeader(value) {
   return !value.includes("\r") && !value.includes("\n");
 }
+function validHeader(name, value) {
+  try {
+    (0, import_node_http.validateHeaderName)(name);
+    (0, import_node_http.validateHeaderValue)(name, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/http-transport.ts
-var import_node_http = __toESM(require("http"), 1);
-var import_node_http2 = __toESM(require("http2"), 1);
+var import_node_http2 = __toESM(require("http"), 1);
+var import_node_http22 = __toESM(require("http2"), 1);
 var import_node_https = __toESM(require("https"), 1);
-var import_node_buffer34 = require("buffer");
+var import_node_buffer36 = require("buffer");
+
+// src/http2-slot-pool.ts
+var HTTP2SessionRetiredError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "HTTP2SessionRetiredError";
+  }
+};
+var HTTP2SlotPool = class {
+  active = 0;
+  idleCallback;
+  limit;
+  retiredError;
+  waiterHead;
+  waiterTail;
+  acquire(signal) {
+    if (signal.aborted) return Promise.reject(signalAbortError(signal));
+    if (this.retiredError != null) return Promise.reject(this.retiredError);
+    if (this.limit != null && this.active < this.limit) {
+      this.active += 1;
+      return Promise.resolve(this.releaseOnce());
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        abort: () => {
+          if (waiter.settled) return;
+          waiter.settled = true;
+          this.removeWaiter(waiter);
+          reject(signalAbortError(signal));
+        },
+        queued: true,
+        reject,
+        resolve,
+        settled: false,
+        signal
+      };
+      this.enqueueWaiter(waiter);
+      signal.addEventListener("abort", waiter.abort, { once: true });
+    });
+  }
+  updateLimit(limit) {
+    if (this.retiredError != null) return;
+    this.limit = limit;
+    this.drain();
+  }
+  retire(error) {
+    if (this.retiredError != null) return;
+    this.retiredError = error;
+    while (this.waiterHead != null) {
+      const waiter = this.waiterHead;
+      this.removeWaiter(waiter);
+      if (waiter.settled) continue;
+      waiter.settled = true;
+      waiter.signal.removeEventListener("abort", waiter.abort);
+      waiter.reject(error);
+    }
+  }
+  whenIdle(callback) {
+    if (this.active === 0) callback();
+    else this.idleCallback = callback;
+  }
+  drain() {
+    while (this.retiredError == null && this.limit != null && this.active < this.limit) {
+      const waiter = this.waiterHead;
+      if (waiter == null) return;
+      this.removeWaiter(waiter);
+      if (waiter.settled) continue;
+      waiter.settled = true;
+      waiter.signal.removeEventListener("abort", waiter.abort);
+      this.active += 1;
+      waiter.resolve(this.releaseOnce());
+    }
+  }
+  enqueueWaiter(waiter) {
+    waiter.previous = this.waiterTail;
+    if (this.waiterTail == null) this.waiterHead = waiter;
+    else this.waiterTail.next = waiter;
+    this.waiterTail = waiter;
+  }
+  removeWaiter(waiter) {
+    if (!waiter.queued) return;
+    if (waiter.previous == null) this.waiterHead = waiter.next;
+    else waiter.previous.next = waiter.next;
+    if (waiter.next == null) this.waiterTail = waiter.previous;
+    else waiter.next.previous = waiter.previous;
+    waiter.next = void 0;
+    waiter.previous = void 0;
+    waiter.queued = false;
+  }
+  releaseOnce() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.active -= 1;
+      this.drain();
+      if (this.active === 0) {
+        const callback = this.idleCallback;
+        this.idleCallback = void 0;
+        callback?.();
+      }
+    };
+  }
+};
+function signalAbortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new HTTPTransportError("HTTP request was aborted", { raw: signal.reason });
+}
+
+// src/http-transport.ts
 var HTTPTransport = class {
   constructor(config) {
     this.config = config;
-    this.#httpAgent = new import_node_http.default.Agent({ keepAlive: true, maxSockets: config.maxConnections });
+    this.#httpAgent = new import_node_http2.default.Agent({
+      keepAlive: true,
+      maxFreeSockets: config.maxConnections,
+      maxSockets: config.maxConnections,
+      maxTotalSockets: config.maxConnections
+    });
     this.#httpsAgent = new import_node_https.default.Agent({
       ...config.tlsOptions,
       keepAlive: true,
-      maxSockets: config.maxConnections
+      maxFreeSockets: config.maxConnections,
+      maxSockets: config.maxConnections,
+      maxTotalSockets: config.maxConnections
     });
   }
   config;
   #httpAgent;
   #httpsAgent;
+  #allSessions = /* @__PURE__ */ new Set();
   #sessions = /* @__PURE__ */ new Map();
+  #sessionSlots = /* @__PURE__ */ new WeakMap();
+  #requests = /* @__PURE__ */ new Set();
   #closed = false;
-  async post(body) {
+  async post(body, timeoutMs) {
     if (this.#closed) throw new HTTPTransportError("HTTP transport is closed");
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    this.#requests.add(controller);
+    const timer = timeoutMs == null ? void 0 : setLongTimeout(() => controller.abort(requestTimeoutReason), timeoutMs);
+    timer?.unref();
     try {
       return await this.request(this.config.commandUrl, "POST", body, 0, controller.signal);
     } catch (error) {
       if (controller.signal.aborted) {
-        throw new RequestTimeoutError(this.config.timeoutMs, "possibly_sent", {
+        if (controller.signal.reason instanceof HTTPTransportError) throw controller.signal.reason;
+        throw new RequestTimeoutError(timeoutMs ?? this.config.timeoutMs, "possibly_sent", {
           cause: error,
           raw: { retryable: true, safe_to_retry: false }
         });
@@ -8912,15 +9138,19 @@ var HTTPTransport = class {
         safeToRetry: false
       });
     } finally {
-      clearTimeout(timer);
+      timer?.cancel();
+      this.#requests.delete(controller);
     }
   }
   async close() {
     if (this.#closed) return;
     this.#closed = true;
+    const error = new HTTPTransportError("HTTP transport is closed");
+    for (const controller of this.#requests) controller.abort(error);
     this.#httpAgent.destroy();
     this.#httpsAgent.destroy();
-    for (const session of this.#sessions.values()) session.destroy();
+    for (const session of this.#allSessions) session.destroy();
+    this.#allSessions.clear();
     this.#sessions.clear();
   }
   async request(url, method, body, redirects, signal) {
@@ -8943,7 +9173,7 @@ var HTTPTransport = class {
     );
   }
   async http1Request(url, method, body, signal) {
-    const request = url.protocol === "https:" ? import_node_https.default.request : import_node_http.default.request;
+    const request = url.protocol === "https:" ? import_node_https.default.request : import_node_http2.default.request;
     const agent = url.protocol === "https:" ? this.#httpsAgent : this.#httpAgent;
     const headers = this.requestHeaders(body);
     return await new Promise((resolve, reject) => {
@@ -8968,7 +9198,6 @@ var HTTPTransport = class {
     );
   }
   async http2Request(url, method, body, signal) {
-    const session = this.session(url);
     const headers = {
       ...this.requestHeaders(body),
       ":authority": url.host,
@@ -8976,10 +9205,43 @@ var HTTPTransport = class {
       ":path": `${url.pathname}${url.search}`,
       ":scheme": url.protocol.slice(0, -1)
     };
+    if (signal.aborted) throw signalAbortError(signal);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const session = this.session(url);
+      let release;
+      try {
+        release = await this.slotPool(session).acquire(signal);
+      } catch (error) {
+        if (attempt === 0 && error instanceof HTTP2SessionRetiredError && !signal.aborted) continue;
+        throw error;
+      }
+      try {
+        let stream;
+        try {
+          stream = session.request(headers);
+        } catch (error) {
+          if (attempt === 0 && retryableSessionOpenError(error) && !signal.aborted) {
+            this.retireSession(url.origin, session, true, error);
+            continue;
+          }
+          throw error;
+        }
+        try {
+          return await this.collectHttp2(stream, body, signal);
+        } catch (error) {
+          if (attempt === 0 && refusedStreamError(error) && !signal.aborted) continue;
+          throw error;
+        }
+      } finally {
+        release();
+      }
+    }
+    throw new HTTPTransportError("HTTP/2 session could not accept the request");
+  }
+  async collectHttp2(stream, body, signal) {
     return await new Promise((resolve, reject) => {
-      const stream = session.request(headers);
       let responseHeaders = {};
-      const abort = () => stream.close(import_node_http2.default.constants.NGHTTP2_CANCEL);
+      const abort = () => stream.close(import_node_http22.default.constants.NGHTTP2_CANCEL);
       signal.addEventListener("abort", abort, { once: true });
       stream.once("response", (value) => responseHeaders = value);
       stream.once("error", reject);
@@ -8987,19 +9249,60 @@ var HTTPTransport = class {
         const status = Number(responseHeaders[":status"] ?? 0);
         resolve({ body: response.body, headers: normalizeHeaders(responseHeaders), status });
       }, reject).finally(() => signal.removeEventListener("abort", abort));
-      stream.end(body);
+      if (signal.aborted) abort();
+      else stream.end(body);
     });
   }
   session(url) {
     const origin = url.origin;
     const current = this.#sessions.get(origin);
     if (current != null && !current.closed && !current.destroyed) return current;
-    const session = import_node_http2.default.connect(origin, this.config.tlsOptions);
-    session.on("error", () => void 0);
-    session.once("close", () => this.#sessions.delete(origin));
+    const session = import_node_http22.default.connect(origin, {
+      ...this.config.tlsOptions,
+      settings: { enablePush: false }
+    });
+    const slots = new HTTP2SlotPool();
+    this.#allSessions.add(session);
+    this.#sessionSlots.set(session, slots);
+    session.on("remoteSettings", (settings) => {
+      const remoteLimit = settings.maxConcurrentStreams;
+      const limit = typeof remoteLimit === "number" && Number.isFinite(remoteLimit) ? Math.max(0, Math.floor(remoteLimit)) : this.config.maxConnections;
+      slots.updateLimit(Math.min(this.config.maxConnections, limit));
+    });
+    session.on("error", (error) => this.retireSession(origin, session, true, error));
+    session.once("goaway", () => {
+      this.retireSession(
+        origin,
+        session,
+        "when_idle",
+        new HTTP2SessionRetiredError("HTTP/2 session received GOAWAY")
+      );
+    });
+    session.once("close", () => {
+      if (session.destroyed) this.#allSessions.delete(session);
+      this.retireSession(origin, session);
+    });
     this.#sessions.set(origin, session);
     return session;
   }
+  retireSession(origin, session, destroy = false, cause) {
+    if (this.#sessions.get(origin) === session) this.#sessions.delete(origin);
+    const slots = this.#sessionSlots.get(session);
+    slots?.retire(
+      cause instanceof HTTP2SessionRetiredError ? cause : new HTTP2SessionRetiredError("HTTP/2 session is unavailable", cause)
+    );
+    if (destroy === true && !session.destroyed) session.destroy();
+    else if (destroy === "when_idle") {
+      slots?.whenIdle(() => {
+        if (!session.destroyed) session.destroy();
+      });
+    }
+  }
+  slotPool(session) {
+    const slots = this.#sessionSlots.get(session);
+    if (slots == null) throw new HTTP2SessionRetiredError("HTTP/2 session is unavailable");
+    return slots;
+  }
   requestHeaders(body) {
     const headers = { ...this.config.headers };
     delete headers["content-length"];
@@ -9011,11 +9314,21 @@ var HTTPTransport = class {
     };
   }
 };
+var requestTimeoutReason = /* @__PURE__ */ Symbol("ferricstore-http-request-timeout");
+function retryableSessionOpenError(error) {
+  if (typeof error !== "object" || error == null || !("code" in error)) return false;
+  const code = error.code;
+  return code === "ERR_HTTP2_GOAWAY_SESSION" || code === "ERR_HTTP2_INVALID_SESSION";
+}
+function refusedStreamError(error) {
+  if (!(error instanceof Error)) return false;
+  return error.code === "ERR_HTTP2_STREAM_ERROR" && error.message.includes("NGHTTP2_REFUSED_STREAM");
+}
 async function collectBody(source, status, headers, maximum) {
   const chunks = [];
   let size = 0;
   for await (const chunk of source) {
-    const bytes2 = import_node_buffer34.Buffer.from(chunk);
+    const bytes2 = import_node_buffer36.Buffer.from(chunk);
     size += bytes2.byteLength;
     if (size > maximum) {
       const destroy = source.destroy;
@@ -9024,10 +9337,10 @@ async function collectBody(source, status, headers, maximum) {
     }
     chunks.push(bytes2);
   }
-  return { body: import_node_buffer34.Buffer.concat(chunks, size), headers, status };
+  return { body: import_node_buffer36.Buffer.concat(chunks, size), headers, status };
 }
 function normalizeHeaders(headers) {
-  const result = {};
+  const result = /* @__PURE__ */ Object.create(null);
   for (const [name, raw] of Object.entries(headers)) {
     const value = headerValue(raw);
     if (value != null) result[name.toLowerCase()] = value;
@@ -9079,11 +9392,16 @@ var HTTPAdapter = class _HTTPAdapter {
       throw new HTTPTransportError("HTTP command batch exceeds maxBatchItems");
     }
     for (const command of commands) assertHTTPCommandSupported(command[0]);
-    const body = encodeHTTPCommands(commands.map((command) => httpCommand(command, this.#config.maxRequestBytes)));
+    const prepared = commands.map((command) => prepareHTTPCommand(command, this.#config.maxRequestBytes));
+    const body = encodeHTTPCommands(prepared.map((command) => command.encoded), this.#config.maxRequestBytes);
     if (body.byteLength > this.#config.maxRequestBytes) {
       throw new HTTPTransportError("HTTP command request exceeds maxRequestBytes");
     }
-    const response = await this.#transport.post(body);
+    const serverBlockMs = combinedServerBlockMs(prepared.map((command) => command.serverBlockMs));
+    const response = await this.#transport.post(
+      body,
+      serverResponseTimeoutMs(this.#config.timeoutMs, serverBlockMs)
+    );
     let envelope = {};
     try {
       if (response.body.byteLength > 0) envelope = decodeHTTPEnvelope(response.body);
@@ -9107,12 +9425,17 @@ var HTTPAdapter = class _HTTPAdapter {
 var commandNamesByOpcode = new Map(
   Object.entries(COMMAND_OPCODES).map(([name, opcode]) => [opcode, name])
 );
-function httpCommand(command, maxRequestBytes) {
+function prepareHTTPCommand(command, maxRequestBytes) {
   const protocol = buildProtocolCommand(command, maxRequestBytes, false);
-  if (protocol.opcode === OPCODES.commandExec) return command;
+  if (protocol.opcode === OPCODES.commandExec) {
+    return { encoded: command, serverBlockMs: protocol.serverBlockMs };
+  }
   const name = commandNamesByOpcode.get(protocol.opcode);
   if (name == null) throw new HTTPTransportError(`HTTP command has unknown opcode ${protocol.opcode}`);
-  return { command: name, opcode: protocol.opcode, payload: protocol.payload ?? {} };
+  return {
+    encoded: { command: name, opcode: protocol.opcode, payload: protocol.payload ?? {} },
+    serverBlockMs: protocol.serverBlockMs
+  };
 }
 function validatedResult(value) {
   if (!isRecord2(value)) throw new HTTPTransportError("HTTP response has an invalid result item");
@@ -9132,7 +9455,7 @@ function commandError(value) {
 function topLevelError(status, envelope, retryAfter) {
   const details = isRecord2(envelope.error) ? envelope.error : {};
   const message = typeof details.message === "string" ? details.message : `HTTP command request failed with status ${status}`;
-  const retryAfterMs2 = retryAfter == null || !/^\d+$/u.test(retryAfter) ? void 0 : Number(retryAfter) * 1e3;
+  const retryAfterMs2 = retryAfterMilliseconds(retryAfter);
   return new HTTPTransportError(message, {
     raw: details,
     retryable: status === 408 || status === 425 || status === 429 || status >= 500,
@@ -9141,6 +9464,18 @@ function topLevelError(status, envelope, retryAfter) {
     statusCode: status
   });
 }
+function retryAfterMilliseconds(value) {
+  if (value == null) return void 0;
+  if (/^\d+$/u.test(value)) {
+    const seconds = Number.parseInt(value, 10);
+    const milliseconds2 = seconds * 1e3;
+    return Number.isSafeInteger(milliseconds2) ? milliseconds2 : void 0;
+  }
+  const deadline = Date.parse(value);
+  if (!Number.isFinite(deadline)) return void 0;
+  const milliseconds = Math.max(0, deadline - Date.now());
+  return Number.isSafeInteger(milliseconds) ? milliseconds : void 0;
+}
 function isRecord2(value) {
   return typeof value === "object" && value != null && !Array.isArray(value);
 }
@@ -9153,10 +9488,10 @@ function executeCommandArgs(executor, args) {
 }
 
 // src/reconnecting-executor.ts
-var import_node_buffer36 = require("buffer");
+var import_node_buffer38 = require("buffer");
 
 // src/command-retry-policy.ts
-var import_node_buffer35 = require("buffer");
+var import_node_buffer37 = require("buffer");
 function isCasMutation(args) {
   const offset = commandName2(args[0]) === "COMMAND_EXEC" ? 1 : 0;
   const name = commandName2(args[offset]);
@@ -9170,8 +9505,8 @@ function isCasMutation(args) {
 }
 function commandName2(value) {
   if (typeof value === "string") return value.toUpperCase();
-  if (import_node_buffer35.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return import_node_buffer35.Buffer.from(value).toString("utf8").toUpperCase();
+  if (import_node_buffer37.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer37.Buffer.from(value).toString("utf8").toUpperCase();
   }
   return void 0;
 }
@@ -9383,15 +9718,15 @@ function normalizeNonNegativeInteger2(value, fallback) {
 }
 
 // src/topology.ts
-var import_node_buffer39 = require("buffer");
+var import_node_buffer41 = require("buffer");
 
 // src/topology-routing.ts
-var import_node_buffer38 = require("buffer");
+var import_node_buffer40 = require("buffer");
 
 // src/flow-partition-route-cache.ts
-var import_node_buffer37 = require("buffer");
+var import_node_buffer39 = require("buffer");
 var import_node_crypto = require("crypto");
-var AUTO_PREFIX = import_node_buffer37.Buffer.from("__flow_auto__:", "ascii");
+var AUTO_PREFIX = import_node_buffer39.Buffer.from("__flow_auto__:", "ascii");
 var MAX_CACHEABLE_PARTITION_BYTES = 4 * 1024;
 var MAX_CACHE_BYTES = 1 * 1024 * 1024;
 var MAX_CACHE_ENTRIES = 1024;
@@ -9401,10 +9736,10 @@ var cacheBytes = 0;
 var cacheHits = 0;
 var cacheMisses = 0;
 function flowLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer37.Buffer.isBuffer(value)) return void 0;
+  if (typeof value !== "string" && !import_node_buffer39.Buffer.isBuffer(value)) return void 0;
   const autoBucket = flowAutoBucket(value);
   if (autoBucket != null) return `{fa:${autoBucket}}`;
-  const bytes2 = import_node_buffer37.Buffer.isBuffer(value) ? value : import_node_buffer37.Buffer.from(value);
+  const bytes2 = import_node_buffer39.Buffer.isBuffer(value) ? value : import_node_buffer39.Buffer.from(value);
   if (bytes2.byteLength > MAX_CACHEABLE_PARTITION_BYTES) return hashRoute(bytes2);
   const cacheKey = bytes2.toString("base64");
   const cached = routeCache.get(cacheKey);
@@ -9478,7 +9813,7 @@ function routingKeyFromProtocolPayload(name, command) {
       "scope"
     ]) {
       const value = getField(command.payload, field3);
-      if (typeof value === "string" || import_node_buffer38.Buffer.isBuffer(value)) {
+      if (typeof value === "string" || import_node_buffer40.Buffer.isBuffer(value)) {
         return value;
       }
     }
@@ -9526,7 +9861,7 @@ function flowRoutingData(name, args) {
     if (typeof partition === "string" && partition.toUpperCase() !== "AUTO" && partition.toUpperCase() !== "MIXED") {
       return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
     }
-    if (import_node_buffer38.Buffer.isBuffer(partition)) {
+    if (import_node_buffer40.Buffer.isBuffer(partition)) {
       const text3 = partition.toString("utf8").toUpperCase();
       if (text3 !== "AUTO" && text3 !== "MIXED") {
         return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
@@ -9617,17 +9952,17 @@ function flowPartitionRoutingKeyFromCommand(command, claim) {
   return { handled: false };
 }
 function isRoutingKey(value) {
-  return typeof value === "string" || import_node_buffer38.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer40.Buffer.isBuffer(value);
 }
 function flowAutoIdRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer38.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer40.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bucket = (import_node_buffer38.Buffer.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
+  const bucket = (import_node_buffer40.Buffer.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
   return `{fa:${bucket}}`;
 }
 function flowClaimLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer38.Buffer.isBuffer(value)) return void 0;
+  if (typeof value !== "string" && !import_node_buffer40.Buffer.isBuffer(value)) return void 0;
   const selector = commandPart(value);
   if (selector === "AUTO" || selector === "ANY") return void 0;
   if (selector === "GLOBAL") return "{f}";
@@ -9642,7 +9977,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_buffer38.Buffer.isBuffer(key))) {
+  if (keys.length === 0 || keys.some((key) => typeof key !== "string" && !import_node_buffer40.Buffer.isBuffer(key))) {
     return void 0;
   }
   const usable = keys;
@@ -9675,7 +10010,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_buffer38.Buffer.isBuffer(key)) return void 0;
+    if (typeof key !== "string" && !import_node_buffer40.Buffer.isBuffer(key)) return void 0;
     const route = routeKey(key);
     const groupKey = `${route.endpointKey}\0${route.laneId}`;
     const group = groups.get(groupKey);
@@ -10764,7 +11099,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
 };
 
 // src/response-map-preservation.ts
-var import_node_buffer40 = require("buffer");
+var import_node_buffer42 = require("buffer");
 function toStringKeyMapPreservingValues(value) {
   if (value == null) return void 0;
   const result = {};
@@ -10774,7 +11109,7 @@ function toStringKeyMapPreservingValues(value) {
     }
     return result;
   }
-  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer40.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer42.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     for (const [key, item] of Object.entries(value)) {
       setOwnValue(result, text(key), normalizeMapStructurePreservingBytes(item));
     }
@@ -10783,7 +11118,7 @@ function toStringKeyMapPreservingValues(value) {
   return void 0;
 }
 function normalizeMapStructurePreservingBytes(value) {
-  if (import_node_buffer40.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
+  if (import_node_buffer42.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
   if (value instanceof Map) {
     const result = {};
     for (const [key, item] of value.entries()) {
@@ -10805,7 +11140,7 @@ function normalizeMapStructurePreservingBytes(value) {
 }
 
 // src/native-kv-responses.ts
-var import_node_buffer41 = require("buffer");
+var import_node_buffer43 = require("buffer");
 function rateLimitResultFromResp(value) {
   if (!Array.isArray(value) || value.length !== 4) {
     throw new TypeError("RATELIMIT.ADD returned an unexpected response");
@@ -10862,13 +11197,13 @@ function fetchOrComputeResultFromResp(value, codec) {
 }
 function decodePayload(codec, value) {
   if (value == null) return null;
-  if (import_node_buffer41.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer41.Buffer.from(value));
-  if (typeof value === "string") return codec.decode(import_node_buffer41.Buffer.from(value));
+  if (import_node_buffer43.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer43.Buffer.from(value));
+  if (typeof value === "string") return codec.decode(import_node_buffer43.Buffer.from(value));
   return normalizeRefMeta(value);
 }
 function requiredResponseString(value, context) {
-  if (typeof value !== "string" && !import_node_buffer41.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !import_node_buffer43.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   const result = text(value);
@@ -10885,7 +11220,7 @@ function requiredNonNegativeInteger(value, context) {
   return result;
 }
 function responseBytes(value, context) {
-  if (typeof value !== "string" && !import_node_buffer41.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+  if (typeof value !== "string" && !import_node_buffer43.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   return bytes(value);
@@ -11568,7 +11903,7 @@ function groupAutoPartitionItems(items) {
 }
 
 // src/client-values.ts
-var import_node_buffer42 = require("buffer");
+var import_node_buffer44 = require("buffer");
 async function valueMGetEntries(client, refs, options = {}) {
   const refCount = refs.length;
   if (refCount === 0) {
@@ -11603,12 +11938,12 @@ async function valueMGetEntries(client, refs, options = {}) {
     const item = response[index];
     if (item == null) {
       entries[index] = { found: false };
-    } else if (import_node_buffer42.Buffer.isBuffer(item)) {
+    } else if (import_node_buffer44.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_buffer42.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer44.Buffer.from(item)) };
     } else if (typeof item === "string") {
-      entries[index] = { found: true, value: client.codec.decode(import_node_buffer42.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer44.Buffer.from(item)) };
     } else {
       entries[index] = { found: true, value: item };
     }
@@ -11617,10 +11952,10 @@ async function valueMGetEntries(client, refs, options = {}) {
 }
 
 // src/auto-batch.ts
-var import_node_buffer44 = require("buffer");
+var import_node_buffer46 = require("buffer");
 
 // src/auto-batch-ordering.ts
-var import_node_buffer43 = require("buffer");
+var import_node_buffer45 = require("buffer");
 function autoBatchOrderingPlan(batch) {
   const accesses = /* @__PURE__ */ new Map();
   const fallbackDependencies = [];
@@ -11735,13 +12070,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_buffer43.Buffer.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
+      (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && isFencingToken(command[itemIndex + (mixed ? 2 : 1)]) && import_node_buffer45.Buffer.isBuffer(command[itemIndex + (mixed ? 3 : 2)])
     );
   }
   return fixedFlowItemIds(
     command,
     mixed ? 4 : 3,
-    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer43.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
+    (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer45.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
   );
 }
 function createManyAutoBatchIds(command) {
@@ -11754,7 +12089,7 @@ function createManyAutoBatchIds(command) {
       const ids = fixedFlowItemIds(
         command,
         width,
-        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer43.Buffer.isBuffer(command[itemIndex + width - 1]),
+        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer45.Buffer.isBuffer(command[itemIndex + width - 1]),
         markerIndex
       );
       if (ids != null) return ids;
@@ -11772,7 +12107,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_buffer43.Buffer.isBuffer(command[cursor + 2])) return void 0;
+    if (!isAutoBatchResourceValue(id) || !isAutoBatchResourceValue(command[cursor + 1]) || !import_node_buffer45.Buffer.isBuffer(command[cursor + 2])) return void 0;
     ids.push(id);
     cursor += 3;
     const afterValues = skipExtendedNamedItems(command, cursor, true);
@@ -11791,7 +12126,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_buffer43.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
+    if (!isAutoBatchResourceValue(name) || (encodedValues ? !import_node_buffer45.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
   }
   return firstItem + count * 2;
 }
@@ -11806,7 +12141,7 @@ function runStepsManyAutoBatchIds(command) {
         ids.push(item);
         continue;
       }
-      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer43.Buffer.isBuffer(item)) return void 0;
+      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer45.Buffer.isBuffer(item)) return void 0;
       const id = item.id;
       if (!isAutoBatchResourceValue(id)) return void 0;
       ids.push(id);
@@ -11847,7 +12182,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_buffer43.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer45.Buffer.isBuffer(value);
 }
 function isFencingToken(value) {
   return typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint";
@@ -11856,7 +12191,7 @@ function nonNegativeItemCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
 function autoBatchResourceKey(namespace, value) {
-  return `${namespace}:${import_node_buffer43.Buffer.from(value).toString("base64")}`;
+  return `${namespace}:${import_node_buffer45.Buffer.from(value).toString("base64")}`;
 }
 function autoBatchCommandName(command) {
   return commandView(command).name ?? null;
@@ -12265,13 +12600,13 @@ function claimFailure(error) {
 }
 
 // src/client-flow-support.ts
-var import_node_buffer57 = require("buffer");
+var import_node_buffer59 = require("buffer");
 
 // src/flow-query-builder.ts
-var import_node_buffer46 = require("buffer");
+var import_node_buffer48 = require("buffer");
 
 // src/flow-query-metadata.ts
-var import_node_buffer45 = require("buffer");
+var import_node_buffer47 = require("buffer");
 var MAX_FLOW_QUERY_METADATA_KEY_BYTES = 64;
 function normalizeStateMeta(value, state) {
   if (value == null) return {};
@@ -12296,7 +12631,7 @@ function normalizeStateMeta(value, state) {
 function metadataEntries(value, context) {
   const entries = objectEntries(value ?? {}, context).map(([rawName, item]) => {
     const name = rawName.trim();
-    const size = import_node_buffer45.Buffer.byteLength(name, "utf8");
+    const size = import_node_buffer47.Buffer.byteLength(name, "utf8");
     if (size === 0 || size > MAX_FLOW_QUERY_METADATA_KEY_BYTES || name.startsWith("__")) {
       throw new TypeError(`${context} key is invalid or reserved`);
     }
@@ -12320,7 +12655,7 @@ function objectEntries(value, context) {
   return keys.map((key) => [key, value[key]]);
 }
 function isPlainRecord(value) {
-  if (typeof value !== "object" || value == null || Array.isArray(value) || import_node_buffer45.Buffer.isBuffer(value)) {
+  if (typeof value !== "object" || value == null || Array.isArray(value) || import_node_buffer47.Buffer.isBuffer(value)) {
     return false;
   }
   const prototype = Object.getPrototypeOf(value);
@@ -12390,7 +12725,7 @@ var FlowCollectionQuery = class {
     const states = /* @__PURE__ */ new Set();
     for (const [rawState, metadata] of objectEntries(values, "stateMeta")) {
       const state = requiredText(rawState, "stateMeta state").trim();
-      const stateBytes = import_node_buffer46.Buffer.byteLength(state, "utf8");
+      const stateBytes = import_node_buffer48.Buffer.byteLength(state, "utf8");
       if (stateBytes === 0 || stateBytes > MAX_FLOW_QUERY_STATE_BYTES) {
         throw new TypeError(
           `stateMeta state names must be 1..${MAX_FLOW_QUERY_STATE_BYTES} bytes`
@@ -12569,7 +12904,7 @@ function requiredPartition(value) {
       "FLOW.QUERY convenience methods require a partition key"
     );
   }
-  const size = import_node_buffer46.Buffer.byteLength(value, "utf8");
+  const size = import_node_buffer48.Buffer.byteLength(value, "utf8");
   if (size === 0 || size > MAX_FLOW_QUERY_PARTITION_BYTES) {
     throw new TypeError(
       `FLOW.QUERY partition key must be 1..${MAX_FLOW_QUERY_PARTITION_BYTES} bytes`
@@ -12617,23 +12952,23 @@ function requiredText(value, context) {
   return value;
 }
 function queryParameter(value, context) {
-  if (typeof value === "string" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "number" || import_node_buffer46.Buffer.isBuffer(value)) {
+  if (typeof value === "string" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "number" || import_node_buffer48.Buffer.isBuffer(value)) {
     return value;
   }
   throw new TypeError(`${context} must be a scalar FLOW.QUERY parameter`);
 }
 
 // src/flow-query-response.ts
-var import_node_buffer50 = require("buffer");
+var import_node_buffer52 = require("buffer");
 
 // src/flow-query-diagnostic-response.ts
-var import_node_buffer48 = require("buffer");
+var import_node_buffer50 = require("buffer");
 
 // src/flow-query-response-validation.ts
-var import_node_buffer47 = require("buffer");
+var import_node_buffer49 = require("buffer");
 function requiredMap2(value, context) {
   if (value instanceof Map) return value;
-  if (typeof value !== "object" || value == null || Array.isArray(value) || import_node_buffer47.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (typeof value !== "object" || value == null || Array.isArray(value) || import_node_buffer49.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     throw decodeError(`${context} must be a map`, value);
   }
   return value;
@@ -12690,7 +13025,7 @@ function normalizeMetadataValue(value, context, budget, ancestors, depth) {
     if (!value.isWellFormed()) throw decodeError(`${context} contains invalid text`, value);
     return value;
   }
-  if (import_node_buffer47.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (import_node_buffer49.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     const decoded = strictText2(value);
     if (decoded == null) throw decodeError(`${context} contains invalid UTF-8`, value);
     return decoded;
@@ -12769,7 +13104,7 @@ function optionalText2(mapping2, name, context) {
 }
 function requiredBoundedText2(mapping2, name, context, maximumBytes) {
   const value = requiredText2(mapping2, name, context);
-  if (import_node_buffer47.Buffer.byteLength(value, "utf8") > maximumBytes) {
+  if (import_node_buffer49.Buffer.byteLength(value, "utf8") > maximumBytes) {
     throw decodeError(
       `${context} ${name} exceeds ${maximumBytes} bytes`,
       mapping2
@@ -12782,7 +13117,7 @@ function boundedText(value, context, maximumBytes) {
   if (decoded == null || decoded.length === 0) {
     throw decodeError(`${context} must be non-empty text`, value);
   }
-  if (import_node_buffer47.Buffer.byteLength(decoded, "utf8") > maximumBytes) {
+  if (import_node_buffer49.Buffer.byteLength(decoded, "utf8") > maximumBytes) {
     throw decodeError(`${context} exceeds ${maximumBytes} bytes`, value);
   }
   return decoded;
@@ -12836,10 +13171,10 @@ function positiveBoundedInteger(value, maximum, context) {
 function hasKey(mapping2, name) {
   if (!(mapping2 instanceof Map)) return Object.hasOwn(mapping2, name);
   if (mapping2.has(name)) return true;
-  const binaryName = import_node_buffer47.Buffer.from(name);
+  const binaryName = import_node_buffer49.Buffer.from(name);
   for (const key of mapping2.keys()) {
-    if (import_node_buffer47.Buffer.isBuffer(key) && key.equals(binaryName)) return true;
-    if (key instanceof Uint8Array && import_node_buffer47.Buffer.from(key).equals(binaryName))
+    if (import_node_buffer49.Buffer.isBuffer(key) && key.equals(binaryName)) return true;
+    if (key instanceof Uint8Array && import_node_buffer49.Buffer.from(key).equals(binaryName))
       return true;
   }
   return false;
@@ -12850,7 +13185,7 @@ function decodeError(message, raw) {
 function strictText2(value) {
   if (typeof value === "string")
     return value.isWellFormed() ? value : void 0;
-  if (import_node_buffer47.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+  if (import_node_buffer49.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     try {
       return new TextDecoder("utf-8", { fatal: true }).decode(value);
     } catch {
@@ -12930,7 +13265,7 @@ function tryDecodeFlowQueryError(value, cause) {
 }
 function optionalDiagnosticText(mapping2, name) {
   const value = optionalText2(mapping2, name, "FLOW.QUERY diagnostic");
-  if (value != null && import_node_buffer48.Buffer.byteLength(value, "utf8") > DIAGNOSTIC_TEXT_BYTES) {
+  if (value != null && import_node_buffer50.Buffer.byteLength(value, "utf8") > DIAGNOSTIC_TEXT_BYTES) {
     throw decodeError(
       `FLOW.QUERY diagnostic ${name} exceeds ${DIAGNOSTIC_TEXT_BYTES} bytes`,
       mapping2
@@ -12965,7 +13300,7 @@ function validateDiagnosticContextValue(value, depth, budget) {
   }
   const text3 = diagnosticContextText(value);
   if (text3 != null) {
-    if (import_node_buffer48.Buffer.byteLength(text3, "utf8") <= DIAGNOSTIC_TEXT_BYTES) return;
+    if (import_node_buffer50.Buffer.byteLength(text3, "utf8") <= DIAGNOSTIC_TEXT_BYTES) return;
     throw decodeError("FLOW.QUERY diagnostic context contains oversized text", value);
   }
   if (depth <= 0) {
@@ -12991,7 +13326,7 @@ function validateDiagnosticContextValue(value, depth, budget) {
     }
     for (const [rawKey, item] of entries) {
       const key = diagnosticContextText(rawKey);
-      if (key == null || key.length === 0 || import_node_buffer48.Buffer.byteLength(key, "utf8") > DIAGNOSTIC_CONTEXT_KEY_BYTES) {
+      if (key == null || key.length === 0 || import_node_buffer50.Buffer.byteLength(key, "utf8") > DIAGNOSTIC_CONTEXT_KEY_BYTES) {
         throw decodeError("FLOW.QUERY diagnostic context contains an invalid key", value);
       }
       validateDiagnosticContextValue(item, depth - 1, budget);
@@ -13008,7 +13343,7 @@ function consumeDiagnosticContextNode(value, budget) {
 }
 function diagnosticContextText(value) {
   if (typeof value === "string") return value.isWellFormed() ? value : void 0;
-  if (!import_node_buffer48.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return void 0;
+  if (!import_node_buffer50.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return void 0;
   try {
     return new TextDecoder("utf-8", { fatal: true }).decode(value);
   } catch {
@@ -13034,7 +13369,7 @@ function decodePosition(value) {
 }
 
 // src/flow-query-index-contract.ts
-var import_node_buffer49 = require("buffer");
+var import_node_buffer51 = require("buffer");
 var FLOW_QUERY_BUILD_PHASES = ["pending", "snapshot", "backfill", "done"];
 var FLOW_QUERY_VALIDATION_PHASES = [
   "pending",
@@ -13280,10 +13615,10 @@ function fieldKind(name) {
   return void 0;
 }
 function validUnquoted(value) {
-  return !value.startsWith("__") && UNQUOTED_METADATA.test(value) && import_node_buffer49.Buffer.byteLength(value, "ascii") <= 64;
+  return !value.startsWith("__") && UNQUOTED_METADATA.test(value) && import_node_buffer51.Buffer.byteLength(value, "ascii") <= 64;
 }
 function validMetadata(value, rejectReserved) {
-  return value.length > 0 && import_node_buffer49.Buffer.byteLength(value, "utf8") <= 64 && (!rejectReserved || !value.startsWith("__"));
+  return value.length > 0 && import_node_buffer51.Buffer.byteLength(value, "utf8") <= 64 && (!rejectReserved || !value.startsWith("__"));
 }
 function externalSelector(root, ...segments) {
   return segments.every(validUnquoted) ? [root, ...segments].join(".") : root + segments.map((segment) => `['${segment.replaceAll("'", "''")}']`).join("");
@@ -14190,7 +14525,7 @@ function decodePage(value) {
   const mapping2 = requiredMap2(value, "FLOW.QUERY page");
   const hasMore = requiredBoolean(mapping2, "has_more", "FLOW.QUERY page");
   const cursor = optionalText2(mapping2, "cursor", "FLOW.QUERY page");
-  if (cursor != null && (!cursor.startsWith("fqc1_") || import_node_buffer50.Buffer.byteLength(cursor) < 16 || import_node_buffer50.Buffer.byteLength(cursor) > 4096)) {
+  if (cursor != null && (!cursor.startsWith("fqc1_") || import_node_buffer52.Buffer.byteLength(cursor) < 16 || import_node_buffer52.Buffer.byteLength(cursor) > 4096)) {
     throw decodeError("FLOW.QUERY page cursor is invalid", value);
   }
   if (hasMore !== (cursor != null)) {
@@ -14200,12 +14535,12 @@ function decodePage(value) {
 }
 
 // src/client-core.ts
-var import_node_buffer55 = require("buffer");
+var import_node_buffer57 = require("buffer");
 
 // src/client-core-helpers.ts
-var import_node_buffer51 = require("buffer");
+var import_node_buffer53 = require("buffer");
 function bgsaveResponse(response) {
-  if ((typeof response === "string" || import_node_buffer51.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
+  if ((typeof response === "string" || import_node_buffer53.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
     return true;
   }
   return okResponse(response);
@@ -14219,7 +14554,7 @@ function fetchOrComputeCompletionToken(options) {
       "fetch-or-compute completion requires computeToken"
     );
   }
-  if (!import_node_buffer51.Buffer.isBuffer(options.computeToken)) {
+  if (!import_node_buffer53.Buffer.isBuffer(options.computeToken)) {
     throw new TypeError("fetch-or-compute computeToken must be a Buffer");
   }
   return options.computeToken;
@@ -14242,10 +14577,10 @@ function unsupportedClientCaching() {
 }
 
 // src/client-base.ts
-var import_node_buffer53 = require("buffer");
+var import_node_buffer55 = require("buffer");
 
 // src/client-executor.ts
-var import_node_buffer52 = require("buffer");
+var import_node_buffer54 = require("buffer");
 var ErrorMappingExecutor = class {
   constructor(executor) {
     this.executor = executor;
@@ -14586,14 +14921,14 @@ var FerricStoreAdministrationClient = class extends FerricStoreClientBase {
 };
 
 // src/store-utilities.ts
-var import_node_buffer54 = require("buffer");
+var import_node_buffer56 = require("buffer");
 function encode(codec, value) {
   return codec.encode(value);
 }
 function decode(codec, value) {
   if (value == null) return null;
-  if (import_node_buffer54.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer54.Buffer.from(value));
+  if (import_node_buffer56.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer56.Buffer.from(value));
   return value;
 }
 function number(value) {
@@ -17449,7 +17784,7 @@ function throwIfClosed(signal) {
 }
 
 // src/flow-policy.ts
-var import_node_buffer56 = require("buffer");
+var import_node_buffer58 = require("buffer");
 var MAX_FLOW_POLICY_GENERATION = Number.MAX_SAFE_INTEGER;
 function assertFlowPolicyGeneration(value) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
@@ -17539,7 +17874,7 @@ function requiredRecord(value, context) {
     }
     return result;
   }
-  if (typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer56.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return value;
+  if (typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer58.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return value;
   throw new TypeError(`${context} returned an unexpected response`);
 }
 function optionalRecord(value, context) {
@@ -17560,8 +17895,8 @@ function stringArray(value, context) {
 }
 function requiredText4(value, context) {
   if (typeof value === "string") return value;
-  if (import_node_buffer56.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return import_node_buffer56.Buffer.from(value).toString("utf8");
+  if (import_node_buffer58.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer58.Buffer.from(value).toString("utf8");
   }
   throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
 }
@@ -17817,7 +18152,7 @@ var FerricStoreFlowSupportClient = class extends FerricStoreFlowQueryClient {
 };
 
 // src/flow-many-snapshot.ts
-var import_node_buffer58 = require("buffer");
+var import_node_buffer60 = require("buffer");
 var encodedOptionFields = ["error", "payload", "reason", "result"];
 function snapshotCreateItem(item, codec) {
   const snapshot = {
@@ -17857,7 +18192,7 @@ function snapshotFlowManyOptions(options, codec) {
 }
 function snapshotClaimedItem(item) {
   const wire = item[CLAIMED_ITEM_WIRE];
-  const leaseToken = import_node_buffer58.Buffer.from(wire?.leaseToken ?? item.leaseToken);
+  const leaseToken = import_node_buffer60.Buffer.from(wire?.leaseToken ?? item.leaseToken);
   const snapshot = {
     ...item,
     fencingToken: wire?.fencingToken ?? item.fencingToken,
@@ -17874,15 +18209,15 @@ function snapshotClaimedItem(item) {
 function snapshotFencedItem(item) {
   return Object.freeze({
     ...item,
-    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer58.Buffer.from(item.leaseToken) }
+    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer60.Buffer.from(item.leaseToken) }
   });
 }
 function snapshotClaimedItemWire(wire, leaseToken) {
   return Object.freeze({
     fencingToken: wire.fencingToken,
-    id: import_node_buffer58.Buffer.from(wire.id),
+    id: import_node_buffer60.Buffer.from(wire.id),
     leaseToken,
-    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer58.Buffer.from(wire.partitionKey)
+    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer60.Buffer.from(wire.partitionKey)
   });
 }
 function snapshotArray(values) {
@@ -17893,7 +18228,7 @@ function snapshotArray(values) {
   return Object.freeze(snapshot);
 }
 function snapshotStateMeta(stateMeta) {
-  return snapshotRecord(stateMeta, (value) => import_node_buffer58.Buffer.isBuffer(value) ? import_node_buffer58.Buffer.from(value) : value);
+  return snapshotRecord(stateMeta, (value) => import_node_buffer60.Buffer.isBuffer(value) ? import_node_buffer60.Buffer.from(value) : value);
 }
 function snapshotCommandRecord(values) {
   const seen = /* @__PURE__ */ new WeakMap();
@@ -17911,7 +18246,7 @@ function snapshotRecord(values, capture) {
 }
 function snapshotCommandArgument(value, seen) {
   if (typeof value !== "object" || value == null) return value;
-  if (import_node_buffer58.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer58.Buffer.from(value);
+  if (import_node_buffer60.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer60.Buffer.from(value);
   const objectValue = value;
   const existing = seen.get(objectValue);
   if (existing != null) return existing;
@@ -18907,7 +19242,7 @@ function nativeOptionsForBootstrap(options, signal) {
 }
 
 // src/flow-query-projection.ts
-var import_node_buffer59 = require("buffer");
+var import_node_buffer61 = require("buffer");
 var MAX_PROJECTION_FIELDS = 32;
 var MAX_DYNAMIC_NAME_BYTES = 64;
 var FIELD_BRAND = /* @__PURE__ */ Symbol("FerricStoreFlowProjectionField");
@@ -18977,7 +19312,7 @@ function projectFlowQuery(query, shape, ...fields) {
   }
   const base = stripOptionalTerminator(query);
   const result = `${base} RETURN ${shape.toUpperCase()} (${selectors.join(", ")})`;
-  if (import_node_buffer59.Buffer.byteLength(result, "utf8") > FLOW_QUERY_MAX_BYTES) {
+  if (import_node_buffer61.Buffer.byteLength(result, "utf8") > FLOW_QUERY_MAX_BYTES) {
     throw new TypeError(`FLOW.QUERY query exceeds ${FLOW_QUERY_MAX_BYTES} bytes`);
   }
   return result;
@@ -19037,7 +19372,7 @@ function quoteName(value, allowPrivate) {
     throw new TypeError("Flow query projection metadata name must be text");
   }
   validateUnicodeScalarText2(value);
-  const size = import_node_buffer59.Buffer.byteLength(value, "utf8");
+  const size = import_node_buffer61.Buffer.byteLength(value, "utf8");
   if (size === 0 || size > MAX_DYNAMIC_NAME_BYTES || !allowPrivate && value.startsWith("__")) {
     throw new TypeError(
       `Flow query projection metadata names must be 1..${MAX_DYNAMIC_NAME_BYTES} UTF-8 bytes`
@@ -21043,7 +21378,7 @@ var WorkflowWorker = class {
 };
 
 // src/version.ts
-var FERRICSTORE_SDK_VERSION = "0.11.9";
+var FERRICSTORE_SDK_VERSION = "0.11.11";
 var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.11.4";
 var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 // Annotate the CommonJS export names for ESM import in node: