@versori/run 0.6.1 → 0.6.3

package/esm/deps/jsr.io/@nats-io/jetstream/3.4.0/src/jsclient.js

@@ -0,0 +1,763 @@
+/*
+ * Copyright 2022-2026 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BaseApiClientImpl, parseJsResponse } from "./jsbaseclient_api.js";
+import { ConsumerAPIImpl } from "./jsmconsumer_api.js";
+import { backoff, createInbox, deadline, deferred, delay, Empty, errors, headers, nuid, QueuedIteratorImpl, RequestError, } from "../../../nats-core/3.4.0/src/internal_mod.js";
+import { ConsumersImpl, StreamAPIImpl, StreamsImpl } from "./jsmstream_api.js";
+import { PubHeaders } from "./jsapi_types.js";
+import { JetStreamError, JetStreamNotEnabled } from "./jserrors.js";
+import { DirectStreamAPIImpl } from "./jsm_direct.js";
+/**
+ * Starts a fast-ingest batch on the stream that consumes `subj`. Internal
+ * export — exposed via `@nats-io/jetstream/internal` and intended for
+ * companion packages to wrap. Not part of the public {@link JetStreamClient}
+ * API.
+ */
+export function startFastIngest(nc, subj, payload, opts, defaultTimeout = 5000) {
+    const { ackInterval, allowGaps, inboxPrefix, maxOutstandingAcks, ...publishOpts } = opts;
+    const prefix = inboxPrefix ?? "_INBOX";
+    if (!prefix || /\s/.test(prefix) || /[*>]/.test(prefix)) {
+        return Promise.reject(new Error(`inboxPrefix must be non-empty, no wildcards or whitespace (got "${prefix}")`));
+    }
+    const o = {
+        ackInterval: ackInterval ?? 10,
+        allowGaps,
+        inboxPrefix: prefix,
+        maxOutstandingAcks: Math.min(3, Math.max(1, maxOutstandingAcks ?? 2)),
+    };
+    const fi = new FastIngestImpl(nc, o, subj, defaultTimeout);
+    return fi.start(payload, publishOpts).then(() => fi);
+}
+function buildPublishHeaders(opts) {
+    const expect = opts.expect || {};
+    const mh = opts.headers || headers();
+    if (opts.msgID) {
+        mh.set(PubHeaders.MsgIdHdr, opts.msgID);
+    }
+    if (expect.lastMsgID) {
+        mh.set(PubHeaders.ExpectedLastMsgIdHdr, expect.lastMsgID);
+    }
+    if (expect.streamName) {
+        mh.set(PubHeaders.ExpectedStreamHdr, expect.streamName);
+    }
+    if (typeof expect.lastSequence === "number") {
+        mh.set(PubHeaders.ExpectedLastSeqHdr, `${expect.lastSequence}`);
+    }
+    if (typeof expect.lastSubjectSequence === "number") {
+        mh.set(PubHeaders.ExpectedLastSubjectSequenceHdr, `${expect.lastSubjectSequence}`);
+    }
+    if (expect.lastSubjectSequenceSubject) {
+        mh.set(PubHeaders.ExpectedLastSubjectSequenceSubjectHdr, expect.lastSubjectSequenceSubject);
+    }
+    if (opts.ttl) {
+        mh.set(PubHeaders.MessageTTL, `${opts.ttl}`);
+    }
+    if (opts.schedule && opts.cancelSchedule) {
+        throw new Error("schedule and cancelSchedule are mutually exclusive");
+    }
+    if (opts.schedule) {
+        const so = opts.schedule;
+        if (so.specification) {
+            mh.set(PubHeaders.Schedule, scheduleSpecToHeader(so.specification));
+        }
+        if (so.target) {
+            mh.set(PubHeaders.ScheduleTarget, so.target);
+        }
+        if (so.source) {
+            mh.set(PubHeaders.ScheduleSource, so.source);
+        }
+        if (so.ttl) {
+            mh.set(PubHeaders.ScheduleTTL, so.ttl);
+        }
+        if (so.timezone) {
+            mh.set(PubHeaders.ScheduleTimeZone, so.timezone);
+        }
+        if (so.rollup) {
+            mh.set(PubHeaders.ScheduleRollup, so.rollup);
+        }
+    }
+    if (opts.cancelSchedule) {
+        mh.set(PubHeaders.Scheduler, opts.cancelSchedule.scheduleSubject);
+        mh.set(PubHeaders.ScheduleNext, "purge");
+    }
+    return mh;
+}
+export function toJetStreamClient(nc) {
+    //@ts-ignore: see if we have a nc
+    if (typeof nc.nc === "undefined") {
+        return jetstream(nc);
+    }
+    return nc;
+}
+/**
+ * Returns a {@link JetStreamClient} supported by the specified NatsConnection
+ * @param nc
+ * @param opts
+ */
+export function jetstream(nc, opts = {}) {
+    return new JetStreamClientImpl(nc, opts);
+}
+/**
+ * Returns a {@link JetStreamManager} supported by the specified NatsConnection
+ * @param nc
+ * @param opts
+ */
+export async function jetstreamManager(nc, opts = {}) {
+    const adm = new JetStreamManagerImpl(nc, opts);
+    if (opts.checkAPI !== false) {
+        try {
+            await adm.getAccountInfo();
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    return adm;
+}
+export class JetStreamManagerImpl extends BaseApiClientImpl {
+    constructor(nc, opts) {
+        super(nc, opts);
+        Object.defineProperty(this, "streams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "consumers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "direct", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.streams = new StreamAPIImpl(nc, opts);
+        this.consumers = new ConsumerAPIImpl(nc, opts);
+        this.direct = new DirectStreamAPIImpl(nc, opts);
+    }
+    async getAccountInfo() {
+        const r = await this._request(`${this.prefix}.INFO`);
+        return r;
+    }
+    jetstream() {
+        return jetstream(this.nc, this.getOptions());
+    }
+    advisories() {
+        const iter = new QueuedIteratorImpl();
+        this.nc.subscribe(`$JS.EVENT.ADVISORY.>`, {
+            callback: (err, msg) => {
+                if (err) {
+                    throw err;
+                }
+                try {
+                    const d = this.parseJsResponse(msg);
+                    const chunks = d.type.split(".");
+                    const kind = chunks[chunks.length - 1];
+                    iter.push({ kind: kind, data: d });
+                }
+                catch (err) {
+                    iter.stop(err);
+                }
+            },
+        });
+        return iter;
+    }
+}
+/**
+ * Converts a {@link ScheduleSpec}, `Date`, or raw header string into the
+ * value sent on the `Nats-Schedule` header.
+ *
+ * Validates `every` interval is at least 1s (server minimum).
+ *
+ * @internal exported for testing only
+ */
+export function scheduleSpecToHeader(spec) {
+    if (typeof spec === "string") {
+        return spec;
+    }
+    if (spec instanceof Date) {
+        return `@at ${spec.toISOString()}`;
+    }
+    if ("at" in spec) {
+        const iso = spec.at instanceof Date ? spec.at.toISOString() : spec.at;
+        return `@at ${iso}`;
+    }
+    if ("every" in spec) {
+        assertEveryAtLeastOneSecond(spec.every);
+        return `@every ${spec.every}`;
+    }
+    if ("cron" in spec) {
+        return spec.cron;
+    }
+    if ("predefined" in spec) {
+        return spec.predefined;
+    }
+    throw new Error("invalid schedule specification");
+}
+function assertEveryAtLeastOneSecond(d) {
+    const trimmed = d.trim();
+    const re = /(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/g;
+    let totalMs = 0;
+    let pos = 0;
+    let m;
+    while ((m = re.exec(trimmed)) !== null) {
+        if (m.index !== pos)
+            break;
+        pos += m[0].length;
+        const n = parseFloat(m[1]);
+        const unit = m[2];
+        totalMs += unit === "ns"
+            ? n / 1e6
+            : unit === "us" || unit === "µs"
+                ? n / 1e3
+                : unit === "ms"
+                    ? n
+                    : unit === "s"
+                        ? n * 1e3
+                        : unit === "m"
+                            ? n * 60_000
+                            : n * 3_600_000;
+    }
+    if (trimmed === "" || pos !== trimmed.length) {
+        throw new Error(`@every: unrecognized duration format: "${d}"`);
+    }
+    if (totalMs < 1000) {
+        throw new Error("@every interval must be at least 1s");
+    }
+}
+export class JetStreamClientImpl extends BaseApiClientImpl {
+    constructor(nc, opts) {
+        super(nc, opts);
+        Object.defineProperty(this, "consumers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "consumerAPI", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streamAPI", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.consumerAPI = new ConsumerAPIImpl(nc, opts);
+        this.streamAPI = new StreamAPIImpl(nc, opts);
+        this.consumers = new ConsumersImpl(this.consumerAPI);
+        this.streams = new StreamsImpl(this.streamAPI);
+    }
+    jetstreamManager(checkAPI) {
+        if (checkAPI === undefined) {
+            checkAPI = this.opts.checkAPI;
+        }
+        const opts = Object.assign({}, this.opts, { checkAPI });
+        // fail early if watcherPrefix is bad
+        try {
+            createInbox(opts.watcherPrefix);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        return jetstreamManager(this.nc, opts);
+    }
+    get apiPrefix() {
+        return this.prefix;
+    }
+    startBatch(subj, payload, opts) {
+        const d = deferred();
+        const bp = new BatchPublisherImpl(this);
+        bp.first(subj, payload, opts)
+            .then(() => {
+            d.resolve(bp);
+        })
+            .catch((err) => {
+            d.reject(err);
+        });
+        return d;
+    }
+    async _publish(subj, data = Empty, opts) {
+        opts = opts || {};
+        opts = { ...opts };
+        if (opts.cancelSchedule &&
+            opts.cancelSchedule.scheduleSubject === subj) {
+            throw new Error("cancelSchedule.scheduleSubject must not equal the publish subject");
+        }
+        const mh = buildPublishHeaders(opts);
+        const to = opts.timeout || this.timeout;
+        const ro = {};
+        if (to) {
+            ro.timeout = to;
+        }
+        if (opts) {
+            ro.headers = mh;
+        }
+        let { retries } = opts;
+        retries = retries || 1;
+        const bo = backoff();
+        let r = null;
+        for (let i = 0; i < retries; i++) {
+            try {
+                r = await this.nc.request(subj, data, ro);
+                // if here we succeeded
+                break;
+            }
+            catch (err) {
+                const re = err instanceof RequestError ? err : null;
+                if ((err instanceof errors.TimeoutError || re?.isNoResponders()) &&
+                    i + 1 < retries) {
+                    await delay(bo.backoff(i));
+                }
+                else {
+                    throw re?.isNoResponders()
+                        ? new JetStreamNotEnabled(`jetstream is not enabled`, {
+                            cause: err,
+                        })
+                        : err;
+                }
+            }
+        }
+        return r;
+    }
+    async publish(subj, data = Empty, opts) {
+        const r = await this._publish(subj, data, opts);
+        const pa = this.parseJsResponse(r);
+        if (pa.stream === "") {
+            throw new JetStreamError("invalid ack response");
+        }
+        pa.duplicate = pa.duplicate ? pa.duplicate : false;
+        return pa;
+    }
+}
+export class BatchPublisherImpl {
+    constructor(js) {
+        Object.defineProperty(this, "nc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "js", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.count = 0;
+        this.id = nuid.next();
+        this.js = js;
+        this.nc = this.js.nc;
+        this.done = false;
+    }
+    async first(subj, payload, opts) {
+        opts = opts || {};
+        opts.headers = opts?.headers || headers();
+        opts.headers.set("Nats-Batch-Id", this.id);
+        this.count++;
+        opts.headers.set("Nats-Batch-Sequence", this.count.toString());
+        const r = await this.js._publish(subj, payload, opts);
+        if (r.data.length > 0) {
+            this.js.parseJsResponse(r);
+        }
+    }
+    add(subj, payload, opts = { ack: false }) {
+        if (this.done) {
+            throw new Error("batch publisher is done");
+        }
+        opts.headers = opts?.headers || headers();
+        opts.headers.set("Nats-Batch-Id", this.id);
+        this.count++;
+        opts.headers.set("Nats-Batch-Sequence", this.count.toString());
+        const hasAck = "ack" in opts && opts.ack === true;
+        if (hasAck) {
+            const d = deferred();
+            this.js._publish(subj, payload, {
+                headers: opts.headers,
+                timeout: opts.timeout,
+            }).then((m) => {
+                if (m.data.length > 0) {
+                    this.js.parseJsResponse(m);
+                }
+                d.resolve();
+            }).catch((err) => {
+                this.done = true;
+                d.reject(err);
+            });
+            return d;
+        }
+        else {
+            return this.nc.publish(subj, payload, { headers: opts.headers });
+        }
+    }
+    async commit(subj, payload, opts = {}) {
+        if (this.done) {
+            throw new Error("batch publisher is done");
+        }
+        else {
+            this.done = true;
+        }
+        opts.headers = opts?.headers || headers();
+        opts.headers.set("Nats-Batch-Id", this.id);
+        this.count++;
+        opts.headers.set("Nats-Batch-Sequence", this.count.toString());
+        opts.headers.set("Nats-Batch-Commit", "1");
+        const r = await this.js._publish(subj, payload, {
+            headers: opts.headers,
+            timeout: opts.timeout || 0,
+        });
+        const ack = r.json();
+        if (ack.count !== this.count) {
+            throw new Error("batch didn't contain number of published messages");
+        }
+        return ack;
+    }
+}
+const BATCH_CLOSED = "batch closed";
+const FastIngestOp = {
+    Start: 0,
+    Append: 1,
+    Final: 2,
+    EOB: 3,
+    Ping: 4,
+};
+class FastIngestImpl {
+    constructor(nc, opts, firstSubj, defaultTimeout) {
+        Object.defineProperty(this, "batch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "batchSubj", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gapMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initialFlow", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "seq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "acked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ackInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inboxPrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxOutstandingAcks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gapIter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sub", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closeErr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "startDeferred", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closedDeferred", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.nc = nc;
+        this.batchSubj = firstSubj;
+        this.gapMode = opts.allowGaps ? "ok" : "fail";
+        this.initialFlow = opts.ackInterval;
+        this.inboxPrefix = opts.inboxPrefix;
+        this.maxOutstandingAcks = opts.maxOutstandingAcks;
+        this.defaultTimeout = defaultTimeout;
+        this.batch = nuid.next();
+        this.seq = 0;
+        this.acked = 0;
+        this.ackInterval = opts.ackInterval;
+        this.pending = new Map();
+        this.closed = false;
+        this.startDeferred = deferred();
+        this.closedDeferred = deferred();
+        // swallow unhandled rejection if caller never attaches to done()
+        this.closedDeferred.catch(() => { });
+        this.startDeferred.catch(() => { });
+        const inbox = `${this.inboxPrefix}.${this.batch}.>`;
+        this.sub = this.nc.subscribe(inbox, {
+            callback: (err, msg) => this.route(err, msg),
+        });
+    }
+    replyFor(op, seq) {
+        return `${this.inboxPrefix}.${this.batch}.${this.initialFlow}.${this.gapMode}.${seq}.${op}.$FI`;
+    }
+    start(payload, opts) {
+        this.seq = 1;
+        const rs = this.replyFor(FastIngestOp.Start, 1);
+        const headers = opts ? buildPublishHeaders(opts) : undefined;
+        this.nc.publish(this.batchSubj, payload, { reply: rs, headers });
+        return this.deadlineOrClose(this.startDeferred, opts?.timeout ?? this.defaultTimeout);
+    }
+    deadlineOrClose(p, ms) {
+        return deadline(p, ms).catch((err) => {
+            if (!this.closed)
+                this.close(err);
+            throw err;
+        });
+    }
+    route(err, m) {
+        if (err) {
+            this.close(err);
+            return;
+        }
+        let data;
+        try {
+            data = parseJsResponse(m);
+        }
+        catch (err) {
+            this.close(err);
+            return;
+        }
+        // terminal pub ack (has `batch` field — discriminates from BatchFlowAck)
+        if ("batch" in data && typeof data.batch === "string") {
+            const ack = data;
+            const e = this.pending.get(m.subject);
+            if (e && (e.op === FastIngestOp.Final || e.op === FastIngestOp.EOB)) {
+                e.deferred.resolve(ack);
+                this.pending.delete(m.subject);
+            }
+            // resolve any stragglers (adds/pings awaiting flow ack) — batch is committed
+            for (const [, entry] of this.pending) {
+                if (entry.op === FastIngestOp.Append ||
+                    entry.op === FastIngestOp.Ping) {
+                    entry.deferred.resolve({ batchSeq: entry.seq, ackSeq: this.acked });
+                }
+                else {
+                    entry.deferred.reject(new Error(BATCH_CLOSED));
+                }
+            }
+            this.pending.clear();
+            this.resolveStart();
+            this.closedDeferred.resolve(ack);
+            this.closed = true;
+            this.gapIter?.stop();
+            this.sub.unsubscribe();
+            return;
+        }
+        const typed = data;
+        if (typed.type === "gap") {
+            if (this.gapIter) {
+                const g = data;
+                this.gapIter.push({ lastSeq: g.last_seq, seq: g.seq });
+            }
+            return;
+        }
+        // type:"err" is never reached here — parseJsResponse above throws on the
+        // nested `.error` field, which then closes the batch via the outer catch.
+        const fa = data;
+        if (typeof fa.msgs === "number")
+            this.ackInterval = fa.msgs;
+        // cumulative: advance, never regress, so a later ack covers lost earlier ones
+        if (typeof fa.seq === "number" && fa.seq > this.acked) {
+            this.acked = fa.seq;
+        }
+        this.resolveStart();
+        // exact-subject resolution: ping's flow ack or a blocked add
+        const exact = this.pending.get(m.subject);
+        if (exact &&
+            (exact.op === FastIngestOp.Append || exact.op === FastIngestOp.Ping)) {
+            exact.deferred.resolve({ batchSeq: exact.seq, ackSeq: this.acked });
+            this.pending.delete(m.subject);
+        }
+        // slide window: any blocked adds now within the allowed window resolve
+        for (const [rs, e] of this.pending) {
+            if (e.op === FastIngestOp.Append &&
+                e.seq - this.acked < this.ackInterval * this.maxOutstandingAcks) {
+                e.deferred.resolve({ batchSeq: e.seq, ackSeq: this.acked });
+                this.pending.delete(rs);
+            }
+        }
+    }
+    resolveStart() {
+        this.startDeferred.resolve();
+    }
+    close(err) {
+        this.closed = true;
+        this.closeErr = err;
+        for (const [, e] of this.pending)
+            e.deferred.reject(err);
+        this.pending.clear();
+        this.startDeferred.reject(err);
+        this.closedDeferred.reject(err);
+        this.gapIter?.stop();
+        this.sub.unsubscribe();
+    }
+    add(subj, payload, opts) {
+        if (this.closed)
+            return Promise.reject(new Error(BATCH_CLOSED));
+        const mySeq = ++this.seq;
+        const rs = this.replyFor(FastIngestOp.Append, mySeq);
+        const headers = opts ? buildPublishHeaders(opts) : undefined;
+        this.nc.publish(subj, payload, { reply: rs, headers });
+        if (mySeq - this.acked < this.ackInterval * this.maxOutstandingAcks) {
+            return Promise.resolve({ batchSeq: mySeq, ackSeq: this.acked });
+        }
+        const d = deferred();
+        this.pending.set(rs, { seq: mySeq, op: FastIngestOp.Append, deferred: d });
+        return this.deadlineOrClose(d, opts?.timeout ?? this.defaultTimeout);
+    }
+    last(subj, payload, opts) {
+        if (this.closed)
+            return Promise.reject(new Error(BATCH_CLOSED));
+        const mySeq = ++this.seq;
+        const rs = this.replyFor(FastIngestOp.Final, mySeq);
+        const d = deferred();
+        this.pending.set(rs, { seq: mySeq, op: FastIngestOp.Final, deferred: d });
+        const headers = opts ? buildPublishHeaders(opts) : undefined;
+        this.nc.publish(subj, payload, { reply: rs, headers });
+        return this.deadlineOrClose(d, opts?.timeout ?? this.defaultTimeout);
+    }
+    end(opts) {
+        if (this.closed)
+            return Promise.reject(new Error(BATCH_CLOSED));
+        const mySeq = ++this.seq;
+        const rs = this.replyFor(FastIngestOp.EOB, mySeq);
+        const d = deferred();
+        this.pending.set(rs, { seq: mySeq, op: FastIngestOp.EOB, deferred: d });
+        const headers = opts ? buildPublishHeaders(opts) : undefined;
+        this.nc.publish(this.batchSubj, Empty, { reply: rs, headers });
+        return this.deadlineOrClose(d, opts?.timeout ?? this.defaultTimeout);
+    }
+    ping(timeout = this.defaultTimeout) {
+        if (this.closed)
+            return Promise.reject(new Error(BATCH_CLOSED));
+        const rs = this.replyFor(FastIngestOp.Ping, this.seq);
+        // coalesce concurrent pings on same seq — same reply subject, one server ack
+        const existing = this.pending.get(rs);
+        if (existing && existing.op === FastIngestOp.Ping) {
+            return deadline(existing.deferred, timeout);
+        }
+        const d = deferred();
+        this.pending.set(rs, { seq: this.seq, op: FastIngestOp.Ping, deferred: d });
+        this.nc.publish(this.batchSubj, Empty, { reply: rs });
+        return this.deadlineOrClose(d, timeout);
+    }
+    done() {
+        return this.closedDeferred;
+    }
+    gaps() {
+        if (!this.gapIter) {
+            this.gapIter = new QueuedIteratorImpl();
+        }
+        return this.gapIter;
+    }
+}