@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/build/cjs/dev/vite/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sources":["../../../../src/vite/transform.ts"],"sourcesContent":["import MagicString from 'magic-string';\nimport { detectWorkerEntrypointClasses } from './workerEntrypoint';\n\n// ---------------------------------------------------------------------------\n// Minimal ESTree node types for the AST nodes we inspect.\n// ---------------------------------------------------------------------------\n\nexport interface BaseNode {\n  type: string;\n  start: number;\n  end: number;\n}\n\nexport interface ProgramBody {\n  body: BaseNode[];\n}\n\ninterface IdentifierNode extends BaseNode {\n  name: string;\n}\n\ninterface CalleeNode {\n  type: string;\n  name?: string;\n  property?: { type: string; name?: string };\n}\n\ninterface CallExpressionNode extends BaseNode {\n  callee?: CalleeNode;\n}\n\ninterface ClassDeclarationNode extends BaseNode {\n  id?: IdentifierNode | null;\n}\n\ninterface ExportDefaultNode extends BaseNode {\n  declaration: BaseNode;\n}\n\ninterface ExportSpecifierNode {\n  type: string;\n  local?: { type: string; name?: string };\n  exported?: { type: string; name?: string };\n}\n\ninterface ExportNamedNode extends BaseNode {\n  declaration?: BaseNode | null;\n  source?: unknown;\n  specifiers?: ExportSpecifierNode[];\n}\n\ninterface VariableDeclaratorNode {\n  id?: { type: string; name?: string };\n  init?: BaseNode | null;\n}\n\ninterface VariableDeclarationNode extends BaseNode {\n  declarations?: VariableDeclaratorNode[];\n}\n\nfunction isCallToMethod(node: BaseNode, methodName: string): boolean {\n  if (node.type !== 'CallExpression') return false;\n  const callee = (node as CallExpressionNode).callee;\n  if (!callee) return false;\n  if (callee.type === 'Identifier' && callee.name === methodName) return true;\n  return (\n    callee.type === 'MemberExpression' && callee.property?.type === 'Identifier' && callee.property.name === methodName\n  );\n}\n\n/**\n * The kind of Sentry wrapper to apply to an exported class.\n *\n * `durableObject` and `workflow` are keyed by name from the wrangler config\n * (`durable_objects.bindings`, `workflows`), since those class names are\n * authoritative there. `workerEntrypoint` is different: a worker's own\n * entrypoints aren't enumerated in its config, so they're detected structurally\n * (a class extending `WorkerEntrypoint` from `cloudflare:workers`), with the\n * config providing only a fallback for self-bound entrypoints whose base class\n * lives in another module.\n */\nexport type ClassWrapperKind = 'durableObject' | 'agent' | 'workflow' | 'workerEntrypoint';\n\n/**\n * The `@sentry/cloudflare` helper each wrapper kind emits. All share the same\n * `(optionsCallback, Class)` signature. `WorkerEntrypoint` classes use\n * `withSentry`, which runtime-detects the class type and routes accordingly.\n */\nconst WRAPPER_METHODS: Record<ClassWrapperKind, string> = {\n  durableObject: 'instrumentDurableObjectWithSentry',\n  agent: 'instrumentAgentWithSentry',\n  workflow: 'instrumentWorkflowWithSentry',\n  workerEntrypoint: 'withSentry',\n};\n\nexport interface TransformContext {\n  /**\n   * Exported class name → the kind of Sentry wrapper to apply. Populated from\n   * the wrangler config, so the transform can wrap by name without resolving\n   * each class's base type.\n   */\n  classWrappers: Map<string, ClassWrapperKind>;\n  /**\n   * Local class names detected as `agents` Agents. An Agent is configured as a Durable Object in\n   * wrangler, so this upgrades those entries from `durableObject` to `agent`.\n   */\n  agentClasses?: ReadonlySet<string>;\n  optionsFn: string;\n  /** Import statement prepended when `optionsFn` references a separate module. */\n  optionsImport?: string;\n}\n\nexport interface TransformResult {\n  code: string;\n  map: ReturnType<MagicString['generateMap']>;\n  /**\n   * The configured class names that were actually wrapped. Lets the plugin warn\n   * about configured classes it could not find, instead of silently leaving\n   * them uninstrumented.\n   */\n  wrappedClasses: Set<string>;\n}\n\n/**\n * Rewrite the worker entry source to wrap its default export with `withSentry`\n * and any configured class export with its matching Sentry wrapper (see\n * {@link TransformContext.classWrappers}, e.g. Durable Object classes with\n * `instrumentDurableObjectWithSentry`).\n *\n * Handles both `export class MyDO {}` and the specifier form\n * (`class MyDO {}` … `export { MyDO }` / `export { Foo as MyDO }`).\n * Re-exports from other modules (`export { MyDO } from './do'`) cannot be\n * wrapped here and are left alone — the plugin warns about them via\n * {@link TransformResult.wrappedClasses}.\n *\n * Exported (rather than inlined into the plugin) so it can be unit-tested with a\n * plain AST and no Vite context. Returns `undefined` when nothing was wrapped and\n * there are no already-manually-wrapped classes to report.\n */\nexport function applyAutoInstrumentTransforms(\n  code: string,\n  ast: ProgramBody,\n  ctx: TransformContext,\n): TransformResult | undefined {\n  const ms = new MagicString(code);\n  const topLevelClasses = collectTopLevelClasses(ast);\n  const state: TransformState = {\n    ms,\n    needsImport: false,\n    wrappedClasses: new Set<string>(),\n    topLevelClasses,\n    renamedLocals: new Set<string>(),\n    classWrappers: ctx.classWrappers,\n    agentClasses: ctx.agentClasses ?? new Set<string>(),\n    workerEntrypointClasses: detectWorkerEntrypointClasses(ast),\n  };\n  const { wrappedClasses } = state;\n\n  // Named exports first, regardless of source order: the default-export handler\n  // needs to know which local bindings a named export already wrapped, so it can\n  // skip a class that is both exported by name and re-exported as default (which\n  // would otherwise wrap it twice).\n  for (const node of ast.body) {\n    if (node.type === 'ExportNamedDeclaration') {\n      handleNamedExport(node, ctx, state);\n    }\n  }\n  for (const node of ast.body) {\n    if (node.type === 'ExportDefaultDeclaration') {\n      wrapDefaultExport(node as ExportDefaultNode, ctx, state);\n    }\n  }\n\n  if (!state.needsImport) {\n    // Nothing was rewritten. Still surface any classes found already wrapped\n    // manually (via `wrappedClasses`) so the caller doesn't warn about them;\n    // return undefined only when there was nothing to report either.\n    if (wrappedClasses.size === 0) return undefined;\n    return { code, map: ms.generateMap({ hires: true }), wrappedClasses };\n  }\n\n  if (ctx.optionsImport) ms.prepend(ctx.optionsImport);\n  ms.prepend(\"import * as __SENTRY__ from '@sentry/cloudflare';\\n\");\n\n  return {\n    code: ms.toString(),\n    map: ms.generateMap({ hires: true }),\n    wrappedClasses,\n  };\n}\n\ninterface TransformState {\n  ms: MagicString;\n  needsImport: boolean;\n  wrappedClasses: Set<string>;\n  /**\n   * Top-level (non-exported) class declarations, so specifier exports like\n   * `export { MyDO }` can locate the class they refer to.\n   */\n  topLevelClasses: Map<string, ClassDeclarationNode>;\n  /**\n   * Local class names already renamed + wrapped, so two specifiers pointing at\n   * the same class don't produce duplicate bindings.\n   */\n  renamedLocals: Set<string>;\n  /** Class name → wrapper kind, keyed by the *exported* name (from config). */\n  classWrappers: Map<string, ClassWrapperKind>;\n  /** Local class names detected as `agents` Agents (see {@link TransformContext.agentClasses}). */\n  agentClasses: ReadonlySet<string>;\n  /**\n   * Local class names detected as `WorkerEntrypoint` subclasses in this module,\n   * so they can be wrapped without a config entry.\n   */\n  workerEntrypointClasses: Set<string>;\n}\n\n/**\n * Resolve the wrapper kind for a class export.\n *\n * Config (`classWrappers`) wins — it's authoritative for Durable Objects and\n * Workflows, and provides the self-binding fallback for WorkerEntrypoints whose\n * base class this module can't see. Otherwise a structurally-detected\n * `WorkerEntrypoint` subclass (matched by its *local* name) gets wrapped with\n * `withSentry`.\n *\n * The one case where config is refined rather than obeyed is an `agents` Agent:\n * it *is* a Durable Object, so wrangler can only ever describe it as one, and\n * only the detected base chain distinguishes the two.\n */\nfunction resolveWrapperKind(\n  exportedName: string,\n  localName: string | undefined,\n  state: TransformState,\n): ClassWrapperKind | undefined {\n  const configured = state.classWrappers.get(exportedName);\n  if (configured === 'durableObject' && localName && state.agentClasses.has(localName)) return 'agent';\n  if (configured) return configured;\n  if (localName && state.workerEntrypointClasses.has(localName)) return 'workerEntrypoint';\n  return undefined;\n}\n\nfunction collectTopLevelClasses(ast: ProgramBody): Map<string, ClassDeclarationNode> {\n  const classes = new Map<string, ClassDeclarationNode>();\n  for (const node of ast.body) {\n    if (node.type !== 'ClassDeclaration') continue;\n    const classNode = node as ClassDeclarationNode;\n    if (classNode.id?.name) classes.set(classNode.id.name, classNode);\n  }\n  return classes;\n}\n\nfunction wrapDefaultExport(node: ExportDefaultNode, ctx: TransformContext, state: TransformState): void {\n  const decl = node.declaration;\n\n  // Already wrapped — leave it alone\n  if (isCallToMethod(decl, 'withSentry')) return;\n\n  // `export default Foo` where `Foo` is a local class already wrapped by a named\n  // export (e.g. a self-bound WorkerEntrypoint also used as the default handler).\n  // Wrapping again would produce `withSentry(withSentry(...))`.\n  if (decl.type === 'Identifier' && state.renamedLocals.has((decl as IdentifierNode).name)) return;\n\n  // `export default <expr>` → `const __SENTRY_DEFAULT_EXPORT__ = <expr>`\n  // MagicString positions are always relative to the original source.\n  state.ms.overwrite(node.start, decl.start, 'const __SENTRY_DEFAULT_EXPORT__ = ');\n  state.ms.append(`\\nexport default __SENTRY__.withSentry(${ctx.optionsFn}, __SENTRY_DEFAULT_EXPORT__);\\n`);\n  state.needsImport = true;\n}\n\nfunction handleNamedExport(node: ExportNamedNode, ctx: TransformContext, state: TransformState): void {\n  const decl = node.declaration;\n\n  // ---- Manually wrapped class export ----\n  // `export const MyDO = instrumentDurableObjectWithSentry(...)` — count it\n  // as wrapped so the plugin doesn't warn about it, but leave it alone.\n  if (decl?.type === 'VariableDeclaration') {\n    collectManuallyWrappedClassExports(decl, ctx, state);\n    return;\n  }\n\n  // ---- Named class export matching a configured binding ----\n  if (decl?.type === 'ClassDeclaration') {\n    wrapInlineClassExport(node, decl, ctx, state);\n    return;\n  }\n\n  // ---- Specifier export of a local class (`export { Foo as MyDO }`) ----\n  // Re-exports from another module carry a `source` — nothing local to wrap.\n  if (node.source) return;\n  for (const specifier of node.specifiers ?? []) {\n    wrapSpecifierExport(specifier, ctx, state);\n  }\n}\n\nfunction collectManuallyWrappedClassExports(\n  varDecl: VariableDeclarationNode,\n  ctx: TransformContext,\n  state: TransformState,\n): void {\n  for (const declarator of varDecl.declarations ?? []) {\n    const name = declarator.id?.type === 'Identifier' ? declarator.id.name : undefined;\n    const kind = name ? ctx.classWrappers.get(name) : undefined;\n    if (!name || !kind || !declarator.init) continue;\n\n    // A hand-wrapped Agent is configured as a Durable Object, so accept either helper there —\n    // otherwise an already-instrumented Agent would be reported as unwrapped.\n    const accepted =\n      kind === 'durableObject' ? [WRAPPER_METHODS.durableObject, WRAPPER_METHODS.agent] : [WRAPPER_METHODS[kind]];\n\n    if (accepted.some(method => isCallToMethod(declarator.init as BaseNode, method))) {\n      state.wrappedClasses.add(name);\n    }\n  }\n}\n\nfunction wrapInlineClassExport(\n  exportNode: ExportNamedNode,\n  classDecl: ClassDeclarationNode,\n  ctx: TransformContext,\n  state: TransformState,\n): void {\n  const classId = classDecl.id;\n  // Inline export: the exported name and the local class name are the same.\n  const kind = classId ? resolveWrapperKind(classId.name, classId.name, state) : undefined;\n  if (!classId || !kind) return;\n\n  const className = classId.name;\n  const renamedClass = `__SENTRY_ORIGINAL_${className}__`;\n\n  // Strip the `export ` keyword\n  state.ms.overwrite(exportNode.start, classDecl.start, '');\n\n  // Rename the class to avoid a duplicate binding\n  state.ms.overwrite(classId.start, classId.end, renamedClass);\n\n  // Insert the wrapped re-export after the class body\n  state.ms.appendLeft(\n    exportNode.end,\n    `\\nexport const ${className} = __SENTRY__.${WRAPPER_METHODS[kind]}(${ctx.optionsFn}, ${renamedClass});\\n`,\n  );\n\n  state.wrappedClasses.add(className);\n  state.renamedLocals.add(className);\n  state.needsImport = true;\n}\n\nfunction wrapSpecifierExport(specifier: ExportSpecifierNode, ctx: TransformContext, state: TransformState): void {\n  if (specifier.type !== 'ExportSpecifier' || specifier.exported?.type !== 'Identifier') return;\n  const exportedName = specifier.exported.name;\n  if (!exportedName) return;\n\n  const localName = specifier.local?.type === 'Identifier' ? specifier.local.name : undefined;\n  const kind = resolveWrapperKind(exportedName, localName, state);\n  if (!kind) return;\n\n  const localClass = localName ? state.topLevelClasses.get(localName) : undefined;\n  if (!localName || !localClass?.id) return;\n\n  state.wrappedClasses.add(exportedName);\n  state.needsImport = true;\n  if (state.renamedLocals.has(localName)) return;\n  state.renamedLocals.add(localName);\n\n  const renamedClass = `__SENTRY_ORIGINAL_${localName}__`;\n  state.ms.overwrite(localClass.id.start, localClass.id.end, renamedClass);\n  // The existing `export { ... }` statement keeps exporting the (now\n  // wrapped) `localName` binding, so the wrapper is NOT exported here.\n  state.ms.appendLeft(\n    localClass.end,\n    `\\nconst ${localName} = __SENTRY__.${WRAPPER_METHODS[kind]}(${ctx.optionsFn}, ${renamedClass});\\n`,\n  );\n}\n"],"names":["MagicString","detectWorkerEntrypointClasses"],"mappings":"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"}

package/build/cjs/dev/vite/workerEntrypoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerEntrypoint.js","sources":["../../../../src/vite/workerEntrypoint.ts"],"sourcesContent":["import type { BaseNode, ProgramBody } from './transform';\n\n// ---------------------------------------------------------------------------\n// Minimal ESTree node shapes for structural WorkerEntrypoint detection.\n// ---------------------------------------------------------------------------\n\ninterface IdentifierNode extends BaseNode {\n  name: string;\n}\n\ninterface MemberExpressionNode extends BaseNode {\n  object?: { type: string; name?: string };\n  property?: { type: string; name?: string };\n}\n\ninterface ClassDeclarationNode extends BaseNode {\n  id?: IdentifierNode | null;\n  superClass?: BaseNode | null;\n}\n\ninterface ExportNamedDeclNode extends BaseNode {\n  declaration?: BaseNode | null;\n}\n\ninterface ImportSpecifierNode {\n  type: string;\n  imported?: { type: string; name?: string };\n  local?: { type: string; name?: string };\n}\n\ninterface ImportDeclarationNode extends BaseNode {\n  source?: { value?: unknown };\n  specifiers?: ImportSpecifierNode[];\n}\n\ninterface WorkerEntrypointBases {\n  /** Local identifiers bound to the named `WorkerEntrypoint` import. */\n  named: Set<string>;\n  /** Local identifiers bound to a `* as ns` import of `cloudflare:workers`. */\n  namespaces: Set<string>;\n}\n\n/**\n * Find top-level classes that (transitively, within this module) extend\n * `WorkerEntrypoint` imported from `cloudflare:workers`. esbuild has already\n * stripped TypeScript by transform time, so a superclass is a plain identifier\n * (`extends WorkerEntrypoint`) or member access (`extends cf.WorkerEntrypoint`).\n *\n * Only same-file base chains are resolvable here; a base class imported from\n * another module is invisible and relies on the config self-binding fallback.\n */\nexport function detectWorkerEntrypointClasses(ast: ProgramBody): Set<string> {\n  const bases = collectWorkerEntrypointImports(ast);\n  if (bases.named.size === 0 && bases.namespaces.size === 0) {\n    return new Set<string>();\n  }\n\n  // Every top-level class, including the `export class Foo {}` form (where the\n  // class is nested inside an ExportNamedDeclaration) so directly-exported\n  // entrypoints are seen too.\n  const classes = new Map<string, ClassDeclarationNode>();\n  for (const node of ast.body) {\n    const classNode = asClassDeclaration(node);\n    if (classNode?.id?.name) classes.set(classNode.id.name, classNode);\n  }\n\n  const entrypoints = new Set<string>();\n  // Iterate to a fixed point so an indirect chain (A extends B extends WE) is\n  // fully resolved regardless of declaration order.\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const [name, classNode] of classes) {\n      if (entrypoints.has(name)) continue;\n      if (extendsWorkerEntrypoint(classNode.superClass, bases, entrypoints)) {\n        entrypoints.add(name);\n        changed = true;\n      }\n    }\n  }\n  return entrypoints;\n}\n\n/** Unwrap `export class Foo {}` to its ClassDeclaration; pass bare classes through. */\nfunction asClassDeclaration(node: BaseNode): ClassDeclarationNode | undefined {\n  if (node.type === 'ClassDeclaration') return node;\n  if (node.type === 'ExportNamedDeclaration') {\n    const decl = (node as ExportNamedDeclNode).declaration;\n    if (decl?.type === 'ClassDeclaration') return decl;\n  }\n  return undefined;\n}\n\nfunction collectWorkerEntrypointImports(ast: ProgramBody): WorkerEntrypointBases {\n  const named = new Set<string>();\n  const namespaces = new Set<string>();\n  for (const node of ast.body) {\n    if (node.type !== 'ImportDeclaration') continue;\n    const importNode = node as ImportDeclarationNode;\n    if (importNode.source?.value !== 'cloudflare:workers') continue;\n    for (const specifier of importNode.specifiers ?? []) {\n      if (\n        specifier.type === 'ImportSpecifier' &&\n        specifier.imported?.name === 'WorkerEntrypoint' &&\n        specifier.local?.name\n      ) {\n        named.add(specifier.local.name);\n      } else if (specifier.type === 'ImportNamespaceSpecifier' && specifier.local?.name) {\n        namespaces.add(specifier.local.name);\n      }\n    }\n  }\n  return { named, namespaces };\n}\n\n/**\n * Whether a superclass expression resolves to `WorkerEntrypoint` — either a bare\n * identifier from the named import (or an already-detected local subclass), or a\n * `ns.WorkerEntrypoint` member access off a namespace import.\n */\nfunction extendsWorkerEntrypoint(\n  superClass: BaseNode | null | undefined,\n  bases: WorkerEntrypointBases,\n  detected: Set<string>,\n): boolean {\n  if (!superClass) return false;\n  if (superClass.type === 'Identifier') {\n    const name = (superClass as IdentifierNode).name;\n    return bases.named.has(name) || detected.has(name);\n  }\n  if (superClass.type === 'MemberExpression') {\n    const member = superClass as MemberExpressionNode;\n    return (\n      member.object?.type === 'Identifier' &&\n      !!member.object.name &&\n      bases.namespaces.has(member.object.name) &&\n      member.property?.name === 'WorkerEntrypoint'\n    );\n  }\n  return false;\n}\n"],"names":[],"mappings":"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"}

package/build/cjs/dev/vite/wranglerConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wranglerConfig.js","sources":["../../../../src/vite/wranglerConfig.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { dirname, resolve } from 'node:path';\nimport { type Unstable_Config, unstable_readConfig } from 'wrangler';\n\n/**\n * The slice of the wrangler configuration the auto-instrument plugin cares\n * about. `main` is an absolute path (wrangler resolves it against the config\n * file's directory).\n */\nexport interface WranglerConfig {\n  main?: string;\n  durableObjects: Array<{ name: string; className: string }>;\n  workflows: Array<{ name: string; className: string }>;\n  /**\n   * Named `WorkerEntrypoint` exports this worker binds to itself via a service\n   * binding (`services[]` whose `service` is this worker's own `name`). Only\n   * self-bindings appear here: a service binding's `entrypoint` otherwise names\n   * an export on a *different* worker, which this build can't wrap.\n   */\n  workerEntrypoints: string[];\n}\n\n/**\n * Locate and resolve the wrangler configuration via wrangler's own\n * `unstable_readConfig` — the API `@cloudflare/vite-plugin` uses.\n *\n * We only locate the file (probing `wrangler.json`, `.jsonc`, `.toml` inside\n * `root` with wrangler's own precedence, since it discovers from `cwd` rather\n * than an arbitrary root); wrangler then parses it, flattens the active\n * environment (honoring `CLOUDFLARE_ENV`), and resolves `main` to an absolute\n * path. Durable Object and Workflow bindings are the active environment's,\n * matching what the deployed Worker actually binds.\n *\n * Returns `undefined` when no config file is found or it can't be read/parsed\n * (the caller warns and disables auto-instrumentation rather than failing the\n * whole build).\n */\nexport function resolveWranglerConfig(\n  root: string,\n  explicitPath?: string,\n): { config: WranglerConfig; configDir: string } | undefined {\n  const configPath = explicitPath\n    ? resolve(root, explicitPath)\n    : ['wrangler.json', 'wrangler.jsonc', 'wrangler.toml'].map(name => resolve(root, name)).find(existsSync);\n\n  if (!configPath || !existsSync(configPath)) {\n    return undefined;\n  }\n\n  let raw: Unstable_Config;\n  try {\n    // `hideWarnings` keeps wrangler's config diagnostics (e.g. missing DO\n    // migrations) out of the Vite build output.\n    raw = unstable_readConfig({ config: configPath }, { hideWarnings: true });\n  } catch {\n    return undefined;\n  }\n\n  return {\n    config: {\n      main: raw.main,\n      durableObjects: collectClassBindings(raw.durable_objects?.bindings),\n      workflows: collectClassBindings(raw.workflows),\n      workerEntrypoints: collectSelfBoundEntrypoints(raw),\n    },\n    configDir: dirname(raw.configPath ?? configPath),\n  };\n}\n\n/**\n * Collect named `WorkerEntrypoint` exports the worker binds to itself. A service\n * binding's `entrypoint` normally names an export on the *target* worker, so it\n * is only ours when `service` equals this worker's own `name`. Without a `name`\n * there is nothing to match against, so no entrypoints are derivable.\n */\nfunction collectSelfBoundEntrypoints(raw: Unstable_Config): string[] {\n  if (!raw.name) {\n    return [];\n  }\n  const entrypoints = new Set<string>();\n  for (const binding of raw.services ?? []) {\n    if (binding?.service === raw.name && typeof binding.entrypoint === 'string') {\n      entrypoints.add(binding.entrypoint);\n    }\n  }\n  return [...entrypoints];\n}\n\n/**\n * Map wrangler class bindings (Durable Objects, Workflows — same shape) to the\n * `{ name, className }` the transform needs, skipping duplicates and bindings\n * with a `script_name` (those reference a class exported by a *different*\n * worker, so there is nothing to wrap in this worker's entry file).\n */\nfunction collectClassBindings(\n  bindings: ReadonlyArray<{ name: string; class_name?: string; script_name?: string }> | undefined,\n): Array<{ name: string; className: string }> {\n  const result: Array<{ name: string; className: string }> = [];\n  const seenClassNames = new Set<string>();\n  for (const binding of bindings ?? []) {\n    if (typeof binding?.class_name !== 'string' || binding.script_name || seenClassNames.has(binding.class_name)) {\n      continue;\n    }\n    seenClassNames.add(binding.class_name);\n    result.push({ name: binding.name, className: binding.class_name });\n  }\n  return result;\n}\n"],"names":["resolve","existsSync","unstable_readConfig","dirname"],"mappings":";;;;;;AAqCO,SAAS,qBAAA,CACd,MACA,YAAA,EAC2D;AAC3D,EAAA,MAAM,aAAa,YAAA,GACfA,iBAAA,CAAQ,MAAM,YAAY,CAAA,GAC1B,CAAC,eAAA,EAAiB,gBAAA,EAAkB,eAAe,CAAA,CAAE,GAAA,CAAI,UAAQA,iBAAA,CAAQ,IAAA,EAAM,IAAI,CAAC,CAAA,CAAE,KAAKC,kBAAU,CAAA;AAEzG,EAAA,IAAI,CAAC,UAAA,IAAc,CAACA,kBAAA,CAAW,UAAU,CAAA,EAAG;AAC1C,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,IAAI,GAAA;AACJ,EAAA,IAAI;AAGF,IAAA,GAAA,GAAMC,4BAAA,CAAoB,EAAE,MAAA,EAAQ,UAAA,IAAc,EAAE,YAAA,EAAc,MAAM,CAAA;AAAA,EAC1E,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,OAAO;AAAA,IACL,MAAA,EAAQ;AAAA,MACN,MAAM,GAAA,CAAI,IAAA;AAAA,MACV,cAAA,EAAgB,oBAAA,CAAqB,GAAA,CAAI,eAAA,EAAiB,QAAQ,CAAA;AAAA,MAClE,SAAA,EAAW,oBAAA,CAAqB,GAAA,CAAI,SAAS,CAAA;AAAA,MAC7C,iBAAA,EAAmB,4BAA4B,GAAG;AAAA,KACpD;AAAA,IACA,SAAA,EAAWC,iBAAA,CAAQ,GAAA,CAAI,UAAA,IAAc,UAAU;AAAA,GACjD;AACF;AAQA,SAAS,4BAA4B,GAAA,EAAgC;AACnE,EAAA,IAAI,CAAC,IAAI,IAAA,EAAM;AACb,IAAA,OAAO,EAAC;AAAA,EACV;AACA,EAAA,MAAM,WAAA,uBAAkB,GAAA,EAAY;AACpC,EAAA,KAAA,MAAW,OAAA,IAAW,GAAA,CAAI,QAAA,IAAY,EAAC,EAAG;AACxC,IAAA,IAAI,SAAS,OAAA,KAAY,GAAA,CAAI,QAAQ,OAAO,OAAA,CAAQ,eAAe,QAAA,EAAU;AAC3E,MAAA,WAAA,CAAY,GAAA,CAAI,QAAQ,UAAU,CAAA;AAAA,IACpC;AAAA,EACF;AACA,EAAA,OAAO,CAAC,GAAG,WAAW,CAAA;AACxB;AAQA,SAAS,qBACP,QAAA,EAC4C;AAC5C,EAAA,MAAM,SAAqD,EAAC;AAC5D,EAAA,MAAM,cAAA,uBAAqB,GAAA,EAAY;AACvC,EAAA,KAAA,MAAW,OAAA,IAAW,QAAA,IAAY,EAAC,EAAG;AACpC,IAAA,IAAI,OAAO,OAAA,EAAS,UAAA,KAAe,QAAA,IAAY,OAAA,CAAQ,eAAe,cAAA,CAAe,GAAA,CAAI,OAAA,CAAQ,UAAU,CAAA,EAAG;AAC5G,MAAA;AAAA,IACF;AACA,IAAA,cAAA,CAAe,GAAA,CAAI,QAAQ,UAAU,CAAA;AACrC,IAAA,MAAA,CAAO,IAAA,CAAK,EAAE,IAAA,EAAM,OAAA,CAAQ,MAAM,SAAA,EAAW,OAAA,CAAQ,YAAY,CAAA;AAAA,EACnE;AACA,EAAA,OAAO,MAAA;AACT;;;;"}

package/build/cjs/{withSentry.js → dev/withSentry.js}

@@ -1,13 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const async = require('./async.js');
-const instrument = require('./instrument.js');
+const noDiagnosticChannels = require('@sentry/server-utils/no-diagnostic-channels');
 const instrumentEmail = require('./instrumentations/worker/instrumentEmail.js');
 const instrumentFetch = require('./instrumentations/worker/instrumentFetch.js');
 const instrumentQueue = require('./instrumentations/worker/instrumentQueue.js');
 const instrumentScheduled = require('./instrumentations/worker/instrumentScheduled.js');
 const instrumentTail = require('./instrumentations/worker/instrumentTail.js');
-const hono = require('./integrations/hono.js');
 const isCloudflareClass = require('./utils/isCloudflareClass.js');
 const instrumentWorkerEntrypoint = require('./instrumentations/instrumentWorkerEntrypoint.js');
 
@@ -15,10 +13,9 @@ function withSentry(optionsCallback, handler) {
   if (isCloudflareClass.isCloudflareClass(handler, "WorkerEntrypoint")) {
     return instrumentWorkerEntrypoint.instrumentWorkerEntrypoint(optionsCallback, handler);
   }
-  async.setAsyncLocalStorageAsyncContextStrategy();
+  noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy();
   try {
     instrumentFetch.instrumentExportedHandlerFetch(handler, optionsCallback);
-    instrumentHonoErrorHandler(handler);
     instrumentScheduled.instrumentExportedHandlerScheduled(handler, optionsCallback);
     instrumentEmail.instrumentExportedHandlerEmail(handler, optionsCallback);
     instrumentQueue.instrumentExportedHandlerQueue(handler, optionsCallback);
@@ -27,20 +24,6 @@ function withSentry(optionsCallback, handler) {
   }
   return handler;
 }
-function instrumentHonoErrorHandler(handler) {
-  if ("onError" in handler && "errorHandler" in handler && typeof handler.errorHandler === "function") {
-    handler.errorHandler = instrument.ensureInstrumented(
-      handler.errorHandler,
-      (original) => new Proxy(original, {
-        apply(target, thisArg, args) {
-          const [err, context] = args;
-          hono.getHonoIntegration()?.handleHonoException(err, context);
-          return Reflect.apply(target, thisArg, args);
-        }
-      })
-    );
-  }
-}
 
 exports.withSentry = withSentry;
 //# sourceMappingURL=withSentry.js.map

package/build/cjs/dev/withSentry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withSentry.js","sources":["../../../src/withSentry.ts"],"sourcesContent":["import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport { instrumentExportedHandlerEmail } from './instrumentations/worker/instrumentEmail';\nimport { instrumentExportedHandlerFetch } from './instrumentations/worker/instrumentFetch';\nimport { instrumentExportedHandlerQueue } from './instrumentations/worker/instrumentQueue';\nimport { instrumentExportedHandlerScheduled } from './instrumentations/worker/instrumentScheduled';\nimport { instrumentExportedHandlerTail } from './instrumentations/worker/instrumentTail';\nimport { isCloudflareClass } from './utils/isCloudflareClass';\nimport type { AnyExportedHandler, DefaultEnv, ResolveEnv } from './types';\nimport {\n  instrumentWorkerEntrypoint,\n  type WorkerEntrypointConstructor,\n} from './instrumentations/instrumentWorkerEntrypoint';\n\n/**\n * Wrapper for Cloudflare handlers.\n *\n * Initializes the SDK and wraps the handler with Sentry instrumentation.\n *\n * Automatically instruments the `fetch` method of the handler.\n *\n * @param optionsCallback Function that returns the options for the SDK initialization.\n * @param handler {ExportedHandler} The handler to wrap.\n * @returns The wrapped handler.\n */\nexport function withSentry<\n  Env = DefaultEnv,\n  QueueHandlerMessage = unknown,\n  CfHostMetadata = unknown,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends AnyExportedHandler | WorkerEntrypointConstructor<any, any> =\n    | ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>\n    | WorkerEntrypointConstructor<Env>,\n>(optionsCallback: (env: ResolveEnv<T, Env>) => CloudflareOptions | undefined, handler: T): T {\n  if (isCloudflareClass(handler, 'WorkerEntrypoint')) {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    return instrumentWorkerEntrypoint(optionsCallback as any, handler);\n  }\n\n  setAsyncLocalStorageAsyncContextStrategy();\n\n  try {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerFetch(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerScheduled(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerEmail(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerQueue(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerTail(handler, optionsCallback as any);\n    // This is here because Miniflare sometimes cannot get instrumented\n  } catch {\n    // Do not console anything here, we don't want to spam the console with errors\n  }\n\n  return handler;\n}\n"],"names":["isCloudflareClass","instrumentWorkerEntrypoint","setAsyncLocalStorageAsyncContextStrategy","instrumentExportedHandlerFetch","instrumentExportedHandlerScheduled","instrumentExportedHandlerEmail","instrumentExportedHandlerQueue","instrumentExportedHandlerTail"],"mappings":";;;;;;;;;;;AAyBO,SAAS,UAAA,CAQd,iBAA6E,OAAA,EAAe;AAC5F,EAAA,IAAIA,mCAAA,CAAkB,OAAA,EAAS,kBAAkB,CAAA,EAAG;AAElD,IAAA,OAAOC,qDAAA,CAA2B,iBAAwB,OAAO,CAAA;AAAA,EACnE;AAEA,EAAAC,6DAAA,EAAyC;AAEzC,EAAA,IAAI;AAEF,IAAAC,8CAAA,CAA+B,SAAS,eAAsB,CAAA;AAE9D,IAAAC,sDAAA,CAAmC,SAAS,eAAsB,CAAA;AAElE,IAAAC,8CAAA,CAA+B,SAAS,eAAsB,CAAA;AAE9D,IAAAC,8CAAA,CAA+B,SAAS,eAAsB,CAAA;AAE9D,IAAAC,4CAAA,CAA8B,SAAS,eAAsB,CAAA;AAAA,EAE/D,CAAA,CAAA,MAAQ;AAAA,EAER;AAEA,EAAA,OAAO,OAAA;AACT;;;;"}

package/build/cjs/{workflows.js → dev/workflows.js}

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const attributes = require('@sentry/conventions/attributes');
+const op = require('@sentry/conventions/op');
 const core = require('@sentry/core');
-const async = require('./async.js');
+const noDiagnosticChannels = require('@sentry/server-utils/no-diagnostic-channels');
 const flush = require('./flush.js');
 const instrumentEnv = require('./instrumentations/worker/instrumentEnv.js');
 const scopeUtils = require('./scope-utils.js');
@@ -42,10 +44,12 @@ class WrappedWorkflowStep {
       const isFinalAttempt = !hasStepContext || attempt > retryLimit;
       return core.startSpan(
         {
-          op: "function.step.do",
           name,
           scope: scopeForStep,
           attributes: {
+            [attributes.SENTRY_OP]: op.GENERAL_FUNCTION_SPAN_OP,
+            [attributes.CODE_FUNCTION_NAME]: name,
+            "workflow.step.name": name,
             "cloudflare.workflow.timeout": config?.timeout,
             "cloudflare.workflow.retries.backoff": config?.retries?.backoff,
             // In workers-types v5, `delay` may be a `WorkflowDelayFunction`, which isn't a valid span attribute value.
@@ -89,6 +93,7 @@ class WrappedWorkflowStep {
 }
 function instrumentWorkflowWithSentry(optionsCallback, WorkFlowClass) {
   return new Proxy(WorkFlowClass, {
+    // oxlint-disable-next-line typescript/no-explicit-any
     construct(target, args, newTarget) {
       const [ctx, env] = args;
       const context = instrumentContext.instrumentContext(ctx);
@@ -100,7 +105,7 @@ function instrumentWorkflowWithSentry(optionsCallback, WorkFlowClass) {
         get(obj, prop, receiver) {
           if (prop === "run") {
             return async function(event, step) {
-              async.setAsyncLocalStorageAsyncContextStrategy();
+              noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy();
               return core.withIsolationScope(async (isolationScope) => {
                 const waitUntil = flush.getOriginalWaitUntil(context).bind(context);
                 const client = sdk.init({ ...options, ctx: context, enableDedupe: false });

package/build/cjs/dev/workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.js","sources":["../../../src/workflows.ts"],"sourcesContent":["import { CODE_FUNCTION_NAME, SENTRY_OP } from '@sentry/conventions/attributes';\nimport { GENERAL_FUNCTION_SPAN_OP } from '@sentry/conventions/op';\nimport type { PropagationContext } from '@sentry/core';\nimport {\n  captureException,\n  flush,\n  getCurrentScope,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  startSpan,\n  withIsolationScope,\n  withScope,\n} from '@sentry/core';\nimport type {\n  WorkflowDelayDuration,\n  WorkflowEntrypoint,\n  WorkflowEvent,\n  WorkflowSleepDuration,\n  WorkflowStep,\n  WorkflowStepConfig,\n  WorkflowStepContext,\n  WorkflowStepEvent,\n  WorkflowStepRollbackOptions,\n  WorkflowTimeoutDuration,\n} from 'cloudflare:workers';\nimport { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport { flushAndDispose, getOriginalWaitUntil } from './flush';\nimport { instrumentEnv } from './instrumentations/worker/instrumentEnv';\nimport { addCloudResourceContext } from './scope-utils';\nimport { init } from './sdk';\nimport { instrumentContext } from './utils/instrumentContext';\nimport type { DefaultEnv, ResolveEnv } from './types';\n\nconst UUID_REGEX = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i;\n\n/**\n * Hashes a string to a UUID using SHA-1.\n */\nexport async function deterministicTraceIdFromInstanceId(instanceId: string): Promise<string> {\n  const buf = await crypto.subtle.digest('SHA-1', new TextEncoder().encode(instanceId));\n  return (\n    Array.from(new Uint8Array(buf))\n      // We only need the first 16 bytes for the 32 characters\n      .slice(0, 16)\n      .map(b => b.toString(16).padStart(2, '0'))\n      .join('')\n  );\n}\n\nasync function propagationContextFromInstanceId(instanceId: string): Promise<PropagationContext> {\n  const traceId = UUID_REGEX.test(instanceId)\n    ? instanceId.replace(/-/g, '')\n    : await deterministicTraceIdFromInstanceId(instanceId);\n\n  // Derive sampleRand from last 4 characters of the random UUID\n  //\n  // We cannot store any state between workflow steps, so we derive the\n  // sampleRand from the traceId itself. This ensures that the sampling is\n  // consistent across all steps in the same workflow instance.\n  const sampleRand = parseInt(traceId.slice(-4), 16) / 0xffff;\n\n  return {\n    traceId,\n    sampleRand,\n  };\n}\n\nclass WrappedWorkflowStep implements WorkflowStep {\n  public constructor(\n    private _instanceId: string,\n    private _options: CloudflareOptions,\n    private _step: WorkflowStep,\n    private _waitUntil: ExecutionContext['waitUntil'],\n  ) {}\n\n  public async do<T extends Rpc.Serializable<T>>(\n    name: string,\n    callback: (ctx: WorkflowStepContext) => Promise<T>,\n    rollbackOptions?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T>;\n  public async do<T extends Rpc.Serializable<T>, const C extends WorkflowStepConfig>(\n    name: string,\n    config: C,\n    callback: (\n      ctx: WorkflowStepContext<C['retries'] extends { delay: infer D } ? D : WorkflowDelayDuration | number>,\n    ) => Promise<T>,\n    rollbackOptions?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T>;\n  public async do<T extends Rpc.Serializable<T>>(\n    name: string,\n    configOrCallback: WorkflowStepConfig | ((ctx: WorkflowStepContext) => Promise<T>),\n    callbackOrRollback?: ((ctx: WorkflowStepContext) => Promise<T>) | WorkflowStepRollbackOptions<T>,\n    maybeRollback?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T> {\n    // Capture the current scope, so parent span (e.g., a startSpan surrounding step.do) is preserved\n    const scopeForStep = getCurrentScope();\n\n    const hasConfig = typeof configOrCallback !== 'function';\n    const config = hasConfig ? configOrCallback : undefined;\n    const userCallback = (hasConfig ? callbackOrRollback : configOrCallback) as (\n      ctx: WorkflowStepContext,\n    ) => Promise<T>;\n    const rollbackOptions = (hasConfig ? maybeRollback : callbackOrRollback) as\n      | WorkflowStepRollbackOptions<T>\n      | undefined;\n\n    const instrumentedCallback = async (...args: unknown[]): Promise<T> => {\n      // Feature detection: Cloudflare Workflows (April 2026+) pass a step context\n      // with `attempt` and `config.retries.limit`. When available, we only capture\n      // errors on the final attempt to avoid duplicates during retries.\n      const stepContext = args[0] as { attempt?: number; config?: { retries?: { limit?: number } } } | undefined;\n      const attempt = stepContext?.attempt;\n      const retryLimit = stepContext?.config?.retries?.limit;\n      const hasStepContext = typeof attempt === 'number' && typeof retryLimit === 'number';\n\n      // Only capture error on final attempt (attempt > retryLimit means no more retries left)\n      // or when step context is unavailable (legacy behavior - capture all errors)\n      const isFinalAttempt = !hasStepContext || attempt > retryLimit;\n\n      return startSpan(\n        {\n          name,\n          scope: scopeForStep,\n          attributes: {\n            [SENTRY_OP]: GENERAL_FUNCTION_SPAN_OP,\n            [CODE_FUNCTION_NAME]: name,\n            'workflow.step.name': name,\n            'cloudflare.workflow.timeout': config?.timeout,\n            'cloudflare.workflow.retries.backoff': config?.retries?.backoff,\n            // In workers-types v5, `delay` may be a `WorkflowDelayFunction`, which isn't a valid span attribute value.\n            'cloudflare.workflow.retries.delay':\n              typeof config?.retries?.delay === 'function' ? undefined : config?.retries?.delay,\n            'cloudflare.workflow.retries.limit': config?.retries?.limit,\n            'cloudflare.workflow.attempt': attempt,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.faas.cloudflare.workflow',\n            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'task',\n          },\n        },\n        async span => {\n          try {\n            const result = await (userCallback as (...args: unknown[]) => Promise<T>)(...args);\n            span.setStatus({ code: 1 });\n            return result;\n          } catch (error) {\n            if (isFinalAttempt) {\n              captureException(error, { mechanism: { handled: true, type: 'auto.faas.cloudflare.workflow' } });\n            }\n            throw error;\n          } finally {\n            this._waitUntil(flush(2000));\n          }\n        },\n      );\n    };\n\n    if (config) {\n      return rollbackOptions\n        ? this._step.do(name, config, instrumentedCallback, rollbackOptions)\n        : this._step.do(name, config, instrumentedCallback);\n    }\n\n    return rollbackOptions\n      ? this._step.do(name, instrumentedCallback, rollbackOptions)\n      : this._step.do(name, instrumentedCallback);\n  }\n\n  public async sleep(name: string, duration: WorkflowSleepDuration): Promise<void> {\n    return this._step.sleep(name, duration);\n  }\n\n  public async sleepUntil(name: string, timestamp: Date | number): Promise<void> {\n    return this._step.sleepUntil(name, timestamp);\n  }\n\n  public async waitForEvent<T extends Rpc.Serializable<T>>(\n    name: string,\n    options: { type: string; timeout?: WorkflowTimeoutDuration | number },\n  ): Promise<WorkflowStepEvent<T>> {\n    return this._step.waitForEvent<T>(name, options);\n  }\n}\n\n/**\n * Instruments a Cloudflare Workflow class with Sentry.\n *\n * @example\n * ```typescript\n * const InstrumentedWorkflow = instrumentWorkflowWithSentry(\n *   (env) => ({ dsn: env.SENTRY_DSN }),\n *   MyWorkflowClass\n * );\n *\n * export default InstrumentedWorkflow;\n * ```\n *\n * @param optionsCallback - Function that returns Sentry options to initialize Sentry\n * @param WorkflowClass - The workflow class to instrument\n * @returns Instrumented workflow class with the same interface\n */\nexport function instrumentWorkflowWithSentry<\n  E = DefaultEnv, // Environment type\n  P = unknown, // Payload type\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends WorkflowEntrypoint<any, any> = WorkflowEntrypoint<E, P>, // WorkflowEntrypoint type\n  // The constraint must not route through `T`: workers-types defaults `WorkflowEntrypoint`'s\n  // `Env` to `unknown` (unlike `WorkerEntrypoint`/`DurableObject`, which default to\n  // `Cloudflare.Env`), so a bare subclass would be rejected in a `wrangler types` project.\n  // The callback env is resolved from the inferred constructor via `ResolveEnv` instead.\n  // oxlint-disable-next-line typescript/no-explicit-any\n  C extends new (ctx: ExecutionContext, env: any) => WorkflowEntrypoint<any, any> = new (\n    ctx: ExecutionContext,\n    // oxlint-disable-next-line typescript/no-explicit-any\n    env: any,\n  ) => T, // Constructor type of the WorkflowEntrypoint class\n>(optionsCallback: (env: ResolveEnv<C, E>) => CloudflareOptions, WorkFlowClass: C): C {\n  return new Proxy(WorkFlowClass, {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    construct(target: C, args: [ctx: ExecutionContext, env: any], newTarget) {\n      const [ctx, env] = args;\n      const context = instrumentContext(ctx);\n      const options = optionsCallback(env);\n      args[0] = context;\n      args[1] = instrumentEnv(env as Record<string, unknown>, options) as E;\n      const instance = Reflect.construct(target, args, newTarget) as T;\n      return new Proxy(instance, {\n        get(obj, prop, receiver) {\n          if (prop === 'run') {\n            return async function (event: WorkflowEvent<P>, step: WorkflowStep): Promise<unknown> {\n              setAsyncLocalStorageAsyncContextStrategy();\n\n              return withIsolationScope(async isolationScope => {\n                const waitUntil = getOriginalWaitUntil(context).bind(context);\n                const client = init({ ...options, ctx: context, enableDedupe: false });\n                isolationScope.setClient(client);\n\n                addCloudResourceContext(isolationScope);\n\n                return withScope(async scope => {\n                  const propagationContext = await propagationContextFromInstanceId(event.instanceId);\n                  scope.setPropagationContext(propagationContext);\n\n                  try {\n                    return await obj.run.call(\n                      obj,\n                      event,\n                      new WrappedWorkflowStep(event.instanceId, options, step, waitUntil),\n                    );\n                  } finally {\n                    waitUntil(flushAndDispose(client));\n                  }\n                });\n              });\n            };\n          }\n          return Reflect.get(obj, prop, receiver);\n        },\n      });\n    },\n  });\n}\n"],"names":["getCurrentScope","startSpan","SENTRY_OP","GENERAL_FUNCTION_SPAN_OP","CODE_FUNCTION_NAME","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","captureException","flush","instrumentContext","instrumentEnv","setAsyncLocalStorageAsyncContextStrategy","withIsolationScope","getOriginalWaitUntil","init","addCloudResourceContext","withScope","flushAndDispose"],"mappings":"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"}

package/build/cjs/dev/wrapMethodWithSentry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapMethodWithSentry.js","sources":["../../../src/wrapMethodWithSentry.ts"],"sourcesContent":["import type { DurableObjectStorage } from '@cloudflare/workers-types';\nimport type { SerializedTraceData } from '@sentry/core';\nimport {\n  isObjectLike,\n  captureException,\n  continueTrace,\n  isThenable,\n  type Scope,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  startNewTrace as startNewTraceCore,\n  startSpan,\n} from '@sentry/core';\nimport type { CloudflareOptions } from './client';\nimport type { ExecutionContextCompat } from './executionContext';\nimport { flushAndDispose, getOriginalWaitUntil } from './flush';\nimport { ensureInstrumented } from './instrument';\nimport { init } from './sdk';\nimport { withInvocationIsolationScope } from './utils/invocationScope';\nimport { extractRpcMeta } from './utils/rpcMeta';\nimport { buildSpanLinks, getStoredSpanContext, storeSpanContext } from './utils/traceLinks';\n\n/** Extended DurableObjectState with originalStorage exposed by instrumentContext */\nexport interface InstrumentedDurableObjectState extends DurableObjectState {\n  originalStorage?: DurableObjectStorage;\n}\n\n/**\n * Resolves uninstrumented DO storage for the current invocation.\n * Prefer `thisArg.ctx` (the live Durable Object instance) over the context captured at\n * construction time to avoid cross-DO I/O errors in the same isolate.\n */\nfunction resolveOriginalStorage(\n  context: ExecutionContext | InstrumentedDurableObjectState | undefined,\n  thisArg: unknown,\n): DurableObjectStorage | undefined {\n  if (isObjectLike(thisArg) && 'ctx' in thisArg) {\n    const doCtx = (thisArg as { ctx: InstrumentedDurableObjectState }).ctx;\n    if (doCtx?.originalStorage) {\n      return doCtx.originalStorage;\n    }\n  }\n\n  if (context && 'originalStorage' in context && context.originalStorage) {\n    return context.originalStorage;\n  }\n\n  return undefined;\n}\n\ntype MethodWrapperOptions = {\n  spanName?: string;\n  spanOp?: string;\n  options: CloudflareOptions;\n  context: ExecutionContext | InstrumentedDurableObjectState;\n  /**\n   * If true, starts a fresh trace instead of inheriting from a parent trace.\n   * Useful for scheduled/independent invocations like alarms.\n   *\n   * If true, it also stores the current span context and links to the previous invocation's span.\n   * Uses Durable Object storage to persist the link. The link is set asynchronously via `span.addLinks()`\n   * in a `waitUntil` to avoid blocking.\n   *\n   * @default false\n   */\n  startNewTrace?: boolean;\n  /**\n   * The trace origin identifying which instrumentation created the span, e.g. `auto.faas.cloudflare.durable_object`.\n   * Used both as the span's `sentry.origin` attribute and as the `mechanism.type` for captured exceptions.\n   */\n  origin: string;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type UncheckedMethod = (...args: any[]) => any;\ntype OriginalMethod = UncheckedMethod;\n\n/**\n * Wraps a method with Sentry error tracking and optional tracing.\n * Supports starting new traces and linking to previous invocations via Durable Object storage.\n *\n * @param wrapperOptions - The options for the wrapper.\n * @param handler - The method to wrap.\n * @param callback - The callback to call.\n * @param noMark - Whether to mark the method as instrumented.\n * @returns The wrapped method.\n */\nexport function wrapMethodWithSentry<T extends OriginalMethod>(\n  wrapperOptions: MethodWrapperOptions,\n  handler: T,\n  callback?: (...args: Parameters<T>) => void,\n  noMark?: true,\n): T {\n  return ensureInstrumented(\n    handler,\n    original =>\n      new Proxy(original, {\n        apply(target, thisArg, rawArgs: Parameters<T>) {\n          const { startNewTrace, origin } = wrapperOptions;\n\n          // For RPC methods, extract Sentry trace context from the trailing argument.\n          // The caller side (instrumentDurableObjectStub / JSRPC proxy) appends it;\n          // we strip it here so the user's method never sees it.\n          let args = rawArgs;\n          let rpcMeta: SerializedTraceData | undefined;\n\n          if (wrapperOptions.spanOp === 'rpc') {\n            const extracted = extractRpcMeta(rawArgs);\n            args = extracted.args;\n            rpcMeta = extracted.rpcMeta;\n          }\n\n          const wrappedFunction = (scope: Scope): unknown | Promise<unknown> => {\n            // In certain situations, the passed context can become undefined.\n            // For example, for Astro while prerendering pages at build time.\n            // see: https://github.com/getsentry/sentry-javascript/issues/13217\n            const context: typeof wrapperOptions.context | undefined = wrapperOptions.context;\n\n            // see: https://github.com/getsentry/sentry-javascript/issues/22328\n            const waitUntil = context\n              ? getOriginalWaitUntil(context as ExecutionContextCompat)?.bind(context)\n              : undefined;\n            const storage = resolveOriginalStorage(context, thisArg);\n\n            let scopeClient = scope.getClient();\n            // Check if client exists AND is still usable (transport not disposed)\n            // This handles the case where a previous handler disposed the client\n            // but the scope still holds a reference to it (e.g., alarm handlers in Durable Objects)\n            // For startNewTrace, always create a fresh client\n            if (startNewTrace || !scopeClient?.getTransport()) {\n              const client = init({\n                ...wrapperOptions.options,\n                ctx: context as unknown as ExecutionContext | undefined,\n              });\n              scope.setClient(client);\n              scopeClient = client;\n            }\n\n            const clientToDispose = scopeClient;\n            const methodName = wrapperOptions.spanName || 'unknown';\n\n            const teardown = async (): Promise<void> => {\n              if (startNewTrace && storage) {\n                storeSpanContext(storage, methodName);\n              }\n              await flushAndDispose(clientToDispose);\n            };\n\n            const onFulfilled = (res: unknown) => {\n              waitUntil?.(teardown());\n              return res;\n            };\n\n            const onRejected = (e: unknown) => {\n              captureException(e, {\n                mechanism: {\n                  type: origin,\n                  handled: false,\n                },\n              });\n              waitUntil?.(teardown());\n              throw e;\n            };\n\n            if (!wrapperOptions.spanName) {\n              try {\n                if (callback) {\n                  callback(...args);\n                }\n\n                const result = Reflect.apply(target, thisArg, args);\n\n                if (isThenable(result)) {\n                  return result.then(onFulfilled, onRejected);\n                } else {\n                  return onFulfilled(result);\n                }\n              } catch (e) {\n                return onRejected(e);\n              }\n            }\n\n            const attributes = wrapperOptions.spanOp\n              ? {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: wrapperOptions.spanOp,\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: origin,\n                }\n              : {};\n\n            const executeSpan = (): unknown => {\n              return startSpan({ name: methodName, attributes }, span => {\n                if (startNewTrace && storage) {\n                  const storedContext = getStoredSpanContext(storage, methodName);\n\n                  if (storedContext) {\n                    span.addLinks(buildSpanLinks(storedContext));\n                    // TODO: Remove this once EAP can store span links. We currently only set this attribute so that we\n                    // can obtain the previous trace information from the EAP store. Long-term, EAP will handle\n                    // span links and then we should remove this again. Also throwing in a TODO(v11), to remind us\n                    // to check this at v11 time :)\n                    const sampledFlag = storedContext.sampled ? '1' : '0';\n                    span.setAttribute(\n                      'sentry.previous_trace',\n                      `${storedContext.traceId}-${storedContext.spanId}-${sampledFlag}`,\n                    );\n                  }\n                }\n\n                try {\n                  const result = Reflect.apply(target, thisArg, args);\n\n                  if (isThenable(result)) {\n                    return result.then(onFulfilled, onRejected);\n                  } else {\n                    return onFulfilled(result);\n                  }\n                } catch (e) {\n                  return onRejected(e);\n                }\n              });\n            };\n\n            if (rpcMeta) {\n              return continueTrace(\n                { sentryTrace: rpcMeta['sentry-trace'] || '', baggage: rpcMeta.baggage || '' },\n                executeSpan,\n              );\n            }\n\n            if (startNewTrace) {\n              return startNewTraceCore(() => executeSpan());\n            }\n\n            return executeSpan();\n          };\n\n          return withInvocationIsolationScope(wrappedFunction);\n        },\n      }),\n    noMark,\n  );\n}\n"],"names":["isObjectLike","ensureInstrumented","rpcMeta","extractRpcMeta","getOriginalWaitUntil","init","storeSpanContext","flushAndDispose","captureException","isThenable","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","startSpan","getStoredSpanContext","buildSpanLinks","continueTrace","startNewTraceCore","withInvocationIsolationScope"],"mappings":"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"}

package/build/cjs/prod/baseSdk.js

@@ -0,0 +1,73 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const client = require('./client.js');
+const flush = require('./flush.js');
+const fetch = require('./integrations/fetch.js');
+const httpServer = require('./integrations/httpServer.js');
+const tracer = require('./opentelemetry/tracer.js');
+const transport = require('./transport.js');
+const stacktrace = require('./vendor/stacktrace.js');
+
+function getRegisteredChannelIntegrations() {
+  const registered = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations;
+  return registered ? [...registered.values()].map((factory) => factory()) : [];
+}
+function getBaseDefaultIntegrations(options) {
+  return [
+    // The Dedupe integration should not be used in workflows because we want to
+    // capture all step failures, even if they are the same error.
+    ...options.enableDedupe === false ? [] : [core.dedupeIntegration()],
+    core.eventFiltersIntegration(),
+    core.functionToStringIntegration(),
+    core.conversationIdIntegration(),
+    core.linkedErrorsIntegration(),
+    fetch.fetchIntegration(),
+    httpServer.httpServerIntegration(),
+    core.requestDataIntegration(),
+    core.consoleIntegration(),
+    // The orchestrion diagnostics-channel subscribers (mysql, pg, …). The
+    // `@sentry/cloudflare/vite` plugin injects the channels at build time and,
+    // next to each, a snippet that registers the matching subscriber factory on
+    // the global marker. Read from there instead of importing them so bundles
+    // built without the plugin — where the channels would never fire — don't
+    // ship the code.
+    ...getRegisteredChannelIntegrations()
+  ];
+}
+function initWithDefaultIntegrations(options, getDefaultIntegrationsImpl) {
+  if (options.defaultIntegrations === void 0) {
+    options.defaultIntegrations = getDefaultIntegrationsImpl(options);
+  }
+  const flushLock = options.ctx ? flush.makeFlushLock(options.ctx) : void 0;
+  delete options.ctx;
+  const clientOptions = {
+    ...options,
+    stackParser: core.stackParserFromStackParserOptions(options.stackParser || stacktrace.defaultStackParser),
+    integrations: core.getIntegrationsToSetup(options),
+    transport: options.transport || transport.makeCloudflareTransport,
+    // Like most Node-based SDKs, Cloudflare defaults to running without a Sentry OpenTelemetry tracer
+    // provider. Scope isolation is handled by the entrypoint wrappers' AsyncLocalStorage strategy.
+    enableOpenTelemetrySetup: options.enableOpenTelemetrySetup ?? false,
+    flushLock
+  };
+  if (clientOptions.enableOpenTelemetrySetup) {
+    tracer.setupOpenTelemetryTracer();
+  }
+  const client$1 = core.initAndBind(client.CloudflareClient, clientOptions);
+  client$1.on("orchestrion.module-injected", (moduleName) => {
+    const factory = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations?.get(moduleName);
+    if (factory) {
+      client$1.addIntegration(factory());
+    }
+  });
+  return client$1;
+}
+function initBaseSdk(options) {
+  return initWithDefaultIntegrations(options, getBaseDefaultIntegrations);
+}
+
+exports.getBaseDefaultIntegrations = getBaseDefaultIntegrations;
+exports.initBaseSdk = initBaseSdk;
+exports.initWithDefaultIntegrations = initWithDefaultIntegrations;
+//# sourceMappingURL=baseSdk.js.map

package/build/cjs/prod/baseSdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseSdk.js","sources":["../../../src/baseSdk.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport {\n  consoleIntegration,\n  conversationIdIntegration,\n  dedupeIntegration,\n  eventFiltersIntegration,\n  functionToStringIntegration,\n  getIntegrationsToSetup,\n  GLOBAL_OBJ,\n  initAndBind,\n  linkedErrorsIntegration,\n  requestDataIntegration,\n  stackParserFromStackParserOptions,\n} from '@sentry/core';\nimport type { CloudflareClientOptions, CloudflareOptions } from './client';\nimport { CloudflareClient } from './client';\nimport { makeFlushLock } from './flush';\nimport { fetchIntegration } from './integrations/fetch';\nimport { httpServerIntegration } from './integrations/httpServer';\nimport { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration } from './integrations/spotlight';\nimport { setupOpenTelemetryTracer } from './opentelemetry/tracer';\nimport { makeCloudflareTransport } from './transport';\nimport { defaultStackParser } from './vendor/stacktrace';\n\n/**\n * Instantiate the channel-subscriber factories the `@sentry/cloudflare/vite`\n * plugin registered on the global marker. The plugin splices a small snippet\n * into each instrumented module that `.set`s its factory here (keyed by module\n * name), so the marker holds one factory per package actually bundled.\n *\n * The marker is read directly instead of importing the factories, so a worker\n * built without the plugin — where the channels never fire — ships none of this\n * code.\n * TODO(v11): Use `@sentry/server-utils/orchestrion` once we move to `nodejs_compat` by default.\n */\nfunction getRegisteredChannelIntegrations(): Integration[] {\n  const registered = GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations;\n\n  return registered ? [...registered.values()].map(factory => factory()) : [];\n}\n\n/**\n * Get the default integrations that run on any Workers-compatible runtime, i.e. without the\n * `nodejs_compat` compatibility flag.\n *\n * `getDefaultIntegrations` in `sdk.ts` extends this set with the integrations that do depend on\n * Node.js APIs. Keeping the two apart is what allows `wrapRequestHandler` to stay usable on runtimes\n * that cannot enable `nodejs_compat`, such as Shopify Oxygen.\n */\nexport function getBaseDefaultIntegrations(options: CloudflareOptions): Integration[] {\n  return [\n    // The Dedupe integration should not be used in workflows because we want to\n    // capture all step failures, even if they are the same error.\n    ...(options.enableDedupe === false ? [] : [dedupeIntegration()]),\n    eventFiltersIntegration(),\n    functionToStringIntegration(),\n    conversationIdIntegration(),\n    linkedErrorsIntegration(),\n    fetchIntegration(),\n    httpServerIntegration(),\n    requestDataIntegration(),\n    consoleIntegration(),\n    // The orchestrion diagnostics-channel subscribers (mysql, pg, …). The\n    // `@sentry/cloudflare/vite` plugin injects the channels at build time and,\n    // next to each, a snippet that registers the matching subscriber factory on\n    // the global marker. Read from there instead of importing them so bundles\n    // built without the plugin — where the channels would never fire — don't\n    // ship the code.\n    ...getRegisteredChannelIntegrations(),\n  ];\n}\n\n/**\n * Initializes the Cloudflare SDK with the passed default integrations.\n *\n * The default integrations are injected rather than imported so that this module stays free of\n * Node.js-only code. `request.ts` — which backs both `wrapRequestHandler` and the\n * `@sentry/cloudflare/request` entry point, and therefore has to work on runtimes without the\n * `nodejs_compat` compatibility flag — creates its client from here instead of from `sdk.ts`.\n */\nexport function initWithDefaultIntegrations(\n  options: CloudflareOptions,\n  getDefaultIntegrationsImpl: (options: CloudflareOptions) => Integration[],\n): CloudflareClient | undefined {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = getDefaultIntegrationsImpl(options);\n  }\n\n  const flushLock = options.ctx ? makeFlushLock(options.ctx) : undefined;\n  delete options.ctx;\n\n  const clientOptions: CloudflareClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || makeCloudflareTransport,\n    // Like most Node-based SDKs, Cloudflare defaults to running without a Sentry OpenTelemetry tracer\n    // provider. Scope isolation is handled by the entrypoint wrappers' AsyncLocalStorage strategy.\n    enableOpenTelemetrySetup: options.enableOpenTelemetrySetup ?? false,\n    flushLock,\n  };\n\n  /*! rollup-include-development-only */\n  if (options.spotlight && !clientOptions.integrations.some(({ name }) => name === SPOTLIGHT_INTEGRATION_NAME)) {\n    clientOptions.integrations.push(\n      spotlightIntegration({\n        sidecarUrl: typeof options.spotlight === 'string' ? options.spotlight : undefined,\n      }),\n    );\n  }\n  /*! rollup-include-development-only-end */\n\n  // Opt-in only: when `enableOpenTelemetrySetup` is `true`, set up a custom trace provider so spans\n  // emitted via `@opentelemetry/api` are captured by Sentry. See the option's docs for the caveats.\n  if (clientOptions.enableOpenTelemetrySetup) {\n    setupOpenTelemetryTracer();\n  }\n\n  const client = initAndBind(CloudflareClient, clientOptions) as CloudflareClient;\n\n  // An instrumented module that first evaluates AFTER this init (e.g. a driver\n  // lazily required on first use) stores its subscriber factory on the global\n  // marker too late for the default-integrations snapshot above. Its injected\n  // snippet emits this event right after storing the factory, so install the\n  // integration on the live client here. `addIntegration` dedupes by\n  // integration name, so already-installed integrations are no-ops.\n  client.on('orchestrion.module-injected', moduleName => {\n    const factory = GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations?.get(moduleName);\n    if (factory) {\n      client.addIntegration(factory());\n    }\n  });\n\n  return client;\n}\n\n/**\n * Initializes the Cloudflare SDK with only the default integrations from\n * {@link getBaseDefaultIntegrations}, i.e. those that work without the `nodejs_compat`\n * compatibility flag.\n */\nexport function initBaseSdk(options: CloudflareOptions): CloudflareClient | undefined {\n  return initWithDefaultIntegrations(options, getBaseDefaultIntegrations);\n}\n"],"names":["GLOBAL_OBJ","dedupeIntegration","eventFiltersIntegration","functionToStringIntegration","conversationIdIntegration","linkedErrorsIntegration","fetchIntegration","httpServerIntegration","requestDataIntegration","consoleIntegration","makeFlushLock","stackParserFromStackParserOptions","defaultStackParser","getIntegrationsToSetup","makeCloudflareTransport","setupOpenTelemetryTracer","client","initAndBind","CloudflareClient"],"mappings":";;;;;;;;;;;AAmCA,SAAS,gCAAA,GAAkD;AACzD,EAAA,MAAM,UAAA,GAAaA,gBAAW,sBAAA,EAAwB,YAAA;AAEtD,EAAA,OAAO,UAAA,GAAa,CAAC,GAAG,UAAA,CAAW,MAAA,EAAQ,CAAA,CAAE,GAAA,CAAI,CAAA,OAAA,KAAW,OAAA,EAAS,CAAA,GAAI,EAAC;AAC5E;AAUO,SAAS,2BAA2B,OAAA,EAA2C;AACpF,EAAA,OAAO;AAAA;AAAA;AAAA,IAGL,GAAI,QAAQ,YAAA,KAAiB,KAAA,GAAQ,EAAC,GAAI,CAACC,wBAAmB,CAAA;AAAA,IAC9DC,4BAAA,EAAwB;AAAA,IACxBC,gCAAA,EAA4B;AAAA,IAC5BC,8BAAA,EAA0B;AAAA,IAC1BC,4BAAA,EAAwB;AAAA,IACxBC,sBAAA,EAAiB;AAAA,IACjBC,gCAAA,EAAsB;AAAA,IACtBC,2BAAA,EAAuB;AAAA,IACvBC,uBAAA,EAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOnB,GAAG,gCAAA;AAAiC,GACtC;AACF;AAUO,SAAS,2BAAA,CACd,SACA,0BAAA,EAC8B;AAC9B,EAAA,IAAI,OAAA,CAAQ,wBAAwB,MAAA,EAAW;AAC7C,IAAA,OAAA,CAAQ,mBAAA,GAAsB,2BAA2B,OAAO,CAAA;AAAA,EAClE;AAEA,EAAA,MAAM,YAAY,OAAA,CAAQ,GAAA,GAAMC,mBAAA,CAAc,OAAA,CAAQ,GAAG,CAAA,GAAI,MAAA;AAC7D,EAAA,OAAO,OAAA,CAAQ,GAAA;AAEf,EAAA,MAAM,aAAA,GAAyC;AAAA,IAC7C,GAAG,OAAA;AAAA,IACH,WAAA,EAAaC,sCAAA,CAAkC,OAAA,CAAQ,WAAA,IAAeC,6BAAkB,CAAA;AAAA,IACxF,YAAA,EAAcC,4BAAuB,OAAO,CAAA;AAAA,IAC5C,SAAA,EAAW,QAAQ,SAAA,IAAaC,iCAAA;AAAA;AAAA;AAAA,IAGhC,wBAAA,EAA0B,QAAQ,wBAAA,IAA4B,KAAA;AAAA,IAC9D;AAAA,GACF;AAIA,EAAA,IAAI,cAAc,wBAAA,EAA0B;AAC1C,IAAAC,+BAAA,EAAyB;AAAA,EAC3B;AAEA,EAAA,MAAMC,QAAA,GAASC,gBAAA,CAAYC,uBAAA,EAAkB,aAAa,CAAA;AAQ1D,EAAAF,QAAA,CAAO,EAAA,CAAG,+BAA+B,CAAA,UAAA,KAAc;AACrD,IAAA,MAAM,OAAA,GAAUhB,eAAA,CAAW,sBAAA,EAAwB,YAAA,EAAc,IAAI,UAAU,CAAA;AAC/E,IAAA,IAAI,OAAA,EAAS;AACX,MAAAgB,QAAA,CAAO,cAAA,CAAe,SAAS,CAAA;AAAA,IACjC;AAAA,EACF,CAAC,CAAA;AAED,EAAA,OAAOA,QAAA;AACT;AAOO,SAAS,YAAY,OAAA,EAA0D;AACpF,EAAA,OAAO,2BAAA,CAA4B,SAAS,0BAA0B,CAAA;AACxE;;;;;;"}

package/build/cjs/prod/client.js

@@ -0,0 +1,122 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const debugBuild = require('./debug-build.js');
+
+class CloudflareClient extends core.ServerRuntimeClient {
+  /**
+   * Creates a new Cloudflare SDK instance.
+   * @param options Configuration options for this SDK.
+   */
+  constructor(options) {
+    core.applySdkMetadata(options, "cloudflare");
+    options._metadata = options._metadata || {};
+    const { flushLock, ...serverOptions } = options;
+    const clientOptions = {
+      ...serverOptions,
+      platform: "javascript",
+      // TODO: Grab version information
+      runtime: { name: "cloudflare" },
+      // TODO: Add server name
+      _flushInterval: 0
+    };
+    super(clientOptions);
+    this._pendingSpans = /* @__PURE__ */ new Set();
+    this._spanCompletionPromise = null;
+    this._resolveSpanCompletion = null;
+    this._unsubscribeSpanStart = null;
+    this._unsubscribeSpanEnd = null;
+    this._flushLock = flushLock;
+    this._unsubscribeSpanStart = this.on("spanStart", (span) => {
+      const spanId = span.spanContext().spanId;
+      debugBuild.DEBUG_BUILD && core.debug.log("[CloudflareClient] Span started:", spanId);
+      if (!core.spanIsSampled(span)) {
+        return;
+      }
+      this._pendingSpans.add(spanId);
+      if (!this._spanCompletionPromise) {
+        this._spanCompletionPromise = new Promise((resolve) => {
+          this._resolveSpanCompletion = resolve;
+        });
+      }
+    });
+    this._unsubscribeSpanEnd = this.on("spanEnd", (span) => {
+      const spanId = span.spanContext().spanId;
+      debugBuild.DEBUG_BUILD && core.debug.log("[CloudflareClient] Span ended:", spanId);
+      this._pendingSpans.delete(spanId);
+      if (this._pendingSpans.size === 0 && this._resolveSpanCompletion) {
+        debugBuild.DEBUG_BUILD && core.debug.log("[CloudflareClient] All spans completed, resolving promise");
+        this._resolveSpanCompletion();
+        this._resetSpanCompletionPromise();
+      }
+    });
+  }
+  /**
+   * Flushes pending operations and ensures all data is processed.
+   * If a timeout is provided, the operation will be completed within the specified time limit.
+   *
+   * It will wait for all pending spans to complete before flushing.
+   *
+   * @param {number} [timeout] - Optional timeout in milliseconds to force the completion of the flush operation.
+   * @return {Promise<boolean>} A promise that resolves to a boolean indicating whether the flush operation was successful.
+   */
+  async flush(timeout) {
+    if (this._flushLock) {
+      await this._flushLock.finalize();
+    }
+    if (this._pendingSpans.size > 0 && this._spanCompletionPromise) {
+      debugBuild.DEBUG_BUILD && core.debug.log("[CloudflareClient] Waiting for", this._pendingSpans.size, "pending spans to complete...");
+      const timeoutMs = timeout ?? 5e3;
+      const spanCompletionRace = Promise.race([
+        this._spanCompletionPromise,
+        new Promise(
+          (resolve) => setTimeout(() => {
+            debugBuild.DEBUG_BUILD && core.debug.log("[CloudflareClient] Span completion timeout after", timeoutMs, "ms, flushing anyway");
+            resolve(void 0);
+          }, timeoutMs)
+        )
+      ]);
+      await spanCompletionRace;
+    }
+    return super.flush(timeout);
+  }
+  /**
+   * Disposes of the client and releases all resources.
+   *
+   * This method clears all Cloudflare-specific state in addition to the base client cleanup.
+   * It unsubscribes from span lifecycle events and clears pending span tracking.
+   *
+   * Call this method after flushing to allow the client to be garbage collected.
+   * After calling dispose(), the client should not be used anymore.
+   */
+  dispose() {
+    debugBuild.DEBUG_BUILD && core.debug.log("[CloudflareClient] Disposing client...");
+    super.dispose();
+    if (this._unsubscribeSpanStart) {
+      this._unsubscribeSpanStart();
+      this._unsubscribeSpanStart = null;
+    }
+    if (this._unsubscribeSpanEnd) {
+      this._unsubscribeSpanEnd();
+      this._unsubscribeSpanEnd = null;
+    }
+    this._resetSpanCompletionPromise();
+    this._flushLock = void 0;
+  }
+  /** @inheritDoc */
+  _setupIntegrations() {
+    core._INTERNAL_clearAiProviderSkips();
+    super._setupIntegrations();
+  }
+  /**
+   * Resets the span completion promise and resolve function.
+   */
+  _resetSpanCompletionPromise() {
+    this._pendingSpans.clear();
+    this._spanCompletionPromise = null;
+    this._resolveSpanCompletion = null;
+  }
+}
+
+exports.CloudflareClient = CloudflareClient;
+//# sourceMappingURL=client.js.map

package/build/cjs/prod/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":["../../../src/client.ts"],"sourcesContent":["import type { ClientOptions, Options, ServerRuntimeClientOptions } from '@sentry/core';\nimport {\n  _INTERNAL_clearAiProviderSkips,\n  applySdkMetadata,\n  debug,\n  ServerRuntimeClient,\n  spanIsSampled,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { ExecutionContextCompat } from './executionContext';\nimport type { makeFlushLock } from './flush';\nimport type { CloudflareTransportOptions } from './transport';\n\n/**\n * The Sentry Cloudflare SDK Client.\n *\n * @see CloudflareClientOptions for documentation on configuration options.\n * @see ServerRuntimeClient for usage documentation.\n */\nexport class CloudflareClient extends ServerRuntimeClient {\n  private readonly _flushLock: ReturnType<typeof makeFlushLock> | void;\n  private _pendingSpans: Set<string> = new Set();\n  private _spanCompletionPromise: Promise<void> | null = null;\n  private _resolveSpanCompletion: (() => void) | null = null;\n\n  private _unsubscribeSpanStart: (() => void) | null = null;\n  private _unsubscribeSpanEnd: (() => void) | null = null;\n\n  /**\n   * Creates a new Cloudflare SDK instance.\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: CloudflareClientOptions) {\n    applySdkMetadata(options, 'cloudflare');\n    options._metadata = options._metadata || {};\n    const { flushLock, ...serverOptions } = options;\n\n    const clientOptions: ServerRuntimeClientOptions = {\n      ...serverOptions,\n      platform: 'javascript',\n      // TODO: Grab version information\n      runtime: { name: 'cloudflare' },\n      // TODO: Add server name\n      _flushInterval: 0,\n    };\n\n    super(clientOptions);\n    this._flushLock = flushLock;\n\n    // Track span lifecycle to know when to flush\n    this._unsubscribeSpanStart = this.on('spanStart', span => {\n      const spanId = span.spanContext().spanId;\n      DEBUG_BUILD && debug.log('[CloudflareClient] Span started:', spanId);\n\n      // Negatively sampled spans never emit spanEnd,\n      // so tracking them would cause _pendingSpans to grow unboundedly.\n      // We should fix the inconsistent behavior for NonRecordingSpans in the future but\n      // for now, we just ignore them.\n      if (!spanIsSampled(span)) {\n        return;\n      }\n\n      this._pendingSpans.add(spanId);\n\n      if (!this._spanCompletionPromise) {\n        this._spanCompletionPromise = new Promise(resolve => {\n          this._resolveSpanCompletion = resolve;\n        });\n      }\n    });\n\n    this._unsubscribeSpanEnd = this.on('spanEnd', span => {\n      const spanId = span.spanContext().spanId;\n      DEBUG_BUILD && debug.log('[CloudflareClient] Span ended:', spanId);\n      this._pendingSpans.delete(spanId);\n\n      // If no more pending spans, resolve the completion promise\n      if (this._pendingSpans.size === 0 && this._resolveSpanCompletion) {\n        DEBUG_BUILD && debug.log('[CloudflareClient] All spans completed, resolving promise');\n        this._resolveSpanCompletion();\n        this._resetSpanCompletionPromise();\n      }\n    });\n  }\n\n  /**\n   * Flushes pending operations and ensures all data is processed.\n   * If a timeout is provided, the operation will be completed within the specified time limit.\n   *\n   * It will wait for all pending spans to complete before flushing.\n   *\n   * @param {number} [timeout] - Optional timeout in milliseconds to force the completion of the flush operation.\n   * @return {Promise<boolean>} A promise that resolves to a boolean indicating whether the flush operation was successful.\n   */\n  public async flush(timeout?: number): Promise<boolean> {\n    if (this._flushLock) {\n      await this._flushLock.finalize();\n    }\n\n    if (this._pendingSpans.size > 0 && this._spanCompletionPromise) {\n      DEBUG_BUILD &&\n        debug.log('[CloudflareClient] Waiting for', this._pendingSpans.size, 'pending spans to complete...');\n\n      const timeoutMs = timeout ?? 5000;\n      const spanCompletionRace = Promise.race([\n        this._spanCompletionPromise,\n        new Promise(resolve =>\n          setTimeout(() => {\n            DEBUG_BUILD &&\n              debug.log('[CloudflareClient] Span completion timeout after', timeoutMs, 'ms, flushing anyway');\n            resolve(undefined);\n          }, timeoutMs),\n        ),\n      ]);\n\n      await spanCompletionRace;\n    }\n\n    return super.flush(timeout);\n  }\n\n  /**\n   * Disposes of the client and releases all resources.\n   *\n   * This method clears all Cloudflare-specific state in addition to the base client cleanup.\n   * It unsubscribes from span lifecycle events and clears pending span tracking.\n   *\n   * Call this method after flushing to allow the client to be garbage collected.\n   * After calling dispose(), the client should not be used anymore.\n   */\n  public override dispose(): void {\n    DEBUG_BUILD && debug.log('[CloudflareClient] Disposing client...');\n\n    super.dispose();\n\n    if (this._unsubscribeSpanStart) {\n      this._unsubscribeSpanStart();\n      this._unsubscribeSpanStart = null;\n    }\n    if (this._unsubscribeSpanEnd) {\n      this._unsubscribeSpanEnd();\n      this._unsubscribeSpanEnd = null;\n    }\n\n    this._resetSpanCompletionPromise();\n    (this as unknown as { _flushLock: ReturnType<typeof makeFlushLock> | void })._flushLock = undefined;\n  }\n\n  /** @inheritDoc */\n  protected override _setupIntegrations(): void {\n    // Clear AI provider skip registrations before setting up integrations.\n    // The registry is module-global and Cloudflare calls `init()` per request, so without this a\n    // single `ai` SDK call would suppress direct `env.AI.run` spans for the rest of the isolate's\n    // life. Mirrors the same reset in the Node client.\n    _INTERNAL_clearAiProviderSkips();\n    super._setupIntegrations();\n  }\n\n  /**\n   * Resets the span completion promise and resolve function.\n   */\n  private _resetSpanCompletionPromise(): void {\n    this._pendingSpans.clear();\n    this._spanCompletionPromise = null;\n    this._resolveSpanCompletion = null;\n  }\n}\n\ninterface BaseCloudflareOptions {\n  /**\n   * @ignore Used internally to disable the deDupeIntegration for workflows.\n   * @hidden Used internally to disable the deDupeIntegration for workflows.\n   * @default true\n   */\n  enableDedupe?: boolean;\n\n  /**\n   * The Cloudflare SDK is not OpenTelemetry native. By default (`false`) it does not set up a tracer\n   * provider; spans are emitted via the SDK's own instrumentation and scopes are isolated with\n   * AsyncLocalStorage.\n   *\n   * Set this to `true` to opt into the OpenTelemetry compatibility tracer, which captures spans\n   * emitted via `@opentelemetry/api`. Big caveat: it does not handle custom context, always working\n   * off the current scope. This is good enough for many, but not all, integrations.\n   *\n   * @default false\n   */\n  enableOpenTelemetrySetup?: boolean;\n\n  /**\n   * Enable trace propagation for RPC calls between Workers, Durable Objects, and Service Bindings.\n   *\n   * When enabled, trace context (sentry-trace + baggage) is propagated across:\n   * - `stub.fetch()` calls to Durable Objects (via HTTP headers)\n   * - Service binding `fetch()` calls (via HTTP headers)\n   * - RPC method calls to Durable Objects and WorkerEntrypoints (via trailing argument)\n   *\n   * When enabled on the **receiver side** (DurableObject or WorkerEntrypoint), the SDK will also:\n   * - Extract and continue traces from incoming RPC calls\n   * - Create spans for each RPC method invocation\n   * - Capture errors thrown by RPC methods\n   *\n   * **Important:** This option is enabled by default. Set it to `false` to opt out, e.g. if you\n   * do not want trace context to leave your Worker via RPC calls.\n   *\n   * @default true\n   * @example\n   * ```ts\n   * // Opt out of RPC trace propagation\n   * export default Sentry.withSentry(\n   *   (env) => ({\n   *     dsn: env.SENTRY_DSN,\n   *     enableRpcTracePropagation: false,\n   *   }),\n   *   handler,\n   * );\n   * ```\n   */\n  enableRpcTracePropagation?: boolean;\n\n  /**\n   * Table names that should stay instrumented even though they match the reserved `cf_` prefix used\n   * by Durable Object frameworks (`agents`, `partyserver`, ...) for their internal SQLite tables.\n   *\n   * By default, `exec` queries against `cf_`-prefixed tables are treated as framework noise and no\n   * `db.query` span is created for them. If one of your own tables happens to use this prefix, add it\n   * here to opt it back into instrumentation. Entries are matched against each table name in the\n   * query summary — strings must match exactly, while regular expressions give you prefix/pattern\n   * matching.\n   *\n   * @default []\n   * @example\n   * ```ts\n   * export default Sentry.withSentry(\n   *   (env) => ({\n   *     dsn: env.SENTRY_DSN,\n   *     durableObjectSqlSpanAllowlist: ['cf_my_table', /^cf_reports_/],\n   *   }),\n   *   handler,\n   * );\n   * ```\n   */\n  durableObjectSqlSpanAllowlist?: Array<string | RegExp>;\n\n  /**\n   * KV keys that should stay instrumented even though they match a reserved prefix used by Durable\n   * Object frameworks (`agents`, `partyserver`, ...) for their internal storage entries.\n   *\n   * By default, KV reads/writes (`get`, `put`, `delete`, `list`) of `cf_`- or `__ps_`-prefixed keys\n   * are treated as framework noise and no `durable_object_storage_*` span is created for them,\n   * mirroring how `cf_`-prefixed SQL tables are handled (see {@link durableObjectSqlSpanAllowlist}).\n   * If one of your own keys happens to use such a prefix, add it here to opt it back into\n   * instrumentation. Strings must match exactly, while regular expressions give you prefix/pattern\n   * matching.\n   *\n   * @default []\n   * @example\n   * ```ts\n   * export default Sentry.withSentry(\n   *   (env) => ({\n   *     dsn: env.SENTRY_DSN,\n   *     durableObjectStorageSpanAllowlist: ['cf_my_key', /^cf_reports_/],\n   *   }),\n   *   handler,\n   * );\n   * ```\n   */\n  durableObjectStorageSpanAllowlist?: Array<string | RegExp>;\n\n  /**\n   * If you use Spotlight by Sentry during development, use\n   * this option to forward captured Sentry events to Spotlight.\n   *\n   * Either set it to true, or provide a specific Spotlight Sidecar URL.\n   *\n   * More details: https://spotlightjs.com/\n   *\n   * IMPORTANT: Only set this option to `true` while developing, not in production!\n   */\n  spotlight?: boolean | string;\n}\n\n/**\n * Configuration options for the Sentry Cloudflare SDK\n *\n * @see @sentry/core Options for more information.\n */\nexport interface CloudflareOptions extends Options<CloudflareTransportOptions>, BaseCloudflareOptions {\n  ctx?: ExecutionContextCompat;\n}\n\n/**\n * Configuration options for the Sentry Cloudflare SDK Client class\n *\n * @see CloudflareClient for more information.\n */\nexport interface CloudflareClientOptions extends ClientOptions<CloudflareTransportOptions>, BaseCloudflareOptions {\n  flushLock?: ReturnType<typeof makeFlushLock>;\n}\n"],"names":["ServerRuntimeClient","applySdkMetadata","DEBUG_BUILD","debug","spanIsSampled","_INTERNAL_clearAiProviderSkips"],"mappings":";;;;;AAmBO,MAAM,yBAAyBA,wBAAA,CAAoB;AAAA;AAAA;AAAA;AAAA;AAAA,EAajD,YAAY,OAAA,EAAkC;AACnD,IAAAC,qBAAA,CAAiB,SAAS,YAAY,CAAA;AACtC,IAAA,OAAA,CAAQ,SAAA,GAAY,OAAA,CAAQ,SAAA,IAAa,EAAC;AAC1C,IAAA,MAAM,EAAE,SAAA,EAAW,GAAG,aAAA,EAAc,GAAI,OAAA;AAExC,IAAA,MAAM,aAAA,GAA4C;AAAA,MAChD,GAAG,aAAA;AAAA,MACH,QAAA,EAAU,YAAA;AAAA;AAAA,MAEV,OAAA,EAAS,EAAE,IAAA,EAAM,YAAA,EAAa;AAAA;AAAA,MAE9B,cAAA,EAAgB;AAAA,KAClB;AAEA,IAAA,KAAA,CAAM,aAAa,CAAA;AAzBrB,IAAA,IAAA,CAAQ,aAAA,uBAAiC,GAAA,EAAI;AAC7C,IAAA,IAAA,CAAQ,sBAAA,GAA+C,IAAA;AACvD,IAAA,IAAA,CAAQ,sBAAA,GAA8C,IAAA;AAEtD,IAAA,IAAA,CAAQ,qBAAA,GAA6C,IAAA;AACrD,IAAA,IAAA,CAAQ,mBAAA,GAA2C,IAAA;AAqBjD,IAAA,IAAA,CAAK,UAAA,GAAa,SAAA;AAGlB,IAAA,IAAA,CAAK,qBAAA,GAAwB,IAAA,CAAK,EAAA,CAAG,WAAA,EAAa,CAAA,IAAA,KAAQ;AACxD,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA;AAClC,MAAAC,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,kCAAA,EAAoC,MAAM,CAAA;AAMnE,MAAA,IAAI,CAACC,kBAAA,CAAc,IAAI,CAAA,EAAG;AACxB,QAAA;AAAA,MACF;AAEA,MAAA,IAAA,CAAK,aAAA,CAAc,IAAI,MAAM,CAAA;AAE7B,MAAA,IAAI,CAAC,KAAK,sBAAA,EAAwB;AAChC,QAAA,IAAA,CAAK,sBAAA,GAAyB,IAAI,OAAA,CAAQ,CAAA,OAAA,KAAW;AACnD,UAAA,IAAA,CAAK,sBAAA,GAAyB,OAAA;AAAA,QAChC,CAAC,CAAA;AAAA,MACH;AAAA,IACF,CAAC,CAAA;AAED,IAAA,IAAA,CAAK,mBAAA,GAAsB,IAAA,CAAK,EAAA,CAAG,SAAA,EAAW,CAAA,IAAA,KAAQ;AACpD,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA;AAClC,MAAAF,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,gCAAA,EAAkC,MAAM,CAAA;AACjE,MAAA,IAAA,CAAK,aAAA,CAAc,OAAO,MAAM,CAAA;AAGhC,MAAA,IAAI,IAAA,CAAK,aAAA,CAAc,IAAA,KAAS,CAAA,IAAK,KAAK,sBAAA,EAAwB;AAChE,QAAAD,sBAAA,IAAeC,UAAA,CAAM,IAAI,2DAA2D,CAAA;AACpF,QAAA,IAAA,CAAK,sBAAA,EAAuB;AAC5B,QAAA,IAAA,CAAK,2BAAA,EAA4B;AAAA,MACnC;AAAA,IACF,CAAC,CAAA;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAa,MAAM,OAAA,EAAoC;AACrD,IAAA,IAAI,KAAK,UAAA,EAAY;AACnB,MAAA,MAAM,IAAA,CAAK,WAAW,QAAA,EAAS;AAAA,IACjC;AAEA,IAAA,IAAI,IAAA,CAAK,aAAA,CAAc,IAAA,GAAO,CAAA,IAAK,KAAK,sBAAA,EAAwB;AAC9D,MAAAD,sBAAA,IACEC,WAAM,GAAA,CAAI,gCAAA,EAAkC,IAAA,CAAK,aAAA,CAAc,MAAM,8BAA8B,CAAA;AAErG,MAAA,MAAM,YAAY,OAAA,IAAW,GAAA;AAC7B,MAAA,MAAM,kBAAA,GAAqB,QAAQ,IAAA,CAAK;AAAA,QACtC,IAAA,CAAK,sBAAA;AAAA,QACL,IAAI,OAAA;AAAA,UAAQ,CAAA,OAAA,KACV,WAAW,MAAM;AACf,YAAAD,sBAAA,IACEC,UAAA,CAAM,GAAA,CAAI,kDAAA,EAAoD,SAAA,EAAW,qBAAqB,CAAA;AAChG,YAAA,OAAA,CAAQ,MAAS,CAAA;AAAA,UACnB,GAAG,SAAS;AAAA;AACd,OACD,CAAA;AAED,MAAA,MAAM,kBAAA;AAAA,IACR;AAEA,IAAA,OAAO,KAAA,CAAM,MAAM,OAAO,CAAA;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWgB,OAAA,GAAgB;AAC9B,IAAAD,sBAAA,IAAeC,UAAA,CAAM,IAAI,wCAAwC,CAAA;AAEjE,IAAA,KAAA,CAAM,OAAA,EAAQ;AAEd,IAAA,IAAI,KAAK,qBAAA,EAAuB;AAC9B,MAAA,IAAA,CAAK,qBAAA,EAAsB;AAC3B,MAAA,IAAA,CAAK,qBAAA,GAAwB,IAAA;AAAA,IAC/B;AACA,IAAA,IAAI,KAAK,mBAAA,EAAqB;AAC5B,MAAA,IAAA,CAAK,mBAAA,EAAoB;AACzB,MAAA,IAAA,CAAK,mBAAA,GAAsB,IAAA;AAAA,IAC7B;AAEA,IAAA,IAAA,CAAK,2BAAA,EAA4B;AACjC,IAAC,KAA4E,UAAA,GAAa,MAAA;AAAA,EAC5F;AAAA;AAAA,EAGmB,kBAAA,GAA2B;AAK5C,IAAAE,mCAAA,EAA+B;AAC/B,IAAA,KAAA,CAAM,kBAAA,EAAmB;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKQ,2BAAA,GAAoC;AAC1C,IAAA,IAAA,CAAK,cAAc,KAAA,EAAM;AACzB,IAAA,IAAA,CAAK,sBAAA,GAAyB,IAAA;AAC9B,IAAA,IAAA,CAAK,sBAAA,GAAyB,IAAA;AAAA,EAChC;AACF;;;;"}

package/build/cjs/prod/debug-build.js

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
+
+exports.DEBUG_BUILD = DEBUG_BUILD;
+//# sourceMappingURL=debug-build.js.map

package/build/cjs/prod/debug-build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-build.js","sources":["../../../src/debug-build.ts"],"sourcesContent":["declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n"],"names":[],"mappings":";;AAOO,MAAM,WAAA,IAAc,OAAA,gBAAA,KAAA,WAAA,IAAA,gBAAA;;;;"}

package/build/cjs/prod/defineCloudflareOptions.js

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function defineCloudflareOptions(optionsOrCallback) {
+  if (typeof optionsOrCallback === "function") {
+    return optionsOrCallback;
+  }
+  return () => optionsOrCallback;
+}
+
+exports.defineCloudflareOptions = defineCloudflareOptions;
+//# sourceMappingURL=defineCloudflareOptions.js.map

package/build/cjs/prod/defineCloudflareOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineCloudflareOptions.js","sources":["../../../src/defineCloudflareOptions.ts"],"sourcesContent":["import type { CloudflareOptions } from './client';\nimport type { DefaultEnv } from './types';\n\n/**\n * Define the Sentry options for a Cloudflare Worker in a dedicated module.\n *\n * This is the recommended way to configure the SDK when using the Vite plugin's\n * auto-instrumentation: place an `instrument.server.{ts,js,mjs}` file next to\n * the worker entry whose **default export** is the result of this function. The\n * plugin picks it up automatically and hands it to `withSentry`.\n *\n * Unlike Node's `Sentry.init(...)`, the options cannot be applied at module\n * load time on Cloudflare: the DSN and other settings typically come from the\n * per-request `env`, which only exists inside the handler. Pass a callback to\n * read from `env`, or a static object when no `env` access is needed — either\n * way you get full type-checking and autocomplete on {@link CloudflareOptions}.\n *\n * At runtime this is a thin pass-through; it only normalizes a static object\n * into a callback so the plugin always imports a `(env) => options` function.\n *\n * @example\n * ```ts\n * // src/instrument.server.ts\n * import { defineCloudflareOptions } from '@sentry/cloudflare';\n *\n * export default defineCloudflareOptions((env) => ({\n *   dsn: env.SENTRY_DSN,\n *   tracesSampleRate: 1.0,\n * }));\n * ```\n *\n * @example\n * ```ts\n * // Static options — no `env` access needed\n * export default defineCloudflareOptions({ tracesSampleRate: 1.0 });\n * ```\n */\nexport function defineCloudflareOptions<Env = DefaultEnv>(\n  optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined),\n): (env: Env) => CloudflareOptions | undefined {\n  if (typeof optionsOrCallback === 'function') {\n    return optionsOrCallback;\n  }\n\n  return () => optionsOrCallback;\n}\n"],"names":[],"mappings":";;AAqCO,SAAS,wBACd,iBAAA,EAC6C;AAC7C,EAAA,IAAI,OAAO,sBAAsB,UAAA,EAAY;AAC3C,IAAA,OAAO,iBAAA;AAAA,EACT;AAEA,EAAA,OAAO,MAAM,iBAAA;AACf;;;;"}