promptfoo 0.121.4 → 0.121.7

package/dist/src/{otlpReceiver-BfcVq2Nq.cjs → otlpReceiver-CvJdBGSc.cjs}

@@ -1,12 +1,16 @@
-const require_logger = require("./logger-COuQb2xB.cjs");
-const require_esm = require("./esm-CtEPLdAj.cjs");
-const require_store = require("./store-DAAyxcy6.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-D_mwlA32.cjs");
+const require_logger = require("./logger-cfNpzI4o.cjs");
+const require_esm = require("./esm-BIKakvNa.cjs");
+const require_store = require("./store-B2NDDooM.cjs");
+const require_resourceAttributes = require("./resourceAttributes-ephgOvdR.cjs");
 let path = require("path");
-path = require_logger.__toESM(path);
+path = require_rolldown_runtime.__toESM(path, 1);
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
 let express = require("express");
-express = require_logger.__toESM(express);
+express = require_rolldown_runtime.__toESM(express, 1);
 let protobufjs = require("protobufjs");
-protobufjs = require_logger.__toESM(protobufjs);
+protobufjs = require_rolldown_runtime.__toESM(protobufjs, 1);
 //#region src/tracing/protobuf.ts
 /**
 * OTLP Protobuf decoder for trace data
@@ -85,6 +89,33 @@ async function decodeExportTraceServiceRequest(data) {
 }
 //#endregion
 //#region src/tracing/otlpReceiver.ts
+const LOG_EVENT_NAME_DENYLIST = new Set(["claude_code.tracing"]);
+const LOG_SPAN_DURATION_MS = 1;
+const MAX_BODY_AS_NAME_LENGTH = 128;
+const SEVERITY_NUMBER_ERROR = 17;
+const MAX_LOG_BODY_ATTR_LENGTH = 8192;
+function truncateLogBody(value) {
+	if (typeof value !== "string") return value;
+	if (value.length <= MAX_LOG_BODY_ATTR_LENGTH) return value;
+	return `${value.slice(0, MAX_LOG_BODY_ATTR_LENGTH - 15)}... [truncated]`;
+}
+const BASE64_ZERO_SPAN_ID = /^A{11,12}=?$/;
+function isZeroSpanId(id) {
+	return /^0+$/.test(id) || BASE64_ZERO_SPAN_ID.test(id);
+}
+function randomSpanId() {
+	return node_crypto.default.randomBytes(8).toString("hex");
+}
+function getStringAttribute(attributes, key) {
+	const value = attributes[key];
+	return typeof value === "string" ? value : void 0;
+}
+function resolveLogSpanName(attributes, bodyValue) {
+	const eventName = attributes["event.name"] ?? attributes["claude_code.event.name"];
+	if (typeof eventName === "string" && eventName.length > 0) return eventName;
+	if (typeof bodyValue === "string" && bodyValue.length > 0 && bodyValue.length <= MAX_BODY_AS_NAME_LENGTH) return bodyValue;
+	return "otel.log";
+}
 const SPAN_KIND_MAP = {
 	0: "unspecified",
 	1: "internal",
@@ -143,6 +174,21 @@ var OTLPReceiver = class {
 			limit: "10mb",
 			type: (req) => this.acceptFormats.includes("protobuf") && getRequestFormat(req.headers["content-type"]) === "protobuf"
 		}));
+		this.app.use("/v1/logs", (req, res, next) => {
+			if (req.method !== "POST") {
+				next();
+				return;
+			}
+			if (getRequestFormat(req.headers["content-type"]) !== "json") {
+				res.status(415).json({ error: "Only application/json is supported for /v1/logs" });
+				return;
+			}
+			next();
+		});
+		this.app.use("/v1/logs", express.default.json({
+			limit: "10mb",
+			type: (req) => getRequestFormat(req.headers["content-type"]) === "json"
+		}));
 		require_logger.logger.debug("[OtlpReceiver] Middleware configured for accepted OTLP formats");
 	}
 	setupRoutes() {
@@ -166,6 +212,17 @@ var OTLPReceiver = class {
 				this.handleProcessingError(error, res);
 			}
 		});
+		this.app.post("/v1/logs", async (req, res) => {
+			require_logger.logger.debug("[OtlpReceiver] Received logs request");
+			try {
+				const traces = this.parseOTLPLogsJSONRequest(req.body);
+				require_logger.logger.debug(`[OtlpReceiver] Parsed ${traces.length} logs into span records`);
+				if (traces.length > 0) await this.persistTraces(this.groupTraces(traces));
+				res.status(200).json({ partialSuccess: {} });
+			} catch (error) {
+				this.handleProcessingError(error, res);
+			}
+		});
 		this.app.get("/health", (_req, res) => {
 			require_logger.logger.debug("[OtlpReceiver] Health check requested");
 			res.status(200).json({ status: "ok" });
@@ -297,6 +354,67 @@ var OTLPReceiver = class {
 		}
 		return traces;
 	}
+	parseOTLPLogsJSONRequest(body) {
+		const traces = [];
+		const resourceLogs = body?.resourceLogs ?? [];
+		require_logger.logger.debug(`[OtlpReceiver] Parsing logs request with ${resourceLogs.length} resource logs`);
+		for (const resourceLog of resourceLogs) {
+			const resourceAttributes = this.parseAttributes(resourceLog.resource?.attributes);
+			for (const scopeLog of resourceLog.scopeLogs ?? []) for (const log of scopeLog.logRecords ?? []) try {
+				const parsed = this.logRecordToParsedTrace(log, scopeLog, resourceAttributes);
+				if (parsed) traces.push(parsed);
+			} catch (err) {
+				require_logger.logger.warn(`[OtlpReceiver] Skipping malformed log record in scope ${scopeLog.scope?.name ?? "(unknown)"}: ${err}`);
+			}
+		}
+		return traces;
+	}
+	logRecordToParsedTrace(log, scopeLog, resourceAttributes) {
+		const rawTraceId = log.traceId ?? getStringAttribute(resourceAttributes, "promptfoo.trace_id");
+		if (!rawTraceId) {
+			require_logger.logger.debug(`[OtlpReceiver] Dropping log: no traceId and no ${require_resourceAttributes.PROMPTFOO_RESOURCE_ATTR_TRACE_ID} resource attribute (scope=${scopeLog.scope?.name ?? "unknown"}). Ensure TRACEPARENT is propagated or OTEL_RESOURCE_ATTRIBUTES is set by the provider.`);
+			return null;
+		}
+		const traceId = this.convertId(rawTraceId, 32);
+		if (traceId.length !== 32 || !/^[0-9a-f]+$/.test(traceId)) {
+			require_logger.logger.debug(`[OtlpReceiver] Dropping log: invalid trace_id shape '${rawTraceId}'`);
+			return null;
+		}
+		const attributes = {
+			...resourceAttributes,
+			...this.parseAttributes(log.attributes),
+			"otel.scope.name": scopeLog.scope?.name,
+			"otel.scope.version": scopeLog.scope?.version,
+			"otel.log.severity_number": log.severityNumber,
+			"otel.log.severity_text": log.severityText
+		};
+		const bodyValue = log.body ? this.parseAttributeValue(log.body) : void 0;
+		const name = resolveLogSpanName(attributes, bodyValue);
+		if (LOG_EVENT_NAME_DENYLIST.has(name)) {
+			require_logger.logger.debug(`[OtlpReceiver] Dropping log: event '${name}' is in the denylist`);
+			return null;
+		}
+		if (bodyValue !== void 0) attributes["otel.log.body"] = truncateLogBody(bodyValue);
+		const timeNano = log.timeUnixNano ?? log.observedTimeUnixNano;
+		const startTime = timeNano ? Number(timeNano) / 1e6 : Date.now();
+		const endTime = startTime + LOG_SPAN_DURATION_MS;
+		const rawParentSpanId = !!log.spanId && !isZeroSpanId(log.spanId) ? log.spanId : getStringAttribute(resourceAttributes, require_resourceAttributes.PROMPTFOO_RESOURCE_ATTR_PARENT_SPAN_ID);
+		const parentSpanId = rawParentSpanId ? this.convertId(rawParentSpanId, 16) : void 0;
+		const severityIsError = typeof log.severityNumber === "number" && log.severityNumber >= SEVERITY_NUMBER_ERROR;
+		return {
+			traceId,
+			span: {
+				spanId: randomSpanId(),
+				parentSpanId,
+				name,
+				startTime,
+				endTime,
+				attributes,
+				statusCode: 1,
+				statusMessage: severityIsError ? log.severityText : void 0
+			}
+		};
+	}
 	async parseOTLPProtobufRequest(body) {
 		const decoded = await decodeExportTraceServiceRequest(body);
 		require_logger.logger.debug(`[OtlpReceiver] Parsing protobuf request with ${decoded.resourceSpans?.length || 0} resource spans`);
@@ -466,4 +584,4 @@ async function stopOTLPReceiver() {
 exports.startOTLPReceiver = startOTLPReceiver;
 exports.stopOTLPReceiver = stopOTLPReceiver;
 
-//# sourceMappingURL=otlpReceiver-BfcVq2Nq.cjs.map
+//# sourceMappingURL=otlpReceiver-CvJdBGSc.cjs.map

package/dist/src/packageParser--MWTSrPW.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { i as resolvePackageEntryPoint, r as importModule } from "./esm-Bexx2PFc.js";
+import path from "path";
+//#region src/providers/packageParser.ts
+function getValue(obj, path) {
+	return path.split(".").reduce((acc, key) => {
+		return acc && acc[key] !== void 0 ? acc[key] : void 0;
+	}, obj);
+}
+function isPackagePath(path) {
+	return typeof path === "string" && path.startsWith("package:");
+}
+async function loadFromPackage(packageInstancePath, basePath) {
+	const [, packageName, entityName] = packageInstancePath.split(":");
+	if (!packageName || !entityName) throw new Error(`Invalid package format: ${packageInstancePath}. Expected format: package:packageName:exportedClassOrFunction`);
+	const filePath = resolvePackageEntryPoint(packageName, path.resolve(basePath));
+	if (!filePath) throw new Error(`Package not found: ${packageName}. Make sure it's installed in ${basePath}`);
+	let module;
+	try {
+		module = await importModule(filePath);
+	} catch (error) {
+		throw new Error(`Failed to import module: ${packageName}. Error: ${error}`);
+	}
+	const entity = getValue(module, entityName);
+	if (entity === void 0) throw new Error(`Could not find entity: ${entityName} in module: ${filePath}. Make sure the entity is exported from the package.`);
+	return entity;
+}
+async function parsePackageProvider(providerPath, basePath, options) {
+	const Provider = await loadFromPackage(providerPath, basePath);
+	if (typeof Provider !== "function") throw new Error(`Provider malformed: ${providerPath} must export a provider constructor. Received: ${typeof Provider}`);
+	return new Provider(options);
+}
+//#endregion
+export { loadFromPackage as n, parsePackageProvider as r, isPackagePath as t };
+
+//# sourceMappingURL=packageParser--MWTSrPW.js.map

package/dist/src/packageParser-CgE-ziRo.js

@@ -0,0 +1,35 @@
+import { i as resolvePackageEntryPoint, r as importModule } from "./esm-BTK1W7lG.js";
+import path from "path";
+//#region src/providers/packageParser.ts
+function getValue(obj, path) {
+	return path.split(".").reduce((acc, key) => {
+		return acc && acc[key] !== void 0 ? acc[key] : void 0;
+	}, obj);
+}
+function isPackagePath(path) {
+	return typeof path === "string" && path.startsWith("package:");
+}
+async function loadFromPackage(packageInstancePath, basePath) {
+	const [, packageName, entityName] = packageInstancePath.split(":");
+	if (!packageName || !entityName) throw new Error(`Invalid package format: ${packageInstancePath}. Expected format: package:packageName:exportedClassOrFunction`);
+	const filePath = resolvePackageEntryPoint(packageName, path.resolve(basePath));
+	if (!filePath) throw new Error(`Package not found: ${packageName}. Make sure it's installed in ${basePath}`);
+	let module;
+	try {
+		module = await importModule(filePath);
+	} catch (error) {
+		throw new Error(`Failed to import module: ${packageName}. Error: ${error}`);
+	}
+	const entity = getValue(module, entityName);
+	if (entity === void 0) throw new Error(`Could not find entity: ${entityName} in module: ${filePath}. Make sure the entity is exported from the package.`);
+	return entity;
+}
+async function parsePackageProvider(providerPath, basePath, options) {
+	const Provider = await loadFromPackage(providerPath, basePath);
+	if (typeof Provider !== "function") throw new Error(`Provider malformed: ${providerPath} must export a provider constructor. Received: ${typeof Provider}`);
+	return new Provider(options);
+}
+//#endregion
+export { loadFromPackage as n, parsePackageProvider as r, isPackagePath as t };
+
+//# sourceMappingURL=packageParser-CgE-ziRo.js.map

package/dist/src/packageParser-QoCS1FMl.cjs

@@ -0,0 +1,54 @@
+const require_rolldown_runtime = require("./rolldown-runtime-D_mwlA32.cjs");
+const require_esm = require("./esm-BIKakvNa.cjs");
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path, 1);
+//#region src/providers/packageParser.ts
+function getValue(obj, path$2) {
+	return path$2.split(".").reduce((acc, key) => {
+		return acc && acc[key] !== void 0 ? acc[key] : void 0;
+	}, obj);
+}
+function isPackagePath(path$3) {
+	return typeof path$3 === "string" && path$3.startsWith("package:");
+}
+async function loadFromPackage(packageInstancePath, basePath) {
+	const [, packageName, entityName] = packageInstancePath.split(":");
+	if (!packageName || !entityName) throw new Error(`Invalid package format: ${packageInstancePath}. Expected format: package:packageName:exportedClassOrFunction`);
+	const filePath = require_esm.resolvePackageEntryPoint(packageName, path.default.resolve(basePath));
+	if (!filePath) throw new Error(`Package not found: ${packageName}. Make sure it's installed in ${basePath}`);
+	let module;
+	try {
+		module = await require_esm.importModule(filePath);
+	} catch (error) {
+		throw new Error(`Failed to import module: ${packageName}. Error: ${error}`);
+	}
+	const entity = getValue(module, entityName);
+	if (entity === void 0) throw new Error(`Could not find entity: ${entityName} in module: ${filePath}. Make sure the entity is exported from the package.`);
+	return entity;
+}
+async function parsePackageProvider(providerPath, basePath, options) {
+	const Provider = await loadFromPackage(providerPath, basePath);
+	if (typeof Provider !== "function") throw new Error(`Provider malformed: ${providerPath} must export a provider constructor. Received: ${typeof Provider}`);
+	return new Provider(options);
+}
+//#endregion
+Object.defineProperty(exports, "isPackagePath", {
+	enumerable: true,
+	get: function() {
+		return isPackagePath;
+	}
+});
+Object.defineProperty(exports, "loadFromPackage", {
+	enumerable: true,
+	get: function() {
+		return loadFromPackage;
+	}
+});
+Object.defineProperty(exports, "parsePackageProvider", {
+	enumerable: true,
+	get: function() {
+		return parsePackageProvider;
+	}
+});
+
+//# sourceMappingURL=packageParser-QoCS1FMl.cjs.map

package/dist/src/packageParser-hwwSGnAZ.js

@@ -0,0 +1,35 @@
+import { i as resolvePackageEntryPoint, r as importModule } from "./esm-B6whoAcf.js";
+import path from "path";
+//#region src/providers/packageParser.ts
+function getValue(obj, path) {
+	return path.split(".").reduce((acc, key) => {
+		return acc && acc[key] !== void 0 ? acc[key] : void 0;
+	}, obj);
+}
+function isPackagePath(path) {
+	return typeof path === "string" && path.startsWith("package:");
+}
+async function loadFromPackage(packageInstancePath, basePath) {
+	const [, packageName, entityName] = packageInstancePath.split(":");
+	if (!packageName || !entityName) throw new Error(`Invalid package format: ${packageInstancePath}. Expected format: package:packageName:exportedClassOrFunction`);
+	const filePath = resolvePackageEntryPoint(packageName, path.resolve(basePath));
+	if (!filePath) throw new Error(`Package not found: ${packageName}. Make sure it's installed in ${basePath}`);
+	let module;
+	try {
+		module = await importModule(filePath);
+	} catch (error) {
+		throw new Error(`Failed to import module: ${packageName}. Error: ${error}`);
+	}
+	const entity = getValue(module, entityName);
+	if (entity === void 0) throw new Error(`Could not find entity: ${entityName} in module: ${filePath}. Make sure the entity is exported from the package.`);
+	return entity;
+}
+async function parsePackageProvider(providerPath, basePath, options) {
+	const Provider = await loadFromPackage(providerPath, basePath);
+	if (typeof Provider !== "function") throw new Error(`Provider malformed: ${providerPath} must export a provider constructor. Received: ${typeof Provider}`);
+	return new Provider(options);
+}
+//#endregion
+export { loadFromPackage as n, parsePackageProvider as r, isPackagePath as t };
+
+//# sourceMappingURL=packageParser-hwwSGnAZ.js.map

package/dist/src/processShim-BBxt7LKO.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { n as __require } from "./chunk-DRamLcfz.js";
+//#region src/util/processShim.ts
+/**
+* Browser-safe process shim module.
+*
+* This module provides a shimmed process object that works in both Node.js and browser
+* environments. In Node.js, it provides full functionality including process.mainModule.require.
+* In browsers, it returns a minimal shim that throws helpful errors when Node.js-specific
+* features are accessed.
+*
+* This separation is necessary because:
+* 1. The promptfoo webui imports httpTransforms.ts which needs getProcessShim()
+* 2. httpTransforms.ts is designed to be frontend-importable for testing transforms in the UI
+* 3. The Node.js implementation uses createRequire from 'node:module' which doesn't exist in browsers
+*
+* By using runtime environment detection and dynamic imports, we can:
+* - Avoid top-level imports of Node.js-only modules that would break browser bundling
+* - Provide appropriate functionality for each environment
+*/
+/**
+* Detects if the current environment is a browser or web worker.
+* Handles test environments (jsdom/happy-dom) that define window in Node.js.
+*/
+function isBrowserEnvironment() {
+	if (typeof process !== "undefined" && typeof process.versions?.node === "string") return false;
+	return typeof window !== "undefined" || typeof self !== "undefined" && typeof self.importScripts === "function";
+}
+/**
+* Creates a minimal process shim for browser environments.
+* This shim provides helpful error messages when Node.js-specific features are accessed.
+*/
+function createBrowserProcessShim() {
+	return {
+		env: {},
+		mainModule: {
+			require: () => {
+				throw new Error("require() is not available in browser transforms. Use standard JavaScript instead.");
+			},
+			exports: {},
+			id: ".",
+			filename: "",
+			loaded: true,
+			children: [],
+			paths: []
+		}
+	};
+}
+let cachedNodeProcessShim = null;
+/**
+* Returns a shimmed process object that works in both Node.js and browser environments.
+*
+* In Node.js:
+* - Returns a proxy with process.mainModule.require shimmed for ESM compatibility
+* - Allows inline transforms to use require() even in ESM context
+*
+* In browsers:
+* - Returns a minimal shim with helpful error messages
+* - Allows simple transforms that don't use require() to work
+*
+* @example
+* // In Node.js - can use require
+* const fn = new Function('data', 'process', `return process.mainModule.require('fs')`);
+* fn(data, getProcessShim());
+*
+* @example
+* // In browser - simple transforms work
+* const fn = new Function('data', 'process', `return data.toUpperCase()`);
+* fn(data, getProcessShim());
+*/
+function getProcessShim() {
+	if (isBrowserEnvironment()) return createBrowserProcessShim();
+	if (!cachedNodeProcessShim) try {
+		const esmRequire = __require("node:module").createRequire(import.meta.url);
+		cachedNodeProcessShim = new Proxy(process, { get(target, prop) {
+			if (prop === "mainModule") return {
+				require: esmRequire,
+				exports: {},
+				id: ".",
+				filename: "",
+				loaded: true,
+				children: [],
+				paths: []
+			};
+			return Reflect.get(target, prop);
+		} });
+	} catch {
+		return createBrowserProcessShim();
+	}
+	return cachedNodeProcessShim;
+}
+//#endregion
+export { getProcessShim as t };
+
+//# sourceMappingURL=processShim-BBxt7LKO.js.map

package/dist/src/processShim-BcGzU8fY.js

@@ -0,0 +1,94 @@
+import { n as __require } from "./chunk-DEq-mXcV.js";
+//#region src/util/processShim.ts
+/**
+* Browser-safe process shim module.
+*
+* This module provides a shimmed process object that works in both Node.js and browser
+* environments. In Node.js, it provides full functionality including process.mainModule.require.
+* In browsers, it returns a minimal shim that throws helpful errors when Node.js-specific
+* features are accessed.
+*
+* This separation is necessary because:
+* 1. The promptfoo webui imports httpTransforms.ts which needs getProcessShim()
+* 2. httpTransforms.ts is designed to be frontend-importable for testing transforms in the UI
+* 3. The Node.js implementation uses createRequire from 'node:module' which doesn't exist in browsers
+*
+* By using runtime environment detection and dynamic imports, we can:
+* - Avoid top-level imports of Node.js-only modules that would break browser bundling
+* - Provide appropriate functionality for each environment
+*/
+/**
+* Detects if the current environment is a browser or web worker.
+* Handles test environments (jsdom/happy-dom) that define window in Node.js.
+*/
+function isBrowserEnvironment() {
+	if (typeof process !== "undefined" && typeof process.versions?.node === "string") return false;
+	return typeof window !== "undefined" || typeof self !== "undefined" && typeof self.importScripts === "function";
+}
+/**
+* Creates a minimal process shim for browser environments.
+* This shim provides helpful error messages when Node.js-specific features are accessed.
+*/
+function createBrowserProcessShim() {
+	return {
+		env: {},
+		mainModule: {
+			require: () => {
+				throw new Error("require() is not available in browser transforms. Use standard JavaScript instead.");
+			},
+			exports: {},
+			id: ".",
+			filename: "",
+			loaded: true,
+			children: [],
+			paths: []
+		}
+	};
+}
+let cachedNodeProcessShim = null;
+/**
+* Returns a shimmed process object that works in both Node.js and browser environments.
+*
+* In Node.js:
+* - Returns a proxy with process.mainModule.require shimmed for ESM compatibility
+* - Allows inline transforms to use require() even in ESM context
+*
+* In browsers:
+* - Returns a minimal shim with helpful error messages
+* - Allows simple transforms that don't use require() to work
+*
+* @example
+* // In Node.js - can use require
+* const fn = new Function('data', 'process', `return process.mainModule.require('fs')`);
+* fn(data, getProcessShim());
+*
+* @example
+* // In browser - simple transforms work
+* const fn = new Function('data', 'process', `return data.toUpperCase()`);
+* fn(data, getProcessShim());
+*/
+function getProcessShim() {
+	if (isBrowserEnvironment()) return createBrowserProcessShim();
+	if (!cachedNodeProcessShim) try {
+		const esmRequire = __require("node:module").createRequire(import.meta.url);
+		cachedNodeProcessShim = new Proxy(process, { get(target, prop) {
+			if (prop === "mainModule") return {
+				require: esmRequire,
+				exports: {},
+				id: ".",
+				filename: "",
+				loaded: true,
+				children: [],
+				paths: []
+			};
+			return Reflect.get(target, prop);
+		} });
+	} catch {
+		return createBrowserProcessShim();
+	}
+	return cachedNodeProcessShim;
+}
+//#endregion
+export { getProcessShim as t };
+
+//# sourceMappingURL=processShim-BcGzU8fY.js.map

package/dist/src/processShim-C_z3aRvF.js

@@ -0,0 +1,94 @@
+import { n as __require } from "./chunk-DEq-mXcV.js";
+//#region src/util/processShim.ts
+/**
+* Browser-safe process shim module.
+*
+* This module provides a shimmed process object that works in both Node.js and browser
+* environments. In Node.js, it provides full functionality including process.mainModule.require.
+* In browsers, it returns a minimal shim that throws helpful errors when Node.js-specific
+* features are accessed.
+*
+* This separation is necessary because:
+* 1. The promptfoo webui imports httpTransforms.ts which needs getProcessShim()
+* 2. httpTransforms.ts is designed to be frontend-importable for testing transforms in the UI
+* 3. The Node.js implementation uses createRequire from 'node:module' which doesn't exist in browsers
+*
+* By using runtime environment detection and dynamic imports, we can:
+* - Avoid top-level imports of Node.js-only modules that would break browser bundling
+* - Provide appropriate functionality for each environment
+*/
+/**
+* Detects if the current environment is a browser or web worker.
+* Handles test environments (jsdom/happy-dom) that define window in Node.js.
+*/
+function isBrowserEnvironment() {
+	if (typeof process !== "undefined" && typeof process.versions?.node === "string") return false;
+	return typeof window !== "undefined" || typeof self !== "undefined" && typeof self.importScripts === "function";
+}
+/**
+* Creates a minimal process shim for browser environments.
+* This shim provides helpful error messages when Node.js-specific features are accessed.
+*/
+function createBrowserProcessShim() {
+	return {
+		env: {},
+		mainModule: {
+			require: () => {
+				throw new Error("require() is not available in browser transforms. Use standard JavaScript instead.");
+			},
+			exports: {},
+			id: ".",
+			filename: "",
+			loaded: true,
+			children: [],
+			paths: []
+		}
+	};
+}
+let cachedNodeProcessShim = null;
+/**
+* Returns a shimmed process object that works in both Node.js and browser environments.
+*
+* In Node.js:
+* - Returns a proxy with process.mainModule.require shimmed for ESM compatibility
+* - Allows inline transforms to use require() even in ESM context
+*
+* In browsers:
+* - Returns a minimal shim with helpful error messages
+* - Allows simple transforms that don't use require() to work
+*
+* @example
+* // In Node.js - can use require
+* const fn = new Function('data', 'process', `return process.mainModule.require('fs')`);
+* fn(data, getProcessShim());
+*
+* @example
+* // In browser - simple transforms work
+* const fn = new Function('data', 'process', `return data.toUpperCase()`);
+* fn(data, getProcessShim());
+*/
+function getProcessShim() {
+	if (isBrowserEnvironment()) return createBrowserProcessShim();
+	if (!cachedNodeProcessShim) try {
+		const esmRequire = __require("node:module").createRequire(import.meta.url);
+		cachedNodeProcessShim = new Proxy(process, { get(target, prop) {
+			if (prop === "mainModule") return {
+				require: esmRequire,
+				exports: {},
+				id: ".",
+				filename: "",
+				loaded: true,
+				children: [],
+				paths: []
+			};
+			return Reflect.get(target, prop);
+		} });
+	} catch {
+		return createBrowserProcessShim();
+	}
+	return cachedNodeProcessShim;
+}
+//#endregion
+export { getProcessShim as t };
+
+//# sourceMappingURL=processShim-C_z3aRvF.js.map