@versori/run 0.0.1-alpha.9 → 0.1.0-alpha.10

package/esm/deps/jsr.io/@nats-io/kv/3.0.2/src/kv.js

@@ -0,0 +1,1044 @@
+/*
+ * Copyright 2021-2024 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.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Kvm_instances, _Kvm_maybeCreate;
+import { compare, Empty, Feature, headers, millis, nanos, nuid, parseSemVer, QueuedIteratorImpl, } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import { AckPolicy, DeliverPolicy, DiscardPolicy, JetStreamApiCodes, JetStreamApiError, JsHeaders, ListerImpl, PubHeaders, RetentionPolicy, StorageType, StoreCompression, toJetStreamClient, } from "../../../jetstream/3.0.2/src/internal_mod.js";
+import { kvPrefix, KvWatchInclude } from "./types.js";
+export function Base64KeyCodec() {
+    return {
+        encode(key) {
+            return btoa(key);
+        },
+        decode(bkey) {
+            return atob(bkey);
+        },
+    };
+}
+export function NoopKvCodecs() {
+    return {
+        key: {
+            encode(k) {
+                return k;
+            },
+            decode(k) {
+                return k;
+            },
+        },
+        value: {
+            encode(v) {
+                return v;
+            },
+            decode(v) {
+                return v;
+            },
+        },
+    };
+}
+export function defaultBucketOpts() {
+    return {
+        replicas: 1,
+        history: 1,
+        timeout: 2000,
+        max_bytes: -1,
+        maxValueSize: -1,
+        codec: NoopKvCodecs(),
+        storage: StorageType.File,
+    };
+}
+export const kvOperationHdr = "KV-Operation";
+const kvSubjectPrefix = "$KV";
+const validKeyRe = /^[-/=.\w]+$/;
+const validSearchKey = /^[-/=.>*\w]+$/;
+const validBucketRe = /^[-\w]+$/;
+// this exported for tests
+export function validateKey(k) {
+    if (k.startsWith(".") || k.endsWith(".") || !validKeyRe.test(k)) {
+        throw new Error(`invalid key: ${k}`);
+    }
+}
+export function validateSearchKey(k) {
+    if (k.startsWith(".") || k.endsWith(".") || !validSearchKey.test(k)) {
+        throw new Error(`invalid key: ${k}`);
+    }
+}
+export function hasWildcards(k) {
+    if (k.startsWith(".") || k.endsWith(".")) {
+        throw new Error(`invalid key: ${k}`);
+    }
+    const chunks = k.split(".");
+    let hasWildcards = false;
+    for (let i = 0; i < chunks.length; i++) {
+        switch (chunks[i]) {
+            case "*":
+                hasWildcards = true;
+                break;
+            case ">":
+                if (i !== chunks.length - 1) {
+                    throw new Error(`invalid key: ${k}`);
+                }
+                hasWildcards = true;
+                break;
+            default:
+            // continue
+        }
+    }
+    return hasWildcards;
+}
+// this exported for tests
+export function validateBucket(name) {
+    if (!validBucketRe.test(name)) {
+        throw new Error(`invalid bucket name: ${name}`);
+    }
+}
+/**
+ * The entry point to creating new KV instances.
+ */
+export class Kvm {
+    /**
+     * Creates an instance of the Kv that allows you to create and access KV stores.
+     * Note that if the argument is a NatsConnection, default JetStream Options are
+     * used. If you want to set some options, please provide a JetStreamClient instead.
+     * @param nc
+     */
+    constructor(nc) {
+        _Kvm_instances.add(this);
+        Object.defineProperty(this, "js", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.js = toJetStreamClient(nc);
+    }
+    /**
+     * Creates and opens the specified KV. If the KV already exists, it opens the existing KV.
+     * @param name
+     * @param opts
+     */
+    create(name, opts = {}) {
+        return __classPrivateFieldGet(this, _Kvm_instances, "m", _Kvm_maybeCreate).call(this, name, opts);
+    }
+    /**
+     * Open to the specified KV. If the KV doesn't exist, this API will fail.
+     * @param name
+     * @param opts
+     */
+    open(name, opts = {}) {
+        opts.bindOnly = true;
+        return __classPrivateFieldGet(this, _Kvm_instances, "m", _Kvm_maybeCreate).call(this, name, opts);
+    }
+    /**
+     * Lists all available KVs
+     */
+    list() {
+        const filter = (v) => {
+            const slr = v;
+            const kvStreams = slr.streams.filter((v) => {
+                return v.config.name.startsWith(kvPrefix);
+            });
+            kvStreams.forEach((si) => {
+                si.config.sealed = si.config.sealed || false;
+                si.config.deny_delete = si.config.deny_delete || false;
+                si.config.deny_purge = si.config.deny_purge || false;
+                si.config.allow_rollup_hdrs = si.config.allow_rollup_hdrs || false;
+            });
+            let cluster = "";
+            if (kvStreams.length) {
+                cluster = this.js.nc.info?.cluster ?? "";
+            }
+            return kvStreams.map((si) => {
+                return new KvStatusImpl(si, cluster);
+            });
+        };
+        const subj = `${this.js.prefix}.STREAM.LIST`;
+        return new ListerImpl(subj, filter, this.js);
+    }
+}
+_Kvm_instances = new WeakSet(), _Kvm_maybeCreate = function _Kvm_maybeCreate(name, opts = {}) {
+    const { ok, min } = this.js.nc.features.get(Feature.JS_KV);
+    if (!ok) {
+        return Promise.reject(new Error(`kv is only supported on servers ${min} or better`));
+    }
+    if (opts.bindOnly) {
+        return Bucket.bind(this.js, name, opts);
+    }
+    return Bucket.create(this.js, name, opts);
+};
+export class Bucket {
+    constructor(bucket, js, jsm) {
+        Object.defineProperty(this, "js", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "jsm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bucket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "direct", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "editPrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useJsPrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_prefixLen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "validateKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: validateKey
+        });
+        Object.defineProperty(this, "validateSearchKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: validateSearchKey
+        });
+        Object.defineProperty(this, "hasWildcards", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: hasWildcards
+        });
+        validateBucket(bucket);
+        this.js = js;
+        this.jsm = jsm;
+        this.bucket = bucket;
+        this.prefix = kvSubjectPrefix;
+        this.editPrefix = "";
+        this.useJsPrefix = false;
+        this._prefixLen = 0;
+    }
+    static async create(js, name, opts = {}) {
+        validateBucket(name);
+        const jsm = await js.jetstreamManager();
+        const bucket = new Bucket(name, js, jsm);
+        await bucket.init(opts);
+        return bucket;
+    }
+    static async bind(js, name, opts = {}) {
+        const jsm = await js.jetstreamManager();
+        const info = {
+            config: {
+                allow_direct: opts.allow_direct,
+            },
+        };
+        validateBucket(name);
+        const bucket = new Bucket(name, js, jsm);
+        info.config.name = opts.streamName ?? bucket.bucketName();
+        Object.assign(bucket, info);
+        bucket.stream = info.config.name;
+        bucket.codec = opts.codec || NoopKvCodecs();
+        bucket.direct = info.config.allow_direct ?? false;
+        bucket.initializePrefixes(info);
+        return bucket;
+    }
+    async init(opts = {}) {
+        const bo = Object.assign(defaultBucketOpts(), opts);
+        this.codec = bo.codec;
+        const sc = {};
+        this.stream = sc.name = opts.streamName ?? this.bucketName();
+        sc.retention = RetentionPolicy.Limits;
+        sc.max_msgs_per_subject = bo.history;
+        if (bo.max_bytes) {
+            sc.max_bytes = bo.max_bytes;
+        }
+        sc.max_msg_size = bo.maxValueSize;
+        sc.storage = bo.storage;
+        if (opts.placement) {
+            sc.placement = opts.placement;
+        }
+        if (opts.republish) {
+            sc.republish = opts.republish;
+        }
+        if (opts.description) {
+            sc.description = opts.description;
+        }
+        if (opts.mirror) {
+            const mirror = Object.assign({}, opts.mirror);
+            if (!mirror.name.startsWith(kvPrefix)) {
+                mirror.name = `${kvPrefix}${mirror.name}`;
+            }
+            sc.mirror = mirror;
+            sc.mirror_direct = true;
+        }
+        else if (opts.sources) {
+            const sources = opts.sources.map((s) => {
+                const c = Object.assign({}, s);
+                const srcBucketName = c.name.startsWith(kvPrefix)
+                    ? c.name.substring(kvPrefix.length)
+                    : c.name;
+                if (!c.name.startsWith(kvPrefix)) {
+                    c.name = `${kvPrefix}${c.name}`;
+                }
+                if (!s.external && srcBucketName !== this.bucket) {
+                    c.subject_transforms = [
+                        { src: `$KV.${srcBucketName}.>`, dest: `$KV.${this.bucket}.>` },
+                    ];
+                }
+                return c;
+            });
+            sc.sources = sources;
+            sc.subjects = [this.subjectForBucket()];
+        }
+        else {
+            sc.subjects = [this.subjectForBucket()];
+        }
+        if (opts.metadata) {
+            sc.metadata = opts.metadata;
+        }
+        if (typeof opts.compression === "boolean") {
+            sc.compression = opts.compression
+                ? StoreCompression.S2
+                : StoreCompression.None;
+        }
+        const nci = this.js.nc;
+        const have = nci.getServerVersion();
+        const discardNew = have ? compare(have, parseSemVer("2.7.2")) >= 0 : false;
+        sc.discard = discardNew ? DiscardPolicy.New : DiscardPolicy.Old;
+        const { ok: direct, min } = nci.features.get(Feature.JS_ALLOW_DIRECT);
+        if (!direct && opts.allow_direct === true) {
+            const v = have
+                ? `${have.major}.${have.minor}.${have.micro}`
+                : "unknown";
+            return Promise.reject(new Error(`allow_direct is not available on server version ${v} - requires ${min}`));
+        }
+        // if we are given allow_direct we use it, otherwise what
+        // the server supports - in creation this will always rule,
+        // but allows the client to opt-in even if it is already
+        // available on the stream
+        opts.allow_direct = typeof opts.allow_direct === "boolean"
+            ? opts.allow_direct
+            : direct;
+        sc.allow_direct = opts.allow_direct;
+        this.direct = sc.allow_direct;
+        sc.num_replicas = bo.replicas;
+        if (bo.ttl) {
+            sc.max_age = nanos(bo.ttl);
+        }
+        sc.allow_rollup_hdrs = true;
+        let info;
+        try {
+            info = await this.jsm.streams.info(sc.name);
+            if (!info.config.allow_direct && this.direct === true) {
+                this.direct = false;
+            }
+        }
+        catch (err) {
+            if (err.message === "stream not found") {
+                info = await this.jsm.streams.add(sc);
+            }
+            else {
+                throw err;
+            }
+        }
+        this.initializePrefixes(info);
+    }
+    initializePrefixes(info) {
+        this._prefixLen = 0;
+        this.prefix = `$KV.${this.bucket}`;
+        this.useJsPrefix = this.js.apiPrefix !== "$JS.API";
+        const { mirror } = info.config;
+        if (mirror) {
+            let n = mirror.name;
+            if (n.startsWith(kvPrefix)) {
+                n = n.substring(kvPrefix.length);
+            }
+            if (mirror.external && mirror.external.api !== "") {
+                const mb = mirror.name.substring(kvPrefix.length);
+                this.useJsPrefix = false;
+                this.prefix = `$KV.${mb}`;
+                this.editPrefix = `${mirror.external.api}.$KV.${n}`;
+            }
+            else {
+                this.editPrefix = this.prefix;
+            }
+        }
+    }
+    bucketName() {
+        return this.stream ?? `${kvPrefix}${this.bucket}`;
+    }
+    subjectForBucket() {
+        return `${this.prefix}.${this.bucket}.>`;
+    }
+    subjectForKey(k, edit = false) {
+        const builder = [];
+        if (edit) {
+            if (this.useJsPrefix) {
+                builder.push(this.js.apiPrefix);
+            }
+            if (this.editPrefix !== "") {
+                builder.push(this.editPrefix);
+            }
+            else {
+                builder.push(this.prefix);
+            }
+        }
+        else {
+            if (this.prefix) {
+                builder.push(this.prefix);
+            }
+        }
+        builder.push(k);
+        return builder.join(".");
+    }
+    fullKeyName(k) {
+        if (this.prefix !== "") {
+            return `${this.prefix}.${k}`;
+        }
+        return `${kvSubjectPrefix}.${this.bucket}.${k}`;
+    }
+    get prefixLen() {
+        if (this._prefixLen === 0) {
+            this._prefixLen = this.prefix.length + 1;
+        }
+        return this._prefixLen;
+    }
+    encodeKey(key) {
+        const chunks = [];
+        for (const t of key.split(".")) {
+            switch (t) {
+                case ">":
+                case "*":
+                    chunks.push(t);
+                    break;
+                default:
+                    chunks.push(this.codec.key.encode(t));
+                    break;
+            }
+        }
+        return chunks.join(".");
+    }
+    decodeKey(ekey) {
+        const chunks = [];
+        for (const t of ekey.split(".")) {
+            switch (t) {
+                case ">":
+                case "*":
+                    chunks.push(t);
+                    break;
+                default:
+                    chunks.push(this.codec.key.decode(t));
+                    break;
+            }
+        }
+        return chunks.join(".");
+    }
+    close() {
+        return Promise.resolve();
+    }
+    dataLen(data, h) {
+        const slen = h ? h.get(JsHeaders.MessageSizeHdr) || "" : "";
+        if (slen !== "") {
+            return parseInt(slen, 10);
+        }
+        return data.length;
+    }
+    smToEntry(sm) {
+        return new KvStoredEntryImpl(this.bucket, this.prefixLen, sm);
+    }
+    jmToWatchEntry(jm, isUpdate) {
+        const key = this.decodeKey(jm.subject.substring(this.prefixLen));
+        return new KvJsMsgEntryImpl(this.bucket, key, jm, isUpdate);
+    }
+    async create(k, data) {
+        let firstErr;
+        try {
+            const n = await this.put(k, data, { previousSeq: 0 });
+            return Promise.resolve(n);
+        }
+        catch (err) {
+            firstErr = err;
+            if (err instanceof JetStreamApiError) {
+                const jserr = err;
+                if (jserr.code !== JetStreamApiCodes.StreamWrongLastSequence) {
+                    return Promise.reject(err);
+                }
+            }
+        }
+        let rev = 0;
+        try {
+            const e = await this.get(k);
+            if (e?.operation === "DEL" || e?.operation === "PURGE") {
+                rev = e !== null ? e.revision : 0;
+                return this.update(k, data, rev);
+            }
+            else {
+                return Promise.reject(firstErr);
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    update(k, data, version) {
+        if (version <= 0) {
+            throw new Error("version must be greater than 0");
+        }
+        return this.put(k, data, { previousSeq: version });
+    }
+    async put(k, data, opts = {}) {
+        const ek = this.encodeKey(k);
+        this.validateKey(ek);
+        const o = {};
+        if (opts.previousSeq !== undefined) {
+            const h = headers();
+            o.headers = h;
+            h.set(PubHeaders.ExpectedLastSubjectSequenceHdr, `${opts.previousSeq}`);
+        }
+        try {
+            const pa = await this.js.publish(this.subjectForKey(ek, true), data, o);
+            return pa.seq;
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    async get(k, opts) {
+        const ek = this.encodeKey(k);
+        this.validateKey(ek);
+        let arg = { last_by_subj: this.subjectForKey(ek) };
+        if (opts && opts.revision > 0) {
+            arg = { seq: opts.revision };
+        }
+        let sm = null;
+        try {
+            if (this.direct) {
+                const direct = this.jsm.direct;
+                sm = await direct.getMessage(this.bucketName(), arg);
+            }
+            else {
+                sm = await this.jsm.streams.getMessage(this.bucketName(), arg);
+            }
+            if (sm === null) {
+                return null;
+            }
+            const ke = this.smToEntry(sm);
+            if (ke.key !== ek) {
+                return null;
+            }
+            return ke;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    purge(k, opts) {
+        return this._deleteOrPurge(k, "PURGE", opts);
+    }
+    delete(k, opts) {
+        return this._deleteOrPurge(k, "DEL", opts);
+    }
+    async purgeDeletes(olderMillis = 30 * 60 * 1000) {
+        const buf = [];
+        const i = await this.history({
+            key: ">",
+        });
+        await (async () => {
+            for await (const e of i) {
+                if (e.operation === "DEL" || e.operation === "PURGE") {
+                    buf.push(e);
+                }
+            }
+        })().then();
+        i.stop();
+        const min = Date.now() - olderMillis;
+        const proms = buf.map((e) => {
+            const subj = this.subjectForKey(e.key);
+            if (e.created.getTime() >= min) {
+                return this.jsm.streams.purge(this.stream, { filter: subj, keep: 1 });
+            }
+            else {
+                return this.jsm.streams.purge(this.stream, { filter: subj, keep: 0 });
+            }
+        });
+        const purged = await Promise.all(proms);
+        purged.unshift({ success: true, purged: 0 });
+        return purged.reduce((pv, cv) => {
+            pv.purged += cv.purged;
+            return pv;
+        });
+    }
+    async _deleteOrPurge(k, op, opts) {
+        if (!this.hasWildcards(k)) {
+            return this._doDeleteOrPurge(k, op, opts);
+        }
+        const iter = await this.keys(k);
+        const buf = [];
+        for await (const k of iter) {
+            buf.push(this._doDeleteOrPurge(k, op));
+            if (buf.length === 100) {
+                await Promise.all(buf);
+                buf.length = 0;
+            }
+        }
+        if (buf.length > 0) {
+            await Promise.all(buf);
+        }
+    }
+    async _doDeleteOrPurge(k, op, opts) {
+        const ek = this.encodeKey(k);
+        this.validateKey(ek);
+        const h = headers();
+        h.set(kvOperationHdr, op);
+        if (op === "PURGE") {
+            h.set(JsHeaders.RollupHdr, JsHeaders.RollupValueSubject);
+        }
+        if (opts?.previousSeq) {
+            h.set(PubHeaders.ExpectedLastSubjectSequenceHdr, `${opts.previousSeq}`);
+        }
+        await this.js.publish(this.subjectForKey(ek, true), Empty, { headers: h });
+    }
+    _buildCC(k, content, opts = {}) {
+        const a = !Array.isArray(k) ? [k] : k;
+        let filter_subjects = a.map((k) => {
+            const ek = this.encodeKey(k);
+            this.validateSearchKey(k);
+            return this.fullKeyName(ek);
+        });
+        let deliver_policy = DeliverPolicy.LastPerSubject;
+        if (content === KvWatchInclude.AllHistory) {
+            deliver_policy = DeliverPolicy.All;
+        }
+        if (content === KvWatchInclude.UpdatesOnly) {
+            deliver_policy = DeliverPolicy.New;
+        }
+        let filter_subject = undefined;
+        if (filter_subjects.length === 1) {
+            filter_subject = filter_subjects[0];
+            filter_subjects = undefined;
+        }
+        return Object.assign({
+            deliver_policy,
+            "ack_policy": AckPolicy.None,
+            filter_subjects,
+            filter_subject,
+            "flow_control": true,
+            "idle_heartbeat": nanos(5 * 1000),
+        }, opts);
+    }
+    remove(k) {
+        return this.purge(k);
+    }
+    async history(opts = {}) {
+        const k = opts.key ?? ">";
+        const co = {};
+        co.headers_only = opts.headers_only || false;
+        const qi = new QueuedIteratorImpl();
+        const fn = () => {
+            qi.stop();
+        };
+        const cc = this._buildCC(k, KvWatchInclude.AllHistory, co);
+        const oc = await this.js.consumers.getPushConsumer(this.stream, cc);
+        qi._data = oc;
+        const info = await oc.info(true);
+        if (info.num_pending === 0) {
+            qi.push(fn);
+            return qi;
+        }
+        const iter = await oc.consume({
+            callback: (m) => {
+                const e = this.jmToWatchEntry(m, false);
+                qi.push(e);
+                qi.received++;
+                if (m.info.pending === 0) {
+                    qi.push(fn);
+                }
+            },
+        });
+        iter.closed().then(() => {
+            qi.push(fn);
+        });
+        (async () => {
+            for await (const s of iter.status()) {
+                switch (s.type) {
+                    // if we get a heartbeat we got all the keys
+                    case "heartbeat":
+                        qi.push(() => {
+                            qi.stop();
+                        });
+                        break;
+                }
+            }
+        })().then();
+        // if they break from the iterator stop the consumer
+        qi.iterClosed.then(() => {
+            iter.stop();
+        });
+        return qi;
+    }
+    canSetWatcherName() {
+        //@ts-ignore: avoiding circular dependencies
+        const nci = this.js.nc;
+        const { ok } = nci.features.get(Feature.JS_NEW_CONSUMER_CREATE_API);
+        return ok;
+    }
+    async watch(opts = {}) {
+        const k = opts.key ?? ">";
+        const qi = new QueuedIteratorImpl();
+        const co = {};
+        co.headers_only = opts.headers_only || false;
+        let content = KvWatchInclude.LastValue;
+        if (opts.include === KvWatchInclude.AllHistory) {
+            content = KvWatchInclude.AllHistory;
+        }
+        else if (opts.include === KvWatchInclude.UpdatesOnly) {
+            content = KvWatchInclude.UpdatesOnly;
+        }
+        const ignoreDeletes = opts.ignoreDeletes === true;
+        const cc = this._buildCC(k, content, co);
+        cc.name = `KV_WATCHER_${nuid.next()}`;
+        if (opts.resumeFromRevision && opts.resumeFromRevision > 0) {
+            cc.deliver_policy = DeliverPolicy.StartSequence;
+            cc.opt_start_seq = opts.resumeFromRevision;
+        }
+        const oc = await this.js.consumers.getPushConsumer(this.stream, cc);
+        const info = await oc.info(true);
+        const count = info.num_pending;
+        let isUpdate = content === KvWatchInclude.UpdatesOnly || count === 0;
+        qi._data = oc;
+        let i = 0;
+        const iter = await oc.consume({
+            callback: (m) => {
+                if (!isUpdate) {
+                    i++;
+                    isUpdate = i >= count;
+                }
+                const e = this.jmToWatchEntry(m, isUpdate);
+                if (ignoreDeletes && e.operation === "DEL") {
+                    return;
+                }
+                qi.push(e);
+                qi.received++;
+            },
+        });
+        qi.iterClosed.then(() => {
+            iter.stop();
+        });
+        iter.closed().then(() => {
+            qi.push(() => {
+                qi.stop();
+            });
+        });
+        return qi;
+    }
+    async keys(k = ">") {
+        const keys = new QueuedIteratorImpl();
+        const cc = this._buildCC(k, KvWatchInclude.LastValue, {
+            headers_only: true,
+        });
+        const oc = await this.js.consumers.getPushConsumer(this.stream, cc);
+        const info = await oc.info();
+        if (info.num_pending === 0) {
+            keys.stop();
+            return keys;
+        }
+        keys._data = oc;
+        const iter = await oc.consume({
+            callback: (m) => {
+                const op = m.headers?.get(kvOperationHdr);
+                if (op !== "DEL" && op !== "PURGE") {
+                    const key = this.decodeKey(m.subject.substring(this.prefixLen));
+                    keys.push(key);
+                }
+                if (m.info.pending === 0) {
+                    iter.stop();
+                }
+            },
+        });
+        (async () => {
+            for await (const s of iter.status()) {
+                switch (s.type) {
+                    // if we get a heartbeat we got all the keys
+                    case "heartbeat":
+                        keys.push(() => {
+                            keys.stop();
+                        });
+                        break;
+                }
+            }
+        })().then();
+        iter.closed().then(() => {
+            keys.push(() => {
+                keys.stop();
+            });
+        });
+        keys.iterClosed.then(() => {
+            iter.stop();
+        });
+        return keys;
+    }
+    purgeBucket(opts) {
+        return this.jsm.streams.purge(this.bucketName(), opts);
+    }
+    destroy() {
+        return this.jsm.streams.delete(this.bucketName());
+    }
+    async status() {
+        const nc = this.js.nc;
+        const cluster = nc.info?.cluster ?? "";
+        const bn = this.bucketName();
+        const si = await this.jsm.streams.info(bn);
+        return new KvStatusImpl(si, cluster);
+    }
+}
+export class KvStatusImpl {
+    constructor(si, cluster = "") {
+        Object.defineProperty(this, "si", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cluster", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.si = si;
+        this.cluster = cluster;
+    }
+    get bucket() {
+        return this.si.config.name.startsWith(kvPrefix)
+            ? this.si.config.name.substring(kvPrefix.length)
+            : this.si.config.name;
+    }
+    get values() {
+        return this.si.state.messages;
+    }
+    get history() {
+        return this.si.config.max_msgs_per_subject;
+    }
+    get ttl() {
+        return millis(this.si.config.max_age);
+    }
+    get bucket_location() {
+        return this.cluster;
+    }
+    get backingStore() {
+        return this.si.config.storage;
+    }
+    get storage() {
+        return this.si.config.storage;
+    }
+    get replicas() {
+        return this.si.config.num_replicas;
+    }
+    get description() {
+        return this.si.config.description ?? "";
+    }
+    get maxBucketSize() {
+        return this.si.config.max_bytes;
+    }
+    get maxValueSize() {
+        return this.si.config.max_msg_size;
+    }
+    get max_bytes() {
+        return this.si.config.max_bytes;
+    }
+    get placement() {
+        return this.si.config.placement || { cluster: "", tags: [] };
+    }
+    get placementCluster() {
+        return this.si.config.placement?.cluster ?? "";
+    }
+    get republish() {
+        return this.si.config.republish ?? { src: "", dest: "" };
+    }
+    get streamInfo() {
+        return this.si;
+    }
+    get size() {
+        return this.si.state.bytes;
+    }
+    get metadata() {
+        return this.si.config.metadata ?? {};
+    }
+    get compression() {
+        if (this.si.config.compression) {
+            return this.si.config.compression !== StoreCompression.None;
+        }
+        return false;
+    }
+}
+class KvStoredEntryImpl {
+    constructor(bucket, prefixLen, sm) {
+        Object.defineProperty(this, "bucket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prefixLen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.bucket = bucket;
+        this.prefixLen = prefixLen;
+        this.sm = sm;
+    }
+    get key() {
+        return this.sm.subject.substring(this.prefixLen);
+    }
+    get value() {
+        return this.sm.data;
+    }
+    get delta() {
+        return 0;
+    }
+    get created() {
+        return this.sm.time;
+    }
+    get revision() {
+        return this.sm.seq;
+    }
+    get operation() {
+        return this.sm.header.get(kvOperationHdr) || "PUT";
+    }
+    get length() {
+        const slen = this.sm.header.get(JsHeaders.MessageSizeHdr) || "";
+        if (slen !== "") {
+            return parseInt(slen, 10);
+        }
+        return this.sm.data.length;
+    }
+    json() {
+        return this.sm.json();
+    }
+    string() {
+        return this.sm.string();
+    }
+}
+class KvJsMsgEntryImpl {
+    constructor(bucket, key, sm, isUpdate) {
+        Object.defineProperty(this, "bucket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "update", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.bucket = bucket;
+        this.key = key;
+        this.sm = sm;
+        this.update = isUpdate;
+    }
+    get value() {
+        return this.sm.data;
+    }
+    get created() {
+        return new Date(millis(this.sm.info.timestampNanos));
+    }
+    get revision() {
+        return this.sm.seq;
+    }
+    get operation() {
+        return this.sm.headers?.get(kvOperationHdr) || "PUT";
+    }
+    get delta() {
+        return this.sm.info.pending;
+    }
+    get length() {
+        const slen = this.sm.headers?.get(JsHeaders.MessageSizeHdr) || "";
+        if (slen !== "") {
+            return parseInt(slen, 10);
+        }
+        return this.sm.data.length;
+    }
+    get isUpdate() {
+        return this.update;
+    }
+    json() {
+        return this.sm.json();
+    }
+    string() {
+        return this.sm.string();
+    }
+}