@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/otel/http.js

@@ -7,7 +7,7 @@ const HTTP_SPAN_HANDLE_KEY = Symbol.for("anysphere.july.otel.httpSpanHandle");
 /** End the inbound SERVER span once the Fetch status is known (hosted flush). */
 export function endActiveHttpSpan(statusCode, error) {
     const handle = context.active().getValue(HTTP_SPAN_HANDLE_KEY);
-    handle === null || handle === void 0 ? void 0 : handle.end(statusCode, error);
+    handle?.end(statusCode, error);
 }
 /**
  * Instrument one inbound Node request: SERVER span, W3C extract, auto-end
@@ -29,7 +29,6 @@ export function instrumentHttp(runtime, req, res, fn) {
     return context.with(handle.context.setValue(HTTP_SPAN_HANDLE_KEY, handle), fn);
 }
 function startHttpSpan(runtime, req) {
-    var _a, _b, _c, _d;
     if (runtime === undefined || runtime.config.traces === false) {
         return undefined;
     }
@@ -44,15 +43,15 @@ function startHttpSpan(runtime, req) {
         }
     }
     const parent = propagation.extract(context.active(), headers);
-    const method = (_a = req.method) !== null && _a !== void 0 ? _a : "GET";
-    const path = (_c = ((_b = req.url) !== null && _b !== void 0 ? _b : "/").split("?")[0]) !== null && _c !== void 0 ? _c : "/";
+    const method = req.method ?? "GET";
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
     const started = Date.now();
     const span = runtime.tracer.startSpan("agent_sdk.http", {
         kind: SpanKind.SERVER,
         attributes: {
             "http.request.method": method,
             "url.path": path,
-            "network.peer.address": (_d = req.socket.remoteAddress) !== null && _d !== void 0 ? _d : "",
+            "network.peer.address": req.socket.remoteAddress ?? "",
         },
     }, parent);
     const ctx = trace.setSpan(parent, span);
@@ -60,7 +59,6 @@ function startHttpSpan(runtime, req) {
     return {
         context: ctx,
         end(statusCode, error) {
-            var _a;
             if (ended) {
                 return;
             }
@@ -80,7 +78,7 @@ function startHttpSpan(runtime, req) {
                 span.setStatus({ code: SpanStatusCode.OK });
             }
             span.end();
-            (_a = runtime.httpDuration) === null || _a === void 0 ? void 0 : _a.record(Date.now() - started, {
+            runtime.httpDuration?.record(Date.now() - started, {
                 "http.request.method": method,
                 "http.response.status_code": statusCode,
                 "url.path": routeClass(path),

package/dist/internal/otel/mcp.js

@@ -3,15 +3,6 @@
  * HTTP + SSE fetches, SEP-414 `_meta.traceparent` on JSON-RPC params, and
  * CLIENT spans for `tools/list` / `tools/call`.
  */
-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 { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { activeTraceparent, instrumentedFetch } from "../../otel.js";
 import { attrs } from "./attrs.js";
@@ -37,9 +28,9 @@ export function runMcpClientSpan(args, fn) {
             "agent_sdk.mcp.connection": args.connection,
         }),
     });
-    return context.with(trace.setSpan(context.active(), span), () => __awaiter(this, void 0, void 0, function* () {
+    return context.with(trace.setSpan(context.active(), span), async () => {
         try {
-            return yield fn();
+            return await fn();
         }
         catch (error) {
             span.setStatus({
@@ -51,5 +42,5 @@ export function runMcpClientSpan(args, fn) {
         finally {
             span.end();
         }
-    }));
+    });
 }

package/dist/internal/otel/runtime.js

@@ -5,15 +5,6 @@
  * already owns the process (CLI, extension host, etc.). Spans still use
  * `trace.getTracer()` so they nest under an existing parent when present.
  */
-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 { DiagLogLevel, diag, metrics, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { ExportResultCode } from "@opentelemetry/core";
@@ -38,29 +29,28 @@ const INSTRUMENTATION = "agent_sdk";
  * lands. Bound the exporter wait so a slow collector cannot hold the
  * delivery (OTLP BatchSpanProcessor defaults to 30s).
  */
-export const OTEL_FORCE_FLUSH_TIMEOUT_MS = 1000;
+export const OTEL_FORCE_FLUSH_TIMEOUT_MS = 1_000;
 /**
  * First hosted OTLP POST may include a cold TLS handshake to Datadog.
  * Bound separately from {@link OTEL_FORCE_FLUSH_TIMEOUT_MS} so the
  * queued turn/tool batch is not abandoned after 1s.
  */
-export const OTEL_DEFERRED_EXPORT_TIMEOUT_MS = 5000;
+export const OTEL_DEFERRED_EXPORT_TIMEOUT_MS = 5_000;
 /** Drop oldest finished spans when no collector has drained the buffer. */
-export const OTEL_IN_MEMORY_SPAN_LIMIT = 2048;
+export const OTEL_IN_MEMORY_SPAN_LIMIT = 2_048;
 export function createOtelRuntime(config, log, options) {
-    var _a;
     if (!config.enabled) {
         return undefined;
     }
     if (config.traces !== false) {
         installOutboundFetchInstrumentation();
     }
-    const proto = (_a = process.env.OTEL_EXPORTER_OTLP_PROTOCOL) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+    const proto = process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim().toLowerCase();
     if (proto === "grpc") {
         log("[bdk:otel] OTEL_EXPORTER_OTLP_PROTOCOL=grpc is unsupported; using http/protobuf");
     }
     ensureW3cPropagator();
-    const sdk = startOtelSdk(config, log, options === null || options === void 0 ? void 0 : options.resolveExport);
+    const sdk = startOtelSdk(config, log, options?.resolveExport);
     const meter = config.metrics === false ? undefined : metrics.getMeterProvider().getMeter(INSTRUMENTATION);
     return {
         config,
@@ -77,36 +67,29 @@ export function createOtelRuntime(config, log, options) {
         shutdown: sdk.shutdown,
     };
 }
-export function forceFlushOtelRuntime(runtime) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield runtime === null || runtime === void 0 ? void 0 : runtime.forceFlush();
-    });
+export async function forceFlushOtelRuntime(runtime) {
+    await runtime?.forceFlush();
 }
-export function shutdownOtelRuntime(runtime) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield runtime === null || runtime === void 0 ? void 0 : runtime.shutdown();
-    });
+export async function shutdownOtelRuntime(runtime) {
+    await runtime?.shutdown();
 }
-export function raceOtelForceFlush(work_1, log_1) {
-    return __awaiter(this, arguments, void 0, function* (work, log, timeoutMs = OTEL_FORCE_FLUSH_TIMEOUT_MS) {
-        let timer;
-        const timeout = new Promise(resolve => {
-            timer = setTimeout(() => resolve("timeout"), timeoutMs);
-        });
-        const result = yield Promise.race([
-            work.then(() => "done").catch(() => "done"),
-            timeout,
-        ]);
-        if (timer !== undefined) {
-            clearTimeout(timer);
-        }
-        if (result === "timeout") {
-            log(`[bdk:otel] forceFlush exceeded ${timeoutMs}ms; continuing`);
-        }
+export async function raceOtelForceFlush(work, log, timeoutMs = OTEL_FORCE_FLUSH_TIMEOUT_MS) {
+    let timer;
+    const timeout = new Promise(resolve => {
+        timer = setTimeout(() => resolve("timeout"), timeoutMs);
     });
+    const result = await Promise.race([
+        work.then(() => "done").catch(() => "done"),
+        timeout,
+    ]);
+    if (timer !== undefined) {
+        clearTimeout(timer);
+    }
+    if (result === "timeout") {
+        log(`[bdk:otel] forceFlush exceeded ${timeoutMs}ms; continuing`);
+    }
 }
 function startOtelSdk(config, logger, resolveExport) {
-    var _a, _b;
     diag.setLogger({
         verbose: m => logger(`[bdk:otel] ${m}`),
         debug: m => logger(`[bdk:otel] ${m}`),
@@ -140,7 +123,7 @@ function startOtelSdk(config, logger, resolveExport) {
                 resource,
                 spanProcessors,
                 sampler: new ParentBasedSampler({
-                    root: new TraceIdRatioBasedSampler((_a = traceOpts.sampleRatio) !== null && _a !== void 0 ? _a : 1),
+                    root: new TraceIdRatioBasedSampler(traceOpts.sampleRatio ?? 1),
                 }),
             });
             tracerProvider.register();
@@ -150,7 +133,7 @@ function startOtelSdk(config, logger, resolveExport) {
     if (metricOpts !== false) {
         const exporters = exportersForSignal(config.exporters, "metrics");
         if (exporters.length > 0) {
-            const exportIntervalMillis = (_b = metricOpts.exportIntervalMillis) !== null && _b !== void 0 ? _b : 10000;
+            const exportIntervalMillis = metricOpts.exportIntervalMillis ?? 10_000;
             const provider = new MeterProvider({
                 resource,
                 readers: exporters.map(exporter => new PeriodicExportingMetricReader({
@@ -190,8 +173,7 @@ function startOtelSdk(config, logger, resolveExport) {
     else {
         logger(`[bdk] otel recording service=${config.serviceName} (export on flush when OTLP exporters resolve)`);
     }
-    const flushDeferred = () => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    const flushDeferred = async () => {
         if (memoryExporter === undefined) {
             return;
         }
@@ -199,7 +181,7 @@ function startOtelSdk(config, logger, resolveExport) {
         if (spans.length === 0) {
             return;
         }
-        const exportConfig = (_a = resolveExport === null || resolveExport === void 0 ? void 0 : resolveExport()) !== null && _a !== void 0 ? _a : config;
+        const exportConfig = resolveExport?.() ?? config;
         const destinations = exportersForSignal(exportConfig.exporters, "traces");
         if (destinations.length === 0) {
             return;
@@ -207,30 +189,30 @@ function startOtelSdk(config, logger, resolveExport) {
         // Spans already carry the bake-time Resource. Hosted v2 binds
         // deployment secrets after bake, so env / service extras on
         // exportConfig must replace that Resource on the wire.
-        const ok = yield exportQueuedSpans(spans, destinations, logger, buildResource(exportConfig));
+        const ok = await exportQueuedSpans(spans, destinations, logger, buildResource(exportConfig));
         if (ok) {
             memoryExporter.reset();
         }
-    });
+    };
     return {
-        forceFlush: () => __awaiter(this, void 0, void 0, function* () {
-            yield Promise.allSettled([
+        forceFlush: async () => {
+            await Promise.allSettled([
                 raceOtelForceFlush(Promise.allSettled([
-                    tracerProvider === null || tracerProvider === void 0 ? void 0 : tracerProvider.forceFlush(),
-                    meterProvider === null || meterProvider === void 0 ? void 0 : meterProvider.forceFlush(),
-                    loggerProvider === null || loggerProvider === void 0 ? void 0 : loggerProvider.forceFlush(),
+                    tracerProvider?.forceFlush(),
+                    meterProvider?.forceFlush(),
+                    loggerProvider?.forceFlush(),
                 ]), logger),
                 raceOtelForceFlush(flushDeferred(), logger, OTEL_DEFERRED_EXPORT_TIMEOUT_MS),
             ]);
-        }),
-        shutdown: () => __awaiter(this, void 0, void 0, function* () {
-            yield flushDeferred();
-            yield Promise.allSettled([
-                tracerProvider === null || tracerProvider === void 0 ? void 0 : tracerProvider.shutdown(),
-                meterProvider === null || meterProvider === void 0 ? void 0 : meterProvider.shutdown(),
-                loggerProvider === null || loggerProvider === void 0 ? void 0 : loggerProvider.shutdown(),
+        },
+        shutdown: async () => {
+            await flushDeferred();
+            await Promise.allSettled([
+                tracerProvider?.shutdown(),
+                meterProvider?.shutdown(),
+                loggerProvider?.shutdown(),
             ]);
-        }),
+        },
     };
 }
 function withExportResource(span, resource) {
@@ -243,31 +225,36 @@ function withExportResource(span, resource) {
         },
     });
 }
-function exportQueuedSpans(spans, destinations, logger, resource) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const payload = spans.map(span => withExportResource(span, resource));
-        const exporters = destinations.map(destination => createTraceExporter(destination, signalUrl(destination.url, "traces")));
-        try {
-            const results = yield Promise.all(exporters.map(exporter => new Promise(resolve => {
-                exporter.export(payload, (result) => {
-                    resolve(result.code === ExportResultCode.SUCCESS);
-                });
-            })));
-            return results.every(ok => ok);
-        }
-        catch (error) {
-            logger(`[bdk:otel] deferred export failed: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-        finally {
-            yield Promise.allSettled(exporters.map(exporter => exporter.shutdown()));
-        }
-    });
+async function exportQueuedSpans(spans, destinations, logger, resource) {
+    const payload = spans.map(span => withExportResource(span, resource));
+    const exporters = destinations.map(destination => createTraceExporter(destination, signalUrl(destination.url, "traces")));
+    try {
+        const results = await Promise.all(exporters.map(exporter => new Promise(resolve => {
+            exporter.export(payload, (result) => {
+                resolve(result.code === ExportResultCode.SUCCESS);
+            });
+        })));
+        return results.every(ok => ok);
+    }
+    catch (error) {
+        logger(`[bdk:otel] deferred export failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+    finally {
+        await Promise.allSettled(exporters.map(exporter => exporter.shutdown()));
+    }
 }
 function buildResource(config) {
     // Align with Cursor enterprise wire resource attrs where they overlap so
     // Agent SDK traces join org metrics/logs in the same collector.
-    const resourceAttrs = Object.assign({ [ATTR_SERVICE_NAME]: config.serviceName, "telemetry.sdk.language": "nodejs", "cursor.surface": "unspecified", "cursor.entrypoint": "sdk_ts", "agent_sdk.framework": "@cursor/bdk" }, config.resourceAttributes);
+    const resourceAttrs = {
+        [ATTR_SERVICE_NAME]: config.serviceName,
+        "telemetry.sdk.language": "nodejs",
+        "cursor.surface": "unspecified",
+        "cursor.entrypoint": "sdk_ts",
+        "agent_sdk.framework": "@cursor/bdk",
+        ...config.resourceAttributes,
+    };
     if (config.serviceVersion !== undefined) {
         resourceAttrs[ATTR_SERVICE_VERSION] = config.serviceVersion;
     }
@@ -278,9 +265,8 @@ function signalUrl(base, signal) {
 }
 /** True when a non-noop TracerProvider already owns the process. */
 function hasRealTracerProvider() {
-    var _a;
     const provider = trace.getTracerProvider();
-    const delegate = (_a = provider.getDelegate) === null || _a === void 0 ? void 0 : _a.call(provider);
+    const delegate = provider.getDelegate?.();
     return delegate !== undefined && delegate.constructor.name !== "NoopTracerProvider";
 }
 function isProtobuf(exporter) {

package/dist/internal/package-inline-stdio.js

@@ -2,15 +2,6 @@
  * Package `defineConnection({ tools })` into a `node -e` stdio transport a
  * repo-less cloud VM can spawn.
  */
-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 { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -27,39 +18,41 @@ function jsonSchemaCatalog(tools) {
     const catalog = {};
     for (const [name, tool] of Object.entries(tools)) {
         const outputSchema = toolOutputJsonSchema(tool.outputSchema);
-        catalog[name] = Object.assign({ description: tool.description, inputSchema: toolInputJsonSchema(tool.inputSchema) }, (outputSchema === undefined ? {} : { outputSchema: outputSchema }));
+        catalog[name] = {
+            description: tool.description,
+            inputSchema: toolInputJsonSchema(tool.inputSchema),
+            ...(outputSchema === undefined ? {} : { outputSchema: outputSchema }),
+        };
     }
     return catalog;
 }
-export function packageInlineStdioConnection(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const runtimePath = sibling("inline-stdio-mcp");
-        const stubPath = sibling("inline-stdio-define-stub");
-        const catalog = jsonSchemaCatalog(options.tools);
-        const result = yield esbuild.build({
-            entryPoints: ["inline-stdio-entry"],
-            bundle: true,
-            write: false,
-            platform: "node",
-            format: "esm",
-            target: "node22",
-            minify: true,
-            legalComments: "none",
-            absWorkingDir: options.absWorkingDir,
-            alias: {
-                zod: require.resolve("zod"),
-            },
-            plugins: [
-                {
-                    name: "inline-stdio-entry",
-                    setup(build) {
-                        build.onResolve({ filter: /^inline-stdio-entry$/ }, () => ({
-                            path: "inline-stdio-entry",
-                            namespace: "inline-stdio",
-                        }));
-                        build.onLoad({ filter: /.*/, namespace: "inline-stdio" }, () => ({
-                            contents: `import definition from ${JSON.stringify(options.entryPath)};
+export async function packageInlineStdioConnection(options) {
+    const runtimePath = sibling("inline-stdio-mcp");
+    const stubPath = sibling("inline-stdio-define-stub");
+    const catalog = jsonSchemaCatalog(options.tools);
+    const result = await esbuild.build({
+        entryPoints: ["inline-stdio-entry"],
+        bundle: true,
+        write: false,
+        platform: "node",
+        format: "esm",
+        target: "node22",
+        minify: true,
+        legalComments: "none",
+        absWorkingDir: options.absWorkingDir,
+        alias: {
+            zod: require.resolve("zod"),
+        },
+        plugins: [
+            {
+                name: "inline-stdio-entry",
+                setup(build) {
+                    build.onResolve({ filter: /^inline-stdio-entry$/ }, () => ({
+                        path: "inline-stdio-entry",
+                        namespace: "inline-stdio",
+                    }));
+                    build.onLoad({ filter: /.*/, namespace: "inline-stdio" }, () => ({
+                        contents: `import definition from ${JSON.stringify(options.entryPath)};
 import { serveInlineStdioMcp } from ${JSON.stringify(runtimePath)};
 serveInlineStdioMcp(
   ${JSON.stringify(options.name)},
@@ -67,33 +60,32 @@ serveInlineStdioMcp(
   ${JSON.stringify(catalog)}
 );
 `,
-                            resolveDir: dirname(options.entryPath),
-                            loader: "ts",
-                        }));
-                    },
+                        resolveDir: dirname(options.entryPath),
+                        loader: "ts",
+                    }));
                 },
-                {
-                    name: "inline-stdio-connection-stub",
-                    setup(build) {
-                        build.onResolve({ filter: /^@cursor\/(?:bdk|july)\/connections$/ }, () => ({
-                            path: stubPath,
-                        }));
-                    },
+            },
+            {
+                name: "inline-stdio-connection-stub",
+                setup(build) {
+                    build.onResolve({ filter: /^@cursor\/(?:bdk|july)\/connections$/ }, () => ({
+                        path: stubPath,
+                    }));
                 },
-            ],
-        });
-        const file = (_a = result.outputFiles) === null || _a === void 0 ? void 0 : _a[0];
-        if (file === undefined) {
-            throw new Error(`Failed to package inline stdio MCP connection "${options.name}": esbuild produced no output.`);
-        }
-        const source = file.text.replace(/^#!.*\r?\n/, "");
-        if (source.trim() === "") {
-            throw new Error(`Failed to package inline stdio MCP connection "${options.name}": empty bundle.`);
-        }
-        return {
-            type: "stdio",
-            command: "node",
-            args: ["--input-type=module", "-e", source],
-        };
+            },
+        ],
     });
+    const file = result.outputFiles?.[0];
+    if (file === undefined) {
+        throw new Error(`Failed to package inline stdio MCP connection "${options.name}": esbuild produced no output.`);
+    }
+    const source = file.text.replace(/^#!.*\r?\n/, "");
+    if (source.trim() === "") {
+        throw new Error(`Failed to package inline stdio MCP connection "${options.name}": empty bundle.`);
+    }
+    return {
+        type: "stdio",
+        command: "node",
+        args: ["--input-type=module", "-e", source],
+    };
 }

package/dist/internal/peer-connections.js

@@ -18,14 +18,13 @@ import { MCP_ENDPOINT_PATH } from "./mcp-endpoint.js";
  * self-references (an agent asking itself recurses forever).
  */
 export function collectPeerConnections(mounts) {
-    var _a;
     const knownSlugs = new Set(mounts.map(({ slug }) => slug).filter(slug => slug !== ""));
     const bySlug = new Map();
     for (const { slug, project } of mounts) {
         const refs = [];
         for (const connection of [
             ...project.agent.connections,
-            ...((_a = project.agent.hostConnections) !== null && _a !== void 0 ? _a : []),
+            ...(project.agent.hostConnections ?? []),
         ]) {
             if (!isPeerConnectionTransport(connection.transport)) {
                 continue;
@@ -58,9 +57,14 @@ export function resolvePeerConnections(args) {
     const serverBase = trimTrailingSlash(args.serverUrl);
     const publicBase = args.publicUrl === undefined ? undefined : trimTrailingSlash(args.publicUrl);
     const headers = args.authToken === undefined ? undefined : { authorization: `Bearer ${args.authToken}` };
-    return args.refs.map(ref => (Object.assign(Object.assign({ name: ref.name, localUrl: `${serverBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}` }, (publicBase === undefined
-        ? {}
-        : { cloudUrl: `${publicBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}` })), (headers === undefined ? {} : { headers }))));
+    return args.refs.map(ref => ({
+        name: ref.name,
+        localUrl: `${serverBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}`,
+        ...(publicBase === undefined
+            ? {}
+            : { cloudUrl: `${publicBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}` }),
+        ...(headers === undefined ? {} : { headers }),
+    }));
 }
 function trimTrailingSlash(url) {
     return url.endsWith("/") ? url.slice(0, -1) : url;

package/dist/internal/platform-schedule-sync.js

@@ -3,68 +3,53 @@
  * `agent/schedules/*`. Upsert current names and delete ones that disappeared
  * since the last successful sync (persisted under the engine state root).
  */
-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 { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 export const PLATFORM_SCHEDULE_CATALOG_FILENAME = "platform-schedule-names.json";
-export function syncHostedPlatformSchedules(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const previous = yield readScheduleCatalog(args.catalogPath);
-        const currentNames = args.schedules.map(schedule => schedule.name);
-        const currentSet = new Set(currentNames);
-        const failedDeletes = [];
-        for (const name of previous) {
-            if (currentSet.has(name)) {
-                continue;
-            }
-            try {
-                yield args.timers.deleteSchedule(name);
-            }
-            catch (error) {
-                failedDeletes.push(name);
-                args.logger(`[bdk] platform timer delete failed for schedule "${name}": ${error instanceof Error ? error.message : String(error)}`);
-            }
+export async function syncHostedPlatformSchedules(args) {
+    const previous = await readScheduleCatalog(args.catalogPath);
+    const currentNames = args.schedules.map(schedule => schedule.name);
+    const currentSet = new Set(currentNames);
+    const failedDeletes = [];
+    for (const name of previous) {
+        if (currentSet.has(name)) {
+            continue;
         }
-        for (const schedule of args.schedules) {
-            try {
-                yield args.timers.upsertSchedule({
-                    name: schedule.name,
-                    cron: schedule.cron,
-                });
-            }
-            catch (error) {
-                args.logger(`[bdk] platform timer upsert failed for schedule "${schedule.name}": ${error instanceof Error ? error.message : String(error)}`);
-            }
+        try {
+            await args.timers.deleteSchedule(name);
         }
-        // Keep failed removals in the catalog so the next boot retries them.
-        yield writeScheduleCatalog(args.catalogPath, [...new Set([...currentNames, ...failedDeletes])]);
-    });
-}
-function readScheduleCatalog(catalogPath) {
-    return __awaiter(this, void 0, void 0, function* () {
+        catch (error) {
+            failedDeletes.push(name);
+            args.logger(`[bdk] platform timer delete failed for schedule "${name}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    for (const schedule of args.schedules) {
         try {
-            const parsed = JSON.parse(yield readFile(catalogPath, "utf8"));
-            if (!Array.isArray(parsed)) {
-                return [];
-            }
-            return parsed.filter((entry) => typeof entry === "string");
+            await args.timers.upsertSchedule({
+                name: schedule.name,
+                cron: schedule.cron,
+            });
         }
-        catch (_a) {
+        catch (error) {
+            args.logger(`[bdk] platform timer upsert failed for schedule "${schedule.name}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Keep failed removals in the catalog so the next boot retries them.
+    await writeScheduleCatalog(args.catalogPath, [...new Set([...currentNames, ...failedDeletes])]);
+}
+async function readScheduleCatalog(catalogPath) {
+    try {
+        const parsed = JSON.parse(await readFile(catalogPath, "utf8"));
+        if (!Array.isArray(parsed)) {
             return [];
         }
-    });
+        return parsed.filter((entry) => typeof entry === "string");
+    }
+    catch {
+        return [];
+    }
 }
-function writeScheduleCatalog(catalogPath, names) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield mkdir(dirname(catalogPath), { recursive: true });
-        yield writeFile(catalogPath, `${JSON.stringify(names)}\n`, "utf8");
-    });
+async function writeScheduleCatalog(catalogPath, names) {
+    await mkdir(dirname(catalogPath), { recursive: true });
+    await writeFile(catalogPath, `${JSON.stringify(names)}\n`, "utf8");
 }