@ferricstore/ferricstore 0.11.8 → 0.11.10

package/dist/index.cjs

@@ -49,6 +49,8 @@ __export(index_exports, {
   FlowQueryError: () => FlowQueryError,
   FlowWrongStateError: () => FlowWrongStateError,
   GeoStore: () => GeoStore,
+  HTTPAdapter: () => HTTPAdapter,
+  HTTPTransportError: () => HTTPTransportError,
   HashStore: () => HashStore,
   HyperLogLogStore: () => HyperLogLogStore,
   InvalidCommandError: () => InvalidCommandError,
@@ -86,6 +88,7 @@ __export(index_exports, {
   classifyServerError: () => classifyServerError,
   complete: () => complete,
   fail: () => fail2,
+  httpCommandDisposition: () => httpCommandDisposition,
   isOutcome: () => isOutcome,
   isReconnectableClosedConnectionError: () => isReconnectableClosedConnectionError,
   mapException: () => mapException,
@@ -125,6 +128,14 @@ var FerricStoreError = class extends Error {
     this.retryAfterMs = options.retryAfterMs ?? structuredIntegerField(options.raw, "retry_after_ms");
   }
 };
+var HTTPTransportError = class extends FerricStoreError {
+  code = "http_transport";
+  statusCode;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.statusCode = options.statusCode;
+  }
+};
 var ConnectionClosedError = class extends FerricStoreError {
   code = "connection_closed";
   requestDisposition;
@@ -1545,6 +1556,7 @@ var neverAutoBatchCommandPrefixes = /* @__PURE__ */ new Set([
   "BLPOP",
   "BRPOP",
   "BRPOPLPUSH",
+  "BZMPOP",
   "BZPOPMAX",
   "BZPOPMIN",
   "CLIENT",
@@ -1656,6 +1668,9 @@ var connectionBlockingCommands = /* @__PURE__ */ new Set([
   "BLPOP",
   "BRPOP",
   "BRPOPLPUSH",
+  "BZMPOP",
+  "BZPOPMAX",
+  "BZPOPMIN",
   "XREAD",
   "XREADGROUP"
 ]);
@@ -2524,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) {
@@ -7585,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);
@@ -7613,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
@@ -8643,6 +8675,800 @@ 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",
+  "OPTIONS",
+  "PIPELINE",
+  "QUIT",
+  "ROUTE",
+  "ROUTE_BATCH",
+  "SHARDS",
+  "STARTUP",
+  "SUBSCRIBE_EVENTS",
+  "UNSUBSCRIBE_EVENTS",
+  "WINDOW_UPDATE"
+]);
+var sessionOnlyCommands = /* @__PURE__ */ new Set([
+  "ASKING",
+  "AUTH",
+  "CLIENT",
+  "DISCARD",
+  "EXEC",
+  "HELLO",
+  "MONITOR",
+  "MULTI",
+  "PSUBSCRIBE",
+  "PSYNC",
+  "PUNSUBSCRIBE",
+  "QUIT",
+  "READONLY",
+  "READWRITE",
+  "REPLCONF",
+  "RESET",
+  "SANDBOX",
+  "SELECT",
+  "SSUBSCRIBE",
+  "SUBSCRIBE",
+  "SUNSUBSCRIBE",
+  "SYNC",
+  "UNSUBSCRIBE",
+  "UNWATCH",
+  "WATCH"
+]);
+function httpCommandDisposition(name) {
+  const normalized = name.toUpperCase();
+  return nativeOnlyCommands.has(normalized) || sessionOnlyCommands.has(normalized) ? "native_only" : "supported";
+}
+function assertHTTPCommandSupported(name) {
+  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_buffer34 = require("buffer");
+var encoding = "ferricstore-json-v1";
+var bytesMarker = "$ferricstore_bytes";
+var mapMarker = "$ferricstore_map";
+var maxDepth = 64;
+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, budget))
+  }));
+}
+function decodeHTTPEnvelope(source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source.toString("utf8"));
+  } 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, budget) {
+  if (depth > maxDepth) throw new TypeError("HTTP command value exceeds maximum depth");
+  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") {
+    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 (value instanceof Map) {
+    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)) {
+    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}`);
+}
+function decodeValue2(value, depth) {
+  if (depth > maxDepth) throw new TypeError("HTTP response value exceeds maximum depth");
+  if (Array.isArray(value)) return denseArray(value, depth + 1, decodeValue2);
+  if (!isRecord(value)) return value;
+  if (Object.keys(value).length === 1 && typeof value[bytesMarker] === "string") {
+    return decodeBase64(value[bytesMarker]);
+  }
+  if (Object.keys(value).length === 1 && Array.isArray(value[mapMarker])) {
+    const result = /* @__PURE__ */ new Map();
+    for (const pair of value[mapMarker]) {
+      if (!Array.isArray(pair) || pair.length !== 2) throw new TypeError("invalid HTTP map marker");
+      result.set(decodeValue2(pair[0], depth + 1), decodeValue2(pair[1], depth + 1));
+    }
+    return result;
+  }
+  return decodePlainRecord(value, depth + 1);
+}
+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_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)) {
+    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) {
+    if (!Object.hasOwn(values, index)) throw new TypeError("HTTP command arrays must be dense");
+    result[index] = transform(values[index], depth);
+  }
+  return result;
+}
+function isRecord(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:") {
+    throw new TypeError(`unsupported HTTP URL scheme: ${url.protocol}`);
+  }
+  if (url.username !== "" || url.password !== "") throw new TypeError("HTTP URL userinfo is not allowed");
+  if (url.search !== "" || url.hash !== "") throw new TypeError("HTTP base URL cannot contain query or fragment");
+  const headers = normalizedHeaders(options.headers ?? {});
+  const authorization = authorizationHeader(url, options, headers.authorization);
+  if (authorization != null) headers.authorization = authorization;
+  url.pathname = `${url.pathname.replace(/\/$/u, "")}/v1/commands`;
+  return Object.freeze({
+    commandUrl: url,
+    headers: Object.freeze(headers),
+    http2: booleanOption(options.http2, false, "http2"),
+    maxBatchItems: positiveInteger(options.maxBatchItems, 1e3, "maxBatchItems"),
+    maxConnections: positiveInteger(options.maxConnections, 100, "maxConnections"),
+    maxRedirects: nonNegativeInteger(options.maxRedirects, 20, "maxRedirects"),
+    maxRequestBytes: positiveInteger(options.maxRequestBytes, 1024 * 1024, "maxRequestBytes"),
+    maxResponseBytes: positiveInteger(options.maxResponseBytes, 16 * 1024 * 1024, "maxResponseBytes"),
+    timeoutMs: positiveInteger(options.timeoutMs, 3e4, "timeoutMs"),
+    tlsOptions: Object.freeze({ ...options.tlsOptions ?? {} })
+  });
+}
+function normalizedHeaders(source) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  for (const [rawName, value] of Object.entries(source)) {
+    const name = rawName.toLowerCase();
+    if (typeof value !== "string" || !validHeader(name, value)) {
+      throw new TypeError(`invalid HTTP header: ${rawName}`);
+    }
+    headers[name] = value;
+  }
+  return headers;
+}
+function authorizationHeader(url, options, custom) {
+  const basic = options.username != null || options.password != null;
+  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 (options.bearerToken === "" || !validHeader("authorization", `Bearer ${options.bearerToken}`)) {
+      throw new TypeError("invalid bearer token");
+    }
+    return `Bearer ${options.bearerToken}`;
+  }
+  if (!basic) return custom;
+  if (url.protocol !== "https:") throw new TypeError("Basic authentication requires HTTPS");
+  if (typeof options.password !== "string") throw new TypeError("Basic authentication requires a password");
+  const username = options.username ?? "default";
+  if (username === "" || username.includes(":") || !safeHeader(username) || !safeHeader(options.password)) {
+    throw new TypeError("invalid Basic authentication credentials");
+  }
+  return `Basic ${import_node_buffer35.Buffer.from(`${username}:${options.password}`).toString("base64")}`;
+}
+function positiveInteger(value, fallback, name) {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result <= 0) throw new TypeError(`${name} must be a positive integer`);
+  return result;
+}
+function nonNegativeInteger(value, fallback, name) {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result < 0) throw new TypeError(`${name} must be a non-negative integer`);
+  return result;
+}
+function booleanOption(value, fallback, name) {
+  const result = value ?? fallback;
+  if (typeof result !== "boolean") throw new TypeError(`${name} must be a boolean`);
+  return result;
+}
+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_http2 = __toESM(require("http"), 1);
+var import_node_http22 = __toESM(require("http2"), 1);
+var import_node_https = __toESM(require("https"), 1);
+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_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,
+      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, timeoutMs) {
+    if (this.#closed) throw new HTTPTransportError("HTTP transport is closed");
+    const controller = new AbortController();
+    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) {
+        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 }
+        });
+      }
+      if (error instanceof HTTPTransportError || error instanceof RequestTimeoutError) throw error;
+      throw new HTTPTransportError("HTTP command request failed", {
+        cause: error,
+        retryable: true,
+        safeToRetry: false
+      });
+    } finally {
+      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.#allSessions) session.destroy();
+    this.#allSessions.clear();
+    this.#sessions.clear();
+  }
+  async request(url, method, body, redirects, signal) {
+    const response = this.config.http2 ? await this.http2Request(url, method, body, signal) : await this.http1Request(url, method, body, signal);
+    if (![301, 302, 303, 307, 308].includes(response.status)) return response;
+    if (redirects >= this.config.maxRedirects) throw new HTTPTransportError("too many HTTP redirects");
+    const location = response.headers.location;
+    if (location == null || location === "") throw new HTTPTransportError("HTTP redirect has no location");
+    const target = new URL(location, url);
+    if (target.protocol !== "http:" && target.protocol !== "https:") {
+      throw new HTTPTransportError("HTTP redirect has an unsupported scheme");
+    }
+    const switchToGet = [301, 302, 303].includes(response.status);
+    return await this.request(
+      target,
+      switchToGet ? "GET" : method,
+      switchToGet ? void 0 : body,
+      redirects + 1,
+      signal
+    );
+  }
+  async http1Request(url, method, body, signal) {
+    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) => {
+      const outgoing = request(url, { agent, headers, method, signal }, (response) => {
+        void this.collectHttp1(response).then(resolve, reject);
+      });
+      outgoing.once("error", reject);
+      outgoing.end(body);
+    });
+  }
+  async collectHttp1(response) {
+    const declared = headerValue(response.headers["content-length"]);
+    if (declared != null && Number(declared) > this.config.maxResponseBytes) {
+      response.destroy();
+      throw new HTTPTransportError("HTTP response exceeds maxResponseBytes");
+    }
+    return await collectBody(
+      response,
+      response.statusCode ?? 0,
+      normalizeHeaders(response.headers),
+      this.config.maxResponseBytes
+    );
+  }
+  async http2Request(url, method, body, signal) {
+    const headers = {
+      ...this.requestHeaders(body),
+      ":authority": url.host,
+      ":method": method,
+      ":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) => {
+      let responseHeaders = {};
+      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);
+      void collectBody(stream, 0, {}, this.config.maxResponseBytes).then((response) => {
+        const status = Number(responseHeaders[":status"] ?? 0);
+        resolve({ body: response.body, headers: normalizeHeaders(responseHeaders), status });
+      }, reject).finally(() => signal.removeEventListener("abort", abort));
+      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_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"];
+    delete headers["content-type"];
+    return {
+      ...headers,
+      accept: "application/json",
+      ...body == null ? {} : { "content-length": body.byteLength, "content-type": "application/json" }
+    };
+  }
+};
+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_buffer36.Buffer.from(chunk);
+    size += bytes2.byteLength;
+    if (size > maximum) {
+      const destroy = source.destroy;
+      if (destroy != null) destroy.call(source);
+      throw new HTTPTransportError("HTTP response exceeds maxResponseBytes");
+    }
+    chunks.push(bytes2);
+  }
+  return { body: import_node_buffer36.Buffer.concat(chunks, size), headers, status };
+}
+function normalizeHeaders(headers) {
+  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;
+  }
+  return result;
+}
+function headerValue(value) {
+  if (Array.isArray(value)) return value.join(", ");
+  return value == null ? void 0 : String(value);
+}
+
+// src/http-adapter.ts
+var HTTPAdapter = class _HTTPAdapter {
+  #config;
+  #transport;
+  static async fromUrl(url, options = {}) {
+    return new _HTTPAdapter(normalizeHTTPOptions(url, options));
+  }
+  constructor(config) {
+    this.#config = config;
+    this.#transport = new HTTPTransport(config);
+  }
+  async executeCommand(...args) {
+    return await this.executeCommandArgs(args);
+  }
+  async executeCommandArgs(args) {
+    const [result] = await this.executeBatch([args]);
+    if (result == null) throw new HTTPTransportError("HTTP response omitted a command result");
+    if (result.status === "error") throw commandError(result.error);
+    return result.value;
+  }
+  async executePipeline(commands, options = {}) {
+    const results = await this.executeBatch(commands);
+    const values = results.map((result) => result.status === "ok" ? result.value : commandError(result.error));
+    if (options.throwOnItemError !== false) {
+      const failure = values.find((value) => value instanceof Error);
+      if (failure instanceof Error) throw failure;
+    }
+    return values;
+  }
+  async executeFusedPipeline(commands, options = {}) {
+    return await this.executePipeline(commands, options);
+  }
+  async close() {
+    await this.#transport.close();
+  }
+  async executeBatch(commands) {
+    if (commands.length > this.#config.maxBatchItems) {
+      throw new HTTPTransportError("HTTP command batch exceeds maxBatchItems");
+    }
+    for (const command of commands) assertHTTPCommandSupported(command[0]);
+    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 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);
+    } catch (error) {
+      if (response.status >= 200 && response.status < 300) throw error;
+    }
+    if (response.status < 200 || response.status >= 300) throw topLevelError(
+      response.status,
+      envelope,
+      response.headers["retry-after"]
+    );
+    if (envelope.encoding !== "ferricstore-json-v1") {
+      throw new HTTPTransportError("HTTP response has an unsupported encoding");
+    }
+    if (!Array.isArray(envelope.results) || envelope.results.length !== commands.length) {
+      throw new HTTPTransportError("HTTP response result count does not match the command batch");
+    }
+    return envelope.results.map((result) => validatedResult(result));
+  }
+};
+var commandNamesByOpcode = new Map(
+  Object.entries(COMMAND_OPCODES).map(([name, opcode]) => [opcode, name])
+);
+function prepareHTTPCommand(command, maxRequestBytes) {
+  const protocol = buildProtocolCommand(command, maxRequestBytes, false);
+  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 {
+    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");
+  if (value.status === "ok" && Object.hasOwn(value, "value")) {
+    return { status: "ok", value: value.value };
+  }
+  if (value.status === "error" && isRecord2(value.error)) {
+    return { error: value.error, status: "error" };
+  }
+  throw new HTTPTransportError("HTTP response has an invalid result item");
+}
+function commandError(value) {
+  const message = isRecord2(value) && typeof value.message === "string" ? value.message : "FerricStore command failed";
+  const code = isRecord2(value) && typeof value.code === "string" ? value.code : void 0;
+  return classifyServerError(message, value, void 0, code);
+}
+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 = retryAfterMilliseconds(retryAfter);
+  return new HTTPTransportError(message, {
+    raw: details,
+    retryable: status === 408 || status === 425 || status === 429 || status >= 500,
+    retryAfterMs: retryAfterMs2,
+    safeToRetry: false,
+    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);
+}
+
 // src/adapters.ts
 function executeCommandArgs(executor, args) {
   if (executor.executeCommandArgs != null) return executor.executeCommandArgs(args);
@@ -8651,10 +9477,10 @@ function executeCommandArgs(executor, args) {
 }
 
 // src/reconnecting-executor.ts
-var import_node_buffer34 = require("buffer");
+var import_node_buffer38 = require("buffer");
 
 // src/command-retry-policy.ts
-var import_node_buffer33 = 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]);
@@ -8668,8 +9494,8 @@ function isCasMutation(args) {
 }
 function commandName2(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();
+  if (import_node_buffer37.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer37.Buffer.from(value).toString("utf8").toUpperCase();
   }
   return void 0;
 }
@@ -8881,15 +9707,15 @@ function normalizeNonNegativeInteger2(value, fallback) {
 }
 
 // src/topology.ts
-var import_node_buffer37 = require("buffer");
+var import_node_buffer41 = require("buffer");
 
 // src/topology-routing.ts
-var import_node_buffer36 = require("buffer");
+var import_node_buffer40 = require("buffer");
 
 // src/flow-partition-route-cache.ts
-var import_node_buffer35 = require("buffer");
+var import_node_buffer39 = require("buffer");
 var import_node_crypto = require("crypto");
-var AUTO_PREFIX = import_node_buffer35.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;
@@ -8899,10 +9725,10 @@ var cacheBytes = 0;
 var cacheHits = 0;
 var cacheMisses = 0;
 function flowLogicalPartitionRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer35.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_buffer35.Buffer.isBuffer(value) ? value : import_node_buffer35.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);
@@ -8976,7 +9802,7 @@ function routingKeyFromProtocolPayload(name, command) {
       "scope"
     ]) {
       const value = getField(command.payload, field3);
-      if (typeof value === "string" || import_node_buffer36.Buffer.isBuffer(value)) {
+      if (typeof value === "string" || import_node_buffer40.Buffer.isBuffer(value)) {
         return value;
       }
     }
@@ -9024,7 +9850,7 @@ function flowRoutingData(name, args) {
     if (typeof partition === "string" && partition.toUpperCase() !== "AUTO" && partition.toUpperCase() !== "MIXED") {
       return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
     }
-    if (import_node_buffer36.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));
@@ -9115,17 +9941,17 @@ function flowPartitionRoutingKeyFromCommand(command, claim) {
   return { handled: false };
 }
 function isRoutingKey(value) {
-  return typeof value === "string" || import_node_buffer36.Buffer.isBuffer(value);
+  return typeof value === "string" || import_node_buffer40.Buffer.isBuffer(value);
 }
 function flowAutoIdRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer36.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer40.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bucket = (import_node_buffer36.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_buffer36.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}";
@@ -9140,7 +9966,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_buffer36.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;
@@ -9173,7 +9999,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_buffer36.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);
@@ -10262,7 +11088,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
 };
 
 // src/response-map-preservation.ts
-var import_node_buffer38 = require("buffer");
+var import_node_buffer42 = require("buffer");
 function toStringKeyMapPreservingValues(value) {
   if (value == null) return void 0;
   const result = {};
@@ -10272,7 +11098,7 @@ function toStringKeyMapPreservingValues(value) {
     }
     return result;
   }
-  if (typeof value === "object" && !Array.isArray(value) && !import_node_buffer38.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));
     }
@@ -10281,7 +11107,7 @@ function toStringKeyMapPreservingValues(value) {
   return void 0;
 }
 function normalizeMapStructurePreservingBytes(value) {
-  if (import_node_buffer38.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()) {
@@ -10303,7 +11129,7 @@ function normalizeMapStructurePreservingBytes(value) {
 }
 
 // src/native-kv-responses.ts
-var import_node_buffer39 = 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");
@@ -10360,13 +11186,13 @@ function fetchOrComputeResultFromResp(value, codec) {
 }
 function decodePayload(codec, value) {
   if (value == null) return null;
-  if (import_node_buffer39.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer39.Buffer.from(value));
-  if (typeof value === "string") return codec.decode(import_node_buffer39.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_buffer39.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);
@@ -10383,7 +11209,7 @@ function requiredNonNegativeInteger(value, context) {
   return result;
 }
 function responseBytes(value, context) {
-  if (typeof value !== "string" && !import_node_buffer39.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);
@@ -11066,7 +11892,7 @@ function groupAutoPartitionItems(items) {
 }
 
 // src/client-values.ts
-var import_node_buffer40 = require("buffer");
+var import_node_buffer44 = require("buffer");
 async function valueMGetEntries(client, refs, options = {}) {
   const refCount = refs.length;
   if (refCount === 0) {
@@ -11101,12 +11927,12 @@ async function valueMGetEntries(client, refs, options = {}) {
     const item = response[index];
     if (item == null) {
       entries[index] = { found: false };
-    } else if (import_node_buffer40.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_buffer40.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_buffer40.Buffer.from(item)) };
+      entries[index] = { found: true, value: client.codec.decode(import_node_buffer44.Buffer.from(item)) };
     } else {
       entries[index] = { found: true, value: item };
     }
@@ -11115,10 +11941,10 @@ async function valueMGetEntries(client, refs, options = {}) {
 }
 
 // src/auto-batch.ts
-var import_node_buffer42 = require("buffer");
+var import_node_buffer46 = require("buffer");
 
 // src/auto-batch-ordering.ts
-var import_node_buffer41 = require("buffer");
+var import_node_buffer45 = require("buffer");
 function autoBatchOrderingPlan(batch) {
   const accesses = /* @__PURE__ */ new Map();
   const fallbackDependencies = [];
@@ -11233,13 +12059,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_buffer41.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_buffer41.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) {
@@ -11252,7 +12078,7 @@ function createManyAutoBatchIds(command) {
       const ids = fixedFlowItemIds(
         command,
         width,
-        (itemIndex) => isAutoBatchResourceValue(command[itemIndex]) && (!mixed || isAutoBatchResourceValue(command[itemIndex + 1])) && import_node_buffer41.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;
@@ -11270,7 +12096,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_buffer41.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);
@@ -11289,7 +12115,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_buffer41.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;
 }
@@ -11304,7 +12130,7 @@ function runStepsManyAutoBatchIds(command) {
         ids.push(item);
         continue;
       }
-      if (typeof item !== "object" || item == null || Array.isArray(item) || import_node_buffer41.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);
@@ -11345,7 +12171,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_buffer41.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";
@@ -11354,7 +12180,7 @@ function nonNegativeItemCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
 function autoBatchResourceKey(namespace, value) {
-  return `${namespace}:${import_node_buffer41.Buffer.from(value).toString("base64")}`;
+  return `${namespace}:${import_node_buffer45.Buffer.from(value).toString("base64")}`;
 }
 function autoBatchCommandName(command) {
   return commandView(command).name ?? null;
@@ -11763,13 +12589,13 @@ function claimFailure(error) {
 }
 
 // src/client-flow-support.ts
-var import_node_buffer55 = require("buffer");
+var import_node_buffer59 = require("buffer");
 
 // src/flow-query-builder.ts
-var import_node_buffer44 = require("buffer");
+var import_node_buffer48 = require("buffer");
 
 // src/flow-query-metadata.ts
-var import_node_buffer43 = require("buffer");
+var import_node_buffer47 = require("buffer");
 var MAX_FLOW_QUERY_METADATA_KEY_BYTES = 64;
 function normalizeStateMeta(value, state) {
   if (value == null) return {};
@@ -11794,7 +12620,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_buffer43.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`);
     }
@@ -11818,7 +12644,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_buffer43.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);
@@ -11888,7 +12714,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_buffer44.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`
@@ -12067,7 +12893,7 @@ function requiredPartition(value) {
       "FLOW.QUERY convenience methods require a partition key"
     );
   }
-  const size = import_node_buffer44.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`
@@ -12115,23 +12941,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_buffer44.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_buffer48 = require("buffer");
+var import_node_buffer52 = require("buffer");
 
 // src/flow-query-diagnostic-response.ts
-var import_node_buffer46 = require("buffer");
+var import_node_buffer50 = require("buffer");
 
 // src/flow-query-response-validation.ts
-var import_node_buffer45 = 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_buffer45.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;
@@ -12188,7 +13014,7 @@ function normalizeMetadataValue(value, context, budget, ancestors, depth) {
     if (!value.isWellFormed()) throw decodeError(`${context} contains invalid text`, value);
     return value;
   }
-  if (import_node_buffer45.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;
@@ -12267,7 +13093,7 @@ function optionalText2(mapping2, name, context) {
 }
 function requiredBoundedText2(mapping2, name, context, maximumBytes) {
   const value = requiredText2(mapping2, name, context);
-  if (import_node_buffer45.Buffer.byteLength(value, "utf8") > maximumBytes) {
+  if (import_node_buffer49.Buffer.byteLength(value, "utf8") > maximumBytes) {
     throw decodeError(
       `${context} ${name} exceeds ${maximumBytes} bytes`,
       mapping2
@@ -12280,7 +13106,7 @@ function boundedText(value, context, maximumBytes) {
   if (decoded == null || decoded.length === 0) {
     throw decodeError(`${context} must be non-empty text`, value);
   }
-  if (import_node_buffer45.Buffer.byteLength(decoded, "utf8") > maximumBytes) {
+  if (import_node_buffer49.Buffer.byteLength(decoded, "utf8") > maximumBytes) {
     throw decodeError(`${context} exceeds ${maximumBytes} bytes`, value);
   }
   return decoded;
@@ -12292,7 +13118,7 @@ function requiredBoolean(mapping2, name, context) {
   }
   return value;
 }
-function nonNegativeInteger(value, context) {
+function nonNegativeInteger2(value, context) {
   if (typeof value === "bigint") {
     if (value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER))
       return Number(value);
@@ -12301,8 +13127,8 @@ function nonNegativeInteger(value, context) {
   }
   throw decodeError(`${context} must be a non-negative safe integer`, value);
 }
-function positiveInteger(value, context) {
-  const parsed = nonNegativeInteger(value, context);
+function positiveInteger2(value, context) {
+  const parsed = nonNegativeInteger2(value, context);
   if (parsed === 0) throw decodeError(`${context} must be positive`, value);
   return parsed;
 }
@@ -12334,10 +13160,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_buffer45.Buffer.from(name);
+  const binaryName = import_node_buffer49.Buffer.from(name);
   for (const key of mapping2.keys()) {
-    if (import_node_buffer45.Buffer.isBuffer(key) && key.equals(binaryName)) return true;
-    if (key instanceof Uint8Array && import_node_buffer45.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;
@@ -12348,7 +13174,7 @@ function decodeError(message, raw) {
 function strictText2(value) {
   if (typeof value === "string")
     return value.isWellFormed() ? value : void 0;
-  if (import_node_buffer45.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 {
@@ -12412,7 +13238,7 @@ function tryDecodeFlowQueryError(value, cause) {
       hint: optionalDiagnosticText(mapping2, "hint"),
       retryable: requiredBoolean(mapping2, "retryable", "FLOW.QUERY diagnostic"),
       safeToRetry: requiredBoolean(mapping2, "safe_to_retry", "FLOW.QUERY diagnostic"),
-      retryAfterMs: nonNegativeInteger(
+      retryAfterMs: nonNegativeInteger2(
         field(mapping2, "retry_after_ms"),
         "FLOW.QUERY diagnostic retry_after_ms"
       ),
@@ -12428,7 +13254,7 @@ function tryDecodeFlowQueryError(value, cause) {
 }
 function optionalDiagnosticText(mapping2, name) {
   const value = optionalText2(mapping2, name, "FLOW.QUERY diagnostic");
-  if (value != null && import_node_buffer46.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
@@ -12463,7 +13289,7 @@ function validateDiagnosticContextValue(value, depth, budget) {
   }
   const text3 = diagnosticContextText(value);
   if (text3 != null) {
-    if (import_node_buffer46.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) {
@@ -12489,7 +13315,7 @@ function validateDiagnosticContextValue(value, depth, budget) {
     }
     for (const [rawKey, item] of entries) {
       const key = diagnosticContextText(rawKey);
-      if (key == null || key.length === 0 || import_node_buffer46.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);
@@ -12506,7 +13332,7 @@ function consumeDiagnosticContextNode(value, budget) {
 }
 function diagnosticContextText(value) {
   if (typeof value === "string") return value.isWellFormed() ? value : void 0;
-  if (!import_node_buffer46.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 {
@@ -12522,9 +13348,9 @@ function decodePosition(value) {
   if (value == null) return void 0;
   const mapping2 = requiredMap2(value, "FLOW.QUERY diagnostic position");
   return Object.freeze({
-    byte: positiveInteger(field(mapping2, "byte"), "FLOW.QUERY diagnostic position byte"),
-    line: positiveInteger(field(mapping2, "line"), "FLOW.QUERY diagnostic position line"),
-    column: positiveInteger(
+    byte: positiveInteger2(field(mapping2, "byte"), "FLOW.QUERY diagnostic position byte"),
+    line: positiveInteger2(field(mapping2, "line"), "FLOW.QUERY diagnostic position line"),
+    column: positiveInteger2(
       field(mapping2, "column"),
       "FLOW.QUERY diagnostic position column"
     )
@@ -12532,7 +13358,7 @@ function decodePosition(value) {
 }
 
 // src/flow-query-index-contract.ts
-var import_node_buffer47 = require("buffer");
+var import_node_buffer51 = require("buffer");
 var FLOW_QUERY_BUILD_PHASES = ["pending", "snapshot", "backfill", "done"];
 var FLOW_QUERY_VALIDATION_PHASES = [
   "pending",
@@ -12778,10 +13604,10 @@ function fieldKind(name) {
   return void 0;
 }
 function validUnquoted(value) {
-  return !value.startsWith("__") && UNQUOTED_METADATA.test(value) && import_node_buffer47.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_buffer47.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("");
@@ -13291,7 +14117,7 @@ function decodeCountPrefixes(value, fieldCount) {
     if (!Object.hasOwn(value, index)) {
       throw decodeError(`${context} must be dense`, value);
     }
-    const prefix = positiveInteger(value[index], `${context} entry`);
+    const prefix = positiveInteger2(value[index], `${context} entry`);
     if (prefix > fieldCount || prefix <= previous) {
       throw decodeError(`${context} are invalid`, value);
     }
@@ -13673,7 +14499,7 @@ function decodeUsage(value) {
   const mapping2 = requiredMap2(value, "FLOW.QUERY usage");
   const usage = /* @__PURE__ */ Object.create(null);
   for (const [wireName, property] of USAGE_FIELDS2) {
-    usage[property] = nonNegativeInteger(
+    usage[property] = nonNegativeInteger2(
       field(mapping2, wireName),
       `FLOW.QUERY usage ${wireName}`
     );
@@ -13688,7 +14514,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_buffer48.Buffer.byteLength(cursor) < 16 || import_node_buffer48.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)) {
@@ -13698,12 +14524,12 @@ function decodePage(value) {
 }
 
 // src/client-core.ts
-var import_node_buffer53 = require("buffer");
+var import_node_buffer57 = require("buffer");
 
 // src/client-core-helpers.ts
-var import_node_buffer49 = require("buffer");
+var import_node_buffer53 = require("buffer");
 function bgsaveResponse(response) {
-  if ((typeof response === "string" || import_node_buffer49.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);
@@ -13717,7 +14543,7 @@ function fetchOrComputeCompletionToken(options) {
       "fetch-or-compute completion requires computeToken"
     );
   }
-  if (!import_node_buffer49.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;
@@ -13740,10 +14566,10 @@ function unsupportedClientCaching() {
 }
 
 // src/client-base.ts
-var import_node_buffer51 = require("buffer");
+var import_node_buffer55 = require("buffer");
 
 // src/client-executor.ts
-var import_node_buffer50 = require("buffer");
+var import_node_buffer54 = require("buffer");
 var ErrorMappingExecutor = class {
   constructor(executor) {
     this.executor = executor;
@@ -13808,7 +14634,14 @@ function snapshotClientOptions(options) {
     ...own2,
     ...typeof own2.autoBatch === "object" && own2.autoBatch != null ? { autoBatch: Object.freeze({ ...own2.autoBatch }) } : {},
     ...own2.backpressure == null ? {} : { backpressure: Object.freeze({ ...own2.backpressure }) },
-    ...typeof own2.reconnect === "object" && own2.reconnect != null ? { reconnect: Object.freeze({ ...own2.reconnect }) } : {}
+    ...typeof own2.reconnect === "object" && own2.reconnect != null ? { reconnect: Object.freeze({ ...own2.reconnect }) } : {},
+    ...own2.httpOptions == null ? {} : {
+      httpOptions: Object.freeze({
+        ...own2.httpOptions,
+        ...own2.httpOptions.headers == null ? {} : { headers: Object.freeze({ ...own2.httpOptions.headers }) },
+        ...own2.httpOptions.tlsOptions == null ? {} : { tlsOptions: Object.freeze({ ...own2.httpOptions.tlsOptions }) }
+      })
+    }
   };
   return Object.freeze(snapshot);
 }
@@ -14077,14 +14910,14 @@ var FerricStoreAdministrationClient = class extends FerricStoreClientBase {
 };
 
 // src/store-utilities.ts
-var import_node_buffer52 = 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_buffer52.Buffer.isBuffer(value)) return codec.decode(value);
-  if (value instanceof Uint8Array) return codec.decode(import_node_buffer52.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) {
@@ -14105,7 +14938,7 @@ function array(value, expectedItems, command) {
   }
   return value;
 }
-function denseArray(value, command) {
+function denseArray2(value, command) {
   return assertDenseArray(array(value), command);
 }
 function denseArrayResponse(value, expectedItems, command) {
@@ -14393,7 +15226,7 @@ var BloomFilterStore = class {
     return integerReply(await this.client.command("BF.CARD", key));
   }
   async info(key) {
-    return denseArray(await this.client.command("BF.INFO", key), "BF.INFO");
+    return denseArray2(await this.client.command("BF.INFO", key), "BF.INFO");
   }
 };
 var CuckooFilterStore = class {
@@ -14432,7 +15265,7 @@ var CuckooFilterStore = class {
     return integerReply(await this.client.command("CF.COUNT", key, encode(this.client.codec, element)));
   }
   async info(key) {
-    return denseArray(await this.client.command("CF.INFO", key), "CF.INFO");
+    return denseArray2(await this.client.command("CF.INFO", key), "CF.INFO");
   }
 };
 var CountMinSketchStore = class {
@@ -14477,7 +15310,7 @@ var CountMinSketchStore = class {
     return okResponse(await commandArgs(this.client, args));
   }
   async info(key) {
-    return denseArray(await this.client.command("CMS.INFO", key), "CMS.INFO");
+    return denseArray2(await this.client.command("CMS.INFO", key), "CMS.INFO");
   }
 };
 var TopKStore = class {
@@ -14560,7 +15393,7 @@ var TopKStore = class {
     );
   }
   async info(key) {
-    return denseArray(await this.client.command("TOPK.INFO", key), "TOPK.INFO");
+    return denseArray2(await this.client.command("TOPK.INFO", key), "TOPK.INFO");
   }
 };
 var TDigestStore = class {
@@ -14651,7 +15484,7 @@ var TDigestStore = class {
     return string(await this.client.command("TDIGEST.MAX", key));
   }
   async info(key) {
-    return denseArray(await this.client.command("TDIGEST.INFO", key), "TDIGEST.INFO");
+    return denseArray2(await this.client.command("TDIGEST.INFO", key), "TDIGEST.INFO");
   }
   async merge(destination, sources, options = {}) {
     requireNonEmpty(sources, "TDIGEST.MERGE", "source");
@@ -15043,7 +15876,7 @@ var KeyValueStore = class {
     return response == null ? null : string(response);
   }
   async objectHelp() {
-    return denseArray(await this.client.command("OBJECT", "HELP"), "OBJECT HELP");
+    return denseArray2(await this.client.command("OBJECT", "HELP"), "OBJECT HELP");
   }
   async objectFreq(key) {
     return number(await this.client.command("OBJECT", "FREQ", key));
@@ -16051,14 +16884,14 @@ function validateScheduleCreate(id, options) {
   validateTiming(kind, options);
   const recurring = RECURRING_KINDS.has(kind);
   validateTarget(options.target, recurring);
-  nonNegativeInteger2(options.atMs, "at_ms");
-  nonNegativeInteger2(options.delayMs, "delay_ms");
-  nonNegativeInteger2(options.startAtMs, "start_at_ms");
-  positiveInteger2(options.everyMs, "every_ms");
-  positiveInteger2(options.overlapRetryMs, "overlap_retry_ms");
-  positiveInteger2(options.maxFires, "max_fires");
-  nonNegativeInteger2(options.endAtMs, "end_at_ms");
-  nonNegativeInteger2(options.nowMs, "now_ms");
+  nonNegativeInteger3(options.atMs, "at_ms");
+  nonNegativeInteger3(options.delayMs, "delay_ms");
+  nonNegativeInteger3(options.startAtMs, "start_at_ms");
+  positiveInteger3(options.everyMs, "every_ms");
+  positiveInteger3(options.overlapRetryMs, "overlap_retry_ms");
+  positiveInteger3(options.maxFires, "max_fires");
+  nonNegativeInteger3(options.endAtMs, "end_at_ms");
+  nonNegativeInteger3(options.nowMs, "now_ms");
   optionalBoolean(options.overwrite, "overwrite");
   if (kind === "delay") {
     if (options.delayMs == null) throw new TypeError("delay_ms is required for delay schedules");
@@ -16115,20 +16948,20 @@ function validateScheduleID(id) {
 }
 function validateScheduleFire(id, options) {
   validateScheduleID(id);
-  nonNegativeInteger2(options.fireAtMs, "fire_at_ms");
-  nonNegativeInteger2(options.nowMs, "now_ms");
+  nonNegativeInteger3(options.fireAtMs, "fire_at_ms");
+  nonNegativeInteger3(options.nowMs, "now_ms");
 }
 function validateScheduleStatus(id, nowMs2) {
   validateScheduleID(id);
-  nonNegativeInteger2(nowMs2, "now_ms");
+  nonNegativeInteger3(nowMs2, "now_ms");
 }
 function validateScheduleFireDue(options) {
   if (!mapping(options)) throw new TypeError("schedule fire-due options must be a mapping");
-  nonNegativeInteger2(options.nowMs, "now_ms");
+  nonNegativeInteger3(options.nowMs, "now_ms");
   optionalText3(options.worker, "worker");
-  positiveInteger2(options.leaseMs, "lease_ms");
-  nonNegativeInteger2(options.blockMs, "block_ms");
-  positiveInteger2(options.limit, "limit");
+  positiveInteger3(options.leaseMs, "lease_ms");
+  nonNegativeInteger3(options.blockMs, "block_ms");
+  positiveInteger3(options.limit, "limit");
   const leaseMs = options.leaseMs ?? 3e4;
   if (options.nowMs != null && options.nowMs > MAX_EXACT_INTEGER - leaseMs) {
     throw new TypeError("now_ms plus lease_ms exceeds the exact integer range");
@@ -16144,12 +16977,12 @@ function validateScheduleList(options) {
   }
   optionalText3(options.timezone, "timezone");
   optionalText3(options.targetType, "target_type");
-  nonNegativeInteger2(options.fromMs, "from_ms");
-  nonNegativeInteger2(options.toMs, "to_ms");
+  nonNegativeInteger3(options.fromMs, "from_ms");
+  nonNegativeInteger3(options.toMs, "to_ms");
   if (options.fromMs != null && options.toMs != null && options.fromMs > options.toMs) {
     throw new TypeError("from_ms must not exceed to_ms");
   }
-  positiveInteger2(options.count, "count");
+  positiveInteger3(options.count, "count");
   optionalBoolean(options.rev, "rev");
 }
 function effectiveKind(options) {
@@ -16207,7 +17040,7 @@ function validateTarget(value, recurring) {
   if (typeof idPrefix === "string" && idPrefix.startsWith(INTERNAL_SCHEDULE_ID_PREFIX)) {
     throw new TypeError("target id_prefix is reserved for internal use");
   }
-  nonNegativeInteger2(own(target, "run_at_ms"), "target run_at_ms");
+  nonNegativeInteger3(own(target, "run_at_ms"), "target run_at_ms");
   const priority = own(target, "priority");
   if (priority != null && (typeof priority !== "number" || !Number.isSafeInteger(priority) || priority < 0 || priority > 2)) {
     throw new TypeError("target priority must be an integer between 0 and 2");
@@ -16229,12 +17062,12 @@ function requiredText3(value, name) {
 function optionalText3(value, name) {
   if (value != null) requiredText3(value, name);
 }
-function nonNegativeInteger2(value, name) {
+function nonNegativeInteger3(value, name) {
   if (value != null && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)) {
     throw new TypeError(`${name} must be a non-negative exact integer`);
   }
 }
-function positiveInteger2(value, name) {
+function positiveInteger3(value, name) {
   if (value != null && (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)) {
     throw new TypeError(`${name} must be a positive exact integer`);
   }
@@ -16940,7 +17773,7 @@ function throwIfClosed(signal) {
 }
 
 // src/flow-policy.ts
-var import_node_buffer54 = 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) {
@@ -16958,7 +17791,7 @@ function flowPolicySnapshotFromResp(value) {
   const states = optionalStates(field(policy, "states"));
   return {
     type: requiredText4(field(policy, "type"), "type"),
-    generation: nonNegativeInteger3(field(policy, "generation"), "generation"),
+    generation: nonNegativeInteger4(field(policy, "generation"), "generation"),
     ...state == null ? {} : { state },
     ...version == null ? {} : { version },
     ...mode == null ? {} : { mode },
@@ -16976,12 +17809,12 @@ function retrySnapshot(value, context) {
   const retry2 = requiredRecord(value, `FLOW policy ${context}`);
   const backoff = requiredRecord(field(retry2, "backoff"), `FLOW policy ${context}.backoff`);
   return {
-    maxRetries: nonNegativeInteger3(field(retry2, "max_retries"), `${context}.max_retries`),
+    maxRetries: nonNegativeInteger4(field(retry2, "max_retries"), `${context}.max_retries`),
     backoff: {
       kind: backoffKind(field(backoff, "kind"), `${context}.backoff.kind`),
-      baseMs: nonNegativeInteger3(field(backoff, "base_ms"), `${context}.backoff.base_ms`),
-      maxMs: nonNegativeInteger3(field(backoff, "max_ms"), `${context}.backoff.max_ms`),
-      jitterPct: nonNegativeInteger3(field(backoff, "jitter_pct"), `${context}.backoff.jitter_pct`)
+      baseMs: nonNegativeInteger4(field(backoff, "base_ms"), `${context}.backoff.base_ms`),
+      maxMs: nonNegativeInteger4(field(backoff, "max_ms"), `${context}.backoff.max_ms`),
+      jitterPct: nonNegativeInteger4(field(backoff, "jitter_pct"), `${context}.backoff.jitter_pct`)
     },
     exhaustedTo: requiredText4(field(retry2, "exhausted_to"), `${context}.exhausted_to`)
   };
@@ -16989,8 +17822,8 @@ function retrySnapshot(value, context) {
 function retentionSnapshot(value, context) {
   const retention = requiredRecord(value, `FLOW policy ${context}`);
   return {
-    ttlMs: nonNegativeInteger3(field(retention, "ttl_ms"), `${context}.ttl_ms`),
-    historyMaxEvents: nonNegativeInteger3(
+    ttlMs: nonNegativeInteger4(field(retention, "ttl_ms"), `${context}.ttl_ms`),
+    historyMaxEvents: nonNegativeInteger4(
       field(retention, "history_max_events"),
       `${context}.history_max_events`
     )
@@ -17030,7 +17863,7 @@ function requiredRecord(value, context) {
     }
     return result;
   }
-  if (typeof value === "object" && value != null && !Array.isArray(value) && !import_node_buffer54.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) {
@@ -17051,15 +17884,15 @@ function stringArray(value, context) {
 }
 function requiredText4(value, context) {
   if (typeof value === "string") return value;
-  if (import_node_buffer54.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return import_node_buffer54.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`);
 }
 function optionalText4(value, context) {
   return value == null ? void 0 : requiredText4(value, context);
 }
-function nonNegativeInteger3(value, context) {
+function nonNegativeInteger4(value, context) {
   let parsed;
   try {
     parsed = integer(value);
@@ -17071,14 +17904,14 @@ function nonNegativeInteger3(value, context) {
 }
 function optionalPositiveInteger(value, context) {
   if (value == null) return void 0;
-  const parsed = nonNegativeInteger3(value, context);
+  const parsed = nonNegativeInteger4(value, context);
   if (parsed === 0) throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
   return parsed;
 }
 function optionalVersion(value) {
   if (value == null) return void 0;
   if (typeof value === "number" || typeof value === "bigint") {
-    return nonNegativeInteger3(value, "version");
+    return nonNegativeInteger4(value, "version");
   }
   return requiredText4(value, "version");
 }
@@ -17308,7 +18141,7 @@ var FerricStoreFlowSupportClient = class extends FerricStoreFlowQueryClient {
 };
 
 // src/flow-many-snapshot.ts
-var import_node_buffer56 = require("buffer");
+var import_node_buffer60 = require("buffer");
 var encodedOptionFields = ["error", "payload", "reason", "result"];
 function snapshotCreateItem(item, codec) {
   const snapshot = {
@@ -17348,7 +18181,7 @@ function snapshotFlowManyOptions(options, codec) {
 }
 function snapshotClaimedItem(item) {
   const wire = item[CLAIMED_ITEM_WIRE];
-  const leaseToken = import_node_buffer56.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,
@@ -17365,15 +18198,15 @@ function snapshotClaimedItem(item) {
 function snapshotFencedItem(item) {
   return Object.freeze({
     ...item,
-    ...item.leaseToken == null ? {} : { leaseToken: import_node_buffer56.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_buffer56.Buffer.from(wire.id),
+    id: import_node_buffer60.Buffer.from(wire.id),
     leaseToken,
-    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer56.Buffer.from(wire.partitionKey)
+    partitionKey: wire.partitionKey == null ? wire.partitionKey : import_node_buffer60.Buffer.from(wire.partitionKey)
   });
 }
 function snapshotArray(values) {
@@ -17384,7 +18217,7 @@ function snapshotArray(values) {
   return Object.freeze(snapshot);
 }
 function snapshotStateMeta(stateMeta) {
-  return snapshotRecord(stateMeta, (value) => import_node_buffer56.Buffer.isBuffer(value) ? import_node_buffer56.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();
@@ -17402,7 +18235,7 @@ function snapshotRecord(values, capture) {
 }
 function snapshotCommandArgument(value, seen) {
   if (typeof value !== "object" || value == null) return value;
-  if (import_node_buffer56.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer56.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;
@@ -18167,6 +19000,14 @@ var FerricStoreProducerClient = class extends FerricStoreClaimClient {
 var FerricStoreClient = class _FerricStoreClient extends FerricStoreProducerClient {
   static async fromUrl(url, options = {}) {
     const clientOptions = snapshotClientOptions(options);
+    const scheme = new URL(url).protocol;
+    if (scheme === "http:" || scheme === "https:") {
+      if (clientOptions.nativeOptions != null) {
+        throw new TypeError("nativeOptions are not valid for an HTTP FerricStore URL");
+      }
+      const executor2 = await HTTPAdapter.fromUrl(url, clientOptions.httpOptions);
+      return new _FerricStoreClient(executor2, clientOptions);
+    }
     const nativeOptions = snapshotNativeClientOptions(clientOptions.nativeOptions ?? {});
     const reconnectOptions = clientOptions.reconnect ?? nativeOptions.autoReconnect ?? true;
     const seeds = nativeOptions.seeds ?? [];
@@ -18390,7 +19231,7 @@ function nativeOptionsForBootstrap(options, signal) {
 }
 
 // src/flow-query-projection.ts
-var import_node_buffer57 = 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");
@@ -18460,7 +19301,7 @@ function projectFlowQuery(query, shape, ...fields) {
   }
   const base = stripOptionalTerminator(query);
   const result = `${base} RETURN ${shape.toUpperCase()} (${selectors.join(", ")})`;
-  if (import_node_buffer57.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;
@@ -18520,7 +19361,7 @@ function quoteName(value, allowPrivate) {
     throw new TypeError("Flow query projection metadata name must be text");
   }
   validateUnicodeScalarText2(value);
-  const size = import_node_buffer57.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`
@@ -18622,7 +19463,7 @@ var LeaseRenewalGuard = class {
     if (options.leaseRenewal === false) {
       return;
     }
-    const intervalMs = positiveInteger3(options.leaseRenewIntervalMs, Math.max(1, Math.trunc(leaseMs / 2)));
+    const intervalMs = positiveInteger4(options.leaseRenewIntervalMs, Math.max(1, Math.trunc(leaseMs / 2)));
     this.timer = setLongInterval(() => this.renew(), intervalMs);
     this.timer.unref();
   }
@@ -18694,7 +19535,7 @@ function snapshotLeasedJob(job) {
   return snapshot;
 }
 function workerConcurrency(options) {
-  return positiveInteger3(options.concurrency ?? options.workers, 1);
+  return positiveInteger4(options.concurrency ?? options.workers, 1);
 }
 function workerRefillStrategy(options) {
   return options.refillStrategy === "wave" ? "wave" : "continuous";
@@ -18737,18 +19578,18 @@ function workerErrorPayload(error, options, codec) {
 }
 function workerBatchSize(options, flowManyBatchLimit = DEFAULT_FLOW_MANY_BATCH_LIMIT2) {
   return Math.min(
-    positiveInteger3(options.batchSize, 10),
-    positiveInteger3(flowManyBatchLimit, DEFAULT_FLOW_MANY_BATCH_LIMIT2)
+    positiveInteger4(options.batchSize, 10),
+    positiveInteger4(flowManyBatchLimit, DEFAULT_FLOW_MANY_BATCH_LIMIT2)
   );
 }
 function workerClaimLimit(options, flowManyBatchLimit = DEFAULT_FLOW_MANY_BATCH_LIMIT2) {
   return Math.min(workerBatchSize(options, flowManyBatchLimit), workerConcurrency(options));
 }
 function workerDrainBatches(options) {
-  return positiveInteger3(options.claimDrainBatches, 1);
+  return positiveInteger4(options.claimDrainBatches, 1);
 }
 function workerLeaseMs(options, fallback = 3e4) {
-  return positiveInteger3(options.leaseMs, positiveInteger3(fallback, 3e4));
+  return positiveInteger4(options.leaseMs, positiveInteger4(fallback, 3e4));
 }
 function workerIdleSleepMs(options) {
   return nonNegativeDuration(options.idleSleepMs, 250);
@@ -18760,7 +19601,7 @@ function workerClaimBlockMs(options, useBlocking) {
   if (options.signal == null || !Number.isFinite(options.blockMs) || options.blockMs < 0) {
     return options.blockMs;
   }
-  const abortPollMs = positiveInteger3(options.abortPollMs, 1e3);
+  const abortPollMs = positiveInteger4(options.abortPollMs, 1e3);
   return options.blockMs === 0 ? abortPollMs : Math.min(Math.trunc(options.blockMs), abortPollMs);
 }
 function workerMaxIdleSleepMs(options, idleSleepMs = workerIdleSleepMs(options)) {
@@ -18771,14 +19612,14 @@ function nextWorkerIdleSleepMs(currentIdleSleepMs, maxIdleSleepMs) {
   return Math.min(maxIdleSleepMs, Math.max(1, currentIdleSleepMs * 2));
 }
 async function runContinuousWorkerPool(options) {
-  const concurrency = positiveInteger3(options.concurrency, 1);
-  const maxClaimSize = positiveInteger3(options.maxClaimSize, concurrency);
+  const concurrency = positiveInteger4(options.concurrency, 1);
+  const maxClaimSize = positiveInteger4(options.maxClaimSize, concurrency);
   const initialIdleSleepMs = nonNegativeDuration(options.idleSleepMs, 250);
   const maxIdleSleepMs = Math.max(
     initialIdleSleepMs,
     nonNegativeDuration(options.maxIdleSleepMs, 5e3)
   );
-  const refillDelayMs = nonNegativeInteger4(options.refillDelayMs, 0);
+  const refillDelayMs = nonNegativeInteger5(options.refillDelayMs, 0);
   const active = /* @__PURE__ */ new Set();
   const pending = [];
   let pendingIndex = 0;
@@ -18894,10 +19735,10 @@ function normalizeWorkflowWorkerConfig(options) {
     ...captured
   });
 }
-function positiveInteger3(value, fallback) {
+function positiveInteger4(value, fallback) {
   return value == null || !Number.isFinite(value) ? fallback : Math.max(1, Math.trunc(value));
 }
-function nonNegativeInteger4(value, fallback) {
+function nonNegativeInteger5(value, fallback) {
   return value == null || !Number.isFinite(value) ? fallback : Math.max(0, Math.trunc(value));
 }
 function nonNegativeDuration(value, fallback) {
@@ -20526,7 +21367,7 @@ var WorkflowWorker = class {
 };
 
 // src/version.ts
-var FERRICSTORE_SDK_VERSION = "0.11.8";
+var FERRICSTORE_SDK_VERSION = "0.11.10";
 var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.11.4";
 var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 // Annotate the CommonJS export names for ESM import in node:
@@ -20550,6 +21391,8 @@ var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
   FlowQueryError,
   FlowWrongStateError,
   GeoStore,
+  HTTPAdapter,
+  HTTPTransportError,
   HashStore,
   HyperLogLogStore,
   InvalidCommandError,
@@ -20587,6 +21430,7 @@ var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
   classifyServerError,
   complete,
   fail,
+  httpCommandDisposition,
   isOutcome,
   isReconnectableClosedConnectionError,
   mapException,