@ferricstore/ferricstore 0.11.8 → 0.11.9

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;
@@ -8643,6 +8654,497 @@ var NativeAdapter = class _NativeAdapter {
   }
 };
 
+// src/http-command-policy.ts
+var nativeOnlyCommands = /* @__PURE__ */ new Set([
+  "AUTH",
+  "BACKPRESSURE",
+  "CLIENT",
+  "CLIENT.INFO",
+  "CLIENT.SETNAME",
+  "EVENT",
+  "GOAWAY",
+  "HELLO",
+  "OPTIONS",
+  "PIPELINE",
+  "QUIT",
+  "ROUTE",
+  "ROUTE_BATCH",
+  "SHARDS",
+  "STARTUP",
+  "SUBSCRIBE_EVENTS",
+  "UNSUBSCRIBE_EVENTS",
+  "WINDOW_UPDATE"
+]);
+var sessionOnlyCommands = /* @__PURE__ */ new Set([
+  "AUTH",
+  "BLMOVE",
+  "BLMPOP",
+  "BLPOP",
+  "BRPOP",
+  "CLIENT",
+  "DISCARD",
+  "EXEC",
+  "HELLO",
+  "MULTI",
+  "PSUBSCRIBE",
+  "PUNSUBSCRIBE",
+  "QUIT",
+  "SELECT",
+  "SUBSCRIBE",
+  "UNSUBSCRIBE",
+  "UNWATCH",
+  "WATCH",
+  "XREAD",
+  "XREADGROUP"
+]);
+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`);
+  }
+}
+
+// src/http-envelope.ts
+var import_node_buffer33 = 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({
+    encoding,
+    commands: commands.map((command) => encodeValue(command, 0))
+  }));
+}
+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) {
+  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 (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("HTTP command numbers must be finite");
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
+  }
+  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)
+    ]) };
+  }
+  if (isRecord(value)) {
+    return { [mapMarker]: Object.entries(value).map(([key, item]) => [
+      encodeValue(key, depth + 1),
+      encodeValue(item, depth + 1)
+    ]) };
+  }
+  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_buffer33.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);
+  return result;
+}
+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_buffer33.Buffer.isBuffer(value);
+}
+
+// src/http-options.ts
+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 = {};
+  for (const [rawName, value] of Object.entries(source)) {
+    const name = rawName.toLowerCase();
+    if (name === "" || !safeHeader(name) || !safeHeader(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 (!safeHeader(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 ${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");
+}
+
+// src/http-transport.ts
+var import_node_http = __toESM(require("http"), 1);
+var import_node_http2 = __toESM(require("http2"), 1);
+var import_node_https = __toESM(require("https"), 1);
+var import_node_buffer34 = require("buffer");
+var HTTPTransport = class {
+  constructor(config) {
+    this.config = config;
+    this.#httpAgent = new import_node_http.default.Agent({ keepAlive: true, maxSockets: config.maxConnections });
+    this.#httpsAgent = new import_node_https.default.Agent({
+      ...config.tlsOptions,
+      keepAlive: true,
+      maxSockets: config.maxConnections
+    });
+  }
+  config;
+  #httpAgent;
+  #httpsAgent;
+  #sessions = /* @__PURE__ */ new Map();
+  #closed = false;
+  async post(body) {
+    if (this.#closed) throw new HTTPTransportError("HTTP transport is closed");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    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", {
+          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 {
+      clearTimeout(timer);
+    }
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#httpAgent.destroy();
+    this.#httpsAgent.destroy();
+    for (const session of this.#sessions.values()) session.destroy();
+    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_http.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 session = this.session(url);
+    const headers = {
+      ...this.requestHeaders(body),
+      ":authority": url.host,
+      ":method": method,
+      ":path": `${url.pathname}${url.search}`,
+      ":scheme": url.protocol.slice(0, -1)
+    };
+    return await new Promise((resolve, reject) => {
+      const stream = session.request(headers);
+      let responseHeaders = {};
+      const abort = () => stream.close(import_node_http2.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));
+      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));
+    this.#sessions.set(origin, session);
+    return session;
+  }
+  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" }
+    };
+  }
+};
+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);
+    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_buffer34.Buffer.concat(chunks, size), headers, status };
+}
+function normalizeHeaders(headers) {
+  const result = {};
+  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 body = encodeHTTPCommands(commands.map((command) => httpCommand(command, this.#config.maxRequestBytes)));
+    if (body.byteLength > this.#config.maxRequestBytes) {
+      throw new HTTPTransportError("HTTP command request exceeds maxRequestBytes");
+    }
+    const response = await this.#transport.post(body);
+    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 httpCommand(command, maxRequestBytes) {
+  const protocol = buildProtocolCommand(command, maxRequestBytes, false);
+  if (protocol.opcode === OPCODES.commandExec) return command;
+  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 ?? {} };
+}
+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 = retryAfter == null || !/^\d+$/u.test(retryAfter) ? void 0 : Number(retryAfter) * 1e3;
+  return new HTTPTransportError(message, {
+    raw: details,
+    retryable: status === 408 || status === 425 || status === 429 || status >= 500,
+    retryAfterMs: retryAfterMs2,
+    safeToRetry: false,
+    statusCode: status
+  });
+}
+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 +9153,10 @@ function executeCommandArgs(executor, args) {
 }
 
 // src/reconnecting-executor.ts
-var import_node_buffer34 = require("buffer");
+var import_node_buffer36 = require("buffer");
 
 // src/command-retry-policy.ts
-var import_node_buffer33 = require("buffer");
+var import_node_buffer35 = require("buffer");
 function isCasMutation(args) {
   const offset = commandName2(args[0]) === "COMMAND_EXEC" ? 1 : 0;
   const name = commandName2(args[offset]);
@@ -8668,8 +9170,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_buffer35.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer35.Buffer.from(value).toString("utf8").toUpperCase();
   }
   return void 0;
 }
@@ -8881,15 +9383,15 @@ function normalizeNonNegativeInteger2(value, fallback) {
 }
 
 // src/topology.ts
-var import_node_buffer37 = require("buffer");
+var import_node_buffer39 = require("buffer");
 
 // src/topology-routing.ts
-var import_node_buffer36 = require("buffer");
+var import_node_buffer38 = require("buffer");
 
 // src/flow-partition-route-cache.ts
-var import_node_buffer35 = require("buffer");
+var import_node_buffer37 = require("buffer");
 var import_node_crypto = require("crypto");
-var AUTO_PREFIX = import_node_buffer35.Buffer.from("__flow_auto__:", "ascii");
+var AUTO_PREFIX = import_node_buffer37.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 +9401,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_buffer37.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_buffer37.Buffer.isBuffer(value) ? value : import_node_buffer37.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 +9478,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_buffer38.Buffer.isBuffer(value)) {
         return value;
       }
     }
@@ -9024,7 +9526,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_buffer38.Buffer.isBuffer(partition)) {
       const text3 = partition.toString("utf8").toUpperCase();
       if (text3 !== "AUTO" && text3 !== "MIXED") {
         return flowRoutingResult(flowLogicalPartitionRoutingKey(partition));
@@ -9115,17 +9617,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_buffer38.Buffer.isBuffer(value);
 }
 function flowAutoIdRoutingKey(value) {
-  if (typeof value !== "string" && !import_node_buffer36.Buffer.isBuffer(value)) {
+  if (typeof value !== "string" && !import_node_buffer38.Buffer.isBuffer(value)) {
     return void 0;
   }
-  const bucket = (import_node_buffer36.Buffer.isBuffer(value) ? crc32(value) : crc32Utf8(value)) & 255;
+  const bucket = (import_node_buffer38.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_buffer38.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 +9642,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_buffer38.Buffer.isBuffer(key))) {
     return void 0;
   }
   const usable = keys;
@@ -9173,7 +9675,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_buffer38.Buffer.isBuffer(key)) return void 0;
     const route = routeKey(key);
     const groupKey = `${route.endpointKey}\0${route.laneId}`;
     const group = groups.get(groupKey);
@@ -10262,7 +10764,7 @@ var TopologyNativeAdapterPool = class _TopologyNativeAdapterPool {
 };
 
 // src/response-map-preservation.ts
-var import_node_buffer38 = require("buffer");
+var import_node_buffer40 = require("buffer");
 function toStringKeyMapPreservingValues(value) {
   if (value == null) return void 0;
   const result = {};
@@ -10272,7 +10774,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_buffer40.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     for (const [key, item] of Object.entries(value)) {
       setOwnValue(result, text(key), normalizeMapStructurePreservingBytes(item));
     }
@@ -10281,7 +10783,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_buffer40.Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
   if (value instanceof Map) {
     const result = {};
     for (const [key, item] of value.entries()) {
@@ -10303,7 +10805,7 @@ function normalizeMapStructurePreservingBytes(value) {
 }
 
 // src/native-kv-responses.ts
-var import_node_buffer39 = require("buffer");
+var import_node_buffer41 = require("buffer");
 function rateLimitResultFromResp(value) {
   if (!Array.isArray(value) || value.length !== 4) {
     throw new TypeError("RATELIMIT.ADD returned an unexpected response");
@@ -10360,13 +10862,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_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));
   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_buffer41.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   const result = text(value);
@@ -10383,7 +10885,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_buffer41.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
     throw new TypeError(`${context} returned an unexpected response`);
   }
   return bytes(value);
@@ -11066,7 +11568,7 @@ function groupAutoPartitionItems(items) {
 }
 
 // src/client-values.ts
-var import_node_buffer40 = require("buffer");
+var import_node_buffer42 = require("buffer");
 async function valueMGetEntries(client, refs, options = {}) {
   const refCount = refs.length;
   if (refCount === 0) {
@@ -11101,12 +11603,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_buffer42.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_buffer42.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_buffer42.Buffer.from(item)) };
     } else {
       entries[index] = { found: true, value: item };
     }
@@ -11115,10 +11617,10 @@ async function valueMGetEntries(client, refs, options = {}) {
 }
 
 // src/auto-batch.ts
-var import_node_buffer42 = require("buffer");
+var import_node_buffer44 = require("buffer");
 
 // src/auto-batch-ordering.ts
-var import_node_buffer41 = require("buffer");
+var import_node_buffer43 = require("buffer");
 function autoBatchOrderingPlan(batch) {
   const accesses = /* @__PURE__ */ new Map();
   const fallbackDependencies = [];
@@ -11233,13 +11735,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_buffer43.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_buffer43.Buffer.isBuffer(command[itemIndex + (mixed ? 2 : 1)]) && isFencingToken(command[itemIndex + (mixed ? 3 : 2)])
   );
 }
 function createManyAutoBatchIds(command) {
@@ -11252,7 +11754,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_buffer43.Buffer.isBuffer(command[itemIndex + width - 1]),
         markerIndex
       );
       if (ids != null) return ids;
@@ -11270,7 +11772,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_buffer43.Buffer.isBuffer(command[cursor + 2])) return void 0;
     ids.push(id);
     cursor += 3;
     const afterValues = skipExtendedNamedItems(command, cursor, true);
@@ -11289,7 +11791,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_buffer43.Buffer.isBuffer(value) : !isAutoBatchResourceValue(value))) return void 0;
   }
   return firstItem + count * 2;
 }
@@ -11304,7 +11806,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_buffer43.Buffer.isBuffer(item)) return void 0;
       const id = item.id;
       if (!isAutoBatchResourceValue(id)) return void 0;
       ids.push(id);
@@ -11345,7 +11847,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_buffer43.Buffer.isBuffer(value);
 }
 function isFencingToken(value) {
   return typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint";
@@ -11354,7 +11856,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_buffer43.Buffer.from(value).toString("base64")}`;
 }
 function autoBatchCommandName(command) {
   return commandView(command).name ?? null;
@@ -11763,13 +12265,13 @@ function claimFailure(error) {
 }
 
 // src/client-flow-support.ts
-var import_node_buffer55 = require("buffer");
+var import_node_buffer57 = require("buffer");
 
 // src/flow-query-builder.ts
-var import_node_buffer44 = require("buffer");
+var import_node_buffer46 = require("buffer");
 
 // src/flow-query-metadata.ts
-var import_node_buffer43 = require("buffer");
+var import_node_buffer45 = require("buffer");
 var MAX_FLOW_QUERY_METADATA_KEY_BYTES = 64;
 function normalizeStateMeta(value, state) {
   if (value == null) return {};
@@ -11794,7 +12296,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_buffer45.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 +12320,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_buffer45.Buffer.isBuffer(value)) {
     return false;
   }
   const prototype = Object.getPrototypeOf(value);
@@ -11888,7 +12390,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_buffer46.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 +12569,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_buffer46.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 +12617,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_buffer46.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_buffer50 = require("buffer");
 
 // src/flow-query-diagnostic-response.ts
-var import_node_buffer46 = require("buffer");
+var import_node_buffer48 = require("buffer");
 
 // src/flow-query-response-validation.ts
-var import_node_buffer45 = require("buffer");
+var import_node_buffer47 = 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_buffer47.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     throw decodeError(`${context} must be a map`, value);
   }
   return value;
@@ -12188,7 +12690,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_buffer47.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 +12769,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_buffer47.Buffer.byteLength(value, "utf8") > maximumBytes) {
     throw decodeError(
       `${context} ${name} exceeds ${maximumBytes} bytes`,
       mapping2
@@ -12280,7 +12782,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_buffer47.Buffer.byteLength(decoded, "utf8") > maximumBytes) {
     throw decodeError(`${context} exceeds ${maximumBytes} bytes`, value);
   }
   return decoded;
@@ -12292,7 +12794,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 +12803,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 +12836,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_buffer47.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_buffer47.Buffer.isBuffer(key) && key.equals(binaryName)) return true;
+    if (key instanceof Uint8Array && import_node_buffer47.Buffer.from(key).equals(binaryName))
       return true;
   }
   return false;
@@ -12348,7 +12850,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_buffer47.Buffer.isBuffer(value) || value instanceof Uint8Array) {
     try {
       return new TextDecoder("utf-8", { fatal: true }).decode(value);
     } catch {
@@ -12412,7 +12914,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 +12930,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_buffer48.Buffer.byteLength(value, "utf8") > DIAGNOSTIC_TEXT_BYTES) {
     throw decodeError(
       `FLOW.QUERY diagnostic ${name} exceeds ${DIAGNOSTIC_TEXT_BYTES} bytes`,
       mapping2
@@ -12463,7 +12965,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_buffer48.Buffer.byteLength(text3, "utf8") <= DIAGNOSTIC_TEXT_BYTES) return;
     throw decodeError("FLOW.QUERY diagnostic context contains oversized text", value);
   }
   if (depth <= 0) {
@@ -12489,7 +12991,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_buffer48.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 +13008,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_buffer48.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return void 0;
   try {
     return new TextDecoder("utf-8", { fatal: true }).decode(value);
   } catch {
@@ -12522,9 +13024,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 +13034,7 @@ function decodePosition(value) {
 }
 
 // src/flow-query-index-contract.ts
-var import_node_buffer47 = require("buffer");
+var import_node_buffer49 = require("buffer");
 var FLOW_QUERY_BUILD_PHASES = ["pending", "snapshot", "backfill", "done"];
 var FLOW_QUERY_VALIDATION_PHASES = [
   "pending",
@@ -12778,10 +13280,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_buffer49.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_buffer49.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 +13793,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 +14175,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 +14190,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_buffer50.Buffer.byteLength(cursor) < 16 || import_node_buffer50.Buffer.byteLength(cursor) > 4096)) {
     throw decodeError("FLOW.QUERY page cursor is invalid", value);
   }
   if (hasMore !== (cursor != null)) {
@@ -13698,12 +14200,12 @@ function decodePage(value) {
 }
 
 // src/client-core.ts
-var import_node_buffer53 = require("buffer");
+var import_node_buffer55 = require("buffer");
 
 // src/client-core-helpers.ts
-var import_node_buffer49 = require("buffer");
+var import_node_buffer51 = 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_buffer51.Buffer.isBuffer(response) || response instanceof Uint8Array) && text(response) === "Background saving started") {
     return true;
   }
   return okResponse(response);
@@ -13717,7 +14219,7 @@ function fetchOrComputeCompletionToken(options) {
       "fetch-or-compute completion requires computeToken"
     );
   }
-  if (!import_node_buffer49.Buffer.isBuffer(options.computeToken)) {
+  if (!import_node_buffer51.Buffer.isBuffer(options.computeToken)) {
     throw new TypeError("fetch-or-compute computeToken must be a Buffer");
   }
   return options.computeToken;
@@ -13740,10 +14242,10 @@ function unsupportedClientCaching() {
 }
 
 // src/client-base.ts
-var import_node_buffer51 = require("buffer");
+var import_node_buffer53 = require("buffer");
 
 // src/client-executor.ts
-var import_node_buffer50 = require("buffer");
+var import_node_buffer52 = require("buffer");
 var ErrorMappingExecutor = class {
   constructor(executor) {
     this.executor = executor;
@@ -13808,7 +14310,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 +14586,14 @@ var FerricStoreAdministrationClient = class extends FerricStoreClientBase {
 };
 
 // src/store-utilities.ts
-var import_node_buffer52 = require("buffer");
+var import_node_buffer54 = 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_buffer54.Buffer.isBuffer(value)) return codec.decode(value);
+  if (value instanceof Uint8Array) return codec.decode(import_node_buffer54.Buffer.from(value));
   return value;
 }
 function number(value) {
@@ -14105,7 +14614,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 +14902,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 +14941,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 +14986,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 +15069,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 +15160,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 +15552,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 +16560,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 +16624,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 +16653,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 +16716,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 +16738,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 +17449,7 @@ function throwIfClosed(signal) {
 }
 
 // src/flow-policy.ts
-var import_node_buffer54 = require("buffer");
+var import_node_buffer56 = 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 +17467,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 +17485,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 +17498,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 +17539,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_buffer56.Buffer.isBuffer(value) && !(value instanceof Uint8Array)) return value;
   throw new TypeError(`${context} returned an unexpected response`);
 }
 function optionalRecord(value, context) {
@@ -17051,15 +17560,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_buffer56.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return import_node_buffer56.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 +17580,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 +17817,7 @@ var FerricStoreFlowSupportClient = class extends FerricStoreFlowQueryClient {
 };
 
 // src/flow-many-snapshot.ts
-var import_node_buffer56 = require("buffer");
+var import_node_buffer58 = require("buffer");
 var encodedOptionFields = ["error", "payload", "reason", "result"];
 function snapshotCreateItem(item, codec) {
   const snapshot = {
@@ -17348,7 +17857,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_buffer58.Buffer.from(wire?.leaseToken ?? item.leaseToken);
   const snapshot = {
     ...item,
     fencingToken: wire?.fencingToken ?? item.fencingToken,
@@ -17365,15 +17874,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_buffer58.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_buffer58.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_buffer58.Buffer.from(wire.partitionKey)
   });
 }
 function snapshotArray(values) {
@@ -17384,7 +17893,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_buffer58.Buffer.isBuffer(value) ? import_node_buffer58.Buffer.from(value) : value);
 }
 function snapshotCommandRecord(values) {
   const seen = /* @__PURE__ */ new WeakMap();
@@ -17402,7 +17911,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_buffer58.Buffer.isBuffer(value) || value instanceof Uint8Array) return import_node_buffer58.Buffer.from(value);
   const objectValue = value;
   const existing = seen.get(objectValue);
   if (existing != null) return existing;
@@ -18167,6 +18676,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 +18907,7 @@ function nativeOptionsForBootstrap(options, signal) {
 }
 
 // src/flow-query-projection.ts
-var import_node_buffer57 = require("buffer");
+var import_node_buffer59 = require("buffer");
 var MAX_PROJECTION_FIELDS = 32;
 var MAX_DYNAMIC_NAME_BYTES = 64;
 var FIELD_BRAND = /* @__PURE__ */ Symbol("FerricStoreFlowProjectionField");
@@ -18460,7 +18977,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_buffer59.Buffer.byteLength(result, "utf8") > FLOW_QUERY_MAX_BYTES) {
     throw new TypeError(`FLOW.QUERY query exceeds ${FLOW_QUERY_MAX_BYTES} bytes`);
   }
   return result;
@@ -18520,7 +19037,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_buffer59.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 +19139,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 +19211,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 +19254,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 +19277,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 +19288,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 +19411,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 +21043,7 @@ var WorkflowWorker = class {
 };
 
 // src/version.ts
-var FERRICSTORE_SDK_VERSION = "0.11.8";
+var FERRICSTORE_SDK_VERSION = "0.11.9";
 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 +21067,8 @@ var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
   FlowQueryError,
   FlowWrongStateError,
   GeoStore,
+  HTTPAdapter,
+  HTTPTransportError,
   HashStore,
   HyperLogLogStore,
   InvalidCommandError,
@@ -20587,6 +21106,7 @@ var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
   classifyServerError,
   complete,
   fail,
+  httpCommandDisposition,
   isOutcome,
   isReconnectableClosedConnectionError,
   mapException,