@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/filesystem/walk.js

@@ -4,46 +4,12 @@
  * recursive; `stat` tells file / directory / missing apart; composers
  * merge already-sorted streams with a k-way heap.
  */
-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 __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 import { posix } from "node:path";
 import { minimatch } from "minimatch";
 import { FILE_SYSTEM_SCAN_LIMIT, normalizeFsPath } from "../../filesystem.js";
 import { mergeSorted } from "./merge.js";
 /** Filename-character ingest budget; matches LocalLsExecutor. */
-export const LS_INGEST_CHARACTER_BUDGET = 2500;
+export const LS_INGEST_CHARACTER_BUDGET = 2_500;
 function takeLimit(entries, limit) {
     if (limit === undefined || !Number.isFinite(limit)) {
         return [...entries];
@@ -55,25 +21,23 @@ function takeLimit(entries, limit) {
  * Yield the files under `prefix`, sorted. A file whose path equals
  * `prefix` is not under itself.
  */
-export function listFilesFromPaths(files, prefix, options) {
-    return __asyncGenerator(this, arguments, function* listFilesFromPaths_1() {
-        const scope = normalizeListPrefix(prefix);
-        const withSlash = scope === "/" ? "/" : `${scope}/`;
-        const matches = [];
-        for (const file of files) {
-            const filePath = normalizeFsPath(file.path);
-            if (scope === "/") {
-                matches.push(file.size === undefined ? { path: filePath } : { path: filePath, size: file.size });
-                continue;
-            }
-            if (filePath === scope || !filePath.startsWith(withSlash)) {
-                continue;
-            }
+export async function* listFilesFromPaths(files, prefix, options) {
+    const scope = normalizeListPrefix(prefix);
+    const withSlash = scope === "/" ? "/" : `${scope}/`;
+    const matches = [];
+    for (const file of files) {
+        const filePath = normalizeFsPath(file.path);
+        if (scope === "/") {
             matches.push(file.size === undefined ? { path: filePath } : { path: filePath, size: file.size });
+            continue;
         }
-        matches.sort((left, right) => left.path.localeCompare(right.path));
-        yield __await(yield* __asyncDelegator(__asyncValues(takeLimit(applyIgnores(matches, options === null || options === void 0 ? void 0 : options.excludes), options === null || options === void 0 ? void 0 : options.limit))));
-    });
+        if (filePath === scope || !filePath.startsWith(withSlash)) {
+            continue;
+        }
+        matches.push(file.size === undefined ? { path: filePath } : { path: filePath, size: file.size });
+    }
+    matches.sort((left, right) => left.path.localeCompare(right.path));
+    yield* takeLimit(applyIgnores(matches, options?.excludes), options?.limit);
 }
 export function normalizeListPrefix(prefix) {
     if (prefix === undefined || prefix === "" || prefix === "/") {
@@ -102,80 +66,46 @@ export function statFromFilePaths(files, path) {
     }
     return { kind: "missing" };
 }
-export function collectList(root, prefix, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, e_1, _b, _c;
-        const entries = [];
-        if (root.list === undefined) {
-            return entries;
-        }
-        try {
-            for (var _d = true, _e = __asyncValues(root.list(prefix, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const entry = _c;
-                entries.push(entry);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
+export async function collectList(root, prefix, options) {
+    const entries = [];
+    if (root.list === undefined) {
         return entries;
-    });
+    }
+    for await (const entry of root.list(prefix, options)) {
+        entries.push(entry);
+    }
+    return entries;
 }
-export function collectGlob(root, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, e_2, _b, _c;
-        const entries = [];
-        if (root.glob === undefined) {
-            return entries;
-        }
-        const globOptions = options.limit === undefined ? undefined : { limit: options.limit };
-        try {
-            for (var _d = true, _e = __asyncValues(root.glob(options.pattern, options.dir, globOptions)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const entry = _c;
-                entries.push(entry);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
+export async function collectGlob(root, options) {
+    const entries = [];
+    if (root.glob === undefined) {
         return entries;
-    });
+    }
+    const globOptions = options.limit === undefined ? undefined : { limit: options.limit };
+    for await (const entry of root.glob(options.pattern, options.dir, globOptions)) {
+        entries.push(entry);
+    }
+    return entries;
 }
 /**
  * List, then `stat` only when nothing came back. A non-empty listing is
  * already a directory (a file is not under itself).
  */
-export function collectListOrStat(root, path, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const files = yield collectList(root, path, options);
-        if (files.length > 0) {
-            return { kind: "directory", files };
-        }
-        if (root.stat === undefined) {
-            return { kind: "missing", files };
-        }
-        const probe = path === undefined || path === "" ? "." : path;
-        return { kind: (yield root.stat(probe)).kind, files };
-    });
+export async function collectListOrStat(root, path, options) {
+    const files = await collectList(root, path, options);
+    if (files.length > 0) {
+        return { kind: "directory", files };
+    }
+    if (root.stat === undefined) {
+        return { kind: "missing", files };
+    }
+    const probe = path === undefined || path === "" ? "." : path;
+    return { kind: (await root.stat(probe)).kind, files };
 }
-export function mergeSortedByPath(sources, options) {
-    return __asyncGenerator(this, arguments, function* mergeSortedByPath_1() {
-        yield __await(yield* __asyncDelegator(__asyncValues(mergeSorted(sources, {
-            compare: (left, right) => left.path.localeCompare(right.path),
-            unique: (options === null || options === void 0 ? void 0 : options.unique) === true,
-        }))));
+export async function* mergeSortedByPath(sources, options) {
+    yield* mergeSorted(sources, {
+        compare: (left, right) => left.path.localeCompare(right.path),
+        unique: options?.unique === true,
     });
 }
 function emptyLsNode(absPath) {
@@ -206,7 +136,6 @@ export function buildLsTree(dir, files) {
     return root;
 }
 function addPathToTree(filePath, rootPath, dirNodes, state, characterBudget) {
-    var _a;
     const fileName = posix.basename(filePath);
     const dirPath = posixParent(filePath);
     ensureDirectoryPath(dirPath, rootPath, dirNodes, state.budgetExceeded);
@@ -241,7 +170,7 @@ function addPathToTree(filePath, rootPath, dirNodes, state, characterBudget) {
         const node = dirNodes.get(currentDir);
         if (node !== undefined) {
             node.fullSubtreeExtensionCounts[extension] =
-                ((_a = node.fullSubtreeExtensionCounts[extension]) !== null && _a !== void 0 ? _a : 0) + 1;
+                (node.fullSubtreeExtensionCounts[extension] ?? 0) + 1;
             node.numFiles += 1;
         }
         const parentDir = posixParent(currentDir);
@@ -259,7 +188,10 @@ function ensureDirectoryPath(dirPath, rootPath, dirNodes, budgetExceeded) {
     if (parentPath !== dirPath && pathIsUnderRoot(parentPath, rootPath)) {
         ensureDirectoryPath(parentPath, rootPath, dirNodes, budgetExceeded);
     }
-    const dirNode = Object.assign(Object.assign({}, emptyLsNode(dirPath)), { childrenWereProcessed: !budgetExceeded });
+    const dirNode = {
+        ...emptyLsNode(dirPath),
+        childrenWereProcessed: !budgetExceeded,
+    };
     dirNodes.set(dirPath, dirNode);
     const parentNode = dirNodes.get(parentPath);
     if (parentNode !== undefined) {
@@ -299,30 +231,31 @@ export function isExcludedPath(path, excludes) {
     }
     return excludes.some(glob => matchesIgnoreGlob(path, glob));
 }
-export function lsFromList(root, path, ignoreGlobs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const listed = yield collectListOrStat(root, path, Object.assign({ limit: FILE_SYSTEM_SCAN_LIMIT }, (ignoreGlobs === undefined || ignoreGlobs.length === 0 ? {} : { excludes: ignoreGlobs })));
-        const treePath = path !== null && path !== void 0 ? path : inferListedRoot(listed.files);
-        switch (listed.kind) {
-            case "missing":
-                return {
-                    status: "error",
-                    error: { message: `Path does not exist: ${treePath}` },
-                };
-            case "file":
-                return {
-                    status: "error",
-                    error: { message: `Path is not a directory: ${treePath}` },
-                };
-            case "directory":
-                return {
-                    status: "success",
-                    value: {
-                        directoryTreeRoot: buildLsTree(treePath, applyIgnores(listed.files, ignoreGlobs)),
-                    },
-                };
-        }
+export async function lsFromList(root, path, ignoreGlobs) {
+    const listed = await collectListOrStat(root, path, {
+        limit: FILE_SYSTEM_SCAN_LIMIT,
+        ...(ignoreGlobs === undefined || ignoreGlobs.length === 0 ? {} : { excludes: ignoreGlobs }),
     });
+    const treePath = path ?? inferListedRoot(listed.files);
+    switch (listed.kind) {
+        case "missing":
+            return {
+                status: "error",
+                error: { message: `Path does not exist: ${treePath}` },
+            };
+        case "file":
+            return {
+                status: "error",
+                error: { message: `Path is not a directory: ${treePath}` },
+            };
+        case "directory":
+            return {
+                status: "success",
+                value: {
+                    directoryTreeRoot: buildLsTree(treePath, applyIgnores(listed.files, ignoreGlobs)),
+                },
+            };
+    }
 }
 function inferListedRoot(files) {
     if (files.length === 0) {

package/dist/internal/framework-file-storage.js

@@ -6,15 +6,6 @@
  * access that namespace through `host.kv` or `host.files`. Author KV, evals,
  * and conditional writes remain on the author-facing side of the split.
  */
-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 { AGENTSDK_STORAGE_KEY_ROOT } from "../storage-protocol.js";
 import { mapBounded } from "./bounded.js";
 /**
@@ -69,115 +60,105 @@ function isUnrepresentableFileKey(key) {
  */
 export function fileSinkStorageCore(sink) {
     return {
-        put(key, value) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (isUnrepresentableFileKey(key)) {
-                    // Loud rather than silent: the coordinator logs and drops failed
-                    // mirror writes (at-most-once), and awaited callers must not
-                    // believe an impossible write landed.
-                    throw new Error(`framework file storage: key "${key}" has a path segment the store cannot represent`);
-                }
-                yield sink.put(key, encodeDocument(key, value));
-            });
+        async put(key, value) {
+            if (isUnrepresentableFileKey(key)) {
+                // Loud rather than silent: the coordinator logs and drops failed
+                // mirror writes (at-most-once), and awaited callers must not
+                // believe an impossible write landed.
+                throw new Error(`framework file storage: key "${key}" has a path segment the store cannot represent`);
+            }
+            await sink.put(key, encodeDocument(key, value));
         },
-        putMany(entries) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const results = entries.map(entry => ({
-                    key: entry.key,
-                }));
-                const writable = [];
-                for (let index = 0; index < entries.length; index += 1) {
-                    const entry = entries[index];
-                    if (entry === undefined) {
-                        continue;
-                    }
-                    if (isUnrepresentableFileKey(entry.key)) {
-                        results[index] = {
-                            key: entry.key,
-                            error: new Error(`framework file storage: key "${entry.key}" has a path segment the store cannot represent`),
-                        };
-                        continue;
-                    }
-                    writable.push({
-                        index,
-                        key: entry.key,
-                        body: encodeDocument(entry.key, entry.value),
-                    });
-                }
-                if (writable.length === 0) {
-                    return results;
+        async putMany(entries) {
+            const results = entries.map(entry => ({
+                key: entry.key,
+            }));
+            const writable = [];
+            for (let index = 0; index < entries.length; index += 1) {
+                const entry = entries[index];
+                if (entry === undefined) {
+                    continue;
                 }
-                if (sink.putMany !== undefined) {
-                    // Preserve the sink's batch behavior when it provides one.
-                    const settled = yield sink.putMany(writable.map(({ key, body }) => ({ key, body })));
-                    for (let i = 0; i < writable.length; i += 1) {
-                        const target = writable[i];
-                        const outcome = settled[i];
-                        if (target === undefined) {
-                            continue;
-                        }
-                        if ((outcome === null || outcome === void 0 ? void 0 : outcome.status) === "rejected") {
-                            results[target.index] = { key: target.key, error: outcome.reason };
-                        }
-                    }
-                    return results;
+                if (isUnrepresentableFileKey(entry.key)) {
+                    results[index] = {
+                        key: entry.key,
+                        error: new Error(`framework file storage: key "${entry.key}" has a path segment the store cannot represent`),
+                    };
+                    continue;
                 }
-                // No batch support: sequential puts, preserving the sink's strict
-                // one-at-a-time ordering contract.
-                for (const target of writable) {
-                    try {
-                        yield sink.put(target.key, target.body);
+                writable.push({
+                    index,
+                    key: entry.key,
+                    body: encodeDocument(entry.key, entry.value),
+                });
+            }
+            if (writable.length === 0) {
+                return results;
+            }
+            if (sink.putMany !== undefined) {
+                // Preserve the sink's batch behavior when it provides one.
+                const settled = await sink.putMany(writable.map(({ key, body }) => ({ key, body })));
+                for (let i = 0; i < writable.length; i += 1) {
+                    const target = writable[i];
+                    const outcome = settled[i];
+                    if (target === undefined) {
+                        continue;
                     }
-                    catch (error) {
-                        results[target.index] = { key: target.key, error };
+                    if (outcome?.status === "rejected") {
+                        results[target.index] = { key: target.key, error: outcome.reason };
                     }
                 }
                 return results;
-            });
-        },
-        get(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (isUnrepresentableFileKey(key)) {
-                    return undefined;
+            }
+            // No batch support: sequential puts, preserving the sink's strict
+            // one-at-a-time ordering contract.
+            for (const target of writable) {
+                try {
+                    await sink.put(target.key, target.body);
                 }
-                const body = yield sink.get(key);
-                if (body === undefined) {
-                    return undefined;
+                catch (error) {
+                    results[target.index] = { key: target.key, error };
                 }
-                return decodeDocument(key, body instanceof Uint8Array ? body : body.body);
-            });
+            }
+            return results;
         },
-        delete(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (isUnrepresentableFileKey(key)) {
-                    return;
-                }
-                yield sink.delete(key);
-            });
+        async get(key) {
+            if (isUnrepresentableFileKey(key)) {
+                return undefined;
+            }
+            const body = await sink.get(key);
+            if (body === undefined) {
+                return undefined;
+            }
+            return decodeDocument(key, body instanceof Uint8Array ? body : body.body);
         },
-        list(prefix) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const entries = yield sink.list(prefix);
-                // FileSink.list returns metadata only, so values require separate reads.
-                // Prefer the sink's batch API and otherwise use bounded parallel reads.
-                const bodies = sink.getMany !== undefined
-                    ? yield sink.getMany(entries.map(entry => entry.key))
-                    : yield mapBounded(entries, LIST_READ_CONCURRENCY, entry => sink.get(entry.key));
-                const out = [];
-                for (let index = 0; index < entries.length; index += 1) {
-                    const entry = entries[index];
-                    const body = bodies[index];
-                    if (entry === undefined || body === undefined) {
-                        // Deleted between list and read; a miss is not corruption.
-                        continue;
-                    }
-                    out.push({
-                        key: entry.key,
-                        value: decodeDocument(entry.key, body instanceof Uint8Array ? body : body.body),
-                    });
+        async delete(key) {
+            if (isUnrepresentableFileKey(key)) {
+                return;
+            }
+            await sink.delete(key);
+        },
+        async list(prefix) {
+            const entries = await sink.list(prefix);
+            // FileSink.list returns metadata only, so values require separate reads.
+            // Prefer the sink's batch API and otherwise use bounded parallel reads.
+            const bodies = sink.getMany !== undefined
+                ? await sink.getMany(entries.map(entry => entry.key))
+                : await mapBounded(entries, LIST_READ_CONCURRENCY, entry => sink.get(entry.key));
+            const out = [];
+            for (let index = 0; index < entries.length; index += 1) {
+                const entry = entries[index];
+                const body = bodies[index];
+                if (entry === undefined || body === undefined) {
+                    // Deleted between list and read; a miss is not corruption.
+                    continue;
                 }
-                return out;
-            });
+                out.push({
+                    key: entry.key,
+                    value: decodeDocument(entry.key, body instanceof Uint8Array ? body : body.body),
+                });
+            }
+            return out;
         },
     };
 }
@@ -228,43 +209,41 @@ export function composeFrameworkStorage(input) {
     const route = (key) => isFrameworkFileKey(key) ? input.files : input.kv;
     return {
         put: (key, value, ctx) => route(key).put(key, value, ctx),
-        putMany(entries, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // Partition by destination store, batch each side, and reassemble
-                // per-entry outcomes in input order.
-                const indexed = entries.map((entry, index) => ({ entry, index }));
-                const results = entries.map(entry => ({
-                    key: entry.key,
-                }));
-                for (const core of [input.files, input.kv]) {
-                    const side = indexed.filter(({ entry }) => route(entry.key) === core);
-                    if (side.length === 0) {
-                        continue;
-                    }
-                    if (core.putMany === undefined) {
-                        // No batch write on this side (the KV proxy): sequential puts,
-                        // preserving the strict one-at-a-time ordering it promises.
-                        for (const { entry, index } of side) {
-                            try {
-                                yield core.put(entry.key, entry.value, ctx);
-                            }
-                            catch (error) {
-                                results[index] = { key: entry.key, error };
-                            }
+        async putMany(entries, ctx) {
+            // Partition by destination store, batch each side, and reassemble
+            // per-entry outcomes in input order.
+            const indexed = entries.map((entry, index) => ({ entry, index }));
+            const results = entries.map(entry => ({
+                key: entry.key,
+            }));
+            for (const core of [input.files, input.kv]) {
+                const side = indexed.filter(({ entry }) => route(entry.key) === core);
+                if (side.length === 0) {
+                    continue;
+                }
+                if (core.putMany === undefined) {
+                    // No batch write on this side (the KV proxy): sequential puts,
+                    // preserving the strict one-at-a-time ordering it promises.
+                    for (const { entry, index } of side) {
+                        try {
+                            await core.put(entry.key, entry.value, ctx);
                         }
-                        continue;
-                    }
-                    const settled = yield core.putMany(side.map(({ entry }) => entry), ctx);
-                    for (let i = 0; i < side.length; i += 1) {
-                        const target = side[i];
-                        const outcome = settled[i];
-                        if (target !== undefined && outcome !== undefined) {
-                            results[target.index] = outcome;
+                        catch (error) {
+                            results[index] = { key: entry.key, error };
                         }
                     }
+                    continue;
                 }
-                return results;
-            });
+                const settled = await core.putMany(side.map(({ entry }) => entry), ctx);
+                for (let i = 0; i < side.length; i += 1) {
+                    const target = side[i];
+                    const outcome = settled[i];
+                    if (target !== undefined && outcome !== undefined) {
+                        results[target.index] = outcome;
+                    }
+                }
+            }
+            return results;
         },
         get: (key, ctx) => route(key).get(key, ctx),
         delete: (key, ctx) => route(key).delete(key, ctx),

package/dist/internal/framework-storage-selection.js

@@ -24,17 +24,20 @@ import { resolveAgentV2Hosting } from "./v2-hosting.js";
  * directory is the only copy.
  */
 export function selectFrameworkStorageDefinition(input) {
-    var _a, _b;
     if (input.architecture !== "v2") {
         if (input.authored !== undefined) {
             return input.authored;
         }
-        const env = (_a = input.env) !== null && _a !== void 0 ? _a : process.env;
-        if (((_b = env[AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR]) !== null && _b !== void 0 ? _b : "").trim() !== "") {
+        const env = input.env ?? process.env;
+        if ((env[AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR] ?? "").trim() !== "") {
             // Managed v1 deployment with no authored sink: keep the Cursor-hosted
             // mirror (lazy restore) so agents can delete `agent/storage.ts`
             // without losing durability while they still run architecture v1.
-            return defineStorage(Object.assign({ name: "cursor-hosted (lazy restore)", policy: { restore: "off" } }, cursorHostedStorage()));
+            return defineStorage({
+                name: "cursor-hosted (lazy restore)",
+                policy: { restore: "off" },
+                ...cursorHostedStorage(),
+            });
         }
         return undefined;
     }
@@ -57,18 +60,23 @@ export function selectFrameworkStorageDefinition(input) {
     const policy = {
         restore: "off",
     };
-    const resolveApiKey = () => { var _a; return (_a = resolveApiKeySync()) === null || _a === void 0 ? void 0 : _a.apiKey; };
+    const resolveApiKey = () => resolveApiKeySync()?.apiKey;
     // Author KV, CAS coordination, and evals stay separate from framework-owned
     // session state. Session listing reads the framework side of that split.
     const kv = cursorHostedStorageV2({ resolveApiKey });
-    return defineStorage(Object.assign(Object.assign(Object.assign({ name: "cursor-hosted (framework files)", policy }, kv), composeFrameworkStorage({
-        kv,
-        files: fileSinkStorageCore(cursorHostedFiles({
-            resolveStoreSourceId: () => hosting.resolveStoreIds().frameworkStoreSourceId,
-            resolveApiKey,
-        })),
-    })), { 
+    return defineStorage({
+        name: "cursor-hosted (framework files)",
+        policy,
+        ...kv,
+        ...composeFrameworkStorage({
+            kv,
+            files: fileSinkStorageCore(cursorHostedFiles({
+                resolveStoreSourceId: () => hosting.resolveStoreIds().frameworkStoreSourceId,
+                resolveApiKey,
+            })),
+        }),
         // CAS stays on the KV proxy but must refuse framework-file keys, or a
         // future coordination path would split-brain against the plain core.
-        cas: frameworkGuardedCas(kv.cas) }));
+        cas: frameworkGuardedCas(kv.cas),
+    });
 }