@arbitro/client 0.2.0

package/dist/index.js

@@ -0,0 +1,1634 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AckPolicy: () => AckPolicy,
+  ArbitroClient: () => ArbitroClient,
+  ArbitroError: () => ArbitroError,
+  Codec: () => Codec,
+  Consumer: () => Consumer,
+  DeliverPolicy: () => DeliverPolicy,
+  ErrorCode: () => ErrorCode,
+  JournalType: () => JournalType,
+  JsonCodec: () => JsonCodec,
+  Message: () => Message,
+  Stream: () => Stream,
+  StringCodec: () => StringCodec,
+  Subscription: () => Subscription,
+  Topic: () => Topic,
+  decodeJson: () => decodeJson,
+  decodeString: () => decodeString,
+  encodeJson: () => encodeJson,
+  encodeString: () => encodeString,
+  makeLazyMessage: () => makeLazyMessage,
+  schema: () => schema,
+  streamId: () => streamId,
+  zodCodec: () => zodCodec
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/config.ts
+var DeliverPolicy = /* @__PURE__ */ ((DeliverPolicy2) => {
+  DeliverPolicy2["All"] = "All";
+  DeliverPolicy2["Last"] = "Last";
+  DeliverPolicy2["New"] = "New";
+  DeliverPolicy2["BySeq"] = "ByStartSeq";
+  DeliverPolicy2["ByTime"] = "ByStartTime";
+  return DeliverPolicy2;
+})(DeliverPolicy || {});
+var JournalType = /* @__PURE__ */ ((JournalType2) => {
+  JournalType2["Memory"] = "Memory";
+  JournalType2["Tolerant"] = "Tolerant";
+  JournalType2["Strict"] = "Strict";
+  return JournalType2;
+})(JournalType || {});
+var AckPolicy = /* @__PURE__ */ ((AckPolicy2) => {
+  AckPolicy2["Explicit"] = "explicit";
+  AckPolicy2["None"] = "none";
+  return AckPolicy2;
+})(AckPolicy || {});
+
+// src/types/error.ts
+var ArbitroError = class extends Error {
+  constructor(message, code, brokerName, brokerDetails, wireCode) {
+    super(message);
+    this.code = code;
+    this.brokerName = brokerName;
+    this.brokerDetails = brokerDetails;
+    this.wireCode = wireCode;
+    this.name = "ArbitroError";
+  }
+};
+var ErrorCode = {
+  // 0x00xx — Protocol
+  UnknownAction: 1,
+  BufferTooShort: 2,
+  InvalidLength: 3,
+  InvalidEntryCount: 4,
+  // 0x01xx — Auth
+  AuthRequired: 257,
+  AuthFailed: 258,
+  // 0x02xx — Stream
+  StreamNotFound: 513,
+  StreamAlreadyExists: 514,
+  StreamFull: 515,
+  StreamFilterOverlap: 516,
+  SubjectNotFound: 517,
+  /** Publish carried a `msgId` already seen for this stream within
+   * `idempotencyWindowMs`. Original write stands; safe to treat as
+   * a successful publish at the application level. */
+  IdempotencyDuplicate: 518,
+  // 0x03xx — Consumer
+  ConsumerNotFound: 769,
+  ConsumerAlreadyExists: 770,
+  ConsumerFilterOverlap: 771,
+  // 0x04xx — Delivery
+  InvalidSequence: 1025,
+  MaxInflightReached: 1026,
+  AckTimeout: 1027,
+  // 0x05xx — System
+  ServerShuttingDown: 1281,
+  InternalError: 1282
+};
+
+// src/utils/text.ts
+function encodeString(s) {
+  return Buffer.from(s, "utf8");
+}
+function decodeString(buf) {
+  return buf.toString("utf8");
+}
+
+// src/utils/json.ts
+function encodeJson(value) {
+  return Buffer.from(JSON.stringify(value), "utf8");
+}
+function decodeJson(buf) {
+  return JSON.parse(buf.toString("utf8"));
+}
+
+// src/utils/codec.ts
+var import_msgpackr = require("msgpackr");
+var TextEncoding = class {
+  encode(value) {
+    return Buffer.from(value, this.encoding);
+  }
+  decode(buf) {
+    return buf.toString(this.encoding);
+  }
+};
+var StringCodec = class extends TextEncoding {
+  encoding;
+  constructor(encoding = "utf8") {
+    super();
+    this.encoding = encoding;
+  }
+};
+var JsonCodec = class {
+  text;
+  constructor(encoding = "utf8") {
+    this.text = new StringCodec(encoding);
+  }
+  encode(value) {
+    return this.text.encode(JSON.stringify(value));
+  }
+  decode(buf) {
+    return JSON.parse(this.text.decode(buf));
+  }
+};
+var Codec = class {
+  fields;
+  packr;
+  unpackr;
+  constructor(schema2) {
+    this.fields = Object.keys(schema2);
+    this.packr = new import_msgpackr.Packr({ structuredClone: false, useRecords: false });
+    this.unpackr = new import_msgpackr.Unpackr({ structuredClone: false, useRecords: false });
+  }
+  // Encodes only known fields in definition order — no extras, no key enumeration.
+  encode(value) {
+    const obj = {};
+    for (const k of this.fields) obj[k] = value[k];
+    return Buffer.from(this.packr.pack(obj));
+  }
+  decode(buf) {
+    return this.unpackr.unpack(buf);
+  }
+};
+function schema(def) {
+  return new Codec(def);
+}
+
+// src/topic/topic.ts
+var Topic = class {
+  constructor(stream, subject, codec) {
+    this.stream = stream;
+    this.subject = subject;
+    this.codec = codec;
+    this.fields = codec.fields ?? [];
+  }
+  fields;
+  publish(value) {
+    this.stream.publish(this.subject, this.codec.encode(value));
+  }
+  async publishAck(value) {
+    await this.stream.publishAck(this.subject, this.codec.encode(value));
+  }
+  publishBatch(values) {
+    this.stream.publishBatch(values.map((v) => ({
+      subject: this.subject,
+      payload: this.codec.encode(v)
+    })));
+  }
+  async subscribe(group, cb) {
+    const consumer = this.stream.consumer({ name: group });
+    return consumer.subscribe(this.codec, cb);
+  }
+};
+
+// src/topic/lazy-message.ts
+function makeLazyMessage(raw, codec, fields, onAck, onNack, onNackDelay) {
+  let cache;
+  const lazy = () => cache ??= codec.decode(raw);
+  const msg = {
+    _raw: raw,
+    decode: lazy,
+    ack: onAck,
+    nack: onNack,
+    nackDelay: onNackDelay ?? onNack
+  };
+  for (const key of fields) {
+    Object.defineProperty(msg, key, {
+      get: () => lazy()[key],
+      enumerable: true
+    });
+  }
+  return msg;
+}
+
+// src/proto/constants.ts
+var MAGIC_V2 = 843207233;
+var HELLO_SIZE = 8;
+var CURRENT_VERSION = 2;
+var HEADER_SIZE = 16;
+var OFF_ACTION = 0;
+var OFF_FLAGS = 2;
+var OFF_ENTRY_FLAGS = 3;
+var OFF_MSG_LEN = 4;
+var OFF_SEQ = 8;
+
+// src/proto/frame.ts
+function frame(action, seq, bodyLen, flags = 0, entryFlags = 0) {
+  const buf = Buffer.allocUnsafe(HEADER_SIZE + bodyLen);
+  buf.writeUInt16LE(action, OFF_ACTION);
+  buf[OFF_FLAGS] = flags;
+  buf[OFF_ENTRY_FLAGS] = entryFlags;
+  buf.writeUInt32LE(bodyLen, OFF_MSG_LEN);
+  buf.writeBigUInt64LE(seq, OFF_SEQ);
+  return buf;
+}
+function packHello(caps = 2 /* Reply */) {
+  const buf = Buffer.allocUnsafe(HELLO_SIZE);
+  buf.writeUInt32LE(MAGIC_V2, 0);
+  buf[4] = CURRENT_VERSION;
+  buf[5] = 0 /* Client */;
+  buf.writeUInt16LE(caps, 6);
+  return buf;
+}
+function packDisconnect(seq) {
+  return frame(1541 /* Disconnect */, seq, 0);
+}
+
+// src/proto/publish.ts
+var EMPTY = Buffer.alloc(0);
+function packPublish(seq, streamId2, subject, payload, flags = 0, entryFlags = 0, msgId = EMPTY) {
+  const buf = frame(
+    257 /* Publish */,
+    seq,
+    8 + subject.length + msgId.length + payload.length,
+    flags,
+    entryFlags
+  );
+  buf.writeUInt32LE(streamId2, HEADER_SIZE);
+  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4);
+  buf.writeUInt16LE(msgId.length, HEADER_SIZE + 6);
+  let off = HEADER_SIZE + 8;
+  subject.copy(buf, off);
+  off += subject.length;
+  msgId.copy(buf, off);
+  off += msgId.length;
+  payload.copy(buf, off);
+  return buf;
+}
+function packPublishWithReply(seq, streamId2, subject, replyTo, payload, flags = 0, entryFlags = 0) {
+  const tail = subject.length + replyTo.length + payload.length;
+  const buf = frame(260 /* PublishWithReply */, seq, 12 + tail, flags, entryFlags);
+  buf.writeUInt32LE(streamId2, HEADER_SIZE);
+  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4);
+  buf.writeUInt16LE(replyTo.length, HEADER_SIZE + 6);
+  buf.writeUInt32LE(0, HEADER_SIZE + 8);
+  let off = HEADER_SIZE + 12;
+  subject.copy(buf, off);
+  off += subject.length;
+  replyTo.copy(buf, off);
+  off += replyTo.length;
+  payload.copy(buf, off);
+  return buf;
+}
+function packPublishBatch(seq, streamId2, entries, flags = 0, entryFlags = 0) {
+  let tail = 0;
+  for (const e of entries) {
+    const midLen = e.msgId ? e.msgId.length : 0;
+    tail += 8 + e.subject.length + midLen + e.payload.length;
+  }
+  const buf = frame(259 /* PublishBatch */, seq, 8 + tail, flags, entryFlags);
+  buf.writeUInt32LE(streamId2, HEADER_SIZE);
+  buf.writeUInt32LE(entries.length, HEADER_SIZE + 4);
+  let off = HEADER_SIZE + 8;
+  for (const e of entries) {
+    const mid = e.msgId ?? EMPTY;
+    buf.writeUInt16LE(e.subject.length, off);
+    buf.writeUInt16LE(mid.length, off + 2);
+    buf.writeUInt32LE(e.payload.length, off + 4);
+    off += 8;
+    buf.write(e.subject, off);
+    off += e.subject.length;
+    mid.copy(buf, off);
+    off += mid.length;
+    e.payload.copy(buf, off);
+    off += e.payload.length;
+  }
+  return buf;
+}
+
+// src/proto/delivery.ts
+function packCold(action, seq, body) {
+  const utf8 = Buffer.from(JSON.stringify(body), "utf8");
+  const buf = frame(action, seq, utf8.length);
+  utf8.copy(buf, HEADER_SIZE);
+  return buf;
+}
+function packSubscribe(seq, _connId, consumerId, filter, _optionsFlags = 0) {
+  const filters = filter.length === 0 ? [] : [Array.from(filter)];
+  return packCold(769 /* Subscribe */, seq, {
+    consumer_id: consumerId >>> 0,
+    subscription_id: 0,
+    filters
+  });
+}
+function packUnsubscribe(seq, _connId, consumerId) {
+  return packCold(770 /* Unsubscribe */, seq, { consumer_id: consumerId >>> 0 });
+}
+function packAck(seq, consumerId, subjectHash, ackSeq) {
+  const buf = frame(513 /* Ack */, seq, 16);
+  buf.writeUInt32LE(consumerId, HEADER_SIZE);
+  buf.writeUInt32LE(subjectHash, HEADER_SIZE + 4);
+  buf.writeBigUInt64LE(ackSeq, HEADER_SIZE + 8);
+  return buf;
+}
+function packNack(seq, consumerId, subjectHash, nackSeq) {
+  const buf = frame(514 /* Nack */, seq, 16);
+  buf.writeUInt32LE(consumerId, HEADER_SIZE);
+  buf.writeUInt32LE(subjectHash, HEADER_SIZE + 4);
+  buf.writeBigUInt64LE(nackSeq, HEADER_SIZE + 8);
+  return buf;
+}
+function packBatchNack(seq, consumerId, entries) {
+  const buf = frame(522 /* BatchNack */, seq, 8 + entries.length * 16);
+  buf.writeUInt32LE(consumerId, HEADER_SIZE);
+  buf.writeUInt32LE(entries.length, HEADER_SIZE + 4);
+  let off = HEADER_SIZE + 8;
+  for (const e of entries) {
+    buf.writeBigUInt64LE(e.seq, off);
+    buf.writeUInt32LE(e.subjectHash, off + 8);
+    buf.writeUInt32LE(e.delayMs, off + 12);
+    off += 16;
+  }
+  return buf;
+}
+
+// src/proto/manage.ts
+function packCold2(action, seq, body) {
+  const utf8 = Buffer.from(JSON.stringify(body), "utf8");
+  const buf = frame(action, seq, utf8.length);
+  utf8.copy(buf, HEADER_SIZE);
+  return buf;
+}
+function bytesArr(b) {
+  return Array.from(b);
+}
+function packCreateStream(seq, name, filter, maxMsgs, maxBytes, maxAgeSecs, replicas = 1, journalKind = 0, retention = 0, discard = 0, idempotencyWindowMs = 0) {
+  return packCold2(1025 /* CreateStream */, seq, {
+    name: bytesArr(name),
+    filter: bytesArr(filter),
+    max_msgs: Number(maxMsgs),
+    // u64 — fits in JS number if < 2^53
+    max_bytes: Number(maxBytes),
+    max_age_secs: Number(maxAgeSecs),
+    replicas,
+    journal_kind: journalKind,
+    retention,
+    discard,
+    idempotency_window_ms: idempotencyWindowMs >>> 0
+  });
+}
+var packDeleteStream = (seq, name) => packCold2(1026 /* DeleteStream */, seq, { name: bytesArr(name) });
+var packGetStream = (seq, name) => packCold2(1027 /* GetStream */, seq, { name: bytesArr(name) });
+var packPurgeStream = (seq, name) => packCold2(1029 /* PurgeStream */, seq, { name: bytesArr(name) });
+var packDrainSubject = (seq, name, subject) => packCold2(1030 /* DrainSubject */, seq, {
+  name: bytesArr(name),
+  subject: bytesArr(subject)
+});
+var packListStreams = (seq, offset = 0, limit = 1e3) => packCold2(1028 /* ListStreams */, seq, { offset: offset >>> 0, limit: limit >>> 0 });
+function packCreateConsumer(seq, opts) {
+  const limits = (opts.subjectLimits ?? []).map((l) => ({
+    pattern: bytesArr(l.pattern),
+    limit: l.limit >>> 0
+  }));
+  return packCold2(1281 /* CreateConsumer */, seq, {
+    stream_id: opts.streamId >>> 0,
+    name: bytesArr(opts.name),
+    group: bytesArr(opts.group),
+    subject: bytesArr(opts.filter),
+    max_inflight: Math.min(opts.maxInflight ?? 0, 65535),
+    ack_policy: opts.ackPolicy ?? 1,
+    deliver_policy: opts.deliverPolicy ?? 0,
+    deliver_mode: opts.deliverMode ?? 0,
+    ack_wait_ms: (opts.ackWaitMs ?? 0) >>> 0,
+    start_seq: Number(opts.startSeq ?? 0n),
+    subject_limits: limits
+  });
+}
+var packDeleteConsumer = (seq, consumerId) => packCold2(1282 /* DeleteConsumer */, seq, { consumer_id: consumerId >>> 0 });
+var packGetConsumer = (seq, streamId2, name) => packCold2(1283 /* GetConsumer */, seq, {
+  stream_id: streamId2 >>> 0,
+  name: bytesArr(name)
+});
+var packListConsumers = (seq, streamId2 = 0, offset = 0, limit = 1e3) => packCold2(1284 /* ListConsumers */, seq, {
+  stream_id: streamId2 >>> 0,
+  offset: offset >>> 0,
+  limit: limit >>> 0
+});
+var packConsumerStats = (seq, consumerId) => packCold2(1285 /* ConsumerStats */, seq, { consumer_id: consumerId >>> 0 });
+
+// src/message/message.ts
+var BODY_OFF = HEADER_SIZE;
+var BODY_SIZE = 12;
+var TAIL_OFF = HEADER_SIZE + BODY_SIZE;
+var OFF_CONSUMER = BODY_OFF;
+var OFF_SUBJ_HASH = BODY_OFF + 4;
+var OFF_SUBJ_LEN = BODY_OFF + 8;
+var Message = class {
+  frame;
+  send;
+  seqFn;
+  _subjectLen;
+  constructor(frame2, send, seqFn) {
+    this.frame = frame2;
+    this.send = send;
+    this.seqFn = seqFn;
+  }
+  /** Delivery sequence — used to ack/nack this message. */
+  seq() {
+    return this.frame.readBigUInt64LE(OFF_SEQ);
+  }
+  /** Consumer ID that received this delivery. */
+  consumerId() {
+    return this.frame.readUInt32LE(OFF_CONSUMER);
+  }
+  /** Subject hash — echoed back in ack for O(1) credit release. */
+  subjectHash() {
+    return this.frame.readUInt32LE(OFF_SUBJ_HASH);
+  }
+  subjLen() {
+    return this._subjectLen ??= this.frame.readUInt16LE(OFF_SUBJ_LEN);
+  }
+  /** Zero-copy view of the subject bytes. */
+  subject() {
+    return this.frame.subarray(TAIL_OFF, TAIL_OFF + this.subjLen());
+  }
+  /** Zero-copy view of the payload bytes. */
+  data() {
+    return this.frame.subarray(TAIL_OFF + this.subjLen());
+  }
+  /** Acknowledge — fire-and-forget to broker. */
+  ack() {
+    this.send(packAck(
+      this.seqFn(),
+      this.consumerId(),
+      this.subjectHash(),
+      this.seq()
+    ));
+  }
+  /** Negative acknowledge — immediate requeue. */
+  nack() {
+    this.send(packNack(
+      this.seqFn(),
+      this.consumerId(),
+      this.subjectHash(),
+      this.seq()
+    ));
+  }
+  /** Negative acknowledge with redelivery delay (ms). */
+  nackDelay(ms) {
+    this.send(packBatchNack(
+      this.seqFn(),
+      this.consumerId(),
+      [{ seq: this.seq(), subjectHash: this.subjectHash(), delayMs: ms }]
+    ));
+  }
+};
+
+// src/subscription/subscription.ts
+var Subscription = class {
+  constructor(consumerId, conn, streamName, fetchTimeoutMs) {
+    this.consumerId = consumerId;
+    this.conn = conn;
+    this.streamName = streamName;
+    this.fetchTimeoutMs = fetchTimeoutMs;
+  }
+  callback;
+  fetchQueue = [];
+  msgBuf = [];
+  closed = false;
+  /** Consumer ID assigned by the server. */
+  id() {
+    return this.consumerId;
+  }
+  // Called by the delivery handler.
+  deliver(frame2) {
+    if (this.closed) return;
+    const msg = new Message(
+      frame2,
+      (f) => this.conn.send(f),
+      () => this.conn.nextSeq()
+    );
+    if (this.callback) {
+      this.callback(msg);
+      return;
+    }
+    const pending = this.fetchQueue[0];
+    if (pending) {
+      pending.buf.push(msg);
+      if (pending.buf.length >= pending.count) {
+        clearTimeout(pending.timer);
+        this.fetchQueue.shift();
+        pending.resolve(pending.buf);
+      }
+      return;
+    }
+    this.msgBuf.push(msg);
+  }
+  // Push mode — set a callback to receive messages as they arrive.
+  onMessage(cb) {
+    this.callback = cb;
+  }
+  // Pull mode — fetch up to `count` messages, waiting up to `timeoutMs`.
+  fetch(count, timeoutMs = this.fetchTimeoutMs) {
+    if (this.msgBuf.length >= count) {
+      return Promise.resolve(this.msgBuf.splice(0, count));
+    }
+    return new Promise((resolve) => {
+      const buf = this.msgBuf.splice(0);
+      const timer = setTimeout(() => {
+        const idx = this.fetchQueue.findIndex((p) => p === pending);
+        if (idx >= 0) this.fetchQueue.splice(idx, 1);
+        resolve(buf);
+      }, timeoutMs);
+      const pending = { resolve, count, buf, timer };
+      this.fetchQueue.push(pending);
+    });
+  }
+  close() {
+    this.closed = true;
+    this.conn.cancelSubscription(this.consumerId);
+    for (const p of this.fetchQueue) {
+      clearTimeout(p.timer);
+      p.resolve(p.buf);
+    }
+    this.fetchQueue = [];
+  }
+};
+
+// src/net/connection.ts
+var net = __toESM(require("net"));
+var tls = __toESM(require("tls"));
+
+// src/proto/framer.ts
+var ENVELOPE_MSG_LEN_OFF = 8;
+var Framer = class {
+  buf = Buffer.allocUnsafe(65536);
+  pos = 0;
+  push(chunk, onFrame) {
+    this.ensureCapacity(chunk.length);
+    chunk.copy(this.buf, this.pos);
+    this.pos += chunk.length;
+    let offset = 0;
+    while (offset < this.pos) {
+      if (this.pos - offset < HEADER_SIZE) break;
+      const action = this.buf.readUInt16LE(offset + OFF_ACTION);
+      const msgLen = action === 517 /* RepBatch */ || action === 519 /* FanoutBatch */ ? this.buf.readUInt32LE(offset + ENVELOPE_MSG_LEN_OFF) : this.buf.readUInt32LE(offset + OFF_MSG_LEN);
+      const frameLen = HEADER_SIZE + msgLen;
+      if (this.pos - offset < frameLen) break;
+      onFrame(Buffer.from(this.buf.subarray(offset, offset + frameLen)));
+      offset += frameLen;
+    }
+    if (offset > 0 && offset < this.pos) {
+      this.buf.copyWithin(0, offset, this.pos);
+    }
+    this.pos = offset < this.pos ? this.pos - offset : 0;
+  }
+  ensureCapacity(needed) {
+    if (this.pos + needed <= this.buf.length) return;
+    const next = Buffer.allocUnsafe(Math.max(this.buf.length * 2, this.pos + needed));
+    this.buf.copy(next, 0, 0, this.pos);
+    this.buf = next;
+  }
+};
+
+// src/common/logger.ts
+var noop = (() => {
+});
+var NOOP = {
+  trace: noop,
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop,
+  child: () => NOOP
+};
+function resolveLogger(logger) {
+  return logger ?? NOOP;
+}
+
+// src/net/connection.ts
+function parseAddr(addr) {
+  const i = addr.lastIndexOf(":");
+  return i === -1 ? { host: addr, port: 9898 } : { host: addr.slice(0, i), port: parseInt(addr.slice(i + 1), 10) };
+}
+var Connection = class _Connection {
+  constructor(socket, reconnectAddr, reconnectCfg, logger) {
+    this.reconnectAddr = reconnectAddr;
+    this.reconnectCfg = reconnectCfg;
+    this.log = resolveLogger(logger);
+    this.socket = socket;
+    this.attachSocket(socket);
+  }
+  seq = 1n;
+  connId = 0;
+  framer = new Framer();
+  routes = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  socket;
+  closing = false;
+  log;
+  activeSubs = /* @__PURE__ */ new Map();
+  metrics;
+  attachSocket(socket) {
+    socket.setNoDelay(true);
+    socket.on("data", (chunk) => this.framer.push(chunk, (f) => this.onFrame(f)));
+    socket.on("error", (err) => this.drain(err));
+    socket.on("close", () => this.handleClose());
+  }
+  static connect(addr, timeoutMs = 5e3, tlsCfg, reconnectCfg, logger) {
+    const parsed = parseAddr(addr);
+    const { host, port } = parsed;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new ArbitroError("connect timeout", "connect")),
+        timeoutMs
+      );
+      const done = (socket) => {
+        clearTimeout(timer);
+        const conn = new _Connection(socket, parsed, reconnectCfg, logger);
+        socket.write(packHello());
+        conn.log.info({ host, port }, "arbitro connected (v2)");
+        resolve(conn);
+      };
+      const fail = (e) => {
+        clearTimeout(timer);
+        reject(e);
+      };
+      if (tlsCfg) {
+        const s = tls.connect({
+          host,
+          port,
+          ca: tlsCfg.ca,
+          cert: tlsCfg.cert,
+          key: tlsCfg.key,
+          rejectUnauthorized: true
+        });
+        s.once("secureConnect", () => done(s));
+        s.once("error", fail);
+      } else {
+        const s = net.createConnection({ host, port });
+        s.once("connect", () => done(s));
+        s.once("error", fail);
+      }
+    });
+  }
+  nextSeq() {
+    return this.seq++;
+  }
+  /**
+   * Attach a metrics sink. Called by `ArbitroClient` after `connect()`.
+   * The connection bumps `deliveriesReceived` on every Deliver/RepBatch
+   * entry and `reconnects` on successful reconnections. Unset = no-op.
+   */
+  setMetrics(m) {
+    this.metrics = m;
+  }
+  // ── Frame routing ─────────────────────────────────────────────────────────
+  // Seq-based dispatch: match reply.header.seq → pending request. O(1).
+  resolvePending(frame2) {
+    const reqSeq = frame2.readBigUInt64LE(OFF_SEQ);
+    const p = this.pending.get(reqSeq);
+    if (!p) return;
+    this.pending.delete(reqSeq);
+    p.resolve(frame2);
+  }
+  rejectPending(frame2) {
+    const reqSeq = frame2.readBigUInt64LE(OFF_SEQ);
+    const p = this.pending.get(reqSeq);
+    if (!p) return;
+    this.pending.delete(reqSeq);
+    const errorCode = frame2.length >= HEADER_SIZE + 10 ? frame2.readUInt16LE(HEADER_SIZE + 8) : 0;
+    p.reject(new ArbitroError(
+      `server error (code=0x${errorCode.toString(16).padStart(4, "0")})`,
+      "server",
+      void 0,
+      void 0,
+      errorCode
+    ));
+  }
+  onFrame(frame2) {
+    const action = frame2.readUInt16LE(OFF_ACTION);
+    switch (action) {
+      case 515 /* RepOk */:
+      case 1028 /* ListStreams */:
+      case 1284 /* ListConsumers */: {
+        this.resolvePending(frame2);
+        return;
+      }
+      case 516 /* RepError */: {
+        this.rejectPending(frame2);
+        return;
+      }
+      case 512 /* Deliver */: {
+        const consumerId = frame2.readUInt32LE(HEADER_SIZE);
+        const handler = this.routes.get(consumerId);
+        if (!handler) {
+          this.log.warn({ consumerId }, "delivery for unknown consumer");
+          return;
+        }
+        if (this.metrics) this.metrics.deliveriesReceived++;
+        handler(frame2);
+        return;
+      }
+      case 517 /* RepBatch */: {
+        this.handleBatchDeliver(frame2);
+        return;
+      }
+      case 1538 /* Pong */:
+        return;
+      default: {
+        this.log.debug({ action: `0x${action.toString(16)}` }, "unknown action, dropped");
+      }
+    }
+  }
+  handleBatchDeliver(frame2) {
+    if (frame2.length < HEADER_SIZE + 4) return;
+    const count = frame2.readUInt16LE(HEADER_SIZE);
+    let off = HEADER_SIZE + 4;
+    for (let i = 0; i < count; i++) {
+      if (off + 24 > frame2.length) break;
+      const consumerId = frame2.readUInt32LE(off);
+      const deliverSeq = frame2.readBigUInt64LE(off + 4);
+      const subjectLen = frame2.readUInt16LE(off + 12);
+      const replyLen = frame2.readUInt16LE(off + 14);
+      const dataLen = frame2.readUInt32LE(off + 16);
+      const subjectHash = frame2.readUInt32LE(off + 20);
+      off += 24;
+      const tailEnd = off + dataLen;
+      if (tailEnd > frame2.length) break;
+      const payloadLen = dataLen - subjectLen - replyLen;
+      const handler = this.routes.get(consumerId);
+      if (handler) {
+        const bodyLen = 12 + subjectLen + payloadLen;
+        const single = Buffer.allocUnsafe(HEADER_SIZE + bodyLen);
+        single.writeUInt16LE(512 /* Deliver */, 0);
+        single[2] = 0;
+        single[3] = 0;
+        single.writeUInt32LE(bodyLen, 4);
+        single.writeBigUInt64LE(deliverSeq, 8);
+        single.writeUInt32LE(consumerId, HEADER_SIZE);
+        single.writeUInt32LE(subjectHash, HEADER_SIZE + 4);
+        single.writeUInt16LE(subjectLen, HEADER_SIZE + 8);
+        single.writeUInt16LE(0, HEADER_SIZE + 10);
+        frame2.copy(single, HEADER_SIZE + 12, off, off + subjectLen);
+        frame2.copy(
+          single,
+          HEADER_SIZE + 12 + subjectLen,
+          off + subjectLen + replyLen,
+          tailEnd
+        );
+        if (this.metrics) this.metrics.deliveriesReceived++;
+        handler(single);
+      }
+      off = tailEnd;
+    }
+  }
+  // ── Subscriptions ─────────────────────────────────────────────────────────
+  async sendSubscribeV2(consumerId, filter, handler, onRenew) {
+    return new Promise((resolve, reject) => {
+      const seq = this.nextSeq();
+      const timer = setTimeout(
+        () => {
+          this.pending.delete(seq);
+          reject(new ArbitroError("subscribe timeout", "timeout"));
+        },
+        5e3
+      );
+      this.pending.set(seq, {
+        resolve: (_frame) => {
+          clearTimeout(timer);
+          this.routes.set(consumerId, handler);
+          this.activeSubs.set(consumerId, { consumerId, filter, handler, onRenew });
+          resolve(consumerId);
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      });
+      this.socket.write(packSubscribe(seq, this.connId, consumerId, filter));
+    });
+  }
+  cancelSubscription(consumerId) {
+    this.routes.delete(consumerId);
+    this.activeSubs.delete(consumerId);
+    this.socket.write(packUnsubscribe(this.nextSeq(), this.connId, consumerId));
+  }
+  resubscribeAll() {
+    this.socket.write(packHello());
+    const subs = [...this.activeSubs.values()];
+    this.activeSubs.clear();
+    this.routes.clear();
+    for (const { consumerId, filter, handler, onRenew } of subs) {
+      this.sendSubscribeV2(consumerId, filter, handler, onRenew).then((id) => {
+        if (onRenew) onRenew(id);
+      }).catch(() => {
+      });
+    }
+  }
+  // ── Routes (internal use) ─────────────────────────────────────────────────
+  registerRoute(consumerId, handler) {
+    this.routes.set(consumerId, handler);
+  }
+  unregisterRoute(consumerId) {
+    this.routes.delete(consumerId);
+  }
+  // ── Write ─────────────────────────────────────────────────────────────────
+  send(frame2) {
+    this.socket.write(frame2);
+  }
+  /** Send frame and wait for RepOk. Returns the ref_seq from body. */
+  sendExpectReply(frame2, timeoutMs = 5e3) {
+    const seq = frame2.readBigUInt64LE(OFF_SEQ);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => {
+          this.pending.delete(seq);
+          reject(new ArbitroError("request timeout", "timeout"));
+        },
+        timeoutMs
+      );
+      this.pending.set(seq, {
+        resolve: (f) => {
+          clearTimeout(timer);
+          resolve(f.readBigUInt64LE(HEADER_SIZE));
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
+      this.socket.write(frame2);
+    });
+  }
+  /** Send frame and wait for full reply frame buffer. */
+  sendExpectReplyRaw(frame2, timeoutMs = 5e3) {
+    const seq = frame2.readBigUInt64LE(OFF_SEQ);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => {
+          this.pending.delete(seq);
+          reject(new ArbitroError("request timeout", "timeout"));
+        },
+        timeoutMs
+      );
+      this.pending.set(seq, {
+        resolve: (f) => {
+          clearTimeout(timer);
+          resolve(f);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
+      this.socket.write(frame2);
+    });
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  close() {
+    this.closing = true;
+    this.socket.write(packDisconnect(this.nextSeq()));
+    return new Promise((resolve) => this.socket.end(resolve));
+  }
+  drain(err) {
+    for (const p of this.pending.values()) p.reject(err);
+    this.pending.clear();
+  }
+  handleClose() {
+    this.log.debug("arbitro connection closed");
+    this.drain(new ArbitroError("connection closed", "closed"));
+    const cfg = this.reconnectCfg;
+    if (!this.closing && cfg && cfg.enabled !== false && this.reconnectAddr) {
+      this.tryReconnect(0);
+    }
+  }
+  tryReconnect(attempt) {
+    const cfg = this.reconnectCfg;
+    if (!cfg) return;
+    const max = cfg.maxAttempts ?? 10;
+    if (attempt >= max) {
+      this.log.warn({ attempt }, "reconnect exhausted");
+      return;
+    }
+    const base = cfg.intervalMs ?? 500;
+    const jitter = cfg.jitter !== false ? Math.random() * 100 : 0;
+    const delay = Math.min(base * 2 ** attempt, 3e4) + jitter;
+    this.log.debug({ attempt, delayMs: Math.round(delay) }, "reconnecting");
+    setTimeout(() => {
+      const { host, port } = this.reconnectAddr;
+      const socket = net.createConnection({ host, port });
+      socket.once("connect", () => {
+        this.log.info({ host, port, attempt }, "arbitro reconnected");
+        this.framer = new Framer();
+        this.socket = socket;
+        this.attachSocket(socket);
+        this.resubscribeAll();
+      });
+      socket.once("error", () => this.tryReconnect(attempt + 1));
+    }, delay);
+  }
+};
+
+// src/consumer/consumer.ts
+var Consumer = class {
+  constructor(client, streamName, config, _consumerId) {
+    this.client = client;
+    this.streamName = streamName;
+    this.config = config;
+    this._consumerId = _consumerId;
+  }
+  get name() {
+    return this.config.name ?? this.streamName;
+  }
+  get consumerId() {
+    return this._consumerId;
+  }
+  /**
+   * Publish through this consumer's stream. Returns `Promise<void>` that
+   * resolves on broker `RepOk`. Await to wait, or ignore for
+   * fire-and-forget semantics — the caller's choice, on the same call.
+   */
+  publish(subject, data) {
+    return this.client.publish(this.streamName, subject, data);
+  }
+  async create() {
+    const result = await this.client.createConsumer(this.streamName, this.config);
+    this._consumerId = result.consumerId;
+    return this;
+  }
+  async upsert() {
+    const result = await this.client.upsertConsumer(this.streamName, this.config);
+    this._consumerId = result.consumerId;
+    return this;
+  }
+  async delete() {
+    if (this._consumerId == null) throw new Error("consumer not created");
+    await this.client.deleteConsumer(this._consumerId);
+  }
+  async exists() {
+    return this.client.consumerExists(this.streamName, this.name);
+  }
+  /**
+   * Live pending-ack count for this consumer (delivered, not yet acked).
+   * Uses the cached consumer ID when available; otherwise looks it up
+   * from `streamName + name`. Equivalent of NATS `num_ack_pending`.
+   */
+  async getPendings() {
+    if (this._consumerId != null) {
+      return this.client.getPending(this._consumerId);
+    }
+    return this.client.getPending(this.streamName, this.name);
+  }
+  subscribe(codecOrCb, cbOrOpts, opts) {
+    if (!codecOrCb || typeof codecOrCb === "function") {
+      return this.client.subscribe(
+        this.streamName,
+        this.config,
+        codecOrCb,
+        cbOrOpts
+      );
+    }
+    const codec = codecOrCb;
+    const cb = cbOrOpts;
+    const fields = codec.fields ?? [];
+    return this.client.subscribe(this.streamName, this.config, (raw) => {
+      cb(makeLazyMessage(
+        raw.data(),
+        codec,
+        fields,
+        () => raw.ack(),
+        () => raw.nack(),
+        (ms) => raw.nackDelay(ms)
+      ));
+    }, opts);
+  }
+};
+
+// src/stream/stream.ts
+var Stream = class {
+  constructor(client, name, config) {
+    this.client = client;
+    this.name = name;
+    this._config = config;
+  }
+  _config;
+  get config() {
+    return this._config;
+  }
+  async create(config) {
+    const cfg = config ?? this._config;
+    if (!cfg) throw new Error("StreamConfig required \u2014 pass to create() or constructor");
+    this._config = cfg;
+    await this.client.createStream(this.name, cfg);
+    return this;
+  }
+  async upsert(config) {
+    const cfg = config ?? this._config;
+    if (!cfg) throw new Error("StreamConfig required \u2014 pass to upsert() or constructor");
+    this._config = cfg;
+    await this.client.upsertStream(this.name, cfg);
+    return this;
+  }
+  async delete(opts) {
+    await this.client.deleteStream(this.name, opts);
+  }
+  async exists() {
+    return this.client.streamExists(this.name);
+  }
+  async info() {
+    return this.client.getStreamInfo(this.name);
+  }
+  // ── Publish ─────────────────────────────────────────────────────────────
+  /**
+   * Publish to this stream. Returns a `Promise<void>` that resolves on
+   * broker `RepOk`. Await it to wait for confirmation, or ignore the
+   * returned promise for fire-and-forget semantics.
+   *
+   * Pass `opts.msgId` to opt this publish into broker-side dedup on
+   * streams created with `idempotencyWindowMs > 0`. Duplicate ids
+   * within the window are rejected with a `ClientError` carrying the
+   * `IdempotencyDuplicate` code.
+   */
+  publish(subject, data, opts) {
+    return this.client.publish(this.name, subject, data, opts);
+  }
+  /** @deprecated alias for {@link publish}. */
+  publishAck(subject, data, opts) {
+    return this.client.publish(this.name, subject, data, opts);
+  }
+  /** Batch publish — single V2 BatchPubFrame, ONE round-trip.
+   *  Resolves with `first_seq` (the N messages occupy
+   *  `[first_seq, first_seq + N - 1]`).
+   *
+   *  Like {@link publish}, the call always exchanges request/response
+   *  with the broker; the caller decides whether to wait via `await`. */
+  publishBatch(messages) {
+    return this.client.publishBatch(this.name, messages);
+  }
+  request(subject, data, timeoutMs) {
+    return this.client.request(this.name, subject, data, timeoutMs);
+  }
+  // ── Context factories ───────────────────────────────────────────────────
+  consumer(overrides) {
+    const config = {
+      ...overrides,
+      name: overrides?.name ?? this.name,
+      filter: overrides?.filter ?? `${this.name}.>`
+    };
+    return new Consumer(this.client, this.name, config);
+  }
+  topic(subject, codec) {
+    return new Topic(this, subject, codec);
+  }
+};
+
+// src/client/metrics.ts
+var ClientMetrics = class {
+  publishesSent = 0;
+  publishBatchEntries = 0;
+  deliveriesReceived = 0;
+  activeSubscriptions = 0;
+  acksSent = 0;
+  nacksSent = 0;
+  reconnects = 0;
+  pendingReplies = 0;
+  snapshot() {
+    return {
+      publishesSent: this.publishesSent,
+      publishBatchEntries: this.publishBatchEntries,
+      deliveriesReceived: this.deliveriesReceived,
+      activeSubscriptions: this.activeSubscriptions,
+      acksSent: this.acksSent,
+      nacksSent: this.nacksSent,
+      reconnects: this.reconnects,
+      pendingReplies: this.pendingReplies
+    };
+  }
+};
+
+// src/stream/publish.ts
+var EMPTY2 = Buffer.alloc(0);
+function toMsgIdBuf(id) {
+  if (id == null) return EMPTY2;
+  return typeof id === "string" ? Buffer.from(id) : id;
+}
+async function streamPublishAck(conn, sid, subject, data, opts) {
+  const subj = Buffer.from(subject);
+  await conn.sendExpectReply(
+    packPublish(conn.nextSeq(), sid, subj, data, 1 /* AckReq */, 0, toMsgIdBuf(opts?.msgId))
+  );
+}
+async function streamPublishBatch(conn, sid, messages) {
+  return await conn.sendExpectReply(
+    packPublishBatch(conn.nextSeq(), sid, messages)
+  );
+}
+async function streamRequest(conn, sid, subject, data, timeoutMs) {
+  const subj = Buffer.from(subject);
+  const replyTo = Buffer.from(`_INBOX.${conn.nextSeq().toString(36)}`);
+  const frame2 = packPublishWithReply(
+    conn.nextSeq(),
+    sid,
+    subj,
+    replyTo,
+    data,
+    1 /* AckReq */
+  );
+  await conn.sendExpectReply(frame2, timeoutMs);
+  return Buffer.alloc(0);
+}
+
+// src/client/client.ts
+var DEFAULT_CONFIG = {
+  servers: ["127.0.0.1:9898"],
+  prefix: "",
+  timeout: 5e3,
+  reconnect: { enabled: true, maxAttempts: 10, intervalMs: 500, jitter: true }
+};
+var ArbitroClient = class {
+  conn;
+  cfg;
+  tls;
+  logger;
+  sidCache = /* @__PURE__ */ new Map();
+  _metrics = new ClientMetrics();
+  constructor(config) {
+    this.cfg = { ...DEFAULT_CONFIG, ...config };
+    this.tls = config.tls;
+    this.logger = config.logger;
+  }
+  async connect() {
+    const addr = this.cfg.servers[0];
+    if (!addr) throw new ArbitroError("no servers configured", "connect");
+    this.conn = await Connection.connect(
+      addr,
+      this.cfg.timeout,
+      this.tls,
+      this.cfg.reconnect,
+      this.logger
+    );
+    this.conn.setMetrics(this._metrics);
+    return this;
+  }
+  /**
+   * Point-in-time snapshot of client counters: publishes sent, deliveries
+   * received, acks/nacks, active subscriptions, reconnects. Cheap — just
+   * reads plain integer fields. Call on a timer to chart throughput.
+   */
+  metrics() {
+    return this._metrics.snapshot();
+  }
+  /** Internal connection accessor for Stream/Consumer publish methods. */
+  _conn() {
+    return this.conn;
+  }
+  /** Default timeout from config. */
+  get timeout() {
+    return this.cfg.timeout;
+  }
+  // ── Publish (direct to stream via V2 PubFrame) ────────────────────────────
+  /** Apply prefix to subject if configured. */
+  prefixed(subject) {
+    return this.cfg.prefix ? `${this.cfg.prefix}.${subject}` : subject;
+  }
+  /**
+   * Publish a message. Returns a `Promise<void>` that resolves once the
+   * broker confirms receipt (`RepOk`). The TS idiom is "everything async,
+   * the caller chooses to await":
+   *
+   *   await client.publish(s, subj, data)               // wait for ack
+   *   client.publish(s, subj, data)                     // fire-and-forget
+   *   client.publish(s, subj, data).catch(handleError)  // async error path
+   *
+   * The broker always emits `RepOk` regardless of whether the caller
+   * awaits — that's what enables the same call site to support both
+   * semantics. A "no-reply" path doesn't save wire bytes, so it isn't
+   * exposed.
+   */
+  async publish(streamName, subject, data, opts) {
+    const sid = await this.resolveStreamId(streamName);
+    await streamPublishAck(this.conn, sid, this.prefixed(subject), data, opts);
+    this._metrics.publishesSent++;
+  }
+  /**
+   * @deprecated alias for {@link publish}. The default `publish` already
+   * waits for `RepOk` and returns a Promise, so this method is identical.
+   */
+  publishAck(streamName, subject, data, opts) {
+    return this.publish(streamName, subject, data, opts);
+  }
+  /** Batch publish — single V2 BatchPubFrame, ONE round-trip. Resolves
+   * to `first_seq` (sequence of the first message in the batch; the N
+   * messages occupy `[first_seq, first_seq + N - 1]`).
+   *
+   * Mirrors `publish`: the call always exchanges request/response with
+   * the broker. The caller decides whether to actually wait:
+   *
+   *   await client.publishBatch(stream, msgs)   // barrier
+   *   client.publishBatch(stream, msgs)         // fire-and-forget (promise dropped)
+   *   client.publishBatch(stream, msgs)         //   (suppress unhandled rejection)
+   *     .catch(() => {})
+   *
+   * Each entry may carry an optional `msgId` for broker-side dedup on
+   * streams created with `idempotencyWindowMs > 0`. If any entry
+   * collides with a previously-stored id (or another entry in the
+   * SAME batch), the whole batch is rejected — `publishBatch` is
+   * atomic.
+   */
+  publishBatch(streamName, messages) {
+    const sid = this.cachedSid(streamName);
+    const prefixedMsgs = this.cfg.prefix ? messages.map((m) => {
+      const entry = {
+        subject: this.prefixed(m.subject),
+        payload: m.payload
+      };
+      if (m.msgId !== void 0) entry.msgId = m.msgId;
+      return entry;
+    }) : messages;
+    this._metrics.publishBatchEntries += messages.length;
+    return streamPublishBatch(this.conn, sid, prefixedMsgs);
+  }
+  /** Request-reply. */
+  async request(streamName, subject, data, timeoutMs = this.cfg.timeout) {
+    const sid = await this.resolveStreamId(streamName);
+    return streamRequest(this.conn, sid, subject, data, timeoutMs);
+  }
+  async subscribe(streamName, configOrCb, callbackOrOpts, opts) {
+    let config;
+    let callback;
+    let subOpts;
+    if (typeof configOrCb === "function") {
+      config = { name: streamName, filter: "" };
+      callback = configOrCb;
+      subOpts = void 0;
+    } else {
+      config = configOrCb;
+      callback = typeof callbackOrOpts === "function" ? callbackOrOpts : void 0;
+      subOpts = typeof callbackOrOpts === "object" ? callbackOrOpts : opts;
+    }
+    const consumerId = await this.ensureConsumer(streamName, config);
+    const filter = Buffer.from(config.filter ?? "");
+    const sub = new Subscription(consumerId, this.conn, streamName, subOpts?.fetchTimeoutMs ?? 5e3);
+    const handler = (frame2) => sub.deliver(frame2);
+    await this.conn.sendSubscribeV2(consumerId, filter, handler);
+    this._metrics.activeSubscriptions++;
+    const origClose = sub.close.bind(sub);
+    sub.close = () => {
+      if (this._metrics.activeSubscriptions > 0) this._metrics.activeSubscriptions--;
+      return origClose();
+    };
+    if (callback) sub.onMessage(callback);
+    return sub;
+  }
+  // ── Stream management ─────────────────────────────────────────────────────
+  async createStream(name, config) {
+    const nameBuf = Buffer.from(name);
+    const filterBuf = Buffer.from(config.subjectFilter ?? "");
+    const maxMsgs = BigInt(config.maxMsgs ?? 0);
+    const maxBytes = BigInt(config.maxBytes ?? 0);
+    const maxAgeSecs = BigInt(config.maxAgeMs ? Math.ceil(config.maxAgeMs / 1e3) : 0);
+    const journalKind = journalTypeToU8(config.journal?.type);
+    await this.conn.sendExpectReply(packCreateStream(
+      this.conn.nextSeq(),
+      nameBuf,
+      filterBuf,
+      maxMsgs,
+      maxBytes,
+      maxAgeSecs,
+      1,
+      journalKind,
+      0,
+      0,
+      config.idempotencyWindowMs ?? 0
+    ));
+    await this.resolveStreamId(name);
+    return new Stream(this, name, config);
+  }
+  async upsertStream(name, config) {
+    try {
+      return await this.createStream(name, config);
+    } catch (e) {
+      if (e?.message?.includes("code=")) {
+        await this.resolveStreamId(name);
+        return new Stream(this, name, config);
+      }
+      throw e;
+    }
+  }
+  async deleteStream(name, _opts) {
+    await this.conn.sendExpectReply(
+      packDeleteStream(this.conn.nextSeq(), Buffer.from(name))
+    );
+    this.sidCache.delete(name);
+  }
+  async getStreamInfo(name) {
+    try {
+      const refSeq = await this.conn.sendExpectReply(
+        packGetStream(this.conn.nextSeq(), Buffer.from(name))
+      );
+      this.sidCache.set(name, Number(refSeq & 0xFFFFFFFFn));
+      return { name, config: { subjectFilter: "" }, lastSeq: Number(refSeq) };
+    } catch {
+      return null;
+    }
+  }
+  async listStreams() {
+    const raw = await this.conn.sendExpectReplyRaw(
+      packListStreams(this.conn.nextSeq())
+    );
+    return parseListStreamsReply(raw);
+  }
+  async streamExists(name) {
+    return await this.getStreamInfo(name) !== null;
+  }
+  async purgeStream(name) {
+    const refSeq = await this.conn.sendExpectReply(
+      packPurgeStream(this.conn.nextSeq(), Buffer.from(name))
+    );
+    return Number(refSeq);
+  }
+  async drainSubject(streamName, subject) {
+    const refSeq = await this.conn.sendExpectReply(
+      packDrainSubject(this.conn.nextSeq(), Buffer.from(streamName), Buffer.from(subject))
+    );
+    return Number(refSeq);
+  }
+  // ── Consumer management ───────────────────────────────────────────────────
+  async createConsumer(streamName, config) {
+    const consumerId = await this.createConsumerRaw(streamName, config);
+    return new Consumer(this, streamName, config, consumerId);
+  }
+  async createConsumerRaw(streamName, config) {
+    const sid = await this.resolveStreamId(streamName);
+    const name = Buffer.from(config.name ?? streamName);
+    const group = Buffer.from(config.name ?? streamName);
+    const filter = Buffer.from(config.filter ?? "");
+    const ackPolicyByte = config.ackPolicy === "none" /* None */ ? 0 : 1;
+    const opts = {
+      streamId: sid,
+      name,
+      group,
+      filter,
+      maxInflight: config.maxAckPending ?? 0,
+      ackPolicy: ackPolicyByte,
+      deliverPolicy: deliverPolicyToU8(config.deliverPolicy),
+      deliverMode: config.fanout ? 1 : 0,
+      ackWaitMs: config.ackWaitMs ?? 0,
+      startSeq: BigInt(config.startSeq ?? 0)
+    };
+    if (ackPolicyByte === 1 && config.maxSubjectInflights?.length) {
+      opts.subjectLimits = config.maxSubjectInflights.map((l) => ({
+        pattern: Buffer.from(l.pattern),
+        limit: l.limit >>> 0
+        // u32
+      }));
+    }
+    const refSeq = await this.conn.sendExpectReply(
+      packCreateConsumer(this.conn.nextSeq(), opts)
+    );
+    return Number(refSeq);
+  }
+  async upsertConsumer(streamName, config) {
+    try {
+      return await this.createConsumer(streamName, config);
+    } catch (e) {
+      const consumerId = await this.getConsumerId(streamName, config.name ?? streamName);
+      if (consumerId !== null) return new Consumer(this, streamName, config, consumerId);
+      throw e;
+    }
+  }
+  async deleteConsumer(idOrStream, name) {
+    let consumerId;
+    if (typeof idOrStream === "number") {
+      consumerId = idOrStream;
+    } else {
+      const id = await this.getConsumerId(idOrStream, name);
+      if (id === null) return;
+      consumerId = id;
+    }
+    await this.conn.sendExpectReply(
+      packDeleteConsumer(this.conn.nextSeq(), consumerId)
+    );
+  }
+  async getConsumerId(streamName, name) {
+    try {
+      const sid = await this.resolveStreamId(streamName);
+      const refSeq = await this.conn.sendExpectReply(
+        packGetConsumer(this.conn.nextSeq(), sid, Buffer.from(name))
+      );
+      return Number(refSeq);
+    } catch {
+      return null;
+    }
+  }
+  async consumerExists(streamName, name) {
+    return await this.getConsumerId(streamName, name) !== null;
+  }
+  async getPending(idOrStream, name) {
+    let consumerId;
+    if (typeof idOrStream === "number") {
+      consumerId = idOrStream;
+    } else {
+      const id = await this.getConsumerId(idOrStream, name);
+      if (id === null) return 0;
+      consumerId = id;
+    }
+    const refSeq = await this.conn.sendExpectReply(
+      packConsumerStats(this.conn.nextSeq(), consumerId)
+    );
+    return Number(refSeq);
+  }
+  async getConsumerInfo(streamName, name) {
+    const id = await this.getConsumerId(streamName, name);
+    if (id === null) return null;
+    return { group: name, stream: streamName, config: { name } };
+  }
+  async listConsumers(streamName) {
+    const sid = streamName ? await this.resolveStreamId(streamName) : 0;
+    const raw = await this.conn.sendExpectReplyRaw(
+      packListConsumers(this.conn.nextSeq(), sid)
+    );
+    return parseListConsumersReply(raw);
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────────
+  /** Resolve stream name → server wire_hash_32. Caches the result. */
+  async resolveStreamId(name) {
+    const cached = this.sidCache.get(name);
+    if (cached !== void 0) return cached;
+    const refSeq = await this.conn.sendExpectReply(
+      packGetStream(this.conn.nextSeq(), Buffer.from(name))
+    );
+    const sid = Number(refSeq & 0xFFFFFFFFn);
+    this.sidCache.set(name, sid);
+    return sid;
+  }
+  /** Get cached stream_id or throw (for sync fire-and-forget paths). */
+  cachedSid(name) {
+    const sid = this.sidCache.get(name);
+    if (sid === void 0) {
+      throw new ArbitroError(
+        `stream "${name}" not resolved \u2014 call createStream/getStreamInfo first`,
+        "protocol"
+      );
+    }
+    return sid;
+  }
+  async ensureConsumer(streamName, config) {
+    const name = config.name ?? streamName;
+    const existing = await this.getConsumerId(streamName, name);
+    if (existing !== null) return existing;
+    return this.createConsumerRaw(streamName, config);
+  }
+  // ── Domain helpers ────────────────────────────────────────────────────────
+  /** Pre-resolve stream_id from server (GetStream). Required before sync publish(). */
+  async resolveStream(name) {
+    await this.resolveStreamId(name);
+  }
+  stream(name, config) {
+    return new Stream(this, name, config);
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  async close() {
+    await this.conn.close();
+  }
+};
+function parseListStreamsReply(frame2) {
+  if (frame2.length < HEADER_SIZE + 4) return [];
+  const count = frame2.readUInt32LE(HEADER_SIZE);
+  const results = [];
+  let off = HEADER_SIZE + 4;
+  for (let i = 0; i < count; i++) {
+    if (off + 6 > frame2.length) break;
+    const wireId = frame2.readUInt32LE(off);
+    const nameLen = frame2.readUInt16LE(off + 4);
+    off += 6;
+    const name = frame2.subarray(off, off + nameLen).toString();
+    off += nameLen;
+    results.push({ name, config: { subjectFilter: "" }, lastSeq: wireId });
+  }
+  return results;
+}
+function parseListConsumersReply(frame2) {
+  if (frame2.length < HEADER_SIZE + 4) return [];
+  const count = frame2.readUInt32LE(HEADER_SIZE);
+  const results = [];
+  let off = HEADER_SIZE + 4;
+  for (let i = 0; i < count; i++) {
+    if (off + 13 > frame2.length) break;
+    const consumerId = frame2.readUInt32LE(off);
+    const _streamId = frame2.readUInt32LE(off + 4);
+    const _queueId = frame2.readUInt32LE(off + 8);
+    const _paused = frame2[off + 12];
+    off += 13;
+    results.push({
+      group: consumerId.toString(),
+      stream: "",
+      config: { name: consumerId.toString() }
+    });
+  }
+  return results;
+}
+function deliverPolicyToU8(policy) {
+  switch (policy) {
+    case "All" /* All */:
+      return 0;
+    case "New" /* New */:
+      return 1;
+    case "ByStartSeq" /* BySeq */:
+      return 2;
+    case "ByStartTime" /* ByTime */:
+      return 3;
+    default:
+      return 0;
+  }
+}
+function journalTypeToU8(type) {
+  switch (type) {
+    case "Memory" /* Memory */:
+      return 0;
+    case "Tolerant" /* Tolerant */:
+      return 1;
+    case "Strict" /* Strict */:
+      return 2;
+    default:
+      return 0;
+  }
+}
+
+// src/proto/fnv1a.ts
+function streamId(name) {
+  const buf = typeof name === "string" ? Buffer.from(name) : name;
+  let h = 2166136261;
+  for (let i = 0; i < buf.length; i++) {
+    h ^= buf[i];
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+
+// src/utils/zod.ts
+var import_msgpackr2 = require("msgpackr");
+var packr = new import_msgpackr2.Packr({ structuredClone: false, useRecords: false });
+var unpackr = new import_msgpackr2.Unpackr({ structuredClone: false, useRecords: false });
+function zodCodec(zodSchema) {
+  const fields = Object.keys(zodSchema.shape);
+  return {
+    fields,
+    encode(value) {
+      return Buffer.from(packr.pack(value));
+    },
+    decode(buf) {
+      return zodSchema.parse(unpackr.unpack(buf));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AckPolicy,
+  ArbitroClient,
+  ArbitroError,
+  Codec,
+  Consumer,
+  DeliverPolicy,
+  ErrorCode,
+  JournalType,
+  JsonCodec,
+  Message,
+  Stream,
+  StringCodec,
+  Subscription,
+  Topic,
+  decodeJson,
+  decodeString,
+  encodeJson,
+  encodeString,
+  makeLazyMessage,
+  schema,
+  streamId,
+  zodCodec
+});
+//# sourceMappingURL=index.js.map