@sentry/cloudflare 10.67.0 → 10.69.0

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nodejs_compat/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nodejs_compat/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC"}

package/build/types/nodejs_compat/integrations/tracing/vercelai.d.ts

@@ -4,13 +4,7 @@
  * The only difference is that it includes tracing channel support
  * because the default Vercel AI integration needs `nodejs_als`, while this one uses `nodejs_compat`.
  */
-interface VercelAiOptions {
-    /**
-     * Enable or disable truncation of recorded input messages.
-     * Defaults to `true`.
-     */
-    enableTruncation?: boolean;
-}
+import { type VercelAiOptions } from '@sentry/server-utils';
 /**
  * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
  * This integration is not enabled by default, you need to manually add it.
@@ -40,5 +34,4 @@ interface VercelAiOptions {
 export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
     name: string;
 };
-export {};
 //# sourceMappingURL=vercelai.d.ts.map

package/build/types/nodejs_compat/integrations/tracing/vercelai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercelai.d.ts","sourceRoot":"","sources":["../../../../../src/nodejs_compat/integrations/tracing/vercelai.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,UAAU,eAAe;IACvB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}
+{"version":3,"file":"vercelai.d.ts","sourceRoot":"","sources":["../../../../../src/nodejs_compat/integrations/tracing/vercelai.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAyD,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAanH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAyBlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,iBAAiB,YAAK,EAAE,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAyBpG"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAyBlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,iBAAiB,YAAK,EAAE,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAgCpG"}

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

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAahD,OAAO,KAAK,EAA2B,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAS5C,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,EAAE,CAuBhF;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CA4B7E"}
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAchD,OAAO,KAAK,EAA2B,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AA2B5C,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,EAAE,CA8BhF;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAoC7E"}

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/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

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

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

@@ -0,0 +1 @@
+{"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;;2BAUvE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;oBAkC5E,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

@@ -0,0 +1,98 @@
+/**
+ * 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;
+    /**
+     * 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
+         * export with `Sentry.withSentry()` (sourcing options from a co-located
+         * `instrument.*` file, falling back to env), and wraps any configured
+         * Durable Object class with `instrumentDurableObjectWithSentry`. Both
+         * `vite build` and `vite dev` are instrumented.
+         *
+         * @default false
+         * @experimental May change or be removed in any release.
+         */
+        autoInstrumentation?: boolean;
+    };
+}
+/**
+ * Sentry Vite plugin for Cloudflare Workers.
+ *
+ * Add this plugin to your Vite configuration to enable additional Sentry
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { cloudflare } from '@cloudflare/vite-plugin';
+ * import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     cloudflare(),
+ *     sentryCloudflareVitePlugin({
+ *       _experimental: {
+ *         useDiagnosticsChannelInjection: true,
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function sentryCloudflareVitePlugin(options?: SentryCloudflareVitePluginOptions): ({
+    name: string;
+    configResolved(config: {
+        root: string;
+        logger?: {
+            warn(msg: string): void;
+        };
+    }): void;
+    transform(this: import("./agentClass").ModuleResolver & {
+        warn?(msg: string): void;
+        environment?: {
+            name?: string;
+        };
+    }, code: string, id: string): Promise<{
+        code: string;
+        map: unknown;
+    } | undefined>;
+} | import("vite").Plugin<any>)[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"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;;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;;;;cA5DlF,CAAC;;;;;YAiCgE,CAAC;mBAChD,CAAC;gBAAS,CAAA;;;;;;kCAmCnC"}

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

@@ -0,0 +1,22 @@
+export declare const ENV_FALLBACK_OPTIONS_FN = "() => undefined";
+/**
+ * Locate the conventional `instrument.server.*` module sitting next to the
+ * worker entry file. Returns its absolute path, or `undefined` when absent.
+ */
+export declare function resolveInstrumentFile(entryFilePath: string): string | undefined;
+/**
+ * Build the `optionsFn` reference and `import` statement for the instrument
+ * module whose **default export** is the options callback
+ * `(env) => CloudflareOptions`.
+ *
+ * The import is emitted relative to `entryFilePath` because it is injected into
+ * the entry file's source. The file extension is kept: extensionless specifiers
+ * only resolve for extensions in Vite's default `resolve.extensions` (which
+ * excludes `.cjs`), and keeping it makes our probe order authoritative when
+ * several `instrument.server.*` files coexist.
+ */
+export declare function buildOptionsImport(entryFilePath: string, instrumentFilePath: string): {
+    optionsFn: string;
+    importStmt: string;
+};
+//# sourceMappingURL=instrumentFile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentFile.d.ts","sourceRoot":"","sources":["../../../src/vite/instrumentFile.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAWzD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAQ3C"}

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

@@ -0,0 +1,65 @@
+import MagicString from 'magic-string';
+export interface BaseNode {
+    type: string;
+    start: number;
+    end: number;
+}
+export interface ProgramBody {
+    body: BaseNode[];
+}
+/**
+ * The kind of Sentry wrapper to apply to an exported class.
+ *
+ * `durableObject` and `workflow` are keyed by name from the wrangler config
+ * (`durable_objects.bindings`, `workflows`), since those class names are
+ * authoritative there. `workerEntrypoint` is different: a worker's own
+ * entrypoints aren't enumerated in its config, so they're detected structurally
+ * (a class extending `WorkerEntrypoint` from `cloudflare:workers`), with the
+ * config providing only a fallback for self-bound entrypoints whose base class
+ * lives in another module.
+ */
+export type ClassWrapperKind = 'durableObject' | 'agent' | 'workflow' | 'workerEntrypoint';
+export interface TransformContext {
+    /**
+     * Exported class name → the kind of Sentry wrapper to apply. Populated from
+     * the wrangler config, so the transform can wrap by name without resolving
+     * 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;
+}
+export interface TransformResult {
+    code: string;
+    map: ReturnType<MagicString['generateMap']>;
+    /**
+     * The configured class names that were actually wrapped. Lets the plugin warn
+     * about configured classes it could not find, instead of silently leaving
+     * them uninstrumented.
+     */
+    wrappedClasses: Set<string>;
+}
+/**
+ * Rewrite the worker entry source to wrap its default export with `withSentry`
+ * and any configured class export with its matching Sentry wrapper (see
+ * {@link TransformContext.classWrappers}, e.g. Durable Object classes with
+ * `instrumentDurableObjectWithSentry`).
+ *
+ * Handles both `export class MyDO {}` and the specifier form
+ * (`class MyDO {}` … `export { MyDO }` / `export { Foo as MyDO }`).
+ * Re-exports from other modules (`export { MyDO } from './do'`) cannot be
+ * wrapped here and are left alone — the plugin warns about them via
+ * {@link TransformResult.wrappedClasses}.
+ *
+ * Exported (rather than inlined into the plugin) so it can be unit-tested with a
+ * plain AST and no Vite context. Returns `undefined` when nothing was wrapped and
+ * there are no already-manually-wrapped classes to report.
+ */
+export declare function applyAutoInstrumentTransforms(code: string, ast: ProgramBody, ctx: TransformContext): TransformResult | undefined;
+//# sourceMappingURL=transform.d.ts.map

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

@@ -0,0 +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,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/vite/workerEntrypoint.d.ts

@@ -0,0 +1,12 @@
+import type { ProgramBody } from './transform';
+/**
+ * Find top-level classes that (transitively, within this module) extend
+ * `WorkerEntrypoint` imported from `cloudflare:workers`. esbuild has already
+ * stripped TypeScript by transform time, so a superclass is a plain identifier
+ * (`extends WorkerEntrypoint`) or member access (`extends cf.WorkerEntrypoint`).
+ *
+ * Only same-file base chains are resolvable here; a base class imported from
+ * another module is invisible and relies on the config self-binding fallback.
+ */
+export declare function detectWorkerEntrypointClasses(ast: ProgramBody): Set<string>;
+//# sourceMappingURL=workerEntrypoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workerEntrypoint.d.ts","sourceRoot":"","sources":["../../../src/vite/workerEntrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,aAAa,CAAC;AA0CzD;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CA8B3E"}

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

@@ -0,0 +1,43 @@
+/**
+ * The slice of the wrangler configuration the auto-instrument plugin cares
+ * about. `main` is an absolute path (wrangler resolves it against the config
+ * file's directory).
+ */
+export interface WranglerConfig {
+    main?: string;
+    durableObjects: Array<{
+        name: string;
+        className: string;
+    }>;
+    workflows: Array<{
+        name: string;
+        className: string;
+    }>;
+    /**
+     * Named `WorkerEntrypoint` exports this worker binds to itself via a service
+     * binding (`services[]` whose `service` is this worker's own `name`). Only
+     * self-bindings appear here: a service binding's `entrypoint` otherwise names
+     * an export on a *different* worker, which this build can't wrap.
+     */
+    workerEntrypoints: string[];
+}
+/**
+ * Locate and resolve the wrangler configuration via wrangler's own
+ * `unstable_readConfig` — the API `@cloudflare/vite-plugin` uses.
+ *
+ * We only locate the file (probing `wrangler.json`, `.jsonc`, `.toml` inside
+ * `root` with wrangler's own precedence, since it discovers from `cwd` rather
+ * than an arbitrary root); wrangler then parses it, flattens the active
+ * environment (honoring `CLOUDFLARE_ENV`), and resolves `main` to an absolute
+ * path. Durable Object and Workflow bindings are the active environment's,
+ * matching what the deployed Worker actually binds.
+ *
+ * Returns `undefined` when no config file is found or it can't be read/parsed
+ * (the caller warns and disables auto-instrumentation rather than failing the
+ * whole build).
+ */
+export declare function resolveWranglerConfig(root: string, explicitPath?: string): {
+    config: WranglerConfig;
+    configDir: string;
+} | undefined;
+//# sourceMappingURL=wranglerConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wranglerConfig.d.ts","sourceRoot":"","sources":["../../../src/vite/wranglerConfig.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD;;;;;OAKG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,YAAY,CAAC,EAAE,MAAM,GACpB;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA2B3D"}

package/build/types-ts3.8/client.d.ts

@@ -41,6 +41,8 @@ export declare class CloudflareClient extends ServerRuntimeClient {
      * After calling dispose(), the client should not be used anymore.
      */
     dispose(): void;
+    /** @inheritDoc */
+    protected _setupIntegrations(): void;
     /**
      * Resets the span completion promise and resolve function.
      */
@@ -132,6 +134,30 @@ interface BaseCloudflareOptions {
      * ```
      */
     durableObjectSqlSpanAllowlist?: Array<string | RegExp>;
+    /**
+     * KV keys that should stay instrumented even though they match a reserved prefix used by Durable
+     * Object frameworks (`agents`, `partyserver`, ...) for their internal storage entries.
+     *
+     * By default, KV reads/writes (`get`, `put`, `delete`, `list`) of `cf_`- or `__ps_`-prefixed keys
+     * are treated as framework noise and no `durable_object_storage_*` span is created for them,
+     * mirroring how `cf_`-prefixed SQL tables are handled (see {@link durableObjectSqlSpanAllowlist}).
+     * If one of your own keys happens to use such a prefix, add it here to opt it back into
+     * instrumentation. Strings must match exactly, while regular expressions give you prefix/pattern
+     * matching.
+     *
+     * @default []
+     * @example
+     * ```ts
+     * export default Sentry.withSentry(
+     *   (env) => ({
+     *     dsn: env.SENTRY_DSN,
+     *     durableObjectStorageSpanAllowlist: ['cf_my_key', /^cf_reports_/],
+     *   }),
+     *   handler,
+     * );
+     * ```
+     */
+    durableObjectStorageSpanAllowlist?: Array<string | RegExp>;
     /**
      * @deprecated Use `enableRpcTracePropagation` instead. This option will be removed in a future major version.
      *
@@ -145,6 +171,17 @@ interface BaseCloudflareOptions {
      * @default false
      */
     instrumentPrototypeMethods?: boolean | string[];
+    /**
+     * If you use Spotlight by Sentry during development, use
+     * this option to forward captured Sentry events to Spotlight.
+     *
+     * Either set it to true, or provide a specific Spotlight Sidecar URL.
+     *
+     * More details: https://spotlightjs.com/
+     *
+     * IMPORTANT: Only set this option to `true` while developing, not in production!
+     */
+    spotlight?: boolean | string;
 }
 /**
  * Configuration options for the Sentry Cloudflare SDK

package/build/types-ts3.8/defineCloudflareOptions.d.ts

@@ -0,0 +1,38 @@
+import { env as cloudflareEnv } from 'cloudflare:workers';
+import { CloudflareOptions } from './client';
+/**
+ * Define the Sentry options for a Cloudflare Worker in a dedicated module.
+ *
+ * This is the recommended way to configure the SDK when using the Vite plugin's
+ * auto-instrumentation: place an `instrument.server.{ts,js,mjs}` file next to
+ * the worker entry whose **default export** is the result of this function. The
+ * plugin picks it up automatically and hands it to `withSentry`.
+ *
+ * Unlike Node's `Sentry.init(...)`, the options cannot be applied at module
+ * load time on Cloudflare: the DSN and other settings typically come from the
+ * per-request `env`, which only exists inside the handler. Pass a callback to
+ * read from `env`, or a static object when no `env` access is needed — either
+ * way you get full type-checking and autocomplete on {@link CloudflareOptions}.
+ *
+ * At runtime this is a thin pass-through; it only normalizes a static object
+ * into a callback so the plugin always imports a `(env) => options` function.
+ *
+ * @example
+ * ```ts
+ * // src/instrument.server.ts
+ * import { defineCloudflareOptions } from '@sentry/cloudflare';
+ *
+ * export default defineCloudflareOptions((env) => ({
+ *   dsn: env.SENTRY_DSN,
+ *   tracesSampleRate: 1.0,
+ * }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Static options — no `env` access needed
+ * export default defineCloudflareOptions({ tracesSampleRate: 1.0 });
+ * ```
+ */
+export declare function defineCloudflareOptions<Env = typeof cloudflareEnv>(optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined)): (env: Env) => CloudflareOptions | undefined;
+//# sourceMappingURL=defineCloudflareOptions.d.ts.map