@ferricstore/ferricstore 0.11.4 → 0.11.6

package/README.md

@@ -18,9 +18,10 @@ Requires Node.js 22.22 or newer. The SDK ships ESM and CommonJS builds and is te
 
 ## Compatibility
 
-TypeScript SDK `0.11.4` requires FerricStore server `0.11.4` or newer because
-schedule responses now use the complete recurrence contract. The native wire
-protocol remains v1 (`FSNP` framing and existing opcode numbers are unchanged).
+TypeScript SDK `0.11.6` requires FerricStore server `0.11.4` or newer. With
+FerricStore 0.11.6 it negotiates compact Stream mode 34 for homogeneous auto-ID
+`XADD` pipelines and compact Pub/Sub mode 35 for homogeneous `PUBLISH`
+pipelines. Native wire protocol v1 and the generic fallback are unchanged.
 Capabilities and response-size limits are negotiated
 per connection from the HELLO-shaped startup response rather than inferred from
 a server version table.
@@ -43,7 +44,7 @@ const { FerricStoreClient, JsonCodec } = require("@ferricstore/ferricstore");
 docker run -p 6388:6388 \
   -e FERRICSTORE_PROTECTED_MODE=false \
   -v ferricstore_data:/data \
-  ghcr.io/ferricstore/ferricstore:0.11.4
+  quay.io/ferricstore/ferricstore:0.11.6
 ```
 
 ## Query durable runs

package/dist/index.cjs

@@ -4632,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);
@@ -4644,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;
@@ -5227,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 };
@@ -5547,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 }
   };
@@ -6839,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,
@@ -7341,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);
@@ -7356,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 [];
@@ -7364,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);
@@ -7376,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);
@@ -7384,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);
@@ -7404,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);
   }
@@ -8045,6 +8192,8 @@ var NativeConnectionCapabilities = class {
   }
   configuredRequestFrameBytes;
   compactResponseOpcodes = EMPTY_COMPACT_RESPONSE_OPCODES;
+  compactPubSubPublish = false;
+  compactStreamXAdd = false;
   flowQuery;
   requestFrameBytes;
   negotiatedRequestFrameBytes;
@@ -8052,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(
@@ -8277,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. */
@@ -8288,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() {
@@ -20371,7 +20526,7 @@ var WorkflowWorker = class {
 };
 
 // src/version.ts
-var FERRICSTORE_SDK_VERSION = "0.11.4";
+var FERRICSTORE_SDK_VERSION = "0.11.6";
 var FERRICSTORE_MINIMUM_SERVER_VERSION = "0.11.4";
 var FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
 // Annotate the CommonJS export names for ESM import in node: