@sentry/cloudflare 10.69.0 → 11.0.0-alpha.0

package/build/types-ts3.8/utils/instrumentContext.d.ts

@@ -1,16 +0,0 @@
-import { DurableObjectState, ExecutionContext } from '@cloudflare/workers-types';
-type ContextType = ExecutionContext | DurableObjectState;
-/**
- * Instruments an execution context or DurableObjectState with Sentry tracing.
- *
- * Creates a copy of the context that:
- * - Allows overriding of methods (e.g., waitUntil)
- * - For DurableObjectState: instruments storage operations (get, put, delete, list, etc.)
- *   to create Sentry spans automatically
- *
- * @param ctx - The execution context or DurableObjectState to instrument
- * @returns An instrumented copy of the context
- */
-export declare function instrumentContext<T extends ContextType>(ctx: T): T;
-export {};
-//# sourceMappingURL=instrumentContext.d.ts.map

package/build/types-ts3.8/utils/internalSqlQuery.d.ts

@@ -1,20 +0,0 @@
-/**
- * Cloudflare frameworks that build on Durable Objects (`agents`, `partyserver`, ...) manage their
- * own internal SQLite tables, all namespaced with a `cf_` prefix — e.g. `cf_agents_schedules`,
- * `cf_agent_state`, `cf_ai_chat_stream_chunks`. Queries against them (schedule polling, chat-stream
- * persistence, state bookkeeping) are framework implementation details that otherwise flood traces
- * with dozens of zero-signal `db.query` spans per request. The exact set of tables even varies
- * between framework versions, so we match the reserved prefix rather than an enumerated list.
- *
- * The `cf_` prefix is a reserved convention for framework-managed tables, so user tables should not
- * use it. In case a user table does collide with the prefix, the `durableObjectSqlSpanAllowlist`
- * option lets them opt those tables back into instrumentation.
- *
- * 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. 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>, queryText?: string): boolean;
-//# sourceMappingURL=internalSqlQuery.d.ts.map

package/build/types-ts3.8/utils/internalStorageKey.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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-ts3.8/utils/isBinding.d.ts

@@ -1,77 +0,0 @@
-/**
- * Adapted from https://github.com/evanderkoogh/otel-cf-workers/blob/effeb549f0a4ed1c55ea0c4f0d8e8e37e5494fb3/src/instrumentation/env.ts
- *
- * BSD 3-Clause License
- *
- * Copyright (c) 2023, Erwin van der Koogh
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-import { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
-/**
- * Checks if a value is a JSRPC proxy (service binding).
- *
- * JSRPC proxies return a truthy value for ANY property access, including
- * properties that don't exist. This makes other duck-type checks unreliable
- * unless we exclude JSRPC first.
- *
- * Must be checked before other binding type checks.
- */
-export declare function isJSRPC(item: unknown): item is Service;
-/**
- * Duck-type check for DurableObjectNamespace bindings.
- * DurableObjectNamespace has `idFromName`, `idFromString`, `get`, `newUniqueId`.
- */
-export declare function isDurableObjectNamespace(item: unknown): item is DurableObjectNamespace;
-/**
- * Duck-type check for Queue producer bindings.
- * Queue has `send` and `sendBatch` async methods.
- */
-export declare function isQueue(item: unknown): item is Queue;
-/**
- * Duck-type check for D1Database bindings.
- * D1Database has `prepare`, `batch`, and `exec` methods.
- */
-export declare function isD1Database(item: unknown): item is D1Database;
-/**
- * Duck-type check for Workers AI bindings.
- * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
- */
-export declare function isAiBinding(item: unknown): item is Ai;
-/**
- * Duck-type check for R2 Bucket bindings.
- * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.
- */
-export declare function isR2Bucket(item: unknown): item is R2Bucket;
-/**
- * Duck-type check for RateLimit bindings.
- * RateLimit only exposes a single `limit` method. Because that is a fairly
- * common method name, this check is intentionally run after the more specific
- * binding checks (Queue, R2, D1) in `instrumentEnv`, so those win when a binding
- * also happens to expose `limit`.
- */
-export declare function isRateLimit(item: unknown): item is RateLimit;
-//# sourceMappingURL=isBinding.d.ts.map

package/build/types-ts3.8/utils/isCloudflareClass.d.ts

@@ -1,30 +0,0 @@
-import { DurableObject, WorkflowEntrypoint } from 'cloudflare:workers';
-import { WorkerEntrypointConstructor } from '../instrumentations/instrumentWorkerEntrypoint';
-/**
- * Checks if a class constructor extends a specific Cloudflare base class.
- *
- * Uses prototype chain walking with constructor names rather than instanceof,
- * so it works in Node at build time without requiring the cloudflare:workers
- * module (which only exists in the Workers runtime).
- *
- * This is used to differentiate between different Cloudflare worker types:
- * - WorkerEntrypoint: Class-based workers (used with instrumentWorkerEntrypoint)
- * - DurableObject: Durable Object classes
- * - Workflow: Workflow classes
- *
- * For ExportedHandler (plain objects), this will return false for all types.
- *
- * @param value - The value to check (typically a class constructor)
- * @param className - The Cloudflare base class name to check against
- * @returns true if the value is a class that extends the specified Cloudflare class
- *
- * @example
- * ```ts
- * isCloudflareClass(MyWorker, 'WorkerEntrypoint') // true if MyWorker extends WorkerEntrypoint
- * 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: '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-ts3.8/utils/rpcMeta.d.ts

@@ -1,15 +0,0 @@
-import { SerializedTraceData } from '@sentry/core';
-/**
- * Appends Sentry RPC metadata to an args array for trace propagation.
- * If no active trace exists, returns the original args unchanged.
- */
-export declare function appendRpcMeta(args: unknown[]): unknown[];
-/**
- * Extracts Sentry RPC metadata from the trailing argument of an args array.
- * Returns cleaned args (without meta) and the extracted trace data if found.
- */
-export declare function extractRpcMeta<T extends unknown[]>(args: T): {
-    args: T;
-    rpcMeta?: SerializedTraceData;
-};
-//# sourceMappingURL=rpcMeta.d.ts.map

package/build/types-ts3.8/utils/rpcOptions.d.ts

@@ -1,13 +0,0 @@
-import { CloudflareOptions } from '../client';
-/**
- * Gets the effective RPC propagation setting, handling deprecation of `instrumentPrototypeMethods`.
- *
- * Priority:
- * 1. If `enableRpcTracePropagation` is set, use it (ignore `instrumentPrototypeMethods`)
- * 2. If only `instrumentPrototypeMethods` is set, use it with deprecation warning
- * 3. If neither is set, return `false`
- *
- * @returns The effective setting for RPC trace propagation
- */
-export declare function getEffectiveRpcPropagation(options: CloudflareOptions): boolean;
-//# sourceMappingURL=rpcOptions.d.ts.map

package/build/types-ts3.8/utils/streaming.d.ts

@@ -1,17 +0,0 @@
-export type StreamingGuess = {
-    isStreaming: boolean;
-};
-/**
- * Classifies a Response as streaming or non-streaming.
- *
- * Heuristics:
- * - No body → not streaming
- * - Known streaming Content-Types → streaming (SSE, NDJSON, JSON streaming)
- * - text/plain without Content-Length → streaming (some AI APIs)
- * - Otherwise → not streaming (conservative default, including HTML/SSR)
- *
- * We avoid probing the stream to prevent blocking on transform streams (like injectTraceMetaTags)
- * or SSR streams that may not have data ready immediately.
- */
-export declare function classifyResponseStreaming(res: Response): StreamingGuess;
-//# sourceMappingURL=streaming.d.ts.map

package/build/types-ts3.8/utils/traceLinks.d.ts

@@ -1,28 +0,0 @@
-import { DurableObjectStorage } from '@cloudflare/workers-types';
-import { SpanLink } from '@sentry/core';
-/** Stored span context for creating span links */
-export interface StoredSpanContext {
-    traceId: string;
-    spanId: string;
-    sampled: boolean;
-}
-/**
- * Gets the storage key for a specific method's trace link.
- */
-export declare function getTraceLinkKey(methodName: string): string;
-/**
- * Stores the current span context in Durable Object storage for trace linking.
- * Uses the original uninstrumented storage to avoid creating spans for internal operations.
- * Errors are silently ignored to prevent internal storage failures from propagating to user code.
- */
-export declare function storeSpanContext(originalStorage: DurableObjectStorage, methodName: string): void;
-/**
- * Retrieves a stored span context from Durable Object storage.
- * Errors are silently ignored to prevent internal storage failures from propagating to user code.
- */
-export declare function getStoredSpanContext(originalStorage: DurableObjectStorage, methodName: string): StoredSpanContext | undefined;
-/**
- * Builds span links from a stored span context.
- */
-export declare function buildSpanLinks(storedContext: StoredSpanContext): SpanLink[];
-//# sourceMappingURL=traceLinks.d.ts.map

package/build/types-ts3.8/vendor/stacktrace.d.ts

@@ -1,11 +0,0 @@
-import { StackParser } from '@sentry/core';
-/**
- * Gets the module from filename.
- *
- * @param filename
- * @returns Module name
- */
-export declare function getModule(filename: string | undefined): string | undefined;
-/** Cloudflare Workers stack parser */
-export declare const defaultStackParser: StackParser;
-//# sourceMappingURL=stacktrace.d.ts.map

package/build/types-ts3.8/vite/agentClass.d.ts

@@ -1,41 +0,0 @@
-import { 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-ts3.8/vite/autoInstrument.d.ts

@@ -1,22 +0,0 @@
-import { 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-ts3.8/vite/index.d.ts

@@ -1,98 +0,0 @@
-/**
- * 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-ts3.8/vite/instrumentFile.d.ts

@@ -1,22 +0,0 @@
-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-ts3.8/vite/moduleShape.d.ts

@@ -1,52 +0,0 @@
-import { 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-ts3.8/vite/transform.d.ts

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

@@ -1,12 +0,0 @@
-import { 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-ts3.8/vite/wranglerConfig.d.ts

@@ -1,43 +0,0 @@
-/**
- * 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-ts3.8/withSentry.d.ts

@@ -1,16 +0,0 @@
-import { env as cloudflareEnv } from 'cloudflare:workers';
-import { CloudflareOptions } from './client';
-import { WorkerEntrypointConstructor } from './instrumentations/instrumentWorkerEntrypoint';
-/**
- * Wrapper for Cloudflare handlers.
- *
- * Initializes the SDK and wraps the handler with Sentry instrumentation.
- *
- * Automatically instruments the `fetch` method of the handler.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @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;
-//# sourceMappingURL=withSentry.d.ts.map