@telemetry-dev/otel 0.1.0

package/dist/index.mjs

@@ -0,0 +1,553 @@
+import { ROOT_CONTEXT, context, createContextKey } from "@opentelemetry/api";
+import { AggregationTemporality, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { ExportResultCode } from "@opentelemetry/core";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { ProtobufLogsSerializer, ProtobufMetricsSerializer, ProtobufTraceSerializer } from "@opentelemetry/otlp-transformer";
+//#region src/attrs.ts
+const SCOPE_NAME = "@telemetry-dev/sdk";
+const SCOPE_VERSION = "0.0.0";
+function omitUndefined(attributes) {
+	const out = {};
+	for (const key of Object.keys(attributes)) {
+		const value = attributes[key];
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function jsonAttr(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/config.ts
+const DEFAULT_BASE_URL = "https://ingest.telemetry.dev";
+const DEFAULT_BATCH = {
+	maxExportBatchSize: 64,
+	scheduledDelayMillis: 1e3,
+	maxQueueSize: 2048,
+	exportTimeoutMillis: 3e4
+};
+function resolveEnv() {
+	if (typeof process !== "undefined" && process.env) return process.env;
+	return {};
+}
+//#endregion
+//#region src/debug.ts
+const ORDER = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
+	silent: 4
+};
+let currentLevel = "warn";
+function setLogLevel(level) {
+	currentLevel = level;
+}
+function emit(level, args) {
+	if (ORDER[level] < ORDER[currentLevel]) return;
+	console[level]("[telemetry.dev]", ...args);
+}
+const diag = {
+	debug: (...args) => emit("debug", args),
+	info: (...args) => emit("info", args),
+	warn: (...args) => emit("warn", args),
+	error: (...args) => emit("error", args)
+};
+/** Fail-open guard: SDK internals report through onError + diagnostics, never into user code. */
+function reportError(onError, error) {
+	try {
+		onError?.(error);
+	} catch {}
+	diag.error(error);
+}
+//#endregion
+//#region src/context.ts
+function loadAls() {
+	const g = globalThis;
+	if (g.AsyncLocalStorage) return g.AsyncLocalStorage;
+	try {
+		return g.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage;
+	} catch {}
+}
+const AlsCtor = loadAls();
+const als = AlsCtor ? new AlsCtor() : void 0;
+/**
+* The active context: our AsyncLocalStorage when available, falling back to the OTel global
+* context (which joins a host app's own OTel setup when one is registered).
+*/
+function activeContext() {
+	return als?.getStore() ?? context.active();
+}
+/** Run `fn` with `ctx` active in both our ALS and the global OTel context manager. */
+function withContext(ctx, fn) {
+	const run = () => context.with(ctx, fn);
+	return als ? als.run(ctx, run) : run();
+}
+const PROPAGATED_KEY = createContextKey("telemetry.dev propagated attributes");
+const RESERVED_METADATA_KEYS = new Set([
+	"userId",
+	"sessionId",
+	"user_id",
+	"session_id"
+]);
+function buildPropagatedAttributes(attrs) {
+	const out = {};
+	if (attrs.userId !== void 0) out["user.id"] = attrs.userId;
+	if (attrs.sessionId !== void 0) out["gen_ai.conversation.id"] = attrs.sessionId;
+	if (attrs.metadata) for (const [key, value] of Object.entries(attrs.metadata)) {
+		if (RESERVED_METADATA_KEYS.has(key)) {
+			diag.debug(`metadata key "${key}" is reserved; use the userId/sessionId fields of propagateAttributes`);
+			continue;
+		}
+		const attr = typeof value === "string" ? value : jsonAttr(value);
+		if (attr !== void 0) out[`td.metadata.${key}`] = attr;
+	}
+	return out;
+}
+function propagatedFromContext(ctx) {
+	return ctx.getValue(PROPAGATED_KEY);
+}
+/**
+* Stamp correlation attributes (user, session/conversation, metadata) on every span and log
+* record created inside `fn`. Inner scopes merge over outer ones per key. Works before init().
+*/
+function propagateAttributes(attributes, fn) {
+	const base = activeContext();
+	const merged = {
+		...propagatedFromContext(base),
+		...buildPropagatedAttributes(attributes)
+	};
+	return withContext(base.setValue(PROPAGATED_KEY, merged), fn);
+}
+/** Minimal ContextManager over our AsyncLocalStorage, registered only for registerGlobal. */
+var AlsContextManager = class {
+	constructor(storage) {
+		this.storage = storage;
+	}
+	active() {
+		return this.storage.getStore() ?? ROOT_CONTEXT;
+	}
+	with(context, fn, thisArg, ...args) {
+		const cb = thisArg == null ? fn : fn.bind(thisArg);
+		return this.storage.run(context, cb, ...args);
+	}
+	bind(context, target) {
+		if (typeof target === "function") {
+			const storage = this.storage;
+			const bound = function(...args) {
+				return storage.run(context, () => target.apply(this, args));
+			};
+			return bound;
+		}
+		return target;
+	}
+	enable() {
+		return this;
+	}
+	disable() {
+		this.storage.disable();
+		return this;
+	}
+};
+//#endregion
+//#region src/metrics.ts
+const DURATION_BUCKETS = [
+	.01,
+	.02,
+	.04,
+	.08,
+	.16,
+	.32,
+	.64,
+	1.28,
+	2.56,
+	5.12,
+	10.24,
+	20.48,
+	40.96,
+	81.92
+];
+const TOKEN_BUCKETS = [
+	1,
+	4,
+	16,
+	64,
+	256,
+	1024,
+	4096,
+	16384,
+	65536,
+	262144,
+	1048576,
+	4194304,
+	16777216,
+	67108864
+];
+const DURATION_OPERATIONS = new Set([
+	"chat",
+	"invoke_agent",
+	"embeddings",
+	"execute_tool"
+]);
+const TOKEN_OPERATIONS = new Set([
+	"chat",
+	"invoke_agent",
+	"embeddings"
+]);
+const DORMANT_INTERVAL_MS = 2 ** 31 - 1;
+const BATCHED_METRIC_INTERVAL_MS = 6e4;
+function stringAttr(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function createMetricsPipeline({ resource, exporter, exportIntervalMillis }) {
+	const reader = new PeriodicExportingMetricReader({
+		exporter,
+		exportIntervalMillis
+	});
+	const meterProvider = new MeterProvider({
+		resource,
+		readers: [reader]
+	});
+	const meter = meterProvider.getMeter(SCOPE_NAME, SCOPE_VERSION);
+	const durationHistogram = meter.createHistogram("gen_ai.client.operation.duration", {
+		unit: "s",
+		advice: { explicitBucketBoundaries: DURATION_BUCKETS }
+	});
+	const tokenHistogram = meter.createHistogram("gen_ai.client.token.usage", {
+		unit: "{token}",
+		advice: { explicitBucketBoundaries: TOKEN_BUCKETS }
+	});
+	const record = (span) => {
+		const operation = span.attributes["gen_ai.operation.name"];
+		if (typeof operation !== "string" || !DURATION_OPERATIONS.has(operation)) return;
+		const attrs = omitUndefined({
+			"gen_ai.operation.name": operation,
+			"gen_ai.provider.name": stringAttr(span.attributes["gen_ai.provider.name"]),
+			"gen_ai.request.model": stringAttr(span.attributes["gen_ai.request.model"]),
+			"gen_ai.response.model": stringAttr(span.attributes["gen_ai.response.model"])
+		});
+		const durationSec = span.duration[0] + span.duration[1] / 1e9;
+		const errorType = stringAttr(span.attributes["error.type"]);
+		durationHistogram.record(durationSec, errorType !== void 0 ? {
+			...attrs,
+			"error.type": errorType
+		} : attrs);
+		if (!TOKEN_OPERATIONS.has(operation)) return;
+		const inputTokens = span.attributes["gen_ai.usage.input_tokens"];
+		if (typeof inputTokens === "number") tokenHistogram.record(inputTokens, {
+			...attrs,
+			"gen_ai.token.type": "input"
+		});
+		const outputTokens = span.attributes["gen_ai.usage.output_tokens"];
+		if (typeof outputTokens === "number") tokenHistogram.record(outputTokens, {
+			...attrs,
+			"gen_ai.token.type": "output"
+		});
+	};
+	return {
+		record,
+		forceFlush: () => reader.forceFlush(),
+		shutdown: () => meterProvider.shutdown()
+	};
+}
+//#endregion
+//#region src/processor.ts
+/**
+* The vendor span processor: stamps propagated correlation attributes onto every span at start,
+* then filters, records auto-metrics, and delegates to a Batch/SimpleSpanProcessor at end.
+*/
+var StampingSpanProcessor = class {
+	inner;
+	constructor(options) {
+		this.options = options;
+		this.inner = options.exportMode === "immediate" ? new SimpleSpanProcessor(options.exporter) : new BatchSpanProcessor(options.exporter, options.batch);
+	}
+	onStart(span, parentContext) {
+		try {
+			const propagated = parentContext.getValue(PROPAGATED_KEY) ?? propagatedFromContext(activeContext());
+			if (propagated) span.setAttributes(propagated);
+		} catch (error) {
+			reportError(this.options.onError, error);
+		}
+		this.inner.onStart(span, parentContext);
+	}
+	onEnd(span) {
+		try {
+			if (this.options.spanFilter && !this.options.spanFilter(span)) return;
+		} catch (error) {
+			reportError(this.options.onError, error);
+		}
+		try {
+			this.options.recordMetrics?.(span);
+		} catch (error) {
+			reportError(this.options.onError, error);
+		}
+		this.inner.onEnd(span);
+	}
+	forceFlush() {
+		return this.inner.forceFlush();
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+//#endregion
+//#region src/transport.ts
+const RETRY_DELAYS_MS = [100, 500];
+const RETRYABLE_STATUSES = new Set([
+	429,
+	502,
+	503,
+	504
+]);
+const isRetryableStatus = (status) => RETRYABLE_STATUSES.has(status);
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const cancelBody = async (res) => {
+	try {
+		await res.body?.cancel();
+	} catch {}
+};
+const postOtlp = async ({ fetchImpl, url, headers, body }) => {
+	for (let attempt = 0;; attempt += 1) {
+		try {
+			const res = await fetchImpl(url, {
+				method: "POST",
+				headers,
+				body
+			});
+			if (res.ok || !isRetryableStatus(res.status) || attempt === RETRY_DELAYS_MS.length) {
+				await cancelBody(res);
+				return res;
+			}
+			await cancelBody(res);
+		} catch (error) {
+			if (attempt === RETRY_DELAYS_MS.length) throw error;
+		}
+		await delay(RETRY_DELAYS_MS[attempt]);
+	}
+};
+const GZIP_THRESHOLD_BYTES = 1024;
+async function maybeGzip(body) {
+	if (body.byteLength <= GZIP_THRESHOLD_BYTES || typeof CompressionStream === "undefined") return { body };
+	try {
+		const stream = new Blob([body]).stream().pipeThrough(new CompressionStream("gzip"));
+		return {
+			body: new Uint8Array(await new Response(stream).arrayBuffer()),
+			contentEncoding: "gzip"
+		};
+	} catch {
+		return { body };
+	}
+}
+const MAX_BODY_BYTES = 35e5;
+function createOtlpBatchSender(serializer, target, transport, label) {
+	const send = async (items) => {
+		const body = serializer.serializeRequest(items);
+		if (!body || body.byteLength === 0) return;
+		if (body.byteLength > MAX_BODY_BYTES) {
+			if (items.length > 1) {
+				const mid = Math.ceil(items.length / 2);
+				await send(items.slice(0, mid));
+				await send(items.slice(mid));
+				return;
+			}
+			reportError(transport.onError, /* @__PURE__ */ new Error(`telemetry.dev: ${label} record exceeds max export size, dropped`));
+			return;
+		}
+		const { body: finalBody, contentEncoding } = await maybeGzip(body);
+		const headers = contentEncoding ? {
+			...target.headers,
+			"content-encoding": contentEncoding
+		} : target.headers;
+		const res = await postOtlp({
+			fetchImpl: transport.fetchImpl,
+			url: target.url,
+			headers,
+			body: finalBody
+		});
+		if (!res.ok) throw new Error(`telemetry.dev ${label} ingest failed: ${res.status}`);
+	};
+	return send;
+}
+function createTraceExporter(target, transport) {
+	const send = createOtlpBatchSender(ProtobufTraceSerializer, target, transport, "trace");
+	return {
+		export(spans, resultCallback) {
+			send(spans).then(() => resultCallback({ code: ExportResultCode.SUCCESS }), (error) => {
+				reportError(transport.onError, error);
+				resultCallback({
+					code: ExportResultCode.FAILED,
+					error: error instanceof Error ? error : void 0
+				});
+			});
+		},
+		forceFlush: () => Promise.resolve(),
+		shutdown: () => Promise.resolve()
+	};
+}
+function createLogExporter(target, transport) {
+	const send = createOtlpBatchSender(ProtobufLogsSerializer, target, transport, "log");
+	return {
+		export(logs, resultCallback) {
+			send(logs).then(() => resultCallback({ code: ExportResultCode.SUCCESS }), (error) => {
+				reportError(transport.onError, error);
+				resultCallback({
+					code: ExportResultCode.FAILED,
+					error: error instanceof Error ? error : void 0
+				});
+			});
+		},
+		forceFlush: () => Promise.resolve(),
+		shutdown: () => Promise.resolve()
+	};
+}
+function createMetricExporter(target, transport) {
+	const { fetchImpl, onError } = transport;
+	return {
+		export(resourceMetrics, resultCallback) {
+			if (!resourceMetrics.scopeMetrics.some((scope) => scope.metrics.some((metric) => metric.dataPoints.length > 0))) {
+				resultCallback({ code: 0 });
+				return;
+			}
+			const body = ProtobufMetricsSerializer.serializeRequest(resourceMetrics);
+			if (!body || body.byteLength === 0) {
+				resultCallback({ code: 0 });
+				return;
+			}
+			maybeGzip(body).then(({ body: finalBody, contentEncoding }) => {
+				const headers = contentEncoding ? {
+					...target.headers,
+					"content-encoding": contentEncoding
+				} : target.headers;
+				return fetchImpl(target.url, {
+					method: "POST",
+					headers,
+					body: finalBody
+				});
+			}).then((res) => {
+				if (!res.ok) {
+					const error = /* @__PURE__ */ new Error(`telemetry.dev metric ingest failed: ${res.status}`);
+					reportError(onError, error);
+					resultCallback({
+						code: 1,
+						error
+					});
+					return;
+				}
+				resultCallback({ code: 0 });
+			}).catch((error) => {
+				reportError(onError, error);
+				resultCallback({
+					code: 1,
+					error: error instanceof Error ? error : void 0
+				});
+			});
+		},
+		selectAggregationTemporality: () => AggregationTemporality.DELTA,
+		forceFlush: () => Promise.resolve(),
+		shutdown: () => Promise.resolve()
+	};
+}
+function otlpHeaders(apiKey) {
+	return {
+		"content-type": "application/x-protobuf",
+		authorization: `Bearer ${apiKey}`
+	};
+}
+//#endregion
+//#region src/otel.ts
+/**
+* BYO-OpenTelemetry surface: add this processor to your own TracerProvider (NodeSDK,
+* registerOTel, …) to ship its spans to telemetry.dev. Also stamps propagateAttributes
+* correlation attributes onto every span it sees.
+*/
+var TelemetrySpanProcessor = class {
+	inner;
+	metrics;
+	constructor(options = {}) {
+		const env = resolveEnv();
+		const apiKey = options.apiKey ?? env.TELEMETRY_DEV_API_KEY;
+		const baseUrl = (options.baseUrl ?? env.TELEMETRY_DEV_BASE_URL ?? "https://ingest.telemetry.dev").replace(/\/+$/, "");
+		const transport = {
+			fetchImpl: options.fetch ?? globalThis.fetch,
+			onError: options.onError
+		};
+		const exporter = options.spanExporter ?? (apiKey ? createTraceExporter({
+			url: `${baseUrl}/v1/traces`,
+			headers: otlpHeaders(apiKey)
+		}, transport) : void 0);
+		if (!exporter) {
+			diag.debug("no api key (apiKey option or TELEMETRY_DEV_API_KEY); TelemetrySpanProcessor is a no-op");
+			return;
+		}
+		const exportMode = options.exportMode ?? "batched";
+		if (options.metrics !== false && apiKey) {
+			const resource = resourceFromAttributes({
+				"service.name": options.serviceName ?? env.OTEL_SERVICE_NAME ?? "unknown_service",
+				"deployment.environment.name": options.environment ?? env.TELEMETRY_DEV_ENVIRONMENT ?? "production"
+			});
+			this.metrics = createMetricsPipeline({
+				resource,
+				exporter: createMetricExporter({
+					url: `${baseUrl}/v1/metrics`,
+					headers: otlpHeaders(apiKey)
+				}, transport),
+				exportIntervalMillis: exportMode === "batched" ? BATCHED_METRIC_INTERVAL_MS : DORMANT_INTERVAL_MS
+			});
+		}
+		const metrics = this.metrics;
+		this.inner = new StampingSpanProcessor({
+			exporter,
+			exportMode,
+			batch: {
+				...DEFAULT_BATCH,
+				...options.batch
+			},
+			spanFilter: options.spanFilter,
+			recordMetrics: metrics ? (span) => metrics.record(span) : void 0,
+			onError: options.onError
+		});
+	}
+	onStart(span, parentContext) {
+		this.inner?.onStart(span, parentContext);
+	}
+	onEnd(span) {
+		this.inner?.onEnd(span);
+	}
+	forceFlush() {
+		return Promise.all([this.inner?.forceFlush(), this.metrics?.forceFlush()]).then(() => void 0);
+	}
+	shutdown() {
+		return Promise.all([this.inner?.shutdown(), this.metrics?.shutdown()]).then(() => void 0);
+	}
+};
+/** Raw OTLP/protobuf fetch exporter for users wiring their own BatchSpanProcessor. */
+function createTelemetrySpanExporter(options = {}) {
+	const env = resolveEnv();
+	const apiKey = options.apiKey ?? env.TELEMETRY_DEV_API_KEY;
+	const baseUrl = (options.baseUrl ?? env.TELEMETRY_DEV_BASE_URL ?? "https://ingest.telemetry.dev").replace(/\/+$/, "");
+	if (!apiKey) {
+		diag.debug("no api key (apiKey option or TELEMETRY_DEV_API_KEY); exporter is a no-op");
+		return {
+			export: (_spans, resultCallback) => resultCallback({ code: ExportResultCode.SUCCESS }),
+			forceFlush: () => Promise.resolve(),
+			shutdown: () => Promise.resolve()
+		};
+	}
+	return createTraceExporter({
+		url: `${baseUrl}/v1/traces`,
+		headers: otlpHeaders(apiKey)
+	}, {
+		fetchImpl: options.fetch ?? globalThis.fetch,
+		onError: options.onError
+	});
+}
+//#endregion
+export { AlsContextManager, BATCHED_METRIC_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_BATCH, DORMANT_INTERVAL_MS, DURATION_BUCKETS, PROPAGATED_KEY, SCOPE_NAME, SCOPE_VERSION, StampingSpanProcessor, TOKEN_BUCKETS, TelemetrySpanProcessor, activeContext, als, buildPropagatedAttributes, createLogExporter, createMetricExporter, createMetricsPipeline, createTelemetrySpanExporter, createTraceExporter, diag, jsonAttr, maybeGzip, omitUndefined, otlpHeaders, postOtlp, propagateAttributes, propagatedFromContext, reportError, resolveEnv, setLogLevel, withContext };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@telemetry-dev/otel",
+  "version": "0.1.0",
+  "description": "Bring-your-own OpenTelemetry base layer for telemetry.dev: span processor and OTLP/protobuf trace exporter.",
+  "keywords": [
+    "genai",
+    "llm",
+    "observability",
+    "opentelemetry",
+    "otel",
+    "telemetry",
+    "tracing"
+  ],
+  "homepage": "https://telemetry.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telemetry-dev/telemetry.dev.git",
+    "directory": "packages/otel"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opentelemetry/core": "^2.7.1",
+    "@opentelemetry/otlp-transformer": "^0.218.0",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.218.0",
+    "@opentelemetry/sdk-metrics": "^2.7.1",
+    "@opentelemetry/sdk-trace-base": "^2.7.1"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@types/node": "^25.5.0",
+    "@typescript/native-preview": "7.0.0-dev.20260328.1",
+    "typescript": "^6.0.2",
+    "vite-plus": "0.1.20",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.20"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9.0 <2"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "pnpm exec vp pack",
+    "dev": "pnpm exec vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}

package/src/attrs.ts

@@ -0,0 +1,30 @@
+import type { Attributes } from "@opentelemetry/api";
+
+// Pinned by docs/sdk-conformance.md ("instrumentation scopes @telemetry-dev/sdk and
+// telemetry_dev") and asserted by the ingest e2e (C11). Lives here so the metrics
+// pipeline and BYO processor emit the identical scope; do NOT rename to the package name.
+export const SCOPE_NAME = "@telemetry-dev/sdk";
+export const SCOPE_VERSION = "0.0.0";
+
+export function omitUndefined(attributes: Attributes): Attributes {
+  const out: Attributes = {};
+  for (const key of Object.keys(attributes)) {
+    const value = attributes[key];
+    if (value !== undefined) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+// Stringify structured content (messages / tool args) for the gen_ai.* string attributes the
+// ingest parses back into JSON. Returns undefined so omitUndefined drops absent content.
+export function jsonAttr(value: unknown): string | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return undefined;
+  }
+}

package/src/config.ts

@@ -0,0 +1,29 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type SdkLogLevel = LogLevel | "silent";
+export type ExportMode = "batched" | "immediate";
+
+export interface BatchOptions {
+  /** Spans per export batch. LLM spans are large; keep batches small. Default 64. */
+  maxExportBatchSize?: number;
+  /** Delay between batch exports in milliseconds. Default 1000. */
+  scheduledDelayMillis?: number;
+  /** Maximum spans buffered before drops. Default 2048. */
+  maxQueueSize?: number;
+  /** Per-export timeout in milliseconds. Default 30000. */
+  exportTimeoutMillis?: number;
+}
+
+export const DEFAULT_BASE_URL = "https://ingest.telemetry.dev";
+
+export const DEFAULT_BATCH: Required<BatchOptions> = {
+  maxExportBatchSize: 64,
+  scheduledDelayMillis: 1000,
+  maxQueueSize: 2048,
+  exportTimeoutMillis: 30000,
+};
+
+export function resolveEnv(): Record<string, string | undefined> {
+  if (typeof process !== "undefined" && process.env) return process.env;
+  const emptyEnv: Record<string, string | undefined> = {};
+  return emptyEnv;
+}