@smart-byte/leani-sdk 0.1.0-rc.1

package/dist/backfill.js

@@ -0,0 +1,839 @@
+import { LeaniError, responseError } from "./errors.js";
+export { LeaniError } from "./errors.js";
+const BACKFILL_BATCHING_PROFILES = {
+    latency: {
+        targetEncodedBytes: 256 * 1024,
+        maximumEncodedBytes: 1024 * 1024,
+        maximumEvents: 2_000,
+        maximumProcessedBlocks: 512,
+        maximumDelayMs: 10,
+        compression: "gzip",
+    },
+    balanced: {
+        targetEncodedBytes: 1024 * 1024,
+        maximumEncodedBytes: 4 * 1024 * 1024,
+        maximumEvents: 10_000,
+        maximumProcessedBlocks: 4_096,
+        maximumDelayMs: 25,
+        compression: "gzip",
+    },
+    throughput: {
+        targetEncodedBytes: 4 * 1024 * 1024,
+        maximumEncodedBytes: 16 * 1024 * 1024,
+        maximumEvents: 20_000,
+        maximumProcessedBlocks: 8_192,
+        maximumDelayMs: 50,
+        compression: "gzip",
+    },
+};
+export function backfillBatchingProfile(profile) {
+    return { ...BACKFILL_BATCHING_PROFILES[profile] };
+}
+export class BackfillStreamError extends Error {
+    code;
+    earliestAvailableSequence;
+    latestAvailableSequence;
+    constructor(record) {
+        super(record.message);
+        this.name =
+            record.type === "reset_required"
+                ? "BackfillStreamResetError"
+                : "BackfillStreamError";
+        this.code = record.code;
+        this.earliestAvailableSequence = record.earliestAvailableSequence;
+        this.latestAvailableSequence = record.latestAvailableSequence;
+    }
+}
+export function createBackfillSubscriptionClient(options) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new TypeError("a fetch implementation is required");
+    }
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    assertPositiveInteger(timeoutMs, "timeoutMs");
+    const requestJson = async (method, path, body, signal, credential, sessionToken) => {
+        const response = await fetchImpl(new URL(path, baseUrl), {
+            method,
+            headers: requestHeaders(options.token, "application/json", credential, sessionToken),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: signal
+                ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
+                : AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            throw await responseError(response);
+        }
+        return (await response.json());
+    };
+    return Object.freeze({
+        baseUrl,
+        create: (request) => requestJson("POST", "admin/v1/backfill-subscriptions", {
+            processor: request.processor,
+            ...(request.ranges === undefined
+                ? {
+                    fromBlock: assertBlock(request.fromBlock, "fromBlock"),
+                    toBlock: assertUpperBound(request.toBlock, "toBlock"),
+                }
+                : {
+                    ranges: request.ranges.map((range, index) => ({
+                        fromBlock: assertBlock(range.fromBlock, `ranges[${index}].fromBlock`),
+                        toBlock: assertUpperBound(range.toBlock, `ranges[${index}].toBlock`),
+                    })),
+                }),
+            mode: request.mode ?? "fill_missing",
+            consumer: request.consumer === undefined
+                ? undefined
+                : {
+                    id: assertIdentity(request.consumer.id, "consumer.id"),
+                    role: request.consumer.role,
+                    leaseTtlSeconds: assertPositiveInteger(request.consumer.leaseTtlSeconds, "consumer.leaseTtlSeconds"),
+                    credential: request.consumer.credential === undefined
+                        ? undefined
+                        : assertIdentity(request.consumer.credential, "consumer.credential"),
+                },
+            limits: request.limits === undefined
+                ? undefined
+                : {
+                    maxUnacknowledgedBlocks: assertPositiveInteger(request.limits.maxUnacknowledgedBlocks, "limits.maxUnacknowledgedBlocks"),
+                    maxUnacknowledgedBytes: assertPositiveInteger(request.limits.maxUnacknowledgedBytes, "limits.maxUnacknowledgedBytes"),
+                    resumeBelowRatio: assertRatio(request.limits.resumeBelowRatio, "limits.resumeBelowRatio"),
+                },
+            batching: request.batching === undefined
+                ? undefined
+                : {
+                    targetEncodedBytes: request.batching.targetEncodedBytes === undefined
+                        ? undefined
+                        : assertPositiveInteger(request.batching.targetEncodedBytes, "batching.targetEncodedBytes"),
+                    maximumEncodedBytes: request.batching.maximumEncodedBytes === undefined
+                        ? undefined
+                        : assertPositiveInteger(request.batching.maximumEncodedBytes, "batching.maximumEncodedBytes"),
+                    maximumEvents: request.batching.maximumEvents === undefined
+                        ? undefined
+                        : assertPositiveInteger(request.batching.maximumEvents, "batching.maximumEvents"),
+                    maximumProcessedBlocks: request.batching.maximumProcessedBlocks === undefined
+                        ? undefined
+                        : assertPositiveInteger(request.batching.maximumProcessedBlocks, "batching.maximumProcessedBlocks"),
+                    maximumDelayMs: request.batching.maximumDelayMs === undefined
+                        ? undefined
+                        : assertPositiveInteger(request.batching.maximumDelayMs, "batching.maximumDelayMs"),
+                    compression: request.batching.compression,
+                },
+            idempotencyKey: assertIdentity(request.idempotencyKey, "idempotencyKey"),
+        }, request.signal),
+        list: async (listOptions) => {
+            const response = await requestJson("GET", "admin/v1/backfill-subscriptions", undefined, listOptions?.signal);
+            return response.data;
+        },
+        inspect: (subscription, inspectOptions) => requestJson("GET", `admin/v1/backfill-subscriptions/${encodeURIComponent(assertIdentity(subscription, "subscription"))}`, undefined, inspectOptions?.signal),
+        cancel: (subscription, cancelOptions) => requestJson("POST", `admin/v1/backfill-subscriptions/${encodeURIComponent(assertIdentity(subscription, "subscription"))}/cancel`, undefined, cancelOptions?.signal),
+        delete: (subscription, deleteOptions) => requestJson("DELETE", `admin/v1/backfill-subscriptions/${encodeURIComponent(assertIdentity(subscription, "subscription"))}`, undefined, deleteOptions?.signal),
+        changes: (subscription, consumer, changeOptions = {}) => {
+            const path = consumerPath(subscription, consumer, "changes");
+            const url = new URL(path, baseUrl);
+            if (changeOptions.limit !== undefined) {
+                url.searchParams.set("limit", String(assertPositiveInteger(changeOptions.limit, "limit")));
+            }
+            return fetchImpl(url, {
+                headers: requestHeaders(options.token, "application/json", changeOptions.credential),
+                signal: changeOptions.signal,
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw await responseError(response);
+                }
+                return (await response.json());
+            });
+        },
+        stream: (subscription, consumer, streamOptions = {}) => openBackfillStream(fetchImpl, baseUrl, options.token, subscription, consumer, streamOptions.credential, streamOptions.batching, streamOptions.signal),
+        streamLive: (processor, consumer, streamOptions = {}) => openLiveStream(fetchImpl, baseUrl, options.token, processor, consumer, streamOptions.credential, streamOptions.signal),
+        subscribe: (request) => openMultiLaneDelivery(fetchImpl, baseUrl, options.token, request),
+    });
+}
+async function openMultiLaneDelivery(fetchImpl, baseUrl, token, request) {
+    const processor = assertIdentity(request.processor, "processor");
+    const consumer = assertIdentity(request.consumer, "consumer");
+    const history = request.lanes.history ?? [];
+    const historyIds = history.map(({ subscriptionId }, index) => assertIdentity(subscriptionId, `lanes.history[${index}].subscriptionId`));
+    if (new Set(historyIds).size !== historyIds.length) {
+        throw new TypeError("history subscription IDs must be unique");
+    }
+    if (!request.lanes.live && historyIds.length === 0) {
+        throw new TypeError("subscribe requires at least one live or history lane");
+    }
+    const view = request.view ?? "live_priority";
+    const lanes = [];
+    try {
+        if (request.lanes.live) {
+            const open = (signal = request.signal) => openLiveStream(fetchImpl, baseUrl, token, processor, consumer, request.credential, signal);
+            lanes.push(unifiedLiveLane(await open(), open, request.signal));
+        }
+        for (const subscriptionId of historyIds) {
+            const open = (signal = request.signal) => openBackfillStream(fetchImpl, baseUrl, token, subscriptionId, consumer, request.credential, request.batching, signal);
+            lanes.push(unifiedHistoryLane(subscriptionId, await open(), open, request.signal));
+        }
+    }
+    catch (error) {
+        await Promise.allSettled(lanes.map((lane) => lane.close()));
+        throw error;
+    }
+    if (lanes.length > 1 &&
+        lanes.some((lane) => lane.deliveryOrdering === "canonical")) {
+        await Promise.allSettled(lanes.map((lane) => lane.close()));
+        throw new TypeError("canonical processors cannot interleave live and history lanes");
+    }
+    const claimed = new Set();
+    const claim = (selected) => {
+        const duplicate = selected.find((lane) => claimed.has(lane.streamId));
+        if (duplicate) {
+            throw new TypeError(`delivery lane ${duplicate.streamId} is already being iterated`);
+        }
+        for (const lane of selected) {
+            claimed.add(lane.streamId);
+        }
+    };
+    const iterate = (selected) => iterateUnifiedLanes([selected], claim);
+    const byStream = new Map(lanes.map((lane) => [lane.streamId, lane]));
+    const live = lanes.find((lane) => lane.kind === "live");
+    const byHistoryId = new Map(lanes
+        .filter((lane) => lane.kind === "history")
+        .map((lane) => [lane.laneId, lane]));
+    return Object.freeze({
+        batches: () => {
+            if (view !== "live_priority") {
+                throw new TypeError("batches() requires view=live_priority; use lane-specific iterators");
+            }
+            return iterateUnifiedLanes(lanes, claim);
+        },
+        liveBatches: () => {
+            if (view !== "lane_specific") {
+                throw new TypeError("liveBatches() requires view=lane_specific");
+            }
+            if (!live) {
+                throw new TypeError("the delivery subscription has no live lane");
+            }
+            return iterate(live);
+        },
+        historyBatches: (subscriptionId) => {
+            if (view !== "lane_specific") {
+                throw new TypeError("historyBatches() requires view=lane_specific");
+            }
+            const id = assertIdentity(subscriptionId, "subscriptionId");
+            const lane = byHistoryId.get(id);
+            if (!lane) {
+                throw new TypeError(`history subscription ${id} is not selected`);
+            }
+            return iterate(lane);
+        },
+        acknowledge: (batch, acknowledgeOptions) => {
+            const lane = byStream.get(batch.streamId);
+            if (!lane || lane.laneId !== batch.laneId || lane.kind !== batch.laneKind) {
+                throw new TypeError("delivery batch does not belong to this subscription object");
+            }
+            return lane.acknowledge(batch.ackCursor, acknowledgeOptions);
+        },
+        close: async () => {
+            const outcomes = await Promise.allSettled(lanes.map((lane) => lane.close()));
+            const failed = outcomes.find((outcome) => outcome.status === "rejected");
+            if (failed) {
+                throw failed.reason;
+            }
+        },
+    });
+}
+function unifiedLiveLane(initialSession, open, signal) {
+    const connection = reconnectingLaneConnection(initialSession, open, signal);
+    return {
+        kind: "live",
+        laneId: "live",
+        streamId: initialSession.hello.streamId,
+        deliveryOrdering: initialSession.hello.processor.deliveryOrdering,
+        async next() {
+            while (true) {
+                const next = await connection.next();
+                if (next.done)
+                    return { done: true, value: undefined };
+                if (next.value.type === "heartbeat")
+                    continue;
+                const record = next.value;
+                return {
+                    done: false,
+                    value: {
+                        laneKind: "live",
+                        laneId: "live",
+                        streamId: record.streamId,
+                        ackCursor: record.acknowledgeableCursor,
+                        events: record.changes,
+                        record,
+                    },
+                };
+            }
+        },
+        acknowledge: connection.acknowledge,
+        close: connection.close,
+    };
+}
+function unifiedHistoryLane(subscriptionId, initialSession, open, signal) {
+    const connection = reconnectingLaneConnection(initialSession, open, signal);
+    let complete = false;
+    return {
+        kind: "history",
+        laneId: subscriptionId,
+        streamId: initialSession.hello.streamId,
+        deliveryOrdering: initialSession.hello.processor.deliveryOrdering,
+        async next() {
+            if (complete)
+                return { done: true, value: undefined };
+            while (true) {
+                const next = await connection.next();
+                if (next.done)
+                    return { done: true, value: undefined };
+                if (next.value.type === "heartbeat")
+                    continue;
+                if (next.value.type === "backfill_complete") {
+                    complete = true;
+                    const record = next.value;
+                    return {
+                        done: false,
+                        value: {
+                            laneKind: "history",
+                            laneId: subscriptionId,
+                            streamId: record.streamId,
+                            ackCursor: record.cursor,
+                            events: [],
+                            completion: record,
+                            record,
+                        },
+                    };
+                }
+                const record = next.value;
+                return {
+                    done: false,
+                    value: {
+                        laneKind: "history",
+                        laneId: subscriptionId,
+                        streamId: record.streamId,
+                        ackCursor: record.acknowledgeableCursor,
+                        events: record.changes,
+                        record,
+                    },
+                };
+            }
+        },
+        acknowledge: connection.acknowledge,
+        close: connection.close,
+    };
+}
+function reconnectingLaneConnection(initialSession, open, signal) {
+    const expected = initialSession.hello;
+    const stop = new AbortController();
+    const reconnectSignal = signal
+        ? AbortSignal.any([signal, stop.signal])
+        : stop.signal;
+    let session = initialSession;
+    let iterator = session[Symbol.asyncIterator]();
+    let closed = false;
+    let reconnectTask;
+    const reconnect = () => {
+        reconnectTask ??= (async () => {
+            await session.close().catch(() => undefined);
+            let delayMs = 25;
+            while (!reconnectSignal.aborted) {
+                try {
+                    const replacement = await open(reconnectSignal);
+                    try {
+                        validateReplacementHello(expected, replacement.hello);
+                    }
+                    catch (error) {
+                        await replacement.close().catch(() => undefined);
+                        throw error;
+                    }
+                    session = replacement;
+                    iterator = replacement[Symbol.asyncIterator]();
+                    return;
+                }
+                catch (error) {
+                    if (!isRetryableDeliveryDisconnect(error))
+                        throw error;
+                    await waitForReconnectDelay(delayMs, reconnectSignal);
+                    delayMs = Math.min(delayMs * 2, 5_000);
+                }
+            }
+            throw reconnectSignal.reason ?? new DOMException("Aborted", "AbortError");
+        })().finally(() => {
+            reconnectTask = undefined;
+        });
+        return reconnectTask;
+    };
+    const next = async () => {
+        while (!closed && !reconnectSignal.aborted) {
+            try {
+                const result = await iterator.next();
+                if (!result.done)
+                    return result;
+            }
+            catch (error) {
+                if (!isRetryableDeliveryDisconnect(error))
+                    throw error;
+            }
+            await reconnect();
+        }
+        return { done: true, value: undefined };
+    };
+    const acknowledge = async (cursor, options) => {
+        try {
+            return await session.acknowledge(cursor, options);
+        }
+        catch (error) {
+            if (!isRetryableDeliveryDisconnect(error))
+                throw error;
+            await reconnect();
+            return session.acknowledge(cursor, options);
+        }
+    };
+    return {
+        next,
+        acknowledge,
+        close: async () => {
+            if (closed)
+                return;
+            closed = true;
+            stop.abort();
+            await session.close();
+            await reconnectTask?.catch((error) => {
+                if (!isAbortError(error))
+                    throw error;
+            });
+        },
+    };
+}
+function validateReplacementHello(expected, replacement) {
+    if (replacement.streamId !== expected.streamId ||
+        replacement.storeEpoch !== expected.storeEpoch ||
+        replacement.processor.id !== expected.processor.id ||
+        replacement.processor.version !== expected.processor.version ||
+        replacement.processor.codeHash !== expected.processor.codeHash ||
+        replacement.processor.configHash !== expected.processor.configHash ||
+        replacement.processor.deliveryOrdering !==
+            expected.processor.deliveryOrdering) {
+        throw streamProtocolError("live", "replacement connection changed its durable lane identity");
+    }
+}
+function isRetryableDeliveryDisconnect(error) {
+    if (isAbortError(error) || error instanceof BackfillStreamError)
+        return false;
+    if (error instanceof LeaniError) {
+        return error.retryable || error.code === "consumer_session_active" ||
+            error.code === "consumer_session_lost";
+    }
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === "consumer_session_active" ||
+        error.name === "consumer_session_lost") {
+        return true;
+    }
+    if (error.name === "NetworkError" || error.name === "TimeoutError")
+        return true;
+    return (error.name === "TypeError" &&
+        /fetch|network|load failed|socket|connection/i.test(error.message));
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+async function waitForReconnectDelay(delayMs, signal) {
+    if (signal.aborted) {
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+    }
+    await new Promise((resolve, reject) => {
+        const finish = () => {
+            signal.removeEventListener("abort", abort);
+            resolve();
+        };
+        const timeout = setTimeout(finish, delayMs);
+        const abort = () => {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", abort);
+            reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        };
+        signal.addEventListener("abort", abort, { once: true });
+    });
+}
+function iterateUnifiedLanes(lanes, claim) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            claim(lanes);
+            const ready = [];
+            const settled = new Map();
+            let wake;
+            let active = lanes.length;
+            const schedule = (index) => {
+                lanes[index].next().then((result) => {
+                    settled.set(index, { result });
+                    ready.push(index);
+                    wake?.();
+                    wake = undefined;
+                }, (error) => {
+                    settled.set(index, { error });
+                    ready.push(index);
+                    wake?.();
+                    wake = undefined;
+                });
+            };
+            for (let index = 0; index < lanes.length; index += 1)
+                schedule(index);
+            while (active > 0) {
+                if (ready.length === 0) {
+                    await new Promise((resolve) => {
+                        wake = resolve;
+                    });
+                }
+                const livePosition = ready.findIndex((index) => lanes[index].kind === "live");
+                const [index] = ready.splice(livePosition >= 0 ? livePosition : 0, 1);
+                const outcome = settled.get(index);
+                settled.delete(index);
+                if (!outcome)
+                    throw new Error("delivery scheduler lost a settled lane");
+                if ("error" in outcome)
+                    throw outcome.error;
+                if (outcome.result.done) {
+                    active -= 1;
+                    continue;
+                }
+                const completed = outcome.result.value.completion !== undefined;
+                if (completed) {
+                    active -= 1;
+                }
+                yield outcome.result.value;
+                if (!completed) {
+                    schedule(index);
+                    await Promise.resolve();
+                }
+            }
+        },
+    };
+}
+async function openBackfillStream(fetchImpl, baseUrl, token, subscription, consumer, credential, batching, signal) {
+    const session = await openDeliverySession(fetchImpl, baseUrl, token, backfillStreamPath(subscription, consumer, batching), consumerPath(subscription, consumer, "ack"), consumerPath(subscription, consumer, "lease"), credential, signal, "backfill");
+    const batches = async function* () {
+        for await (const record of session) {
+            if (record.type === "batch") {
+                yield record;
+            }
+        }
+    };
+    const events = async function* () {
+        for await (const batch of batches()) {
+            yield* batch.changes;
+        }
+    };
+    return Object.freeze({
+        hello: session.hello,
+        acknowledge: session.acknowledge.bind(session),
+        close: session.close.bind(session),
+        batches,
+        events,
+        [Symbol.asyncIterator]: session[Symbol.asyncIterator].bind(session),
+    });
+}
+async function openLiveStream(fetchImpl, baseUrl, token, processor, consumer, credential, signal) {
+    return openDeliverySession(fetchImpl, baseUrl, token, liveConsumerPath(processor, consumer, "stream"), liveConsumerPath(processor, consumer, "ack"), liveConsumerPath(processor, consumer, "lease"), credential, signal, "live");
+}
+async function openDeliverySession(fetchImpl, baseUrl, token, streamPath, acknowledgePath, renewPath, credential, signal, streamKind) {
+    const connectionStop = new AbortController();
+    const stopFromCaller = () => connectionStop.abort(signal?.reason);
+    if (signal?.aborted) {
+        stopFromCaller();
+    }
+    else {
+        signal?.addEventListener("abort", stopFromCaller, { once: true });
+    }
+    const response = await fetchImpl(new URL(streamPath, baseUrl), {
+        headers: requestHeaders(token, "application/x-ndjson", credential),
+        signal: connectionStop.signal,
+    });
+    if (!response.ok) {
+        signal?.removeEventListener("abort", stopFromCaller);
+        throw await responseError(response);
+    }
+    if (!response.body) {
+        signal?.removeEventListener("abort", stopFromCaller);
+        throw new BackfillStreamError({
+            type: "error",
+            code: "stream_body_missing",
+            message: `${streamKind} stream response has no body`,
+            earliestAvailableSequence: null,
+            latestAvailableSequence: null,
+        });
+    }
+    const records = parseNdjson(response.body, connectionStop.signal);
+    const first = await records.next();
+    if (first.done) {
+        connectionStop.abort();
+        signal?.removeEventListener("abort", stopFromCaller);
+        throw streamProtocolError(streamKind, "stream ended before its hello record");
+    }
+    const firstType = first.value.type;
+    if (firstType === "error" || firstType === "reset_required") {
+        connectionStop.abort();
+        signal?.removeEventListener("abort", stopFromCaller);
+        throw new BackfillStreamError(first.value);
+    }
+    if (firstType !== "hello") {
+        connectionStop.abort();
+        signal?.removeEventListener("abort", stopFromCaller);
+        throw streamProtocolError(streamKind, "first stream record is not hello");
+    }
+    const wireHello = first.value;
+    const sessionToken = assertIdentity(wireHello.sessionToken, "stream hello sessionToken");
+    const leaseTtlMs = parseLeaseTtl(wireHello.leaseTtlMs);
+    const { sessionToken: _sessionToken, ...publicHello } = wireHello;
+    const renewalStop = new AbortController();
+    let renewalError;
+    const renewalTask = renewSessionUntilStopped(fetchImpl, baseUrl, token, renewPath, credential, sessionToken, leaseTtlMs, renewalStop.signal).catch((error) => {
+        if (!renewalStop.signal.aborted) {
+            renewalError = error;
+        }
+    });
+    let iteratorClaimed = false;
+    let closeTask;
+    const close = () => {
+        closeTask ??= (async () => {
+            renewalStop.abort();
+            connectionStop.abort();
+            signal?.removeEventListener("abort", stopFromCaller);
+            try {
+                await records.return(undefined);
+            }
+            catch (error) {
+                if (!connectionStop.signal.aborted) {
+                    throw error;
+                }
+            }
+            await renewalTask;
+            try {
+                await fetchImpl(new URL(renewPath, baseUrl), {
+                    method: "DELETE",
+                    headers: requestHeaders(token, "application/json", credential, sessionToken),
+                });
+            }
+            catch {
+                // The lease also expires and is passively released when the stream
+                // disconnects. Explicit release only makes clean reconnect immediate.
+            }
+        })();
+        return closeTask;
+    };
+    const iterate = async function* () {
+        if (iteratorClaimed) {
+            throw new TypeError("a delivery session can only be iterated once");
+        }
+        iteratorClaimed = true;
+        try {
+            while (true) {
+                if (renewalError !== undefined) {
+                    throw renewalError;
+                }
+                const next = await records.next();
+                if (next.done) {
+                    if (renewalError !== undefined) {
+                        throw renewalError;
+                    }
+                    return;
+                }
+                const record = next.value;
+                const recordType = record.type;
+                if (recordType === "error" || recordType === "reset_required") {
+                    throw new BackfillStreamError(record);
+                }
+                if (recordType === "hello") {
+                    throw streamProtocolError(streamKind, "stream sent a second hello record");
+                }
+                yield record;
+            }
+        }
+        finally {
+            await close();
+        }
+    };
+    return Object.freeze({
+        hello: publicHello,
+        acknowledge: async (cursor, acknowledgeOptions) => {
+            if (closeTask !== undefined) {
+                throw new TypeError("delivery session is closed");
+            }
+            if (renewalError !== undefined) {
+                throw renewalError;
+            }
+            const acknowledge = await fetchImpl(new URL(acknowledgePath, baseUrl), {
+                method: "POST",
+                headers: requestHeaders(token, "application/json", credential, sessionToken),
+                body: JSON.stringify({ cursor: assertIdentity(cursor, "cursor") }),
+                signal: acknowledgeOptions?.signal,
+            });
+            if (!acknowledge.ok) {
+                throw await responseError(acknowledge);
+            }
+            return (await acknowledge.json());
+        },
+        close,
+        [Symbol.asyncIterator]: iterate,
+    });
+}
+function streamProtocolError(streamKind, message) {
+    return new BackfillStreamError({
+        type: "error",
+        code: "invalid_stream_protocol",
+        message: `${streamKind} ${message}`,
+        earliestAvailableSequence: null,
+        latestAvailableSequence: null,
+    });
+}
+async function renewSessionUntilStopped(fetchImpl, baseUrl, token, renewPath, credential, sessionToken, leaseTtlMs, stop) {
+    const intervalMs = Math.max(50, Math.floor(leaseTtlMs / 3));
+    while (!stop.aborted) {
+        await abortableDelay(intervalMs, stop);
+        if (stop.aborted) {
+            return;
+        }
+        const response = await fetchImpl(new URL(renewPath, baseUrl), {
+            method: "POST",
+            headers: requestHeaders(token, "application/json", credential, sessionToken),
+            signal: stop,
+        });
+        if (!response.ok) {
+            throw await responseError(response);
+        }
+        await response.arrayBuffer();
+    }
+}
+function abortableDelay(delayMs, signal) {
+    return new Promise((resolve) => {
+        const timeout = setTimeout(resolve, delayMs);
+        signal.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            resolve();
+        }, { once: true });
+    });
+}
+function parseLeaseTtl(value) {
+    const ttl = Number(value);
+    if (!Number.isSafeInteger(ttl) || ttl <= 0) {
+        throw new TypeError("stream hello contains an invalid leaseTtlMs");
+    }
+    return ttl;
+}
+export async function* parseNdjson(body, signal) {
+    const reader = body.getReader();
+    const cancel = () => { void reader.cancel().catch(() => { }); };
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted)
+        cancel();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw signal.reason ?? new DOMException("aborted", "AbortError");
+            }
+            const { done, value } = await reader.read();
+            buffer += decoder.decode(value, { stream: !done });
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (line) {
+                    yield JSON.parse(line);
+                }
+                newline = buffer.indexOf("\n");
+            }
+            if (done) {
+                const finalLine = buffer.trim();
+                if (finalLine) {
+                    yield JSON.parse(finalLine);
+                }
+                return;
+            }
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", cancel);
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}
+function normalizeBaseUrl(value) {
+    const url = new URL(value);
+    if (!url.pathname.endsWith("/")) {
+        url.pathname += "/";
+    }
+    return url;
+}
+function requestHeaders(token, accept, credential, sessionToken) {
+    const headers = new Headers({ accept });
+    if (token) {
+        headers.set("authorization", `Bearer ${token}`);
+    }
+    if (credential !== undefined) {
+        headers.set("x-leani-consumer-credential", assertIdentity(credential, "credential"));
+    }
+    if (sessionToken !== undefined) {
+        headers.set("x-leani-consumer-session", assertIdentity(sessionToken, "sessionToken"));
+    }
+    if (accept === "application/json") {
+        headers.set("content-type", "application/json");
+    }
+    return headers;
+}
+function consumerPath(subscription, consumer, operation) {
+    return (`v1/backfill-subscriptions/${encodeURIComponent(assertIdentity(subscription, "subscription"))}` +
+        `/consumers/${encodeURIComponent(assertIdentity(consumer, "consumer"))}/${operation}`);
+}
+function backfillStreamPath(subscription, consumer, batching) {
+    const path = consumerPath(subscription, consumer, "stream");
+    if (batching === undefined)
+        return path;
+    const query = new URLSearchParams();
+    for (const [field, value] of [
+        ["targetEncodedBytes", batching.targetEncodedBytes],
+        ["maximumEncodedBytes", batching.maximumEncodedBytes],
+        ["maximumEvents", batching.maximumEvents],
+        ["maximumProcessedBlocks", batching.maximumProcessedBlocks],
+        ["maximumDelayMs", batching.maximumDelayMs],
+    ]) {
+        if (value !== undefined) {
+            query.set(field, String(assertPositiveInteger(value, `batching.${field}`)));
+        }
+    }
+    return query.size === 0 ? path : `${path}?${query}`;
+}
+function liveConsumerPath(processor, consumer, operation) {
+    return (`v1/processors/${encodeURIComponent(assertIdentity(processor, "processor"))}` +
+        `/streams/live/consumers/${encodeURIComponent(assertIdentity(consumer, "consumer"))}/${operation}`);
+}
+function assertBlock(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError(`${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function assertUpperBound(value, field) {
+    return value === "finalized" ? value : assertBlock(value, field);
+}
+function assertPositiveInteger(value, field) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${field} must be a positive safe integer`);
+    }
+    return value;
+}
+function assertIdentity(value, field) {
+    if (!value.trim()) {
+        throw new TypeError(`${field} must not be empty`);
+    }
+    return value;
+}
+function assertRatio(value, field) {
+    if (!Number.isFinite(value) || value <= 0 || value >= 1) {
+        throw new TypeError(`${field} must be greater than zero and less than one`);
+    }
+    return value;
+}
+//# sourceMappingURL=backfill.js.map