@apibara/protocol 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/index.cjs

@@ -0,0 +1,222 @@
+'use strict';
+
+const config = require('./shared/protocol.e39e40d6.cjs');
+const schema = require('@effect/schema');
+const niceGrpc = require('nice-grpc');
+require('protobufjs/minimal.js');
+const assert = require('node:assert');
+require('effect');
+require('viem');
+require('long');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
+
+const index = {
+  __proto__: null,
+  stream: config.stream,
+  testing: config.testing
+};
+
+const StatusRequest = schema.Schema.Struct({});
+const statusRequestToProto = schema.Schema.encodeSync(StatusRequest);
+const statusRequestFromProto = schema.Schema.decodeSync(StatusRequest);
+const StatusResponse = schema.Schema.Struct({
+  currentHead: schema.Schema.optional(config.Cursor),
+  lastIngested: schema.Schema.optional(config.Cursor),
+  finalized: schema.Schema.optional(config.Cursor),
+  starting: schema.Schema.optional(config.Cursor)
+});
+const statusResponseToProto = schema.Schema.encodeSync(StatusResponse);
+const statusResponseFromProto = schema.Schema.decodeSync(StatusResponse);
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const DEFAULT_TIMEOUT_MS = 45e3;
+class TimeoutError extends Error {
+  constructor(timeout) {
+    super(`No message received in ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+function createClient(config$1, streamUrl, options = {}) {
+  const channel = niceGrpc.createChannel(
+    streamUrl,
+    options?.credentials,
+    options?.channelOptions
+  );
+  const client = niceGrpc.createClient(
+    config.DnaStreamDefinition,
+    channel,
+    options?.defaultCallOptions
+  );
+  return new GrpcClient(config$1, client);
+}
+class GrpcClient {
+  constructor(config, client) {
+    this.config = config;
+    this.client = client;
+    __publicField$1(this, "encodeRequest");
+    this.encodeRequest = schema.Schema.encodeSync(config.Request);
+  }
+  async status(request, options) {
+    const response = await this.client.status(
+      statusRequestToProto(request ?? {}),
+      options
+    );
+    return statusResponseFromProto(response);
+  }
+  streamData(request, options) {
+    const it = this.client.streamData(this.encodeRequest(request), options);
+    return new StreamDataIterable(it, this.config.Block, options);
+  }
+}
+class StreamDataIterable {
+  constructor(it, schema, options) {
+    this.it = it;
+    this.schema = schema;
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    const inner = this.it[Symbol.asyncIterator]();
+    const schema$1 = config.StreamDataResponse(this.schema);
+    const decoder = schema.Schema.decodeSync(schema$1);
+    const { endingCursor, timeout = DEFAULT_TIMEOUT_MS } = this.options ?? {};
+    let shouldStop = false;
+    let clock;
+    return {
+      async next() {
+        if (shouldStop) {
+          return { done: true, value: void 0 };
+        }
+        const t = new Promise(
+          (_, reject) => {
+            clock = setTimeout(() => {
+              reject(new TimeoutError(timeout));
+            }, timeout);
+          }
+        );
+        try {
+          const { done, value } = await Promise.race([inner.next(), t]);
+          clearTimeout(clock);
+          if (done || value.message === void 0) {
+            return { done: true, value: void 0 };
+          }
+          const decodedMessage = decoder(value.message);
+          if (endingCursor) {
+            assert__default(value.message.$case === "data");
+            assert__default(decodedMessage._tag === "data");
+            const { orderKey, uniqueKey } = endingCursor;
+            const endCursor = decodedMessage.data.endCursor;
+            if (orderKey === endCursor?.orderKey) {
+              if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
+                shouldStop = true;
+                return { done: false, value: decodedMessage };
+              }
+            }
+          }
+          return {
+            done: false,
+            value: decodedMessage
+          };
+        } finally {
+          clearTimeout(clock);
+        }
+      }
+    };
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RateGauge {
+  constructor(intervalSeconds) {
+    __publicField(this, "interval");
+    __publicField(this, "prev");
+    __publicField(this, "rateMs");
+    __publicField(this, "var");
+    this.interval = intervalSeconds * 1e3;
+    this.var = 0;
+  }
+  record(items) {
+    const prev = this.prev;
+    const now = process.hrtime.bigint();
+    this.prev = now;
+    if (!prev) {
+      return;
+    }
+    const deltaMs = Number(now - prev) / 1e6;
+    const rateMs = items / deltaMs;
+    if (this.rateMs === void 0) {
+      this.rateMs = rateMs;
+      this.var = 0;
+      return;
+    }
+    const alpha = 1 - Math.exp(-deltaMs / this.interval);
+    this.rateMs = alpha * rateMs + (1 - alpha) * this.rateMs;
+    const diff = rateMs - this.rateMs;
+    const incr = alpha * diff;
+    this.var = (1 - alpha) * (this.var + incr * diff);
+  }
+  /** Returns the average rate per second. */
+  average() {
+    if (this.rateMs === void 0) {
+      return void 0;
+    }
+    return this.rateMs * 1e3;
+  }
+  /** Returns the variance. */
+  variance() {
+    return this.var;
+  }
+}
+
+exports.Bytes = config.Bytes;
+exports.BytesFromUint8Array = config.BytesFromUint8Array;
+exports.Cursor = config.Cursor;
+exports.CursorFromBytes = config.CursorFromBytes;
+exports.Data = config.Data;
+exports.DataFinality = config.DataFinality;
+exports.DataProduction = config.DataProduction;
+exports.DnaStreamDefinition = config.DnaStreamDefinition;
+exports.Duration = config.Duration;
+exports.Finalize = config.Finalize;
+exports.Heartbeat = config.Heartbeat;
+exports.Invalidate = config.Invalidate;
+exports.StdErr = config.StdErr;
+exports.StdOut = config.StdOut;
+exports.StreamConfig = config.StreamConfig;
+exports.StreamDataRequest = config.StreamDataRequest;
+exports.StreamDataResponse = config.StreamDataResponse;
+exports.SystemMessage = config.SystemMessage;
+exports._Cursor = config._Cursor;
+exports.createCursor = config.createCursor;
+exports.cursorFromBytes = config.cursorFromBytes;
+exports.cursorFromProto = config.cursorFromProto;
+exports.cursorToBytes = config.cursorToBytes;
+exports.cursorToProto = config.cursorToProto;
+exports.isCursor = config.isCursor;
+exports.normalizeCursor = config.normalizeCursor;
+exports.ClientError = niceGrpc.ClientError;
+exports.Status = niceGrpc.Status;
+exports.GrpcClient = GrpcClient;
+exports.RateGauge = RateGauge;
+exports.StatusRequest = StatusRequest;
+exports.StatusResponse = StatusResponse;
+exports.StreamDataIterable = StreamDataIterable;
+exports.TimeoutError = TimeoutError;
+exports.createClient = createClient;
+exports.proto = index;
+exports.statusRequestFromProto = statusRequestFromProto;
+exports.statusRequestToProto = statusRequestToProto;
+exports.statusResponseFromProto = statusResponseFromProto;
+exports.statusResponseToProto = statusResponseToProto;

package/dist/index.d.cts

@@ -0,0 +1,71 @@
+import { s as stream } from './shared/protocol.4b1cfe2c.cjs';
+export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.cjs';
+import _m0 from 'protobufjs/minimal.js';
+export { ClientError, Status } from 'nice-grpc';
+import '@effect/schema';
+import 'nice-grpc-common';
+import '@effect/schema/AST';
+
+declare const protobufPackage = "dna.v2.testing";
+interface MockFilter {
+    readonly filter?: string | undefined;
+}
+declare const MockFilter: {
+    encode(message: MockFilter, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockFilter;
+    fromJSON(object: any): MockFilter;
+    toJSON(message: MockFilter): unknown;
+    create(base?: DeepPartial<MockFilter>): MockFilter;
+    fromPartial(object: DeepPartial<MockFilter>): MockFilter;
+};
+interface MockBlock {
+    readonly data?: string | undefined;
+}
+declare const MockBlock: {
+    encode(message: MockBlock, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockBlock;
+    fromJSON(object: any): MockBlock;
+    toJSON(message: MockBlock): unknown;
+    create(base?: DeepPartial<MockBlock>): MockBlock;
+    fromPartial(object: DeepPartial<MockBlock>): MockBlock;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+type testing_DeepPartial<T> = DeepPartial<T>;
+declare const testing_MockBlock: typeof MockBlock;
+declare const testing_MockFilter: typeof MockFilter;
+declare const testing_protobufPackage: typeof protobufPackage;
+declare namespace testing {
+  export { type testing_DeepPartial as DeepPartial, testing_MockBlock as MockBlock, testing_MockFilter as MockFilter, testing_protobufPackage as protobufPackage };
+}
+
+declare const index_stream: typeof stream;
+declare const index_testing: typeof testing;
+declare namespace index {
+  export { index_stream as stream, index_testing as testing };
+}
+
+/** Track data rate using high precision timers. */
+declare class RateGauge {
+    private interval;
+    private prev?;
+    private rateMs?;
+    private var;
+    constructor(intervalSeconds: number);
+    record(items: number): void;
+    /** Returns the average rate per second. */
+    average(): number | undefined;
+    /** Returns the variance. */
+    variance(): number;
+}
+
+export { RateGauge, index as proto };

package/dist/index.d.mts

@@ -0,0 +1,71 @@
+import { s as stream } from './shared/protocol.4b1cfe2c.mjs';
+export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.mjs';
+import _m0 from 'protobufjs/minimal.js';
+export { ClientError, Status } from 'nice-grpc';
+import '@effect/schema';
+import 'nice-grpc-common';
+import '@effect/schema/AST';
+
+declare const protobufPackage = "dna.v2.testing";
+interface MockFilter {
+    readonly filter?: string | undefined;
+}
+declare const MockFilter: {
+    encode(message: MockFilter, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockFilter;
+    fromJSON(object: any): MockFilter;
+    toJSON(message: MockFilter): unknown;
+    create(base?: DeepPartial<MockFilter>): MockFilter;
+    fromPartial(object: DeepPartial<MockFilter>): MockFilter;
+};
+interface MockBlock {
+    readonly data?: string | undefined;
+}
+declare const MockBlock: {
+    encode(message: MockBlock, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockBlock;
+    fromJSON(object: any): MockBlock;
+    toJSON(message: MockBlock): unknown;
+    create(base?: DeepPartial<MockBlock>): MockBlock;
+    fromPartial(object: DeepPartial<MockBlock>): MockBlock;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+type testing_DeepPartial<T> = DeepPartial<T>;
+declare const testing_MockBlock: typeof MockBlock;
+declare const testing_MockFilter: typeof MockFilter;
+declare const testing_protobufPackage: typeof protobufPackage;
+declare namespace testing {
+  export { type testing_DeepPartial as DeepPartial, testing_MockBlock as MockBlock, testing_MockFilter as MockFilter, testing_protobufPackage as protobufPackage };
+}
+
+declare const index_stream: typeof stream;
+declare const index_testing: typeof testing;
+declare namespace index {
+  export { index_stream as stream, index_testing as testing };
+}
+
+/** Track data rate using high precision timers. */
+declare class RateGauge {
+    private interval;
+    private prev?;
+    private rateMs?;
+    private var;
+    constructor(intervalSeconds: number);
+    record(items: number): void;
+    /** Returns the average rate per second. */
+    average(): number | undefined;
+    /** Returns the variance. */
+    variance(): number;
+}
+
+export { RateGauge, index as proto };

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+import { s as stream } from './shared/protocol.4b1cfe2c.js';
+export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.js';
+import _m0 from 'protobufjs/minimal.js';
+export { ClientError, Status } from 'nice-grpc';
+import '@effect/schema';
+import 'nice-grpc-common';
+import '@effect/schema/AST';
+
+declare const protobufPackage = "dna.v2.testing";
+interface MockFilter {
+    readonly filter?: string | undefined;
+}
+declare const MockFilter: {
+    encode(message: MockFilter, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockFilter;
+    fromJSON(object: any): MockFilter;
+    toJSON(message: MockFilter): unknown;
+    create(base?: DeepPartial<MockFilter>): MockFilter;
+    fromPartial(object: DeepPartial<MockFilter>): MockFilter;
+};
+interface MockBlock {
+    readonly data?: string | undefined;
+}
+declare const MockBlock: {
+    encode(message: MockBlock, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockBlock;
+    fromJSON(object: any): MockBlock;
+    toJSON(message: MockBlock): unknown;
+    create(base?: DeepPartial<MockBlock>): MockBlock;
+    fromPartial(object: DeepPartial<MockBlock>): MockBlock;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+type testing_DeepPartial<T> = DeepPartial<T>;
+declare const testing_MockBlock: typeof MockBlock;
+declare const testing_MockFilter: typeof MockFilter;
+declare const testing_protobufPackage: typeof protobufPackage;
+declare namespace testing {
+  export { type testing_DeepPartial as DeepPartial, testing_MockBlock as MockBlock, testing_MockFilter as MockFilter, testing_protobufPackage as protobufPackage };
+}
+
+declare const index_stream: typeof stream;
+declare const index_testing: typeof testing;
+declare namespace index {
+  export { index_stream as stream, index_testing as testing };
+}
+
+/** Track data rate using high precision timers. */
+declare class RateGauge {
+    private interval;
+    private prev?;
+    private rateMs?;
+    private var;
+    constructor(intervalSeconds: number);
+    record(items: number): void;
+    /** Returns the average rate per second. */
+    average(): number | undefined;
+    /** Returns the variance. */
+    variance(): number;
+}
+
+export { RateGauge, index as proto };

package/dist/index.mjs

@@ -0,0 +1,179 @@
+import { s as stream, t as testing, C as Cursor, D as DnaStreamDefinition, S as StreamDataResponse } from './shared/protocol.991ff9ad.mjs';
+export { B as Bytes, a as BytesFromUint8Array, e as CursorFromBytes, q as Data, h as DataFinality, j as DataProduction, k as Duration, F as Finalize, H as Heartbeat, I as Invalidate, o as StdErr, m as StdOut, r as StreamConfig, l as StreamDataRequest, p as SystemMessage, _ as _Cursor, c as createCursor, g as cursorFromBytes, d as cursorFromProto, f as cursorToBytes, b as cursorToProto, i as isCursor, n as normalizeCursor } from './shared/protocol.991ff9ad.mjs';
+import { Schema } from '@effect/schema';
+import { createChannel, createClient as createClient$1 } from 'nice-grpc';
+export { ClientError, Status } from 'nice-grpc';
+import 'protobufjs/minimal.js';
+import assert from 'node:assert';
+import 'effect';
+import 'viem';
+import 'long';
+
+const index = {
+  __proto__: null,
+  stream: stream,
+  testing: testing
+};
+
+const StatusRequest = Schema.Struct({});
+const statusRequestToProto = Schema.encodeSync(StatusRequest);
+const statusRequestFromProto = Schema.decodeSync(StatusRequest);
+const StatusResponse = Schema.Struct({
+  currentHead: Schema.optional(Cursor),
+  lastIngested: Schema.optional(Cursor),
+  finalized: Schema.optional(Cursor),
+  starting: Schema.optional(Cursor)
+});
+const statusResponseToProto = Schema.encodeSync(StatusResponse);
+const statusResponseFromProto = Schema.decodeSync(StatusResponse);
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const DEFAULT_TIMEOUT_MS = 45e3;
+class TimeoutError extends Error {
+  constructor(timeout) {
+    super(`No message received in ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+function createClient(config, streamUrl, options = {}) {
+  const channel = createChannel(
+    streamUrl,
+    options?.credentials,
+    options?.channelOptions
+  );
+  const client = createClient$1(
+    DnaStreamDefinition,
+    channel,
+    options?.defaultCallOptions
+  );
+  return new GrpcClient(config, client);
+}
+class GrpcClient {
+  constructor(config, client) {
+    this.config = config;
+    this.client = client;
+    __publicField$1(this, "encodeRequest");
+    this.encodeRequest = Schema.encodeSync(config.Request);
+  }
+  async status(request, options) {
+    const response = await this.client.status(
+      statusRequestToProto(request ?? {}),
+      options
+    );
+    return statusResponseFromProto(response);
+  }
+  streamData(request, options) {
+    const it = this.client.streamData(this.encodeRequest(request), options);
+    return new StreamDataIterable(it, this.config.Block, options);
+  }
+}
+class StreamDataIterable {
+  constructor(it, schema, options) {
+    this.it = it;
+    this.schema = schema;
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    const inner = this.it[Symbol.asyncIterator]();
+    const schema = StreamDataResponse(this.schema);
+    const decoder = Schema.decodeSync(schema);
+    const { endingCursor, timeout = DEFAULT_TIMEOUT_MS } = this.options ?? {};
+    let shouldStop = false;
+    let clock;
+    return {
+      async next() {
+        if (shouldStop) {
+          return { done: true, value: void 0 };
+        }
+        const t = new Promise(
+          (_, reject) => {
+            clock = setTimeout(() => {
+              reject(new TimeoutError(timeout));
+            }, timeout);
+          }
+        );
+        try {
+          const { done, value } = await Promise.race([inner.next(), t]);
+          clearTimeout(clock);
+          if (done || value.message === void 0) {
+            return { done: true, value: void 0 };
+          }
+          const decodedMessage = decoder(value.message);
+          if (endingCursor) {
+            assert(value.message.$case === "data");
+            assert(decodedMessage._tag === "data");
+            const { orderKey, uniqueKey } = endingCursor;
+            const endCursor = decodedMessage.data.endCursor;
+            if (orderKey === endCursor?.orderKey) {
+              if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
+                shouldStop = true;
+                return { done: false, value: decodedMessage };
+              }
+            }
+          }
+          return {
+            done: false,
+            value: decodedMessage
+          };
+        } finally {
+          clearTimeout(clock);
+        }
+      }
+    };
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RateGauge {
+  constructor(intervalSeconds) {
+    __publicField(this, "interval");
+    __publicField(this, "prev");
+    __publicField(this, "rateMs");
+    __publicField(this, "var");
+    this.interval = intervalSeconds * 1e3;
+    this.var = 0;
+  }
+  record(items) {
+    const prev = this.prev;
+    const now = process.hrtime.bigint();
+    this.prev = now;
+    if (!prev) {
+      return;
+    }
+    const deltaMs = Number(now - prev) / 1e6;
+    const rateMs = items / deltaMs;
+    if (this.rateMs === void 0) {
+      this.rateMs = rateMs;
+      this.var = 0;
+      return;
+    }
+    const alpha = 1 - Math.exp(-deltaMs / this.interval);
+    this.rateMs = alpha * rateMs + (1 - alpha) * this.rateMs;
+    const diff = rateMs - this.rateMs;
+    const incr = alpha * diff;
+    this.var = (1 - alpha) * (this.var + incr * diff);
+  }
+  /** Returns the average rate per second. */
+  average() {
+    if (this.rateMs === void 0) {
+      return void 0;
+    }
+    return this.rateMs * 1e3;
+  }
+  /** Returns the variance. */
+  variance() {
+    return this.var;
+  }
+}
+
+export { Cursor, DnaStreamDefinition, GrpcClient, RateGauge, StatusRequest, StatusResponse, StreamDataIterable, StreamDataResponse, TimeoutError, createClient, index as proto, statusRequestFromProto, statusRequestToProto, statusResponseFromProto, statusResponseToProto };