bunqueue-client 0.1.9 → 0.2.0

package/dist/chunk-b967v3w3.js

@@ -0,0 +1,79 @@
+// src/errors.ts
+class BunqueueError2 extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+}
+
+class ConnectionClosedError2 extends BunqueueError2 {
+}
+
+class CommandTimeoutError2 extends BunqueueError2 {
+}
+
+class CommandError2 extends BunqueueError2 {
+}
+
+class SerializationError2 extends BunqueueError2 {
+}
+
+class AuthError2 extends BunqueueError2 {
+}
+
+class UnrecoverableError2 extends BunqueueError2 {
+}
+
+// src/frame.ts
+var PROTOCOL_VERSION2 = 3;
+var MAX_FRAME_SIZE2 = 64 * 1024 * 1024;
+function compact2(obj) {
+  const out = {};
+  for (const key in obj) {
+    if (obj[key] !== undefined)
+      out[key] = obj[key];
+  }
+  return out;
+}
+function frame2(payload) {
+  if (payload.length > MAX_FRAME_SIZE2) {
+    throw new SerializationError2(`frame size ${payload.length} exceeds maximum ${MAX_FRAME_SIZE2}`);
+  }
+  const framed = Buffer.allocUnsafe(4 + payload.length);
+  framed.writeUInt32BE(payload.length, 0);
+  framed.set(payload, 4);
+  return framed;
+}
+
+class FrameParser2 {
+  buffer = Buffer.alloc(0);
+  addData(data) {
+    const buffer = this.buffer.length === 0 ? data : Buffer.concat([this.buffer, data]);
+    const frames = [];
+    let offset = 0;
+    while (buffer.length - offset >= 4) {
+      const length = buffer.readUInt32BE(offset);
+      if (length > MAX_FRAME_SIZE2) {
+        this.buffer = Buffer.alloc(0);
+        throw new ConnectionClosedError2(`frame size ${length} exceeds maximum`);
+      }
+      if (buffer.length - offset < 4 + length)
+        break;
+      frames.push(Buffer.from(buffer.subarray(offset + 4, offset + 4 + length)));
+      offset += 4 + length;
+    }
+    if (offset >= buffer.length) {
+      this.buffer = Buffer.alloc(0);
+    } else if (offset === 0) {
+      this.buffer = buffer;
+    } else {
+      this.buffer = Buffer.from(buffer.subarray(offset));
+    }
+    return frames;
+  }
+  clear() {
+    this.buffer = Buffer.alloc(0);
+  }
+}
+
+export { BunqueueError2, ConnectionClosedError2, CommandTimeoutError2, CommandError2, SerializationError2, AuthError2, UnrecoverableError2, PROTOCOL_VERSION2, MAX_FRAME_SIZE2, compact2, frame2, FrameParser2 };

package/dist/chunk-fekm0ma6.js

@@ -0,0 +1,110 @@
+import {
+  compact2
+} from "./chunk-b967v3w3.js";
+
+// src/terminal-outcome.ts
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function validatedIndices(value, size) {
+  if (!Array.isArray(value))
+    throw new Error("Invalid ACKB ignoredIndices response");
+  const seen = new Set;
+  for (const index of value) {
+    if (!Number.isInteger(index) || index < 0 || index >= size || seen.has(index)) {
+      throw new Error("Invalid ACKB ignoredIndices response");
+    }
+    seen.add(index);
+  }
+  return [...seen];
+}
+function validatedIds(value) {
+  if (!Array.isArray(value) || value.some((id) => typeof id !== "string")) {
+    throw new Error("Invalid ACKB ignoredIds response");
+  }
+  return value;
+}
+function ignoredAckIndices(data, batch) {
+  if (data === undefined)
+    return new Set;
+  const payload = record(data);
+  if (!payload)
+    throw new Error("Invalid ACKB response data");
+  const hasIndices = Object.hasOwn(payload, "ignoredIndices");
+  const hasIds = Object.hasOwn(payload, "ignoredIds");
+  if (!hasIndices)
+    throw new Error("Invalid ACKB ignoredIndices response");
+  const ids = hasIds ? validatedIds(payload.ignoredIds) : null;
+  const indices = validatedIndices(payload.ignoredIndices, batch.length);
+  if (ids) {
+    if (ids.length !== indices.length)
+      throw new Error("Mismatched ACKB ignored evidence");
+    for (let offset = 0;offset < indices.length; offset++) {
+      if (batch[indices[offset]]?.id !== ids[offset]) {
+        throw new Error("Mismatched ACKB ignored evidence");
+      }
+    }
+  }
+  return new Set(indices);
+}
+function terminalOutcomeWasApplied(data) {
+  if (data === undefined)
+    return true;
+  const payload = record(data);
+  if (payload?.applied === false && payload.reason === "already-finalized")
+    return false;
+  throw new Error("Invalid terminal outcome response data");
+}
+
+// src/ack-batcher.ts
+class AckBatcher2 {
+  connection;
+  maxSize;
+  maxDelayMs;
+  buffer = [];
+  timer = null;
+  constructor(connection, maxSize, maxDelayMs) {
+    this.connection = connection;
+    this.maxSize = maxSize;
+    this.maxDelayMs = maxDelayMs;
+  }
+  add(item) {
+    this.buffer.push(item);
+    if (this.buffer.length >= this.maxSize) {
+      this.flush();
+    } else if (!this.timer) {
+      this.timer = setTimeout(() => void this.flush(), this.maxDelayMs);
+      this.timer.unref?.();
+    }
+  }
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer.length === 0)
+      return;
+    const batch = this.buffer;
+    this.buffer = [];
+    let error;
+    let ignoredIndices = new Set;
+    try {
+      const response = await this.connection.call(compact2({
+        cmd: "ACKB",
+        ids: batch.map((b) => b.id),
+        tokens: batch.map((b) => b.token),
+        results: batch.map((b) => b.result)
+      }));
+      ignoredIndices = ignoredAckIndices(response.data, batch);
+    } catch (err) {
+      error = err ?? new Error("ACKB failed");
+    }
+    for (let index = 0;index < batch.length; index++) {
+      try {
+        batch[index].onSettled(error, error === undefined ? !ignoredIndices.has(index) : undefined);
+      } catch {}
+    }
+  }
+}
+
+export { terminalOutcomeWasApplied, AckBatcher2 };