@laserdata/laser-sdk 0.0.1-rc.21 → 0.0.1-rc.22

package/dist/iggy/apache-iggy.js

@@ -0,0 +1,634 @@
+import { Consumer, HeaderKeyFactory, HeaderValue as IggyHeaderValueFactory, Partitioning, PollingStrategy as IggyPollingStrategy, SimpleClient, getRawClient } from "apache-iggy";
+import { readFileSync } from "node:fs";
+import { ConfigError, TransportError } from "../client/errors.js";
+import { LASERDATA_ROOT_CA } from "../client/laserdata-ca.js";
+import { Mutex } from "../runtime/mutex.js";
+const DEFAULT_RECONNECT_INTERVAL_MS = 1_000;
+const VSR_HEARTBEAT_INTERVAL_MS = 5_000;
+export function toNodeBuffer(bytes) {
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function toIggyConsumer(target) {
+    return target.kind === "single"
+        ? target.name === undefined
+            ? Consumer.Single
+            : { kind: 1, id: target.name }
+        : Consumer.Group(target.name);
+}
+function toIggyOffsetConsumer(target) {
+    return target.kind === "group"
+        ? Consumer.Group(target.name)
+        : { kind: 1, id: target.name };
+}
+function rotateLeft(value, bits) {
+    return ((value << bits) | (value >>> (32 - bits))) >>> 0;
+}
+function xxHashRound(accumulator, lane) {
+    const added = (accumulator + Math.imul(lane, 0x85ebca77)) >>> 0;
+    return Math.imul(rotateLeft(added, 13), 0x9e3779b1) >>> 0;
+}
+export function xxHash32(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 0;
+    let hash;
+    if (bytes.byteLength >= 16) {
+        let lane1 = 0x24234428;
+        let lane2 = 0x85ebca77;
+        let lane3 = 0;
+        let lane4 = 0x61c8864f;
+        const limit = bytes.byteLength - 16;
+        do {
+            lane1 = xxHashRound(lane1, view.getUint32(offset, true));
+            lane2 = xxHashRound(lane2, view.getUint32(offset + 4, true));
+            lane3 = xxHashRound(lane3, view.getUint32(offset + 8, true));
+            lane4 = xxHashRound(lane4, view.getUint32(offset + 12, true));
+            offset += 16;
+        } while (offset <= limit);
+        hash =
+            (rotateLeft(lane1, 1) +
+                rotateLeft(lane2, 7) +
+                rotateLeft(lane3, 12) +
+                rotateLeft(lane4, 18)) >>>
+                0;
+    }
+    else {
+        hash = 0x165667b1;
+    }
+    hash = (hash + bytes.byteLength) >>> 0;
+    while (offset + 4 <= bytes.byteLength) {
+        hash = (hash + Math.imul(view.getUint32(offset, true), 0xc2b2ae3d)) >>> 0;
+        hash = Math.imul(rotateLeft(hash, 17), 0x27d4eb2f) >>> 0;
+        offset += 4;
+    }
+    while (offset < bytes.byteLength) {
+        hash = (hash + Math.imul(bytes[offset] ?? 0, 0x165667b1)) >>> 0;
+        hash = Math.imul(rotateLeft(hash, 11), 0x9e3779b1) >>> 0;
+        offset += 1;
+    }
+    hash ^= hash >>> 15;
+    hash = Math.imul(hash, 0x85ebca77) >>> 0;
+    hash ^= hash >>> 13;
+    hash = Math.imul(hash, 0xc2b2ae3d) >>> 0;
+    hash ^= hash >>> 16;
+    return hash >>> 0;
+}
+function toIggyPollingStrategy(strategy) {
+    switch (strategy.kind) {
+        case "first":
+            return IggyPollingStrategy.First;
+        case "last":
+            return IggyPollingStrategy.Last;
+        case "next":
+            return IggyPollingStrategy.Next;
+        case "offset":
+            return IggyPollingStrategy.Offset(strategy.value);
+        case "timestamp":
+            return IggyPollingStrategy.Timestamp(strategy.value);
+    }
+}
+function toIggyHeaderValue(value) {
+    switch (value.kind) {
+        case "raw":
+            return IggyHeaderValueFactory.Raw(Buffer.from(value.value));
+        case "string":
+            return IggyHeaderValueFactory.String(value.value);
+        case "bool":
+            return IggyHeaderValueFactory.Bool(value.value);
+        case "int8":
+            return IggyHeaderValueFactory.Int8(value.value);
+        case "int16":
+            return IggyHeaderValueFactory.Int16(value.value);
+        case "int32":
+            return IggyHeaderValueFactory.Int32(value.value);
+        case "int64":
+            return IggyHeaderValueFactory.Int64(value.value);
+        case "int128":
+            return IggyHeaderValueFactory.Int128(Buffer.from(value.value));
+        case "uint8":
+            return IggyHeaderValueFactory.Uint8(value.value);
+        case "uint16":
+            return IggyHeaderValueFactory.Uint16(value.value);
+        case "uint32":
+            return IggyHeaderValueFactory.Uint32(value.value);
+        case "uint64":
+            return IggyHeaderValueFactory.Uint64(value.value);
+        case "uint128":
+            return IggyHeaderValueFactory.Uint128(Buffer.from(value.value));
+        case "float":
+            return IggyHeaderValueFactory.Float(value.value);
+        case "double":
+            return IggyHeaderValueFactory.Double(value.value);
+    }
+}
+const HEADER_KIND_BY_NUMBER = {
+    1: "raw",
+    2: "string",
+    3: "bool",
+    4: "int8",
+    5: "int16",
+    6: "int32",
+    7: "int64",
+    8: "int128",
+    9: "uint8",
+    10: "uint16",
+    11: "uint32",
+    12: "uint64",
+    13: "uint128",
+    14: "float",
+    15: "double"
+};
+function fromParsedHeaderValue(kind, value) {
+    const tag = HEADER_KIND_BY_NUMBER[kind];
+    if (tag === undefined)
+        return undefined;
+    switch (tag) {
+        case "raw":
+        case "int128":
+        case "uint128": {
+            if (!(value instanceof Buffer))
+                return undefined;
+            return { kind: tag, value: new Uint8Array(value) };
+        }
+        case "string":
+            return typeof value === "string" ? { kind: tag, value } : undefined;
+        case "bool":
+            return typeof value === "boolean" ? { kind: tag, value } : undefined;
+        case "int64":
+        case "uint64":
+            return typeof value === "bigint" ? { kind: tag, value } : undefined;
+        case "int8":
+        case "int16":
+        case "int32":
+        case "uint8":
+        case "uint16":
+        case "uint32":
+        case "float":
+        case "double":
+            return typeof value === "number" ? { kind: tag, value } : undefined;
+    }
+}
+function parsedHeadersToMap(entries) {
+    const map = new Map();
+    for (const entry of entries) {
+        if (typeof entry.key.value !== "string")
+            continue;
+        const value = fromParsedHeaderValue(entry.value.kind, entry.value.value);
+        if (value !== undefined)
+            map.set(entry.key.value, value);
+    }
+    return map;
+}
+function laserDataHost(host) {
+    const normalized = host.toLowerCase();
+    return (normalized === "laserdata.cloud" ||
+        normalized.endsWith(".laserdata.cloud") ||
+        normalized === "laserdata.com" ||
+        normalized.endsWith(".laserdata.com"));
+}
+function parseReconnectInterval(value) {
+    if (value === null)
+        return DEFAULT_RECONNECT_INTERVAL_MS;
+    const match = /^(\d+)(ms|s|m)$/.exec(value);
+    if (match === null) {
+        throw new ConfigError("reconnection_interval must use ms, s, or m");
+    }
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit === "ms" ? 1 : unit === "s" ? 1_000 : 60_000;
+    const intervalMs = amount * multiplier;
+    if (!Number.isSafeInteger(intervalMs) || intervalMs < 0) {
+        throw new ConfigError("reconnection_interval is outside the supported range");
+    }
+    return intervalMs;
+}
+function parseReconnectRetries(value) {
+    if (value === "unlimited")
+        return undefined;
+    if (value === null)
+        return undefined;
+    const retries = Number(value);
+    if (!Number.isSafeInteger(retries) || retries < 0) {
+        throw new ConfigError("reconnection_retries must be a non-negative integer or unlimited");
+    }
+    return retries;
+}
+export function parseConnectionString(connectionString, env = process.env) {
+    const trimmed = connectionString.trim();
+    const withScheme = trimmed.startsWith("iggy://") || trimmed.startsWith("iggy+") ? trimmed : `iggy://${trimmed}`;
+    let url;
+    try {
+        url = new URL(withScheme);
+    }
+    catch (cause) {
+        throw new ConfigError(`invalid connection string: ${connectionString}`, { cause });
+    }
+    if (url.protocol !== "iggy:" && url.protocol !== "iggy+tcp:") {
+        throw new ConfigError(`unsupported connection scheme: ${url.protocol}`);
+    }
+    if (!url.hostname) {
+        throw new ConfigError(`connection string missing host: ${connectionString}`);
+    }
+    const port = url.port ? Number(url.port) : 8090;
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new ConfigError(`connection string has invalid port: ${connectionString}`);
+    }
+    const username = decodeURIComponent(url.username);
+    const password = decodeURIComponent(url.password);
+    const credentials = username.length === 0
+        ? { username: "iggy", password: "iggy" }
+        : password.length === 0
+            ? { token: username }
+            : { username, password };
+    const autoTls = env["LASER_NO_TLS"] === undefined && laserDataHost(url.hostname);
+    const tls = url.searchParams.get("tls") === "true" || autoTls;
+    const caPath = url.searchParams.get("tls_ca_file") ?? env["LASER_TLS_CERT"];
+    let ca;
+    if (caPath !== undefined && caPath.length > 0) {
+        try {
+            ca = readFileSync(caPath, "utf8");
+        }
+        catch (cause) {
+            throw new ConfigError(`failed to read TLS CA file: ${caPath}`, { cause });
+        }
+    }
+    else if (autoTls) {
+        ca = LASERDATA_ROOT_CA;
+    }
+    const reconnection = {
+        intervalMs: parseReconnectInterval(url.searchParams.get("reconnection_interval")),
+        maxRetries: parseReconnectRetries(url.searchParams.get("reconnection_retries"))
+    };
+    return {
+        host: url.hostname,
+        port,
+        credentials,
+        tls,
+        ...(ca !== undefined ? { ca } : {}),
+        reconnection
+    };
+}
+async function connectSimpleClient(parsed) {
+    const config = parsed.tls
+        ? {
+            protocol: "vsr",
+            heartbeatInterval: VSR_HEARTBEAT_INTERVAL_MS,
+            transport: "TLS",
+            options: {
+                port: parsed.port,
+                host: parsed.host,
+                ...(parsed.ca !== undefined ? { ca: parsed.ca } : {})
+            },
+            credentials: parsed.credentials,
+            reconnect: { enabled: false, interval: 0, maxRetries: 0 }
+        }
+        : {
+            protocol: "vsr",
+            heartbeatInterval: VSR_HEARTBEAT_INTERVAL_MS,
+            transport: "TCP",
+            options: { port: parsed.port, host: parsed.host },
+            credentials: parsed.credentials,
+            reconnect: { enabled: false, interval: 0, maxRetries: 0 }
+        };
+    let raw;
+    try {
+        raw = getRawClient(config);
+        const connection = raw.connection;
+        const client = new SimpleClient(raw);
+        await new Promise((resolve, reject) => {
+            const failed = (cause) => {
+                reject(cause instanceof Error ? cause : new Error(String(cause)));
+            };
+            connection.once("error", failed);
+            client.client.getMe().then(() => {
+                connection.off("error", failed);
+                resolve();
+            }, reject);
+        });
+        connection.on("error", () => undefined);
+        return { client, raw };
+    }
+    catch (cause) {
+        raw?.destroy();
+        throw new TransportError(`failed to connect to ${parsed.host}:${String(parsed.port)}`, false, {
+            cause
+        });
+    }
+}
+function serverResponseError(error) {
+    let current = error;
+    for (let depth = 0; depth < 8; depth += 1) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        if ("errorCode" in current &&
+            typeof current.errorCode === "number") {
+            return current instanceof Error ? current : new Error("server rejected connection");
+        }
+        current = "cause" in current ? current.cause : undefined;
+    }
+    return undefined;
+}
+async function connectWithRetry(parsed) {
+    let retries = 0;
+    let lastError;
+    while (parsed.reconnection.maxRetries === undefined ||
+        retries <= parsed.reconnection.maxRetries) {
+        try {
+            return await connectSimpleClient(parsed);
+        }
+        catch (error) {
+            lastError = error;
+            if (serverResponseError(error) !== undefined) {
+                break;
+            }
+            if (parsed.reconnection.maxRetries !== undefined &&
+                retries >= parsed.reconnection.maxRetries) {
+                break;
+            }
+            retries += 1;
+            await new Promise((resolve) => setTimeout(resolve, parsed.reconnection.intervalMs));
+        }
+    }
+    const responseError = serverResponseError(lastError);
+    const message = responseError === undefined
+        ? `failed to connect to ${parsed.host}:${String(parsed.port)}`
+        : `server rejected connection: ${responseError.message}`;
+    throw new TransportError(message, responseError === undefined, { cause: lastError });
+}
+export class ApacheIggyTransport {
+    client;
+    connection;
+    ownership;
+    kind = "apache-iggy";
+    reconnectLock = new Mutex();
+    disconnected = new WeakSet();
+    consumerGroups = new Map();
+    partitionCounts = new Map();
+    balancedCursors = new Map();
+    closed = false;
+    constructor(client, connection, ownership) {
+        this.client = client;
+        this.connection = connection;
+        this.ownership = ownership;
+    }
+    get iggyClient() {
+        return this.client;
+    }
+    static async connect(connectionString) {
+        const parsed = parseConnectionString(connectionString);
+        const connected = await connectWithRetry(parsed);
+        const transport = new ApacheIggyTransport(connected.client, parsed, "owned");
+        transport.watch(connected);
+        return transport;
+    }
+    static async fromClient(client, ownership = "borrowed") {
+        const raw = await client.clientProvider();
+        if (raw.protocol !== "vsr") {
+            throw new ConfigError("Laser requires an Apache Iggy VSR client");
+        }
+        return new ApacheIggyTransport(client, undefined, ownership);
+    }
+    async execute(operation, message) {
+        const stale = this.client;
+        if (this.disconnected.has(stale)) {
+            await this.reconnect(stale);
+            return operation(this.client);
+        }
+        try {
+            return await operation(stale);
+        }
+        catch (firstCause) {
+            if (!this.disconnected.has(stale)) {
+                throw new TransportError(message, true, { cause: firstCause });
+            }
+            try {
+                await this.reconnect(stale);
+                return await operation(this.client);
+            }
+            catch (cause) {
+                throw new TransportError(message, true, { cause: cause ?? firstCause });
+            }
+        }
+    }
+    reconnect(stale) {
+        return this.reconnectLock.runExclusive(async () => {
+            if (this.closed)
+                throw new TransportError("transport is closed", false);
+            if (this.client !== stale)
+                return;
+            if (this.connection === undefined) {
+                throw new TransportError("an injected client cannot be reconnected by Laser", true);
+            }
+            await stale.destroy().catch(() => undefined);
+            let retries = 0;
+            let lastError;
+            while (this.connection.reconnection.maxRetries === undefined ||
+                retries <= this.connection.reconnection.maxRetries) {
+                try {
+                    const connected = await connectSimpleClient(this.connection);
+                    try {
+                        for (const group of this.consumerGroups.values()) {
+                            await connected.client.group.ensureAndJoin(group.streamId, group.topicId, group.name);
+                        }
+                    }
+                    catch (cause) {
+                        await connected.client.destroy().catch(() => undefined);
+                        throw cause;
+                    }
+                    this.client = connected.client;
+                    this.watch(connected);
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (serverResponseError(error) !== undefined) {
+                        break;
+                    }
+                    if (this.connection.reconnection.maxRetries !== undefined &&
+                        retries >= this.connection.reconnection.maxRetries) {
+                        break;
+                    }
+                    retries += 1;
+                    await new Promise((resolve) => setTimeout(resolve, this.connection?.reconnection.intervalMs ?? 0));
+                }
+            }
+            const responseError = serverResponseError(lastError);
+            const message = responseError === undefined
+                ? "reconnect attempts exhausted"
+                : `server rejected connection: ${responseError.message}`;
+            throw new TransportError(message, responseError === undefined, { cause: lastError });
+        });
+    }
+    watch(connected) {
+        const markDisconnected = () => {
+            this.disconnected.add(connected.client);
+        };
+        const stream = connected.raw.getReadStream();
+        stream.once("error", markDisconnected);
+        stream.once("end", markDisconnected);
+        stream.once("close", markDisconnected);
+    }
+    async sendManaged(code, payload) {
+        const buffer = Buffer.from(payload);
+        const reply = await this.execute((client) => client.sendBinaryRequest(code, buffer), `managed command ${String(code)} failed`);
+        return new Uint8Array(reply.buffer, reply.byteOffset, reply.byteLength);
+    }
+    async ensureStream(name) {
+        await this.execute((client) => client.stream.ensure(name), `failed to ensure stream \`${name}\``);
+    }
+    async ensureTopic(streamId, topicId, partitions) {
+        const topic = await this.execute((client) => client.topic.ensure(streamId, topicId, partitions), `failed to ensure topic \`${topicId}\` on stream \`${streamId}\``);
+        this.partitionCounts.set(this.topicKey(streamId, topicId), topic.partitionsCount);
+    }
+    async ensureTopicWithExpiry(streamId, topicId, partitions, messageExpiryMicros) {
+        const partitionCount = await this.execute(async (client) => {
+            const topic = await client.topic.ensure(streamId, topicId, partitions);
+            if (topic.messageExpiry === messageExpiryMicros)
+                return topic.partitionsCount;
+            await client.topic.update({
+                streamId,
+                topicId,
+                name: topic.name,
+                messageExpiry: messageExpiryMicros
+            });
+            return topic.partitionsCount;
+        }, `failed to ensure topic \`${topicId}\` on stream \`${streamId}\` with message expiry`);
+        this.partitionCounts.set(this.topicKey(streamId, topicId), partitionCount);
+    }
+    async findTopicPartitionCount(streamId, topicId) {
+        const topic = await this.execute((client) => client.topic.get({ streamId, topicId }), `failed to read topic \`${topicId}\``);
+        if (topic === null)
+            return undefined;
+        this.partitionCounts.set(this.topicKey(streamId, topicId), topic.partitionsCount);
+        return topic.partitionsCount;
+    }
+    async getTopicPartitionCount(streamId, topicId) {
+        const partitions = await this.findTopicPartitionCount(streamId, topicId);
+        if (partitions === undefined) {
+            throw new TransportError(`topic \`${topicId}\` on stream \`${streamId}\` does not exist`, false);
+        }
+        return partitions;
+    }
+    async resolveStreamTopicIds(streamId, topicId) {
+        const [stream, topic] = await this.execute((client) => Promise.all([client.stream.get({ streamId }), client.topic.get({ streamId, topicId })]), `failed to resolve topic \`${topicId}\``);
+        if (stream === null) {
+            throw new TransportError(`stream \`${streamId}\` does not exist`, false);
+        }
+        if (topic === null) {
+            throw new TransportError(`topic \`${topicId}\` on stream \`${streamId}\` does not exist`, false);
+        }
+        return { streamId: stream.id, topicId: topic.id };
+    }
+    async resolveStreamTopicNames(streamId, topicId) {
+        const stream = await this.execute((client) => client.stream.get({ streamId }), `failed to resolve stream ${String(streamId)}`);
+        if (stream === null)
+            return undefined;
+        const topic = await this.execute((client) => client.topic.get({ streamId, topicId }), `failed to resolve topic ${String(topicId)}`);
+        return topic === null ? undefined : { stream: stream.name, topic: topic.name };
+    }
+    async sendMessages(streamId, topicId, payloads, routing) {
+        const partitionId = await this.resolvePartition(streamId, topicId, routing);
+        await this.execute((client) => client.message.send({
+            streamId,
+            topicId,
+            messages: payloads.map((payload) => ({ payload: Buffer.from(payload) })),
+            partition: Partitioning.PartitionId(partitionId)
+        }), `failed to send to topic \`${topicId}\``);
+    }
+    async sendMessageWithHeaders(streamId, topicId, payload, headers, partitionKey, partitionId) {
+        await this.sendMessagesWithHeaders(streamId, topicId, [{ payload, headers }], partitionKey, partitionId);
+    }
+    async sendMessagesWithHeaders(streamId, topicId, messages, partitionKey, partitionId) {
+        const resolvedPartition = await this.resolvePartition(streamId, topicId, partitionId !== undefined
+            ? { kind: "partition", partition: partitionId }
+            : partitionKey !== undefined
+                ? {
+                    kind: "key",
+                    key: typeof partitionKey === "string"
+                        ? new TextEncoder().encode(partitionKey)
+                        : partitionKey
+                }
+                : { kind: "balanced" });
+        await this.execute((client) => client.message.send({
+            streamId,
+            topicId,
+            messages: messages.map(({ payload, headers }) => ({
+                payload: Buffer.from(payload),
+                headers: [...headers].map(([key, value]) => ({
+                    key: HeaderKeyFactory.String(key),
+                    value: toIggyHeaderValue(value)
+                }))
+            })),
+            partition: Partitioning.PartitionId(resolvedPartition)
+        }), `failed to send to topic \`${topicId}\``);
+    }
+    async pollMessages(streamId, topicId, target, strategy, count, autoCommit) {
+        const reply = await this.execute((client) => client.message.poll({
+            streamId,
+            topicId,
+            partitionId: target.kind === "single" ? target.partitionId : null,
+            consumer: toIggyConsumer(target),
+            pollingStrategy: toIggyPollingStrategy(strategy),
+            count,
+            autocommit: autoCommit
+        }), `failed to poll topic \`${topicId}\``);
+        return reply.messages.map((message) => ({
+            payload: new Uint8Array(message.payload.buffer, message.payload.byteOffset, message.payload.byteLength),
+            partitionId: reply.partitionId,
+            offset: message.headers.offset,
+            timestampMicros: BigInt(message.headers.timestamp.getTime()) * 1000n,
+            headers: parsedHeadersToMap(message.userHeaders)
+        }));
+    }
+    async storeOffset(streamId, topicId, target, partitionId, offset) {
+        await this.execute((client) => client.offset.store({
+            streamId,
+            topicId,
+            consumer: toIggyConsumer(target),
+            partitionId,
+            offset
+        }), `failed to store offset for topic \`${topicId}\``);
+    }
+    async getConsumerOffset(streamId, topicId, target, partitionId) {
+        const offset = await this.execute((client) => client.offset.get({
+            streamId,
+            topicId,
+            consumer: toIggyOffsetConsumer(target),
+            partitionId
+        }), `failed to read offset for topic \`${topicId}\``);
+        return offset === null
+            ? undefined
+            : { storedOffset: offset.storedOffset, currentOffset: offset.currentOffset };
+    }
+    async joinConsumerGroup(streamId, topicId, name) {
+        await this.execute((client) => client.group.ensureAndJoin(streamId, topicId, name), `failed to join consumer group \`${name}\``);
+        this.consumerGroups.set(`${streamId}\0${topicId}\0${name}`, { streamId, topicId, name });
+    }
+    async leaveConsumerGroup(streamId, topicId, name) {
+        await this.execute((client) => client.group.leave({ streamId, topicId, groupId: name }), `failed to leave consumer group \`${name}\``);
+        this.consumerGroups.delete(`${streamId}\0${topicId}\0${name}`);
+    }
+    async close() {
+        this.closed = true;
+        this.consumerGroups.clear();
+        if (this.ownership === "owned")
+            await this.client.destroy();
+    }
+    topicKey(streamId, topicId) {
+        return `${streamId}\0${topicId}`;
+    }
+    async resolvePartition(streamId, topicId, routing) {
+        if (routing.kind === "partition")
+            return routing.partition;
+        const key = this.topicKey(streamId, topicId);
+        const partitionCount = this.partitionCounts.get(key) ?? (await this.getTopicPartitionCount(streamId, topicId));
+        if (partitionCount <= 0) {
+            throw new TransportError(`topic \`${topicId}\` on stream \`${streamId}\` has no partitions`, false);
+        }
+        if (routing.kind === "key")
+            return xxHash32(routing.key) % partitionCount;
+        const cursor = this.balancedCursors.get(key) ?? 0;
+        this.balancedCursors.set(key, (cursor + 1) >>> 0);
+        return cursor % partitionCount;
+    }
+}
+//# sourceMappingURL=apache-iggy.js.map