@ferricstore/ferricstore 0.5.2 → 0.11.5

package/dist/index.cjs

@@ -3187,6 +3187,7 @@ var FLOW_ADMIN_FIELDS = {
   AT_MS: "at_ms",
   BLOCK: "block_ms",
   BLOCK_MS: "block_ms",
+  CATCHUP_POLICY: "catchup_policy",
   CONSISTENT_PROJECTION: "consistent_projection",
   CORRELATION_ID: "correlation_id",
   COUNT: "count",
@@ -4631,7 +4632,7 @@ function compactKeyPipelinePayload(opcode, args, mode, maxBodyBytes) {
   }
   return { flags: FLAG_CUSTOM_PAYLOAD, opcode, payload: out };
 }
-function compactPipelinePayload(commands, maxBodyBytes) {
+function compactPipelinePayload(commands, maxBodyBytes, allowStreamXAdd = true, allowPubSubPublish = true) {
   if (commands.length === 0) {
     assertCompactPayloadFits(6, maxBodyBytes);
     const out = import_node_buffer14.Buffer.allocUnsafe(6);
@@ -4643,8 +4644,115 @@ function compactPipelinePayload(commands, maxBodyBytes) {
   }
   if (commandNameIs(commands[0]?.[0], "SET")) return compactSetPipelinePayload(commands, maxBodyBytes);
   if (commandNameIs(commands[0]?.[0], "GET")) return compactGetPipelinePayload(commands, maxBodyBytes);
+  if (commandNameIs(commands[0]?.[0], "XADD")) {
+    return allowStreamXAdd ? compactStreamXAddPipelinePayload(commands, maxBodyBytes) : void 0;
+  }
+  if (commandNameIs(commands[0]?.[0], "PUBLISH")) {
+    return allowPubSubPublish ? compactPubSubPublishPipelinePayload(commands, maxBodyBytes) : void 0;
+  }
   return void 0;
 }
+function compactPubSubPublishPipelinePayload(commands, maxBodyBytes) {
+  const minimum = 6 + commands.length * 8;
+  if (!compactPayloadFits(minimum, maxBodyBytes)) {
+    if (!compactPipelineEligible(commands, "PUBLISH", 3)) return void 0;
+    assertCompactPayloadFits(minimum, maxBodyBytes);
+  }
+  const argumentByteLengths = new Uint32Array(commands.length * 2);
+  const argumentValues = new Array(commands.length * 2);
+  let total = 6;
+  for (let index = 0; index < commands.length; index += 1) {
+    const command = commands[index];
+    if (!Object.hasOwn(commands, index) || !Array.isArray(command)) {
+      throw new TypeError("pipeline commands must be a dense array of command arrays");
+    }
+    if (command.length !== 3 || !Object.hasOwn(command, 0) || !Object.hasOwn(command, 1) || !Object.hasOwn(command, 2)) {
+      if (command.length === 3) throw new TypeError("pipeline command arguments must be dense");
+      return void 0;
+    }
+    if (!commandNameIs(command[0], "PUBLISH")) return void 0;
+    const channel = command[1];
+    const message = command[2];
+    if (!isCompactBinaryScalar(channel) || !isCompactBinaryScalar(message)) return void 0;
+    const channelByteLength = compactBinaryByteLength(channel);
+    const messageByteLength = compactBinaryByteLength(message);
+    argumentValues[index * 2] = channel;
+    argumentValues[index * 2 + 1] = message;
+    argumentByteLengths[index * 2] = channelByteLength;
+    argumentByteLengths[index * 2 + 1] = messageByteLength;
+    total += 8 + channelByteLength + messageByteLength;
+  }
+  assertCompactPayloadFits(total, maxBodyBytes);
+  const out = import_node_buffer14.Buffer.allocUnsafe(total);
+  let offset = writeCompactPipelineHeader(out, 128 | 35, commands.length);
+  for (let index = 0; index < commands.length; index += 1) {
+    offset = writeBinaryValue(
+      out,
+      offset,
+      argumentValues[index * 2],
+      argumentByteLengths[index * 2] ?? 0
+    );
+    offset = writeBinaryValue(
+      out,
+      offset,
+      argumentValues[index * 2 + 1],
+      argumentByteLengths[index * 2 + 1] ?? 0
+    );
+  }
+  return out;
+}
+function compactStreamXAddPipelinePayload(commands, maxBodyBytes) {
+  let argumentCount = 0;
+  let minimum = 6;
+  for (const command of commands) {
+    if (!Array.isArray(command)) {
+      throw new TypeError("pipeline commands must be a dense array of command arrays");
+    }
+    if (command.length < 5 || (command.length - 3) % 2 !== 0) return void 0;
+    for (let argumentIndex = 0; argumentIndex < command.length; argumentIndex += 1) {
+      if (!Object.hasOwn(command, argumentIndex)) {
+        throw new TypeError("pipeline command arguments must be dense");
+      }
+    }
+    if (!commandTokenIs(command[0], "XADD") || !commandTokenIs(command[2], "*")) return void 0;
+    if ((command.length - 3) / 2 > 65535) return void 0;
+    for (let argumentIndex = 1; argumentIndex < command.length; argumentIndex += 1) {
+      if (argumentIndex !== 2 && !isCompactBinaryScalar(command[argumentIndex])) return void 0;
+    }
+    argumentCount += command.length - 2;
+    minimum += 2 + (command.length - 2) * 4;
+  }
+  assertCompactPayloadFits(minimum, maxBodyBytes);
+  const byteLengths = new Uint32Array(argumentCount);
+  let lengthIndex = 0;
+  let total = 6;
+  for (const command of commands) {
+    total += 2;
+    for (let argumentIndex = 1; argumentIndex < command.length; argumentIndex += 1) {
+      if (argumentIndex === 2) continue;
+      const value = command[argumentIndex];
+      const byteLength = compactBinaryByteLength(value);
+      byteLengths[lengthIndex] = byteLength;
+      lengthIndex += 1;
+      total += 4 + byteLength;
+    }
+  }
+  assertCompactPayloadFits(total, maxBodyBytes);
+  const out = import_node_buffer14.Buffer.allocUnsafe(total);
+  let offset = writeCompactPipelineHeader(out, 128 | 34, commands.length);
+  lengthIndex = 0;
+  for (const command of commands) {
+    offset = writeBinaryValue(out, offset, command[1], byteLengths[lengthIndex] ?? 0);
+    lengthIndex += 1;
+    out.writeUInt16BE((command.length - 3) / 2, offset);
+    offset += 2;
+    for (let argumentIndex = 3; argumentIndex < command.length; argumentIndex += 1) {
+      offset = writeBinaryValue(out, offset, command[argumentIndex], byteLengths[lengthIndex] ?? 0);
+      lengthIndex += 1;
+    }
+  }
+  return out;
+}
 function compactSetPipelinePayload(commands, maxBodyBytes) {
   let total = 6;
   const minimum = total + commands.length * 8;
@@ -5226,10 +5334,19 @@ function decodeValueAt(data, offset, limits, budget, depth) {
     const count = data.readUInt32BE(offset);
     requireValueContainer(count, depth, limits, budget);
     offset += 4;
-    const values = [];
+    const values = new Array(count);
+    if (count === 3) {
+      const first = decodeValueAt(data, offset, limits, budget, depth + 1);
+      const second = decodeValueAt(data, first.offset, limits, budget, depth + 1);
+      const third = decodeValueAt(data, second.offset, limits, budget, depth + 1);
+      values[0] = first.value;
+      values[1] = second.value;
+      values[2] = third.value;
+      return { value: values, offset: third.offset };
+    }
     for (let index = 0; index < count; index += 1) {
       const read = decodeValueAt(data, offset, limits, budget, depth + 1);
-      values.push(read.value);
+      values[index] = read.value;
       offset = read.offset;
     }
     return { value: values, offset };
@@ -5546,6 +5663,8 @@ function nativeNegotiation(value) {
     compactResponseOpcodes: parseCompactResponseOpcodes(
       field(responseCodecs, "compact_response_opcodes")
     ),
+    compactPubSubPublish: strictUnsigned16(field(field(field(capabilities, "pipeline"), "modes"), "pubsub_publish")) === 35,
+    compactStreamXAdd: strictUnsigned16(field(field(field(capabilities, "pipeline"), "modes"), "stream_xadd_auto")) === 34,
     flowQuery: parseFlowQueryNegotiation(capabilities, schemas),
     ...maxResponseBytes == null ? {} : { maxResponseBytes }
   };
@@ -5620,15 +5739,15 @@ function requiredMap(value, context) {
   }
   throw incompatibleServer(`${context} is missing or invalid`);
 }
-function requiredBoundedText(mapping, name) {
-  const value = strictText(field(mapping, name));
+function requiredBoundedText(mapping2, name) {
+  const value = strictText(field(mapping2, name));
   if (value == null || value.length === 0 || import_node_buffer20.Buffer.byteLength(value) > 256) {
     throw incompatibleServer(`HELLO flow_query ${name} must be bounded non-empty text`);
   }
   return value;
 }
-function boundedTextSet(mapping, name, maximum) {
-  const raw = field(mapping, name);
+function boundedTextSet(mapping2, name, maximum) {
+  const raw = field(mapping2, name);
   if (!Array.isArray(raw) || raw.length < 1 || raw.length > maximum) {
     throw incompatibleServer(`HELLO ${name} must contain 1..${maximum} entries`);
   }
@@ -6838,8 +6957,13 @@ function buildProtocolCommand(args, maxBodyBytes = Number.MAX_SAFE_INTEGER, allo
   }
   return commandExec(args);
 }
-function tryPipelineCommand(commands, maxBodyBytes = Number.MAX_SAFE_INTEGER) {
-  const compact = compactPipelinePayload(commands, maxBodyBytes);
+function tryPipelineCommand(commands, maxBodyBytes = Number.MAX_SAFE_INTEGER, allowStreamXAdd = true, allowPubSubPublish = true) {
+  const compact = compactPipelinePayload(
+    commands,
+    maxBodyBytes,
+    allowStreamXAdd,
+    allowPubSubPublish
+  );
   if (compact != null) {
     return {
       compactResponseItems: commands.length,
@@ -6951,15 +7075,15 @@ function snapshotOwnStringArray(values, name) {
 
 // src/client-native-options.ts
 function snapshotNativeClientOptions(options) {
-  const own = { ...options };
+  const own2 = { ...options };
   const snapshot = {
-    ...own,
-    ...typeof own.autoReconnect === "object" && own.autoReconnect != null ? { autoReconnect: Object.freeze({ ...own.autoReconnect }) } : {},
-    ...own.endpointPolicy == null ? {} : { endpointPolicy: snapshotEndpointPolicy(own.endpointPolicy) },
-    ...own.events == null ? {} : { events: snapshotOwnStringArray(own.events, "events") },
-    ...own.seeds == null ? {} : { seeds: snapshotOwnStringArray(own.seeds, "seeds") },
-    ...own.tlsOptions == null ? {} : { tlsOptions: snapshotTlsOptions(own.tlsOptions) },
-    ...own.trustedHosts == null ? {} : { trustedHosts: snapshotOwnStringArray(own.trustedHosts, "trustedHosts") }
+    ...own2,
+    ...typeof own2.autoReconnect === "object" && own2.autoReconnect != null ? { autoReconnect: Object.freeze({ ...own2.autoReconnect }) } : {},
+    ...own2.endpointPolicy == null ? {} : { endpointPolicy: snapshotEndpointPolicy(own2.endpointPolicy) },
+    ...own2.events == null ? {} : { events: snapshotOwnStringArray(own2.events, "events") },
+    ...own2.seeds == null ? {} : { seeds: snapshotOwnStringArray(own2.seeds, "seeds") },
+    ...own2.tlsOptions == null ? {} : { tlsOptions: snapshotTlsOptions(own2.tlsOptions) },
+    ...own2.trustedHosts == null ? {} : { trustedHosts: snapshotOwnStringArray(own2.trustedHosts, "trustedHosts") }
   };
   return Object.freeze(snapshot);
 }
@@ -7000,12 +7124,12 @@ function topologyNativeOptions(options) {
 }
 function snapshotEndpointPolicy(policy) {
   if (typeof policy !== "object") return policy;
-  const own = { ...policy };
-  if (!Object.hasOwn(own, "allowHosts") || !Array.isArray(own.allowHosts)) {
+  const own2 = { ...policy };
+  if (!Object.hasOwn(own2, "allowHosts") || !Array.isArray(own2.allowHosts)) {
     throw new TypeError("endpointPolicy.allowHosts must be an own array of strings");
   }
   return Object.freeze({
-    allowHosts: snapshotOwnStringArray(own.allowHosts, "endpointPolicy.allowHosts")
+    allowHosts: snapshotOwnStringArray(own2.allowHosts, "endpointPolicy.allowHosts")
   });
 }
 function snapshotTlsOptions(options) {
@@ -7340,13 +7464,18 @@ function surfaceIndividualCommandErrors(results, rejected, hasRejected, options)
 }
 
 // src/native-pipeline-execution.ts
-async function executeNativeFusedPipeline(host, commands, laneId, options, maxPipelineCommands, maxRequestFrameBytes) {
+async function executeNativeFusedPipeline(host, commands, laneId, options, maxPipelineCommands, maxRequestFrameBytes, compactStreamXAdd = true, compactPubSubPublish = true) {
   commands = snapshotPipelineCommands(commands);
   options = snapshotPipelineOptions(options) ?? options;
   if (commands.length === 0) return [];
   if (maxPipelineCommands === 0 || commands.length > maxPipelineCommands) return void 0;
   try {
-    const pipeline = tryPipelineCommand(commands, maxRequestFrameBytes);
+    const pipeline = tryPipelineCommand(
+      commands,
+      maxRequestFrameBytes,
+      compactStreamXAdd,
+      compactPubSubPublish
+    );
     if (pipeline == null) return void 0;
     const response = await host.executeProtocolCommand(pipeline, laneId);
     return unwrapPipelineResponse(response, options, commands.length);
@@ -7355,7 +7484,7 @@ async function executeNativeFusedPipeline(host, commands, laneId, options, maxPi
     throw error;
   }
 }
-async function executeNativePipeline(host, commands, laneId, options, maxPipelineCommands, maxRequestFrameBytes) {
+async function executeNativePipeline(host, commands, laneId, options, maxPipelineCommands, maxRequestFrameBytes, compactStreamXAdd = true, compactPubSubPublish = true) {
   commands = snapshotPipelineCommands(commands);
   options = snapshotPipelineOptions(options) ?? options;
   if (commands.length === 0) return [];
@@ -7363,7 +7492,15 @@ async function executeNativePipeline(host, commands, laneId, options, maxPipelin
     return await executeIndividually(host, commands, laneId, pipelineFallbackOptions(commands, options));
   }
   if (commands.length <= maxPipelineCommands) {
-    return await executeChunk(host, commands, laneId, options, maxRequestFrameBytes);
+    return await executeChunk(
+      host,
+      commands,
+      laneId,
+      options,
+      maxRequestFrameBytes,
+      compactStreamXAdd,
+      compactPubSubPublish
+    );
   }
   const collectingOptions = pipelineErrorCollectingOptions(options);
   const results = new Array(commands.length);
@@ -7375,7 +7512,9 @@ async function executeNativePipeline(host, commands, laneId, options, maxPipelin
       chunk,
       laneId,
       pipelineSliceOptions(collectingOptions, start, start + chunk.length),
-      maxRequestFrameBytes
+      maxRequestFrameBytes,
+      compactStreamXAdd,
+      compactPubSubPublish
     );
     for (let index = 0; index < chunkResults.length; index += 1) results[start + index] = chunkResults[index];
     rejected = collectPipelineRejections(chunkResults, start, rejected);
@@ -7383,9 +7522,14 @@ async function executeNativePipeline(host, commands, laneId, options, maxPipelin
   if (rejected != null) attachPipelineItemRejectionFlags(results, rejected);
   return surfaceFirstPipelineItemError(results, options);
 }
-async function executeChunk(host, commands, laneId, options, maxRequestFrameBytes) {
+async function executeChunk(host, commands, laneId, options, maxRequestFrameBytes, compactStreamXAdd, compactPubSubPublish) {
   try {
-    const pipeline = tryPipelineCommand(commands, maxRequestFrameBytes);
+    const pipeline = tryPipelineCommand(
+      commands,
+      maxRequestFrameBytes,
+      compactStreamXAdd,
+      compactPubSubPublish
+    );
     if (pipeline != null) {
       const response = await host.executeProtocolCommand(pipeline, laneId);
       return unwrapPipelineResponse(response, options, commands.length);
@@ -7403,14 +7547,18 @@ async function executeChunk(host, commands, laneId, options, maxRequestFrameByte
       commands.slice(0, middle),
       laneId,
       pipelineSliceOptions(collectingOptions, 0, middle),
-      maxRequestFrameBytes
+      maxRequestFrameBytes,
+      compactStreamXAdd,
+      compactPubSubPublish
     );
     const second = await executeChunk(
       host,
       commands.slice(middle),
       laneId,
       pipelineSliceOptions(collectingOptions, middle, commands.length),
-      maxRequestFrameBytes
+      maxRequestFrameBytes,
+      compactStreamXAdd,
+      compactPubSubPublish
     );
     return surfaceFirstPipelineItemError(mergePipelineResults(first, second), options);
   }
@@ -8044,6 +8192,8 @@ var NativeConnectionCapabilities = class {
   }
   configuredRequestFrameBytes;
   compactResponseOpcodes = EMPTY_COMPACT_RESPONSE_OPCODES;
+  compactPubSubPublish = false;
+  compactStreamXAdd = false;
   flowQuery;
   requestFrameBytes;
   negotiatedRequestFrameBytes;
@@ -8051,6 +8201,8 @@ var NativeConnectionCapabilities = class {
     const limits = startupLimits(value);
     const negotiation = nativeNegotiation(value);
     this.compactResponseOpcodes = negotiation.compactResponseOpcodes;
+    this.compactPubSubPublish = negotiation.compactPubSubPublish;
+    this.compactStreamXAdd = negotiation.compactStreamXAdd;
     this.flowQuery = negotiation.flowQuery;
     if (limits.frameBytes != null) {
       this.negotiatedRequestFrameBytes = Math.min(
@@ -8276,7 +8428,9 @@ var NativeAdapter = class _NativeAdapter {
       laneId,
       options,
       this.maxPipelineCommands,
-      this.capabilities.requestFrameBytes
+      this.capabilities.requestFrameBytes,
+      this.capabilities.compactStreamXAdd,
+      this.capabilities.compactPubSubPublish
     );
   }
   /** @internal Execute an ordered pipeline on a topology-selected lane. */
@@ -8287,7 +8441,9 @@ var NativeAdapter = class _NativeAdapter {
       laneId,
       options,
       this.maxPipelineCommands,
-      this.capabilities.requestFrameBytes
+      this.capabilities.requestFrameBytes,
+      this.capabilities.compactStreamXAdd,
+      this.capabilities.compactPubSubPublish
     );
   }
   async close() {
@@ -12085,36 +12241,36 @@ function isPlainObject6(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function requireContract(mapping, name, expected, context) {
-  const actual = requiredText2(mapping, name, context);
+function requireContract(mapping2, name, expected, context) {
+  const actual = requiredText2(mapping2, name, context);
   if (actual !== expected) {
     throw decodeError(
       `${context} has unsupported contract ${JSON.stringify(actual)}`,
-      mapping
+      mapping2
     );
   }
 }
-function requiredText2(mapping, name, context) {
-  const value = strictText2(field(mapping, name));
+function requiredText2(mapping2, name, context) {
+  const value = strictText2(field(mapping2, name));
   if (value == null || value.length === 0) {
-    throw decodeError(`${context} ${name} must be non-empty text`, mapping);
+    throw decodeError(`${context} ${name} must be non-empty text`, mapping2);
   }
   return value;
 }
-function optionalText2(mapping, name, context) {
-  const raw = field(mapping, name);
+function optionalText2(mapping2, name, context) {
+  const raw = field(mapping2, name);
   if (raw == null) return void 0;
   const value = strictText2(raw);
   if (value == null)
-    throw decodeError(`${context} ${name} must be text`, mapping);
+    throw decodeError(`${context} ${name} must be text`, mapping2);
   return value;
 }
-function requiredBoundedText2(mapping, name, context, maximumBytes) {
-  const value = requiredText2(mapping, name, context);
+function requiredBoundedText2(mapping2, name, context, maximumBytes) {
+  const value = requiredText2(mapping2, name, context);
   if (import_node_buffer45.Buffer.byteLength(value, "utf8") > maximumBytes) {
     throw decodeError(
       `${context} ${name} exceeds ${maximumBytes} bytes`,
-      mapping
+      mapping2
     );
   }
   return value;
@@ -12129,10 +12285,10 @@ function boundedText(value, context, maximumBytes) {
   }
   return decoded;
 }
-function requiredBoolean(mapping, name, context) {
-  const value = field(mapping, name);
+function requiredBoolean(mapping2, name, context) {
+  const value = field(mapping2, name);
   if (typeof value !== "boolean") {
-    throw decodeError(`${context} ${name} must be boolean`, mapping);
+    throw decodeError(`${context} ${name} must be boolean`, mapping2);
   }
   return value;
 }
@@ -12175,11 +12331,11 @@ function positiveBoundedInteger(value, maximum, context) {
   if (parsed === 0) throw decodeError(`${context} must be positive`, value);
   return parsed;
 }
-function hasKey(mapping, name) {
-  if (!(mapping instanceof Map)) return Object.hasOwn(mapping, name);
-  if (mapping.has(name)) return true;
+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);
-  for (const key of mapping.keys()) {
+  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))
       return true;
@@ -12236,28 +12392,28 @@ var DIAGNOSTIC_CONTEXT_DEPTH = 6;
 var DIAGNOSTIC_CONTEXT_NODES = 512;
 function tryDecodeFlowQueryError(value, cause) {
   try {
-    const mapping = requiredMap2(value, "FLOW.QUERY diagnostic");
-    const context = decodeDiagnosticContext(field(mapping, "context"));
-    const position = decodePosition(field(mapping, "position"));
+    const mapping2 = requiredMap2(value, "FLOW.QUERY diagnostic");
+    const context = decodeDiagnosticContext(field(mapping2, "context"));
+    const position = decodePosition(field(mapping2, "position"));
     return new FlowQueryError({
       code: requiredBoundedText2(
-        mapping,
+        mapping2,
         "code",
         "FLOW.QUERY diagnostic",
         DIAGNOSTIC_TEXT_BYTES
       ),
       message: requiredBoundedText2(
-        mapping,
+        mapping2,
         "message",
         "FLOW.QUERY diagnostic",
         DIAGNOSTIC_TEXT_BYTES
       ),
-      detail: optionalDiagnosticText(mapping, "detail"),
-      hint: optionalDiagnosticText(mapping, "hint"),
-      retryable: requiredBoolean(mapping, "retryable", "FLOW.QUERY diagnostic"),
-      safeToRetry: requiredBoolean(mapping, "safe_to_retry", "FLOW.QUERY diagnostic"),
+      detail: optionalDiagnosticText(mapping2, "detail"),
+      hint: optionalDiagnosticText(mapping2, "hint"),
+      retryable: requiredBoolean(mapping2, "retryable", "FLOW.QUERY diagnostic"),
+      safeToRetry: requiredBoolean(mapping2, "safe_to_retry", "FLOW.QUERY diagnostic"),
       retryAfterMs: nonNegativeInteger(
-        field(mapping, "retry_after_ms"),
+        field(mapping2, "retry_after_ms"),
         "FLOW.QUERY diagnostic retry_after_ms"
       ),
       position,
@@ -12270,29 +12426,29 @@ function tryDecodeFlowQueryError(value, cause) {
     throw error;
   }
 }
-function optionalDiagnosticText(mapping, name) {
-  const value = optionalText2(mapping, name, "FLOW.QUERY diagnostic");
+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) {
     throw decodeError(
       `FLOW.QUERY diagnostic ${name} exceeds ${DIAGNOSTIC_TEXT_BYTES} bytes`,
-      mapping
+      mapping2
     );
   }
   return value;
 }
 function decodeDiagnosticContext(value) {
   if (value == null) return void 0;
-  const mapping = requiredMap2(value, "FLOW.QUERY diagnostic context");
-  const size = mapping instanceof Map ? mapping.size : Object.keys(mapping).length;
+  const mapping2 = requiredMap2(value, "FLOW.QUERY diagnostic context");
+  const size = mapping2 instanceof Map ? mapping2.size : Object.keys(mapping2).length;
   if (size > DIAGNOSTIC_CONTEXT_ENTRIES) {
     throw decodeError("FLOW.QUERY diagnostic context contains too many entries", value);
   }
   validateDiagnosticContextValue(
-    mapping,
+    mapping2,
     DIAGNOSTIC_CONTEXT_DEPTH,
     { remaining: DIAGNOSTIC_CONTEXT_NODES }
   );
-  return freezeMetadataMap(mapping, "FLOW.QUERY diagnostic context");
+  return freezeMetadataMap(mapping2, "FLOW.QUERY diagnostic context");
 }
 function validateDiagnosticContextValue(value, depth, budget) {
   consumeDiagnosticContextNode(value, budget);
@@ -12364,12 +12520,12 @@ function isDiagnosticContextRecord(value) {
 }
 function decodePosition(value) {
   if (value == null) return void 0;
-  const mapping = requiredMap2(value, "FLOW.QUERY diagnostic position");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY diagnostic position");
   return Object.freeze({
-    byte: positiveInteger(field(mapping, "byte"), "FLOW.QUERY diagnostic position byte"),
-    line: positiveInteger(field(mapping, "line"), "FLOW.QUERY diagnostic position line"),
+    byte: positiveInteger(field(mapping2, "byte"), "FLOW.QUERY diagnostic position byte"),
+    line: positiveInteger(field(mapping2, "line"), "FLOW.QUERY diagnostic position line"),
     column: positiveInteger(
-      field(mapping, "column"),
+      field(mapping2, "column"),
       "FLOW.QUERY diagnostic position column"
     )
   });
@@ -12669,25 +12825,25 @@ function decodeUniqueTextArray(value, context, maximum, maximumBytes) {
   }
   return Object.freeze(result);
 }
-function requiredChoice(mapping, name, context, choices) {
-  const value = requiredBoundedText2(mapping, name, context, 64);
+function requiredChoice(mapping2, name, context, choices) {
+  const value = requiredBoundedText2(mapping2, name, context, 64);
   if (!choices.includes(value)) {
-    throw decodeError(`${context} ${name} is unsupported`, mapping);
+    throw decodeError(`${context} ${name} is unsupported`, mapping2);
   }
   return value;
 }
-function optionalBoundedText(mapping, name, context, maximumBytes) {
-  const value = field(mapping, name);
+function optionalBoundedText(mapping2, name, context, maximumBytes) {
+  const value = field(mapping2, name);
   if (value == null) return void 0;
   return boundedText(value, `${context} ${name}`, maximumBytes);
 }
-function optionalIndexInteger(mapping, name, context) {
-  const value = field(mapping, name);
+function optionalIndexInteger(mapping2, name, context) {
+  const value = field(mapping2, name);
   return value == null ? void 0 : unsignedIndexInteger(value, `${context} ${name}`);
 }
-function indexCounter(mapping, name, section) {
+function indexCounter(mapping2, name, section) {
   return unsignedIndexInteger(
-    field(mapping, name),
+    field(mapping2, name),
     `FLOW.QUERY.INDEXES index ${section} ${name}`
   );
 }
@@ -12704,13 +12860,13 @@ function indexInteger2(value) {
 // src/flow-query-index-lifecycle-response.ts
 function decodeIndexCoverage(value) {
   const context = "FLOW.QUERY.INDEXES index coverage";
-  const mapping = requiredMap2(value, context);
+  const mapping2 = requiredMap2(value, context);
   const completeShards = unsignedIndexInteger(
-    field(mapping, "complete_shards"),
+    field(mapping2, "complete_shards"),
     `${context} complete_shards`
   );
   const totalShards = positiveIndexInteger(
-    field(mapping, "total_shards"),
+    field(mapping2, "total_shards"),
     `${context} total_shards`
   );
   if (indexInteger2(completeShards) > indexInteger2(totalShards)) {
@@ -12719,60 +12875,60 @@ function decodeIndexCoverage(value) {
   return Object.freeze({
     completeShards,
     totalShards,
-    validation: requiredChoice(mapping, "validation", context, [
+    validation: requiredChoice(mapping2, "validation", context, [
       "pending",
       "passed",
       "failed"
     ]),
-    raw: freezeMap(mapping)
+    raw: freezeMap(mapping2)
   });
 }
 function decodeIndexBuild(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY.INDEXES index build");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY.INDEXES index build");
   const progress = decodeIndexProgress(
-    mapping,
+    mapping2,
     "build",
     FLOW_QUERY_BUILD_PHASES
   );
   return Object.freeze({
     ...progress,
-    scannedRecords: indexCounter(mapping, "scanned_records", "build"),
-    writtenEntries: indexCounter(mapping, "written_entries", "build"),
-    writtenBytes: indexCounter(mapping, "written_bytes", "build")
+    scannedRecords: indexCounter(mapping2, "scanned_records", "build"),
+    writtenEntries: indexCounter(mapping2, "written_entries", "build"),
+    writtenBytes: indexCounter(mapping2, "written_bytes", "build")
   });
 }
 function decodeIndexValidation(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY.INDEXES index validation");
-  if (!hasKey(mapping, "failure_reason") || !hasKey(mapping, "validated_at_ms")) {
+  const mapping2 = requiredMap2(value, "FLOW.QUERY.INDEXES index validation");
+  if (!hasKey(mapping2, "failure_reason") || !hasKey(mapping2, "validated_at_ms")) {
     throw decodeError(
       "FLOW.QUERY.INDEXES index validation is missing nullable fields",
       value
     );
   }
   const progress = decodeIndexProgress(
-    mapping,
+    mapping2,
     "validation",
     FLOW_QUERY_VALIDATION_PHASES
   );
   return Object.freeze({
     ...progress,
     status: requiredChoice(
-      mapping,
+      mapping2,
       "status",
       "FLOW.QUERY.INDEXES index validation",
       ["pending", "passed", "failed"]
     ),
-    checkedRecords: indexCounter(mapping, "checked_records", "validation"),
-    checkedEntries: indexCounter(mapping, "checked_entries", "validation"),
-    mismatches: indexCounter(mapping, "mismatches", "validation"),
+    checkedRecords: indexCounter(mapping2, "checked_records", "validation"),
+    checkedEntries: indexCounter(mapping2, "checked_entries", "validation"),
+    mismatches: indexCounter(mapping2, "mismatches", "validation"),
     failureReason: optionalBoundedText(
-      mapping,
+      mapping2,
       "failure_reason",
       "FLOW.QUERY.INDEXES index validation",
       128
     ),
     validatedAtMs: optionalIndexInteger(
-      mapping,
+      mapping2,
       "validated_at_ms",
       "FLOW.QUERY.INDEXES index validation"
     )
@@ -12780,77 +12936,77 @@ function decodeIndexValidation(value) {
 }
 function decodeIndexRetirement(value) {
   const context = "FLOW.QUERY.INDEXES index retirement";
-  const mapping = requiredMap2(value, context);
-  const status = requiredChoice(mapping, "status", context, [
+  const mapping2 = requiredMap2(value, context);
+  const status = requiredChoice(mapping2, "status", context, [
     "not_applicable",
     "pending",
     "complete"
   ]);
   if (status === "not_applicable") {
-    return Object.freeze({ status, raw: freezeMap(mapping) });
+    return Object.freeze({ status, raw: freezeMap(mapping2) });
   }
   const completedShards = unsignedIndexInteger(
-    field(mapping, "completed_shards"),
+    field(mapping2, "completed_shards"),
     `${context} completed_shards`
   );
   const totalShards = positiveIndexInteger(
-    field(mapping, "total_shards"),
+    field(mapping2, "total_shards"),
     `${context} total_shards`
   );
   if (indexInteger2(completedShards) > indexInteger2(totalShards)) {
     throw decodeError(
       `${context} completed_shards exceeds total_shards`,
-      mapping
+      mapping2
     );
   }
   return Object.freeze({
     status,
     phaseCounts: decodePhaseCounts(
-      field(mapping, "phase_counts"),
+      field(mapping2, "phase_counts"),
       "retirement"
     ),
     currentPhases: decodeAllowedPhases(
-      field(mapping, "current_phases"),
+      field(mapping2, "current_phases"),
       "retirement",
       FLOW_QUERY_RETIREMENT_PHASES
     ),
     completedShards,
     totalShards,
-    deletedEntries: indexCounter(mapping, "deleted_entries", "retirement"),
-    deletedBytes: indexCounter(mapping, "deleted_bytes", "retirement"),
+    deletedEntries: indexCounter(mapping2, "deleted_entries", "retirement"),
+    deletedBytes: indexCounter(mapping2, "deleted_bytes", "retirement"),
     rewrittenReverseRows: indexCounter(
-      mapping,
+      mapping2,
       "rewritten_reverse_rows",
       "retirement"
     ),
-    raw: freezeMap(mapping)
+    raw: freezeMap(mapping2)
   });
 }
 function decodeIndexStatistics(value) {
   const context = "FLOW.QUERY.INDEXES index statistics";
-  const mapping = requiredMap2(value, context);
+  const mapping2 = requiredMap2(value, context);
   for (const name of [
     "oldest_collected_at_ms",
     "newest_collected_at_ms",
     "oldest_age_ms",
     "newest_age_ms"
   ]) {
-    if (!hasKey(mapping, name)) {
+    if (!hasKey(mapping2, name)) {
       throw decodeError(
         `${context} is missing required nullable fields`,
         value
       );
     }
   }
-  const samples = indexCounter(mapping, "samples", "statistics");
-  const freshSamples = indexCounter(mapping, "fresh_samples", "statistics");
-  const staleSamples = indexCounter(mapping, "stale_samples", "statistics");
-  const futureSamples = indexCounter(mapping, "future_samples", "statistics");
+  const samples = indexCounter(mapping2, "samples", "statistics");
+  const freshSamples = indexCounter(mapping2, "fresh_samples", "statistics");
+  const staleSamples = indexCounter(mapping2, "stale_samples", "statistics");
+  const futureSamples = indexCounter(mapping2, "future_samples", "statistics");
   if (indexInteger2(freshSamples) + indexInteger2(staleSamples) !== indexInteger2(samples) || indexInteger2(futureSamples) > indexInteger2(staleSamples)) {
     throw decodeError(`${context} counters are inconsistent`, value);
   }
   return Object.freeze({
-    status: requiredChoice(mapping, "status", context, [
+    status: requiredChoice(mapping2, "status", context, [
       "fresh",
       "stale",
       "future",
@@ -12863,53 +13019,53 @@ function decodeIndexStatistics(value) {
     staleSamples,
     futureSamples,
     oldestCollectedAtMs: optionalIndexInteger(
-      mapping,
+      mapping2,
       "oldest_collected_at_ms",
       context
     ),
     newestCollectedAtMs: optionalIndexInteger(
-      mapping,
+      mapping2,
       "newest_collected_at_ms",
       context
     ),
-    oldestAgeMs: optionalIndexInteger(mapping, "oldest_age_ms", context),
-    newestAgeMs: optionalIndexInteger(mapping, "newest_age_ms", context),
-    raw: freezeMap(mapping)
+    oldestAgeMs: optionalIndexInteger(mapping2, "oldest_age_ms", context),
+    newestAgeMs: optionalIndexInteger(mapping2, "newest_age_ms", context),
+    raw: freezeMap(mapping2)
   });
 }
-function decodeIndexProgress(mapping, section, allowedPhases) {
+function decodeIndexProgress(mapping2, section, allowedPhases) {
   const context = `FLOW.QUERY.INDEXES index ${section}`;
   const completedShards = unsignedIndexInteger(
-    field(mapping, "completed_shards"),
+    field(mapping2, "completed_shards"),
     `${context} completed_shards`
   );
   const totalShards = positiveIndexInteger(
-    field(mapping, "total_shards"),
+    field(mapping2, "total_shards"),
     `${context} total_shards`
   );
   if (indexInteger2(completedShards) > indexInteger2(totalShards)) {
     throw decodeError(
       `${context} completed_shards exceeds total_shards`,
-      mapping
+      mapping2
     );
   }
   return Object.freeze({
-    scope: requiredChoice(mapping, "scope", context, ["catalog_build"]),
-    phaseCounts: decodePhaseCounts(field(mapping, "phase_counts"), section),
+    scope: requiredChoice(mapping2, "scope", context, ["catalog_build"]),
+    phaseCounts: decodePhaseCounts(field(mapping2, "phase_counts"), section),
     currentPhases: decodeAllowedPhases(
-      field(mapping, "current_phases"),
+      field(mapping2, "current_phases"),
       section,
       allowedPhases
     ),
     completedShards,
     totalShards,
-    raw: freezeMap(mapping)
+    raw: freezeMap(mapping2)
   });
 }
 function decodePhaseCounts(value, section) {
   const context = `FLOW.QUERY.INDEXES index ${section} phase_counts`;
-  const mapping = requiredMap2(value, context);
-  const entries = mapping instanceof Map ? [...mapping.entries()] : Object.entries(mapping);
+  const mapping2 = requiredMap2(value, context);
+  const entries = mapping2 instanceof Map ? [...mapping2.entries()] : Object.entries(mapping2);
   if (entries.length > 16) {
     throw decodeError(`${context} contains too many entries`, value);
   }
@@ -12942,19 +13098,19 @@ function decodeAllowedPhases(value, section, allowed) {
 // src/flow-query-index-response.ts
 var FLOW_QUERY_INDEXES_CONTRACT = "ferric.flow.query.indexes/v1";
 function decodeFlowQueryIndexStatus(value, expectedId) {
-  const mapping = requiredMap2(value, "FLOW.QUERY.INDEXES");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY.INDEXES");
   requireContract(
-    mapping,
+    mapping2,
     "contract_version",
     FLOW_QUERY_INDEXES_CONTRACT,
     "FLOW.QUERY.INDEXES"
   );
   const registry = requiredMap2(
-    field(mapping, "registry"),
+    field(mapping2, "registry"),
     "FLOW.QUERY.INDEXES registry"
   );
-  const services = decodeIndexServices(field(mapping, "services"));
-  const rawIndexes = field(mapping, "indexes");
+  const services = decodeIndexServices(field(mapping2, "services"));
+  const rawIndexes = field(mapping2, "indexes");
   if (!Array.isArray(rawIndexes) || rawIndexes.length > 32) {
     throw decodeError(
       "FLOW.QUERY.INDEXES indexes must contain at most 32 entries",
@@ -12974,11 +13130,11 @@ function decodeFlowQueryIndexStatus(value, expectedId) {
   const status = Object.freeze({
     contractVersion: FLOW_QUERY_INDEXES_CONTRACT,
     observedAtMs: unsignedIndexInteger(
-      field(mapping, "observed_at_ms"),
+      field(mapping2, "observed_at_ms"),
       "FLOW.QUERY.INDEXES observed_at_ms"
     ),
     statisticsMaxAgeMs: unsignedIndexInteger(
-      field(mapping, "statistics_max_age_ms"),
+      field(mapping2, "statistics_max_age_ms"),
       "FLOW.QUERY.INDEXES statistics_max_age_ms"
     ),
     registry: Object.freeze({
@@ -12993,30 +13149,30 @@ function decodeFlowQueryIndexStatus(value, expectedId) {
     }),
     services,
     indexes: Object.freeze(indexes),
-    raw: freezeMap(mapping)
+    raw: freezeMap(mapping2)
   });
   validateFlowQueryIndexContract(status, expectedId);
   return status;
 }
 function decodeIndex(value, index) {
-  const mapping = requiredMap2(value, `FLOW.QUERY.INDEXES index ${index}`);
-  const fields = decodeIndexFields(field(mapping, "fields"));
+  const mapping2 = requiredMap2(value, `FLOW.QUERY.INDEXES index ${index}`);
+  const fields = decodeIndexFields(field(mapping2, "fields"));
   return Object.freeze({
-    id: requiredBoundedText2(mapping, "id", "FLOW.QUERY.INDEXES index", 64),
+    id: requiredBoundedText2(mapping2, "id", "FLOW.QUERY.INDEXES index", 64),
     version: positiveIndexInteger(
-      field(mapping, "version"),
+      field(mapping2, "version"),
       "FLOW.QUERY.INDEXES index version"
     ),
     buildId: requiredBoundedText2(
-      mapping,
+      mapping2,
       "build_id",
       "FLOW.QUERY.INDEXES index",
       128
     ),
-    source: requiredChoice(mapping, "source", "FLOW.QUERY.INDEXES index", [
+    source: requiredChoice(mapping2, "source", "FLOW.QUERY.INDEXES index", [
       "runs"
     ]),
-    state: requiredChoice(mapping, "state", "FLOW.QUERY.INDEXES index", [
+    state: requiredChoice(mapping2, "state", "FLOW.QUERY.INDEXES index", [
       "building",
       "validating",
       "active",
@@ -13024,60 +13180,60 @@ function decodeIndex(value, index) {
       "failed"
     ]),
     queryable: requiredBoolean(
-      mapping,
+      mapping2,
       "queryable",
       "FLOW.QUERY.INDEXES index"
     ),
     fields,
     workloads: decodeUniqueTextArray(
-      field(mapping, "workloads"),
+      field(mapping2, "workloads"),
       "FLOW.QUERY.INDEXES index workloads",
       16,
       64
     ),
     countPrefixes: decodeCountPrefixes(
-      field(mapping, "count_prefixes"),
+      field(mapping2, "count_prefixes"),
       fields.length
     ),
-    coveringFields: decodeCoveringFields(mapping),
-    format: decodeIndexFormat(mapping),
-    coverage: decodeIndexCoverage(field(mapping, "coverage")),
-    build: decodeIndexBuild(field(mapping, "build")),
-    validation: decodeIndexValidation(field(mapping, "validation")),
-    retirement: decodeIndexRetirement(field(mapping, "retirement")),
-    statistics: decodeIndexStatistics(field(mapping, "statistics")),
-    raw: freezeMap(mapping)
+    coveringFields: decodeCoveringFields(mapping2),
+    format: decodeIndexFormat(mapping2),
+    coverage: decodeIndexCoverage(field(mapping2, "coverage")),
+    build: decodeIndexBuild(field(mapping2, "build")),
+    validation: decodeIndexValidation(field(mapping2, "validation")),
+    retirement: decodeIndexRetirement(field(mapping2, "retirement")),
+    statistics: decodeIndexStatistics(field(mapping2, "statistics")),
+    raw: freezeMap(mapping2)
   });
 }
 function decodeIndexServices(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY.INDEXES services");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY.INDEXES services");
   const choices = ["ready", "unavailable"];
   return Object.freeze({
     registry: requiredChoice(
-      mapping,
+      mapping2,
       "registry",
       "FLOW.QUERY.INDEXES services",
       choices
     ),
     lifecycleWorker: requiredChoice(
-      mapping,
+      mapping2,
       "lifecycle_worker",
       "FLOW.QUERY.INDEXES services",
       choices
     ),
     statisticsStore: requiredChoice(
-      mapping,
+      mapping2,
       "statistics_store",
       "FLOW.QUERY.INDEXES services",
       choices
     ),
     statisticsWorker: requiredChoice(
-      mapping,
+      mapping2,
       "statistics_worker",
       "FLOW.QUERY.INDEXES services",
       choices
     ),
-    raw: freezeMap(mapping)
+    raw: freezeMap(mapping2)
   });
 }
 function decodeIndexFields(value) {
@@ -13091,12 +13247,12 @@ function decodeIndexFields(value) {
     if (!Object.hasOwn(value, index)) {
       throw decodeError(`${context} must be dense`, value);
     }
-    const mapping = requiredMap2(
+    const mapping2 = requiredMap2(
       value[index],
       `FLOW.QUERY.INDEXES index field ${index}`
     );
     const name = requiredBoundedText2(
-      mapping,
+      mapping2,
       "name",
       "FLOW.QUERY.INDEXES index field",
       512
@@ -13108,18 +13264,18 @@ function decodeIndexFields(value) {
     fields[index] = Object.freeze({
       name,
       direction: requiredChoice(
-        mapping,
+        mapping2,
         "direction",
         "FLOW.QUERY.INDEXES index field",
         ["asc", "desc"]
       ),
       encoding: requiredChoice(
-        mapping,
+        mapping2,
         "encoding",
         "FLOW.QUERY.INDEXES index field",
         ["hashed", "ordered"]
       ),
-      raw: freezeMap(mapping)
+      raw: freezeMap(mapping2)
     });
   }
   return Object.freeze(fields);
@@ -13144,8 +13300,8 @@ function decodeCountPrefixes(value, fieldCount) {
   }
   return Object.freeze(prefixes);
 }
-function decodeCoveringFields(mapping) {
-  const raw = field(mapping, "covering_fields");
+function decodeCoveringFields(mapping2) {
+  const raw = field(mapping2, "covering_fields");
   if (!Array.isArray(raw) || raw.length > 32) {
     throw decodeError(
       "FLOW.QUERY.INDEXES index covering_fields must contain at most 32 entries",
@@ -13177,9 +13333,9 @@ function decodeCoveringFields(mapping) {
   }
   return Object.freeze(fields);
 }
-function decodeIndexFormat(mapping) {
+function decodeIndexFormat(mapping2) {
   const raw = requiredMap2(
-    field(mapping, "format"),
+    field(mapping2, "format"),
     "FLOW.QUERY.INDEXES index format"
   );
   if (!hasKey(raw, "counter")) {
@@ -13248,7 +13404,7 @@ var QUALITY_VALUES2 = {
   pagination: ["none", "complete", "authenticated_seek", "live_seek"]
 };
 function decodeFlowQueryResult(value) {
-  const result = decodeFlowQueryResponse(value, (mapping) => freezeMap(mapping));
+  const result = decodeFlowQueryResponse(value, (mapping2) => freezeMap(mapping2));
   if (result.kind === "records") {
     return Object.freeze({
       kind: "records",
@@ -13272,7 +13428,7 @@ function decodeFlowQueryResult(value) {
 function decodeFlowQueryRecords(value, decodeRecord) {
   const result = decodeFlowQueryResponse(
     value,
-    (mapping, index) => decodeRecord(mapping instanceof Map ? freezeMap(mapping) : mapping, index)
+    (mapping2, index) => decodeRecord(mapping2 instanceof Map ? freezeMap(mapping2) : mapping2, index)
   );
   if (result.kind === "count") {
     throw new FerricStoreError("Flow record convenience query returned a count result", {
@@ -13282,18 +13438,18 @@ function decodeFlowQueryRecords(value, decodeRecord) {
   return result.records;
 }
 function decodeFlowQueryResponse(value, decodeRecord) {
-  const mapping = requiredMap2(value, "FLOW.QUERY result");
-  requireContract(mapping, "version", FLOW_QUERY_RESULT_CONTRACT, "FLOW.QUERY result");
-  const quality = decodeQuality(field(mapping, "quality"));
-  const usage = decodeUsage(field(mapping, "usage"));
-  const hasRecords = hasKey(mapping, "records");
-  const hasCount = hasKey(mapping, "result");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY result");
+  requireContract(mapping2, "version", FLOW_QUERY_RESULT_CONTRACT, "FLOW.QUERY result");
+  const quality = decodeQuality(field(mapping2, "quality"));
+  const usage = decodeUsage(field(mapping2, "usage"));
+  const hasRecords = hasKey(mapping2, "records");
+  const hasCount = hasKey(mapping2, "result");
   if (hasRecords === hasCount) {
     throw decodeError("FLOW.QUERY result must contain exactly one records or count shape", value);
   }
-  const raw = freezeMap(mapping);
+  const raw = freezeMap(mapping2);
   if (hasRecords) {
-    const rawRecords = field(mapping, "records");
+    const rawRecords = field(mapping2, "records");
     if (!Array.isArray(rawRecords) || rawRecords.length > 100) {
       throw decodeError("FLOW.QUERY records must be an array of at most 100 maps", value);
     }
@@ -13313,16 +13469,16 @@ function decodeFlowQueryResponse(value, decodeRecord) {
     return {
       kind: "records",
       records,
-      page: decodePage(field(mapping, "page")),
+      page: decodePage(field(mapping2, "page")),
       quality,
       usage,
       raw
     };
   }
-  if (hasKey(mapping, "page")) {
+  if (hasKey(mapping2, "page")) {
     throw decodeError("FLOW.QUERY count result contains an unexpected page", value);
   }
-  const countResult = requiredMap2(field(mapping, "result"), "FLOW.QUERY count result");
+  const countResult = requiredMap2(field(mapping2, "result"), "FLOW.QUERY count result");
   if (requiredText2(countResult, "kind", "FLOW.QUERY count result") !== "count") {
     throw decodeError("FLOW.QUERY count result kind must be count", value);
   }
@@ -13343,31 +13499,31 @@ function decodeFlowQueryResponse(value, decodeRecord) {
   };
 }
 function decodeFlowExplainResult(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY explain");
-  requireContract(mapping, "version", FLOW_EXPLAIN_CONTRACT, "FLOW.QUERY explain");
-  const queryFingerprint = requiredText2(mapping, "query_fingerprint", "FLOW.QUERY explain");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY explain");
+  requireContract(mapping2, "version", FLOW_EXPLAIN_CONTRACT, "FLOW.QUERY explain");
+  const queryFingerprint = requiredText2(mapping2, "query_fingerprint", "FLOW.QUERY explain");
   if (!/^[0-9a-f]{64}$/iu.test(queryFingerprint)) {
     throw decodeError("FLOW.QUERY explain query_fingerprint is invalid", value);
   }
-  const status = requiredText2(mapping, "status", "FLOW.QUERY explain");
+  const status = requiredText2(mapping2, "status", "FLOW.QUERY explain");
   if (status !== "planned" && status !== "rejected" && status !== "executed") {
     throw decodeError(`FLOW.QUERY explain status ${JSON.stringify(status)} is unsupported`, value);
   }
   const plan = freezeMetadataMap(
-    requiredMap2(field(mapping, "plan"), "FLOW.QUERY explain plan"),
+    requiredMap2(field(mapping2, "plan"), "FLOW.QUERY explain plan"),
     "FLOW.QUERY explain plan"
   );
   const estimate = freezeMetadataMap(
-    requiredMap2(field(mapping, "estimate"), "FLOW.QUERY explain estimate"),
+    requiredMap2(field(mapping2, "estimate"), "FLOW.QUERY explain estimate"),
     "FLOW.QUERY explain estimate"
   );
   const bounds = freezeMetadataMap(
-    requiredMap2(field(mapping, "bounds"), "FLOW.QUERY explain bounds"),
+    requiredMap2(field(mapping2, "bounds"), "FLOW.QUERY explain bounds"),
     "FLOW.QUERY explain bounds"
   );
-  const capabilities = decodeExplainCapabilities(mapping);
+  const capabilities = decodeExplainCapabilities(mapping2);
   const extendedFields = ["stats", "quality", "pressure", "decision", "alternatives"];
-  const extendedPresence = extendedFields.map((name) => hasKey(mapping, name));
+  const extendedPresence = extendedFields.map((name) => hasKey(mapping2, name));
   const specialized = capabilities != null && !extendedPresence.some(Boolean);
   let stats;
   let quality;
@@ -13378,30 +13534,30 @@ function decodeFlowExplainResult(value) {
     if (status !== "planned") {
       throw decodeError("FLOW.QUERY specialized explain must be planned", value);
     }
-    if (hasKey(mapping, "actual") || hasKey(mapping, "diagnostic")) {
+    if (hasKey(mapping2, "actual") || hasKey(mapping2, "diagnostic")) {
       throw decodeError("FLOW.QUERY specialized explain has extended status fields", value);
     }
     alternatives = Object.freeze([]);
   } else {
-    if (!extendedPresence.every(Boolean) || !hasKey(mapping, "actual") || !hasKey(mapping, "diagnostic")) {
+    if (!extendedPresence.every(Boolean) || !hasKey(mapping2, "actual") || !hasKey(mapping2, "diagnostic")) {
       throw decodeError("FLOW.QUERY explain is missing required v1 fields", value);
     }
     stats = freezeMetadataMap(
-      requiredMap2(field(mapping, "stats"), "FLOW.QUERY explain stats"),
+      requiredMap2(field(mapping2, "stats"), "FLOW.QUERY explain stats"),
       "FLOW.QUERY explain stats"
     );
-    quality = decodeQuality(field(mapping, "quality"));
+    quality = decodeQuality(field(mapping2, "quality"));
     pressure = freezeMetadataMap(
-      requiredMap2(field(mapping, "pressure"), "FLOW.QUERY explain pressure"),
+      requiredMap2(field(mapping2, "pressure"), "FLOW.QUERY explain pressure"),
       "FLOW.QUERY explain pressure"
     );
     decision = freezeMetadataMap(
-      requiredMap2(field(mapping, "decision"), "FLOW.QUERY explain decision"),
+      requiredMap2(field(mapping2, "decision"), "FLOW.QUERY explain decision"),
       "FLOW.QUERY explain decision"
     );
-    alternatives = decodeExplainAlternatives(field(mapping, "alternatives"));
+    alternatives = decodeExplainAlternatives(field(mapping2, "alternatives"));
   }
-  const actualValue = field(mapping, "actual");
+  const actualValue = field(mapping2, "actual");
   let actual;
   if (status === "executed") {
     if (actualValue == null) {
@@ -13411,7 +13567,7 @@ function decodeFlowExplainResult(value) {
   } else if (actualValue != null) {
     throw decodeError("FLOW.QUERY non-executed explain contains actual usage", value);
   }
-  const diagnosticValue = field(mapping, "diagnostic");
+  const diagnosticValue = field(mapping2, "diagnostic");
   let diagnostic;
   if (status === "rejected") {
     diagnostic = tryDecodeFlowQueryError(diagnosticValue);
@@ -13436,13 +13592,13 @@ function decodeFlowExplainResult(value) {
     capabilities,
     actual,
     diagnostic,
-    raw: freezeMap(mapping)
+    raw: freezeMap(mapping2)
   });
 }
-function decodeExplainCapabilities(mapping) {
-  if (!hasKey(mapping, "capabilities")) return void 0;
+function decodeExplainCapabilities(mapping2) {
+  if (!hasKey(mapping2, "capabilities")) return void 0;
   const value = requiredMap2(
-    field(mapping, "capabilities"),
+    field(mapping2, "capabilities"),
     "FLOW.QUERY explain capabilities"
   );
   return Object.freeze({
@@ -13498,27 +13654,27 @@ function decodeExplainAlternatives(value) {
   return Object.freeze(alternatives);
 }
 function decodeQuality(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY quality");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY quality");
   return Object.freeze({
-    exactness: decodeQualityValue(mapping, "exactness", QUALITY_VALUES2.exactness),
-    freshness: decodeQualityValue(mapping, "freshness", QUALITY_VALUES2.freshness),
-    coverage: decodeQualityValue(mapping, "coverage", QUALITY_VALUES2.coverage),
-    pagination: decodeQualityValue(mapping, "pagination", QUALITY_VALUES2.pagination)
+    exactness: decodeQualityValue(mapping2, "exactness", QUALITY_VALUES2.exactness),
+    freshness: decodeQualityValue(mapping2, "freshness", QUALITY_VALUES2.freshness),
+    coverage: decodeQualityValue(mapping2, "coverage", QUALITY_VALUES2.coverage),
+    pagination: decodeQualityValue(mapping2, "pagination", QUALITY_VALUES2.pagination)
   });
 }
-function decodeQualityValue(mapping, name, allowed) {
-  const value = requiredBoundedText2(mapping, name, "FLOW.QUERY quality", 64);
+function decodeQualityValue(mapping2, name, allowed) {
+  const value = requiredBoundedText2(mapping2, name, "FLOW.QUERY quality", 64);
   if (!allowed.includes(value)) {
-    throw decodeError(`FLOW.QUERY quality ${name} is unsupported`, mapping);
+    throw decodeError(`FLOW.QUERY quality ${name} is unsupported`, mapping2);
   }
   return value;
 }
 function decodeUsage(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY usage");
+  const mapping2 = requiredMap2(value, "FLOW.QUERY usage");
   const usage = /* @__PURE__ */ Object.create(null);
   for (const [wireName, property] of USAGE_FIELDS2) {
     usage[property] = nonNegativeInteger(
-      field(mapping, wireName),
+      field(mapping2, wireName),
       `FLOW.QUERY usage ${wireName}`
     );
   }
@@ -13529,9 +13685,9 @@ function decodeUsage(value) {
   return Object.freeze(decoded);
 }
 function decodePage(value) {
-  const mapping = requiredMap2(value, "FLOW.QUERY page");
-  const hasMore = requiredBoolean(mapping, "has_more", "FLOW.QUERY page");
-  const cursor = optionalText2(mapping, "cursor", "FLOW.QUERY page");
+  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)) {
     throw decodeError("FLOW.QUERY page cursor is invalid", value);
   }
@@ -13647,12 +13803,12 @@ var ErrorMappingExecutor = class {
 
 // src/client-config.ts
 function snapshotClientOptions(options) {
-  const own = { ...options };
+  const own2 = { ...options };
   const snapshot = {
-    ...own,
-    ...typeof own.autoBatch === "object" && own.autoBatch != null ? { autoBatch: Object.freeze({ ...own.autoBatch }) } : {},
-    ...own.backpressure == null ? {} : { backpressure: Object.freeze({ ...own.backpressure }) },
-    ...typeof own.reconnect === "object" && own.reconnect != null ? { reconnect: Object.freeze({ ...own.reconnect }) } : {}
+    ...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 }) } : {}
   };
   return Object.freeze(snapshot);
 }
@@ -15841,33 +15997,511 @@ var FerricStoreClientCore = class extends FerricStoreAdministrationClient {
   }
 };
 
-// src/client-management.ts
-var FerricStoreManagementClient = class extends FerricStoreClientCore {
-  async stats(type, options = {}) {
-    const args = ["FLOW.STATS", type];
-    append(args, "STATE", options.state);
-    append(args, "COUNT", options.count);
-    append(args, "PARTITION", options.partitionKey);
-    appendAttributes(args, options.attributes);
-    appendBool(args, "CONSISTENT_PROJECTION", options.consistentProjection);
-    return adminRecordResponse(await this.commandArgs(args), "FLOW.STATS");
+// src/schedule-request.ts
+var MAX_EXACT_INTEGER = Number.MAX_SAFE_INTEGER;
+var SCHEDULE_KINDS = /* @__PURE__ */ new Set(["one_shot", "delay", "interval", "cron"]);
+var RECURRING_KINDS = /* @__PURE__ */ new Set(["interval", "cron"]);
+var OVERLAP_POLICIES = /* @__PURE__ */ new Set([
+  "allow",
+  "skip",
+  "queue_after_previous",
+  "fail_schedule"
+]);
+var SCHEDULE_STATES = /* @__PURE__ */ new Set([
+  "active",
+  "paused",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "all"
+]);
+var TARGET_FIELDS = /* @__PURE__ */ new Set([
+  "correlation_id",
+  "id",
+  "id_prefix",
+  "parent_flow_id",
+  "partition_key",
+  "payload",
+  "payload_ref",
+  "priority",
+  "root_flow_id",
+  "run_at_ms",
+  "state",
+  "type",
+  "value_refs",
+  "values"
+]);
+var TARGET_TEXT_FIELDS = [
+  "state",
+  "id",
+  "id_prefix",
+  "partition_key",
+  "correlation_id",
+  "parent_flow_id",
+  "root_flow_id",
+  "payload_ref"
+];
+var INTERNAL_SCHEDULE_TYPE = "__ferricstore_schedule";
+var INTERNAL_SCHEDULE_ID_PREFIX = "__ferricstore_schedule__:";
+function validateScheduleCreate(id, options) {
+  requiredText3(id, "id");
+  if (!mapping(options)) throw new TypeError("schedule options must be a mapping");
+  const kind = effectiveKind(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");
+  optionalBoolean(options.overwrite, "overwrite");
+  if (kind === "delay") {
+    if (options.delayMs == null) throw new TypeError("delay_ms is required for delay schedules");
+    if (options.nowMs != null && options.nowMs > MAX_EXACT_INTEGER - options.delayMs) {
+      throw new TypeError("now_ms plus delay_ms exceeds the exact integer range");
+    }
+  }
+  if (kind === "interval" && options.everyMs == null) {
+    throw new TypeError("every_ms is required for interval schedules");
+  }
+  if (kind === "cron") {
+    requiredText3(options.cron, "cron");
+    optionalText3(options.timezone, "timezone");
+  } else if (options.timezone != null) {
+    throw new TypeError("timezone is only supported for cron schedules");
+  }
+  if (kind === "interval") {
+    if (options.catchupPolicy != null && options.catchupPolicy !== "fire_once") {
+      throw new TypeError("catchup_policy must be fire_once");
+    }
+  } else if (options.catchupPolicy != null) {
+    throw new TypeError("catchup_policy is only supported for interval schedules");
+  }
+  if (recurring) {
+    if (options.overlapPolicy != null && !OVERLAP_POLICIES.has(options.overlapPolicy)) {
+      throw new TypeError(
+        "overlap_policy must be allow, skip, queue_after_previous, or fail_schedule"
+      );
+    }
+    if (options.overlapRetryMs != null && options.overlapPolicy !== "queue_after_previous") {
+      throw new TypeError("overlap_retry_ms requires overlap_policy queue_after_previous");
+    }
+    const firstRun = knownFirstRun(kind, options);
+    if (options.endAtMs != null && firstRun != null && options.endAtMs < firstRun) {
+      throw new TypeError("end_at_ms must be at or after first run");
+    }
+  } else {
+    if (options.overlapPolicy != null) {
+      throw new TypeError("overlap_policy is only supported for recurring schedules");
+    }
+    if (options.overlapRetryMs != null) {
+      throw new TypeError("overlap_retry_ms requires overlap_policy queue_after_previous");
+    }
+    if (options.maxFires != null) {
+      throw new TypeError("max_fires is only supported for recurring schedules");
+    }
+    if (options.endAtMs != null) {
+      throw new TypeError("end_at_ms is only supported for recurring schedules");
+    }
   }
-  async countByState(type, state, options = {}) {
-    const stats = await this.stats(type, { ...options, state });
-    if (!("count" in stats)) throw new TypeError("FLOW.STATS response missing count");
-    return integer(stats.count);
+}
+function validateScheduleID(id) {
+  requiredText3(id, "id");
+}
+function validateScheduleFire(id, options) {
+  validateScheduleID(id);
+  nonNegativeInteger2(options.fireAtMs, "fire_at_ms");
+  nonNegativeInteger2(options.nowMs, "now_ms");
+}
+function validateScheduleStatus(id, nowMs2) {
+  validateScheduleID(id);
+  nonNegativeInteger2(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");
+  optionalText3(options.worker, "worker");
+  positiveInteger2(options.leaseMs, "lease_ms");
+  nonNegativeInteger2(options.blockMs, "block_ms");
+  positiveInteger2(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");
   }
-  async attributes(type, options = {}) {
-    const args = ["FLOW.ATTRIBUTES", type];
-    appendAttributeQueryOptions(args, options);
-    return adminRecordList(await this.commandArgs(args), "FLOW.ATTRIBUTES");
+}
+function validateScheduleList(options) {
+  if (!mapping(options)) throw new TypeError("schedule list options must be a mapping");
+  if (options.kind != null && !SCHEDULE_KINDS.has(options.kind)) {
+    throw new TypeError("kind must be one_shot, delay, interval, or cron");
   }
-  async attributeValues(type, attribute, options = {}) {
-    const args = ["FLOW.ATTRIBUTE_VALUES", type, attribute];
-    appendAttributeQueryOptions(args, options);
-    return adminRecordList(await this.commandArgs(args), "FLOW.ATTRIBUTE_VALUES");
+  if (options.state != null && !SCHEDULE_STATES.has(options.state)) {
+    throw new TypeError("state is invalid");
+  }
+  optionalText3(options.timezone, "timezone");
+  optionalText3(options.targetType, "target_type");
+  nonNegativeInteger2(options.fromMs, "from_ms");
+  nonNegativeInteger2(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");
+  optionalBoolean(options.rev, "rev");
+}
+function effectiveKind(options) {
+  if (options.kind != null) {
+    if (!SCHEDULE_KINDS.has(options.kind)) {
+      throw new TypeError("kind must be one_shot, delay, interval, or cron");
+    }
+    return options.kind;
+  }
+  if (options.cron != null) return "cron";
+  if (options.everyMs != null) return "interval";
+  if (options.delayMs != null) return "delay";
+  return "one_shot";
+}
+function validateTiming(kind, options) {
+  if (options.atMs != null && options.startAtMs != null) {
+    throw new TypeError("cannot set both at_ms and start_at_ms");
+  }
+  if (options.delayMs != null && kind !== "delay") {
+    throw new TypeError("delay_ms is only supported for delay schedules");
+  }
+  if (options.everyMs != null && kind !== "interval") {
+    throw new TypeError("every_ms is only supported for interval schedules");
+  }
+  if (options.cron != null && kind !== "cron") {
+    throw new TypeError("cron is only supported for cron schedules");
+  }
+  if (kind === "delay" && (options.atMs != null || options.startAtMs != null)) {
+    throw new TypeError("at_ms and start_at_ms are not supported for delay schedules");
+  }
+}
+function validateTarget(value, recurring) {
+  if (!mapping(value)) throw new TypeError("target must be a mapping with a non-empty type");
+  const target = value;
+  for (const key of Object.keys(target)) {
+    if (!TARGET_FIELDS.has(key)) throw new TypeError(`target contains unknown field ${key}`);
+  }
+  const type = own(target, "type");
+  requiredText3(type, "target type");
+  if (type === INTERNAL_SCHEDULE_TYPE) {
+    throw new TypeError("target type is reserved for internal use");
+  }
+  for (const key of TARGET_TEXT_FIELDS) optionalText3(own(target, key), `target ${key}`);
+  const id = own(target, "id");
+  const idPrefix = own(target, "id_prefix");
+  if (id != null && idPrefix != null) {
+    throw new TypeError("target cannot set both id and id_prefix");
+  }
+  if (recurring && id != null) {
+    throw new TypeError("target id is not supported for recurring schedules; use id_prefix");
+  }
+  if (typeof id === "string" && id.startsWith(INTERNAL_SCHEDULE_ID_PREFIX)) {
+    throw new TypeError("target id is reserved for internal use");
+  }
+  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");
+  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");
+  }
+}
+function knownFirstRun(kind, options) {
+  if (kind === "delay") {
+    if (options.nowMs == null || options.delayMs == null) return void 0;
+    return options.nowMs + options.delayMs;
+  }
+  if (kind === "cron") return options.startAtMs ?? options.atMs ?? options.nowMs;
+  return options.atMs ?? options.startAtMs ?? options.nowMs;
+}
+function requiredText3(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${name} must be a non-empty string`);
+  }
+}
+function optionalText3(value, name) {
+  if (value != null) requiredText3(value, name);
+}
+function nonNegativeInteger2(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) {
+  if (value != null && (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)) {
+    throw new TypeError(`${name} must be a positive exact integer`);
+  }
+}
+function optionalBoolean(value, name) {
+  if (value != null && typeof value !== "boolean") {
+    throw new TypeError(`${name} must be a boolean`);
+  }
+}
+function mapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function own(mapping2, key) {
+  return Object.prototype.hasOwnProperty.call(mapping2, key) ? mapping2[key] : void 0;
+}
+
+// src/schedule-response.ts
+var SCHEDULE_INTEGER_FIELDS = [
+  "end_at_ms",
+  "last_catchup_at_ms",
+  "last_fire_at_ms",
+  "last_overlap_at_ms",
+  "last_skipped_at_ms",
+  "max_fires",
+  "next_run_at_ms",
+  "overlap_queued_due_at_ms"
+];
+var REQUIRED_SCHEDULE_INTEGER_FIELDS = [
+  "attempts",
+  "coalesced_count",
+  "fire_count",
+  "last_coalesced_count",
+  "skipped_count"
+];
+var OPTIONAL_SCHEDULE_TEXT_FIELDS = [
+  "cron",
+  "end_reason",
+  "flow_id",
+  "last_overlap_reason",
+  "last_overlap_target_id",
+  "last_planning_error",
+  "last_target_id",
+  "timezone"
+];
+var SCHEDULE_KINDS2 = /* @__PURE__ */ new Set(["one_shot", "delay", "interval", "cron"]);
+var SCHEDULE_STATES2 = /* @__PURE__ */ new Set([
+  "active",
+  "paused",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var SCHEDULE_OVERLAP_POLICIES = /* @__PURE__ */ new Set([
+  "allow",
+  "skip",
+  "queue_after_previous",
+  "fail_schedule"
+]);
+function scheduleRecordResponse(value, context) {
+  const record = adminRecordResponse(value, context);
+  if (typeof record.id !== "string" || record.id.length === 0) {
+    throw new TypeError(`${context} response missing id`);
+  }
+  if (typeof record.kind !== "string" || !SCHEDULE_KINDS2.has(record.kind)) {
+    throw new TypeError(`${context} response missing or invalid kind`);
+  }
+  if (typeof record.state !== "string" || !SCHEDULE_STATES2.has(record.state)) {
+    throw new TypeError(`${context} response missing or invalid state`);
+  }
+  if (typeof record.target !== "object" || record.target == null || Array.isArray(record.target)) {
+    throw new TypeError(`${context} response missing or invalid target`);
+  }
+  const target = record.target;
+  if (typeof target.type !== "string" || target.type.length === 0) {
+    throw new TypeError(`${context} response missing or invalid target type`);
+  }
+  if (!("catchup_policy" in record) || record.kind === "interval" && record.catchup_policy !== "fire_once" || record.kind !== "interval" && record.catchup_policy != null) {
+    throw new TypeError(`${context} returned an invalid catchup_policy`);
+  }
+  if (typeof record.overlap_policy !== "string" || !SCHEDULE_OVERLAP_POLICIES.has(record.overlap_policy)) {
+    throw new TypeError(`${context} response missing or invalid overlap_policy`);
+  }
+  safeNonNegativeInteger(record, "created_at_ms", context, true);
+  const everyMs = requiredNullableNonNegativeInteger(record, "every_ms", context);
+  const cron = requiredNullableResponseText(record, "cron", context);
+  const timezone = requiredNullableResponseText(record, "timezone", context);
+  const overlapRetryMs = requiredNullableNonNegativeInteger(
+    record,
+    "overlap_retry_ms",
+    context
+  );
+  validateRecurrence(record, context, everyMs, cron, timezone, overlapRetryMs);
+  let coalescedCount = 0;
+  let lastCoalescedCount = 0;
+  for (const field3 of REQUIRED_SCHEDULE_INTEGER_FIELDS) {
+    const value2 = safeNonNegativeInteger(record, field3, context, true);
+    if (field3 === "coalesced_count") coalescedCount = value2;
+    if (field3 === "last_coalesced_count") lastCoalescedCount = value2;
+  }
+  for (const field3 of SCHEDULE_INTEGER_FIELDS) {
+    if (record[field3] != null) safeNonNegativeInteger(record, field3, context);
+  }
+  for (const field3 of OPTIONAL_SCHEDULE_TEXT_FIELDS) {
+    optionalResponseText(record, field3, context);
+  }
+  validateCatchupState(record, context, coalescedCount, lastCoalescedCount);
+  return record;
+}
+function validateRecurrence(record, context, everyMs, cron, timezone, overlapRetryMs) {
+  if (record.kind === "interval") {
+    if (everyMs == null || everyMs <= 0) {
+      throw new TypeError(`${context} interval every_ms must be positive`);
+    }
+  } else if (everyMs != null) {
+    throw new TypeError(`${context} every_ms is only valid for interval schedules`);
+  }
+  if (record.kind === "cron") {
+    if (cron == null) throw new TypeError(`${context} cron schedule is missing cron`);
+    if (timezone == null) throw new TypeError(`${context} cron schedule is missing timezone`);
+  } else if (cron != null) {
+    throw new TypeError(`${context} cron is only valid for cron schedules`);
+  } else if (timezone != null) {
+    throw new TypeError(`${context} timezone is only valid for cron schedules`);
+  }
+  if (record.kind !== "interval" && record.kind !== "cron" && record.overlap_policy !== "allow") {
+    throw new TypeError(`${context} overlap_policy is only valid for recurring schedules`);
+  }
+  if (overlapRetryMs != null) {
+    if (overlapRetryMs <= 0) {
+      throw new TypeError(`${context} overlap_retry_ms must be positive`);
+    }
+    if (record.overlap_policy !== "queue_after_previous") {
+      throw new TypeError(`${context} overlap_retry_ms requires queue_after_previous`);
+    }
+  }
+}
+function validateCatchupState(record, context, coalescedCount, lastCoalescedCount) {
+  const lastCatchupAt = record.last_catchup_at_ms;
+  if (record.kind !== "interval") {
+    if (coalescedCount !== 0) {
+      throw new TypeError(`${context} non-interval coalesced_count must be zero`);
+    }
+    if (lastCoalescedCount !== 0) {
+      throw new TypeError(`${context} non-interval last_coalesced_count must be zero`);
+    }
+    if (lastCatchupAt != null) {
+      throw new TypeError(`${context} non-interval last_catchup_at_ms must be null`);
+    }
+    return;
+  }
+  if (lastCoalescedCount > coalescedCount) {
+    throw new TypeError(`${context} last_coalesced_count exceeds coalesced_count`);
+  }
+  if (lastCoalescedCount > 0 && lastCatchupAt == null) {
+    throw new TypeError(`${context} response missing last_catchup_at_ms after catch-up`);
+  }
+  if (lastCoalescedCount === 0 && lastCatchupAt != null) {
+    throw new TypeError(`${context} last_catchup_at_ms requires a catch-up`);
+  }
+}
+function optionalScheduleRecord(value, context) {
+  return value == null ? null : scheduleRecordResponse(value, context);
+}
+function scheduleRecordList(value, context) {
+  return arrayResponse(value).map((item) => scheduleRecordResponse(item, context));
+}
+function scheduleFireDueResponse(value) {
+  const context = "FLOW.SCHEDULE.FIRE_DUE";
+  const record = adminRecordResponse(value, context);
+  const claimed = safeNonNegativeInteger(record, "claimed", context, true);
+  const fired = safeNonNegativeInteger(record, "fired", context, true);
+  const skipped = safeNonNegativeInteger(record, "skipped", context, true);
+  const coalesced = safeNonNegativeInteger(record, "coalesced", context, true);
+  if (!Array.isArray(record.errors)) {
+    throw new TypeError(`${context} response missing errors`);
+  }
+  for (const error of record.errors) {
+    if (!Array.isArray(error) || error.length !== 2 || typeof error[0] !== "string" || error[0].length === 0 || typeof error[1] !== "string" || error[1].length === 0) {
+      throw new TypeError(`${context} returned an invalid error entry`);
+    }
   }
+  if (fired + skipped + record.errors.length !== claimed) {
+    throw new TypeError(`${context} outcomes do not equal claimed`);
+  }
+  optionalResponseText(record, "claim_error", context);
+  const lastTargetId = optionalResponseText(record, "last_target_id", context);
+  const lastSkipReason = optionalResponseText(record, "last_skip_reason", context);
+  if (fired > 0 && lastTargetId == null) {
+    throw new TypeError(`${context} response missing last_target_id`);
+  }
+  if (fired === 0 && lastTargetId != null) {
+    throw new TypeError(`${context} last_target_id requires a fired outcome`);
+  }
+  if (skipped > 0 && lastSkipReason == null) {
+    throw new TypeError(`${context} response missing last_skip_reason`);
+  }
+  if (skipped === 0 && lastSkipReason != null) {
+    throw new TypeError(`${context} last_skip_reason requires a skipped outcome`);
+  }
+  if (coalesced > 0 && fired + skipped === 0) {
+    throw new TypeError(`${context} coalesced count requires a fired or skipped outcome`);
+  }
+  return record;
+}
+function scheduleFireResponse(value) {
+  const context = "FLOW.SCHEDULE.FIRE";
+  const record = adminRecordResponse(value, context);
+  const schedule = scheduleRecordResponse(record.schedule, `${context} schedule`);
+  const fired = safeNonNegativeInteger(record, "fired", context, true);
+  const skipped = record.skipped == null ? 0 : safeNonNegativeInteger(record, "skipped", context);
+  if (fired > 1 || skipped > 1 || fired + skipped !== 1) {
+    throw new TypeError(`${context} outcomes must equal one`);
+  }
+  if (fired === 1 && (typeof record.target_id !== "string" || record.target_id.length === 0)) {
+    throw new TypeError(`${context} response missing target_id`);
+  }
+  if (skipped === 1 && (typeof record.reason !== "string" || record.reason.length === 0)) {
+    throw new TypeError(`${context} response missing reason`);
+  }
+  if (fired === 0 && record.target_id != null) {
+    throw new TypeError(`${context} target_id requires a fired outcome`);
+  }
+  if (skipped === 0 && record.reason != null) {
+    throw new TypeError(`${context} reason requires a skipped outcome`);
+  }
+  return { ...record, fired, skipped, schedule };
+}
+function optionalResponseText(record, field3, context) {
+  const value = record[field3];
+  if (value == null) return void 0;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${context} ${field3} must be non-empty text`);
+  }
+  return value;
+}
+function requiredNullableResponseText(record, field3, context) {
+  if (!(field3 in record)) throw new TypeError(`${context} response missing ${field3}`);
+  if (record[field3] === void 0) {
+    throw new TypeError(`${context} response missing ${field3}`);
+  }
+  return optionalResponseText(record, field3, context) ?? null;
+}
+function requiredNullableNonNegativeInteger(record, field3, context) {
+  if (!(field3 in record)) throw new TypeError(`${context} response missing ${field3}`);
+  if (record[field3] === void 0) {
+    throw new TypeError(`${context} response missing ${field3}`);
+  }
+  if (record[field3] === null) return null;
+  return safeNonNegativeInteger(record, field3, context);
+}
+function safeNonNegativeInteger(record, field3, context, required = false) {
+  if (!(field3 in record) || record[field3] == null) {
+    if (required) throw new TypeError(`${context} response missing ${field3}`);
+    return 0;
+  }
+  const value = record[field3];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${context} ${field3} must be a safe non-negative integer`);
+  }
+  return value;
+}
+
+// src/client-schedules.ts
+var FerricStoreScheduleClient = class extends FerricStoreClientCore {
   async scheduleCreate(id, options) {
+    validateScheduleCreate(id, options);
     const args = ["FLOW.SCHEDULE.CREATE", id];
     append(args, "KIND", options.kind);
     append(args, "AT_MS", options.atMs);
@@ -15877,6 +16511,7 @@ var FerricStoreManagementClient = class extends FerricStoreClientCore {
     append(args, "CRON", options.cron);
     append(args, "TIMEZONE", options.timezone);
     append(args, "TARGET", options.target);
+    append(args, "CATCHUP_POLICY", options.catchupPolicy);
     append(args, "OVERLAP_POLICY", options.overlapPolicy);
     append(args, "OVERLAP_RETRY_MS", options.overlapRetryMs);
     append(args, "MAX_FIRES", options.maxFires);
@@ -15886,34 +16521,55 @@ var FerricStoreManagementClient = class extends FerricStoreClientCore {
     for (const [name, value] of Object.entries(options.extraOptions ?? {})) {
       args.push(name.toUpperCase(), value);
     }
-    return adminRecordResponse(await this.commandArgs(args), "FLOW.SCHEDULE.CREATE");
+    return scheduleRecordResponse(await this.commandArgs(args), "FLOW.SCHEDULE.CREATE");
   }
-  async scheduleGet(id, options = {}) {
-    const args = ["FLOW.SCHEDULE.GET", id];
-    append(args, "NOW", options.nowMs);
-    return optionalAdminRecord(await this.commandArgs(args), "FLOW.SCHEDULE.GET");
+  async scheduleGet(id) {
+    validateScheduleID(id);
+    return optionalScheduleRecord(
+      await this.commandArgs(["FLOW.SCHEDULE.GET", id]),
+      "FLOW.SCHEDULE.GET"
+    );
   }
   async scheduleFire(id, options = {}) {
-    return await this.scheduleStatus("FLOW.SCHEDULE.FIRE", id, options.nowMs);
+    validateScheduleFire(id, options);
+    const args = ["FLOW.SCHEDULE.FIRE", id];
+    append(args, "FIRE_AT_MS", options.fireAtMs);
+    append(args, "NOW", options.nowMs);
+    return scheduleFireResponse(await this.commandArgs(args));
   }
   async schedulePause(id, options = {}) {
-    return await this.scheduleStatus("FLOW.SCHEDULE.PAUSE", id, options.nowMs);
+    validateScheduleStatus(id, options.nowMs);
+    return scheduleRecordResponse(
+      await this.scheduleStatusResponse("FLOW.SCHEDULE.PAUSE", id, options.nowMs),
+      "FLOW.SCHEDULE.PAUSE"
+    );
   }
   async scheduleResume(id, options = {}) {
-    return await this.scheduleStatus("FLOW.SCHEDULE.RESUME", id, options.nowMs);
+    validateScheduleStatus(id, options.nowMs);
+    return scheduleRecordResponse(
+      await this.scheduleStatusResponse("FLOW.SCHEDULE.RESUME", id, options.nowMs),
+      "FLOW.SCHEDULE.RESUME"
+    );
   }
   async scheduleDelete(id, options = {}) {
-    return await this.scheduleStatus("FLOW.SCHEDULE.DELETE", id, options.nowMs);
+    validateScheduleStatus(id, options.nowMs);
+    const response = await this.scheduleStatusResponse("FLOW.SCHEDULE.DELETE", id, options.nowMs);
+    if (!okLike(response)) {
+      throw new TypeError("FLOW.SCHEDULE.DELETE response must be OK");
+    }
   }
   async scheduleFireDue(options = {}) {
+    validateScheduleFireDue(options);
     const args = ["FLOW.SCHEDULE.FIRE_DUE"];
     append(args, "NOW", options.nowMs);
     append(args, "WORKER", options.worker);
+    append(args, "LEASE_MS", options.leaseMs);
     append(args, "BLOCK", options.blockMs);
     append(args, "LIMIT", options.limit);
-    return adminRecordResponse(await this.commandArgs(args), "FLOW.SCHEDULE.FIRE_DUE");
+    return scheduleFireDueResponse(await this.commandArgs(args));
   }
   async scheduleList(options = {}) {
+    validateScheduleList(options);
     const args = ["FLOW.SCHEDULE.LIST"];
     append(args, "KIND", options.kind);
     append(args, "STATE", options.state);
@@ -15923,14 +16579,40 @@ var FerricStoreManagementClient = class extends FerricStoreClientCore {
     append(args, "TO_MS", options.toMs);
     append(args, "COUNT", options.count);
     appendBool(args, "REV", options.rev);
-    return adminRecordList(await this.commandArgs(args), "FLOW.SCHEDULE.LIST");
+    return scheduleRecordList(await this.commandArgs(args), "FLOW.SCHEDULE.LIST");
   }
-  async scheduleStatus(command, id, now) {
+  async scheduleStatusResponse(command, id, now) {
     const args = [command, id];
     append(args, "NOW", now);
-    const response = await this.commandArgs(args);
-    if (okLike(response)) return { id, status: "deleted" };
-    return adminRecordResponse(response, command);
+    return await this.commandArgs(args);
+  }
+};
+
+// src/client-management.ts
+var FerricStoreManagementClient = class extends FerricStoreScheduleClient {
+  async stats(type, options = {}) {
+    const args = ["FLOW.STATS", type];
+    append(args, "STATE", options.state);
+    append(args, "COUNT", options.count);
+    append(args, "PARTITION", options.partitionKey);
+    appendAttributes(args, options.attributes);
+    appendBool(args, "CONSISTENT_PROJECTION", options.consistentProjection);
+    return adminRecordResponse(await this.commandArgs(args), "FLOW.STATS");
+  }
+  async countByState(type, state, options = {}) {
+    const stats = await this.stats(type, { ...options, state });
+    if (!("count" in stats)) throw new TypeError("FLOW.STATS response missing count");
+    return integer(stats.count);
+  }
+  async attributes(type, options = {}) {
+    const args = ["FLOW.ATTRIBUTES", type];
+    appendAttributeQueryOptions(args, options);
+    return adminRecordList(await this.commandArgs(args), "FLOW.ATTRIBUTES");
+  }
+  async attributeValues(type, attribute, options = {}) {
+    const args = ["FLOW.ATTRIBUTE_VALUES", type, attribute];
+    appendAttributeQueryOptions(args, options);
+    return adminRecordList(await this.commandArgs(args), "FLOW.ATTRIBUTE_VALUES");
   }
   async effectReserve(id, effectKey, effectType, options) {
     const args = [
@@ -16268,15 +16950,15 @@ function assertFlowPolicyGeneration(value) {
 function flowPolicySnapshotFromResp(value) {
   const policy = requiredRecord(value, "FLOW policy snapshot");
   const maxActiveMs = optionalPositiveInteger(field(policy, "max_active_ms"), "max_active_ms");
-  const state = optionalText3(field(policy, "state"), "state");
+  const state = optionalText4(field(policy, "state"), "state");
   const mode = optionalMode(field(policy, "mode"), "mode");
   const version = optionalVersion(field(policy, "version"));
-  const indexedStateMeta = optionalText3(field(policy, "indexed_state_meta"), "indexed_state_meta");
+  const indexedStateMeta = optionalText4(field(policy, "indexed_state_meta"), "indexed_state_meta");
   const governance = optionalRecord(field(policy, "governance"), "governance");
   const states = optionalStates(field(policy, "states"));
   return {
-    type: requiredText3(field(policy, "type"), "type"),
-    generation: nonNegativeInteger2(field(policy, "generation"), "generation"),
+    type: requiredText4(field(policy, "type"), "type"),
+    generation: nonNegativeInteger3(field(policy, "generation"), "generation"),
     ...state == null ? {} : { state },
     ...version == null ? {} : { version },
     ...mode == null ? {} : { mode },
@@ -16294,21 +16976,21 @@ function retrySnapshot(value, context) {
   const retry2 = requiredRecord(value, `FLOW policy ${context}`);
   const backoff = requiredRecord(field(retry2, "backoff"), `FLOW policy ${context}.backoff`);
   return {
-    maxRetries: nonNegativeInteger2(field(retry2, "max_retries"), `${context}.max_retries`),
+    maxRetries: nonNegativeInteger3(field(retry2, "max_retries"), `${context}.max_retries`),
     backoff: {
       kind: backoffKind(field(backoff, "kind"), `${context}.backoff.kind`),
-      baseMs: nonNegativeInteger2(field(backoff, "base_ms"), `${context}.backoff.base_ms`),
-      maxMs: nonNegativeInteger2(field(backoff, "max_ms"), `${context}.backoff.max_ms`),
-      jitterPct: nonNegativeInteger2(field(backoff, "jitter_pct"), `${context}.backoff.jitter_pct`)
+      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`)
     },
-    exhaustedTo: requiredText3(field(retry2, "exhausted_to"), `${context}.exhausted_to`)
+    exhaustedTo: requiredText4(field(retry2, "exhausted_to"), `${context}.exhausted_to`)
   };
 }
 function retentionSnapshot(value, context) {
   const retention = requiredRecord(value, `FLOW policy ${context}`);
   return {
-    ttlMs: nonNegativeInteger2(field(retention, "ttl_ms"), `${context}.ttl_ms`),
-    historyMaxEvents: nonNegativeInteger2(
+    ttlMs: nonNegativeInteger3(field(retention, "ttl_ms"), `${context}.ttl_ms`),
+    historyMaxEvents: nonNegativeInteger3(
       field(retention, "history_max_events"),
       `${context}.history_max_events`
     )
@@ -16344,7 +17026,7 @@ function requiredRecord(value, context) {
   if (value instanceof Map) {
     const result = {};
     for (const [key, item] of value.entries()) {
-      setOwnValue(result, requiredText3(key, `${context} key`), item);
+      setOwnValue(result, requiredText4(key, `${context} key`), item);
     }
     return result;
   }
@@ -16363,21 +17045,21 @@ function stringArray(value, context) {
     if (!Object.hasOwn(value, index)) {
       throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
     }
-    result[index] = requiredText3(value[index], `${context}[${index}]`);
+    result[index] = requiredText4(value[index], `${context}[${index}]`);
   }
   return result;
 }
-function requiredText3(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");
   }
   throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
 }
-function optionalText3(value, context) {
-  return value == null ? void 0 : requiredText3(value, context);
+function optionalText4(value, context) {
+  return value == null ? void 0 : requiredText4(value, context);
 }
-function nonNegativeInteger2(value, context) {
+function nonNegativeInteger3(value, context) {
   let parsed;
   try {
     parsed = integer(value);
@@ -16389,26 +17071,26 @@ function nonNegativeInteger2(value, context) {
 }
 function optionalPositiveInteger(value, context) {
   if (value == null) return void 0;
-  const parsed = nonNegativeInteger2(value, context);
+  const parsed = nonNegativeInteger3(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 nonNegativeInteger2(value, "version");
+    return nonNegativeInteger3(value, "version");
   }
-  return requiredText3(value, "version");
+  return requiredText4(value, "version");
 }
 function backoffKind(value, context) {
-  const kind = requiredText3(value, context).toLowerCase();
+  const kind = requiredText4(value, context).toLowerCase();
   if (kind === "none" || kind === "fixed" || kind === "linear" || kind === "exponential") {
     return kind;
   }
   throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
 }
 function requiredMode(value, context) {
-  const mode = requiredText3(value, context).toLowerCase();
+  const mode = requiredText4(value, context).toLowerCase();
   if (mode === "fifo" || mode === "parallel") return mode;
   throw new TypeError(`FLOW policy ${context} returned an unexpected response`);
 }
@@ -17940,7 +18622,7 @@ var LeaseRenewalGuard = class {
     if (options.leaseRenewal === false) {
       return;
     }
-    const intervalMs = positiveInteger2(options.leaseRenewIntervalMs, Math.max(1, Math.trunc(leaseMs / 2)));
+    const intervalMs = positiveInteger3(options.leaseRenewIntervalMs, Math.max(1, Math.trunc(leaseMs / 2)));
     this.timer = setLongInterval(() => this.renew(), intervalMs);
     this.timer.unref();
   }
@@ -18012,7 +18694,7 @@ function snapshotLeasedJob(job) {
   return snapshot;
 }
 function workerConcurrency(options) {
-  return positiveInteger2(options.concurrency ?? options.workers, 1);
+  return positiveInteger3(options.concurrency ?? options.workers, 1);
 }
 function workerRefillStrategy(options) {
   return options.refillStrategy === "wave" ? "wave" : "continuous";
@@ -18055,18 +18737,18 @@ function workerErrorPayload(error, options, codec) {
 }
 function workerBatchSize(options, flowManyBatchLimit = DEFAULT_FLOW_MANY_BATCH_LIMIT2) {
   return Math.min(
-    positiveInteger2(options.batchSize, 10),
-    positiveInteger2(flowManyBatchLimit, DEFAULT_FLOW_MANY_BATCH_LIMIT2)
+    positiveInteger3(options.batchSize, 10),
+    positiveInteger3(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 positiveInteger2(options.claimDrainBatches, 1);
+  return positiveInteger3(options.claimDrainBatches, 1);
 }
 function workerLeaseMs(options, fallback = 3e4) {
-  return positiveInteger2(options.leaseMs, positiveInteger2(fallback, 3e4));
+  return positiveInteger3(options.leaseMs, positiveInteger3(fallback, 3e4));
 }
 function workerIdleSleepMs(options) {
   return nonNegativeDuration(options.idleSleepMs, 250);
@@ -18078,7 +18760,7 @@ function workerClaimBlockMs(options, useBlocking) {
   if (options.signal == null || !Number.isFinite(options.blockMs) || options.blockMs < 0) {
     return options.blockMs;
   }
-  const abortPollMs = positiveInteger2(options.abortPollMs, 1e3);
+  const abortPollMs = positiveInteger3(options.abortPollMs, 1e3);
   return options.blockMs === 0 ? abortPollMs : Math.min(Math.trunc(options.blockMs), abortPollMs);
 }
 function workerMaxIdleSleepMs(options, idleSleepMs = workerIdleSleepMs(options)) {
@@ -18089,14 +18771,14 @@ function nextWorkerIdleSleepMs(currentIdleSleepMs, maxIdleSleepMs) {
   return Math.min(maxIdleSleepMs, Math.max(1, currentIdleSleepMs * 2));
 }
 async function runContinuousWorkerPool(options) {
-  const concurrency = positiveInteger2(options.concurrency, 1);
-  const maxClaimSize = positiveInteger2(options.maxClaimSize, concurrency);
+  const concurrency = positiveInteger3(options.concurrency, 1);
+  const maxClaimSize = positiveInteger3(options.maxClaimSize, concurrency);
   const initialIdleSleepMs = nonNegativeDuration(options.idleSleepMs, 250);
   const maxIdleSleepMs = Math.max(
     initialIdleSleepMs,
     nonNegativeDuration(options.maxIdleSleepMs, 5e3)
   );
-  const refillDelayMs = nonNegativeInteger3(options.refillDelayMs, 0);
+  const refillDelayMs = nonNegativeInteger4(options.refillDelayMs, 0);
   const active = /* @__PURE__ */ new Set();
   const pending = [];
   let pendingIndex = 0;
@@ -18212,10 +18894,10 @@ function normalizeWorkflowWorkerConfig(options) {
     ...captured
   });
 }
-function positiveInteger2(value, fallback) {
+function positiveInteger3(value, fallback) {
   return value == null || !Number.isFinite(value) ? fallback : Math.max(1, Math.trunc(value));
 }
-function nonNegativeInteger3(value, fallback) {
+function nonNegativeInteger4(value, fallback) {
   return value == null || !Number.isFinite(value) ? fallback : Math.max(0, Math.trunc(value));
 }
 function nonNegativeDuration(value, fallback) {
@@ -19099,13 +19781,13 @@ var QueueWorker = class {
 
 // src/flow-client-options.ts
 function snapshotFlowClientOptions(options, context) {
-  const own = { ...options };
-  if (typeof own.type !== "string" || own.type.length === 0) {
+  const own2 = { ...options };
+  if (typeof own2.type !== "string" || own2.type.length === 0) {
     throw new TypeError(`${context} type must be an own non-empty string`);
   }
-  const valueConfig = own.valueConfig;
+  const valueConfig = own2.valueConfig;
   return Object.freeze({
-    ...own,
+    ...own2,
     ...valueConfig == null ? {} : { valueConfig: Object.freeze({ ...valueConfig }) }
   });
 }
@@ -19528,19 +20210,19 @@ async function applyFail(client, ctx, outcome, returnRecord) {
 
 // src/workflow-registration.ts
 function createWorkflowStateRegistration(name, handler, options, defaultValueMaxBytes) {
-  const own = { ...options };
-  const claimValues = own.claimValues == null ? void 0 : snapshotOwnStringArray(own.claimValues, "claimValues");
-  const retryPolicy = own.retryPolicy == null ? void 0 : Object.freeze({ ...own.retryPolicy });
+  const own2 = { ...options };
+  const claimValues = own2.claimValues == null ? void 0 : snapshotOwnStringArray(own2.claimValues, "claimValues");
+  const retryPolicy = own2.retryPolicy == null ? void 0 : Object.freeze({ ...own2.retryPolicy });
   return Object.freeze({
-    claimPayload: own.claimPayload ?? true,
-    claimRecord: own.claimRecord ?? true,
-    exceptionPolicy: normalizeExceptionPolicy(own.exceptionPolicy),
+    claimPayload: own2.claimPayload ?? true,
+    claimRecord: own2.claimRecord ?? true,
+    exceptionPolicy: normalizeExceptionPolicy(own2.exceptionPolicy),
     handler,
-    leaseMs: own.leaseMs ?? 3e4,
-    ...own.mode == null ? {} : { mode: normalizeStateMode(own.mode) },
+    leaseMs: own2.leaseMs ?? 3e4,
+    ...own2.mode == null ? {} : { mode: normalizeStateMode(own2.mode) },
     name,
-    returnRecord: own.returnRecord ?? false,
-    valueMaxBytes: own.valueMaxBytes ?? defaultValueMaxBytes,
+    returnRecord: own2.returnRecord ?? false,
+    valueMaxBytes: own2.valueMaxBytes ?? defaultValueMaxBytes,
     ...claimValues == null ? {} : { claimValues },
     ...retryPolicy == null ? {} : { retryPolicy }
   });
@@ -19844,8 +20526,8 @@ var WorkflowWorker = class {
 };
 
 // src/version.ts
-var FERRICSTORE_SDK_VERSION = "0.5.2";
-var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.11.0";
+var FERRICSTORE_SDK_VERSION = "0.11.5";
+var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.11.4";
 var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {