@depup/sentry__server-utils 10.67.0-depup.0

package/build/types-ts3.8/redis/index.d.ts

@@ -0,0 +1,18 @@
+import { RedisDiagnosticChannelResponseHook } from './redis-dc-subscriber';
+/** Options controlling the redis diagnostics-channel subscription. */
+export interface RedisDiagnosticChannelsOptions {
+    /**
+     * Optional hook invoked once the redis command response arrives. Useful for attaching
+     * response-derived attributes (e.g. cache hit/miss, payload size).
+     */
+    responseHook?: RedisDiagnosticChannelResponseHook;
+}
+/**
+ * Auto-instrument the [redis](https://www.npmjs.com/package/redis) and
+ * [ioredis](https://www.npmjs.com/package/ioredis) libraries via their native
+ * `node:diagnostics_channel` tracing channels (node-redis >= 5.12.0, ioredis >= 5.11.0).
+ */
+export declare const redisIntegration: (options?: RedisDiagnosticChannelsOptions | undefined) => import("@sentry/core").Integration & {
+    name: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/redis/redis-dc-subscriber.d.ts

@@ -0,0 +1,89 @@
+import { TracingChannel } from 'node:diagnostics_channel';
+import { Span } from '@sentry/core';
+export declare const REDIS_DC_CHANNEL_COMMAND = "node-redis:command";
+export declare const REDIS_DC_CHANNEL_BATCH = "node-redis:batch";
+export declare const REDIS_DC_CHANNEL_CONNECT = "node-redis:connect";
+export declare const IOREDIS_DC_CHANNEL_COMMAND = "ioredis:command";
+export declare const IOREDIS_DC_CHANNEL_CONNECT = "ioredis:connect";
+/**
+ * Shape of the `node-redis:command` channel payload published by node-redis.
+ *
+ * Both `command` and `args` are already redacted by node-redis itself (see
+ * `sanitizeArgs` in @redis/client) using the OTel `redis-common` rules. The
+ * arg array is `[<command>, <safe arg>, ..., '?', ...]` — `?` replaces any
+ * value the library considers sensitive. Subscribers can emit `args` directly
+ * as `db.query.text` without further serialization.
+ */
+export interface RedisCommandData {
+    command: string;
+    /** First arg is the command name itself; consumers should slice it off. */
+    args: string[];
+    database?: number;
+    serverAddress?: string;
+    serverPort?: number;
+    result?: unknown;
+    error?: Error;
+}
+/**
+ * Shape of the `ioredis:command` channel payload published by ioredis >= 5.11.0.
+ *
+ * As with node-redis, args are already sanitized by ioredis (`sanitizeArgs` in
+ * `lib/tracing.ts`) before publishing. Unlike node-redis, the command name is
+ * NOT prepended to `args`.
+ */
+export interface IORedisCommandData {
+    command: string;
+    args: string[];
+    batchMode?: 'MULTI';
+    batchSize?: number;
+    database?: number;
+    serverAddress?: string;
+    serverPort?: number;
+    result?: unknown;
+    error?: Error;
+}
+/** Shape of the `node-redis:batch` channel payload published by node-redis. */
+export interface RedisBatchData {
+    batchMode?: 'MULTI' | 'PIPELINE';
+    batchSize?: number;
+    database?: number;
+    clientId?: string | number;
+    serverAddress?: string;
+    serverPort?: number;
+    result?: unknown[];
+    error?: Error;
+}
+/** Shape of the `*:connect` channel payload published by node-redis and ioredis. */
+export interface RedisConnectData {
+    serverAddress?: string;
+    serverPort?: number;
+    url?: string;
+    error?: Error;
+}
+/**
+ * Optional callback invoked once the redis command response arrives. Useful
+ * for attaching response-derived attributes (e.g. cache hit/miss, payload size).
+ *
+ * Mirrors `@opentelemetry/instrumentation-ioredis`' response hook so existing
+ * Sentry node code (`cacheResponseHook`) can be reused unchanged.
+ */
+export type RedisDiagnosticChannelResponseHook = (span: Span, cmdName: string, cmdArgs: string[], result: unknown) => void;
+/**
+ * Platform-provided factory that creates a native tracing channel for the given name. The
+ * subscriber binds the span and its lifecycle onto the channel via `bindTracingChannelToSpan`,
+ * which propagates the active span through the runtime's async context.
+ *
+ * Both Node and Deno pass `node:diagnostics_channel`'s `tracingChannel` directly.
+ */
+export type RedisTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/**
+ * Subscribe Sentry span handlers to node-redis and ioredis diagnostics-channel
+ * events: `node-redis:command`/`:batch`/`:connect` (published by node-redis
+ * >= 5.12.0) and `ioredis:command`/`:connect` (published by ioredis >= 5.11.0).
+ *
+ * On older client versions the channels are never published to, so subscribers
+ * are inert — there is no double-instrumentation against any IITM-based
+ * patcher gated to those older versions.
+ */
+export declare function subscribeRedisDiagnosticChannels(tracingChannel: RedisTracingChannelFactory, responseHook?: RedisDiagnosticChannelResponseHook): void;
+//# sourceMappingURL=redis-dc-subscriber.d.ts.map

package/build/types-ts3.8/redis/redis-statement-serializer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given the redis command name and arguments, return a combination of the
+ * command name + the allowed arguments according to `serializationSubsets`.
+ */
+export declare const defaultDbStatementSerializer: (cmdName: string, cmdArgs: Array<string | Buffer | number | unknown[]>) => string;
+//# sourceMappingURL=redis-statement-serializer.d.ts.map

package/build/types-ts3.8/tracing-channel.d.ts

@@ -0,0 +1,73 @@
+import { TracingChannel, TracingChannelSubscribers } from 'node:diagnostics_channel';
+import { ExclusiveEventHintOrCaptureContext, Span } from '@sentry/core';
+export type TracingChannelPayloadWithSpan<TData extends object> = TData & {
+    /**
+     * The current active span for the traced call.
+     */
+    _sentrySpan?: Span;
+    /**
+     * The context's active store value, used to restore the context for asyncStart continuations for callback-based tracing.
+     */
+    _sentryCallerStore?: unknown;
+};
+export interface SentryTracingChannel<TData extends object = object> extends Pick<TracingChannel<TData, TracingChannelPayloadWithSpan<TData>>, Exclude<keyof TracingChannel<TData, TracingChannelPayloadWithSpan<TData>>, 'subscribe' | 'unsubscribe'>> {
+    subscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;
+    unsubscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;
+}
+export interface TracingChannelLifeCycleOptions<TData extends object = object> {
+    /**
+     * Invoked with the span and the channel context object once the traced operation completes
+     * Use it to enrich the span from the result/error (branch on `'error' in data` / `'result' in data`) or to run cleanup.
+     */
+    beforeSpanEnd?: (span: Span, data: TracingChannelPayloadWithSpan<TData>) => void;
+    /**
+     * Whether a thrown error is captured as a Sentry event. The span is always marked with error status regardless. Defaults to `false`.
+     * You can alternatively pass a function that sets the ExclusiveEventHintOrCaptureContext on the captured error.
+     * Set `true` for instrumentations that own the error boundary, (e.g: route handlers)
+     * For database drivers, it is not recommended to set this at all.
+     */
+    captureError?: boolean | ((e: unknown) => ExclusiveEventHintOrCaptureContext);
+    /**
+     * Take ownership of *when* the span ends: return `true` and the helper won't end it on
+     * `end`/`asyncEnd`. For results that settle out-of-band — e.g. a streamed `EventEmitter` that
+     * completes via its own `'end'`/`'error'` events.
+     *
+     * Call `end` when it settles — `end()` on success, `end(error)` on failure. `end` owns *how* the span
+     * ends (error status/attributes, `captureError`, `beforeSpanEnd`) and is idempotent. Default `false`
+     * lets the helper end the span as usual.
+     */
+    deferSpanEnd?: (args: {
+        span: Span;
+        data: TracingChannelPayloadWithSpan<TData>;
+        /** Ends the span: `end()` on success, `end(error)` on failure. Idempotent. */
+        end: (error?: unknown) => void;
+    }) => boolean;
+    /**
+     * Apply span/scope binding only if there is a parent span, similar to returning `undefined` in the `getSpan` callback.
+     * If you need to perform some conditional checking on the parent span before deciding, do it in the `getSpan` callback.
+     */
+    requiresParentSpan?: boolean;
+}
+/** Returned by {@link bindTracingChannelToSpan}: the bound channel plus a teardown handle. */
+export interface TracingChannelBindingHandle<TData extends object = object> {
+    /**
+     * The tracing channel with the span bound into async context.
+     */
+    channel: SentryTracingChannel<TData>;
+    /**
+     * Tears down the binding: unsubscribes lifecycle handlers, when present, and unbinds the start store.
+     * Idempotent, and a no-op when no async context binding was available.
+     */
+    unbind: () => void;
+}
+/**
+ * Bind a span and its lifecycle to a tracing channel so the span becomes the active async context
+ * for the traced operation and is ended when the operation completes.
+ *
+ * `getSpan` may return `undefined` to opt a payload out entirely: nothing is bound, no span is
+ * tracked, and the active context is left untouched. Use it for events that ride the same channel
+ * but should reuse the enclosing span instead of opening (and ending) their own — e.g. an agent
+ * loop's per-step events, where ending a freshly opened span would close the parent prematurely.
+ */
+export declare function bindTracingChannelToSpan<TData extends object>(channel: TracingChannel<TData, TData>, getSpan: (data: TracingChannelPayloadWithSpan<TData>) => Span | undefined, opts?: TracingChannelLifeCycleOptions<TData>): TracingChannelBindingHandle<TData>;
+//# sourceMappingURL=tracing-channel.d.ts.map

package/build/types-ts3.8/vercel-ai/index.d.ts

@@ -0,0 +1,27 @@
+type VercelAiOptions = {
+    /**
+     * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled if `dataCollection.genAI.outputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
+};
+/**
+ * Auto-instrument the `ai` SDK's native telemetry tracing channel (ai >= 7).
+ */
+export declare const vercelAiIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "VercelAI";
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/vercel-ai/util.d.ts

@@ -0,0 +1,30 @@
+/** Shared, state-free helpers for the Vercel AI (`ai`) channel subscribers, plus the streamed model-call tap. */
+/** Narrow to a string, or `undefined` for anything else. */
+export declare function asString(value: unknown): string | undefined;
+/** Narrow to a finite number, or `undefined` for anything else (including `NaN`). */
+export declare function asNumber(value: unknown): number | undefined;
+/** Add two optional numbers, treating a missing operand as `0` but returning `undefined` when both are absent. */
+export declare function sum(a: number | undefined, b: number | undefined): number | undefined;
+/** The aggregate handed back once a streamed model call finishes, in the shape `enrichSpanOnEnd` expects. */
+export interface StreamedModelCallResult {
+    text?: string;
+    toolCalls: Array<Record<string, unknown>>;
+    usage?: unknown;
+    finishReason?: unknown;
+    responseId?: string;
+    responseModel?: string;
+    providerMetadata?: unknown;
+}
+/** A minimal structural check — the streamed model call exposes a web `ReadableStream` on `result.stream`. */
+export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
+/**
+ * Wrap a streamed model call's `ReadableStream` so its chunks are observed as the SDK consumes them,
+ * without altering what the SDK sees. Returns a replacement stream to swap onto `result.stream`.
+ *
+ * `onFinal` runs exactly once when the stream drains cleanly; `onError` runs exactly once if it errors
+ * or is cancelled. Reading one source chunk per `pull` preserves the SDK's backpressure. The
+ * `try/catch` around every read guarantees the owning span is always ended — a leaked open span on a
+ * mid-stream failure would be worse than a slightly-less-enriched one.
+ */
+export declare function tapModelCallStream(stream: ReadableStream<unknown>, onFinal: (result: StreamedModelCallResult) => void, onError: (error: unknown) => void): ReadableStream<unknown>;
+//# sourceMappingURL=util.d.ts.map

package/build/types-ts3.8/vercel-ai/vercel-ai-dc-subscriber.d.ts

@@ -0,0 +1,72 @@
+import { Span } from '@sentry/core';
+import { TracingChannel } from 'node:diagnostics_channel';
+import { StreamedModelCallResult } from './util';
+/** Drop the per-operation `callId` maps once the owning top-level operation settles (success or error). */
+export declare function clearOperationId(data: VercelAiChannelMessage): void;
+/**
+ * Drop the per-operation `callId` maps for a single id. The v6 orchestrion adapter uses this to clear a
+ * `streamText` operation only after its lazily-run model call settles — the operation's own span ends
+ * synchronously (when `streamText` returns) but the model call runs later as the stream is consumed, and
+ * it still needs the operation's `operationId`/`isStream` entry to name itself `ai.streamText.doStream`.
+ */
+export declare function clearOperationCallId(callId: string): void;
+/** The lifecycle event types the `ai:telemetry` channel can carry. */
+export type ChannelEventType = 'generateText' | 'streamText' | 'generateObject' | 'step' | 'languageModelCall' | 'executeTool' | 'embed' | 'embedMany' | 'rerank';
+/**
+ * The context object the AI SDK passes through one tracing-channel call. It is the same object
+ * identity across `start`/`end`/`asyncEnd`/`error`, and Node's `tracingChannel` attaches
+ * `result`/`error` to it as the traced promise settles.
+ */
+export interface VercelAiChannelMessage {
+    type: ChannelEventType;
+    event: Record<string, unknown>;
+    result?: unknown;
+    error?: unknown;
+}
+/**
+ * Platform-provided factory that returns a tracing channel for the given channel name. The factory
+ * is responsible for, when `start` fires, calling `transformStart(data)` and storing the returned
+ * span on `data._sentrySpan` so the subscriber's `asyncEnd`/`error` handlers can read it.
+ *
+ * Node passes `@sentry/opentelemetry/tracing-channel`, which uses `bindStore` to additionally make
+ * the span the active OTel context for the duration of the traced operation. That is what makes
+ * nested AI SDK operations (model calls, tool calls) become children of the enclosing span without
+ * any manual parent bookkeeping here.
+ */
+export type VercelAiTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/** Integration-level recording options, pinned at subscribe time so we never look the integration up per event. */
+export interface VercelAiChannelOptions {
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+    enableTruncation?: boolean;
+}
+/**
+ * Subscribe Sentry span handlers to the `ai` SDK's native telemetry tracing channel (`ai:telemetry`,
+ * available in `ai` >= 7) and emit fully-formed `gen_ai.*` spans directly — no OpenTelemetry span
+ * post-processing involved.
+ *
+ * The integration passes its options in directly (rather than us looking the integration up on every
+ * event); the global `dataCollection.genAI` default is still read from the client per event.
+ *
+ * Safe to always call: on `ai` versions that don't publish to the channel (e.g. < 7) nothing is
+ * ever emitted and this is inert, so there is no double-instrumentation against the OTel-based
+ * patcher. The integration's `setupOnce` guarantees this runs a single time.
+ */
+export declare function subscribeVercelAiTracingChannel(tracingChannel: VercelAiTracingChannelFactory, options?: VercelAiChannelOptions): void;
+/** Map the tapped stream aggregate onto the `languageModelCall` result shape `enrichSpanOnEnd` reads. */
+export declare function streamedResultToChannelResult(final: StreamedModelCallResult): Record<string, unknown>;
+/**
+ * Transform a channel `start` payload into the span that should be active for the operation. For
+ * `step` we deliberately don't open a span (model calls and tool calls are siblings under the
+ * invoke_agent span, matching the OTel-based output), so we reuse the active span and mark the
+ * payload to skip ending it.
+ */
+export declare function createSpanFromMessage(data: VercelAiChannelMessage, channelOptions: VercelAiChannelOptions): Span | undefined;
+/**
+ * Best-effort enrichment from the resolved value the AI SDK attaches to the channel context.
+ * Everything here is guarded: when a field is missing or the shape differs across `ai` versions,
+ * we simply don't set the attribute rather than emit a malformed span.
+ */
+export declare function enrichSpanOnEnd(span: Span, data: VercelAiChannelMessage, channelOptions: VercelAiChannelOptions): void;
+export declare function captureToolError(span: Span, data: VercelAiChannelMessage, error: unknown): void;
+//# sourceMappingURL=vercel-ai-dc-subscriber.d.ts.map

package/build/types-ts3.8/vercel-ai/vercel-ai-orchestrion-subscriber.d.ts

@@ -0,0 +1,12 @@
+import { VercelAiChannelOptions, VercelAiTracingChannelFactory } from './vercel-ai-dc-subscriber';
+/**
+ * Subscribe the v6 orchestrion channel adapter. Safe to always call: inert on
+ * `ai` >= 7 (those channels are never published) and when orchestrion injection
+ * isn't active. Idempotent.
+ *
+ * `tracingChannel` is the platform-provided factory (the same one passed to
+ * `subscribeVercelAiTracingChannel`); `options` pins the recording settings at
+ * subscribe time so we never look the integration up per event.
+ */
+export declare function subscribeVercelAiOrchestrionChannels(tracingChannel: VercelAiTracingChannelFactory, options?: VercelAiChannelOptions): void;
+//# sourceMappingURL=vercel-ai-orchestrion-subscriber.d.ts.map

package/changes.json

@@ -0,0 +1,14 @@
+{
+  "bumped": {
+    "@apm-js-collab/code-transformer-bundler-plugins": {
+      "from": "^0.7.1",
+      "to": "^0.7.2"
+    },
+    "@sentry/conventions": {
+      "from": "^0.16.0",
+      "to": "^0.17.0"
+    }
+  },
+  "timestamp": "2026-07-21T16:07:56.165Z",
+  "totalUpdated": 2
+}

package/package.json

@@ -0,0 +1,189 @@
+{
+  "name": "@depup/sentry__server-utils",
+  "version": "10.67.0-depup.0",
+  "description": "Server Utilities for all Sentry JavaScript SDKs (with updated dependencies)",
+  "repository": "git://github.com/getsentry/sentry-javascript.git",
+  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/server-utils",
+  "author": "Sentry",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "/build",
+    "changes.json",
+    "README.md"
+  ],
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./build/types/index.d.ts",
+      "import": "./build/esm/index.js",
+      "require": "./build/cjs/index.js"
+    },
+    "./orchestrion": {
+      "types": "./build/types/orchestrion/index.d.ts",
+      "import": "./build/esm/orchestrion/index.js",
+      "require": "./build/cjs/orchestrion/index.js"
+    },
+    "./orchestrion/config": {
+      "types": "./build/types/orchestrion/config/index.d.ts",
+      "import": "./build/esm/orchestrion/config/index.js",
+      "require": "./build/cjs/orchestrion/config/index.js"
+    },
+    "./orchestrion/register": {
+      "types": "./build/types/orchestrion/runtime/register.d.ts",
+      "import": "./build/esm/orchestrion/runtime/register.js",
+      "require": "./build/cjs/orchestrion/runtime/register.js"
+    },
+    "./orchestrion/vite": {
+      "types": "./build/types/orchestrion/bundler/vite.d.ts",
+      "import": "./build/esm/orchestrion/bundler/vite.js",
+      "require": "./build/cjs/orchestrion/bundler/vite.js"
+    },
+    "./orchestrion/rollup": {
+      "types": "./build/types/orchestrion/bundler/rollup.d.ts",
+      "import": "./build/esm/orchestrion/bundler/rollup.js",
+      "require": "./build/cjs/orchestrion/bundler/rollup.js"
+    },
+    "./orchestrion/webpack": {
+      "types": "./build/types/orchestrion/bundler/webpack.d.ts",
+      "import": "./build/esm/orchestrion/bundler/webpack.js",
+      "require": "./build/cjs/orchestrion/bundler/webpack.js"
+    },
+    "./orchestrion/esbuild": {
+      "types": "./build/types/orchestrion/bundler/esbuild.d.ts",
+      "import": "./build/esm/orchestrion/bundler/esbuild.js",
+      "require": "./build/cjs/orchestrion/bundler/esbuild.js"
+    },
+    "./orchestrion/import-hook": {
+      "import": "./build/orchestrion/import-hook.mjs"
+    }
+  },
+  "typesVersions": {
+    "<5.0": {
+      "build/types/index.d.ts": [
+        "build/types-ts3.8/index.d.ts"
+      ],
+      "orchestrion": [
+        "build/types-ts3.8/orchestrion/index.d.ts"
+      ],
+      "orchestrion/config": [
+        "build/types-ts3.8/orchestrion/config/index.d.ts"
+      ],
+      "orchestrion/register": [
+        "build/types-ts3.8/orchestrion/runtime/register.d.ts"
+      ],
+      "orchestrion/vite": [
+        "build/types-ts3.8/orchestrion/bundler/vite.d.ts"
+      ],
+      "orchestrion/rollup": [
+        "build/types-ts3.8/orchestrion/bundler/rollup.d.ts"
+      ],
+      "orchestrion/webpack": [
+        "build/types-ts3.8/orchestrion/bundler/webpack.d.ts"
+      ],
+      "orchestrion/esbuild": [
+        "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+      ]
+    },
+    "*": {
+      "orchestrion": [
+        "build/types/orchestrion/index.d.ts"
+      ],
+      "orchestrion/config": [
+        "build/types/orchestrion/config/index.d.ts"
+      ],
+      "orchestrion/register": [
+        "build/types/orchestrion/runtime/register.d.ts"
+      ],
+      "orchestrion/vite": [
+        "build/types/orchestrion/bundler/vite.d.ts"
+      ],
+      "orchestrion/rollup": [
+        "build/types/orchestrion/bundler/rollup.d.ts"
+      ],
+      "orchestrion/webpack": [
+        "build/types/orchestrion/bundler/webpack.d.ts"
+      ],
+      "orchestrion/esbuild": [
+        "build/types/orchestrion/bundler/esbuild.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@apm-js-collab/code-transformer-bundler-plugins": "^0.7.2",
+    "@apm-js-collab/tracing-hooks": "^0.13.0",
+    "@sentry/conventions": "^0.17.0",
+    "@sentry/core": "10.67.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.1",
+    "vite": "^6.4.3"
+  },
+  "scripts": {
+    "build": "run-p build:transpile build:types",
+    "build:dev": "yarn build",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:types": "run-s build:types:core build:types:downlevel",
+    "build:types:core": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "yarn downlevel-dts build/types build/types-ts3.8 --to ts3.8 && node scripts/inject-ts38-shims.mjs",
+    "build:watch": "run-p build:transpile:watch",
+    "build:dev:watch": "run-p build:transpile:watch",
+    "build:transpile:watch": "rollup -c rollup.npm.config.mjs --watch",
+    "build:tarball": "npm pack",
+    "clean": "rimraf build coverage sentry-server-utils-*.tgz",
+    "lint:fix": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --fix --type-aware",
+    "lint": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --type-aware",
+    "lint:es-compatibility": "es-check es2020 ./build/cjs/*.js && es-check es2020 ./build/esm/*.js --module",
+    "test:unit": "vitest run",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "yalc:publish": "yalc publish --push --sig"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "sideEffects": false,
+  "nx": {
+    "targets": {
+      "build:transpile": {
+        "outputs": [
+          "{projectRoot}/build/esm",
+          "{projectRoot}/build/cjs",
+          "{projectRoot}/build/npm/esm",
+          "{projectRoot}/build/npm/cjs",
+          "{projectRoot}/build/orchestrion"
+        ]
+      }
+    }
+  },
+  "keywords": [
+    "@sentry/server-utils",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched"
+  ],
+  "depup": {
+    "changes": {
+      "@apm-js-collab/code-transformer-bundler-plugins": {
+        "from": "^0.7.1",
+        "to": "^0.7.2"
+      },
+      "@sentry/conventions": {
+        "from": "^0.16.0",
+        "to": "^0.17.0"
+      }
+    },
+    "depsUpdated": 2,
+    "originalPackage": "@sentry/server-utils",
+    "originalVersion": "10.67.0",
+    "processedAt": "2026-07-21T16:07:59.675Z",
+    "smokeTest": "passed"
+  }
+}