promptfoo 0.121.5 → 0.121.8

package/dist/src/{rubyUtils-DoifqkiA.cjs → rubyUtils-CqUWBZAt.cjs}

@@ -1,14 +1,22 @@
-const require_logger = require("./logger-COuQb2xB.cjs");
-const require_esm = require("./esm-B_rGuPTo.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");
 let fs = require("fs");
-fs = require_logger.__toESM(fs);
+fs = require_rolldown_runtime.__toESM(fs, 1);
 let path = require("path");
-path = require_logger.__toESM(path);
+path = require_rolldown_runtime.__toESM(path, 1);
 let os = require("os");
-os = require_logger.__toESM(os);
+os = require_rolldown_runtime.__toESM(os, 1);
 let util = require("util");
 let child_process = require("child_process");
 //#region src/ruby/rubyUtils.ts
+var rubyUtils_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	getSysExecutable: () => getSysExecutable,
+	runRuby: () => runRuby,
+	state: () => state,
+	tryPath: () => tryPath,
+	validateRubyPath: () => validateRubyPath
+});
 const execFileAsync = (0, util.promisify)(child_process.execFile);
 /**
 * Global state for Ruby executable path caching.
@@ -212,10 +220,10 @@ async function runRuby(scriptPath, method, args, options = {}) {
 	}
 }
 //#endregion
-Object.defineProperty(exports, "getSysExecutable", {
+Object.defineProperty(exports, "rubyUtils_exports", {
 	enumerable: true,
 	get: function() {
-		return getSysExecutable;
+		return rubyUtils_exports;
 	}
 });
 Object.defineProperty(exports, "runRuby", {
@@ -224,23 +232,5 @@ Object.defineProperty(exports, "runRuby", {
 		return runRuby;
 	}
 });
-Object.defineProperty(exports, "state", {
-	enumerable: true,
-	get: function() {
-		return state;
-	}
-});
-Object.defineProperty(exports, "tryPath", {
-	enumerable: true,
-	get: function() {
-		return tryPath;
-	}
-});
-Object.defineProperty(exports, "validateRubyPath", {
-	enumerable: true,
-	get: function() {
-		return validateRubyPath;
-	}
-});
 
-//# sourceMappingURL=rubyUtils-DoifqkiA.cjs.map
+//# sourceMappingURL=rubyUtils-CqUWBZAt.cjs.map

package/dist/src/{rubyUtils-DGnoCYL2.js → rubyUtils-DdGojpfv.js}

@@ -219,4 +219,4 @@ async function runRuby(scriptPath, method, args, options = {}) {
 //#endregion
 export { runRuby as n, rubyUtils_exports as t };
 
-//# sourceMappingURL=rubyUtils-DGnoCYL2.js.map
+//# sourceMappingURL=rubyUtils-DdGojpfv.js.map

package/dist/src/runtimeTransform-BJOpL9Yc.js

@@ -0,0 +1,142 @@
+import { a as logger } from "./logger-KD8JjCRJ.js";
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+export { applyRuntimeTransforms as t };
+
+//# sourceMappingURL=runtimeTransform-BJOpL9Yc.js.map

package/dist/src/runtimeTransform-Dgh_D7DU.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { s as logger } from "./logger-BbY6ypFL.js";
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+export { applyRuntimeTransforms as t };
+
+//# sourceMappingURL=runtimeTransform-Dgh_D7DU.js.map

package/dist/src/runtimeTransform-DigbjU1r.js

@@ -0,0 +1,142 @@
+import { a as logger } from "./logger-Ct2S6Yx-.js";
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+export { applyRuntimeTransforms as t };
+
+//# sourceMappingURL=runtimeTransform-DigbjU1r.js.map

package/dist/src/runtimeTransform-ON3YYILw.cjs

@@ -0,0 +1,147 @@
+const require_logger = require("./logger-cfNpzI4o.cjs");
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	require_logger.logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			require_logger.logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		require_logger.logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else require_logger.logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			require_logger.logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	require_logger.logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) require_logger.logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) require_logger.logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+Object.defineProperty(exports, "applyRuntimeTransforms", {
+	enumerable: true,
+	get: function() {
+		return applyRuntimeTransforms;
+	}
+});
+
+//# sourceMappingURL=runtimeTransform-ON3YYILw.cjs.map