@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/cursor-relay-core.js

@@ -7,33 +7,24 @@
  * as data or closures on a {@link RelayAdapter}, so this engine is written
  * once and tested through each provider's relay.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { LOG_PREFIX } from "./distribution.js";
 const OFFSET_SNAPSHOT_VERSION = 1;
-const DEFAULT_POLL_WAIT_MS = 25000;
+const DEFAULT_POLL_WAIT_MS = 25_000;
 const DEFAULT_POLL_LIMIT = 100;
 const DEFAULT_REGISTER_INTERVAL_MS = 5 * 60 * 1000;
 const CONSUMER_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
 const DEFAULT_IDLE_POLL_DELAY_MS = 250;
-const MIN_BACKOFF_MS = 1000;
-const MAX_BACKOFF_MS = 30000;
-const AUTH_FAILURE_BACKOFF_MS = 60000;
+const MIN_BACKOFF_MS = 1_000;
+const MAX_BACKOFF_MS = 30_000;
+const AUTH_FAILURE_BACKOFF_MS = 60_000;
 /** Attempts per event before the offset advances past it. */
 const DISPATCH_ATTEMPTS = 3;
-const DISPATCH_RETRY_DELAYS_MS = [250, 1000];
+const DISPATCH_RETRY_DELAYS_MS = [250, 1_000];
 /** Budget for the best-effort deregistration PUT during stop(). */
-const DEREGISTER_TIMEOUT_MS = 1500;
+const DEREGISTER_TIMEOUT_MS = 1_500;
 /** Durable offset snapshot under `<stateDir>/offset.json`. */
 export class RelayOffsetStore {
     constructor(stateDir) {
@@ -42,34 +33,30 @@ export class RelayOffsetStore {
     get filePath() {
         return join(this.stateDir, "offset.json");
     }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const raw = yield readFile(this.filePath, "utf8");
-                const parsed = JSON.parse(raw);
-                if (parsed.version === OFFSET_SNAPSHOT_VERSION && typeof parsed.offset === "string") {
-                    return parsed.offset;
-                }
-                return undefined;
+    async load() {
+        try {
+            const raw = await readFile(this.filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version === OFFSET_SNAPSHOT_VERSION && typeof parsed.offset === "string") {
+                return parsed.offset;
             }
-            catch (_a) {
-                return undefined;
-            }
-        });
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
     }
-    save(offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield mkdir(this.stateDir, { recursive: true });
-            const snapshot = {
-                version: OFFSET_SNAPSHOT_VERSION,
-                offset,
-                updatedAt: new Date().toISOString(),
-            };
-            // Write-then-rename so a crash mid-write never corrupts the snapshot.
-            const tmpPath = `${this.filePath}.tmp`;
-            yield writeFile(tmpPath, JSON.stringify(snapshot, null, 2), "utf8");
-            yield rename(tmpPath, this.filePath);
-        });
+    async save(offset) {
+        await mkdir(this.stateDir, { recursive: true });
+        const snapshot = {
+            version: OFFSET_SNAPSHOT_VERSION,
+            offset,
+            updatedAt: new Date().toISOString(),
+        };
+        // Write-then-rename so a crash mid-write never corrupts the snapshot.
+        const tmpPath = `${this.filePath}.tmp`;
+        await writeFile(tmpPath, JSON.stringify(snapshot, null, 2), "utf8");
+        await rename(tmpPath, this.filePath);
     }
 }
 /** Compare stream offsets (`<ms>-<seq>`). */
@@ -96,11 +83,10 @@ export const AGENT_SERVE_GENERATION_HEADER = "x-agent-serve-generation";
 /** Must match server-shared `AGENT_SERVE_GENERATION_ENV_VAR`. */
 export const AGENT_SERVE_GENERATION_ENV_VAR = "AGENT_SERVE_GENERATION";
 export function resolveAgentServeDeploymentGeneration(explicit) {
-    var _a;
     if (explicit !== undefined && Number.isSafeInteger(explicit) && explicit > 0) {
         return explicit;
     }
-    const raw = (_a = process.env[AGENT_SERVE_GENERATION_ENV_VAR]) === null || _a === void 0 ? void 0 : _a.trim();
+    const raw = process.env[AGENT_SERVE_GENERATION_ENV_VAR]?.trim();
     if (raw === undefined || raw.length === 0) {
         return undefined;
     }
@@ -115,14 +101,13 @@ export function resolveAgentServeDeploymentGeneration(explicit) {
 }
 export class CursorRelayCore {
     constructor(options) {
-        var _a;
         this.options = options;
         this.running = false;
         this.consumerId = "";
         /** Whether any registration succeeded (gates the stop-time deregister). */
         this.registeredOnce = false;
         this.offsetStore = new RelayOffsetStore(options.stateDir);
-        this.fetchImpl = (_a = options.fetchImpl) !== null && _a !== void 0 ? _a : fetch;
+        this.fetchImpl = options.fetchImpl ?? fetch;
         this.deploymentGeneration = resolveAgentServeDeploymentGeneration(options.deploymentGeneration);
     }
     start() {
@@ -137,19 +122,16 @@ export class CursorRelayCore {
      * registration succeeded — anchoring "now" while unsubscribed would
      * silently miss every delivery in between.
      */
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            yield this.resolveConsumerId();
-            const registered = yield this.registerUntilSuccess();
-            if (!registered)
-                return;
-            this.registerTimer = setInterval(() => {
-                this.heartbeatPromise = this.registerOnce();
-            }, DEFAULT_REGISTER_INTERVAL_MS);
-            (_b = (_a = this.registerTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
-            yield this.consumeLoop();
-        });
+    async run() {
+        await this.resolveConsumerId();
+        const registered = await this.registerUntilSuccess();
+        if (!registered)
+            return;
+        this.registerTimer = setInterval(() => {
+            this.heartbeatPromise = this.registerOnce();
+        }, DEFAULT_REGISTER_INTERVAL_MS);
+        this.registerTimer.unref?.();
+        await this.consumeLoop();
     }
     /**
      * Durable consumer identity for this state root (memoized), so this host's
@@ -157,63 +139,57 @@ export class CursorRelayCore {
      * survive restarts. Public so callers can bind transports with it before
      * `start()` (the Slack relay proxies outbound calls under this id).
      */
-    resolveConsumerId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.consumerId !== "") {
-                return this.consumerId;
-            }
-            const filePath = join(this.options.stateDir, "consumer-id");
-            try {
-                const existing = (yield readFile(filePath, "utf8")).trim();
-                if (CONSUMER_ID_PATTERN.test(existing)) {
-                    this.consumerId = existing;
-                    return existing;
-                }
-            }
-            catch (_a) {
-                // Missing or unreadable: mint below.
-            }
-            const minted = randomUUID();
-            try {
-                yield mkdir(this.options.stateDir, { recursive: true });
-                const tmpPath = `${filePath}.tmp`;
-                yield writeFile(tmpPath, `${minted}\n`, "utf8");
-                yield rename(tmpPath, filePath);
-            }
-            catch (error) {
-                this.log(`could not persist consumer id (${describeRelayError(error)}); using an ephemeral one for this run`);
+    async resolveConsumerId() {
+        if (this.consumerId !== "") {
+            return this.consumerId;
+        }
+        const filePath = join(this.options.stateDir, "consumer-id");
+        try {
+            const existing = (await readFile(filePath, "utf8")).trim();
+            if (CONSUMER_ID_PATTERN.test(existing)) {
+                this.consumerId = existing;
+                return existing;
             }
-            this.consumerId = minted;
-            return minted;
-        });
+        }
+        catch {
+            // Missing or unreadable: mint below.
+        }
+        const minted = randomUUID();
+        try {
+            await mkdir(this.options.stateDir, { recursive: true });
+            const tmpPath = `${filePath}.tmp`;
+            await writeFile(tmpPath, `${minted}\n`, "utf8");
+            await rename(tmpPath, filePath);
+        }
+        catch (error) {
+            this.log(`could not persist consumer id (${describeRelayError(error)}); using an ephemeral one for this run`);
+        }
+        this.consumerId = minted;
+        return minted;
     }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            if (!this.running)
-                return;
-            this.running = false;
-            if (this.registerTimer !== undefined) {
-                clearInterval(this.registerTimer);
-                this.registerTimer = undefined;
-            }
-            (_a = this.abort) === null || _a === void 0 ? void 0 : _a.abort();
-            // Bounded wait: server close must never hang on a poll that ignores the
-            // abort (offsets are saved as events are processed, so cutting the loop
-            // loose loses nothing).
-            yield Promise.race([
-                (_b = this.consumePromise) === null || _b === void 0 ? void 0 : _b.catch(() => { }),
-                new Promise(resolve => {
-                    var _a;
-                    const timer = setTimeout(resolve, 2000);
-                    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
-                }),
-            ]);
-            // A heartbeat re-registration may be in flight (its fetch was just
-            // aborted); let it settle so it cannot land after the deregistration.
-            yield (_c = this.heartbeatPromise) === null || _c === void 0 ? void 0 : _c.catch(() => { });
-            yield this.deregister();
-        });
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.registerTimer !== undefined) {
+            clearInterval(this.registerTimer);
+            this.registerTimer = undefined;
+        }
+        this.abort?.abort();
+        // Bounded wait: server close must never hang on a poll that ignores the
+        // abort (offsets are saved as events are processed, so cutting the loop
+        // loose loses nothing).
+        await Promise.race([
+            this.consumePromise?.catch(() => { }),
+            new Promise(resolve => {
+                const timer = setTimeout(resolve, 2_000);
+                timer.unref?.();
+            }),
+        ]);
+        // A heartbeat re-registration may be in flight (its fetch was just
+        // aborted); let it settle so it cannot land after the deregistration.
+        await this.heartbeatPromise?.catch(() => { });
+        await this.deregister();
     }
     /**
      * Best-effort empty-scope PUT on clean stop, so this consumer's
@@ -222,102 +198,106 @@ export class CursorRelayCore {
      * live and makes name routing ambiguous for a redeployed sibling with a
      * fresh consumer id. Failures only log — the TTL still cleans up.
      */
-    deregister() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const adapter = this.options.adapter;
-            if (adapter.buildDeregistrationBody === undefined ||
-                !this.registeredOnce ||
-                this.consumerId === "") {
-                return;
-            }
-            const url = `${this.options.baseUrl.replace(/\/+$/, "")}${adapter.subscribePath}`;
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), DEREGISTER_TIMEOUT_MS);
-            (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
-            try {
-                const response = yield this.fetchImpl(url, {
-                    method: "PUT",
-                    headers: Object.assign({ authorization: `Bearer ${this.options.apiKey}`, "content-type": "application/json" }, (this.deploymentGeneration === undefined
+    async deregister() {
+        const adapter = this.options.adapter;
+        if (adapter.buildDeregistrationBody === undefined ||
+            !this.registeredOnce ||
+            this.consumerId === "") {
+            return;
+        }
+        const url = `${this.options.baseUrl.replace(/\/+$/, "")}${adapter.subscribePath}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), DEREGISTER_TIMEOUT_MS);
+        timer.unref?.();
+        try {
+            const response = await this.fetchImpl(url, {
+                method: "PUT",
+                headers: {
+                    authorization: `Bearer ${this.options.apiKey}`,
+                    "content-type": "application/json",
+                    ...(this.deploymentGeneration === undefined
                         ? {}
                         : {
                             [AGENT_SERVE_GENERATION_HEADER]: String(this.deploymentGeneration),
-                        })),
-                    body: JSON.stringify(adapter.buildDeregistrationBody(this.consumerId)),
-                    signal: controller.signal,
-                });
-                if (response.ok) {
-                    this.log("deregistered on shutdown");
-                }
-                else {
-                    this.log(`deregistration failed: ${response.status} (registration lapses by TTL)`);
-                }
-            }
-            catch (error) {
-                this.log(`deregistration failed: ${describeRelayError(error)} (registration lapses by TTL)`);
+                        }),
+                },
+                body: JSON.stringify(adapter.buildDeregistrationBody(this.consumerId)),
+                signal: controller.signal,
+            });
+            if (response.ok) {
+                this.log("deregistered on shutdown");
             }
-            finally {
-                clearTimeout(timer);
+            else {
+                this.log(`deregistration failed: ${response.status} (registration lapses by TTL)`);
             }
-        });
+        }
+        catch (error) {
+            this.log(`deregistration failed: ${describeRelayError(error)} (registration lapses by TTL)`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
     }
     log(line) {
         this.options.logger(`${LOG_PREFIX} ${this.options.adapter.logPrefix}: ${line}`);
     }
-    request(method, path, body) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = `${this.options.baseUrl.replace(/\/+$/, "")}${path}`;
-            return this.fetchImpl(url, Object.assign(Object.assign({ method, headers: Object.assign(Object.assign({ authorization: `Bearer ${this.options.apiKey}` }, (body === undefined ? {} : { "content-type": "application/json" })), (this.deploymentGeneration === undefined
+    async request(method, path, body) {
+        const url = `${this.options.baseUrl.replace(/\/+$/, "")}${path}`;
+        return this.fetchImpl(url, {
+            method,
+            headers: {
+                authorization: `Bearer ${this.options.apiKey}`,
+                ...(body === undefined ? {} : { "content-type": "application/json" }),
+                ...(this.deploymentGeneration === undefined
                     ? {}
                     : {
                         [AGENT_SERVE_GENERATION_HEADER]: String(this.deploymentGeneration),
-                    })) }, (body === undefined ? {} : { body: JSON.stringify(body) })), (this.abort === undefined ? {} : { signal: this.abort.signal })));
+                    }),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            ...(this.abort === undefined ? {} : { signal: this.abort.signal }),
         });
     }
     /** Retry registration with backoff until it succeeds or the relay stops. */
-    registerUntilSuccess() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let backoffMs = MIN_BACKOFF_MS;
-            while (this.running) {
-                if (yield this.registerOnce()) {
-                    return true;
-                }
-                yield this.sleep(backoffMs);
-                backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+    async registerUntilSuccess() {
+        let backoffMs = MIN_BACKOFF_MS;
+        while (this.running) {
+            if (await this.registerOnce()) {
+                return true;
             }
-            return false;
-        });
+            await this.sleep(backoffMs);
+            backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+        }
+        return false;
     }
     /**
      * Register (or refresh) via the adapter. Returns true when the server
      * accepted the registration (individual scopes may still have failed
      * validation — the adapter logs those).
      */
-    registerOnce() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.running)
+    async registerOnce() {
+        if (!this.running)
+            return false;
+        try {
+            const response = await this.request("PUT", this.options.adapter.subscribePath, this.options.adapter.buildRegistrationBody(this.consumerId));
+            if (!response.ok) {
+                const text = await response.text().catch(() => "");
+                this.logRegistrationOutcome([
+                    `registration failed: ${response.status} ${text.slice(0, 300)}`,
+                ]);
                 return false;
-            try {
-                const response = yield this.request("PUT", this.options.adapter.subscribePath, this.options.adapter.buildRegistrationBody(this.consumerId));
-                if (!response.ok) {
-                    const text = yield response.text().catch(() => "");
-                    this.logRegistrationOutcome([
-                        `registration failed: ${response.status} ${text.slice(0, 300)}`,
-                    ]);
-                    return false;
-                }
-                const json = (yield response.json());
-                this.logRegistrationOutcome(this.options.adapter.applyRegistrationResponse(json));
-                this.registeredOnce = true;
-                return true;
             }
-            catch (error) {
-                if (this.isAbort(error))
-                    return false;
-                this.logRegistrationOutcome([`registration error: ${describeRelayError(error)}`]);
+            const json = (await response.json());
+            this.logRegistrationOutcome(this.options.adapter.applyRegistrationResponse(json));
+            this.registeredOnce = true;
+            return true;
+        }
+        catch (error) {
+            if (this.isAbort(error))
                 return false;
-            }
-        });
+            this.logRegistrationOutcome([`registration error: ${describeRelayError(error)}`]);
+            return false;
+        }
     }
     /** Log registration outcome lines only when they change (heartbeat-quiet). */
     logRegistrationOutcome(lines) {
@@ -329,80 +309,77 @@ export class CursorRelayCore {
             this.log(line);
         }
     }
-    consumeLoop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            let backoffMs = MIN_BACKOFF_MS;
-            let offset = yield this.offsetStore.load();
-            let announcedGap = false;
-            while (this.running) {
-                try {
-                    if (offset === undefined) {
-                        // First run: anchor at "now" so the agent does not replay (and
-                        // react to) the retained backlog of old events.
-                        const anchorResponse = yield this.request("GET", `${this.options.adapter.pollPath}?after=%24&limit=1`);
-                        if (!anchorResponse.ok) {
-                            backoffMs = yield this.backoffAfterHttpFailure(anchorResponse, backoffMs);
-                            continue;
-                        }
-                        const anchor = (yield anchorResponse.json());
-                        offset = anchor.nextOffset;
-                        yield this.offsetStore.save(offset);
-                        this.log(`anchored at offset "${offset}"`);
-                        backoffMs = MIN_BACKOFF_MS;
-                        continue;
-                    }
-                    const query = new URLSearchParams({
-                        after: offset,
-                        limit: String(DEFAULT_POLL_LIMIT),
-                        waitMs: String((_a = this.options.pollWaitMs) !== null && _a !== void 0 ? _a : DEFAULT_POLL_WAIT_MS),
-                    });
-                    const response = yield this.request("GET", `${this.options.adapter.pollPath}?${query.toString()}`);
-                    if (!response.ok) {
-                        backoffMs = yield this.backoffAfterHttpFailure(response, backoffMs);
+    async consumeLoop() {
+        let backoffMs = MIN_BACKOFF_MS;
+        let offset = await this.offsetStore.load();
+        let announcedGap = false;
+        while (this.running) {
+            try {
+                if (offset === undefined) {
+                    // First run: anchor at "now" so the agent does not replay (and
+                    // react to) the retained backlog of old events.
+                    const anchorResponse = await this.request("GET", `${this.options.adapter.pollPath}?after=%24&limit=1`);
+                    if (!anchorResponse.ok) {
+                        backoffMs = await this.backoffAfterHttpFailure(anchorResponse, backoffMs);
                         continue;
                     }
-                    const poll = (yield response.json());
+                    const anchor = (await anchorResponse.json());
+                    offset = anchor.nextOffset;
+                    await this.offsetStore.save(offset);
+                    this.log(`anchored at offset "${offset}"`);
                     backoffMs = MIN_BACKOFF_MS;
-                    if (poll.gapDetected && !announcedGap) {
-                        announcedGap = true;
-                        this.log("gap detected: events may have been trimmed while this host was offline; resuming from the oldest retained event");
-                    }
-                    if (poll.events.length > 0) {
-                        announcedGap = false;
-                    }
-                    for (const event of poll.events) {
-                        if (!this.running)
-                            break;
-                        // At-least-once dedupe: never re-dispatch at or before the last
-                        // processed offset (reads are exclusive-after, so this only fires
-                        // on replay after a crash between dispatch and save).
-                        if (compareStreamOffsets(event.offset, offset) <= 0)
-                            continue;
-                        if (this.options.adapter.shouldDispatch(event)) {
-                            yield this.dispatchWithRetry(event);
-                        }
-                        offset = event.offset;
-                    }
-                    if (poll.nextOffset !== "" && compareStreamOffsets(poll.nextOffset, offset) > 0) {
-                        offset = poll.nextOffset;
-                    }
-                    if (poll.events.length > 0) {
-                        yield this.offsetStore.save(offset);
-                    }
-                    else {
-                        yield this.sleep(DEFAULT_IDLE_POLL_DELAY_MS);
+                    continue;
+                }
+                const query = new URLSearchParams({
+                    after: offset,
+                    limit: String(DEFAULT_POLL_LIMIT),
+                    waitMs: String(this.options.pollWaitMs ?? DEFAULT_POLL_WAIT_MS),
+                });
+                const response = await this.request("GET", `${this.options.adapter.pollPath}?${query.toString()}`);
+                if (!response.ok) {
+                    backoffMs = await this.backoffAfterHttpFailure(response, backoffMs);
+                    continue;
+                }
+                const poll = (await response.json());
+                backoffMs = MIN_BACKOFF_MS;
+                if (poll.gapDetected && !announcedGap) {
+                    announcedGap = true;
+                    this.log("gap detected: events may have been trimmed while this host was offline; resuming from the oldest retained event");
+                }
+                if (poll.events.length > 0) {
+                    announcedGap = false;
+                }
+                for (const event of poll.events) {
+                    if (!this.running)
+                        break;
+                    // At-least-once dedupe: never re-dispatch at or before the last
+                    // processed offset (reads are exclusive-after, so this only fires
+                    // on replay after a crash between dispatch and save).
+                    if (compareStreamOffsets(event.offset, offset) <= 0)
+                        continue;
+                    if (this.options.adapter.shouldDispatch(event)) {
+                        await this.dispatchWithRetry(event);
                     }
+                    offset = event.offset;
                 }
-                catch (error) {
-                    if (this.isAbort(error))
-                        return;
-                    this.log(`poll error: ${describeRelayError(error)}`);
-                    yield this.sleep(backoffMs);
-                    backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+                if (poll.nextOffset !== "" && compareStreamOffsets(poll.nextOffset, offset) > 0) {
+                    offset = poll.nextOffset;
+                }
+                if (poll.events.length > 0) {
+                    await this.offsetStore.save(offset);
+                }
+                else {
+                    await this.sleep(DEFAULT_IDLE_POLL_DELAY_MS);
                 }
             }
-        });
+            catch (error) {
+                if (this.isAbort(error))
+                    return;
+                this.log(`poll error: ${describeRelayError(error)}`);
+                await this.sleep(backoffMs);
+                backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+            }
+        }
     }
     /**
      * Dispatch one event with a small bounded retry before the offset advances
@@ -411,57 +388,52 @@ export class CursorRelayCore {
      * only costs {@link DISPATCH_ATTEMPTS} tries and is then skipped, keeping
      * at-least-once semantics without a retry loop.
      */
-    dispatchWithRetry(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let attempt = 1; attempt <= DISPATCH_ATTEMPTS; attempt++) {
-                if (attempt > 1 && !this.running) {
-                    this.log(`dispatch abandoned at offset ${event.offset}: relay stopping`);
-                    return;
-                }
-                try {
-                    yield this.options.adapter.dispatch(event);
+    async dispatchWithRetry(event) {
+        for (let attempt = 1; attempt <= DISPATCH_ATTEMPTS; attempt++) {
+            if (attempt > 1 && !this.running) {
+                this.log(`dispatch abandoned at offset ${event.offset}: relay stopping`);
+                return;
+            }
+            try {
+                await this.options.adapter.dispatch(event);
+                return;
+            }
+            catch (error) {
+                if (attempt === DISPATCH_ATTEMPTS) {
+                    this.log(`dispatch failed at offset ${event.offset} after ${attempt} attempts: ${describeRelayError(error)}`);
                     return;
                 }
-                catch (error) {
-                    if (attempt === DISPATCH_ATTEMPTS) {
-                        this.log(`dispatch failed at offset ${event.offset} after ${attempt} attempts: ${describeRelayError(error)}`);
-                        return;
-                    }
-                    this.log(`dispatch attempt ${attempt} failed at offset ${event.offset}: ${describeRelayError(error)}; retrying`);
-                    yield this.sleep(DISPATCH_RETRY_DELAYS_MS[Math.min(attempt - 1, DISPATCH_RETRY_DELAYS_MS.length - 1)]);
-                }
+                this.log(`dispatch attempt ${attempt} failed at offset ${event.offset}: ${describeRelayError(error)}; retrying`);
+                await this.sleep(DISPATCH_RETRY_DELAYS_MS[Math.min(attempt - 1, DISPATCH_RETRY_DELAYS_MS.length - 1)]);
             }
-        });
+        }
     }
     /** Log the failure, sleep, and return the backoff for the NEXT failure. */
-    backoffAfterHttpFailure(response, backoffMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 409 = generation fence (stale resident after redeploy). Same long
-            // backoff as auth: retrying every second cannot heal a wrong generation.
-            const isAuthOrFenceFailure = response.status === 401 || response.status === 403 || response.status === 409;
-            const sleepMs = isAuthOrFenceFailure ? AUTH_FAILURE_BACKOFF_MS : backoffMs;
-            const text = yield response.text().catch(() => "");
-            this.log(`poll failed: ${response.status} ${text.slice(0, 300)} (retrying in ${Math.round(sleepMs / 1000)}s)`);
-            yield this.sleep(sleepMs);
-            return isAuthOrFenceFailure ? AUTH_FAILURE_BACKOFF_MS : Math.min(backoffMs * 2, MAX_BACKOFF_MS);
-        });
+    async backoffAfterHttpFailure(response, backoffMs) {
+        // 409 = generation fence (stale resident after redeploy). Same long
+        // backoff as auth: retrying every second cannot heal a wrong generation.
+        const isAuthOrFenceFailure = response.status === 401 || response.status === 403 || response.status === 409;
+        const sleepMs = isAuthOrFenceFailure ? AUTH_FAILURE_BACKOFF_MS : backoffMs;
+        const text = await response.text().catch(() => "");
+        this.log(`poll failed: ${response.status} ${text.slice(0, 300)} (retrying in ${Math.round(sleepMs / 1000)}s)`);
+        await this.sleep(sleepMs);
+        return isAuthOrFenceFailure ? AUTH_FAILURE_BACKOFF_MS : Math.min(backoffMs * 2, MAX_BACKOFF_MS);
     }
     sleep(ms) {
         return new Promise(resolve => {
-            var _a, _b;
-            const signal = (_a = this.abort) === null || _a === void 0 ? void 0 : _a.signal;
-            if ((signal === null || signal === void 0 ? void 0 : signal.aborted) === true) {
+            const signal = this.abort?.signal;
+            if (signal?.aborted === true) {
                 resolve();
                 return;
             }
             const finish = () => {
                 clearTimeout(timer);
-                signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", finish);
+                signal?.removeEventListener("abort", finish);
                 resolve();
             };
             const timer = setTimeout(finish, ms);
-            (_b = timer.unref) === null || _b === void 0 ? void 0 : _b.call(timer);
-            signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", finish, { once: true });
+            timer.unref?.();
+            signal?.addEventListener("abort", finish, { once: true });
         });
     }
     isAbort(error) {