@cursor/bdk 0.2.9 → 0.2.10

package/dist/files-backends/cursor-hosted.js

@@ -10,16 +10,6 @@
  * {@link FileConflictError}, and the backend reports
  * `host.files.capabilities.conflictDetection`.
  */
-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());
-    });
-};
-var _a;
 import { createHash } from "node:crypto";
 import { FileConflictError, } from "../files.js";
 import { mapBounded } from "../internal/bounded.js";
@@ -40,9 +30,9 @@ export const AGENT_SERVE_STORE_SOURCE_ID_ENV_VAR = "AGENT_SERVE_STORE_SOURCE_ID"
  */
 export const AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_ENV_VAR = "AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID";
 /** Cap on the per-process etag cache; a miss costs a lookup, not correctness. */
-const MAX_REMEMBERED_ETAGS = 1000;
+const MAX_REMEMBERED_ETAGS = 1_000;
 /** Bounded directory page for point lookups. */
-const DIRECTORY_PAGE_SIZE = 1000;
+const DIRECTORY_PAGE_SIZE = 1_000;
 /** Paths requested in each {@link FileSink.getMany} batch. */
 const READ_PRESIGN_BATCH_MAX = 100;
 /** Concurrent downloads inside one {@link FileSink.getMany} batch. */
@@ -54,7 +44,7 @@ const MAX_DIRECTORY_PAGES = 20;
  * could not carry (~1M entries at the page size above). Past it, fail loudly:
  * a silently partial listing would be mistaken for the whole scope.
  */
-const MAX_LIST_WALK_PAGES = 1000;
+const MAX_LIST_WALK_PAGES = 1_000;
 /**
  * True on Cursor-managed hosting with a provisioned file store.
  *
@@ -70,7 +60,6 @@ export function isCursorHostedFilesAvailable(env = process.env) {
  * deployments always use their deployment-scoped store instead.
  */
 export function isCursorUserStoreFilesAvailable(env = process.env) {
-    var _a;
     if (isCursorHostedFilesAvailable(env)) {
         return false;
     }
@@ -78,7 +67,7 @@ export function isCursorUserStoreFilesAvailable(env = process.env) {
     if (env.VITEST === "true") {
         return false;
     }
-    const key = (_a = env.CURSOR_API_KEY) === null || _a === void 0 ? void 0 : _a.trim();
+    const key = env.CURSOR_API_KEY?.trim();
     return key !== undefined && key !== "";
 }
 /**
@@ -109,26 +98,22 @@ export function cursorHostedFiles(options = {}) {
      * Storage bindings and transport selection are resolved for each operation
      * so platform updates do not require recreating the sink.
      */
-    function withFiles(call) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            var _b;
-            const sourceId = resolveStoreSourceId(options);
-            const protocol = (_b = (_a = options.resolveStoreProtocol) === null || _a === void 0 ? void 0 : _a.call(options)) !== null && _b !== void 0 ? _b : resolveStoreProtocolSync();
-            if (storeProtocolEnablesFactoryFlush(protocol)) {
-                // The batched transport addresses managed stores by role. An unknown
-                // store or transport stays on the compatibility path.
-                if (sourceId === resolveFrameworkStoreSourceIdSync()) {
-                    return yield call({ wire: "flush", store: "framework" });
-                }
-                if (sourceId === resolveDeploymentStoreSourceIdSync()) {
-                    return yield call({ wire: "flush", store: "deployment" });
-                }
+    async function withFiles(call) {
+        const sourceId = resolveStoreSourceId(options);
+        const protocol = options.resolveStoreProtocol?.() ?? resolveStoreProtocolSync();
+        if (storeProtocolEnablesFactoryFlush(protocol)) {
+            // The batched transport addresses managed stores by role. An unknown
+            // store or transport stays on the compatibility path.
+            if (sourceId === resolveFrameworkStoreSourceIdSync()) {
+                return await call({ wire: "flush", store: "framework" });
             }
-            return yield call({
-                wire: "v0",
-                path: (suffix = "") => `/${encodeURIComponent(sourceId)}${suffix}`,
-            });
+            if (sourceId === resolveDeploymentStoreSourceIdSync()) {
+                return await call({ wire: "flush", store: "deployment" });
+            }
+        }
+        return await call({
+            wire: "v0",
+            path: (suffix = "") => `/${encodeURIComponent(sourceId)}${suffix}`,
         });
     }
     /**
@@ -148,77 +133,76 @@ export function cursorHostedFiles(options = {}) {
      * delete race resolves itself on retry, where the presign returns 404
      * and this correctly reads as a miss.
      */
-    function downloadPresigned(key, url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield resolveCursorApiFetch(options)(assertPresignedUrlSafe(options, url), {
-                method: "GET",
-                redirect: "manual",
-            });
-            if (response.status === 404) {
-                return undefined;
-            }
-            if (!response.ok) {
-                throw new Error(`cursorHostedFiles: download of "${key}" failed (HTTP ${response.status})`);
-            }
-            const etag = normalizeEtag(response.headers.get("etag"));
-            if (etag !== undefined) {
-                rememberEtag(key, etag);
-            }
-            return Object.assign({ body: new Uint8Array(yield response.arrayBuffer()) }, (etag === undefined ? {} : { etag }));
+    async function downloadPresigned(key, url) {
+        const response = await resolveCursorApiFetch(options)(assertPresignedUrlSafe(options, url), {
+            method: "GET",
+            redirect: "manual",
         });
+        if (response.status === 404) {
+            return undefined;
+        }
+        if (!response.ok) {
+            throw new Error(`cursorHostedFiles: download of "${key}" failed (HTTP ${response.status})`);
+        }
+        const etag = normalizeEtag(response.headers.get("etag"));
+        if (etag !== undefined) {
+            rememberEtag(key, etag);
+        }
+        return {
+            body: new Uint8Array(await response.arrayBuffer()),
+            ...(etag === undefined ? {} : { etag }),
+        };
     }
     /** One page of a directory listing. */
-    function directoryPage(files, directory, pageToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (files.wire === "flush") {
-                return yield flushPost(options, "/list", Object.assign({ store: files.store, path: directory, limit: DIRECTORY_PAGE_SIZE }, (pageToken === undefined ? {} : { pageToken })));
-            }
-            const query = new URLSearchParams({
+    async function directoryPage(files, directory, pageToken) {
+        if (files.wire === "flush") {
+            return await flushPost(options, "/list", {
+                store: files.store,
                 path: directory,
-                limit: String(DIRECTORY_PAGE_SIZE),
+                limit: DIRECTORY_PAGE_SIZE,
+                ...(pageToken === undefined ? {} : { pageToken }),
             });
-            if (pageToken !== undefined) {
-                query.set("pageToken", pageToken);
-            }
-            return yield storeGet(options, files.path(`?${query.toString()}`));
+        }
+        const query = new URLSearchParams({
+            path: directory,
+            limit: String(DIRECTORY_PAGE_SIZE),
         });
+        if (pageToken !== undefined) {
+            query.set("pageToken", pageToken);
+        }
+        return await storeGet(options, files.path(`?${query.toString()}`));
     }
     /** The unscoped whole-store listing. */
-    function unscopedListing(files) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (files.wire === "flush") {
-                return yield flushPost(options, "/list", {
-                    store: files.store,
-                });
-            }
-            return yield storeGet(options, files.path());
-        });
+    async function unscopedListing(files) {
+        if (files.wire === "flush") {
+            return await flushPost(options, "/list", {
+                store: files.store,
+            });
+        }
+        return await storeGet(options, files.path());
     }
-    function listEntries(prefix) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const raw = yield unscopedListing(files);
-                if (raw.complete === true) {
-                    const out = [];
-                    for (const file of (_a = raw.files) !== null && _a !== void 0 ? _a : []) {
-                        if (typeof file.path !== "string" || !file.path.startsWith(prefix)) {
-                            continue;
-                        }
-                        out.push(toEntry(file, file.path));
+    async function listEntries(prefix) {
+        return await withFiles(async (files) => {
+            const raw = await unscopedListing(files);
+            if (raw.complete === true) {
+                const out = [];
+                for (const file of raw.files ?? []) {
+                    if (typeof file.path !== "string" || !file.path.startsWith(prefix)) {
+                        continue;
                     }
-                    // The FileSink contract promises key order, and transcript-chunk
-                    // consumers depend on it (chunk keys are zero-padded so key order
-                    // is append order). The server happens to scan in order today; do
-                    // not let that be the only thing holding the contract.
-                    return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+                    out.push(toEntry(file, file.path));
                 }
-                // The unscoped listing was truncated (`complete: false`) and has no
-                // continuation to follow. `list()` promises the whole scope, so rather
-                // than lie or fail, walk the paginated per-directory form, which does
-                // paginate and reports immediate subdirectories to recurse into.
-                return yield walkDirectoryTree(files, prefix);
-            }));
+                // The FileSink contract promises key order, and transcript-chunk
+                // consumers depend on it (chunk keys are zero-padded so key order
+                // is append order). The server happens to scan in order today; do
+                // not let that be the only thing holding the contract.
+                return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+            }
+            // The unscoped listing was truncated (`complete: false`) and has no
+            // continuation to follow. `list()` promises the whole scope, so rather
+            // than lie or fail, walk the paginated per-directory form, which does
+            // paginate and reports immediate subdirectories to recurse into.
+            return await walkDirectoryTree(files, prefix);
         });
     }
     /**
@@ -229,49 +213,46 @@ export function cursorHostedFiles(options = {}) {
      * store fails loudly rather than returning a silently partial answer the
      * caller would mistake for the whole scope.
      */
-    function walkDirectoryTree(files, prefix) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const slash = prefix.lastIndexOf("/");
-            const pending = [slash === -1 ? "" : prefix.slice(0, slash)];
-            const queued = new Set(pending);
-            const out = [];
-            let pageBudget = MAX_LIST_WALK_PAGES;
-            while (pending.length > 0) {
-                const directory = pending.pop();
-                let pageToken;
-                do {
-                    if (pageBudget <= 0) {
-                        throw new Error("cursorHostedFiles: the store is too large to list; scope the listing with a narrower prefix");
+    async function walkDirectoryTree(files, prefix) {
+        const slash = prefix.lastIndexOf("/");
+        const pending = [slash === -1 ? "" : prefix.slice(0, slash)];
+        const queued = new Set(pending);
+        const out = [];
+        let pageBudget = MAX_LIST_WALK_PAGES;
+        while (pending.length > 0) {
+            const directory = pending.pop();
+            let pageToken;
+            do {
+                if (pageBudget <= 0) {
+                    throw new Error("cursorHostedFiles: the store is too large to list; scope the listing with a narrower prefix");
+                }
+                pageBudget -= 1;
+                const page = await directoryPage(files, directory, pageToken);
+                for (const file of page.files ?? []) {
+                    if (typeof file.path === "string" && file.path.startsWith(prefix)) {
+                        out.push(toEntry(file, file.path));
                     }
-                    pageBudget -= 1;
-                    const page = yield directoryPage(files, directory, pageToken);
-                    for (const file of (_a = page.files) !== null && _a !== void 0 ? _a : []) {
-                        if (typeof file.path === "string" && file.path.startsWith(prefix)) {
-                            out.push(toEntry(file, file.path));
-                        }
+                }
+                // Every page can surface different subdirectories, so collect from
+                // all of them, deduped — and descend only into branches that can
+                // still hold matches: a descendant of the prefix, or (at the first
+                // level) a directory the prefix's basename component narrows to.
+                for (const subdir of page.directories ?? []) {
+                    if (queued.has(subdir)) {
+                        continue;
                     }
-                    // Every page can surface different subdirectories, so collect from
-                    // all of them, deduped — and descend only into branches that can
-                    // still hold matches: a descendant of the prefix, or (at the first
-                    // level) a directory the prefix's basename component narrows to.
-                    for (const subdir of (_b = page.directories) !== null && _b !== void 0 ? _b : []) {
-                        if (queued.has(subdir)) {
-                            continue;
-                        }
-                        if (`${subdir}/`.startsWith(prefix) || prefix.startsWith(`${subdir}/`)) {
-                            queued.add(subdir);
-                            pending.push(subdir);
-                        }
+                    if (`${subdir}/`.startsWith(prefix) || prefix.startsWith(`${subdir}/`)) {
+                        queued.add(subdir);
+                        pending.push(subdir);
                     }
-                    pageToken =
-                        page.complete === false && page.nextPageToken !== undefined
-                            ? page.nextPageToken
-                            : undefined;
-                } while (pageToken !== undefined);
-            }
-            return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
-        });
+                }
+                pageToken =
+                    page.complete === false && page.nextPageToken !== undefined
+                        ? page.nextPageToken
+                        : undefined;
+            } while (pageToken !== undefined);
+        }
+        return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
     }
     /** Shared decode: remember the etag as a side effect, then shape the entry. */
     function toEntry(file, key) {
@@ -279,7 +260,12 @@ export function cursorHostedFiles(options = {}) {
             rememberEtag(key, file.etag);
         }
         const mtimeMs = typeof file.updatedAt === "string" ? Date.parse(file.updatedAt) : undefined;
-        return Object.assign(Object.assign({ key, size: typeof file.sizeBytes === "number" ? file.sizeBytes : 0 }, (typeof file.etag === "string" && file.etag !== "" ? { etag: file.etag } : {})), (mtimeMs === undefined || Number.isNaN(mtimeMs) ? {} : { mtimeMs }));
+        return {
+            key,
+            size: typeof file.sizeBytes === "number" ? file.sizeBytes : 0,
+            ...(typeof file.etag === "string" && file.etag !== "" ? { etag: file.etag } : {}),
+            ...(mtimeMs === undefined || Number.isNaN(mtimeMs) ? {} : { mtimeMs }),
+        };
     }
     /**
      * One key's current entry, via the bounded directory listing.
@@ -289,53 +275,62 @@ export function cursorHostedFiles(options = {}) {
      * the store got. `?path=` is scoped to one directory and paginates, and the
      * scan stops as soon as the key appears.
      */
-    function statKey(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const slash = key.lastIndexOf("/");
-            const directory = slash === -1 ? "" : key.slice(0, slash);
-            return yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                let pageToken;
-                for (let page = 0; page < MAX_DIRECTORY_PAGES; page += 1) {
-                    const raw = yield directoryPage(files, directory, pageToken);
-                    for (const file of (_a = raw.files) !== null && _a !== void 0 ? _a : []) {
-                        if (file.path === key) {
-                            return toEntry(file, key);
-                        }
+    async function statKey(key) {
+        const slash = key.lastIndexOf("/");
+        const directory = slash === -1 ? "" : key.slice(0, slash);
+        return await withFiles(async (files) => {
+            let pageToken;
+            for (let page = 0; page < MAX_DIRECTORY_PAGES; page += 1) {
+                const raw = await directoryPage(files, directory, pageToken);
+                for (const file of raw.files ?? []) {
+                    if (file.path === key) {
+                        return toEntry(file, key);
                     }
-                    // `complete` is false exactly when another page is waiting.
-                    if (raw.complete !== false || raw.nextPageToken === undefined) {
-                        return undefined;
-                    }
-                    pageToken = raw.nextPageToken;
                 }
-                return undefined;
-            }));
+                // `complete` is false exactly when another page is waiting.
+                if (raw.complete !== false || raw.nextPageToken === undefined) {
+                    return undefined;
+                }
+                pageToken = raw.nextPageToken;
+            }
+            return undefined;
         });
     }
     /**
      * Resolve upload instructions for one attempt. A response without a URL
      * reports that the file cannot use the single-part upload path.
      */
-    function presignUploads(files, specs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (files.wire === "flush") {
-                const response = yield flushPost(options, "/flush", {
-                    store: files.store,
-                    ops: specs.map(spec => (Object.assign({ op: "put", path: spec.key, sha: createHash("sha256").update(spec.body).digest("hex"), size: spec.body.byteLength }, spec.precondition))),
-                });
-                // Index-aligned with the request ops, entries without a `url` included:
-                // a refused op (oversize) must keep its slot so the by-path/positional
-                // instruction matching below cannot hand its sibling's presign to it,
-                // and the missing url surfaces as that key's own error.
-                return {
-                    files: ((_a = response.ops) !== null && _a !== void 0 ? _a : []).map(op => (Object.assign(Object.assign({ path: op.path }, (typeof op.url === "string" && op.url !== "" ? { url: op.url } : {})), { headers: op.headers }))),
-                };
-            }
-            return yield storePost(options, files.path("/upload"), {
-                files: specs.map(spec => (Object.assign({ path: spec.key, sha: createHash("sha256").update(spec.body).digest("hex"), size: spec.body.byteLength }, spec.precondition))),
+    async function presignUploads(files, specs) {
+        if (files.wire === "flush") {
+            const response = await flushPost(options, "/flush", {
+                store: files.store,
+                ops: specs.map(spec => ({
+                    op: "put",
+                    path: spec.key,
+                    sha: createHash("sha256").update(spec.body).digest("hex"),
+                    size: spec.body.byteLength,
+                    ...spec.precondition,
+                })),
             });
+            // Index-aligned with the request ops, entries without a `url` included:
+            // a refused op (oversize) must keep its slot so the by-path/positional
+            // instruction matching below cannot hand its sibling's presign to it,
+            // and the missing url surfaces as that key's own error.
+            return {
+                files: (response.ops ?? []).map(op => ({
+                    path: op.path,
+                    ...(typeof op.url === "string" && op.url !== "" ? { url: op.url } : {}),
+                    headers: op.headers,
+                })),
+            };
+        }
+        return await storePost(options, files.path("/upload"), {
+            files: specs.map(spec => ({
+                path: spec.key,
+                sha: createHash("sha256").update(spec.body).digest("hex"),
+                size: spec.body.byteLength,
+                ...spec.precondition,
+            })),
         });
     }
     /**
@@ -344,56 +339,52 @@ export function cursorHostedFiles(options = {}) {
      * disturbs its batch siblings. Resolving the instructions is shared, so
      * that request failing rejects the whole attempt.
      */
-    function attemptUploads(files, specs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const presigned = yield presignUploads(files, specs);
-            return yield Promise.all(specs.map((spec, index) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                var _c, _d;
-                // Match by path, falling back to position for servers that answer
-                // in request order without echoing the path.
-                const instruction = (_c = (_a = presigned.files) === null || _a === void 0 ? void 0 : _a.find(file => file.path === spec.key)) !== null && _c !== void 0 ? _c : (_b = presigned.files) === null || _b === void 0 ? void 0 : _b[index];
-                if ((instruction === null || instruction === void 0 ? void 0 : instruction.url) === undefined) {
-                    // Files past the single-part threshold come back with a multipart
-                    // plan instead of a url; this backend does not implement multipart.
+    async function attemptUploads(files, specs) {
+        const presigned = await presignUploads(files, specs);
+        return await Promise.all(specs.map(async (spec, index) => {
+            // Match by path, falling back to position for servers that answer
+            // in request order without echoing the path.
+            const instruction = presigned.files?.find(file => file.path === spec.key) ?? presigned.files?.[index];
+            if (instruction?.url === undefined) {
+                // Files past the single-part threshold come back with a multipart
+                // plan instead of a url; this backend does not implement multipart.
+                return {
+                    status: "error",
+                    error: new Error(`cursorHostedFiles: no single-part upload url for "${spec.key}" (too large?)`),
+                };
+            }
+            try {
+                const response = await resolveCursorApiFetch(options)(assertPresignedUrlSafe(options, instruction.url), {
+                    method: "PUT",
+                    headers: instruction.headers ?? {},
+                    // A view over bytes is a valid fetch body; the DOM lib types
+                    // are narrower than the runtime, and copying into a Blob would
+                    // double the memory for every upload.
+                    body: spec.body,
+                    // A redirect would re-send the body somewhere the presign did
+                    // not authorize.
+                    redirect: "manual",
+                });
+                if (response.status === 412) {
+                    observedEtags.delete(spec.key);
+                    return { status: "conflict" };
+                }
+                if (!response.ok) {
                     return {
                         status: "error",
-                        error: new Error(`cursorHostedFiles: no single-part upload url for "${spec.key}" (too large?)`),
+                        error: new Error(`cursorHostedFiles: upload of "${spec.key}" failed (HTTP ${response.status})`),
                     };
                 }
-                try {
-                    const response = yield resolveCursorApiFetch(options)(assertPresignedUrlSafe(options, instruction.url), {
-                        method: "PUT",
-                        headers: (_d = instruction.headers) !== null && _d !== void 0 ? _d : {},
-                        // A view over bytes is a valid fetch body; the DOM lib types
-                        // are narrower than the runtime, and copying into a Blob would
-                        // double the memory for every upload.
-                        body: spec.body,
-                        // A redirect would re-send the body somewhere the presign did
-                        // not authorize.
-                        redirect: "manual",
-                    });
-                    if (response.status === 412) {
-                        observedEtags.delete(spec.key);
-                        return { status: "conflict" };
-                    }
-                    if (!response.ok) {
-                        return {
-                            status: "error",
-                            error: new Error(`cursorHostedFiles: upload of "${spec.key}" failed (HTTP ${response.status})`),
-                        };
-                    }
-                    const etag = normalizeEtag(response.headers.get("etag"));
-                    if (etag !== undefined) {
-                        rememberEtag(spec.key, etag);
-                    }
-                    return { status: "ok", result: etag === undefined ? {} : { etag } };
-                }
-                catch (error) {
-                    return { status: "error", error };
+                const etag = normalizeEtag(response.headers.get("etag"));
+                if (etag !== undefined) {
+                    rememberEtag(spec.key, etag);
                 }
-            })));
-        });
+                return { status: "ok", result: etag === undefined ? {} : { etag } };
+            }
+            catch (error) {
+                return { status: "error", error };
+            }
+        }));
     }
     /**
      * The full single-key write flow: precondition resolution, one shared
@@ -401,46 +392,43 @@ export function cursorHostedFiles(options = {}) {
      * `put` promises — including the one statKey-and-retry when an optimistic
      * create loses to an existing object.
      */
-    function settlePut(files, entry, first) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (first.status === "error") {
-                throw first.error;
-            }
-            if (first.status === "ok") {
-                return first.result;
-            }
-            // Conflict. Explicit `ifMatch` (etag or create-only) and cached-etag
-            // writes are single-attempt: the lost precondition is the caller's.
-            const requested = (_a = entry.options) === null || _a === void 0 ? void 0 : _a.ifMatch;
-            if (requested !== undefined) {
-                throw new FileConflictError(entry.key, {
-                    storedEtag: requested !== null && requested !== void 0 ? requested : undefined,
-                });
-            }
-            if (entry.cachedEtagUsed === true) {
-                // Someone else wrote between our etag observation and this PUT.
-                throw new FileConflictError(entry.key, { storedEtag: entry.staleEtag });
-            }
-            // The optimistic create lost: learn the current etag once and replace.
-            const found = yield statKey(entry.key);
-            if ((found === null || found === void 0 ? void 0 : found.etag) === undefined) {
-                // Existed a moment ago (the create lost) but stat sees nothing: a
-                // delete raced this write. Surface the conflict; a retry from the
-                // caller lands on the fresh create-only path.
-                throw new FileConflictError(entry.key, {});
-            }
-            const [replaced] = yield attemptUploads(files, [
-                { key: entry.key, body: entry.body, precondition: { etag: found.etag } },
-            ]);
-            if (replaced === undefined || replaced.status === "conflict") {
-                throw new FileConflictError(entry.key, { storedEtag: found === null || found === void 0 ? void 0 : found.etag });
-            }
-            if (replaced.status === "error") {
-                throw replaced.error;
-            }
-            return replaced.result;
-        });
+    async function settlePut(files, entry, first) {
+        if (first.status === "error") {
+            throw first.error;
+        }
+        if (first.status === "ok") {
+            return first.result;
+        }
+        // Conflict. Explicit `ifMatch` (etag or create-only) and cached-etag
+        // writes are single-attempt: the lost precondition is the caller's.
+        const requested = entry.options?.ifMatch;
+        if (requested !== undefined) {
+            throw new FileConflictError(entry.key, {
+                storedEtag: requested ?? undefined,
+            });
+        }
+        if (entry.cachedEtagUsed === true) {
+            // Someone else wrote between our etag observation and this PUT.
+            throw new FileConflictError(entry.key, { storedEtag: entry.staleEtag });
+        }
+        // The optimistic create lost: learn the current etag once and replace.
+        const found = await statKey(entry.key);
+        if (found?.etag === undefined) {
+            // Existed a moment ago (the create lost) but stat sees nothing: a
+            // delete raced this write. Surface the conflict; a retry from the
+            // caller lands on the fresh create-only path.
+            throw new FileConflictError(entry.key, {});
+        }
+        const [replaced] = await attemptUploads(files, [
+            { key: entry.key, body: entry.body, precondition: { etag: found.etag } },
+        ]);
+        if (replaced === undefined || replaced.status === "conflict") {
+            throw new FileConflictError(entry.key, { storedEtag: found?.etag });
+        }
+        if (replaced.status === "error") {
+            throw replaced.error;
+        }
+        return replaced.result;
     }
     /**
      * Precondition for a write, and whether it came from the etag cache (a
@@ -448,8 +436,7 @@ export function cursorHostedFiles(options = {}) {
      * one stat-and-retry).
      */
     function preconditionFor(entry) {
-        var _a;
-        const requested = (_a = entry.options) === null || _a === void 0 ? void 0 : _a.ifMatch;
+        const requested = entry.options?.ifMatch;
         // The store rejects unconditional writes, so every put carries a
         // precondition. `null` is create-only and an explicit etag is a caller
         // assertion.
@@ -477,269 +464,266 @@ export function cursorHostedFiles(options = {}) {
         // No local copy: bytes live in the store, so `materializedPath()` is
         // `undefined` and the harness reaches files through `host.files`.
         capabilities: { etags: true },
-        put(key, body, putOptions) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                    const entry = { key, body, options: putOptions };
-                    const resolved = preconditionFor(entry);
-                    const [first] = yield attemptUploads(files, [
-                        { key, body, precondition: resolved.precondition },
-                    ]);
-                    if (first === undefined) {
-                        throw new Error(`cursorHostedFiles: upload of "${key}" vanished`);
-                    }
-                    return yield settlePut(files, Object.assign(Object.assign({}, entry), { cachedEtagUsed: resolved.cachedEtagUsed, staleEtag: resolved.staleEtag }), first);
-                }));
+        async put(key, body, putOptions) {
+            return await withFiles(async (files) => {
+                const entry = { key, body, options: putOptions };
+                const resolved = preconditionFor(entry);
+                const [first] = await attemptUploads(files, [
+                    { key, body, precondition: resolved.precondition },
+                ]);
+                if (first === undefined) {
+                    throw new Error(`cursorHostedFiles: upload of "${key}" vanished`);
+                }
+                return await settlePut(files, {
+                    ...entry,
+                    cachedEtagUsed: resolved.cachedEtagUsed,
+                    staleEtag: resolved.staleEtag,
+                }, first);
             });
         },
-        putMany(entries) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (entries.length === 0) {
-                    return [];
+        async putMany(entries) {
+            if (entries.length === 0) {
+                return [];
+            }
+            return await withFiles(async (files) => {
+                const resolved = entries.map(entry => ({
+                    entry,
+                    ...preconditionFor(entry),
+                }));
+                let firsts;
+                try {
+                    // One presign call for the whole batch — the point of putMany.
+                    firsts = await attemptUploads(files, resolved.map(({ entry, precondition }) => ({
+                        key: entry.key,
+                        body: entry.body,
+                        precondition,
+                    })));
                 }
-                return yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                    const resolved = entries.map(entry => (Object.assign({ entry }, preconditionFor(entry))));
-                    let firsts;
-                    try {
-                        // One presign call for the whole batch — the point of putMany.
-                        firsts = yield attemptUploads(files, resolved.map(({ entry, precondition }) => ({
-                            key: entry.key,
-                            body: entry.body,
-                            precondition,
-                        })));
-                    }
-                    catch (error) {
-                        // The shared presign failed: every entry failed the same way.
-                        return entries.map(() => ({
+                catch (error) {
+                    // The shared presign failed: every entry failed the same way.
+                    return entries.map(() => ({
+                        status: "rejected",
+                        reason: error,
+                    }));
+                }
+                return await Promise.all(resolved.map(async ({ entry, cachedEtagUsed, staleEtag }, index) => {
+                    const first = firsts[index];
+                    if (first === undefined) {
+                        return {
                             status: "rejected",
-                            reason: error,
-                        }));
+                            reason: new Error(`cursorHostedFiles: upload of "${entry.key}" vanished`),
+                        };
                     }
-                    return yield Promise.all(resolved.map((_a, index_1) => __awaiter(this, [_a, index_1], void 0, function* ({ entry, cachedEtagUsed, staleEtag }, index) {
-                        const first = firsts[index];
-                        if (first === undefined) {
-                            return {
-                                status: "rejected",
-                                reason: new Error(`cursorHostedFiles: upload of "${entry.key}" vanished`),
-                            };
-                        }
-                        try {
-                            return {
-                                status: "fulfilled",
-                                value: yield settlePut(files, Object.assign(Object.assign({}, entry), { cachedEtagUsed, staleEtag }), first),
-                            };
-                        }
-                        catch (error) {
-                            return { status: "rejected", reason: error };
-                        }
-                    })));
-                }));
-            });
-        },
-        get(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
-                    // A path with no live object is absent, not a storage failure.
-                    let presigned;
                     try {
-                        presigned =
-                            files.wire === "flush"
-                                ? yield flushPost(options, "/read", {
-                                    store: files.store,
-                                    paths: [key],
-                                })
-                                : yield storePost(options, files.path("/download"), {
-                                    paths: [key],
-                                });
+                        return {
+                            status: "fulfilled",
+                            value: await settlePut(files, { ...entry, cachedEtagUsed, staleEtag }, first),
+                        };
                     }
                     catch (error) {
-                        if (error instanceof StoreApiError && error.status === 404) {
-                            return undefined;
-                        }
-                        throw error;
-                    }
-                    const url = (_b = (_a = presigned.files) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url;
-                    if (url === undefined) {
-                        return undefined;
+                        return { status: "rejected", reason: error };
                     }
-                    return yield downloadPresigned(key, url);
                 }));
             });
         },
-        getMany(keys) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (keys.length === 0) {
-                    return [];
-                }
-                const bodies = yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    if (files.wire !== "flush") {
-                        // This transport cannot distinguish one missing key from a failed
-                        // batch, so preserve exact absence semantics with bounded reads.
-                        return yield mapBounded([...keys], GET_MANY_DOWNLOAD_CONCURRENCY, (key) => __awaiter(this, void 0, void 0, function* () {
-                            var _a, _b;
-                            const presigned = yield storePost(options, files.path("/download"), { paths: [key] }).catch((error) => {
-                                if (error instanceof StoreApiError && error.status === 404) {
-                                    return undefined;
-                                }
-                                throw error;
-                            });
-                            const url = (_b = (_a = presigned === null || presigned === void 0 ? void 0 : presigned.files) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url;
-                            if (url === undefined) {
-                                return undefined;
-                            }
-                            return yield downloadPresigned(key, url);
-                        }));
-                    }
-                    const urls = new Map();
-                    for (let from = 0; from < keys.length; from += READ_PRESIGN_BATCH_MAX) {
-                        const chunk = keys.slice(from, from + READ_PRESIGN_BATCH_MAX);
-                        let presigned;
-                        try {
-                            presigned = yield flushPost(options, "/read", {
+        async get(key) {
+            return await withFiles(async (files) => {
+                // A path with no live object is absent, not a storage failure.
+                let presigned;
+                try {
+                    presigned =
+                        files.wire === "flush"
+                            ? await flushPost(options, "/read", {
                                 store: files.store,
-                                paths: chunk,
+                                paths: [key],
+                            })
+                            : await storePost(options, files.path("/download"), {
+                                paths: [key],
                             });
-                        }
-                        catch (error) {
-                            if (error instanceof StoreApiError && error.status === 404) {
-                                // The read route never 404s per path (absent paths are
-                                // omitted entries); a 404 is the store itself — not
-                                // provisioned, or deleted under us — which get() reads as
-                                // absence for every key.
-                                return keys.map(() => undefined);
-                            }
-                            throw error;
-                        }
-                        for (const entry of (_a = presigned.files) !== null && _a !== void 0 ? _a : []) {
-                            if (entry.path !== undefined && entry.url !== undefined) {
-                                urls.set(entry.path, entry.url);
-                            }
-                        }
+                }
+                catch (error) {
+                    if (error instanceof StoreApiError && error.status === 404) {
+                        return undefined;
                     }
-                    return yield mapBounded([...keys], GET_MANY_DOWNLOAD_CONCURRENCY, (key) => __awaiter(this, void 0, void 0, function* () {
-                        var _a, _b;
-                        const url = urls.get(key);
-                        if (url !== undefined) {
-                            return yield downloadPresigned(key, url);
-                        }
-                        // A miss in the batch is NOT yet a definitive absence: the
-                        // server echoes each path *normalized* (trimmed, backslashes
-                        // folded, empty/"." segments dropped), so a key whose
-                        // normalized form differs from what was sent never matches the
-                        // echo even though its object exists. `get()` is immune (it
-                        // reads the response positionally), so settle every batch miss
-                        // through the single-path read — keeping getMany's absence
-                        // semantics byte-identical to get()'s. Genuine absences pay one
-                        // extra request; every batch caller reads keys it just listed
-                        // or was told exist, so real misses are rare (delete races,
-                        // store loss).
-                        const presigned = yield flushPost(options, "/read", {
-                            store: files.store,
-                            paths: [key],
-                        }).catch((error) => {
-                            // Store-level 404 (deleted between the batch and this read):
-                            // absence, same as get().
+                    throw error;
+                }
+                const url = presigned.files?.[0]?.url;
+                if (url === undefined) {
+                    return undefined;
+                }
+                return await downloadPresigned(key, url);
+            });
+        },
+        async getMany(keys) {
+            if (keys.length === 0) {
+                return [];
+            }
+            const bodies = await withFiles(async (files) => {
+                if (files.wire !== "flush") {
+                    // This transport cannot distinguish one missing key from a failed
+                    // batch, so preserve exact absence semantics with bounded reads.
+                    return await mapBounded([...keys], GET_MANY_DOWNLOAD_CONCURRENCY, async (key) => {
+                        const presigned = await storePost(options, files.path("/download"), { paths: [key] }).catch((error) => {
                             if (error instanceof StoreApiError && error.status === 404) {
                                 return undefined;
                             }
                             throw error;
                         });
-                        const singleUrl = (_b = (_a = presigned === null || presigned === void 0 ? void 0 : presigned.files) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url;
-                        if (singleUrl === undefined) {
+                        const url = presigned?.files?.[0]?.url;
+                        if (url === undefined) {
                             return undefined;
                         }
-                        return yield downloadPresigned(key, singleUrl);
-                    }));
-                }));
-                return bodies;
-            });
-        },
-        delete(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const handled = yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    var _b;
-                    if (files.wire !== "flush") {
-                        return false;
+                        return await downloadPresigned(key, url);
+                    });
+                }
+                const urls = new Map();
+                for (let from = 0; from < keys.length; from += READ_PRESIGN_BATCH_MAX) {
+                    const chunk = keys.slice(from, from + READ_PRESIGN_BATCH_MAX);
+                    let presigned;
+                    try {
+                        presigned = await flushPost(options, "/read", {
+                            store: files.store,
+                            paths: chunk,
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof StoreApiError && error.status === 404) {
+                            // The read route never 404s per path (absent paths are
+                            // omitted entries); a 404 is the store itself — not
+                            // provisioned, or deleted under us — which get() reads as
+                            // absence for every key.
+                            return keys.map(() => undefined);
+                        }
+                        throw error;
                     }
-                    // With an observed etag the flush delete is If-Match on that version.
-                    // Without one, the server tombstones whatever live object occupies
-                    // the key (no directory walk here) and an absent key settles as
-                    // `already_deleted`.
-                    const cached = observedEtags.get(key);
-                    const response = yield flushPost(options, "/flush", {
+                    for (const entry of presigned.files ?? []) {
+                        if (entry.path !== undefined && entry.url !== undefined) {
+                            urls.set(entry.path, entry.url);
+                        }
+                    }
+                }
+                return await mapBounded([...keys], GET_MANY_DOWNLOAD_CONCURRENCY, async (key) => {
+                    const url = urls.get(key);
+                    if (url !== undefined) {
+                        return await downloadPresigned(key, url);
+                    }
+                    // A miss in the batch is NOT yet a definitive absence: the
+                    // server echoes each path *normalized* (trimmed, backslashes
+                    // folded, empty/"." segments dropped), so a key whose
+                    // normalized form differs from what was sent never matches the
+                    // echo even though its object exists. `get()` is immune (it
+                    // reads the response positionally), so settle every batch miss
+                    // through the single-path read — keeping getMany's absence
+                    // semantics byte-identical to get()'s. Genuine absences pay one
+                    // extra request; every batch caller reads keys it just listed
+                    // or was told exist, so real misses are rare (delete races,
+                    // store loss).
+                    const presigned = await flushPost(options, "/read", {
                         store: files.store,
-                        ops: [
-                            Object.assign({ op: "delete", path: key }, (cached === undefined ? {} : { etag: cached })),
-                        ],
+                        paths: [key],
+                    }).catch((error) => {
+                        // Store-level 404 (deleted between the batch and this read):
+                        // absence, same as get().
+                        if (error instanceof StoreApiError && error.status === 404) {
+                            return undefined;
+                        }
+                        throw error;
                     });
-                    const outcome = (_a = response.ops) === null || _a === void 0 ? void 0 : _a[0];
-                    if ((outcome === null || outcome === void 0 ? void 0 : outcome.status) === "conflict") {
-                        observedEtags.delete(key);
-                        throw new FileConflictError(key, Object.assign({}, (outcome.etag === undefined
-                            ? {}
-                            : { storedEtag: (_b = normalizeEtag(outcome.etag)) !== null && _b !== void 0 ? _b : outcome.etag })));
+                    const singleUrl = presigned?.files?.[0]?.url;
+                    if (singleUrl === undefined) {
+                        return undefined;
                     }
-                    observedEtags.delete(key);
-                    return true;
-                }));
-                if (handled) {
-                    return;
+                    return await downloadPresigned(key, singleUrl);
+                });
+            });
+            return bodies;
+        },
+        async delete(key) {
+            const handled = await withFiles(async (files) => {
+                if (files.wire !== "flush") {
+                    return false;
                 }
-                if (observedEtags.get(key) === undefined) {
-                    // Deletes are conditional too, so learn the current etag first. A key
-                    // we have never seen is already absent as far as the caller cares.
-                    const found = yield statKey(key);
-                    if ((found === null || found === void 0 ? void 0 : found.etag) === undefined) {
-                        return;
-                    }
+                // With an observed etag the flush delete is If-Match on that version.
+                // Without one, the server tombstones whatever live object occupies
+                // the key (no directory walk here) and an absent key settles as
+                // `already_deleted`.
+                const cached = observedEtags.get(key);
+                const response = await flushPost(options, "/flush", {
+                    store: files.store,
+                    ops: [
+                        {
+                            op: "delete",
+                            path: key,
+                            ...(cached === undefined ? {} : { etag: cached }),
+                        },
+                    ],
+                });
+                const outcome = response.ops?.[0];
+                if (outcome?.status === "conflict") {
+                    observedEtags.delete(key);
+                    throw new FileConflictError(key, {
+                        ...(outcome.etag === undefined
+                            ? {}
+                            : { storedEtag: normalizeEtag(outcome.etag) ?? outcome.etag }),
+                    });
                 }
-                const etag = observedEtags.get(key);
-                if (etag === undefined) {
+                observedEtags.delete(key);
+                return true;
+            });
+            if (handled) {
+                return;
+            }
+            if (observedEtags.get(key) === undefined) {
+                // Deletes are conditional too, so learn the current etag first. A key
+                // we have never seen is already absent as far as the caller cares.
+                const found = await statKey(key);
+                if (found?.etag === undefined) {
                     return;
                 }
-                yield withFiles((files) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    var _b, _c, _d;
-                    if (files.wire === "flush") {
-                        // The protocol pin appeared between the two withFiles calls; the
-                        // cached etag is enough for the conditional flush delete.
-                        const response = yield flushPost(options, "/flush", {
-                            store: files.store,
-                            ops: [{ op: "delete", path: key, etag }],
-                        });
-                        const outcome = (_a = response.ops) === null || _a === void 0 ? void 0 : _a[0];
-                        if ((outcome === null || outcome === void 0 ? void 0 : outcome.status) === "conflict") {
-                            observedEtags.delete(key);
-                            throw new FileConflictError(key, Object.assign({}, (outcome.etag === undefined
-                                ? {}
-                                : { storedEtag: (_b = normalizeEtag(outcome.etag)) !== null && _b !== void 0 ? _b : outcome.etag })));
-                        }
-                        return;
-                    }
-                    const raw = yield storePost(options, files.path("/delete"), {
-                        files: [{ path: key, etag }],
+            }
+            const etag = observedEtags.get(key);
+            if (etag === undefined) {
+                return;
+            }
+            await withFiles(async (files) => {
+                if (files.wire === "flush") {
+                    // The protocol pin appeared between the two withFiles calls; the
+                    // cached etag is enough for the conditional flush delete.
+                    const response = await flushPost(options, "/flush", {
+                        store: files.store,
+                        ops: [{ op: "delete", path: key, etag }],
                     });
-                    // The API answers 200 with a per-file status, so a lost race would look
-                    // like success unless the outcome is read.
-                    const outcome = ((_c = raw.files) !== null && _c !== void 0 ? _c : []).find(entry => entry.path === key);
-                    if ((outcome === null || outcome === void 0 ? void 0 : outcome.status) === "conflict") {
+                    const outcome = response.ops?.[0];
+                    if (outcome?.status === "conflict") {
                         observedEtags.delete(key);
-                        throw new FileConflictError(key, Object.assign({}, (outcome.etag === undefined
-                            ? {}
-                            : { storedEtag: (_d = normalizeEtag(outcome.etag)) !== null && _d !== void 0 ? _d : outcome.etag })));
+                        throw new FileConflictError(key, {
+                            ...(outcome.etag === undefined
+                                ? {}
+                                : { storedEtag: normalizeEtag(outcome.etag) ?? outcome.etag }),
+                        });
                     }
-                }));
-                observedEtags.delete(key);
+                    return;
+                }
+                const raw = await storePost(options, files.path("/delete"), {
+                    files: [{ path: key, etag }],
+                });
+                // The API answers 200 with a per-file status, so a lost race would look
+                // like success unless the outcome is read.
+                const outcome = (raw.files ?? []).find(entry => entry.path === key);
+                if (outcome?.status === "conflict") {
+                    observedEtags.delete(key);
+                    throw new FileConflictError(key, {
+                        ...(outcome.etag === undefined
+                            ? {}
+                            : { storedEtag: normalizeEtag(outcome.etag) ?? outcome.etag }),
+                    });
+                }
             });
+            observedEtags.delete(key);
         },
         list: listEntries,
-        stat(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield statKey(key);
-            });
+        async stat(key) {
+            return await statKey(key);
         },
     };
 }
@@ -755,7 +739,7 @@ function assertPresignedUrlSafe(options, raw) {
     try {
         url = new URL(raw);
     }
-    catch (_a) {
+    catch {
         throw new Error("cursorHostedFiles: presigned URL is not a valid URL");
     }
     if (url.protocol === "https:" &&
@@ -777,56 +761,53 @@ function assertPresignedUrlSafe(options, raw) {
  * of silently writing to another location.
  */
 function resolveStoreSourceId(options) {
-    var _a, _b;
-    var _c, _d;
-    const id = (_b = ((_d = (_c = (_a = options.resolveStoreSourceId) === null || _a === void 0 ? void 0 : _a.call(options)) !== null && _c !== void 0 ? _c : options.storeSourceId) !== null && _d !== void 0 ? _d : resolveDeploymentStoreSourceIdSync(process.env))) === null || _b === void 0 ? void 0 : _b.trim();
+    const id = (options.resolveStoreSourceId?.() ??
+        options.storeSourceId ??
+        resolveDeploymentStoreSourceIdSync(process.env))?.trim();
     if (id === undefined || id === "") {
         throw new Error(`cursorHostedFiles requires ${AGENT_SERVE_STORE_SOURCE_ID_ENV_VAR} (set on Cursor-managed deployments)`);
     }
     return id;
 }
-const DEV_PRESIGN_HOSTS = new Set(((_a = process.env.CURSOR_HOSTED_FILES_DEV_PRESIGN_HOSTS) !== null && _a !== void 0 ? _a : "")
+const DEV_PRESIGN_HOSTS = new Set((process.env.CURSOR_HOSTED_FILES_DEV_PRESIGN_HOSTS ?? "")
     .split(",")
     .map(host => host.trim().toLowerCase())
     .filter(host => host.length > 0));
 /** Send a file request with the deployment pod credential. */
-function storePost(options, path, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield postJson(options, `${resolveCursorApiBaseUrl(options)}${AGENT_SERVE_FILES_PATH}${path}`, body);
-    });
+async function storePost(options, path, body) {
+    return await postJson(options, `${resolveCursorApiBaseUrl(options)}${AGENT_SERVE_FILES_PATH}${path}`, body);
 }
-function storeGet(options, path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield sendJson(options, `${resolveCursorApiBaseUrl(options)}${AGENT_SERVE_FILES_PATH}${path}`, "GET");
-    });
+async function storeGet(options, path) {
+    return await sendJson(options, `${resolveCursorApiBaseUrl(options)}${AGENT_SERVE_FILES_PATH}${path}`, "GET");
 }
 /** Send a batched file request with the deployment pod credential. */
-function flushPost(options, path, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield postJson(options, `${resolveCursorApiBaseUrl(options)}${AGENTSDK_STORE_PATH}${path}`, body);
-    });
+async function flushPost(options, path, body) {
+    return await postJson(options, `${resolveCursorApiBaseUrl(options)}${AGENTSDK_STORE_PATH}${path}`, body);
 }
-function postJson(options, url, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield sendJson(options, url, "POST", body);
-    });
+async function postJson(options, url, body) {
+    return await sendJson(options, url, "POST", body);
 }
-function sendJson(options, url, method, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield resolveCursorApiFetch(options)(url, Object.assign({ method, headers: Object.assign({ Authorization: `Bearer ${resolveCursorApiKey(options)}` }, (body === undefined ? {} : { "Content-Type": "application/json" })) }, (body === undefined ? {} : { body: JSON.stringify(body) })));
-        const text = yield response.text();
-        let parsed;
-        try {
-            parsed = text.length === 0 ? {} : JSON.parse(text);
-        }
-        catch (_a) {
-            throw new Error(`cursorHostedFiles ${url} returned non-JSON (${response.status})`);
-        }
-        if (!response.ok) {
-            throw new StoreApiError(response.status, `cursorHostedFiles ${url}: ${describeError(parsed, response.status)}`);
-        }
-        return parsed;
+async function sendJson(options, url, method, body) {
+    const response = await resolveCursorApiFetch(options)(url, {
+        method,
+        headers: {
+            Authorization: `Bearer ${resolveCursorApiKey(options)}`,
+            ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
     });
+    const text = await response.text();
+    let parsed;
+    try {
+        parsed = text.length === 0 ? {} : JSON.parse(text);
+    }
+    catch {
+        throw new Error(`cursorHostedFiles ${url} returned non-JSON (${response.status})`);
+    }
+    if (!response.ok) {
+        throw new StoreApiError(response.status, `cursorHostedFiles ${url}: ${describeError(parsed, response.status)}`);
+    }
+    return parsed;
 }
 /**
  * A non-2xx answer from the files API, carrying the status so a caller can