@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/storage-coordinator.js

@@ -19,15 +19,6 @@
  * per agent, and splitting it would change backpressure behavior, which this
  * seam deliberately does not touch.
  */
-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 { resolveStoragePolicy, storageKeys, } from "../storage.js";
 import { isCursorHostedStorage } from "../storage-backends/cursor-hosted.js";
 import { describeError } from "./describe-error.js";
@@ -52,16 +43,16 @@ const TERMINAL_SESSION_EVENTS = new Set([
  * At-most-once delivery already tolerates loss; bounding the queue keeps a
  * slow sink from growing memory without limit under sustained traffic.
  */
-const MAX_PENDING_OPS = 1000;
+const MAX_PENDING_OPS = 1_000;
 /**
  * How long {@link StorageCoordinator.close} waits for the sink to
  * drain before giving up. Keeps a hung sink within the shutdown budget.
  */
-const CLOSE_DRAIN_TIMEOUT_MS = 10000;
+const CLOSE_DRAIN_TIMEOUT_MS = 10_000;
 /** Debounced event batching flushes early past this many buffered events. */
 const DEBOUNCE_MAX_BATCH = 200;
 /** Cap on the per-session acked-record dedupe cache (oldest-out). */
-const MAX_ACKED_RECORDS = 5000;
+const MAX_ACKED_RECORDS = 5_000;
 /**
  * Cap on consecutive record rewrites skipped because only volatile
  * bookkeeping changed. Bounds how stale the durable copy's `turnCount` /
@@ -78,7 +69,7 @@ export const MAX_VOLATILE_RECORD_SKIPS = 20;
  * metadata) would lag.
  */
 function resumeProjectionJson(record) {
-    return JSON.stringify(Object.assign(Object.assign({}, record), { turnCount: 0, updatedAt: "" }));
+    return JSON.stringify({ ...record, turnCount: 0, updatedAt: "" });
 }
 /** Session records out of raw sink entries; rows without a usable id are dropped. */
 function sessionRecordsOf(entries) {
@@ -88,7 +79,6 @@ function sessionRecordsOf(entries) {
 }
 export class StorageCoordinator {
     constructor(options) {
-        var _a;
         /** Per-session pending state (events + coalesced record). */
         this.buffers = new Map();
         /**
@@ -119,7 +109,7 @@ export class StorageCoordinator {
         this.dropped = 0;
         this.closed = false;
         this.definition = options.definition;
-        this.keys = (_a = options.keys) !== null && _a !== void 0 ? _a : storageKeys;
+        this.keys = options.keys ?? storageKeys;
         this.policy = resolveStoragePolicy(options.definition.policy);
         this.agentName = options.agentName;
         this.projectRoot = options.projectRoot;
@@ -183,26 +173,26 @@ export class StorageCoordinator {
         this.flushSessionInternal(sessionId, "policy", true);
     }
     flushSessionInternal(sessionId, reason, exactRecord) {
-        var _a, _b;
         const buffer = this.buffers.get(sessionId);
         const acked = this.lastAckedRecord.get(sessionId);
-        if (buffer === undefined && !(exactRecord && (acked === null || acked === void 0 ? void 0 : acked.skippedJson) !== undefined)) {
+        if (buffer === undefined && !(exactRecord && acked?.skippedJson !== undefined)) {
             return;
         }
         this.buffers.delete(sessionId);
-        if ((buffer === null || buffer === void 0 ? void 0 : buffer.debounceTimer) !== undefined) {
+        if (buffer?.debounceTimer !== undefined) {
             clearTimeout(buffer.debounceTimer);
         }
-        const events = (_a = buffer === null || buffer === void 0 ? void 0 : buffer.events) !== null && _a !== void 0 ? _a : [];
+        const events = buffer?.events ?? [];
         // A terminal event can arrive through a debounce-policy timer flush,
         // where eventDispatched never ran: detect it from the buffered events
         // so a finished session's record is exact under either policy.
         const exact = exactRecord || events.some(event => TERMINAL_SESSION_EVENTS.has(event.type));
         // Exact flushes repair earlier volatile-only skips: when the buffer no
         // longer holds a record, the newest skipped one still gets written.
-        const record = (_b = buffer === null || buffer === void 0 ? void 0 : buffer.record) !== null && _b !== void 0 ? _b : (exact && (acked === null || acked === void 0 ? void 0 : acked.skippedJson) !== undefined
-            ? JSON.parse(acked.skippedJson)
-            : undefined);
+        const record = buffer?.record ??
+            (exact && acked?.skippedJson !== undefined
+                ? JSON.parse(acked.skippedJson)
+                : undefined);
         const ops = [];
         const puts = [];
         const first = events[0];
@@ -217,7 +207,7 @@ export class StorageCoordinator {
         if (record !== undefined) {
             const recordJson = JSON.stringify(record);
             const projection = resumeProjectionJson(record);
-            if ((acked === null || acked === void 0 ? void 0 : acked.json) === recordJson) {
+            if (acked?.json === recordJson) {
                 // Byte-identical to the last acknowledged write: rewriting it buys
                 // nothing. Events and continuation index still flush normally.
             }
@@ -258,7 +248,6 @@ export class StorageCoordinator {
      * logged and dropped (at-most-once), never failing batch siblings.
      */
     putsOp(puts, recordAck) {
-        var _a;
         const recordKey = recordAck === undefined ? undefined : this.keys.session(this.agentName, recordAck.sessionId);
         const settleRecord = (failed) => {
             if (recordAck === undefined) {
@@ -280,12 +269,12 @@ export class StorageCoordinator {
                 skips: 0,
             });
         };
-        const putMany = (_a = this.definition.putMany) === null || _a === void 0 ? void 0 : _a.bind(this.definition);
+        const putMany = this.definition.putMany?.bind(this.definition);
         if (putMany !== undefined) {
             return {
                 label: `putMany(${puts.map(entry => entry.key).join(", ")})`,
-                run: (ctx) => __awaiter(this, void 0, void 0, function* () {
-                    const results = yield putMany(puts, ctx);
+                run: async (ctx) => {
+                    const results = await putMany(puts, ctx);
                     let recordFailed = false;
                     for (const result of results) {
                         if (result.error === undefined) {
@@ -297,16 +286,16 @@ export class StorageCoordinator {
                         this.logger(`[bdk] storage put(${result.key}) failed: ${describeError(result.error)}`);
                     }
                     settleRecord(recordFailed);
-                }),
+                },
             };
         }
         return {
             label: `put(${puts.map(entry => entry.key).join(", ")})`,
-            run: (ctx) => __awaiter(this, void 0, void 0, function* () {
+            run: async (ctx) => {
                 let recordFailed = false;
                 for (const entry of puts) {
                     try {
-                        yield this.definition.put(entry.key, entry.value, ctx);
+                        await this.definition.put(entry.key, entry.value, ctx);
                     }
                     catch (error) {
                         if (entry.key === recordKey) {
@@ -316,7 +305,7 @@ export class StorageCoordinator {
                     }
                 }
                 settleRecord(recordFailed);
-            }),
+            },
         };
     }
     /**
@@ -352,7 +341,7 @@ export class StorageCoordinator {
     deleteOp(key) {
         return {
             label: `delete(${key})`,
-            run: ctx => { var _a, _b; return (_b = (_a = this.definition).delete) === null || _b === void 0 ? void 0 : _b.call(_a, key, ctx); },
+            run: ctx => this.definition.delete?.(key, ctx),
         };
     }
     // ==========================================================================
@@ -374,31 +363,27 @@ export class StorageCoordinator {
      * logged and read as "nothing saved" — a broken store must never block
      * serve start.
      */
-    listSessions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entries = yield this.tryList(this.keys.sessionPrefix(this.agentName));
-            return entries
-                .map(entry => entry.value)
-                .filter(record => record != null);
-        });
+    async listSessions() {
+        const entries = await this.tryList(this.keys.sessionPrefix(this.agentName));
+        return entries
+            .map(entry => entry.value)
+            .filter(record => record != null);
     }
     /**
      * Session records from the sink for the sessions API. Unlike
      * {@link listSessions}, missing `list` or a thrown sink error **propagates**
      * so the caller can fall back to the local session store.
      */
-    listSessionsFromSink() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const list = this.definition.list;
-            if (list === undefined) {
-                throw new Error("storage sink has no list");
-            }
-            const entries = yield list(this.keys.sessionPrefix(this.agentName), this.context("restore"));
-            if (!Array.isArray(entries)) {
-                throw new Error("storage list returned a non-array");
-            }
-            return sessionRecordsOf(entries);
-        });
+    async listSessionsFromSink() {
+        const list = this.definition.list;
+        if (list === undefined) {
+            throw new Error("storage sink has no list");
+        }
+        const entries = await list(this.keys.sessionPrefix(this.agentName), this.context("restore"));
+        if (!Array.isArray(entries)) {
+            throw new Error("storage list returned a non-array");
+        }
+        return sessionRecordsOf(entries);
     }
     /**
      * Newest-written session records from the sink (`GET /v1/sessions?latest=1`
@@ -406,35 +391,31 @@ export class StorageCoordinator {
      * posture as {@link listSessionsFromSink}; `undefined` when the sink
      * cannot order by write time, so the caller falls back to the full list.
      */
-    listNewestSessionsFromSink(limit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const listNewest = this.definition.listNewest;
-            if (listNewest === undefined) {
-                return undefined;
-            }
-            const entries = yield listNewest(this.keys.sessionPrefix(this.agentName), limit, this.context("restore"));
-            if (!Array.isArray(entries)) {
-                throw new Error("storage listNewest returned a non-array");
-            }
-            return sessionRecordsOf(entries);
-        });
+    async listNewestSessionsFromSink(limit) {
+        const listNewest = this.definition.listNewest;
+        if (listNewest === undefined) {
+            return undefined;
+        }
+        const entries = await listNewest(this.keys.sessionPrefix(this.agentName), limit, this.context("restore"));
+        if (!Array.isArray(entries)) {
+            throw new Error("storage listNewest returned a non-array");
+        }
+        return sessionRecordsOf(entries);
     }
     /**
      * Saved event stream for one session: chunk values concatenated in key
      * order (chunks are keyed by their first event's index, zero-padded, so
      * ascending key order is append order). Errors read as an empty stream.
      */
-    listSessionEvents(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entries = yield this.tryList(this.keys.sessionEventsPrefix(this.agentName, sessionId));
-            const events = [];
-            for (const entry of entries) {
-                if (Array.isArray(entry.value)) {
-                    events.push(...entry.value);
-                }
+    async listSessionEvents(sessionId) {
+        const entries = await this.tryList(this.keys.sessionEventsPrefix(this.agentName, sessionId));
+        const events = [];
+        for (const entry of entries) {
+            if (Array.isArray(entry.value)) {
+                events.push(...entry.value);
             }
-            return events;
-        });
+        }
+        return events;
     }
     /**
      * One saved session by id (lazy restore for playground Open-trace /
@@ -442,25 +423,23 @@ export class StorageCoordinator {
      * — same posture as {@link getSessionByContinuation}. A definitive miss
      * (no row, or a write-only sink without `get`) resolves undefined.
      */
-    getSessionById(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const get = this.definition.get;
-            if (get === undefined) {
-                return undefined;
-            }
-            if (typeof sessionId !== "string" || sessionId === "") {
-                return undefined;
-            }
-            const ctx = this.context("restore");
-            const record = (yield get(this.keys.session(this.agentName, sessionId), ctx));
-            if (record == null) {
-                return undefined;
-            }
-            if (record.sessionId !== sessionId) {
-                throw new Error(`storage returned a session that does not match the requested id ${sessionId}`);
-            }
-            return record;
-        });
+    async getSessionById(sessionId) {
+        const get = this.definition.get;
+        if (get === undefined) {
+            return undefined;
+        }
+        if (typeof sessionId !== "string" || sessionId === "") {
+            return undefined;
+        }
+        const ctx = this.context("restore");
+        const record = (await get(this.keys.session(this.agentName, sessionId), ctx));
+        if (record == null) {
+            return undefined;
+        }
+        if (record.sessionId !== sessionId) {
+            throw new Error(`storage returned a session that does not match the requested id ${sessionId}`);
+        }
+        return record;
     }
     /**
      * One saved session by channel continuation key (lazy restore). Unlike
@@ -471,37 +450,35 @@ export class StorageCoordinator {
      * A definitive miss (no index entry, or a write-only sink without
      * `get`) resolves undefined.
      */
-    getSessionByContinuation(channelId, continuationKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const get = this.definition.get;
-            if (get === undefined) {
-                return undefined;
-            }
-            const ctx = this.context("restore");
-            const pointer = yield get(this.keys.continuation(this.agentName, channelId, continuationKey), ctx);
-            if (pointer == null) {
-                return undefined;
-            }
-            const sessionId = typeof pointer === "object" && !Array.isArray(pointer) ? pointer.sessionId : undefined;
-            if (typeof sessionId !== "string" || sessionId === "") {
-                throw new Error(`storage returned a malformed continuation entry for channel ${channelId}`);
-            }
-            const record = yield this.getSessionById(sessionId);
-            if (record === undefined) {
-                // Index entry without its record (e.g. the record write was shed
-                // under at-most-once). The session is unrecoverable; treat as a miss
-                // so the conversation can continue rather than failing forever.
-                this.logger(`[bdk] storage continuation entry points at missing session ${sessionId}; treating as a miss`);
-                return undefined;
-            }
-            // The sink must answer for the exact key it was asked about — a
-            // mismatched row is a broken store, not a miss; treating it as a miss
-            // would fork the continuation token onto a new session.
-            if (record.channelId !== channelId || record.continuationKey !== continuationKey) {
-                throw new Error(`storage returned a session that does not match the requested continuation (channel ${channelId})`);
-            }
-            return record;
-        });
+    async getSessionByContinuation(channelId, continuationKey) {
+        const get = this.definition.get;
+        if (get === undefined) {
+            return undefined;
+        }
+        const ctx = this.context("restore");
+        const pointer = await get(this.keys.continuation(this.agentName, channelId, continuationKey), ctx);
+        if (pointer == null) {
+            return undefined;
+        }
+        const sessionId = typeof pointer === "object" && !Array.isArray(pointer) ? pointer.sessionId : undefined;
+        if (typeof sessionId !== "string" || sessionId === "") {
+            throw new Error(`storage returned a malformed continuation entry for channel ${channelId}`);
+        }
+        const record = await this.getSessionById(sessionId);
+        if (record === undefined) {
+            // Index entry without its record (e.g. the record write was shed
+            // under at-most-once). The session is unrecoverable; treat as a miss
+            // so the conversation can continue rather than failing forever.
+            this.logger(`[bdk] storage continuation entry points at missing session ${sessionId}; treating as a miss`);
+            return undefined;
+        }
+        // The sink must answer for the exact key it was asked about — a
+        // mismatched row is a broken store, not a miss; treating it as a miss
+        // would fork the continuation token onto a new session.
+        if (record.channelId !== channelId || record.continuationKey !== continuationKey) {
+            throw new Error(`storage returned a session that does not match the requested continuation (channel ${channelId})`);
+        }
+        return record;
     }
     // ==========================================================================
     // Author KV ({@link HostContext.kv})
@@ -517,34 +494,27 @@ export class StorageCoordinator {
      * Awaited author KV read. Unlike framework session mirrors, this awaits
      * the sink and propagates errors — handlers need read-after-write.
      */
-    kvGet(authorKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const get = this.definition.get;
-            if (get === undefined) {
-                throw new Error("storage get is not configured");
-            }
-            const key = this.keys.kv(this.agentName, authorKey);
-            // Preserve stored JSON `null` (distinct from a missing key).
-            return yield get(key, this.context("restore"));
-        });
+    async kvGet(authorKey) {
+        const get = this.definition.get;
+        if (get === undefined) {
+            throw new Error("storage get is not configured");
+        }
+        const key = this.keys.kv(this.agentName, authorKey);
+        // Preserve stored JSON `null` (distinct from a missing key).
+        return await get(key, this.context("restore"));
     }
     /**
      * Awaited author KV write. Goes straight to the sink (not the
      * at-most-once delivery queue) so callers observe durable success/failure.
      */
-    kvPut(authorKey, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = this.keys.kv(this.agentName, authorKey);
-            yield this.definition.put(key, value, this.context("policy"));
-        });
+    async kvPut(authorKey, value) {
+        const key = this.keys.kv(this.agentName, authorKey);
+        await this.definition.put(key, value, this.context("policy"));
     }
     /** Awaited author KV delete. No-op when the sink omits `delete`. */
-    kvDelete(authorKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const key = this.keys.kv(this.agentName, authorKey);
-            yield (_b = (_a = this.definition).delete) === null || _b === void 0 ? void 0 : _b.call(_a, key, this.context("policy"));
-        });
+    async kvDelete(authorKey) {
+        const key = this.keys.kv(this.agentName, authorKey);
+        await this.definition.delete?.(key, this.context("policy"));
     }
     // ==========================================================================
     // Evals (dedicated `evals` table)
@@ -579,16 +549,16 @@ export class StorageCoordinator {
                     },
                 ], "policy");
             },
-            list: () => __awaiter(this, void 0, void 0, function* () {
+            list: async () => {
                 try {
-                    const runs = yield table.list(this.context("restore"));
+                    const runs = await table.list(this.context("restore"));
                     return Array.isArray(runs) ? runs : [];
                 }
                 catch (error) {
                     this.logger(`[bdk] storage evals.list() failed: ${describeError(error)}`);
                     return [];
                 }
-            }),
+            },
         };
     }
     // ==========================================================================
@@ -598,36 +568,33 @@ export class StorageCoordinator {
      * Flush all buffers and drain the queue, giving the sink at most
      * {@link CLOSE_DRAIN_TIMEOUT_MS}. Called from engine close.
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.closed) {
-                for (const sessionId of [...this.buffers.keys()]) {
-                    this.flushSession(sessionId, "shutdown");
-                }
-                // Sessions whose newest record was only ever skipped (volatile-only
-                // turns) have no buffer left; drain their stashed records too so a
-                // graceful shutdown leaves exact bookkeeping behind.
-                for (const [sessionId, acked] of this.lastAckedRecord) {
-                    if (acked.skippedJson !== undefined) {
-                        this.flushSessionInternal(sessionId, "shutdown", true);
-                    }
-                }
-                this.closed = true;
+    async close() {
+        if (!this.closed) {
+            for (const sessionId of [...this.buffers.keys()]) {
+                this.flushSession(sessionId, "shutdown");
             }
-            let timer;
-            const drained = yield Promise.race([
-                this.queue.then(() => true),
-                new Promise(resolve => {
-                    var _a;
-                    timer = setTimeout(() => resolve(false), CLOSE_DRAIN_TIMEOUT_MS);
-                    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
-                }),
-            ]);
-            clearTimeout(timer);
-            if (!drained) {
-                this.logger(`[bdk] storage shutdown drain timed out after ${CLOSE_DRAIN_TIMEOUT_MS}ms with ${this.pending} write(s) undelivered`);
+            // Sessions whose newest record was only ever skipped (volatile-only
+            // turns) have no buffer left; drain their stashed records too so a
+            // graceful shutdown leaves exact bookkeeping behind.
+            for (const [sessionId, acked] of this.lastAckedRecord) {
+                if (acked.skippedJson !== undefined) {
+                    this.flushSessionInternal(sessionId, "shutdown", true);
+                }
             }
-        });
+            this.closed = true;
+        }
+        let timer;
+        const drained = await Promise.race([
+            this.queue.then(() => true),
+            new Promise(resolve => {
+                timer = setTimeout(() => resolve(false), CLOSE_DRAIN_TIMEOUT_MS);
+                timer.unref?.();
+            }),
+        ]);
+        clearTimeout(timer);
+        if (!drained) {
+            this.logger(`[bdk] storage shutdown drain timed out after ${CLOSE_DRAIN_TIMEOUT_MS}ms with ${this.pending} write(s) undelivered`);
+        }
     }
     /** Pending deliveries (exposed for tests and drain instrumentation). */
     whenIdle() {
@@ -642,7 +609,6 @@ export class StorageCoordinator {
         return buffer;
     }
     armDebounce(sessionId, buffer, debounceMs) {
-        var _a, _b;
         if (buffer.debounceTimer !== undefined) {
             clearTimeout(buffer.debounceTimer);
         }
@@ -651,24 +617,22 @@ export class StorageCoordinator {
             this.flushSession(sessionId);
         }, debounceMs);
         // Never keep the process alive just for a pending storage flush.
-        (_b = (_a = buffer.debounceTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        buffer.debounceTimer.unref?.();
     }
     /** `list` wrapper for the startup reads: missing hook or throw ⇒ empty. */
-    tryList(prefix) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const list = this.definition.list;
-            if (list === undefined) {
-                return [];
-            }
-            try {
-                const entries = yield list(prefix, this.context("restore"));
-                return Array.isArray(entries) ? entries : [];
-            }
-            catch (error) {
-                this.logger(`[bdk] storage list(${prefix}) failed: ${describeError(error)}`);
-                return [];
-            }
-        });
+    async tryList(prefix) {
+        const list = this.definition.list;
+        if (list === undefined) {
+            return [];
+        }
+        try {
+            const entries = await list(prefix, this.context("restore"));
+            return Array.isArray(entries) ? entries : [];
+        }
+        catch (error) {
+            this.logger(`[bdk] storage list(${prefix}) failed: ${describeError(error)}`);
+            return [];
+        }
     }
     enqueue(ops, reason) {
         if (this.closed && reason !== "shutdown") {
@@ -676,17 +640,17 @@ export class StorageCoordinator {
         }
         if (this.pending + ops.length > MAX_PENDING_OPS) {
             this.dropped += ops.length;
-            if (this.dropped <= ops.length || this.dropped % 1000 < ops.length) {
+            if (this.dropped <= ops.length || this.dropped % 1_000 < ops.length) {
                 this.logger(`[bdk] storage queue full (${MAX_PENDING_OPS} pending writes); dropped ${this.dropped} write(s) so far — the sink is too slow for the traffic`);
             }
             return;
         }
         this.pending += ops.length;
         const ctx = this.context(reason);
-        this.queue = this.queue.then(() => __awaiter(this, void 0, void 0, function* () {
+        this.queue = this.queue.then(async () => {
             for (const op of ops) {
                 try {
-                    yield op.run(ctx);
+                    await op.run(ctx);
                 }
                 catch (error) {
                     this.logger(`[bdk] storage ${op.label} failed: ${describeError(error)}`);
@@ -695,7 +659,7 @@ export class StorageCoordinator {
                     this.pending -= 1;
                 }
             }
-        }));
+        });
     }
     context(reason) {
         return { agentName: this.agentName, projectRoot: this.projectRoot, reason };

package/dist/internal/store-mirror.js

@@ -3,15 +3,6 @@
  * skills, workspace seed, and session workspaceFile syncs so they keep the
  * same write-then-sweep discipline and the same path refusals.
  */
-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 { posix } from "node:path";
 import { FileConflictError } from "../files.js";
 /**
@@ -20,16 +11,13 @@ import { FileConflictError } from "../files.js";
  * Writes land before stale deletes, so a failed sync never leaves a gap a
  * concurrent cloud reader could see.
  */
-export function mirrorToStore(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        yield Promise.all([...args.desired].map(([key, body]) => putLastWriterWins(args.sink, key, body)));
-        const listed = yield Promise.all([args.prefix, ...((_a = args.legacyPrefixes) !== null && _a !== void 0 ? _a : [])].map(prefix => args.sink.list(prefix)));
-        yield Promise.all(listed
-            .flat()
-            .filter(entry => !args.desired.has(entry.key))
-            .map(entry => args.sink.delete(entry.key)));
-    });
+export async function mirrorToStore(args) {
+    await Promise.all([...args.desired].map(([key, body]) => putLastWriterWins(args.sink, key, body)));
+    const listed = await Promise.all([args.prefix, ...(args.legacyPrefixes ?? [])].map(prefix => args.sink.list(prefix)));
+    await Promise.all(listed
+        .flat()
+        .filter(entry => !args.desired.has(entry.key))
+        .map(entry => args.sink.delete(entry.key)));
 }
 /**
  * Same refusals as local materialization's `resolveInside`: a rel that
@@ -53,16 +41,14 @@ export function storeRelPath(relPath, what) {
  * Last writer wins. A raced conditional put clears the sink's cached etag,
  * so one retry re-learns the current version and lands.
  */
-function putLastWriterWins(sink, key, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield sink.put(key, body);
-        }
-        catch (error) {
-            if (!(error instanceof FileConflictError)) {
-                throw error;
-            }
-            yield sink.put(key, body);
+async function putLastWriterWins(sink, key, body) {
+    try {
+        await sink.put(key, body);
+    }
+    catch (error) {
+        if (!(error instanceof FileConflictError)) {
+            throw error;
         }
-    });
+        await sink.put(key, body);
+    }
 }