@sentry/cloudflare 10.68.0 → 11.0.0-alpha.0

package/build/esm/prod/utils/isBinding.js

@@ -0,0 +1,29 @@
+function isJSRPC(item) {
+  try {
+    return !!item[`__some_property_that_will_never_exist__${Math.random()}`];
+  } catch {
+    return false;
+  }
+}
+const isNotJSRPC = (item) => !isJSRPC(item);
+function isDurableObjectNamespace(item) {
+  return item != null && isNotJSRPC(item) && typeof item.idFromName === "function";
+}
+function isQueue(item) {
+  return item != null && isNotJSRPC(item) && typeof item.send === "function" && typeof item.sendBatch === "function";
+}
+function isD1Database(item) {
+  return item != null && isNotJSRPC(item) && typeof item.prepare === "function" && typeof item.batch === "function" && typeof item.exec === "function";
+}
+function isAiBinding(item) {
+  return item != null && isNotJSRPC(item) && typeof item.run === "function" && typeof item.gateway === "function" && typeof item.toMarkdown === "function";
+}
+function isR2Bucket(item) {
+  return item != null && isNotJSRPC(item) && typeof item.head === "function" && typeof item.put === "function" && typeof item.createMultipartUpload === "function";
+}
+function isRateLimit(item) {
+  return item != null && isNotJSRPC(item) && typeof item.limit === "function";
+}
+
+export { isAiBinding, isD1Database, isDurableObjectNamespace, isJSRPC, isQueue, isR2Bucket, isRateLimit };
+//# sourceMappingURL=isBinding.js.map

package/build/esm/prod/utils/isBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBinding.js","sources":["../../../../src/utils/isBinding.ts"],"sourcesContent":["/**\n * Adapted from https://github.com/evanderkoogh/otel-cf-workers/blob/effeb549f0a4ed1c55ea0c4f0d8e8e37e5494fb3/src/instrumentation/env.ts\n *\n * BSD 3-Clause License\n *\n * Copyright (c) 2023, Erwin van der Koogh\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice, this\n *    list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above copyright notice,\n *    this list of conditions and the following disclaimer in the documentation\n *    and/or other materials provided with the distribution.\n *\n * 3. Neither the name of the copyright holder nor the names of its\n *    contributors may be used to endorse or promote products derived from\n *    this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';\n\n/**\n * Checks if a value is a JSRPC proxy (service binding).\n *\n * JSRPC proxies return a truthy value for ANY property access, including\n * properties that don't exist. This makes other duck-type checks unreliable\n * unless we exclude JSRPC first.\n *\n * Must be checked before other binding type checks.\n */\nexport function isJSRPC(item: unknown): item is Service {\n  try {\n    return !!(item as Record<string, unknown>)[`__some_property_that_will_never_exist__${Math.random()}`];\n  } catch {\n    return false;\n  }\n}\n\nconst isNotJSRPC = (item: unknown): item is Record<string, unknown> => !isJSRPC(item);\n\n/**\n * Duck-type check for DurableObjectNamespace bindings.\n * DurableObjectNamespace has `idFromName`, `idFromString`, `get`, `newUniqueId`.\n */\nexport function isDurableObjectNamespace(item: unknown): item is DurableObjectNamespace {\n  return item != null && isNotJSRPC(item) && typeof item.idFromName === 'function';\n}\n\n/**\n * Duck-type check for Queue producer bindings.\n * Queue has `send` and `sendBatch` async methods.\n */\nexport function isQueue(item: unknown): item is Queue {\n  return item != null && isNotJSRPC(item) && typeof item.send === 'function' && typeof item.sendBatch === 'function';\n}\n\n/**\n * Duck-type check for D1Database bindings.\n * D1Database has `prepare`, `batch`, and `exec` methods.\n */\nexport function isD1Database(item: unknown): item is D1Database {\n  return (\n    item != null &&\n    isNotJSRPC(item) &&\n    typeof item.prepare === 'function' &&\n    typeof item.batch === 'function' &&\n    typeof item.exec === 'function'\n  );\n}\n\n/**\n * Duck-type check for Workers AI bindings.\n * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.\n */\nexport function isAiBinding(item: unknown): item is Ai {\n  return (\n    item != null &&\n    isNotJSRPC(item) &&\n    typeof item.run === 'function' &&\n    typeof item.gateway === 'function' &&\n    typeof item.toMarkdown === 'function'\n  );\n}\n\n/**\n * Duck-type check for R2 Bucket bindings.\n * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.\n */\nexport function isR2Bucket(item: unknown): item is R2Bucket {\n  return (\n    item != null &&\n    isNotJSRPC(item) &&\n    typeof item.head === 'function' &&\n    typeof item.put === 'function' &&\n    typeof item.createMultipartUpload === 'function'\n  );\n}\n\n/**\n * Duck-type check for RateLimit bindings.\n * RateLimit only exposes a single `limit` method. Because that is a fairly\n * common method name, this check is intentionally run after the more specific\n * binding checks (Queue, R2, D1) in `instrumentEnv`, so those win when a binding\n * also happens to expose `limit`.\n */\nexport function isRateLimit(item: unknown): item is RateLimit {\n  return item != null && isNotJSRPC(item) && typeof item.limit === 'function';\n}\n"],"names":[],"mappings":"AA4CO,SAAS,QAAQ,IAAA,EAAgC;AACtD,EAAA,IAAI;AACF,IAAA,OAAO,CAAC,CAAE,IAAA,CAAiC,0CAA0C,IAAA,CAAK,MAAA,EAAQ,CAAA,CAAE,CAAA;AAAA,EACtG,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,KAAA;AAAA,EACT;AACF;AAEA,MAAM,UAAA,GAAa,CAAC,IAAA,KAAmD,CAAC,QAAQ,IAAI,CAAA;AAM7E,SAAS,yBAAyB,IAAA,EAA+C;AACtF,EAAA,OAAO,QAAQ,IAAA,IAAQ,UAAA,CAAW,IAAI,CAAA,IAAK,OAAO,KAAK,UAAA,KAAe,UAAA;AACxE;AAMO,SAAS,QAAQ,IAAA,EAA8B;AACpD,EAAA,OAAO,IAAA,IAAQ,IAAA,IAAQ,UAAA,CAAW,IAAI,CAAA,IAAK,OAAO,IAAA,CAAK,IAAA,KAAS,UAAA,IAAc,OAAO,IAAA,CAAK,SAAA,KAAc,UAAA;AAC1G;AAMO,SAAS,aAAa,IAAA,EAAmC;AAC9D,EAAA,OACE,IAAA,IAAQ,IAAA,IACR,UAAA,CAAW,IAAI,KACf,OAAO,IAAA,CAAK,OAAA,KAAY,UAAA,IACxB,OAAO,IAAA,CAAK,KAAA,KAAU,UAAA,IACtB,OAAO,KAAK,IAAA,KAAS,UAAA;AAEzB;AAMO,SAAS,YAAY,IAAA,EAA2B;AACrD,EAAA,OACE,IAAA,IAAQ,IAAA,IACR,UAAA,CAAW,IAAI,KACf,OAAO,IAAA,CAAK,GAAA,KAAQ,UAAA,IACpB,OAAO,IAAA,CAAK,OAAA,KAAY,UAAA,IACxB,OAAO,KAAK,UAAA,KAAe,UAAA;AAE/B;AAMO,SAAS,WAAW,IAAA,EAAiC;AAC1D,EAAA,OACE,IAAA,IAAQ,IAAA,IACR,UAAA,CAAW,IAAI,KACf,OAAO,IAAA,CAAK,IAAA,KAAS,UAAA,IACrB,OAAO,IAAA,CAAK,GAAA,KAAQ,UAAA,IACpB,OAAO,KAAK,qBAAA,KAA0B,UAAA;AAE1C;AASO,SAAS,YAAY,IAAA,EAAkC;AAC5D,EAAA,OAAO,QAAQ,IAAA,IAAQ,UAAA,CAAW,IAAI,CAAA,IAAK,OAAO,KAAK,KAAA,KAAU,UAAA;AACnE;;;;"}

package/build/esm/prod/utils/isCloudflareClass.js

@@ -0,0 +1,21 @@
+function isCloudflareClass(value, className) {
+  if (!value || typeof value !== "function") {
+    return false;
+  }
+  if (value.name === className) {
+    return false;
+  }
+  let proto = value.prototype;
+  while (proto) {
+    const ctor = proto.constructor;
+    const constructorName = ctor?.name;
+    if (constructorName === className) {
+      return true;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
+}
+
+export { isCloudflareClass };
+//# sourceMappingURL=isCloudflareClass.js.map

package/build/esm/prod/utils/isCloudflareClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCloudflareClass.js","sources":["../../../../src/utils/isCloudflareClass.ts"],"sourcesContent":["import type { DurableObject, WorkflowEntrypoint } from 'cloudflare:workers';\nimport type { WorkerEntrypointConstructor } from '../instrumentations/instrumentWorkerEntrypoint';\ntype CloudflareClassName = 'WorkerEntrypoint' | 'DurableObject' | 'WorkflowEntrypoint';\n\n/**\n * Checks if a class constructor extends a specific Cloudflare base class.\n *\n * Uses prototype chain walking with constructor names rather than instanceof,\n * so it works in Node at build time without requiring the cloudflare:workers\n * module (which only exists in the Workers runtime).\n *\n * This is used to differentiate between different Cloudflare worker types:\n * - WorkerEntrypoint: Class-based workers (used with instrumentWorkerEntrypoint)\n * - DurableObject: Durable Object classes\n * - Workflow: Workflow classes\n *\n * For ExportedHandler (plain objects), this will return false for all types.\n *\n * @param value - The value to check (typically a class constructor)\n * @param className - The Cloudflare base class name to check against\n * @returns true if the value is a class that extends the specified Cloudflare class\n *\n * @example\n * ```ts\n * isCloudflareClass(MyWorker, 'WorkerEntrypoint') // true if MyWorker extends WorkerEntrypoint\n * isCloudflareClass(MyDO, 'DurableObject') // true if MyDO extends DurableObject\n * ```\n */\nexport function isCloudflareClass(\n  value: unknown,\n  className: 'WorkerEntrypoint',\n  // oxlint-disable-next-line typescript/no-explicit-any\n): value is WorkerEntrypointConstructor<any, any>;\nexport function isCloudflareClass(\n  value: unknown,\n  className: 'DurableObject',\n): value is new (...args: unknown[]) => DurableObject;\nexport function isCloudflareClass(\n  value: unknown,\n  className: 'WorkflowEntrypoint',\n): value is new (...args: unknown[]) => WorkflowEntrypoint;\nexport function isCloudflareClass(value: unknown, className: CloudflareClassName): boolean {\n  if (!value || typeof value !== 'function') {\n    return false;\n  }\n\n  if (value.name === className) {\n    return false;\n  }\n\n  let proto: object | null = value.prototype;\n\n  while (proto) {\n    const ctor = (proto as { constructor?: { name?: string } }).constructor;\n    const constructorName = ctor?.name;\n\n    if (constructorName === className) {\n      return true;\n    }\n\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return false;\n}\n"],"names":[],"mappings":"AAyCO,SAAS,iBAAA,CAAkB,OAAgB,SAAA,EAAyC;AACzF,EAAA,IAAI,CAAC,KAAA,IAAS,OAAO,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,KAAA,CAAM,SAAS,SAAA,EAAW;AAC5B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,QAAuB,KAAA,CAAM,SAAA;AAEjC,EAAA,OAAO,KAAA,EAAO;AACZ,IAAA,MAAM,OAAQ,KAAA,CAA8C,WAAA;AAC5D,IAAA,MAAM,kBAAkB,IAAA,EAAM,IAAA;AAE9B,IAAA,IAAI,oBAAoB,SAAA,EAAW;AACjC,MAAA,OAAO,IAAA;AAAA,IACT;AAEA,IAAA,KAAA,GAAQ,MAAA,CAAO,eAAe,KAAK,CAAA;AAAA,EACrC;AAEA,EAAA,OAAO,KAAA;AACT;;;;"}

package/build/esm/prod/utils/rpcMeta.js

@@ -0,0 +1,35 @@
+import { getTraceData, isObjectLike } from '@sentry/core';
+
+const SENTRY_RPC_META_KEY = "__sentry_rpc_meta__";
+function isSentryRpcMeta(value) {
+  if (!isObjectLike(value) || !(SENTRY_RPC_META_KEY in value)) {
+    return false;
+  }
+  return isObjectLike(value[SENTRY_RPC_META_KEY]);
+}
+function appendRpcMeta(args) {
+  const traceData = getTraceData();
+  if (!traceData["sentry-trace"]) {
+    return args;
+  }
+  return [...args, { [SENTRY_RPC_META_KEY]: traceData }];
+}
+function hasRpcMeta(args) {
+  return args.length > 0 && isSentryRpcMeta(args[args.length - 1]);
+}
+function extractRpcMeta(args) {
+  if (args.length === 0) {
+    return { args };
+  }
+  const last = args[args.length - 1];
+  if (isSentryRpcMeta(last)) {
+    return {
+      args: args.slice(0, -1),
+      rpcMeta: last.__sentry_rpc_meta__
+    };
+  }
+  return { args };
+}
+
+export { appendRpcMeta, extractRpcMeta, hasRpcMeta };
+//# sourceMappingURL=rpcMeta.js.map

package/build/esm/prod/utils/rpcMeta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcMeta.js","sources":["../../../../src/utils/rpcMeta.ts"],"sourcesContent":["import { getTraceData, isObjectLike, type SerializedTraceData } from '@sentry/core';\n\n/**\n * Key used to identify Sentry RPC metadata in a trailing argument.\n * This enables transparent trace propagation across Cloudflare Workers RPC\n * calls (Cap'n Proto), which have no native header/metadata support.\n */\nconst SENTRY_RPC_META_KEY = '__sentry_rpc_meta__';\n\ninterface SentryRpcMeta {\n  __sentry_rpc_meta__: SerializedTraceData;\n}\n\nfunction isSentryRpcMeta(value: unknown): value is SentryRpcMeta {\n  if (!isObjectLike(value) || !(SENTRY_RPC_META_KEY in value)) {\n    return false;\n  }\n  return isObjectLike(value[SENTRY_RPC_META_KEY]);\n}\n\n/**\n * Appends Sentry RPC metadata to an args array for trace propagation.\n * If no active trace exists, returns the original args unchanged.\n */\nexport function appendRpcMeta(args: unknown[]): unknown[] {\n  const traceData = getTraceData();\n\n  if (!traceData['sentry-trace']) {\n    return args;\n  }\n\n  return [...args, { [SENTRY_RPC_META_KEY]: traceData }];\n}\n\n/**\n * Whether the trailing argument carries Sentry RPC metadata.\n *\n * Separate from {@link extractRpcMeta} because the RPC method wrappers run this check on every\n * call — including the instance's own internal method calls, which never carry metadata — and\n * must not allocate on that path.\n */\nexport function hasRpcMeta(args: unknown[]): boolean {\n  return args.length > 0 && isSentryRpcMeta(args[args.length - 1]);\n}\n\n/**\n * Extracts Sentry RPC metadata from the trailing argument of an args array.\n * Returns cleaned args (without meta) and the extracted trace data if found.\n */\nexport function extractRpcMeta<T extends unknown[]>(\n  args: T,\n): {\n  args: T;\n  rpcMeta?: SerializedTraceData;\n} {\n  if (args.length === 0) {\n    return { args };\n  }\n\n  const last = args[args.length - 1];\n  if (isSentryRpcMeta(last)) {\n    return {\n      args: args.slice(0, -1) as T,\n      rpcMeta: last.__sentry_rpc_meta__,\n    };\n  }\n\n  return { args };\n}\n"],"names":[],"mappings":";;AAOA,MAAM,mBAAA,GAAsB,qBAAA;AAM5B,SAAS,gBAAgB,KAAA,EAAwC;AAC/D,EAAA,IAAI,CAAC,YAAA,CAAa,KAAK,CAAA,IAAK,EAAE,uBAAuB,KAAA,CAAA,EAAQ;AAC3D,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,YAAA,CAAa,KAAA,CAAM,mBAAmB,CAAC,CAAA;AAChD;AAMO,SAAS,cAAc,IAAA,EAA4B;AACxD,EAAA,MAAM,YAAY,YAAA,EAAa;AAE/B,EAAA,IAAI,CAAC,SAAA,CAAU,cAAc,CAAA,EAAG;AAC9B,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,OAAO,CAAC,GAAG,IAAA,EAAM,EAAE,CAAC,mBAAmB,GAAG,WAAW,CAAA;AACvD;AASO,SAAS,WAAW,IAAA,EAA0B;AACnD,EAAA,OAAO,IAAA,CAAK,SAAS,CAAA,IAAK,eAAA,CAAgB,KAAK,IAAA,CAAK,MAAA,GAAS,CAAC,CAAC,CAAA;AACjE;AAMO,SAAS,eACd,IAAA,EAIA;AACA,EAAA,IAAI,IAAA,CAAK,WAAW,CAAA,EAAG;AACrB,IAAA,OAAO,EAAE,IAAA,EAAK;AAAA,EAChB;AAEA,EAAA,MAAM,IAAA,GAAO,IAAA,CAAK,IAAA,CAAK,MAAA,GAAS,CAAC,CAAA;AACjC,EAAA,IAAI,eAAA,CAAgB,IAAI,CAAA,EAAG;AACzB,IAAA,OAAO;AAAA,MACL,IAAA,EAAM,IAAA,CAAK,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA;AAAA,MACtB,SAAS,IAAA,CAAK;AAAA,KAChB;AAAA,EACF;AAEA,EAAA,OAAO,EAAE,IAAA,EAAK;AAChB;;;;"}

package/build/esm/prod/utils/streaming.js

@@ -0,0 +1,14 @@
+function classifyResponseStreaming(res) {
+  if (!res.body) {
+    return { isStreaming: false };
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  const contentLength = res.headers.get("content-length");
+  if (/^text\/event-stream\b/i.test(contentType) || /^application\/(x-)?ndjson\b/i.test(contentType) || /^application\/stream\+json\b/i.test(contentType) || /^text\/plain\b/i.test(contentType) && !contentLength) {
+    return { isStreaming: true };
+  }
+  return { isStreaming: false };
+}
+
+export { classifyResponseStreaming };
+//# sourceMappingURL=streaming.js.map

package/build/esm/prod/utils/streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.js","sources":["../../../../src/utils/streaming.ts"],"sourcesContent":["export type StreamingGuess = {\n  isStreaming: boolean;\n};\n\n/**\n * Classifies a Response as streaming or non-streaming.\n *\n * Heuristics:\n * - No body → not streaming\n * - Known streaming Content-Types → streaming (SSE, NDJSON, JSON streaming)\n * - text/plain without Content-Length → streaming (some AI APIs)\n * - Otherwise → not streaming (conservative default, including HTML/SSR)\n *\n * We avoid probing the stream to prevent blocking on transform streams (like injectTraceMetaTags)\n * or SSR streams that may not have data ready immediately.\n */\nexport function classifyResponseStreaming(res: Response): StreamingGuess {\n  if (!res.body) {\n    return { isStreaming: false };\n  }\n\n  const contentType = res.headers.get('content-type') ?? '';\n  const contentLength = res.headers.get('content-length');\n\n  // Streaming: Known streaming content types\n  // - text/event-stream: Server-Sent Events (Vercel AI SDK, real-time APIs)\n  // - application/x-ndjson, application/ndjson: Newline-delimited JSON\n  // - application/stream+json: JSON streaming\n  // - text/plain (without Content-Length): Some AI APIs use this for streaming text\n  if (\n    /^text\\/event-stream\\b/i.test(contentType) ||\n    /^application\\/(x-)?ndjson\\b/i.test(contentType) ||\n    /^application\\/stream\\+json\\b/i.test(contentType) ||\n    (/^text\\/plain\\b/i.test(contentType) && !contentLength)\n  ) {\n    return { isStreaming: true };\n  }\n\n  // Default: treat as non-streaming\n  return { isStreaming: false };\n}\n"],"names":[],"mappings":"AAgBO,SAAS,0BAA0B,GAAA,EAA+B;AACvE,EAAA,IAAI,CAAC,IAAI,IAAA,EAAM;AACb,IAAA,OAAO,EAAE,aAAa,KAAA,EAAM;AAAA,EAC9B;AAEA,EAAA,MAAM,WAAA,GAAc,GAAA,CAAI,OAAA,CAAQ,GAAA,CAAI,cAAc,CAAA,IAAK,EAAA;AACvD,EAAA,MAAM,aAAA,GAAgB,GAAA,CAAI,OAAA,CAAQ,GAAA,CAAI,gBAAgB,CAAA;AAOtD,EAAA,IACE,yBAAyB,IAAA,CAAK,WAAW,CAAA,IACzC,8BAAA,CAA+B,KAAK,WAAW,CAAA,IAC/C,+BAAA,CAAgC,IAAA,CAAK,WAAW,CAAA,IAC/C,iBAAA,CAAkB,KAAK,WAAW,CAAA,IAAK,CAAC,aAAA,EACzC;AACA,IAAA,OAAO,EAAE,aAAa,IAAA,EAAK;AAAA,EAC7B;AAGA,EAAA,OAAO,EAAE,aAAa,KAAA,EAAM;AAC9B;;;;"}

package/build/esm/prod/utils/traceLinks.js

@@ -0,0 +1,49 @@
+import { TraceFlags } from '@opentelemetry/api';
+import { debug, SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE, getActiveSpan, spanIsSampled } from '@sentry/core';
+import { DEBUG_BUILD } from '../debug-build.js';
+
+const SENTRY_TRACE_LINK_KEY_PREFIX = "__SENTRY_TRACE_LINK__";
+function getTraceLinkKey(methodName) {
+  return `${SENTRY_TRACE_LINK_KEY_PREFIX}${methodName}`;
+}
+function storeSpanContext(originalStorage, methodName) {
+  try {
+    const activeSpan = getActiveSpan();
+    if (activeSpan) {
+      const spanContext = activeSpan.spanContext();
+      const storedContext = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId,
+        sampled: spanIsSampled(activeSpan)
+      };
+      originalStorage.kv.put(getTraceLinkKey(methodName), storedContext);
+    }
+  } catch (error) {
+    DEBUG_BUILD && debug.log(`[CloudflareClient] Error storing span context for method ${methodName}`, error);
+  }
+}
+function getStoredSpanContext(originalStorage, methodName) {
+  try {
+    return originalStorage.kv.get(getTraceLinkKey(methodName));
+  } catch (error) {
+    DEBUG_BUILD && debug.log(`[CloudflareClient] Error retrieving span context for method ${methodName}`, error);
+    return void 0;
+  }
+}
+function buildSpanLinks(storedContext) {
+  return [
+    {
+      context: {
+        traceId: storedContext.traceId,
+        spanId: storedContext.spanId,
+        traceFlags: storedContext.sampled ? TraceFlags.SAMPLED : TraceFlags.NONE
+      },
+      attributes: {
+        [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: "previous_trace"
+      }
+    }
+  ];
+}
+
+export { buildSpanLinks, getStoredSpanContext, getTraceLinkKey, storeSpanContext };
+//# sourceMappingURL=traceLinks.js.map

package/build/esm/prod/utils/traceLinks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceLinks.js","sources":["../../../../src/utils/traceLinks.ts"],"sourcesContent":["import type { DurableObjectStorage } from '@cloudflare/workers-types';\nimport { TraceFlags } from '@opentelemetry/api';\nimport type { SpanLink } from '@sentry/core';\nimport { debug, getActiveSpan, SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE, spanIsSampled } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\n\n/** Storage key prefix for the span context that links consecutive method invocations */\nconst SENTRY_TRACE_LINK_KEY_PREFIX = '__SENTRY_TRACE_LINK__';\n\n/** Stored span context for creating span links */\nexport interface StoredSpanContext {\n  traceId: string;\n  spanId: string;\n  sampled: boolean;\n}\n\n/**\n * Gets the storage key for a specific method's trace link.\n */\nexport function getTraceLinkKey(methodName: string): string {\n  return `${SENTRY_TRACE_LINK_KEY_PREFIX}${methodName}`;\n}\n\n/**\n * Stores the current span context in Durable Object storage for trace linking.\n * Uses the original uninstrumented storage to avoid creating spans for internal operations.\n * Errors are silently ignored to prevent internal storage failures from propagating to user code.\n */\nexport function storeSpanContext(originalStorage: DurableObjectStorage, methodName: string): void {\n  try {\n    const activeSpan = getActiveSpan();\n    if (activeSpan) {\n      const spanContext = activeSpan.spanContext();\n      const storedContext: StoredSpanContext = {\n        traceId: spanContext.traceId,\n        spanId: spanContext.spanId,\n        sampled: spanIsSampled(activeSpan),\n      };\n\n      originalStorage.kv.put(getTraceLinkKey(methodName), storedContext);\n    }\n  } catch (error) {\n    // Silently ignore storage errors to prevent internal failures from affecting user code\n    DEBUG_BUILD && debug.log(`[CloudflareClient] Error storing span context for method ${methodName}`, error);\n  }\n}\n\n/**\n * Retrieves a stored span context from Durable Object storage.\n * Errors are silently ignored to prevent internal storage failures from propagating to user code.\n */\nexport function getStoredSpanContext(\n  originalStorage: DurableObjectStorage,\n  methodName: string,\n): StoredSpanContext | undefined {\n  try {\n    return originalStorage.kv.get<StoredSpanContext>(getTraceLinkKey(methodName));\n  } catch (error) {\n    // Silently ignore storage errors to prevent internal failures from affecting user code\n    DEBUG_BUILD && debug.log(`[CloudflareClient] Error retrieving span context for method ${methodName}`, error);\n    return undefined;\n  }\n}\n\n/**\n * Builds span links from a stored span context.\n */\nexport function buildSpanLinks(storedContext: StoredSpanContext): SpanLink[] {\n  return [\n    {\n      context: {\n        traceId: storedContext.traceId,\n        spanId: storedContext.spanId,\n        traceFlags: storedContext.sampled ? TraceFlags.SAMPLED : TraceFlags.NONE,\n      },\n      attributes: {\n        [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: 'previous_trace',\n      },\n    },\n  ];\n}\n"],"names":[],"mappings":";;;;AAOA,MAAM,4BAAA,GAA+B,uBAAA;AAY9B,SAAS,gBAAgB,UAAA,EAA4B;AAC1D,EAAA,OAAO,CAAA,EAAG,4BAA4B,CAAA,EAAG,UAAU,CAAA,CAAA;AACrD;AAOO,SAAS,gBAAA,CAAiB,iBAAuC,UAAA,EAA0B;AAChG,EAAA,IAAI;AACF,IAAA,MAAM,aAAa,aAAA,EAAc;AACjC,IAAA,IAAI,UAAA,EAAY;AACd,MAAA,MAAM,WAAA,GAAc,WAAW,WAAA,EAAY;AAC3C,MAAA,MAAM,aAAA,GAAmC;AAAA,QACvC,SAAS,WAAA,CAAY,OAAA;AAAA,QACrB,QAAQ,WAAA,CAAY,MAAA;AAAA,QACpB,OAAA,EAAS,cAAc,UAAU;AAAA,OACnC;AAEA,MAAA,eAAA,CAAgB,EAAA,CAAG,GAAA,CAAI,eAAA,CAAgB,UAAU,GAAG,aAAa,CAAA;AAAA,IACnE;AAAA,EACF,SAAS,KAAA,EAAO;AAEd,IAAA,WAAA,IAAe,KAAA,CAAM,GAAA,CAAI,CAAA,yDAAA,EAA4D,UAAU,IAAI,KAAK,CAAA;AAAA,EAC1G;AACF;AAMO,SAAS,oBAAA,CACd,iBACA,UAAA,EAC+B;AAC/B,EAAA,IAAI;AACF,IAAA,OAAO,eAAA,CAAgB,EAAA,CAAG,GAAA,CAAuB,eAAA,CAAgB,UAAU,CAAC,CAAA;AAAA,EAC9E,SAAS,KAAA,EAAO;AAEd,IAAA,WAAA,IAAe,KAAA,CAAM,GAAA,CAAI,CAAA,4DAAA,EAA+D,UAAU,IAAI,KAAK,CAAA;AAC3G,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAKO,SAAS,eAAe,aAAA,EAA8C;AAC3E,EAAA,OAAO;AAAA,IACL;AAAA,MACE,OAAA,EAAS;AAAA,QACP,SAAS,aAAA,CAAc,OAAA;AAAA,QACvB,QAAQ,aAAA,CAAc,MAAA;AAAA,QACtB,UAAA,EAAY,aAAA,CAAc,OAAA,GAAU,UAAA,CAAW,UAAU,UAAA,CAAW;AAAA,OACtE;AAAA,MACA,UAAA,EAAY;AAAA,QACV,CAAC,iCAAiC,GAAG;AAAA;AACvC;AACF,GACF;AACF;;;;"}

package/build/esm/prod/vendor/stacktrace.js

@@ -0,0 +1,25 @@
+import { createStackParser, nodeStackLineParser, basename } from '@sentry/core';
+
+function workersStackLineParser(getModule2) {
+  const [arg1, arg2] = nodeStackLineParser(getModule2);
+  const fn = (line) => {
+    const result = arg2(line);
+    if (result) {
+      const filename = result.filename;
+      result.abs_path = filename !== void 0 && !filename.startsWith("/") ? `/${filename}` : filename;
+      result.in_app = filename !== void 0;
+    }
+    return result;
+  };
+  return [arg1, fn];
+}
+function getModule(filename) {
+  if (!filename) {
+    return;
+  }
+  return basename(filename, ".js");
+}
+const defaultStackParser = createStackParser(workersStackLineParser(getModule));
+
+export { defaultStackParser, getModule };
+//# sourceMappingURL=stacktrace.js.map

package/build/esm/prod/vendor/stacktrace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stacktrace.js","sources":["../../../../src/vendor/stacktrace.ts"],"sourcesContent":["// Vendored from https://github.com/robertcepa/toucan-js/blob/036568729e49d0a937de527dc32d73580d9a41b3/packages/toucan-js/src/stacktrace.ts\n// Copyright (c) 2022 Robert Cepa\n// SPDX-License-Identifier: MIT\n\nimport type { StackLineParser, StackLineParserFn, StackParser } from '@sentry/core';\nimport { basename, createStackParser, nodeStackLineParser } from '@sentry/core';\n\ntype GetModuleFn = (filename: string | undefined) => string | undefined;\n\n/**\n * Stack line parser for Cloudflare Workers.\n * This wraps node stack parser and adjusts root paths to match with source maps.\n *\n */\nfunction workersStackLineParser(getModule?: GetModuleFn): StackLineParser {\n  const [arg1, arg2] = nodeStackLineParser(getModule);\n\n  const fn: StackLineParserFn = line => {\n    const result = arg2(line);\n    if (result) {\n      const filename = result.filename;\n      // Workers runtime runs a single bundled file that is always in a virtual root\n      result.abs_path = filename !== undefined && !filename.startsWith('/') ? `/${filename}` : filename;\n      // There is no way to tell what code is in_app and what comes from dependencies (node_modules), since we have one bundled file.\n      // So everything is in_app, unless an error comes from runtime function (ie. JSON.parse), which is determined by the presence of filename.\n      result.in_app = filename !== undefined;\n    }\n    return result;\n  };\n\n  return [arg1, fn];\n}\n\n/**\n * Gets the module from filename.\n *\n * @param filename\n * @returns Module name\n */\nexport function getModule(filename: string | undefined): string | undefined {\n  if (!filename) {\n    return;\n  }\n\n  // In Cloudflare Workers there is always only one bundled file\n  return basename(filename, '.js');\n}\n\n/** Cloudflare Workers stack parser */\nexport const defaultStackParser: StackParser = createStackParser(workersStackLineParser(getModule));\n"],"names":["getModule"],"mappings":";;AAcA,SAAS,uBAAuBA,UAAAA,EAA0C;AACxE,EAAA,MAAM,CAAC,IAAA,EAAM,IAAI,CAAA,GAAI,oBAAoBA,UAAS,CAAA;AAElD,EAAA,MAAM,KAAwB,CAAA,IAAA,KAAQ;AACpC,IAAA,MAAM,MAAA,GAAS,KAAK,IAAI,CAAA;AACxB,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,MAAM,WAAW,MAAA,CAAO,QAAA;AAExB,MAAA,MAAA,CAAO,QAAA,GAAW,QAAA,KAAa,MAAA,IAAa,CAAC,QAAA,CAAS,WAAW,GAAG,CAAA,GAAI,CAAA,CAAA,EAAI,QAAQ,CAAA,CAAA,GAAK,QAAA;AAGzF,MAAA,MAAA,CAAO,SAAS,QAAA,KAAa,MAAA;AAAA,IAC/B;AACA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,OAAO,CAAC,MAAM,EAAE,CAAA;AAClB;AAQO,SAAS,UAAU,QAAA,EAAkD;AAC1E,EAAA,IAAI,CAAC,QAAA,EAAU;AACb,IAAA;AAAA,EACF;AAGA,EAAA,OAAO,QAAA,CAAS,UAAU,KAAK,CAAA;AACjC;AAGO,MAAM,kBAAA,GAAkC,iBAAA,CAAkB,sBAAA,CAAuB,SAAS,CAAC;;;;"}

package/build/esm/prod/vite/agentClass.js

@@ -0,0 +1,111 @@
+import { readFileSync } from 'node:fs';
+import { shapeFromAst, DEFAULT_EXPORT, shapeFromSource } from './moduleShape.js';
+
+const AGENT_BASE_CLASSES = {
+  agents: /* @__PURE__ */ new Set(["Agent"]),
+  "agents/mcp": /* @__PURE__ */ new Set(["McpAgent"]),
+  "@cloudflare/ai-chat": /* @__PURE__ */ new Set(["AIChatAgent"]),
+  "@cloudflare/think": /* @__PURE__ */ new Set(["Think"])
+};
+const MAX_DEPTH = 8;
+async function detectAgentClasses(ast, entryId, candidates, resolver) {
+  const ctx = { resolver, modules: /* @__PURE__ */ new Map([[entryId, shapeFromAst(ast)]]) };
+  const detected = /* @__PURE__ */ new Set();
+  for (const name of candidates) {
+    if (await isAgentBinding(ctx, entryId, name, 0, /* @__PURE__ */ new Set())) {
+      detected.add(name);
+    }
+  }
+  return detected;
+}
+function collectAgentCandidates(ast, configuredNames) {
+  const shape = shapeFromAst(ast);
+  const candidates = /* @__PURE__ */ new Set();
+  for (const configured of configuredNames) {
+    if (shape.classes.has(configured)) {
+      candidates.add(configured);
+    }
+    const local = shape.localExports.get(configured);
+    if (local && shape.classes.has(local)) {
+      candidates.add(local);
+    }
+  }
+  return candidates;
+}
+async function isAgentBinding(ctx, moduleId, name, depth, visited) {
+  if (depth > MAX_DEPTH) return false;
+  const key = `${moduleId} ${name}`;
+  if (visited.has(key)) return false;
+  visited.add(key);
+  const shape = await getModuleShape(ctx, moduleId);
+  if (!shape) return false;
+  if (shape.classes.has(name)) {
+    return extendsAgent(ctx, shape, moduleId, shape.classes.get(name), depth, visited);
+  }
+  const imported = shape.imports.get(name);
+  if (imported) {
+    return followImport(ctx, moduleId, imported.source, imported.imported, depth, visited);
+  }
+  if (name === DEFAULT_EXPORT) {
+    if (shape.defaultExportIsClass) {
+      return extendsAgent(ctx, shape, moduleId, shape.defaultExportSuper, depth, visited);
+    }
+    if (shape.defaultExportName) {
+      return isAgentBinding(ctx, moduleId, shape.defaultExportName, depth + 1, visited);
+    }
+  }
+  const localName = shape.localExports.get(name);
+  if (localName) {
+    return isAgentBinding(ctx, moduleId, localName, depth + 1, visited);
+  }
+  const reexport = shape.reexports.get(name);
+  if (reexport) {
+    return followImport(ctx, moduleId, reexport.source, reexport.imported, depth, visited);
+  }
+  for (const source of shape.starExports) {
+    if (await followImport(ctx, moduleId, source, name, depth, visited)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function extendsAgent(ctx, shape, moduleId, superClass, depth, visited) {
+  if (!superClass) return false;
+  if (superClass.kind === "identifier") {
+    return isAgentBinding(ctx, moduleId, superClass.name, depth + 1, visited);
+  }
+  const source = shape.namespaces.get(superClass.object);
+  if (source) {
+    return followImport(ctx, moduleId, source, superClass.property, depth, visited);
+  }
+  return false;
+}
+async function followImport(ctx, importerId, source, importedName, depth, visited) {
+  if (AGENT_BASE_CLASSES[source]?.has(importedName)) return true;
+  if (!ctx.resolver.resolve) return false;
+  let resolved;
+  try {
+    resolved = await ctx.resolver.resolve(source, importerId);
+  } catch {
+    return false;
+  }
+  if (!resolved?.id) return false;
+  if (resolved.id.includes("/node_modules/") || resolved.id.includes("\\node_modules\\")) return false;
+  return isAgentBinding(ctx, resolved.id, importedName, depth + 1, visited);
+}
+async function getModuleShape(ctx, moduleId) {
+  if (ctx.modules.has(moduleId)) return ctx.modules.get(moduleId);
+  let shape;
+  try {
+    const code = ctx.resolver.readFile ? ctx.resolver.readFile(moduleId) : readFileSync(moduleId.replace(/[?#].*$/, ""), "utf8");
+    if (typeof code === "string") {
+      shape = shapeFromSource(code);
+    }
+  } catch {
+  }
+  ctx.modules.set(moduleId, shape);
+  return shape;
+}
+
+export { collectAgentCandidates, detectAgentClasses };
+//# sourceMappingURL=agentClass.js.map

package/build/esm/prod/vite/agentClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentClass.js","sources":["../../../../src/vite/agentClass.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { DEFAULT_EXPORT, type ModuleShape, shapeFromAst, shapeFromSource, type SuperRef } from './moduleShape';\nimport type { ProgramBody } from './transform';\n\n/**\n * Agent base classes, keyed by the module specifier they are imported from. A class extending any\n * of these — directly or through a chain of local/imported subclasses — is an `agents` Agent rather\n * than a plain Durable Object.\n *\n * `McpAgent`, `AIChatAgent` and `Think` all extend `Agent` themselves, but they live in packages\n * whose sources we never walk into (see {@link followImport}), so each needs its own entry.\n */\nconst AGENT_BASE_CLASSES: Record<string, ReadonlySet<string>> = {\n  agents: new Set(['Agent']),\n  'agents/mcp': new Set(['McpAgent']),\n  '@cloudflare/ai-chat': new Set(['AIChatAgent']),\n  '@cloudflare/think': new Set(['Think']),\n};\n\n/**\n * How many modules deep the base-class chain is followed. Guards against pathological module graphs;\n * real Agent hierarchies are only a few levels deep.\n */\nconst MAX_DEPTH = 8;\n\n/**\n * The subset of the Vite/Rollup plugin context needed to walk the module graph.\n *\n * `resolve` is optional: without it detection still works, but only for base-class chains declared\n * inside the entry module itself. `readFile` is injectable for tests and defaults to reading disk.\n *\n * Deliberately **no `load`**: awaiting the plugin context's `load()` from inside a `transform` hook\n * deadlocks the build — the module cannot finish loading while its own transform is still pending\n * (Rollup documents this hazard, and Vite's Rolldown pipeline is stricter still). Sibling modules\n * are therefore read straight off disk; see {@link getModuleShape}.\n */\nexport interface ModuleResolver {\n  parse(code: string): ProgramBody;\n  resolve?(source: string, importer: string): Promise<{ id: string } | null | undefined>;\n  readFile?(id: string): string | undefined;\n}\n\ninterface DetectContext {\n  resolver: ModuleResolver;\n  modules: Map<string, ModuleShape | undefined>;\n}\n\n/**\n * Find which of `candidates` (top-level class names in the entry module) are Cloudflare\n * [`agents`](https://www.npmjs.com/package/agents) Agents.\n *\n * An Agent is a Durable Object under the hood, so wrangler configures it as one and the transform\n * would otherwise reach for `instrumentDurableObjectWithSentry`. Detecting the Agent base chain lets\n * it pick `instrumentAgentWithSentry` instead, which adds the Agent-specific telemetry on top.\n *\n * Unlike `WorkerEntrypoint` detection, the chain is followed *across* modules: base classes commonly\n * live in their own file (`import { MyBase } from './base'`), and there is no runtime fallback that\n * would catch a missed one. Resolution stops at package boundaries — a base class imported from\n * `node_modules` is only recognized when it is one of {@link AGENT_BASE_CLASSES}.\n */\nexport async function detectAgentClasses(\n  ast: ProgramBody,\n  entryId: string,\n  candidates: Iterable<string>,\n  resolver: ModuleResolver,\n): Promise<Set<string>> {\n  // The entry's shape comes from the AST Vite already handed us (TypeScript stripped, full\n  // fidelity); only sibling modules fall back to source scanning.\n  const ctx: DetectContext = { resolver, modules: new Map([[entryId, shapeFromAst(ast)]]) };\n\n  const detected = new Set<string>();\n  for (const name of candidates) {\n    // A fresh cycle guard per candidate: a shared one would record \"not an Agent\" for bindings\n    // visited while resolving an earlier candidate that turned out to be unrelated.\n    if (await isAgentBinding(ctx, entryId, name, 0, new Set())) {\n      detected.add(name);\n    }\n  }\n  return detected;\n}\n\n/**\n * The local class names in the entry that a configured class name could refer to — either declared\n * under that name directly, or aliased to it by an `export { Local as Configured }` specifier.\n *\n * Keeps detection (which reads and scans other modules) off classes that no binding points at.\n */\nexport function collectAgentCandidates(ast: ProgramBody, configuredNames: Iterable<string>): Set<string> {\n  const shape = shapeFromAst(ast);\n  const candidates = new Set<string>();\n\n  for (const configured of configuredNames) {\n    if (shape.classes.has(configured)) {\n      candidates.add(configured);\n    }\n    const local = shape.localExports.get(configured);\n    if (local && shape.classes.has(local)) {\n      candidates.add(local);\n    }\n  }\n\n  return candidates;\n}\n\nasync function isAgentBinding(\n  ctx: DetectContext,\n  moduleId: string,\n  name: string,\n  depth: number,\n  visited: Set<string>,\n): Promise<boolean> {\n  if (depth > MAX_DEPTH) return false;\n\n  const key = `${moduleId} ${name}`;\n  if (visited.has(key)) return false;\n  visited.add(key);\n\n  const shape = await getModuleShape(ctx, moduleId);\n  if (!shape) return false;\n\n  if (shape.classes.has(name)) {\n    return extendsAgent(ctx, shape, moduleId, shape.classes.get(name), depth, visited);\n  }\n\n  const imported = shape.imports.get(name);\n  if (imported) {\n    return followImport(ctx, moduleId, imported.source, imported.imported, depth, visited);\n  }\n\n  if (name === DEFAULT_EXPORT) {\n    if (shape.defaultExportIsClass) {\n      return extendsAgent(ctx, shape, moduleId, shape.defaultExportSuper, depth, visited);\n    }\n    if (shape.defaultExportName) {\n      return isAgentBinding(ctx, moduleId, shape.defaultExportName, depth + 1, visited);\n    }\n  }\n\n  // `export { Local as Requested }` — the caller asked by exported name.\n  const localName = shape.localExports.get(name);\n  if (localName) {\n    return isAgentBinding(ctx, moduleId, localName, depth + 1, visited);\n  }\n\n  const reexport = shape.reexports.get(name);\n  if (reexport) {\n    return followImport(ctx, moduleId, reexport.source, reexport.imported, depth, visited);\n  }\n\n  // Barrel modules (`export * from './base'`) don't name the binding, so every star source is a\n  // candidate home for it.\n  for (const source of shape.starExports) {\n    if (await followImport(ctx, moduleId, source, name, depth, visited)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Whether a superclass reference resolves to an Agent base — a bare identifier (imported, or a\n * subclass declared in the same module) or `ns.Agent` off a namespace import.\n */\nasync function extendsAgent(\n  ctx: DetectContext,\n  shape: ModuleShape,\n  moduleId: string,\n  superClass: SuperRef | undefined,\n  depth: number,\n  visited: Set<string>,\n): Promise<boolean> {\n  if (!superClass) return false;\n\n  if (superClass.kind === 'identifier') {\n    return isAgentBinding(ctx, moduleId, superClass.name, depth + 1, visited);\n  }\n\n  const source = shape.namespaces.get(superClass.object);\n  if (source) {\n    return followImport(ctx, moduleId, source, superClass.property, depth, visited);\n  }\n\n  return false;\n}\n\n/** Resolve an import to its module and continue the search there, stopping at package boundaries. */\nasync function followImport(\n  ctx: DetectContext,\n  importerId: string,\n  source: string,\n  importedName: string,\n  depth: number,\n  visited: Set<string>,\n): Promise<boolean> {\n  if (AGENT_BASE_CLASSES[source]?.has(importedName)) return true;\n\n  if (!ctx.resolver.resolve) return false;\n\n  let resolved: { id: string } | null | undefined;\n  try {\n    resolved = await ctx.resolver.resolve(source, importerId);\n  } catch {\n    return false;\n  }\n  if (!resolved?.id) return false;\n\n  // Third-party sources are not walked: they are large, may not be plain JS by the time we see\n  // them, and any Agent base worth knowing about is listed in AGENT_BASE_CLASSES.\n  if (resolved.id.includes('/node_modules/') || resolved.id.includes('\\\\node_modules\\\\')) return false;\n\n  return isAgentBinding(ctx, resolved.id, importedName, depth + 1, visited);\n}\n\nasync function getModuleShape(ctx: DetectContext, moduleId: string): Promise<ModuleShape | undefined> {\n  if (ctx.modules.has(moduleId)) return ctx.modules.get(moduleId);\n\n  let shape: ModuleShape | undefined;\n  try {\n    const code = ctx.resolver.readFile\n      ? ctx.resolver.readFile(moduleId)\n      : readFileSync(moduleId.replace(/[?#].*$/, ''), 'utf8');\n    if (typeof code === 'string') {\n      shape = shapeFromSource(code);\n    }\n  } catch {\n    // Unreadable or not a source file — treat as \"not an Agent\" rather than failing the build.\n  }\n\n  ctx.modules.set(moduleId, shape);\n  return shape;\n}\n"],"names":[],"mappings":"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"}

package/build/esm/prod/vite/autoInstrument.js

@@ -0,0 +1,92 @@
+import { basename } from 'node:path';
+import { collectAgentCandidates, detectAgentClasses } from './agentClass.js';
+import { resolveInstrumentFile, buildOptionsImport, ENV_FALLBACK_OPTIONS_FN } from './instrumentFile.js';
+import { applyAutoInstrumentTransforms } from './transform.js';
+import { resolveWranglerConfig } from './wranglerConfig.js';
+
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+const JS_EXTENSION_REGEX = /\.[cm]?[jt]sx?$/;
+function sentryCloudflareAutoInstrumentPlugin(options = {}) {
+  let wranglerConfig;
+  let entryFilePath;
+  let optionsFn = ENV_FALLBACK_OPTIONS_FN;
+  let optionsImport;
+  return {
+    name: "sentry-cloudflare-auto-instrument",
+    configResolved(config) {
+      const result = resolveWranglerConfig(config.root, options.wranglerConfigPath);
+      if (!result) {
+        config.logger?.warn(
+          options.wranglerConfigPath ? `[sentry] Could not find or parse the wrangler config "${basename(options.wranglerConfigPath)}" (resolved against the Vite root) \u2014 auto-instrumentation disabled.` : "[sentry] No parseable wrangler config found \u2014 auto-instrumentation disabled. Set `wranglerConfigPath` if your config uses a custom name."
+        );
+        return;
+      }
+      wranglerConfig = result.config;
+      if (wranglerConfig.main) {
+        entryFilePath = normalizePath(wranglerConfig.main);
+      }
+      if (entryFilePath) {
+        const instrumentFilePath = resolveInstrumentFile(entryFilePath);
+        if (instrumentFilePath) {
+          const built = buildOptionsImport(entryFilePath, instrumentFilePath);
+          optionsFn = built.optionsFn;
+          optionsImport = built.importStmt;
+        }
+      }
+    },
+    async transform(code, id) {
+      if (!wranglerConfig || !entryFilePath) return void 0;
+      if (this.environment?.name === "client") return void 0;
+      const normalizedId = normalizePath(id.replace(/[?#].*$/, ""));
+      if (normalizedId !== entryFilePath) {
+        if (!JS_EXTENSION_REGEX.test(normalizedId) || !JS_EXTENSION_REGEX.test(entryFilePath)) return void 0;
+        if (normalizedId.replace(JS_EXTENSION_REGEX, "") !== entryFilePath.replace(JS_EXTENSION_REGEX, "")) {
+          return void 0;
+        }
+      }
+      let ast;
+      try {
+        ast = this.parse(code);
+      } catch {
+        return void 0;
+      }
+      const classWrappers = /* @__PURE__ */ new Map();
+      for (const { className } of wranglerConfig.durableObjects) {
+        classWrappers.set(className, "durableObject");
+      }
+      for (const { className } of wranglerConfig.workflows) {
+        classWrappers.set(className, "workflow");
+      }
+      for (const className of wranglerConfig.workerEntrypoints) {
+        classWrappers.set(className, "workerEntrypoint");
+      }
+      const agentCandidates = collectAgentCandidates(
+        ast,
+        [...classWrappers].filter(([, kind]) => kind === "durableObject").map(([name]) => name)
+      );
+      const agentClasses = agentCandidates.size > 0 ? await detectAgentClasses(ast, normalizedId, agentCandidates, {
+        parse: (code2) => this.parse(code2),
+        resolve: this.resolve ? (source, importer) => this.resolve(source, importer) : void 0
+      }) : void 0;
+      const result = applyAutoInstrumentTransforms(code, ast, {
+        classWrappers,
+        agentClasses,
+        optionsFn,
+        optionsImport
+      });
+      const wrappedClasses = result?.wrappedClasses ?? /* @__PURE__ */ new Set();
+      const missing = [...classWrappers.keys()].filter((name) => !wrappedClasses.has(name));
+      if (missing.length > 0) {
+        this.warn?.(
+          `[sentry] Could not auto-instrument class(es) ${missing.join(", ")}: no matching exported class declaration found in the worker entry (re-exports from other modules cannot be wrapped automatically). Wrap them manually with the matching \`instrument*WithSentry\` helper.`
+        );
+      }
+      return result ?? void 0;
+    }
+  };
+}
+
+export { sentryCloudflareAutoInstrumentPlugin };
+//# sourceMappingURL=autoInstrument.js.map

package/build/esm/prod/vite/autoInstrument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoInstrument.js","sources":["../../../../src/vite/autoInstrument.ts"],"sourcesContent":["import { basename } from 'node:path';\nimport { collectAgentCandidates, detectAgentClasses, type ModuleResolver } from './agentClass';\nimport { buildOptionsImport, ENV_FALLBACK_OPTIONS_FN, resolveInstrumentFile } from './instrumentFile';\nimport { applyAutoInstrumentTransforms, type ClassWrapperKind, type ProgramBody } from './transform';\nimport { resolveWranglerConfig, type WranglerConfig } from './wranglerConfig';\n\n// Vite normalizes module IDs to posix separators even on Windows, while\n// `path.resolve` yields backslashes there — normalize before comparing.\nfunction normalizePath(path: string): string {\n  return path.replace(/\\\\/g, '/');\n}\n\n// Extensions the entry-module match may tolerate swapping (e.g. wrangler's\n// `main` says `.ts` but the served module is `.js`). Anything else — `.css`,\n// `.html`, … — sharing the entry's basename must never be treated as the entry.\nconst JS_EXTENSION_REGEX = /\\.[cm]?[jt]sx?$/;\n\nexport function sentryCloudflareAutoInstrumentPlugin(options: { wranglerConfigPath?: string } = {}) {\n  let wranglerConfig: WranglerConfig | undefined;\n  let entryFilePath: string | undefined;\n\n  let optionsFn = ENV_FALLBACK_OPTIONS_FN;\n  let optionsImport: string | undefined;\n\n  return {\n    name: 'sentry-cloudflare-auto-instrument',\n\n    configResolved(config: { root: string; logger?: { warn(msg: string): void } }): void {\n      const result = resolveWranglerConfig(config.root, options.wranglerConfigPath);\n      if (!result) {\n        // An explicit path that fails is a misconfiguration worth naming;\n        // without one, hint at the option so custom-named configs (e.g. a\n        // `configPath` handed to @cloudflare/vite-plugin) are discoverable.\n        config.logger?.warn(\n          options.wranglerConfigPath\n            ? `[sentry] Could not find or parse the wrangler config \"${basename(options.wranglerConfigPath)}\" ` +\n                '(resolved against the Vite root) — auto-instrumentation disabled.'\n            : '[sentry] No parseable wrangler config found — auto-instrumentation disabled. ' +\n                'Set `wranglerConfigPath` if your config uses a custom name.',\n        );\n        return;\n      }\n\n      wranglerConfig = result.config;\n      if (wranglerConfig.main) {\n        // `main` is already absolute (wrangler resolves it); just normalize\n        // separators so the entry-module comparison holds on Windows.\n        entryFilePath = normalizePath(wranglerConfig.main);\n      }\n\n      if (entryFilePath) {\n        const instrumentFilePath = resolveInstrumentFile(entryFilePath);\n        if (instrumentFilePath) {\n          const built = buildOptionsImport(entryFilePath, instrumentFilePath);\n          optionsFn = built.optionsFn;\n          optionsImport = built.importStmt;\n        }\n      }\n    },\n\n    async transform(\n      this: ModuleResolver & { warn?(msg: string): void; environment?: { name?: string } },\n      code: string,\n      id: string,\n    ): Promise<{ code: string; map: unknown } | undefined> {\n      if (!wranglerConfig || !entryFilePath) return undefined;\n\n      // The worker entry never belongs to the client (browser) environment.\n      // Skipping it keeps a same-basename sibling (e.g. a `src/index.tsx`\n      // client entry next to a `src/index.ts` worker) out of the browser bundle.\n      if (this.environment?.name === 'client') return undefined;\n\n      // Vite may append query/hash params to the module ID.\n      const normalizedId = normalizePath(id.replace(/[?#].*$/, ''));\n      if (normalizedId !== entryFilePath) {\n        // Tolerate a differing JS-flavored extension (e.g. `.js` vs `.ts`).\n        if (!JS_EXTENSION_REGEX.test(normalizedId) || !JS_EXTENSION_REGEX.test(entryFilePath)) return undefined;\n        if (normalizedId.replace(JS_EXTENSION_REGEX, '') !== entryFilePath.replace(JS_EXTENSION_REGEX, '')) {\n          return undefined;\n        }\n      }\n\n      let ast: ProgramBody;\n      try {\n        ast = this.parse(code);\n      } catch {\n        // Raw TypeScript or syntax error — esbuild hasn't run yet (unlikely)\n        // or the file is genuinely broken.  Either way, skip silently.\n        return undefined;\n      }\n\n      const classWrappers = new Map<string, ClassWrapperKind>();\n      for (const { className } of wranglerConfig.durableObjects) {\n        classWrappers.set(className, 'durableObject');\n      }\n      for (const { className } of wranglerConfig.workflows) {\n        classWrappers.set(className, 'workflow');\n      }\n      for (const className of wranglerConfig.workerEntrypoints) {\n        classWrappers.set(className, 'workerEntrypoint');\n      }\n\n      // An `agents` Agent is a Durable Object, so wrangler lists it among the DO bindings and only\n      // its base-class chain tells the two apart. Detection walks the module graph (base classes\n      // usually live in their own file), so it is limited to the configured DO classes.\n      //\n      // Only `resolve` is handed over — never `load`: awaiting `load()` from inside a transform\n      // hook deadlocks the build, since the module can't finish loading while this transform is\n      // still pending. `agentClass` reads sibling modules off disk instead.\n      const agentCandidates = collectAgentCandidates(\n        ast,\n        [...classWrappers].filter(([, kind]) => kind === 'durableObject').map(([name]) => name),\n      );\n      const agentClasses =\n        agentCandidates.size > 0\n          ? await detectAgentClasses(ast, normalizedId, agentCandidates, {\n              parse: code => this.parse(code),\n              resolve: this.resolve ? (source, importer) => this.resolve!(source, importer) : undefined,\n            })\n          : undefined;\n\n      // No registration import is injected here: the orchestrion plugin's\n      // subscribe-injection makes each bundled package self-register its channel\n      // subscriber on the global marker, so wrapping the entry with `withSentry`\n      // is all this plugin needs to do.\n      const result = applyAutoInstrumentTransforms(code, ast, {\n        classWrappers,\n        agentClasses,\n        optionsFn,\n        optionsImport,\n      });\n\n      const wrappedClasses = result?.wrappedClasses ?? new Set<string>();\n      const missing = [...classWrappers.keys()].filter(name => !wrappedClasses.has(name));\n      if (missing.length > 0) {\n        this.warn?.(\n          `[sentry] Could not auto-instrument class(es) ${missing.join(', ')}: no matching exported class ` +\n            'declaration found in the worker entry (re-exports from other modules cannot be wrapped ' +\n            'automatically). Wrap them manually with the matching `instrument*WithSentry` helper.',\n        );\n      }\n\n      return result ?? undefined;\n    },\n  };\n}\n"],"names":["code"],"mappings":"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"}

package/build/esm/prod/vite/index.js

@@ -0,0 +1,14 @@
+import { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/vite';
+import { sentryCloudflareAutoInstrumentPlugin } from './autoInstrument.js';
+
+function sentryCloudflareVitePlugin(options = {}) {
+  return [
+    sentryOrchestrionPlugin({
+      buildTimeInstrumentation: options.buildTimeInstrumentation
+    }),
+    ...options._experimental?.autoInstrumentation ? [sentryCloudflareAutoInstrumentPlugin({ wranglerConfigPath: options.wranglerConfigPath })] : []
+  ];
+}
+
+export { sentryCloudflareVitePlugin };
+//# sourceMappingURL=index.js.map

package/build/esm/prod/vite/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/vite/index.ts"],"sourcesContent":["// Published ESM-only via the `@sentry/cloudflare/vite` subpath export:\n// `@sentry/server-utils/orchestrion/vite` exposes no `require` condition, so a\n// CJS entry here would fail at resolution time (ERR_PACKAGE_PATH_NOT_EXPORTED).\n// The CJS rollup variant still emits this file, but `package.json` doesn't\n// expose it — same setup as `@sentry/server-utils/orchestrion/vite` itself.\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/vite';\nimport { sentryCloudflareAutoInstrumentPlugin } from './autoInstrument';\n\n/**\n * Options for {@link sentryCloudflareVitePlugin}.\n */\nexport interface SentryCloudflareVitePluginOptions {\n  /**\n   * Path to the wrangler config, relative to the Vite root (or absolute).\n   * Set this when your config doesn't use a default name — e.g. when you\n   * pass `configPath: './wrangler.agent.jsonc'` to `@cloudflare/vite-plugin`,\n   * which the Sentry plugin cannot see. When set, only this file is read\n   * (no default-name probing), and a warning is emitted if it is missing or\n   * unparseable.\n   *\n   * @default undefined (probes `wrangler.json`, `wrangler.jsonc`, `wrangler.toml` at the Vite root)\n   */\n  wranglerConfigPath?: string;\n  /**\n   * Build-time automatic instrumentation of supported dependencies (e.g.\n   * database clients like `mysql`) so the Sentry Cloudflare SDK can trace them\n   * without monkey-patching, which wouldn't work in workerd anyway.\n   *\n   * When enabled, the plugin injects `diagnostics_channel.tracingChannel` calls\n   * into the bundled packages and, next to each, a snippet that registers the\n   * matching Sentry channel-subscriber factory on the global marker, which the\n   * SDK picks up in `Sentry.withSentry()`. Both `vite build` and `vite dev` are\n   * instrumented. Set to `false` to opt out.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n  /**\n   * Experimental options that may change or be removed without notice.\n   */\n  _experimental?: {\n    /**\n     * Automatically wraps your Worker at build time so you don't have to edit\n     * your entry: the plugin reads your wrangler config, wraps the default\n     * export with `Sentry.withSentry()` (sourcing options from a co-located\n     * `instrument.*` file, falling back to env), and wraps any configured\n     * Durable Object class with `instrumentDurableObjectWithSentry`. Both\n     * `vite build` and `vite dev` are instrumented.\n     *\n     * @default false\n     * @experimental May change or be removed in any release.\n     */\n    autoInstrumentation?: boolean;\n  };\n}\n\n/**\n * Sentry Vite plugin for Cloudflare Workers.\n *\n * Add this plugin to your Vite configuration to enable additional Sentry\n * instrumentation for Cloudflare Workers built with Vite. Configure the Sentry\n * SDK in your Worker as usual with `Sentry.withSentry()`.\n *\n * By default, the plugin build-time instruments supported dependencies (such as\n * database clients) so they are traced without changing your application code.\n * Opt out with `buildTimeInstrumentation: false`.\n *\n * @example\n * ```ts\n * // vite.config.ts\n * import { cloudflare } from '@cloudflare/vite-plugin';\n * import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';\n * import { defineConfig } from 'vite';\n *\n * export default defineConfig({\n *   plugins: [cloudflare(), sentryCloudflareVitePlugin()],\n * });\n * ```\n */\nexport function sentryCloudflareVitePlugin(options: SentryCloudflareVitePluginOptions = {}): Array<{ name: string }> {\n  return [\n    sentryOrchestrionPlugin({\n      buildTimeInstrumentation: options.buildTimeInstrumentation,\n    }),\n    ...(options._experimental?.autoInstrumentation\n      ? [sentryCloudflareAutoInstrumentPlugin({ wranglerConfigPath: options.wranglerConfigPath })]\n      : []),\n  ];\n}\n"],"names":[],"mappings":";;;AA+EO,SAAS,0BAAA,CAA2B,OAAA,GAA6C,EAAC,EAA4B;AACnH,EAAA,OAAO;AAAA,IACL,uBAAA,CAAwB;AAAA,MACtB,0BAA0B,OAAA,CAAQ;AAAA,KACnC,CAAA;AAAA,IACD,GAAI,OAAA,CAAQ,aAAA,EAAe,mBAAA,GACvB,CAAC,oCAAA,CAAqC,EAAE,kBAAA,EAAoB,OAAA,CAAQ,kBAAA,EAAoB,CAAC,IACzF;AAAC,GACP;AACF;;;;"}

package/build/esm/prod/vite/instrumentFile.js

@@ -0,0 +1,27 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve, relative } from 'node:path';
+
+const ENV_FALLBACK_OPTIONS_FN = "() => undefined";
+const OPTIONS_IMPORT_IDENTIFIER = "__SENTRY_OPTIONS_CALLBACK__";
+const INSTRUMENT_FILE_BASENAME = "instrument.server";
+const INSTRUMENT_FILE_EXTENSIONS = ["ts", "mts", "js", "mjs", "cjs"];
+function resolveInstrumentFile(entryFilePath) {
+  const dir = dirname(entryFilePath);
+  for (const ext of INSTRUMENT_FILE_EXTENSIONS) {
+    const candidate = resolve(dir, `${INSTRUMENT_FILE_BASENAME}.${ext}`);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function buildOptionsImport(entryFilePath, instrumentFilePath) {
+  let relativePath = relative(dirname(entryFilePath), instrumentFilePath).replace(/\\/g, "/");
+  if (!relativePath.startsWith(".")) relativePath = `./${relativePath}`;
+  return {
+    optionsFn: OPTIONS_IMPORT_IDENTIFIER,
+    importStmt: `import ${OPTIONS_IMPORT_IDENTIFIER} from '${relativePath}';
+`
+  };
+}
+
+export { ENV_FALLBACK_OPTIONS_FN, buildOptionsImport, resolveInstrumentFile };
+//# sourceMappingURL=instrumentFile.js.map

package/build/esm/prod/vite/instrumentFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentFile.js","sources":["../../../../src/vite/instrumentFile.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { dirname, relative, resolve } from 'node:path';\n\n// Fallback options callback used when no instrument file is present. Returning\n// `undefined` makes the SDK read all configuration (DSN, release, environment,\n// sample rate, …) from the worker's `env` at runtime.\nexport const ENV_FALLBACK_OPTIONS_FN = '() => undefined';\n\n// Identifier the generated import binds the user's options module to.\nconst OPTIONS_IMPORT_IDENTIFIER = '__SENTRY_OPTIONS_CALLBACK__';\n\n// Conventional, non-configurable name of the Sentry options module. It is\n// looked up next to the worker entry file; its default export is the options\n// callback `(env) => CloudflareOptions`.\nconst INSTRUMENT_FILE_BASENAME = 'instrument.server';\nconst INSTRUMENT_FILE_EXTENSIONS = ['ts', 'mts', 'js', 'mjs', 'cjs'];\n\n/**\n * Locate the conventional `instrument.server.*` module sitting next to the\n * worker entry file. Returns its absolute path, or `undefined` when absent.\n */\nexport function resolveInstrumentFile(entryFilePath: string): string | undefined {\n  const dir = dirname(entryFilePath);\n  for (const ext of INSTRUMENT_FILE_EXTENSIONS) {\n    const candidate = resolve(dir, `${INSTRUMENT_FILE_BASENAME}.${ext}`);\n    if (existsSync(candidate)) return candidate;\n  }\n  return undefined;\n}\n\n/**\n * Build the `optionsFn` reference and `import` statement for the instrument\n * module whose **default export** is the options callback\n * `(env) => CloudflareOptions`.\n *\n * The import is emitted relative to `entryFilePath` because it is injected into\n * the entry file's source. The file extension is kept: extensionless specifiers\n * only resolve for extensions in Vite's default `resolve.extensions` (which\n * excludes `.cjs`), and keeping it makes our probe order authoritative when\n * several `instrument.server.*` files coexist.\n */\nexport function buildOptionsImport(\n  entryFilePath: string,\n  instrumentFilePath: string,\n): { optionsFn: string; importStmt: string } {\n  let relativePath = relative(dirname(entryFilePath), instrumentFilePath).replace(/\\\\/g, '/');\n  if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;\n\n  return {\n    optionsFn: OPTIONS_IMPORT_IDENTIFIER,\n    importStmt: `import ${OPTIONS_IMPORT_IDENTIFIER} from '${relativePath}';\\n`,\n  };\n}\n"],"names":[],"mappings":";;;AAMO,MAAM,uBAAA,GAA0B;AAGvC,MAAM,yBAAA,GAA4B,6BAAA;AAKlC,MAAM,wBAAA,GAA2B,mBAAA;AACjC,MAAM,6BAA6B,CAAC,IAAA,EAAM,KAAA,EAAO,IAAA,EAAM,OAAO,KAAK,CAAA;AAM5D,SAAS,sBAAsB,aAAA,EAA2C;AAC/E,EAAA,MAAM,GAAA,GAAM,QAAQ,aAAa,CAAA;AACjC,EAAA,KAAA,MAAW,OAAO,0BAAA,EAA4B;AAC5C,IAAA,MAAM,YAAY,OAAA,CAAQ,GAAA,EAAK,GAAG,wBAAwB,CAAA,CAAA,EAAI,GAAG,CAAA,CAAE,CAAA;AACnE,IAAA,IAAI,UAAA,CAAW,SAAS,CAAA,EAAG,OAAO,SAAA;AAAA,EACpC;AACA,EAAA,OAAO,MAAA;AACT;AAaO,SAAS,kBAAA,CACd,eACA,kBAAA,EAC2C;AAC3C,EAAA,IAAI,YAAA,GAAe,SAAS,OAAA,CAAQ,aAAa,GAAG,kBAAkB,CAAA,CAAE,OAAA,CAAQ,KAAA,EAAO,GAAG,CAAA;AAC1F,EAAA,IAAI,CAAC,YAAA,CAAa,UAAA,CAAW,GAAG,CAAA,EAAG,YAAA,GAAe,KAAK,YAAY,CAAA,CAAA;AAEnE,EAAA,OAAO;AAAA,IACL,SAAA,EAAW,yBAAA;AAAA,IACX,UAAA,EAAY,CAAA,OAAA,EAAU,yBAAyB,CAAA,OAAA,EAAU,YAAY,CAAA;AAAA;AAAA,GACvE;AACF;;;;"}