@wix/cli-app 1.1.86 → 1.1.87

package/build/cloudflare-runtime/entry.js

@@ -3635,11 +3635,11 @@ async function importWithAlgCache(cache, jwk, alg) {
   return cached[alg];
 }
 function createLocalJWKSet(jwks) {
-  const set = new LocalJWKSet(jwks);
-  const localJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
+  const set2 = new LocalJWKSet(jwks);
+  const localJWKSet = async (protectedHeader, token) => set2.getKey(protectedHeader, token);
   Object.defineProperties(localJWKSet, {
     jwks: {
-      value: () => clone(set._jwks),
+      value: () => clone(set2._jwks),
       enumerable: true,
       configurable: false,
       writable: false
@@ -3784,32 +3784,32 @@ function isFreshJwksCache(input, cacheMaxAge) {
   return true;
 }
 function createRemoteJWKSet(url, options) {
-  const set = new RemoteJWKSet(url, options);
-  const remoteJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
+  const set2 = new RemoteJWKSet(url, options);
+  const remoteJWKSet = async (protectedHeader, token) => set2.getKey(protectedHeader, token);
   Object.defineProperties(remoteJWKSet, {
     coolingDown: {
-      get: () => set.coolingDown(),
+      get: () => set2.coolingDown(),
       enumerable: true,
       configurable: false
     },
     fresh: {
-      get: () => set.fresh(),
+      get: () => set2.fresh(),
       enumerable: true,
       configurable: false
     },
     reload: {
-      value: () => set.reload(),
+      value: () => set2.reload(),
       enumerable: true,
       configurable: false,
       writable: false
     },
     reloading: {
-      get: () => !!set._pendingFetch,
+      get: () => !!set2._pendingFetch,
       enumerable: true,
       configurable: false
     },
     jwks: {
-      value: () => set._local?.jwks(),
+      value: () => set2._local?.jwks(),
       enumerable: true,
       configurable: false,
       writable: false
@@ -5591,7 +5591,19 @@ var FallbackMonitoringClient = class {
     };
     this.startSpan = (spanOptions, callback) => {
       console.error(this.message);
-      return Promise.resolve(callback(void 0));
+      return callback(void 0);
+    };
+    this.startSpanManual = () => {
+      console.error(this.message);
+      return {
+        end: () => {
+        },
+        fail: () => {
+        }
+      };
+    };
+    this.endSpanManual = () => {
+      console.error(this.message);
     };
     this.addBreadcrumb = () => {
       console.error(this.message);
@@ -5602,6 +5614,83 @@ var createFallbackMonitoringClient = (message2) => {
   return new FallbackMonitoringClient(message2);
 };
 
+// ../../node_modules/@sentry/cloudflare/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  CloudflareClient: () => CloudflareClient,
+  SDK_VERSION: () => SDK_VERSION,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP: () => SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN: () => SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE: () => SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE: () => SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+  Scope: () => Scope,
+  addBreadcrumb: () => addBreadcrumb,
+  addEventProcessor: () => addEventProcessor,
+  addIntegration: () => addIntegration,
+  captureCheckIn: () => captureCheckIn,
+  captureConsoleIntegration: () => captureConsoleIntegration,
+  captureEvent: () => captureEvent,
+  captureException: () => captureException,
+  captureFeedback: () => captureFeedback,
+  captureMessage: () => captureMessage,
+  close: () => close,
+  continueTrace: () => continueTrace,
+  createTransport: () => createTransport,
+  debugIntegration: () => debugIntegration,
+  dedupeIntegration: () => dedupeIntegration,
+  extraErrorDataIntegration: () => extraErrorDataIntegration,
+  fetchIntegration: () => fetchIntegration,
+  flush: () => flush,
+  functionToStringIntegration: () => functionToStringIntegration,
+  getActiveSpan: () => getActiveSpan,
+  getClient: () => getClient,
+  getCurrentScope: () => getCurrentScope,
+  getDefaultIntegrations: () => getDefaultIntegrations,
+  getGlobalScope: () => getGlobalScope,
+  getIsolationScope: () => getIsolationScope,
+  getRootSpan: () => getRootSpan,
+  getSpanDescendants: () => getSpanDescendants,
+  getSpanStatusFromHttpCode: () => getSpanStatusFromHttpCode,
+  getTraceData: () => getTraceData,
+  getTraceMetaTags: () => getTraceMetaTags,
+  inboundFiltersIntegration: () => inboundFiltersIntegration,
+  instrumentD1WithSentry: () => instrumentD1WithSentry,
+  isInitialized: () => isInitialized,
+  lastEventId: () => lastEventId,
+  linkedErrorsIntegration: () => linkedErrorsIntegration,
+  metrics: () => metrics,
+  moduleMetadataIntegration: () => moduleMetadataIntegration,
+  requestDataIntegration: () => requestDataIntegration,
+  rewriteFramesIntegration: () => rewriteFramesIntegration,
+  sentryPagesPlugin: () => sentryPagesPlugin,
+  setContext: () => setContext,
+  setCurrentClient: () => setCurrentClient,
+  setExtra: () => setExtra,
+  setExtras: () => setExtras,
+  setHttpStatus: () => setHttpStatus,
+  setMeasurement: () => setMeasurement,
+  setTag: () => setTag,
+  setTags: () => setTags,
+  setUser: () => setUser,
+  spanToBaggageHeader: () => spanToBaggageHeader,
+  spanToJSON: () => spanToJSON,
+  spanToTraceHeader: () => spanToTraceHeader,
+  startInactiveSpan: () => startInactiveSpan,
+  startNewTrace: () => startNewTrace,
+  startSpan: () => startSpan,
+  startSpanManual: () => startSpanManual,
+  suppressTracing: () => suppressTracing,
+  trpcMiddleware: () => trpcMiddleware,
+  updateSpanName: () => updateSpanName,
+  withActiveSpan: () => withActiveSpan,
+  withIsolationScope: () => withIsolationScope2,
+  withMonitor: () => withMonitor,
+  withScope: () => withScope2,
+  withSentry: () => withSentry,
+  wrapRequestHandler: () => wrapRequestHandler,
+  zodErrorsIntegration: () => zodErrorsIntegration
+});
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/debug-build.js
 var DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
 
@@ -6008,6 +6097,25 @@ function truncate(str, max = 0) {
   }
   return str.length <= max ? str : `${str.slice(0, max)}...`;
 }
+function safeJoin(input, delimiter) {
+  if (!Array.isArray(input)) {
+    return "";
+  }
+  const output = [];
+  for (let i = 0; i < input.length; i++) {
+    const value = input[i];
+    try {
+      if (isVueViewModel(value)) {
+        output.push("[VueViewModel]");
+      } else {
+        output.push(String(value));
+      }
+    } catch (e) {
+      output.push("[value cannot be serialized]");
+    }
+  }
+  return output.join(delimiter);
+}
 function isMatchingPattern(value, pattern, requireExactStringMatch = false) {
   if (!isString(value)) {
     return false;
@@ -7562,6 +7670,13 @@ function showSpanDropWarning() {
     hasShownSpanDropWarning = true;
   }
 }
+function updateSpanName(span, name) {
+  span.updateName(name);
+  span.setAttributes({
+    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "custom",
+    [SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]: name
+  });
+}
 
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/tracing/errors.js
 var errorsInstrumented = false;
@@ -7773,6 +7888,10 @@ function getDynamicSamplingContextFromSpan(span) {
   client.emit("createDsc", dsc, rootSpan);
   return dsc;
 }
+function spanToBaggageHeader(span) {
+  const dsc = getDynamicSamplingContextFromSpan(span);
+  return dynamicSamplingContextToSentryBaggageHeader(dsc);
+}
 
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/tracing/logSpans.js
 function logSpanStart(span) {
@@ -8287,6 +8406,16 @@ function createSpanEnvelope(spans, client) {
 }
 
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/tracing/measurement.js
+function setMeasurement(name, value, unit, activeSpan = getActiveSpan()) {
+  const rootSpan = activeSpan && getRootSpan(activeSpan);
+  if (rootSpan) {
+    DEBUG_BUILD && logger.log(`[Measurement] Setting measurement on root span: ${name} = ${value} ${unit}`);
+    rootSpan.addEvent(name, {
+      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: value,
+      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: unit
+    });
+  }
+}
 function timedEventsToMeasurements(events2) {
   if (!events2 || events2.length === 0) {
     return void 0;
@@ -8640,6 +8769,41 @@ function startSpan(options, callback) {
     });
   });
 }
+function startSpanManual(options, callback) {
+  const acs = getAcs();
+  if (acs.startSpanManual) {
+    return acs.startSpanManual(options, callback);
+  }
+  const spanArguments = parseSentrySpanArguments(options);
+  const { forceTransaction, parentSpan: customParentSpan } = options;
+  return withScope2(options.scope, () => {
+    const wrapper = getActiveSpanWrapper(customParentSpan);
+    return wrapper(() => {
+      const scope = getCurrentScope();
+      const parentSpan = getParentSpan(scope);
+      const shouldSkipSpan = options.onlyIfParent && !parentSpan;
+      const activeSpan = shouldSkipSpan ? new SentryNonRecordingSpan() : createChildOrRootSpan({
+        parentSpan,
+        spanArguments,
+        forceTransaction,
+        scope
+      });
+      _setSpanForScope(scope, activeSpan);
+      function finishAndSetSpan() {
+        activeSpan.end();
+      }
+      return handleCallbackErrors(
+        () => callback(activeSpan, finishAndSetSpan),
+        () => {
+          const { status } = spanToJSON(activeSpan);
+          if (activeSpan.isRecording() && (!status || status === "ok")) {
+            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
+          }
+        }
+      );
+    });
+  });
+}
 function startInactiveSpan(options) {
   const acs = getAcs();
   if (acs.startInactiveSpan) {
@@ -8696,6 +8860,13 @@ function suppressTracing(callback) {
     return callback();
   });
 }
+function startNewTrace(callback) {
+  return withScope2((scope) => {
+    scope.setPropagationContext({ traceId: generateTraceId() });
+    DEBUG_BUILD && logger.info(`Starting a new trace with id ${scope.getPropagationContext().traceId}`);
+    return withActiveSpan(null, callback);
+  });
+}
 function createChildOrRootSpan({
   parentSpan,
   spanArguments,
@@ -9226,6 +9397,72 @@ function captureMessage(message2, captureContext) {
   const context = typeof captureContext !== "string" ? { captureContext } : void 0;
   return getCurrentScope().captureMessage(message2, level, context);
 }
+function captureEvent(event, hint) {
+  return getCurrentScope().captureEvent(event, hint);
+}
+function setContext(name, context) {
+  getIsolationScope().setContext(name, context);
+}
+function setExtras(extras) {
+  getIsolationScope().setExtras(extras);
+}
+function setExtra(key, extra) {
+  getIsolationScope().setExtra(key, extra);
+}
+function setTags(tags) {
+  getIsolationScope().setTags(tags);
+}
+function setTag(key, value) {
+  getIsolationScope().setTag(key, value);
+}
+function setUser(user) {
+  getIsolationScope().setUser(user);
+}
+function lastEventId() {
+  return getIsolationScope().lastEventId();
+}
+function captureCheckIn(checkIn, upsertMonitorConfig) {
+  const scope = getCurrentScope();
+  const client = getClient();
+  if (!client) {
+    DEBUG_BUILD && logger.warn("Cannot capture check-in. No client defined.");
+  } else if (!client.captureCheckIn) {
+    DEBUG_BUILD && logger.warn("Cannot capture check-in. Client does not support sending check-ins.");
+  } else {
+    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);
+  }
+  return uuid4();
+}
+function withMonitor(monitorSlug, callback, upsertMonitorConfig) {
+  const checkInId = captureCheckIn({ monitorSlug, status: "in_progress" }, upsertMonitorConfig);
+  const now = timestampInSeconds();
+  function finishCheckIn(status) {
+    captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - now });
+  }
+  return withIsolationScope2(() => {
+    let maybePromiseResult;
+    try {
+      maybePromiseResult = callback();
+    } catch (e) {
+      finishCheckIn("error");
+      throw e;
+    }
+    if (isThenable(maybePromiseResult)) {
+      Promise.resolve(maybePromiseResult).then(
+        () => {
+          finishCheckIn("ok");
+        },
+        (e) => {
+          finishCheckIn("error");
+          throw e;
+        }
+      );
+    } else {
+      finishCheckIn("ok");
+    }
+    return maybePromiseResult;
+  });
+}
 async function flush(timeout) {
   const client = getClient();
   if (client) {
@@ -9234,10 +9471,24 @@ async function flush(timeout) {
   DEBUG_BUILD && logger.warn("Cannot flush events. No client defined.");
   return Promise.resolve(false);
 }
+async function close(timeout) {
+  const client = getClient();
+  if (client) {
+    return client.close(timeout);
+  }
+  DEBUG_BUILD && logger.warn("Cannot flush events and disable SDK. No client defined.");
+  return Promise.resolve(false);
+}
+function isInitialized() {
+  return !!getClient();
+}
 function isEnabled() {
   const client = getClient();
   return !!client && client.getOptions().enabled !== false && !!client.getTransport();
 }
+function addEventProcessor(callback) {
+  getIsolationScope().addEventProcessor(callback);
+}
 
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/sessionflusher.js
 var SessionFlusher = class {
@@ -9424,6 +9675,14 @@ function setupIntegration(client, integration, integrationIndex) {
   }
   DEBUG_BUILD && logger.log(`Integration installed: ${integration.name}`);
 }
+function addIntegration(integration) {
+  const client = getClient();
+  if (!client) {
+    DEBUG_BUILD && logger.warn(`Cannot add integration "${integration.name}" because no SDK Client is available.`);
+    return;
+  }
+  client.addIntegration(integration);
+}
 function defineIntegration(fn) {
   return fn;
 }
@@ -10632,6 +10891,11 @@ function scopeToTraceHeader(scope) {
   return generateSentryTraceHeader(traceId, spanId, sampled);
 }
 
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/utils/meta.js
+function getTraceMetaTags() {
+  return Object.entries(getTraceData()).map(([key, value]) => `<meta name="${key}" content="${value}"/>`).join("\n");
+}
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/breadcrumbs.js
 var DEFAULT_BREADCRUMBS = 100;
 function addBreadcrumb(breadcrumb, hint) {
@@ -10977,6 +11241,92 @@ var _linkedErrorsIntegration = (options = {}) => {
 };
 var linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);
 
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/metadata.js
+var filenameMetadataMap = /* @__PURE__ */ new Map();
+var parsedStacks = /* @__PURE__ */ new Set();
+function ensureMetadataStacksAreParsed(parser) {
+  if (!GLOBAL_OBJ._sentryModuleMetadata) {
+    return;
+  }
+  for (const stack of Object.keys(GLOBAL_OBJ._sentryModuleMetadata)) {
+    const metadata = GLOBAL_OBJ._sentryModuleMetadata[stack];
+    if (parsedStacks.has(stack)) {
+      continue;
+    }
+    parsedStacks.add(stack);
+    const frames = parser(stack);
+    for (const frame of frames.reverse()) {
+      if (frame.filename) {
+        filenameMetadataMap.set(frame.filename, metadata);
+        break;
+      }
+    }
+  }
+}
+function getMetadataForUrl(parser, filename) {
+  ensureMetadataStacksAreParsed(parser);
+  return filenameMetadataMap.get(filename);
+}
+function addMetadataToStackFrames(parser, event) {
+  try {
+    event.exception.values.forEach((exception) => {
+      if (!exception.stacktrace) {
+        return;
+      }
+      for (const frame of exception.stacktrace.frames || []) {
+        if (!frame.filename || frame.module_metadata) {
+          continue;
+        }
+        const metadata = getMetadataForUrl(parser, frame.filename);
+        if (metadata) {
+          frame.module_metadata = metadata;
+        }
+      }
+    });
+  } catch (_) {
+  }
+}
+function stripMetadataFromStackFrames(event) {
+  try {
+    event.exception.values.forEach((exception) => {
+      if (!exception.stacktrace) {
+        return;
+      }
+      for (const frame of exception.stacktrace.frames || []) {
+        delete frame.module_metadata;
+      }
+    });
+  } catch (_) {
+  }
+}
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/metadata.js
+var moduleMetadataIntegration = defineIntegration(() => {
+  return {
+    name: "ModuleMetadata",
+    setup(client) {
+      client.on("beforeEnvelope", (envelope) => {
+        forEachEnvelopeItem(envelope, (item, type) => {
+          if (type === "event") {
+            const event = Array.isArray(item) ? item[1] : void 0;
+            if (event) {
+              stripMetadataFromStackFrames(event);
+              item[1] = event;
+            }
+          }
+        });
+      });
+      client.on("applyFrameMetadata", (event) => {
+        if (event.type) {
+          return;
+        }
+        const stackParser = client.getOptions().stackParser;
+        addMetadataToStackFrames(stackParser, event);
+      });
+    }
+  };
+});
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/utils-hoist/cookie.js
 function parseCookie(str) {
   const obj = {};
@@ -11407,12 +11757,132 @@ function convertReqDataIntegrationOptsToAddReqDataOpts(integrationOptions) {
   };
 }
 
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/utils-hoist/instrument/console.js
+function addConsoleInstrumentationHandler(handler) {
+  const type = "console";
+  addHandler(type, handler);
+  maybeInstrument(type, instrumentConsole);
+}
+function instrumentConsole() {
+  if (!("console" in GLOBAL_OBJ)) {
+    return;
+  }
+  CONSOLE_LEVELS.forEach(function(level) {
+    if (!(level in GLOBAL_OBJ.console)) {
+      return;
+    }
+    fill(GLOBAL_OBJ.console, level, function(originalConsoleMethod) {
+      originalConsoleMethods[level] = originalConsoleMethod;
+      return function(...args) {
+        const handlerData = { args, level };
+        triggerHandlers("console", handlerData);
+        const log = originalConsoleMethods[level];
+        log && log.apply(GLOBAL_OBJ.console, args);
+      };
+    });
+  });
+}
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/utils-hoist/severity.js
+function severityLevelFromString(level) {
+  return level === "warn" ? "warning" : ["fatal", "error", "warning", "log", "info", "debug"].includes(level) ? level : "log";
+}
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/captureconsole.js
+var INTEGRATION_NAME5 = "CaptureConsole";
+var _captureConsoleIntegration = (options = {}) => {
+  const levels = options.levels || CONSOLE_LEVELS;
+  const handled = !!options.handled;
+  return {
+    name: INTEGRATION_NAME5,
+    setup(client) {
+      if (!("console" in GLOBAL_OBJ)) {
+        return;
+      }
+      addConsoleInstrumentationHandler(({ args, level }) => {
+        if (getClient() !== client || !levels.includes(level)) {
+          return;
+        }
+        consoleHandler(args, level, handled);
+      });
+    }
+  };
+};
+var captureConsoleIntegration = defineIntegration(_captureConsoleIntegration);
+function consoleHandler(args, level, handled) {
+  const captureContext = {
+    level: severityLevelFromString(level),
+    extra: {
+      arguments: args
+    }
+  };
+  withScope2((scope) => {
+    scope.addEventProcessor((event) => {
+      event.logger = "console";
+      addExceptionMechanism(event, {
+        handled,
+        type: "console"
+      });
+      return event;
+    });
+    if (level === "assert") {
+      if (!args[0]) {
+        const message3 = `Assertion failed: ${safeJoin(args.slice(1), " ") || "console.assert"}`;
+        scope.setExtra("arguments", args.slice(1));
+        captureMessage(message3, captureContext);
+      }
+      return;
+    }
+    const error = args.find((arg) => arg instanceof Error);
+    if (error) {
+      captureException(error, captureContext);
+      return;
+    }
+    const message2 = safeJoin(args, " ");
+    captureMessage(message2, captureContext);
+  });
+}
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/debug.js
+var INTEGRATION_NAME6 = "Debug";
+var _debugIntegration = (options = {}) => {
+  const _options = {
+    debugger: false,
+    stringify: false,
+    ...options
+  };
+  return {
+    name: INTEGRATION_NAME6,
+    setup(client) {
+      client.on("beforeSendEvent", (event, hint) => {
+        if (_options.debugger) {
+          debugger;
+        }
+        consoleSandbox(() => {
+          if (_options.stringify) {
+            console.log(JSON.stringify(event, null, 2));
+            if (hint && Object.keys(hint).length) {
+              console.log(JSON.stringify(hint, null, 2));
+            }
+          } else {
+            console.log(event);
+            if (hint && Object.keys(hint).length) {
+              console.log(hint);
+            }
+          }
+        });
+      });
+    }
+  };
+};
+var debugIntegration = defineIntegration(_debugIntegration);
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/dedupe.js
-var INTEGRATION_NAME5 = "Dedupe";
+var INTEGRATION_NAME7 = "Dedupe";
 var _dedupeIntegration = () => {
   let previousEvent;
   return {
-    name: INTEGRATION_NAME5,
+    name: INTEGRATION_NAME7,
     processEvent(currentEvent) {
       if (currentEvent.type) {
         return currentEvent;
@@ -11522,13 +11992,162 @@ function _getExceptionFromEvent(event) {
   return event.exception && event.exception.values && event.exception.values[0];
 }
 
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/extraerrordata.js
+var INTEGRATION_NAME8 = "ExtraErrorData";
+var _extraErrorDataIntegration = (options = {}) => {
+  const { depth = 3, captureErrorCause = true } = options;
+  return {
+    name: INTEGRATION_NAME8,
+    processEvent(event, hint, client) {
+      const { maxValueLength = 250 } = client.getOptions();
+      return _enhanceEventWithErrorData(event, hint, depth, captureErrorCause, maxValueLength);
+    }
+  };
+};
+var extraErrorDataIntegration = defineIntegration(_extraErrorDataIntegration);
+function _enhanceEventWithErrorData(event, hint = {}, depth, captureErrorCause, maxValueLength) {
+  if (!hint.originalException || !isError(hint.originalException)) {
+    return event;
+  }
+  const exceptionName = hint.originalException.name || hint.originalException.constructor.name;
+  const errorData = _extractErrorData(hint.originalException, captureErrorCause, maxValueLength);
+  if (errorData) {
+    const contexts = {
+      ...event.contexts
+    };
+    const normalizedErrorData = normalize(errorData, depth);
+    if (isPlainObject(normalizedErrorData)) {
+      addNonEnumerableProperty(normalizedErrorData, "__sentry_skip_normalization__", true);
+      contexts[exceptionName] = normalizedErrorData;
+    }
+    return {
+      ...event,
+      contexts
+    };
+  }
+  return event;
+}
+function _extractErrorData(error, captureErrorCause, maxValueLength) {
+  try {
+    const nativeKeys = [
+      "name",
+      "message",
+      "stack",
+      "line",
+      "column",
+      "fileName",
+      "lineNumber",
+      "columnNumber",
+      "toJSON"
+    ];
+    const extraErrorInfo = {};
+    for (const key of Object.keys(error)) {
+      if (nativeKeys.indexOf(key) !== -1) {
+        continue;
+      }
+      const value = error[key];
+      extraErrorInfo[key] = isError(value) || typeof value === "string" ? truncate(`${value}`, maxValueLength) : value;
+    }
+    if (captureErrorCause && error.cause !== void 0) {
+      extraErrorInfo.cause = isError(error.cause) ? error.cause.toString() : error.cause;
+    }
+    if (typeof error.toJSON === "function") {
+      const serializedError = error.toJSON();
+      for (const key of Object.keys(serializedError)) {
+        const value = serializedError[key];
+        extraErrorInfo[key] = isError(value) ? value.toString() : value;
+      }
+    }
+    return extraErrorInfo;
+  } catch (oO) {
+    DEBUG_BUILD && logger.error("Unable to extract extra data from the Error object:", oO);
+  }
+  return null;
+}
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/utils-hoist/path.js
+function normalizeArray(parts, allowAboveRoot) {
+  let up = 0;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const last = parts[i];
+    if (last === ".") {
+      parts.splice(i, 1);
+    } else if (last === "..") {
+      parts.splice(i, 1);
+      up++;
+    } else if (up) {
+      parts.splice(i, 1);
+      up--;
+    }
+  }
+  if (allowAboveRoot) {
+    for (; up--; up) {
+      parts.unshift("..");
+    }
+  }
+  return parts;
+}
 var splitPathRe = /^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;
 function splitPath(filename) {
   const truncated = filename.length > 1024 ? `<truncated>${filename.slice(-1024)}` : filename;
   const parts = splitPathRe.exec(truncated);
   return parts ? parts.slice(1) : [];
 }
+function resolve(...args) {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path = i >= 0 ? args[i] : "/";
+    if (!path) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charAt(0) === "/";
+  }
+  resolvedPath = normalizeArray(
+    resolvedPath.split("/").filter((p) => !!p),
+    !resolvedAbsolute
+  ).join("/");
+  return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+}
+function trim(arr) {
+  let start = 0;
+  for (; start < arr.length; start++) {
+    if (arr[start] !== "") {
+      break;
+    }
+  }
+  let end = arr.length - 1;
+  for (; end >= 0; end--) {
+    if (arr[end] !== "") {
+      break;
+    }
+  }
+  if (start > end) {
+    return [];
+  }
+  return arr.slice(start, end - start + 1);
+}
+function relative(from, to) {
+  from = resolve(from).slice(1);
+  to = resolve(to).slice(1);
+  const fromParts = trim(from.split("/"));
+  const toParts = trim(to.split("/"));
+  const length = Math.min(fromParts.length, toParts.length);
+  let samePartsLength = length;
+  for (let i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+  let outputParts = [];
+  for (let i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push("..");
+  }
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+  return outputParts.join("/");
+}
 function basename(path, ext) {
   let f = splitPath(path)[2] || "";
   if (ext && f.slice(ext.length * -1) === ext) {
@@ -11537,6 +12156,283 @@ function basename(path, ext) {
   return f;
 }
 
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/rewriteframes.js
+var INTEGRATION_NAME9 = "RewriteFrames";
+var rewriteFramesIntegration = defineIntegration((options = {}) => {
+  const root = options.root;
+  const prefix = options.prefix || "app:///";
+  const isBrowser = "window" in GLOBAL_OBJ && GLOBAL_OBJ.window !== void 0;
+  const iteratee = options.iteratee || generateIteratee({ isBrowser, root, prefix });
+  function _processExceptionsEvent(event) {
+    try {
+      return {
+        ...event,
+        exception: {
+          ...event.exception,
+          // The check for this is performed inside `process` call itself, safe to skip here
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          values: event.exception.values.map((value) => ({
+            ...value,
+            ...value.stacktrace && { stacktrace: _processStacktrace(value.stacktrace) }
+          }))
+        }
+      };
+    } catch (_oO) {
+      return event;
+    }
+  }
+  function _processStacktrace(stacktrace) {
+    return {
+      ...stacktrace,
+      frames: stacktrace && stacktrace.frames && stacktrace.frames.map((f) => iteratee(f))
+    };
+  }
+  return {
+    name: INTEGRATION_NAME9,
+    processEvent(originalEvent) {
+      let processedEvent = originalEvent;
+      if (originalEvent.exception && Array.isArray(originalEvent.exception.values)) {
+        processedEvent = _processExceptionsEvent(processedEvent);
+      }
+      return processedEvent;
+    }
+  };
+});
+function generateIteratee({
+  isBrowser,
+  root,
+  prefix
+}) {
+  return (frame) => {
+    if (!frame.filename) {
+      return frame;
+    }
+    const isWindowsFrame = /^[a-zA-Z]:\\/.test(frame.filename) || // or the presence of a backslash without a forward slash (which are not allowed on Windows)
+    frame.filename.includes("\\") && !frame.filename.includes("/");
+    const startsWithSlash = /^\//.test(frame.filename);
+    if (isBrowser) {
+      if (root) {
+        const oldFilename = frame.filename;
+        if (oldFilename.indexOf(root) === 0) {
+          frame.filename = oldFilename.replace(root, prefix);
+        }
+      }
+    } else {
+      if (isWindowsFrame || startsWithSlash) {
+        const filename = isWindowsFrame ? frame.filename.replace(/^[a-zA-Z]:/, "").replace(/\\/g, "/") : frame.filename;
+        const base = root ? relative(root, filename) : basename(filename);
+        frame.filename = `${prefix}${base}`;
+      }
+    }
+    return frame;
+  };
+}
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/integrations/zoderrors.js
+var DEFAULT_LIMIT2 = 10;
+var INTEGRATION_NAME10 = "ZodErrors";
+function originalExceptionIsZodError(originalException) {
+  return isError(originalException) && originalException.name === "ZodError" && Array.isArray(originalException.issues);
+}
+function flattenIssue(issue) {
+  return {
+    ...issue,
+    path: "path" in issue && Array.isArray(issue.path) ? issue.path.join(".") : void 0,
+    keys: "keys" in issue ? JSON.stringify(issue.keys) : void 0,
+    unionErrors: "unionErrors" in issue ? JSON.stringify(issue.unionErrors) : void 0
+  };
+}
+function flattenIssuePath(path) {
+  return path.map((p) => {
+    if (typeof p === "number") {
+      return "<array>";
+    } else {
+      return p;
+    }
+  }).join(".");
+}
+function formatIssueMessage(zodError) {
+  const errorKeyMap = /* @__PURE__ */ new Set();
+  for (const iss of zodError.issues) {
+    const issuePath = flattenIssuePath(iss.path);
+    if (issuePath.length > 0) {
+      errorKeyMap.add(issuePath);
+    }
+  }
+  const errorKeys = Array.from(errorKeyMap);
+  if (errorKeys.length === 0) {
+    let rootExpectedType = "variable";
+    if (zodError.issues.length > 0) {
+      const iss = zodError.issues[0];
+      if (iss !== void 0 && "expected" in iss && typeof iss.expected === "string") {
+        rootExpectedType = iss.expected;
+      }
+    }
+    return `Failed to validate ${rootExpectedType}`;
+  }
+  return `Failed to validate keys: ${truncate(errorKeys.join(", "), 100)}`;
+}
+function applyZodErrorsToEvent(limit, saveZodIssuesAsAttachment = false, event, hint) {
+  if (!event.exception || !event.exception.values || !hint || !hint.originalException || !originalExceptionIsZodError(hint.originalException) || hint.originalException.issues.length === 0) {
+    return event;
+  }
+  try {
+    const issuesToFlatten = saveZodIssuesAsAttachment ? hint.originalException.issues : hint.originalException.issues.slice(0, limit);
+    const flattenedIssues = issuesToFlatten.map(flattenIssue);
+    if (saveZodIssuesAsAttachment) {
+      if (!Array.isArray(hint.attachments)) {
+        hint.attachments = [];
+      }
+      hint.attachments.push({
+        filename: "zod_issues.json",
+        data: JSON.stringify({
+          issues: flattenedIssues
+        })
+      });
+    }
+    return {
+      ...event,
+      exception: {
+        ...event.exception,
+        values: [
+          {
+            ...event.exception.values[0],
+            value: formatIssueMessage(hint.originalException)
+          },
+          ...event.exception.values.slice(1)
+        ]
+      },
+      extra: {
+        ...event.extra,
+        "zoderror.issues": flattenedIssues.slice(0, limit)
+      }
+    };
+  } catch (e) {
+    return {
+      ...event,
+      extra: {
+        ...event.extra,
+        "zoderrors sentry integration parse error": {
+          message: "an exception was thrown while processing ZodError within applyZodErrorsToEvent()",
+          error: e instanceof Error ? `${e.name}: ${e.message}
+${e.stack}` : "unknown"
+        }
+      }
+    };
+  }
+}
+var _zodErrorsIntegration = (options = {}) => {
+  const limit = typeof options.limit === "undefined" ? DEFAULT_LIMIT2 : options.limit;
+  return {
+    name: INTEGRATION_NAME10,
+    processEvent(originalEvent, hint) {
+      const processedEvent = applyZodErrorsToEvent(limit, options.saveZodIssuesAsAttachment, originalEvent, hint);
+      return processedEvent;
+    }
+  };
+};
+var zodErrorsIntegration = defineIntegration(_zodErrorsIntegration);
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/metrics/constants.js
+var COUNTER_METRIC_TYPE = "c";
+var GAUGE_METRIC_TYPE = "g";
+var SET_METRIC_TYPE = "s";
+var DISTRIBUTION_METRIC_TYPE = "d";
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/metrics/exports.js
+function getMetricsAggregatorForClient(client, Aggregator) {
+  const globalMetricsAggregators = getGlobalSingleton(
+    "globalMetricsAggregators",
+    () => /* @__PURE__ */ new WeakMap()
+  );
+  const aggregator = globalMetricsAggregators.get(client);
+  if (aggregator) {
+    return aggregator;
+  }
+  const newAggregator = new Aggregator(client);
+  client.on("flush", () => newAggregator.flush());
+  client.on("close", () => newAggregator.close());
+  globalMetricsAggregators.set(client, newAggregator);
+  return newAggregator;
+}
+function addToMetricsAggregator(Aggregator, metricType, name, value, data = {}) {
+  const client = data.client || getClient();
+  if (!client) {
+    return;
+  }
+  const span = getActiveSpan();
+  const rootSpan = span ? getRootSpan(span) : void 0;
+  const transactionName = rootSpan && spanToJSON(rootSpan).description;
+  const { unit, tags, timestamp } = data;
+  const { release, environment } = client.getOptions();
+  const metricTags = {};
+  if (release) {
+    metricTags.release = release;
+  }
+  if (environment) {
+    metricTags.environment = environment;
+  }
+  if (transactionName) {
+    metricTags.transaction = transactionName;
+  }
+  DEBUG_BUILD && logger.log(`Adding value of ${value} to ${metricType} metric ${name}`);
+  const aggregator = getMetricsAggregatorForClient(client, Aggregator);
+  aggregator.add(metricType, name, value, unit, { ...metricTags, ...tags }, timestamp);
+}
+function increment(aggregator, name, value = 1, data) {
+  addToMetricsAggregator(aggregator, COUNTER_METRIC_TYPE, name, ensureNumber(value), data);
+}
+function distribution(aggregator, name, value, data) {
+  addToMetricsAggregator(aggregator, DISTRIBUTION_METRIC_TYPE, name, ensureNumber(value), data);
+}
+function timing(aggregator, name, value, unit = "second", data) {
+  if (typeof value === "function") {
+    const startTime = timestampInSeconds();
+    return startSpanManual(
+      {
+        op: "metrics.timing",
+        name,
+        startTime,
+        onlyIfParent: true
+      },
+      (span) => {
+        return handleCallbackErrors(
+          () => value(),
+          () => {
+          },
+          () => {
+            const endTime = timestampInSeconds();
+            const timeDiff = endTime - startTime;
+            distribution(aggregator, name, timeDiff, { ...data, unit: "second" });
+            span.end(endTime);
+          }
+        );
+      }
+    );
+  }
+  distribution(aggregator, name, value, { ...data, unit });
+}
+function set(aggregator, name, value, data) {
+  addToMetricsAggregator(aggregator, SET_METRIC_TYPE, name, value, data);
+}
+function gauge(aggregator, name, value, data) {
+  addToMetricsAggregator(aggregator, GAUGE_METRIC_TYPE, name, ensureNumber(value), data);
+}
+var metrics = {
+  increment,
+  distribution,
+  set,
+  gauge,
+  timing,
+  /**
+   * @ignore This is for internal use only.
+   */
+  getMetricsAggregatorForClient
+};
+function ensureNumber(number) {
+  return typeof number === "string" ? parseInt(number) : number;
+}
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/fetch.js
 function instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeaders, spans, spanOrigin = "auto.http.browser") {
   if (!handlerData.fetchData) {
@@ -11689,6 +12585,88 @@ function isHeaders(headers) {
   return typeof Headers !== "undefined" && isInstanceOf(headers, Headers);
 }
 
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/trpc.js
+var trpcCaptureContext = { mechanism: { handled: false, data: { function: "trpcMiddleware" } } };
+function captureIfError(nextResult) {
+  if (typeof nextResult === "object" && nextResult !== null && "ok" in nextResult && !nextResult.ok && "error" in nextResult) {
+    captureException(nextResult.error, trpcCaptureContext);
+  }
+}
+function trpcMiddleware(options = {}) {
+  return async function(opts) {
+    const { path, type, next, rawInput, getRawInput } = opts;
+    const client = getClient();
+    const clientOptions = client && client.getOptions();
+    const trpcContext = {
+      procedure_path: path,
+      procedure_type: type
+    };
+    if (options.attachRpcInput !== void 0 ? options.attachRpcInput : clientOptions && clientOptions.sendDefaultPii) {
+      if (rawInput !== void 0) {
+        trpcContext.input = normalize(rawInput);
+      }
+      if (getRawInput !== void 0 && typeof getRawInput === "function") {
+        try {
+          const rawRes = await getRawInput();
+          trpcContext.input = normalize(rawRes);
+        } catch (err) {
+        }
+      }
+    }
+    return withScope2((scope) => {
+      scope.setContext("trpc", trpcContext);
+      return startSpanManual(
+        {
+          name: `trpc/${path}`,
+          op: "rpc.server",
+          attributes: {
+            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "route",
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.rpc.trpc"
+          }
+        },
+        async (span) => {
+          try {
+            const nextResult = await next();
+            captureIfError(nextResult);
+            span.end();
+            return nextResult;
+          } catch (e) {
+            captureException(e, trpcCaptureContext);
+            span.end();
+            throw e;
+          }
+        }
+      );
+    });
+  };
+}
+
+// ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/feedback.js
+function captureFeedback(params, hint = {}, scope = getCurrentScope()) {
+  const { message: message2, name, email, url, source, associatedEventId, tags } = params;
+  const feedbackEvent = {
+    contexts: {
+      feedback: dropUndefinedKeys({
+        contact_email: email,
+        name,
+        message: message2,
+        url,
+        source,
+        associated_event_id: associatedEventId
+      })
+    },
+    type: "feedback",
+    level: "info",
+    tags
+  };
+  const client = scope && scope.getClient() || getClient();
+  if (client) {
+    client.emit("beforeSendFeedback", feedbackEvent, hint);
+  }
+  const eventId = scope.captureEvent(feedbackEvent, hint);
+  return eventId;
+}
+
 // ../../node_modules/@sentry/cloudflare/node_modules/@sentry/core/build/esm/utils-hoist/breadcrumb-log-level.js
 function getBreadcrumbLogLevelFromHttpStatusCode(statusCode) {
   if (statusCode === void 0) {
@@ -12088,7 +13066,7 @@ var CloudflareClient = class extends ServerRuntimeClient {
 };
 
 // ../../node_modules/@sentry/cloudflare/build/esm/integrations/fetch.js
-var INTEGRATION_NAME6 = "Fetch";
+var INTEGRATION_NAME11 = "Fetch";
 var HAS_CLIENT_MAP = /* @__PURE__ */ new WeakMap();
 var _fetchIntegration = (options = {}) => {
   const breadcrumbs = options.breadcrumbs === void 0 ? true : options.breadcrumbs;
@@ -12126,7 +13104,7 @@ var _fetchIntegration = (options = {}) => {
     return decision;
   }
   return {
-    name: INTEGRATION_NAME6,
+    name: INTEGRATION_NAME11,
     setupOnce() {
       addFetchInstrumentationHandler((handlerData) => {
         const client = getClient();
@@ -12435,6 +13413,198 @@ function isInstrumented(handler) {
   }
 }
 
+// ../../node_modules/@sentry/cloudflare/build/esm/pages-plugin.js
+function sentryPagesPlugin(handlerOrOptions) {
+  setAsyncLocalStorageAsyncContextStrategy();
+  return (context) => {
+    const options = typeof handlerOrOptions === "function" ? handlerOrOptions(context) : handlerOrOptions;
+    return wrapRequestHandler({ options, request: context.request, context }, () => context.next());
+  };
+}
+
+// ../../node_modules/@sentry/cloudflare/build/esm/d1.js
+var patchedStatement = /* @__PURE__ */ new WeakSet();
+function instrumentD1PreparedStatementQueries(statement, query) {
+  if (patchedStatement.has(statement)) {
+    return statement;
+  }
+  statement.first = new Proxy(statement.first, {
+    apply(target, thisArg, args) {
+      return startSpan(createStartSpanOptions(query, "first"), async () => {
+        const res = await Reflect.apply(target, thisArg, args);
+        createD1Breadcrumb(query, "first");
+        return res;
+      });
+    }
+  });
+  statement.run = new Proxy(statement.run, {
+    apply(target, thisArg, args) {
+      return startSpan(createStartSpanOptions(query, "run"), async (span) => {
+        const d1Response = await Reflect.apply(target, thisArg, args);
+        applyD1ReturnObjectToSpan(span, d1Response);
+        createD1Breadcrumb(query, "run", d1Response);
+        return d1Response;
+      });
+    }
+  });
+  statement.all = new Proxy(statement.all, {
+    apply(target, thisArg, args) {
+      return startSpan(createStartSpanOptions(query, "all"), async (span) => {
+        const d1Result = await Reflect.apply(target, thisArg, args);
+        applyD1ReturnObjectToSpan(span, d1Result);
+        createD1Breadcrumb(query, "all", d1Result);
+        return d1Result;
+      });
+    }
+  });
+  statement.raw = new Proxy(statement.raw, {
+    apply(target, thisArg, args) {
+      return startSpan(createStartSpanOptions(query, "raw"), async () => {
+        const res = await Reflect.apply(target, thisArg, args);
+        createD1Breadcrumb(query, "raw");
+        return res;
+      });
+    }
+  });
+  patchedStatement.add(statement);
+  return statement;
+}
+function instrumentD1PreparedStatement(statement, query) {
+  statement.bind = new Proxy(statement.bind, {
+    apply(target, thisArg, args) {
+      return instrumentD1PreparedStatementQueries(Reflect.apply(target, thisArg, args), query);
+    }
+  });
+  return instrumentD1PreparedStatementQueries(statement, query);
+}
+function applyD1ReturnObjectToSpan(span, d1Result) {
+  if (!d1Result.success) {
+    span.setStatus({ code: SPAN_STATUS_ERROR });
+  }
+  span.setAttributes(getAttributesFromD1Response(d1Result));
+}
+function getAttributesFromD1Response(d1Result) {
+  return {
+    "cloudflare.d1.duration": d1Result.meta.duration,
+    "cloudflare.d1.rows_read": d1Result.meta.rows_read,
+    "cloudflare.d1.rows_written": d1Result.meta.rows_written
+  };
+}
+function createD1Breadcrumb(query, type, d1Result) {
+  addBreadcrumb({
+    category: "query",
+    message: query,
+    data: {
+      ...d1Result ? getAttributesFromD1Response(d1Result) : {},
+      "cloudflare.d1.query_type": type
+    }
+  });
+}
+function createStartSpanOptions(query, type) {
+  return {
+    op: "db.query",
+    name: query,
+    attributes: {
+      "cloudflare.d1.query_type": type,
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.db.cloudflare.d1"
+    }
+  };
+}
+function instrumentD1WithSentry(db) {
+  db.prepare = new Proxy(db.prepare, {
+    apply(target, thisArg, args) {
+      const [query] = args;
+      return instrumentD1PreparedStatement(Reflect.apply(target, thisArg, args), query);
+    }
+  });
+  return db;
+}
+
+// ../../node_modules/@wix/monitoring-common-sentry/build/index.js
+var isPromise = (value) => typeof value?.then === "function";
+var runWithMaybePromise = (value, cb) => {
+  if (!cb) {
+    return value;
+  }
+  if (isPromise(value)) {
+    return value.then((res) => {
+      cb(res, true);
+      return res;
+    });
+  } else {
+    cb(value, false);
+    return value;
+  }
+};
+var runWithMaybeDelay = (cb, maybeTimeCompensation) => {
+  if (!cb) {
+    return;
+  }
+  if (maybeTimeCompensation) {
+    setTimeout(cb, maybeTimeCompensation);
+  } else {
+    cb();
+  }
+};
+var ManualSpanRegistryImpl = class {
+  constructor(options) {
+    this.options = options;
+    this.spanMap = /* @__PURE__ */ new Map();
+  }
+  createSpan(spanOptions, sentryOptionsOrPromise) {
+    let resolveSpan;
+    let rejectSpan;
+    let error;
+    const startTime = Date.now();
+    let maybeDurationCompensation;
+    const maybePromise = runWithMaybePromise(
+      sentryOptionsOrPromise,
+      ({ sentrySDK, scope }, isPromise2) => {
+        if (isPromise2) {
+          maybeDurationCompensation = Date.now() - startTime;
+        }
+        const promise = sentrySDK.startSpan(
+          {
+            ...spanOptions,
+            scope,
+            forceTransaction: this.options.forceTransaction
+          },
+          () => new Promise((resolve2, reject) => {
+            resolveSpan = resolve2;
+            rejectSpan = reject;
+          })
+        );
+        promise?.catch((e) => {
+          if (e?.message !== error?.message) {
+            throw e;
+          }
+        });
+      }
+    );
+    const endSpan2 = (cb) => {
+      this.spanMap.delete(spanOptions.name);
+      runWithMaybePromise(maybePromise, () => {
+        runWithMaybeDelay(cb, maybeDurationCompensation);
+      });
+    };
+    const span = {
+      end: () => {
+        endSpan2(() => resolveSpan?.());
+      },
+      fail: (_error) => {
+        error = error ?? _error;
+        endSpan2(() => rejectSpan?.(_error));
+      }
+    };
+    this.spanMap.set(spanOptions.name, span);
+    return span;
+  }
+  getSpan(spanOptions) {
+    return this.spanMap.get(spanOptions.name);
+  }
+};
+var createManualSpanRegistry = (options) => new ManualSpanRegistryImpl(options);
+
 // ../../node_modules/@wix/monitoring-cloudflare-sentry/build/index.js
 var UNHANDLED_MARK_KEY = "_markAsUnhandled";
 var captureUnhandledException = (error) => {
@@ -12518,6 +13688,7 @@ var instrumentWithData = (options) => {
 };
 var SentryCloudflareClient = class {
   constructor() {
+    this.manualSpanRegistry = createManualSpanRegistry({ forceTransaction: false });
     this.addBreadcrumb = (breadcrumb) => {
       addBreadcrumb(breadcrumb);
     };
@@ -12535,9 +13706,19 @@ var SentryCloudflareClient = class {
         contexts: captureContext?.contexts
       });
     };
-    this.startSpan = async (spanOptions, callback) => {
+    this.startSpan = (spanOptions, callback) => {
       return startSpan(spanOptions, callback);
     };
+    this.startSpanManual = (spanOptions) => {
+      const span = this.manualSpanRegistry.createSpan(spanOptions, {
+        sentrySDK: esm_exports
+      });
+      return span;
+    };
+    this.endSpanManual = (spanOptions) => {
+      const span = this.manualSpanRegistry.getSpan(spanOptions);
+      span?.end();
+    };
   }
 };
 var createSentryCloudflareClient = (options) => {