@sentry/cloudflare 10.68.0 → 11.0.0-alpha.0

package/build/types/transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,4BAA4B,EAAoB,MAAM,cAAc,CAAC;AAGpH,MAAM,WAAW,0BAA2B,SAAQ,oBAAoB;IACtE,iFAAiF;IACjF,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,iCAAiC;IACjC,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B;AAID;;;;;;;GAOG;AACH,qBAAa,qBAAqB;IAGzB,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,4BAA4B,CAAC,CAAC,CAAC;IAE3D,OAAO,CAAC,cAAc,CAAsD;IAE5E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAElB,WAAW,SAAgC;IAM9D;;OAEG;IACI,GAAG,CAAC,YAAY,EAAE,MAAM,WAAW,CAAC,4BAA4B,CAAC,GAAG,WAAW,CAAC,4BAA4B,CAAC;IASpH;;OAEG;IACI,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC;CA0BrD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,0BAA0B,GAAG,SAAS,CAkCtF"}
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,4BAA4B,EAAoB,MAAM,cAAc,CAAC;AAGpH,MAAM,WAAW,0BAA2B,SAAQ,oBAAoB;IACtE,iFAAiF;IACjF,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,iCAAiC;IACjC,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B;AAID;;;;;;;GAOG;AACH,qBAAa,qBAAqB;IAGzB,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,4BAA4B,CAAC,CAAC,CAAC;IAE3D,OAAO,CAAC,cAAc,CAAsD;IAE5E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC,YAAmB,WAAW,SAAgC,EAI7D;IAED;;OAEG;IACI,GAAG,CAAC,YAAY,EAAE,MAAM,WAAW,CAAC,4BAA4B,CAAC,GAAG,WAAW,CAAC,4BAA4B,CAAC,CAOnH;IAED;;OAEG;IACI,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAyBnD;CACF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,0BAA0B,GAAG,SAAS,CAkCtF"}

package/build/types/types.d.ts

@@ -0,0 +1,85 @@
+import type { env as cloudflareEnv } from 'cloudflare:workers';
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * A handler method of an `ExportedHandler` (`fetch`, `scheduled`, `queue`, ...).
+ */
+type AnyHandlerMethod = (event: any, env: any, ctx: any) => any;
+/**
+ * Structural version of `ExportedHandler` that accepts every env/message/metadata/props
+ * combination. Used as the handler constraint of `withSentry` instead of
+ * `ExportedHandler<any, any, any>`: on `@cloudflare/workers-types` v5, `ExportedHandler`
+ * has a 4th generic (`ExecutionContext<Props>`) which defaults to `unknown`, so a direct
+ * `ExportedHandler<any, any, any>` constraint rejects handlers typed with a concrete
+ * `Props`. Referencing the 4th generic is not an option either — it does not exist on v4,
+ * which the SDK also supports.
+ */
+export interface AnyExportedHandler {
+    fetch?: AnyHandlerMethod;
+    scheduled?: AnyHandlerMethod;
+    queue?: AnyHandlerMethod;
+    email?: AnyHandlerMethod;
+    tail?: AnyHandlerMethod;
+    trace?: AnyHandlerMethod;
+    tailStream?: AnyHandlerMethod;
+    connect?: AnyHandlerMethod;
+    test?: AnyHandlerMethod;
+}
+type HandlerMethodName = keyof AnyExportedHandler;
+/**
+ * Extracts the `Env` type from a handler method signature (its second parameter).
+ * `any` methods are skipped: framework app types like Hono's carry a string index
+ * signature, which would otherwise make every missing handler method read as `any`
+ * and poison the inferred env.
+ */
+type EnvFromMethod<Method> = IsAny<Method> extends true ? never : Method extends (event: any, env: infer Env, ctx: any) => any ? Env : never;
+/**
+ * Extracts the `Env` type from an `ExportedHandler`-shaped type.
+ *
+ * This infers the env from any of the handler methods (`fetch`, `scheduled`, `queue`, ...),
+ * so a handler literal with `satisfies ExportedHandler<Env>` or a pre-typed
+ * `ExportedHandler<Env>` both yield their `Env`. The structural read (instead of
+ * `T extends ExportedHandler<infer Env, ...>`) keeps inference working for
+ * `ExecutionContext<Props>`-typed handlers on workers-types v5.
+ */
+type InferEnvFromHandler<T> = T extends AnyExportedHandler ? {
+    [K in HandlerMethodName]: K extends keyof T ? EnvFromMethod<T[K]> : never;
+}[HandlerMethodName] : never;
+/**
+ * Extracts the `Env` type from a class constructor type (`WorkerEntrypoint`, `DurableObject`
+ * or `WorkflowEntrypoint` subclasses). The env is inferred from the second constructor parameter,
+ * which carries the user's env type both for explicit constructors and for constructors inherited
+ * from a `WorkerEntrypoint<Env>` / `DurableObject<Env>` / `WorkflowEntrypoint<Env>` base class.
+ */
+type InferEnvFromConstructor<T> = T extends new (ctx: any, env: infer Env) => any ? Env : never;
+/**
+ * Infers the `Env` type from a handler passed to one of the instrumentation functions.
+ * Returns `never` when nothing can be inferred.
+ */
+export type InferEnv<T> = [InferEnvFromHandler<T>] extends [never] ? InferEnvFromConstructor<T> : InferEnvFromHandler<T>;
+/**
+ * Removes empty object types (`{}`) from a union. Framework handler types like Hono's
+ * `fetch(request, env?: E['Bindings'] | {}, ...)` union the env with `{}`, which would
+ * otherwise collapse the inferred env to "empty" — filtering keeps the meaningful member.
+ */
+type FilterEmptyObjects<T> = T extends any ? ([keyof T] extends [never] ? never : T) : never;
+/**
+ * Resolves the env type exposed on the options callback of the instrumentation functions.
+ *
+ * Resolution order:
+ * 1. The env inferred from the passed handler (e.g. via `satisfies ExportedHandler<Env>`,
+ *    a pre-typed handler, or a `WorkerEntrypoint<Env>` subclass).
+ * 2. The explicitly provided `Env` generic (e.g. `withSentry<Env>(...)`), which defaults
+ *    to the wrangler-generated `Cloudflare.Env` (via `typeof cloudflareEnv`).
+ * 3. `any` as the last resort, so untyped setups keep compiling instead of failing on
+ *    an empty `Cloudflare.Env` interface.
+ */
+export type ResolveEnv<Handler, ExplicitEnv> = IsAny<FilterEmptyObjects<InferEnv<Handler>>> extends true ? ExplicitEnv : unknown extends FilterEmptyObjects<InferEnv<Handler>> ? ExplicitEnv : [FilterEmptyObjects<InferEnv<Handler>>] extends [never] ? ExplicitEnv : FilterEmptyObjects<InferEnv<Handler>>;
+/**
+ * The default env type when nothing can be inferred and no explicit generic is provided:
+ * the wrangler-generated `Cloudflare.Env` (via `cloudflare:workers`), falling back to `any`
+ * when the project never ran `wrangler types` (the interface is empty) so property access
+ * on `env` does not fail.
+ */
+export type DefaultEnv = [keyof typeof cloudflareEnv] extends [never] ? any : typeof cloudflareEnv;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/build/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE/D,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAE/C;;GAEG;AAEH,KAAK,gBAAgB,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB;AAED,KAAK,iBAAiB,GAAG,MAAM,kBAAkB,CAAC;AAElD;;;;;GAKG;AAEH,KAAK,aAAa,CAAC,MAAM,IACvB,KAAK,CAAC,MAAM,CAAC,SAAS,IAAI,GACtB,KAAK,GAEL,MAAM,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,GAAG,GAC1D,GAAG,GACH,KAAK,CAAC;AAEd;;;;;;;;GAQG;AACH,KAAK,mBAAmB,CAAC,CAAC,IAAI,CAAC,SAAS,kBAAkB,GACtD;KACG,CAAC,IAAI,iBAAiB,GAAG,CAAC,SAAS,MAAM,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK;CAC1E,CAAC,iBAAiB,CAAC,GACpB,KAAK,CAAC;AAEV;;;;;GAKG;AAEH,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC;AAEhG;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC9D,uBAAuB,CAAC,CAAC,CAAC,GAC1B,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE3B;;;;GAIG;AAEH,KAAK,kBAAkB,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;AAE7F;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,EAAE,WAAW,IACzC,KAAK,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrD,WAAW,GACX,OAAO,SAAS,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GACnD,WAAW,GACX,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACrD,WAAW,GACX,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,OAAO,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,GAEjE,GAAG,GACH,OAAO,aAAa,CAAC"}

package/build/types/utils/instrumentContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentContext.d.ts","sourceRoot":"","sources":["../../../src/utils/instrumentContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA6B,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAGtH,KAAK,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;AAGzD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAgDlE"}
+{"version":3,"file":"instrumentContext.d.ts","sourceRoot":"","sources":["../../../src/utils/instrumentContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA6B,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAGtH,KAAK,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;AAGzD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CA6ClE"}

package/build/types/utils/internalSqlQuery.d.ts

@@ -12,7 +12,9 @@
  *
  * The check operates on the query summary produced by `getSqlQuerySummary` (`{operation} {table} ...`,
  * the same value used as the span name), so table targets are already isolated from the rest of the
- * query.
+ * query. The one exception is `CREATE INDEX`: its summary carries the index name, not the indexed
+ * table (upstream OTel convention), so the `cf_` target only appears in the ON clause of the full
+ * statement, which `queryText` is needed for.
  */
-export declare function targetsCloudflareInternalTable(querySummary: string | undefined, allowlist?: Array<string | RegExp>): boolean;
+export declare function targetsCloudflareInternalTable(querySummary: string | undefined, allowlist?: Array<string | RegExp>, queryText?: string): boolean;
 //# sourceMappingURL=internalSqlQuery.d.ts.map

package/build/types/utils/internalSqlQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internalSqlQuery.d.ts","sourceRoot":"","sources":["../../../src/utils/internalSqlQuery.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GACjC,OAAO,CAgBT"}
+{"version":3,"file":"internalSqlQuery.d.ts","sourceRoot":"","sources":["../../../src/utils/internalSqlQuery.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAClC,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAaT"}

package/build/types/utils/internalStorageKey.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cloudflare frameworks that build on Durable Objects (`agents`, `partyserver`, ...) also manage
+ * their own internal KV entries alongside their internal SQLite tables, namespaced with a reserved
+ * prefix — e.g. `cf_agents_state`, `cf_agents_mcp_servers`, `__ps_name`. Reads/writes of these
+ * (message persistence, MCP connection bookkeeping, name hydration) are framework implementation
+ * details that otherwise flood traces with dozens of zero-signal `durable_object_storage_*` spans
+ * per request, so we match the reserved prefixes rather than an enumerated list. This mirrors the
+ * `cf_` convention used for internal SQL tables (see `targetsCloudflareInternalTable`).
+ *
+ * The prefixes are a reserved convention for framework-managed entries, so user keys should not use
+ * them. In case a user key does collide, the `durableObjectStorageSpanAllowlist` option lets them
+ * opt those keys back into instrumentation.
+ */
+export declare function targetsCloudflareInternalKey(key: string | undefined, allowlist?: Array<string | RegExp>): boolean;
+/**
+ * Extracts the KV keys a Durable Object storage call targets, so the caller can decide whether the
+ * operation only touches framework-internal entries. Returns `undefined` when the keys can't be
+ * determined from the arguments (e.g. `list()` without a prefix), in which case the call is treated
+ * as user work and stays instrumented.
+ */
+export declare function getStorageKeys(methodName: string, args: unknown[]): string[] | undefined;
+//# sourceMappingURL=internalStorageKey.d.ts.map

package/build/types/utils/internalStorageKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalStorageKey.d.ts","sourceRoot":"","sources":["../../../src/utils/internalStorageKey.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAsBjH;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS,CAgCxF"}

package/build/types/utils/invocationScope.d.ts

@@ -0,0 +1,24 @@
+import { type Scope } from '@sentry/core';
+/**
+ * Runs `callback` on the isolation scope for the current invocation.
+ *
+ * An instrumented handler is either the entry point of an invocation or reentrant — reached from
+ * another instrumented handler already serving the same invocation (a Durable Object method calling
+ * its own `fetch`, an RPC method reaching a sibling method). Only the entry point may fork:
+ *
+ * - Forking at the entry point is mandatory. `setUser`/`setTag` write to the isolation scope, and a
+ *   Durable Object's isolation scope outlives the invocation that touched it, so without a fork one
+ *   invocation's user and tags reappear on the next invocation's events in the same isolate.
+ *   Forking clones, so request data set by an enclosing wrapper is still inherited.
+ * - Forking again when reentrant would be wrong. Everything below the entry point is one logical
+ *   unit of work: a nested call must see what the caller set and be able to add to it, the way it
+ *   would if the SDK were not wrapping it at all.
+ *
+ * The AsyncLocalStorage strategy hands the default isolation scope back whenever no invocation is in
+ * flight, and a forked one while inside `withIsolationScope`. Reference-comparing against the default
+ * is therefore enough to tell the two cases apart. The stack fallback does not fork, so it reports the
+ * default scope even inside an invocation; there the fork degrades to a no-op, which the stack strategy
+ * tolerates. This matches the approach used by `patchEventHandler` in Nuxt.
+ */
+export declare function withInvocationIsolationScope<T>(callback: (scope: Scope) => T): T;
+//# sourceMappingURL=invocationScope.d.ts.map

package/build/types/utils/invocationScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocationScope.d.ts","sourceRoot":"","sources":["../../../src/utils/invocationScope.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+C,KAAK,KAAK,EAAsB,MAAM,cAAc,CAAC;AAE3G;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,CAAC,GAAG,CAAC,CAMhF"}

package/build/types/utils/isCloudflareClass.d.ts

@@ -24,7 +24,7 @@ import type { WorkerEntrypointConstructor } from '../instrumentations/instrument
  * isCloudflareClass(MyDO, 'DurableObject') // true if MyDO extends DurableObject
  * ```
  */
-export declare function isCloudflareClass(value: unknown, className: 'WorkerEntrypoint'): value is WorkerEntrypointConstructor;
+export declare function isCloudflareClass(value: unknown, className: 'WorkerEntrypoint'): value is WorkerEntrypointConstructor<any, any>;
 export declare function isCloudflareClass(value: unknown, className: 'DurableObject'): value is new (...args: unknown[]) => DurableObject;
 export declare function isCloudflareClass(value: unknown, className: 'WorkflowEntrypoint'): value is new (...args: unknown[]) => WorkflowEntrypoint;
 //# sourceMappingURL=isCloudflareClass.d.ts.map

package/build/types/utils/isCloudflareClass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isCloudflareClass.d.ts","sourceRoot":"","sources":["../../../src/utils/isCloudflareClass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAGlG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,kBAAkB,GAAG,KAAK,IAAI,2BAA2B,CAAC;AACvH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,eAAe,GACzB,KAAK,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,aAAa,CAAC;AACtD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,oBAAoB,GAC9B,KAAK,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,kBAAkB,CAAC"}
+{"version":3,"file":"isCloudflareClass.d.ts","sourceRoot":"","sources":["../../../src/utils/isCloudflareClass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAGlG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,kBAAkB,GAE5B,KAAK,IAAI,2BAA2B,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AAClD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,eAAe,GACzB,KAAK,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,aAAa,CAAC;AACtD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,oBAAoB,GAC9B,KAAK,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,kBAAkB,CAAC"}

package/build/types/utils/rpcMeta.d.ts

@@ -4,6 +4,14 @@ import { type SerializedTraceData } from '@sentry/core';
  * If no active trace exists, returns the original args unchanged.
  */
 export declare function appendRpcMeta(args: unknown[]): unknown[];
+/**
+ * Whether the trailing argument carries Sentry RPC metadata.
+ *
+ * Separate from {@link extractRpcMeta} because the RPC method wrappers run this check on every
+ * call — including the instance's own internal method calls, which never carry metadata — and
+ * must not allocate on that path.
+ */
+export declare function hasRpcMeta(args: unknown[]): boolean;
 /**
  * Extracts Sentry RPC metadata from the trailing argument of an args array.
  * Returns cleaned args (without meta) and the extracted trace data if found.

package/build/types/utils/rpcMeta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpcMeta.d.ts","sourceRoot":"","sources":["../../../src/utils/rpcMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAoBpF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAQxD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,EAChD,IAAI,EAAE,CAAC,GACN;IACD,IAAI,EAAE,CAAC,CAAC;IACR,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,CAcA"}
+{"version":3,"file":"rpcMeta.d.ts","sourceRoot":"","sources":["../../../src/utils/rpcMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAoBpF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAQxD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAEnD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,EAChD,IAAI,EAAE,CAAC,GACN;IACD,IAAI,EAAE,CAAC,CAAC;IACR,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,CAcA"}

package/build/types/vite/agentClass.d.ts

@@ -0,0 +1,41 @@
+import type { ProgramBody } from './transform';
+/**
+ * The subset of the Vite/Rollup plugin context needed to walk the module graph.
+ *
+ * `resolve` is optional: without it detection still works, but only for base-class chains declared
+ * inside the entry module itself. `readFile` is injectable for tests and defaults to reading disk.
+ *
+ * Deliberately **no `load`**: awaiting the plugin context's `load()` from inside a `transform` hook
+ * deadlocks the build — the module cannot finish loading while its own transform is still pending
+ * (Rollup documents this hazard, and Vite's Rolldown pipeline is stricter still). Sibling modules
+ * are therefore read straight off disk; see {@link getModuleShape}.
+ */
+export interface ModuleResolver {
+    parse(code: string): ProgramBody;
+    resolve?(source: string, importer: string): Promise<{
+        id: string;
+    } | null | undefined>;
+    readFile?(id: string): string | undefined;
+}
+/**
+ * Find which of `candidates` (top-level class names in the entry module) are Cloudflare
+ * [`agents`](https://www.npmjs.com/package/agents) Agents.
+ *
+ * An Agent is a Durable Object under the hood, so wrangler configures it as one and the transform
+ * would otherwise reach for `instrumentDurableObjectWithSentry`. Detecting the Agent base chain lets
+ * it pick `instrumentAgentWithSentry` instead, which adds the Agent-specific telemetry on top.
+ *
+ * Unlike `WorkerEntrypoint` detection, the chain is followed *across* modules: base classes commonly
+ * live in their own file (`import { MyBase } from './base'`), and there is no runtime fallback that
+ * would catch a missed one. Resolution stops at package boundaries — a base class imported from
+ * `node_modules` is only recognized when it is one of {@link AGENT_BASE_CLASSES}.
+ */
+export declare function detectAgentClasses(ast: ProgramBody, entryId: string, candidates: Iterable<string>, resolver: ModuleResolver): Promise<Set<string>>;
+/**
+ * The local class names in the entry that a configured class name could refer to — either declared
+ * under that name directly, or aliased to it by an `export { Local as Configured }` specifier.
+ *
+ * Keeps detection (which reads and scans other modules) off classes that no binding points at.
+ */
+export declare function collectAgentCandidates(ast: ProgramBody, configuredNames: Iterable<string>): Set<string>;
+//# sourceMappingURL=agentClass.d.ts.map

package/build/types/vite/agentClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentClass.d.ts","sourceRoot":"","sources":["../../../src/vite/agentClass.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAuB/C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IACjC,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IACvF,QAAQ,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC3C;AAOD;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC5B,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CActB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,WAAW,EAAE,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAevG"}

package/build/types/vite/autoInstrument.d.ts

@@ -1,5 +1,7 @@
-import { type ProgramBody } from './transform';
-export declare function sentryCloudflareAutoInstrumentPlugin(): {
+import { type ModuleResolver } from './agentClass';
+export declare function sentryCloudflareAutoInstrumentPlugin(options?: {
+    wranglerConfigPath?: string;
+}): {
     name: string;
     configResolved(config: {
         root: string;
@@ -7,15 +9,14 @@ export declare function sentryCloudflareAutoInstrumentPlugin(): {
             warn(msg: string): void;
         };
     }): void;
-    transform(this: {
-        parse(code: string): ProgramBody;
+    transform(this: ModuleResolver & {
         warn?(msg: string): void;
         environment?: {
             name?: string;
         };
-    }, code: string, id: string): {
+    }, code: string, id: string): Promise<{
         code: string;
         map: unknown;
-    } | undefined;
+    } | undefined>;
 };
 //# sourceMappingURL=autoInstrument.d.ts.map

package/build/types/vite/autoInstrument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../src/vite/autoInstrument.ts"],"names":[],"mappings":"AACA,OAAO,EAAwD,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAcrG,wBAAgB,oCAAoC;;2BAUzB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;oBAyB5E;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAAC,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,QAC/F,MAAM,MACR,MAAM,GACT;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS;EA6DhD"}
+{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../src/vite/autoInstrument.ts"],"names":[],"mappings":"AACA,OAAO,EAA8C,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAgB/F,wBAAgB,oCAAoC,CAAC,OAAO,GAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAO;IAQ9F,IAAI;IAEJ,cAAc,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;IAiC9E,SAAS,OACP,cAAc,GAAG;QAAE,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,QAC9E,MAAM,MACR,MAAM,GACT,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;EAiFzD"}

package/build/types/vite/index.d.ts

@@ -2,25 +2,35 @@
  * Options for {@link sentryCloudflareVitePlugin}.
  */
 export interface SentryCloudflareVitePluginOptions {
+    /**
+     * Path to the wrangler config, relative to the Vite root (or absolute).
+     * Set this when your config doesn't use a default name — e.g. when you
+     * pass `configPath: './wrangler.agent.jsonc'` to `@cloudflare/vite-plugin`,
+     * which the Sentry plugin cannot see. When set, only this file is read
+     * (no default-name probing), and a warning is emitted if it is missing or
+     * unparseable.
+     *
+     * @default undefined (probes `wrangler.json`, `wrangler.jsonc`, `wrangler.toml` at the Vite root)
+     */
+    wranglerConfigPath?: string;
+    /**
+     * Build-time automatic instrumentation of supported dependencies (e.g.
+     * database clients like `mysql`) so the Sentry Cloudflare SDK can trace them
+     * without monkey-patching, which wouldn't work in workerd anyway.
+     *
+     * When enabled, the plugin injects `diagnostics_channel.tracingChannel` calls
+     * into the bundled packages and, next to each, a snippet that registers the
+     * matching Sentry channel-subscriber factory on the global marker, which the
+     * SDK picks up in `Sentry.withSentry()`. Both `vite build` and `vite dev` are
+     * instrumented. Set to `false` to opt out.
+     *
+     * @default true
+     */
+    buildTimeInstrumentation?: boolean;
     /**
      * Experimental options that may change or be removed without notice.
      */
     _experimental?: {
-        /**
-         * Enables build-time automatic instrumentation of supported dependencies
-         * (e.g. database clients like `mysql`) so the Sentry Cloudflare SDK can
-         * trace them without monkey-patching, which wouldn't work in workerd anyway.
-         *
-         * When enabled, the plugin injects `diagnostics_channel.tracingChannel`
-         * calls into the bundled packages and, next to each, a snippet that
-         * registers the matching Sentry channel-subscriber factory on the global
-         * marker, which the SDK picks up in `Sentry.withSentry()`. Both `vite build`
-         * and `vite dev` are instrumented.
-         *
-         * @default false
-         * @experimental May change or be removed in any release.
-         */
-        useDiagnosticsChannelInjection?: boolean;
         /**
          * Automatically wraps your Worker at build time so you don't have to edit
          * your entry: the plugin reads your wrangler config, wraps the default
@@ -42,10 +52,9 @@ export interface SentryCloudflareVitePluginOptions {
  * instrumentation for Cloudflare Workers built with Vite. Configure the Sentry
  * SDK in your Worker as usual with `Sentry.withSentry()`.
  *
- * Currently, the only functionality is the experimental
- * `_experimental.useDiagnosticsChannelInjection` option, which traces supported
- * dependencies (such as database clients) without changing your application
- * code. Without it, the plugin is a no-op.
+ * By default, the plugin build-time instruments supported dependencies (such as
+ * database clients) so they are traced without changing your application code.
+ * Opt out with `buildTimeInstrumentation: false`.
  *
  * @example
  * ```ts
@@ -55,34 +64,11 @@ export interface SentryCloudflareVitePluginOptions {
  * import { defineConfig } from 'vite';
  *
  * export default defineConfig({
- *   plugins: [
- *     cloudflare(),
- *     sentryCloudflareVitePlugin({
- *       _experimental: {
- *         useDiagnosticsChannelInjection: true,
- *       },
- *     }),
- *   ],
+ *   plugins: [cloudflare(), sentryCloudflareVitePlugin()],
  * });
  * ```
  */
-export declare function sentryCloudflareVitePlugin(options?: SentryCloudflareVitePluginOptions): ({
+export declare function sentryCloudflareVitePlugin(options?: SentryCloudflareVitePluginOptions): Array<{
     name: string;
-    configResolved(config: {
-        root: string;
-        logger?: {
-            warn(msg: string): void;
-        };
-    }): void;
-    transform(this: {
-        parse(code: string): import("./transform").ProgramBody;
-        warn?(msg: string): void;
-        environment?: {
-            name?: string;
-        };
-    }, code: string, id: string): {
-        code: string;
-        map: unknown;
-    } | undefined;
-} | import("vite").Plugin<any>)[];
+}>;
 //# sourceMappingURL=index.d.ts.map

package/build/types/vite/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vite/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,aAAa,CAAC,EAAE;QACd;;;;;;;;;;;;;WAaG;QACH,8BAA8B,CAAC,EAAE,OAAO,CAAC;QACzC;;;;;;;;;;WAUG;QACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iCAAsC;;;;cAvDpC,CAAC;;;;;;YAoB7B,CAAA;mBAKf,CAAC;gBAAQ,CAAC;;;;;;kCAqCpB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vite/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;;;;;;;;OASG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;OAEG;IACH,aAAa,CAAC,EAAE;QACd;;;;;;;;;;WAUG;QACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iCAAsC,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CASnH"}

package/build/types/vite/moduleShape.d.ts

@@ -0,0 +1,52 @@
+import type { ProgramBody } from './transform';
+/** Binding name used for a module's default export. */
+export declare const DEFAULT_EXPORT = "default";
+/** A resolved superclass reference: a bare identifier or a `ns.Member` expression. */
+export type SuperRef = {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'member';
+    object: string;
+    property: string;
+};
+/** The declarations of a single module that binding resolution needs. */
+export interface ModuleShape {
+    /** Top-level class names → their superclass reference (absent when the class has no `extends`). */
+    classes: Map<string, SuperRef | undefined>;
+    /** Local binding name → the import it came from (`imported` is `default` for a default import). */
+    imports: Map<string, {
+        source: string;
+        imported: string;
+    }>;
+    /** Local binding name → module specifier, for `import * as ns from '...'`. */
+    namespaces: Map<string, string>;
+    /** Exported name → the re-export it came from, for `export { x as y } from '...'`. */
+    reexports: Map<string, {
+        source: string;
+        imported: string;
+    }>;
+    /** Exported name → local binding name, for `export { x as y }` without a source. */
+    localExports: Map<string, string>;
+    /** Module specifiers of bare `export * from '...'` declarations. */
+    starExports: string[];
+    /** `export default <Identifier>` — the local name it refers to. */
+    defaultExportName?: string;
+    /** True when the module's default export is a class declaration/expression. */
+    defaultExportIsClass?: boolean;
+    /** Superclass of an anonymous `export default class extends X`. */
+    defaultExportSuper?: SuperRef;
+}
+/** Collect the shape of a module from its parsed AST — used for the already-parsed entry module. */
+export declare function shapeFromAst(ast: ProgramBody): ModuleShape;
+/**
+ * Extract the module shape from **unprocessed source**.
+ *
+ * Sibling modules are read straight from disk (the plugin context's `load()` would deadlock inside a
+ * transform hook), so they may still be TypeScript — which no JS parser will accept. Only
+ * import/export statements and `class X extends Y` headers matter here, and those are
+ * declaration-level syntax a scan can pick out reliably; class bodies, type annotations and generics
+ * are irrelevant and simply skipped.
+ */
+export declare function shapeFromSource(rawCode: string): ModuleShape;
+//# sourceMappingURL=moduleShape.d.ts.map

package/build/types/vite/moduleShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleShape.d.ts","sourceRoot":"","sources":["../../../src/vite/moduleShape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,aAAa,CAAC;AAoDzD,uDAAuD;AACvD,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC,sFAAsF;AACtF,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnH,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,mGAAmG;IACnG,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;IAC3C,mGAAmG;IACnG,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,8EAA8E;IAC9E,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,sFAAsF;IACtF,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,oFAAoF;IACpF,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,oEAAoE;IACpE,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,QAAQ,CAAC;CAC/B;AAiBD,oGAAoG;AACpG,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,CAqC1D;AAiED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAgD5D"}

package/build/types/vite/transform.d.ts

@@ -18,7 +18,7 @@ export interface ProgramBody {
  * config providing only a fallback for self-bound entrypoints whose base class
  * lives in another module.
  */
-export type ClassWrapperKind = 'durableObject' | 'workflow' | 'workerEntrypoint';
+export type ClassWrapperKind = 'durableObject' | 'agent' | 'workflow' | 'workerEntrypoint';
 export interface TransformContext {
     /**
      * Exported class name → the kind of Sentry wrapper to apply. Populated from
@@ -26,6 +26,11 @@ export interface TransformContext {
      * each class's base type.
      */
     classWrappers: Map<string, ClassWrapperKind>;
+    /**
+     * Local class names detected as `agents` Agents. An Agent is configured as a Durable Object in
+     * wrangler, so this upgrades those entries from `durableObject` to `agent`.
+     */
+    agentClasses?: ReadonlySet<string>;
     optionsFn: string;
     /** Import statement prepended when `optionsFn` references a separate module. */
     optionsImport?: string;

package/build/types/vite/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/vite/transform.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,cAAc,CAAC;AAOvC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,EAAE,CAAC;CAClB;AAuDD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAajF,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C;;;;OAIG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,gBAAgB,GACpB,eAAe,GAAG,SAAS,CA6C7B"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/vite/transform.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,cAAc,CAAC;AAOvC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,EAAE,CAAC;CAClB;AAuDD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,OAAO,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAc3F,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C;;;OAGG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C;;;;OAIG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,gBAAgB,GACpB,eAAe,GAAG,SAAS,CA8C7B"}

package/build/types/withSentry.d.ts

@@ -1,5 +1,5 @@
-import type { env as cloudflareEnv } from 'cloudflare:workers';
 import type { CloudflareOptions } from './client';
+import type { AnyExportedHandler, DefaultEnv, ResolveEnv } from './types';
 import { type WorkerEntrypointConstructor } from './instrumentations/instrumentWorkerEntrypoint';
 /**
  * Wrapper for Cloudflare handlers.
@@ -12,5 +12,5 @@ import { type WorkerEntrypointConstructor } from './instrumentations/instrumentW
  * @param handler {ExportedHandler} The handler to wrap.
  * @returns The wrapped handler.
  */
-export declare function withSentry<Env = typeof cloudflareEnv, QueueHandlerMessage = unknown, CfHostMetadata = unknown, T extends ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata> | WorkerEntrypointConstructor = ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>>(optionsCallback: (env: Env) => CloudflareOptions | undefined, handler: T): T;
+export declare function withSentry<Env = DefaultEnv, QueueHandlerMessage = unknown, CfHostMetadata = unknown, T extends AnyExportedHandler | WorkerEntrypointConstructor<any, any> = ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata> | WorkerEntrypointConstructor<Env>>(optionsCallback: (env: ResolveEnv<T, Env>) => CloudflareOptions | undefined, handler: T): T;
 //# sourceMappingURL=withSentry.d.ts.map

package/build/types/withSentry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withSentry.d.ts","sourceRoot":"","sources":["../../src/withSentry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AASlD,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,+CAA+C,CAAC;AAEvD;;;;;;;;;;GAUG;AAGH,wBAAgB,UAAU,CACxB,GAAG,GAAG,OAAO,aAAa,EAC1B,mBAAmB,GAAG,OAAO,EAC7B,cAAc,GAAG,OAAO,EACxB,CAAC,SAAS,eAAe,CAAC,GAAG,EAAE,mBAAmB,EAAE,cAAc,CAAC,GAAG,2BAA2B,GAAG,eAAe,CACjH,GAAG,EACH,mBAAmB,EACnB,cAAc,CACf,EACD,eAAe,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,iBAAiB,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CA0B7E"}
+{"version":3,"file":"withSentry.d.ts","sourceRoot":"","sources":["../../src/withSentry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAOlD,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,+CAA+C,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACxB,GAAG,GAAG,UAAU,EAChB,mBAAmB,GAAG,OAAO,EAC7B,cAAc,GAAG,OAAO,EAExB,CAAC,SAAS,kBAAkB,GAAG,2BAA2B,CAAC,GAAG,EAAE,GAAG,CAAC,GAChE,eAAe,CAAC,GAAG,EAAE,mBAAmB,EAAE,cAAc,CAAC,GACzD,2BAA2B,CAAC,GAAG,CAAC,EACpC,eAAe,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,iBAAiB,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAyB5F"}

package/build/types/workflows.d.ts

@@ -1,5 +1,6 @@
 import type { WorkflowEntrypoint } from 'cloudflare:workers';
 import type { CloudflareOptions } from './client';
+import type { DefaultEnv, ResolveEnv } from './types';
 /**
  * Hashes a string to a UUID using SHA-1.
  */
@@ -21,8 +22,8 @@ export declare function deterministicTraceIdFromInstanceId(instanceId: string):
  * @param WorkflowClass - The workflow class to instrument
  * @returns Instrumented workflow class with the same interface
  */
-export declare function instrumentWorkflowWithSentry<E, // Environment type
-P, // Payload type
-T extends WorkflowEntrypoint<E, P>, // WorkflowEntrypoint type
-C extends new (ctx: ExecutionContext, env: E) => T>(optionsCallback: (env: E) => CloudflareOptions, WorkFlowClass: C): C;
+export declare function instrumentWorkflowWithSentry<E = DefaultEnv, // Environment type
+P = unknown, // Payload type
+T extends WorkflowEntrypoint<any, any> = WorkflowEntrypoint<E, P>, // WorkflowEntrypoint type
+C extends new (ctx: ExecutionContext, env: any) => WorkflowEntrypoint<any, any> = new (ctx: ExecutionContext, env: any) => T>(optionsCallback: (env: ResolveEnv<C, E>) => CloudflareOptions, WorkFlowClass: C): C;
 //# sourceMappingURL=workflows.d.ts.map

package/build/types/workflows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/workflows.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAEV,kBAAkB,EASnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AASlD;;GAEG;AACH,wBAAsB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAS5F;AAqID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,mBAAmB;AACtB,CAAC,EAAE,eAAe;AAClB,CAAC,SAAS,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,0BAA0B;AAC9D,CAAC,SAAS,KAAK,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAClD,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,iBAAiB,EAAE,aAAa,EAAE,CAAC,GAAG,CAAC,CA4CrE"}
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/workflows.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAEV,kBAAkB,EASnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAMlD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAItD;;GAEG;AACH,wBAAsB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAS5F;AAuID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,CAAC,GAAG,UAAU,EAAE,mBAAmB;AACnC,CAAC,GAAG,OAAO,EAAE,eAAe;AAE5B,CAAC,SAAS,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,0BAA0B;AAM7F,CAAC,SAAS,KAAK,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,GAAG,KAAK,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,KAChF,GAAG,EAAE,gBAAgB,EAErB,GAAG,EAAE,GAAG,KACL,CAAC,EACN,eAAe,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,iBAAiB,EAAE,aAAa,EAAE,CAAC,GAAG,CAAC,CA6CpF"}

package/build/types/wrapMethodWithSentry.d.ts

@@ -1,7 +1,7 @@
 import type { DurableObjectStorage } from '@cloudflare/workers-types';
 import type { CloudflareOptions } from './client';
 /** Extended DurableObjectState with originalStorage exposed by instrumentContext */
-interface InstrumentedDurableObjectState extends DurableObjectState {
+export interface InstrumentedDurableObjectState extends DurableObjectState {
     originalStorage?: DurableObjectStorage;
 }
 type MethodWrapperOptions = {

package/build/types/wrapMethodWithSentry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapMethodWithSentry.d.ts","sourceRoot":"","sources":["../../src/wrapMethodWithSentry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAgBtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAQlD,oFAAoF;AACpF,UAAU,8BAA+B,SAAQ,kBAAkB;IACjE,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAyBD,KAAK,oBAAoB,GAAG;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,gBAAgB,GAAG,8BAA8B,CAAC;IAC3D;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AACtD,KAAK,cAAc,GAAG,eAAe,CAAC;AAEtC;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,EAC3D,cAAc,EAAE,oBAAoB,EACpC,OAAO,EAAE,CAAC,EACV,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,MAAM,CAAC,EAAE,IAAI,GACZ,CAAC,CA0JH"}
+{"version":3,"file":"wrapMethodWithSentry.d.ts","sourceRoot":"","sources":["../../src/wrapMethodWithSentry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAatE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AASlD,oFAAoF;AACpF,MAAM,WAAW,8BAA+B,SAAQ,kBAAkB;IACxE,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAyBD,KAAK,oBAAoB,GAAG;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,gBAAgB,GAAG,8BAA8B,CAAC;IAC3D;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AACtD,KAAK,cAAc,GAAG,eAAe,CAAC;AAEtC;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,EAC3D,cAAc,EAAE,oBAAoB,EACpC,OAAO,EAAE,CAAC,EACV,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,MAAM,CAAC,EAAE,IAAI,GACZ,CAAC,CAqJH"}