@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/artifacts-store.js

@@ -5,15 +5,6 @@
  * Cursor-managed hosting preserves artifacts across deployment replacement.
  * Self-hosted agents store them under `--state-root/artifacts`.
  */
-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 { createHash, randomUUID } from "node:crypto";
 import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -24,7 +15,7 @@ import { mapBounded } from "./bounded.js";
 /** Default {@link ArtifactPageOptions.limit}; also `GET /v1/artifacts`. */
 export const ARTIFACTS_PAGE_DEFAULT_LIMIT = 200;
 /** Ceiling for {@link ArtifactPageOptions.limit}; larger asks clamp. */
-export const ARTIFACTS_PAGE_MAX_LIMIT = 1000;
+export const ARTIFACTS_PAGE_MAX_LIMIT = 1_000;
 /**
  * Rows examined per `page()` call, floor. Filters live in row bodies, so a
  * sparse filter must hydrate rows just to reject them; this stops one call
@@ -62,10 +53,9 @@ export const ARTIFACT_DEFAULT_KIND = "artifact";
  */
 export class ArtifactsStore {
     constructor(options) {
-        var _a, _b;
         /** Serializes tags so read-modify-write upserts and eviction don't race. */
         this.tagChain = Promise.resolve();
-        const sink = (_a = options.sink) !== null && _a !== void 0 ? _a : (isCursorHostedFilesAvailable() ? cursorHostedFiles() : undefined);
+        const sink = options.sink ?? (isCursorHostedFilesAvailable() ? cursorHostedFiles() : undefined);
         if (sink === undefined) {
             this.rows = createFilesystemRowStore(options.stateRoot);
             this.content = createFilesystemContentStore(options.stateRoot);
@@ -76,57 +66,54 @@ export class ArtifactsStore {
         }
         this.config = options.config;
         this.max = resolveArtifactsMax(options.config);
-        this.enforceCap = (_b = options.enforceCap) !== null && _b !== void 0 ? _b : (() => true);
+        this.enforceCap = options.enforceCap ?? (() => true);
     }
     tag(input) {
         const result = this.tagChain.then(() => this.tagSerialized(input));
         this.tagChain = result.catch(() => { });
         return result;
     }
-    tagSerialized(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { kind, data } = this.resolveKindAndData(input);
-            const id = input.key === undefined ? `art_${randomUUID()}` : artifactIdForKey(input.key);
-            // Fresh random ids can't collide; only keyed tags upsert.
-            const existing = input.key === undefined ? undefined : yield this.rows.get(id);
-            const now = new Date().toISOString();
-            const record = {
-                id,
-                kind,
-                key: input.key,
-                title: input.title,
-                data,
-                sessionId: input.sessionId,
-                turnId: input.turnId,
-                source: (_a = input.source) !== null && _a !== void 0 ? _a : "host",
-                createdAt: (_b = existing === null || existing === void 0 ? void 0 : existing.createdAt) !== null && _b !== void 0 ? _b : now,
-                updatedAt: now,
+    async tagSerialized(input) {
+        const { kind, data } = this.resolveKindAndData(input);
+        const id = input.key === undefined ? `art_${randomUUID()}` : artifactIdForKey(input.key);
+        // Fresh random ids can't collide; only keyed tags upsert.
+        const existing = input.key === undefined ? undefined : await this.rows.get(id);
+        const now = new Date().toISOString();
+        const record = {
+            id,
+            kind,
+            key: input.key,
+            title: input.title,
+            data,
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            source: input.source ?? "host",
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        };
+        if (input.contents !== undefined) {
+            const body = typeof input.contents === "string" ? Buffer.from(input.contents, "utf8") : input.contents;
+            await this.content.put(id, body);
+            record.content = {
+                size: body.byteLength,
+                contentType: input.contentType,
             };
-            if (input.contents !== undefined) {
-                const body = typeof input.contents === "string" ? Buffer.from(input.contents, "utf8") : input.contents;
-                yield this.content.put(id, body);
-                record.content = {
-                    size: body.byteLength,
-                    contentType: input.contentType,
-                };
-            }
-            else if ((existing === null || existing === void 0 ? void 0 : existing.content) !== undefined) {
-                if (existing.sessionId === record.sessionId) {
-                    record.content = existing.content;
-                }
-                else {
-                    // Keys are deployment-global: rebinding a keyed row to another
-                    // session must not carry the prior session's payload with it.
-                    yield this.content.delete(id);
-                }
+        }
+        else if (existing?.content !== undefined) {
+            if (existing.sessionId === record.sessionId) {
+                record.content = existing.content;
             }
-            yield this.rows.put(record);
-            if (existing === undefined && this.enforceCap()) {
-                yield this.evictPastCap();
+            else {
+                // Keys are deployment-global: rebinding a keyed row to another
+                // session must not carry the prior session's payload with it.
+                await this.content.delete(id);
             }
-            return record;
-        });
+        }
+        await this.rows.put(record);
+        if (existing === undefined && this.enforceCap()) {
+            await this.evictPastCap();
+        }
+        return record;
     }
     get(id) {
         return this.rows.get(id);
@@ -140,11 +127,9 @@ export class ArtifactsStore {
      * {@link ArtifactsApi.list} contract. Walk the full set via
      * {@link ArtifactsStore.page}.
      */
-    list(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const page = yield this.page(filter);
-            return page.records;
-        });
+    async list(filter) {
+        const page = await this.page(filter);
+        return page.records;
     }
     /**
      * Bounded cursor pagination, newest-updated first. On a store whose
@@ -166,22 +151,19 @@ export class ArtifactsStore {
      * the caller received, and continues only while more *visible* records
      * remain, at the bounded cost of hydrating the full set.
      */
-    page(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const limit = Math.min(Math.max((_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : ARTIFACTS_PAGE_DEFAULT_LIMIT, 1), ARTIFACTS_PAGE_MAX_LIMIT);
-            const cursor = (options === null || options === void 0 ? void 0 : options.cursor) === undefined ? undefined : decodeArtifactPageCursor(options.cursor);
-            const matches = (record) => ((options === null || options === void 0 ? void 0 : options.kind) === undefined || record.kind === options.kind) &&
-                ((options === null || options === void 0 ? void 0 : options.sessionId) === undefined || record.sessionId === options.sessionId) &&
-                ((options === null || options === void 0 ? void 0 : options.matches) === undefined || options.matches(record));
-            if ((options === null || options === void 0 ? void 0 : options.matches) === undefined) {
-                const metas = yield this.rows.listMeta();
-                if (metas.some(meta => meta.mtimeMs !== undefined)) {
-                    return this.pageFromMetadata(metas, limit, cursor, matches, (options === null || options === void 0 ? void 0 : options.kind) !== undefined || (options === null || options === void 0 ? void 0 : options.sessionId) !== undefined);
-                }
+    async page(options) {
+        const limit = Math.min(Math.max(options?.limit ?? ARTIFACTS_PAGE_DEFAULT_LIMIT, 1), ARTIFACTS_PAGE_MAX_LIMIT);
+        const cursor = options?.cursor === undefined ? undefined : decodeArtifactPageCursor(options.cursor);
+        const matches = (record) => (options?.kind === undefined || record.kind === options.kind) &&
+            (options?.sessionId === undefined || record.sessionId === options.sessionId) &&
+            (options?.matches === undefined || options.matches(record));
+        if (options?.matches === undefined) {
+            const metas = await this.rows.listMeta();
+            if (metas.some(meta => meta.mtimeMs !== undefined)) {
+                return this.pageFromMetadata(metas, limit, cursor, matches, options?.kind !== undefined || options?.sessionId !== undefined);
             }
-            return this.pageFromRecords(limit, cursor, matches);
-        });
+        }
+        return this.pageFromRecords(limit, cursor, matches);
     }
     /**
      * Metadata-ordered page: sort metas newest first, resume after the
@@ -189,85 +171,81 @@ export class ArtifactsStore {
      * budget runs out, or the metas do. The cursor marks the last *examined*
      * meta, so a budget-limited call still makes progress.
      */
-    pageFromMetadata(metas, limit, cursor, matches, filtered) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            var _c, _d, _e;
-            const newestFirst = metas.sort((a, b) => byOldestModified(b, a));
-            let start = 0;
-            if (cursor !== undefined && cursor.kind === "mtime") {
-                // Resume after (boundary stamp, rows of that cohort already
-                // examined). Same-stamp rows sit contiguously in the sort, so the
-                // pair names an exact position without identifying any row.
-                start = newestFirst.findIndex(meta => { var _a; return ((_a = meta.mtimeMs) !== null && _a !== void 0 ? _a : 0) <= cursor.m; });
-                if (start === -1) {
-                    return { records: [] };
-                }
-                let skipped = 0;
-                while (start < newestFirst.length &&
-                    ((_c = (_a = newestFirst[start]) === null || _a === void 0 ? void 0 : _a.mtimeMs) !== null && _c !== void 0 ? _c : 0) === cursor.m &&
-                    skipped < cursor.s) {
-                    start += 1;
-                    skipped += 1;
-                }
-                if (start >= newestFirst.length) {
-                    return { records: [] };
-                }
+    async pageFromMetadata(metas, limit, cursor, matches, filtered) {
+        const newestFirst = metas.sort((a, b) => byOldestModified(b, a));
+        let start = 0;
+        if (cursor !== undefined && cursor.kind === "mtime") {
+            // Resume after (boundary stamp, rows of that cohort already
+            // examined). Same-stamp rows sit contiguously in the sort, so the
+            // pair names an exact position without identifying any row.
+            start = newestFirst.findIndex(meta => (meta.mtimeMs ?? 0) <= cursor.m);
+            if (start === -1) {
+                return { records: [] };
             }
-            // A cursor of the other kind means the store's listing gained mtimes
-            // between pages (a mode flip, not caller error): restart from the top
-            // rather than fail the walk.
-            const budget = Math.max(limit, ARTIFACTS_PAGE_SCAN_MIN);
-            const records = [];
-            let examined = 0;
-            let lastExamined = start - 1;
-            // A batched row store hydrates a bigger slice per round trip. Without
-            // one, keep the slice at the per-row fan-out bound. An unfiltered
-            // page needs exactly the rows it returns — every hydrated row matches —
-            // so cap its slice at the remaining page instead of over-hydrating a
-            // full batch for a small `limit`.
-            const scanBatchSize = this.rows.getMany !== undefined ? ARTIFACTS_SCAN_BATCH_ROWS : ROW_HYDRATION_CONCURRENCY;
-            scan: while (lastExamined + 1 < newestFirst.length &&
-                records.length < limit &&
-                examined < budget) {
-                const from = lastExamined + 1;
-                const sliceCap = filtered ? scanBatchSize : Math.min(scanBatchSize, limit - records.length);
-                const batch = newestFirst.slice(from, from + Math.min(sliceCap, budget - examined));
-                const bodies = this.rows.getMany !== undefined
-                    ? yield this.rows.getMany(batch.map(meta => meta.id))
-                    : yield mapBounded(batch, ROW_HYDRATION_CONCURRENCY, meta => this.rows.get(meta.id));
-                for (let i = 0; i < batch.length; i += 1) {
-                    lastExamined = from + i;
-                    examined += 1;
-                    const record = bodies[i];
-                    if (record !== undefined && matches(record)) {
-                        records.push(record);
-                        if (records.length === limit) {
-                            break scan;
-                        }
-                    }
-                }
+            let skipped = 0;
+            while (start < newestFirst.length &&
+                (newestFirst[start]?.mtimeMs ?? 0) === cursor.m &&
+                skipped < cursor.s) {
+                start += 1;
+                skipped += 1;
             }
-            if (lastExamined >= newestFirst.length - 1) {
-                return { records };
+            if (start >= newestFirst.length) {
+                return { records: [] };
             }
-            const boundary = (_d = newestFirst[lastExamined].mtimeMs) !== null && _d !== void 0 ? _d : 0;
-            // How deep into the boundary's same-stamp cohort the scan got —
-            // cohorts are contiguous, so count back from the last examined row.
-            let cohortExamined = 0;
-            for (let i = lastExamined; i >= 0 && ((_e = (_b = newestFirst[i]) === null || _b === void 0 ? void 0 : _b.mtimeMs) !== null && _e !== void 0 ? _e : 0) === boundary; i -= 1) {
-                cohortExamined += 1;
+        }
+        // A cursor of the other kind means the store's listing gained mtimes
+        // between pages (a mode flip, not caller error): restart from the top
+        // rather than fail the walk.
+        const budget = Math.max(limit, ARTIFACTS_PAGE_SCAN_MIN);
+        const records = [];
+        let examined = 0;
+        let lastExamined = start - 1;
+        // A batched row store hydrates a bigger slice per round trip. Without
+        // one, keep the slice at the per-row fan-out bound. An unfiltered
+        // page needs exactly the rows it returns — every hydrated row matches —
+        // so cap its slice at the remaining page instead of over-hydrating a
+        // full batch for a small `limit`.
+        const scanBatchSize = this.rows.getMany !== undefined ? ARTIFACTS_SCAN_BATCH_ROWS : ROW_HYDRATION_CONCURRENCY;
+        scan: while (lastExamined + 1 < newestFirst.length &&
+            records.length < limit &&
+            examined < budget) {
+            const from = lastExamined + 1;
+            const sliceCap = filtered ? scanBatchSize : Math.min(scanBatchSize, limit - records.length);
+            const batch = newestFirst.slice(from, from + Math.min(sliceCap, budget - examined));
+            const bodies = this.rows.getMany !== undefined
+                ? await this.rows.getMany(batch.map(meta => meta.id))
+                : await mapBounded(batch, ROW_HYDRATION_CONCURRENCY, meta => this.rows.get(meta.id));
+            for (let i = 0; i < batch.length; i += 1) {
+                lastExamined = from + i;
+                examined += 1;
+                const record = bodies[i];
+                if (record !== undefined && matches(record)) {
+                    records.push(record);
+                    if (records.length === limit) {
+                        break scan;
+                    }
+                }
             }
-            return {
-                records,
-                nextCursor: encodeArtifactPageCursor({
-                    v: 1,
-                    kind: "mtime",
-                    m: boundary,
-                    s: cohortExamined,
-                }),
-            };
-        });
+        }
+        if (lastExamined >= newestFirst.length - 1) {
+            return { records };
+        }
+        const boundary = newestFirst[lastExamined].mtimeMs ?? 0;
+        // How deep into the boundary's same-stamp cohort the scan got —
+        // cohorts are contiguous, so count back from the last examined row.
+        let cohortExamined = 0;
+        for (let i = lastExamined; i >= 0 && (newestFirst[i]?.mtimeMs ?? 0) === boundary; i -= 1) {
+            cohortExamined += 1;
+        }
+        return {
+            records,
+            nextCursor: encodeArtifactPageCursor({
+                v: 1,
+                kind: "mtime",
+                m: boundary,
+                s: cohortExamined,
+            }),
+        };
     }
     /**
      * Hydrate-everything page: exact `updatedAt` order, cursor = the last
@@ -276,37 +254,35 @@ export class ArtifactsStore {
      * {@link ArtifactsStore.page} for why filtered callers must not receive
      * metadata-lane cursors.
      */
-    pageFromRecords(limit, cursor, matches) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const records = (yield this.rows.list()).filter(matches).sort(byNewestUpdated);
-            let start = 0;
-            if (cursor !== undefined && cursor.kind === "updated") {
-                const position = {
-                    updatedAt: cursor.u,
-                    createdAt: cursor.c,
-                    id: cursor.id,
-                };
-                start = records.findIndex(record => byNewestUpdated(record, position) > 0);
-                if (start === -1) {
-                    return { records: [] };
-                }
-            }
-            const page = records.slice(start, start + limit);
-            const last = page[page.length - 1];
-            if (last === undefined || start + page.length >= records.length) {
-                return { records: page };
-            }
-            return {
-                records: page,
-                nextCursor: encodeArtifactPageCursor({
-                    v: 1,
-                    kind: "updated",
-                    u: last.updatedAt,
-                    c: last.createdAt,
-                    id: last.id,
-                }),
+    async pageFromRecords(limit, cursor, matches) {
+        const records = (await this.rows.list()).filter(matches).sort(byNewestUpdated);
+        let start = 0;
+        if (cursor !== undefined && cursor.kind === "updated") {
+            const position = {
+                updatedAt: cursor.u,
+                createdAt: cursor.c,
+                id: cursor.id,
             };
-        });
+            start = records.findIndex(record => byNewestUpdated(record, position) > 0);
+            if (start === -1) {
+                return { records: [] };
+            }
+        }
+        const page = records.slice(start, start + limit);
+        const last = page[page.length - 1];
+        if (last === undefined || start + page.length >= records.length) {
+            return { records: page };
+        }
+        return {
+            records: page,
+            nextCursor: encodeArtifactPageCursor({
+                v: 1,
+                kind: "updated",
+                u: last.updatedAt,
+                c: last.createdAt,
+                id: last.id,
+            }),
+        };
     }
     /**
      * Resolve the effective kind (freeform when no kinds are declared) and
@@ -315,13 +291,11 @@ export class ArtifactsStore {
      * parsed output — defaults and coercions applied — is what gets stored.
      */
     resolveKindAndData(input) {
-        var _a;
-        var _b;
-        const kind = (_b = input.kind) !== null && _b !== void 0 ? _b : ARTIFACT_DEFAULT_KIND;
+        const kind = input.kind ?? ARTIFACT_DEFAULT_KIND;
         if (kind.trim() === "") {
             throw new Error("artifacts.tag: kind must be a non-empty string");
         }
-        const kinds = (_a = this.config) === null || _a === void 0 ? void 0 : _a.kinds;
+        const kinds = this.config?.kinds;
         if (kinds === undefined || Object.keys(kinds).length === 0) {
             return { kind, data: input.data };
         }
@@ -347,44 +321,40 @@ export class ArtifactsStore {
      * Deletes are capped per pass so a store far past the cap drains across
      * inserts instead of delaying one insert for the entire backlog.
      */
-    evictPastCap() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const metas = yield this.rows.listMeta();
-            const excess = Math.min(metas.length - this.max, ARTIFACTS_EVICT_MAX_PER_PASS);
-            if (excess <= 0) {
-                return;
-            }
-            yield mapBounded(yield this.oldestRowIds(metas, excess), ROW_HYDRATION_CONCURRENCY, (id) => __awaiter(this, void 0, void 0, function* () {
-                yield this.rows.delete(id);
-                // Without the row body there is no `content` flag to consult;
-                // delete the payload unconditionally — absent ones are a no-op.
-                yield this.content.delete(id);
-            }));
+    async evictPastCap() {
+        const metas = await this.rows.listMeta();
+        const excess = Math.min(metas.length - this.max, ARTIFACTS_EVICT_MAX_PER_PASS);
+        if (excess <= 0) {
+            return;
+        }
+        await mapBounded(await this.oldestRowIds(metas, excess), ROW_HYDRATION_CONCURRENCY, async (id) => {
+            await this.rows.delete(id);
+            // Without the row body there is no `content` flag to consult;
+            // delete the payload unconditionally — absent ones are a no-op.
+            await this.content.delete(id);
         });
     }
     /** The `excess` oldest row ids, cheapest available ordering first. */
-    oldestRowIds(metas, excess) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (metas.some(meta => meta.mtimeMs !== undefined)) {
-                // A store that tracks mtimes must never regress to per-insert
-                // hydration. An entry missing one sorts oldest via the comparator's
-                // `?? 0` and is evicted first, avoiding a full hydration on each insert.
-                return metas
-                    .sort(byOldestModified)
-                    .slice(0, excess)
-                    .map(meta => meta.id);
-            }
-            // A store that tracks no modification times at all (the local
-            // filesystem store, deliberately) leaves only the rows' own
-            // `updatedAt`: hydrate — bounded — and order exactly. Corrupt rows
-            // drop out of `list()`, so recompute the excess against the rows that
-            // actually parsed.
-            const records = yield this.rows.list();
-            return records
-                .sort((a, b) => byNewestUpdated(b, a))
-                .slice(0, Math.min(excess, Math.max(0, records.length - this.max)))
-                .map(record => record.id);
-        });
+    async oldestRowIds(metas, excess) {
+        if (metas.some(meta => meta.mtimeMs !== undefined)) {
+            // A store that tracks mtimes must never regress to per-insert
+            // hydration. An entry missing one sorts oldest via the comparator's
+            // `?? 0` and is evicted first, avoiding a full hydration on each insert.
+            return metas
+                .sort(byOldestModified)
+                .slice(0, excess)
+                .map(meta => meta.id);
+        }
+        // A store that tracks no modification times at all (the local
+        // filesystem store, deliberately) leaves only the rows' own
+        // `updatedAt`: hydrate — bounded — and order exactly. Corrupt rows
+        // drop out of `list()`, so recompute the excess against the rows that
+        // actually parsed.
+        const records = await this.rows.list();
+        return records
+            .sort((a, b) => byNewestUpdated(b, a))
+            .slice(0, Math.min(excess, Math.max(0, records.length - this.max)))
+            .map(record => record.id);
     }
 }
 /** A syntactically invalid {@link ArtifactPageOptions.cursor}. */
@@ -403,7 +373,7 @@ function decodeArtifactPageCursor(raw) {
     try {
         value = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
     }
-    catch (_a) {
+    catch {
         throw new InvalidArtifactCursorError();
     }
     if (typeof value !== "object" || value === null) {
@@ -441,9 +411,8 @@ export function artifactIdForKey(key) {
  * the retention cap.
  */
 function byOldestModified(a, b) {
-    var _a, _b;
     if (a.mtimeMs !== b.mtimeMs) {
-        return ((_a = a.mtimeMs) !== null && _a !== void 0 ? _a : 0) - ((_b = b.mtimeMs) !== null && _b !== void 0 ? _b : 0);
+        return (a.mtimeMs ?? 0) - (b.mtimeMs ?? 0);
     }
     return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }
@@ -484,7 +453,7 @@ function parseRecordBytes(bytes) {
     try {
         value = JSON.parse(Buffer.from(bytes).toString("utf8"));
     }
-    catch (_a) {
+    catch {
         // A corrupt row must not poison list().
         return undefined;
     }
@@ -500,58 +469,46 @@ function sinkBody(found) {
 function createSinkRowStore(sink, agentName) {
     const key = (id) => agentStoreKeys.artifactRow(agentName, id);
     return {
-        get(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return parseRecordBytes(sinkBody(yield sink.get(key(id))));
-            });
+        async get(id) {
+            return parseRecordBytes(sinkBody(await sink.get(key(id))));
         },
-        put(record) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield sink.put(key(record.id), Buffer.from(JSON.stringify(record), "utf8"));
-            });
+        async put(record) {
+            await sink.put(key(record.id), Buffer.from(JSON.stringify(record), "utf8"));
         },
-        delete(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield sink.delete(key(id));
-            });
+        async delete(id) {
+            await sink.delete(key(id));
         },
-        getMany(ids) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const keys = ids.map(id => key(id));
-                const bodies = sink.getMany !== undefined
-                    ? yield sink.getMany(keys)
-                    : yield mapBounded(keys, ROW_HYDRATION_CONCURRENCY, rowKey => sink.get(rowKey));
-                return bodies.map(body => parseRecordBytes(sinkBody(body)));
-            });
+        async getMany(ids) {
+            const keys = ids.map(id => key(id));
+            const bodies = sink.getMany !== undefined
+                ? await sink.getMany(keys)
+                : await mapBounded(keys, ROW_HYDRATION_CONCURRENCY, rowKey => sink.get(rowKey));
+            return bodies.map(body => parseRecordBytes(sinkBody(body)));
         },
-        list() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const entries = yield sink.list(agentStoreKeys.artifactRowPrefix(agentName));
-                const bodies = sink.getMany !== undefined
-                    ? yield sink.getMany(entries.map(entry => entry.key))
-                    : yield mapBounded(entries, ROW_HYDRATION_CONCURRENCY, entry => sink.get(entry.key));
-                const records = [];
-                for (const body of bodies) {
-                    const record = parseRecordBytes(sinkBody(body));
-                    if (record !== undefined) {
-                        records.push(record);
-                    }
+        async list() {
+            const entries = await sink.list(agentStoreKeys.artifactRowPrefix(agentName));
+            const bodies = sink.getMany !== undefined
+                ? await sink.getMany(entries.map(entry => entry.key))
+                : await mapBounded(entries, ROW_HYDRATION_CONCURRENCY, entry => sink.get(entry.key));
+            const records = [];
+            for (const body of bodies) {
+                const record = parseRecordBytes(sinkBody(body));
+                if (record !== undefined) {
+                    records.push(record);
                 }
-                return records;
-            });
+            }
+            return records;
         },
-        listMeta() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const prefix = agentStoreKeys.artifactRowPrefix(agentName);
-                const metas = [];
-                for (const entry of yield sink.list(prefix)) {
-                    const id = rowIdFromName(entry.key.slice(prefix.length));
-                    if (id !== undefined) {
-                        metas.push({ id, mtimeMs: entry.mtimeMs });
-                    }
+        async listMeta() {
+            const prefix = agentStoreKeys.artifactRowPrefix(agentName);
+            const metas = [];
+            for (const entry of await sink.list(prefix)) {
+                const id = rowIdFromName(entry.key.slice(prefix.length));
+                if (id !== undefined) {
+                    metas.push({ id, mtimeMs: entry.mtimeMs });
                 }
-                return metas;
-            });
+            }
+            return metas;
         },
     };
 }
@@ -573,27 +530,21 @@ function rowIdFromName(name) {
         const id = decodeURIComponent(encoded);
         return encodeURIComponent(id) === encoded ? id : undefined;
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
 }
 function createSinkContentStore(sink, agentName) {
     const key = (id) => agentStoreKeys.artifactContent(agentName, id);
     return {
-        get(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sinkBody(yield sink.get(key(id)));
-            });
+        async get(id) {
+            return sinkBody(await sink.get(key(id)));
         },
-        put(id, body) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield sink.put(key(id), body);
-            });
+        async put(id, body) {
+            await sink.put(key(id), body);
         },
-        delete(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield sink.delete(key(id));
-            });
+        async delete(id) {
+            await sink.delete(key(id));
         },
     };
 }
@@ -602,9 +553,9 @@ function createFilesystemRowStore(stateRoot) {
     const filePath = (id) => join(dir, `${encodeURIComponent(id)}.json`);
     // Missing and corrupt rows both read as absent — a truncated/garbled
     // file must not poison list() (and with it every insert's eviction).
-    const readRecord = (path) => __awaiter(this, void 0, void 0, function* () {
+    const readRecord = async (path) => {
         try {
-            const value = JSON.parse(yield readFile(path, "utf8"));
+            const value = JSON.parse(await readFile(path, "utf8"));
             return isArtifactRecord(value) ? value : undefined;
         }
         catch (error) {
@@ -613,76 +564,68 @@ function createFilesystemRowStore(stateRoot) {
             }
             throw error;
         }
-    });
+    };
     return {
         get(id) {
             return readRecord(filePath(id));
         },
-        put(record) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield mkdir(dir, { recursive: true });
-                const tmp = join(dir, `.tmp-${randomUUID()}`);
-                yield writeFile(tmp, JSON.stringify(record), "utf8");
-                yield rename(tmp, filePath(record.id));
-            });
+        async put(record) {
+            await mkdir(dir, { recursive: true });
+            const tmp = join(dir, `.tmp-${randomUUID()}`);
+            await writeFile(tmp, JSON.stringify(record), "utf8");
+            await rename(tmp, filePath(record.id));
         },
-        delete(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield rm(filePath(id), { force: true });
-            });
+        async delete(id) {
+            await rm(filePath(id), { force: true });
         },
-        list() {
-            return __awaiter(this, void 0, void 0, function* () {
-                let names;
-                try {
-                    names = yield readdir(dir);
+        async list() {
+            let names;
+            try {
+                names = await readdir(dir);
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return [];
                 }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        return [];
-                    }
-                    throw error;
+                throw error;
+            }
+            const records = [];
+            for (const name of names.sort()) {
+                if (name.startsWith(".") || !name.endsWith(".json")) {
+                    continue;
                 }
-                const records = [];
-                for (const name of names.sort()) {
-                    if (name.startsWith(".") || !name.endsWith(".json")) {
-                        continue;
-                    }
-                    const record = yield readRecord(join(dir, name));
-                    if (record !== undefined) {
-                        records.push(record);
-                    }
+                const record = await readRecord(join(dir, name));
+                if (record !== undefined) {
+                    records.push(record);
                 }
-                return records;
-            });
+            }
+            return records;
         },
-        listMeta() {
-            return __awaiter(this, void 0, void 0, function* () {
-                // No mtimes on purpose: local rows are cheap to hydrate, and the
-                // rows' own `updatedAt` orders eviction exactly, immune to coarse
-                // filesystem timestamp granularity.
-                let names;
-                try {
-                    names = yield readdir(dir);
+        async listMeta() {
+            // No mtimes on purpose: local rows are cheap to hydrate, and the
+            // rows' own `updatedAt` orders eviction exactly, immune to coarse
+            // filesystem timestamp granularity.
+            let names;
+            try {
+                names = await readdir(dir);
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return [];
                 }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        return [];
-                    }
-                    throw error;
+                throw error;
+            }
+            const metas = [];
+            for (const name of names) {
+                if (name.startsWith(".")) {
+                    continue;
                 }
-                const metas = [];
-                for (const name of names) {
-                    if (name.startsWith(".")) {
-                        continue;
-                    }
-                    const id = rowIdFromName(name);
-                    if (id !== undefined) {
-                        metas.push({ id });
-                    }
+                const id = rowIdFromName(name);
+                if (id !== undefined) {
+                    metas.push({ id });
                 }
-                return metas;
-            });
+            }
+            return metas;
         },
     };
 }
@@ -690,31 +633,25 @@ function createFilesystemContentStore(stateRoot) {
     const dir = join(stateRoot, "artifacts", "content");
     const filePath = (id) => join(dir, encodeURIComponent(id));
     return {
-        get(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return new Uint8Array(yield readFile(filePath(id)));
-                }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        return undefined;
-                    }
-                    throw error;
+        async get(id) {
+            try {
+                return new Uint8Array(await readFile(filePath(id)));
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return undefined;
                 }
-            });
+                throw error;
+            }
         },
-        put(id, body) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield mkdir(dir, { recursive: true });
-                const tmp = join(dir, `.tmp-${randomUUID()}`);
-                yield writeFile(tmp, body);
-                yield rename(tmp, filePath(id));
-            });
+        async put(id, body) {
+            await mkdir(dir, { recursive: true });
+            const tmp = join(dir, `.tmp-${randomUUID()}`);
+            await writeFile(tmp, body);
+            await rename(tmp, filePath(id));
         },
-        delete(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield rm(filePath(id), { force: true });
-            });
+        async delete(id) {
+            await rm(filePath(id), { force: true });
         },
     };
 }