@use-lattice/litmus 0.121.3

package/dist/src/evalResult-C7JJAPBb.js

@@ -0,0 +1,295 @@
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { h as safeJsonStringify, r as logger, v as getEnvBool } from "./logger-C40ZGil9.js";
+import { A as isApiProvider, g as ResultFailureReason, j as isProviderOptions, k as isResultFailureReason } from "./types-Bn6D9c4U.js";
+import { u as getCurrentTimestamp } from "./fetch-DQckpUFz.js";
+import { t as hashPrompt } from "./utils-CisQwpjA.js";
+import { i as evalResultsTable, p as getDb } from "./tables-Bi2fjr4W.js";
+import { n as isBlobStorageEnabled, t as extractAndStoreBinaryData } from "./extractor-DtlL28vL.js";
+import { and, eq, gte, inArray, lt, ne } from "drizzle-orm";
+//#region src/models/evalResult.ts
+var evalResult_exports = /* @__PURE__ */ __exportAll({
+	default: () => EvalResult,
+	sanitizeProvider: () => sanitizeProvider
+});
+function sanitizeProvider(provider) {
+	try {
+		if (isApiProvider(provider)) return {
+			id: provider.id(),
+			label: provider.label,
+			...provider.config && { config: JSON.parse(safeJsonStringify(provider.config)) }
+		};
+		if (isProviderOptions(provider)) return {
+			id: provider.id,
+			label: provider.label,
+			...provider.config && { config: JSON.parse(safeJsonStringify(provider.config)) }
+		};
+		if (typeof provider === "object" && provider) {
+			const providerObj = provider;
+			return {
+				id: typeof providerObj.id === "function" ? providerObj.id() : providerObj.id,
+				label: providerObj.label,
+				...providerObj.config && { config: JSON.parse(safeJsonStringify(providerObj.config)) }
+			};
+		}
+	} catch {}
+	return JSON.parse(safeJsonStringify(provider));
+}
+/**
+* Sanitize an object for database storage by removing circular references
+* and non-serializable values (functions, Timeout objects, etc.).
+* Uses safeJsonStringify which handles circular references gracefully.
+*
+* This prevents "Converting circular structure to JSON" errors that can occur
+* when Node.js Timeout objects or other non-serializable data leaks into results.
+* See: https://github.com/promptfoo/promptfoo/issues/7266
+*/
+function sanitizeForDb(obj) {
+	if (obj === null || obj === void 0) return obj;
+	try {
+		const serialized = safeJsonStringify(obj);
+		if (serialized === void 0) {
+			logger.debug("sanitizeForDb: Failed to serialize object, using fallback", {
+				valueType: typeof obj,
+				isArray: Array.isArray(obj)
+			});
+			return Array.isArray(obj) ? [] : null;
+		}
+		return JSON.parse(serialized);
+	} catch (error) {
+		logger.debug("sanitizeForDb: Parse error, using fallback", { error });
+		return Array.isArray(obj) ? [] : null;
+	}
+}
+var EvalResult = class EvalResult {
+	static async createFromEvaluateResult(evalId, result, opts) {
+		const persist = opts?.persist == null ? true : opts.persist;
+		const { prompt, error, score, latencyMs, success, provider, gradingResult, namedScores, cost, metadata, failureReason, testCase } = result;
+		const preSanitizeTestCase = {
+			...testCase,
+			...testCase.provider && { provider: sanitizeProvider(testCase.provider) }
+		};
+		const processedResponse = await extractAndStoreBinaryData(result.response, {
+			evalId,
+			testIdx: result.testIdx,
+			promptIdx: result.promptIdx
+		});
+		const args = {
+			id: crypto.randomUUID(),
+			evalId,
+			testCase: sanitizeForDb(preSanitizeTestCase),
+			promptIdx: result.promptIdx,
+			testIdx: result.testIdx,
+			prompt: sanitizeForDb(prompt),
+			promptId: hashPrompt(prompt),
+			error: error?.toString(),
+			success,
+			score: score == null ? 0 : score,
+			response: sanitizeForDb(processedResponse || null),
+			gradingResult: sanitizeForDb(gradingResult || null),
+			namedScores: sanitizeForDb(namedScores),
+			provider: sanitizeProvider(provider),
+			latencyMs,
+			cost,
+			metadata: sanitizeForDb(metadata),
+			failureReason
+		};
+		if (persist) return new EvalResult({
+			...(await getDb().insert(evalResultsTable).values(args).returning())[0],
+			persisted: true
+		});
+		return new EvalResult(args);
+	}
+	static async createManyFromEvaluateResult(results, evalId) {
+		const db = getDb();
+		const returnResults = [];
+		const processedResults = [];
+		for (const result of results) {
+			const processedResponse = isBlobStorageEnabled() ? await extractAndStoreBinaryData(result.response, {
+				evalId,
+				testIdx: result.testIdx,
+				promptIdx: result.promptIdx
+			}) : result.response;
+			processedResults.push({
+				...result,
+				response: processedResponse ?? void 0
+			});
+		}
+		db.transaction(() => {
+			for (const result of processedResults) {
+				const sanitizedResult = {
+					...result,
+					testCase: sanitizeForDb(result.testCase),
+					prompt: sanitizeForDb(result.prompt),
+					response: sanitizeForDb(result.response),
+					gradingResult: sanitizeForDb(result.gradingResult),
+					namedScores: sanitizeForDb(result.namedScores),
+					metadata: sanitizeForDb(result.metadata),
+					provider: result.provider ? sanitizeProvider(result.provider) : result.provider
+				};
+				const dbResult = db.insert(evalResultsTable).values({
+					...sanitizedResult,
+					evalId,
+					id: crypto.randomUUID()
+				}).returning().get();
+				returnResults.push(new EvalResult({
+					...dbResult,
+					persisted: true
+				}));
+			}
+		});
+		return returnResults;
+	}
+	static async findById(id) {
+		const result = await getDb().select().from(evalResultsTable).where(eq(evalResultsTable.id, id));
+		return result.length > 0 ? new EvalResult({
+			...result[0],
+			persisted: true
+		}) : null;
+	}
+	static async findManyByEvalId(evalId, opts) {
+		return (await getDb().select().from(evalResultsTable).where(and(eq(evalResultsTable.evalId, evalId), opts?.testIdx == null ? void 0 : eq(evalResultsTable.testIdx, opts.testIdx)))).map((result) => new EvalResult({
+			...result,
+			persisted: true
+		}));
+	}
+	static async findManyByEvalIdAndTestIndices(evalId, testIndices) {
+		if (!testIndices.length) return [];
+		return (await getDb().select().from(evalResultsTable).where(and(eq(evalResultsTable.evalId, evalId), testIndices.length === 1 ? eq(evalResultsTable.testIdx, testIndices[0]) : inArray(evalResultsTable.testIdx, testIndices)))).map((result) => new EvalResult({
+			...result,
+			persisted: true
+		}));
+	}
+	/**
+	* Returns a set of completed (testIdx,promptIdx) pairs for a given eval.
+	* Key format: `${testIdx}:${promptIdx}`
+	*
+	* @param evalId - The evaluation ID to query
+	* @param opts.excludeErrors - If true, excludes results with ERROR failureReason (used in retry mode)
+	*/
+	static async getCompletedIndexPairs(evalId, opts) {
+		const db = getDb();
+		const whereClause = opts?.excludeErrors ? and(eq(evalResultsTable.evalId, evalId), ne(evalResultsTable.failureReason, ResultFailureReason.ERROR)) : eq(evalResultsTable.evalId, evalId);
+		const rows = await db.select({
+			testIdx: evalResultsTable.testIdx,
+			promptIdx: evalResultsTable.promptIdx
+		}).from(evalResultsTable).where(whereClause);
+		const ret = /* @__PURE__ */ new Set();
+		for (const r of rows) ret.add(`${r.testIdx}:${r.promptIdx}`);
+		return ret;
+	}
+	static async *findManyByEvalIdBatched(evalId, opts) {
+		const db = getDb();
+		const batchSize = opts?.batchSize || 100;
+		let offset = 0;
+		while (true) {
+			const results = await db.select().from(evalResultsTable).where(and(eq(evalResultsTable.evalId, evalId), gte(evalResultsTable.testIdx, offset), lt(evalResultsTable.testIdx, offset + batchSize))).all();
+			if (results.length === 0) break;
+			yield results.map((result) => new EvalResult({
+				...result,
+				persisted: true
+			}));
+			offset += batchSize;
+		}
+	}
+	id;
+	evalId;
+	description;
+	promptIdx;
+	testIdx;
+	testCase;
+	prompt;
+	promptId;
+	error;
+	success;
+	score;
+	response;
+	gradingResult;
+	namedScores;
+	provider;
+	latencyMs;
+	cost;
+	metadata;
+	failureReason;
+	persisted;
+	pluginId;
+	constructor(opts) {
+		this.id = opts.id;
+		this.evalId = opts.evalId;
+		this.promptIdx = opts.promptIdx;
+		this.testIdx = opts.testIdx;
+		this.testCase = opts.testCase;
+		this.prompt = opts.prompt;
+		this.promptId = opts.promptId || hashPrompt(opts.prompt);
+		this.error = opts.error;
+		this.score = opts.score;
+		this.success = opts.success;
+		this.response = opts.response || void 0;
+		this.gradingResult = opts.gradingResult;
+		this.namedScores = opts.namedScores || {};
+		this.provider = opts.provider;
+		this.latencyMs = opts.latencyMs || 0;
+		this.cost = opts.cost || 0;
+		this.metadata = opts.metadata || {};
+		this.failureReason = isResultFailureReason(opts.failureReason) ? opts.failureReason : ResultFailureReason.NONE;
+		this.persisted = opts.persisted || false;
+		this.pluginId = opts.testCase.metadata?.pluginId;
+	}
+	async save() {
+		const db = getDb();
+		if (this.persisted) await db.update(evalResultsTable).set({
+			...this,
+			updatedAt: getCurrentTimestamp()
+		}).where(eq(evalResultsTable.id, this.id));
+		else {
+			this.id = (await db.insert(evalResultsTable).values(this).returning())[0].id;
+			this.persisted = true;
+		}
+	}
+	toEvaluateResult() {
+		const shouldStripPromptText = getEnvBool("PROMPTFOO_STRIP_PROMPT_TEXT", false);
+		const shouldStripResponseOutput = getEnvBool("PROMPTFOO_STRIP_RESPONSE_OUTPUT", false);
+		const shouldStripTestVars = getEnvBool("PROMPTFOO_STRIP_TEST_VARS", false);
+		const shouldStripGradingResult = getEnvBool("PROMPTFOO_STRIP_GRADING_RESULT", false);
+		const shouldStripMetadata = getEnvBool("PROMPTFOO_STRIP_METADATA", false);
+		const response = shouldStripResponseOutput && this.response ? {
+			...this.response,
+			output: "[output stripped]"
+		} : this.response;
+		const prompt = shouldStripPromptText ? {
+			...this.prompt,
+			raw: "[prompt stripped]"
+		} : this.prompt;
+		const testCase = shouldStripTestVars ? {
+			...this.testCase,
+			vars: void 0
+		} : this.testCase;
+		return {
+			cost: this.cost,
+			description: this.description || void 0,
+			error: this.error || void 0,
+			gradingResult: shouldStripGradingResult ? null : this.gradingResult,
+			id: this.id,
+			latencyMs: this.latencyMs,
+			namedScores: this.namedScores,
+			prompt,
+			promptId: this.promptId,
+			promptIdx: this.promptIdx,
+			provider: {
+				id: this.provider.id,
+				label: this.provider.label
+			},
+			response,
+			score: this.score,
+			success: this.success,
+			testCase,
+			testIdx: this.testIdx,
+			vars: shouldStripTestVars ? {} : this.testCase.vars || {},
+			metadata: shouldStripMetadata ? {} : this.metadata,
+			failureReason: this.failureReason
+		};
+	}
+};
+//#endregion
+export { evalResult_exports as n, EvalResult as t };
+
+//# sourceMappingURL=evalResult-C7JJAPBb.js.map

package/dist/src/evalResult-DoVTZZWI.cjs

@@ -0,0 +1,2 @@
+const require_evalResult = require("./evalResult-C3NJPQOo.cjs");
+exports.default = require_evalResult.EvalResult;

package/dist/src/extractor-DnMD3fwt.cjs

@@ -0,0 +1,391 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_fetch = require("./fetch-BTxakTSg.cjs");
+const require_accounts = require("./accounts-Bt1oJb1Z.cjs");
+const require_blobs = require("./blobs-BgcNn97m.cjs");
+//#region src/blobs/remoteUpload.ts
+function buildRemoteUrl() {
+	const baseUrl = require_fetch.cloudConfig.getApiHost();
+	const apiKey = require_fetch.cloudConfig.getApiKey();
+	if (!baseUrl || !apiKey || !require_accounts.isLoggedIntoCloud()) return null;
+	try {
+		return new URL("/api/blobs", baseUrl).toString();
+	} catch (error) {
+		require_logger.logger.debug("[RemoteBlob] Invalid remote blob URL", {
+			error: error instanceof Error ? error.message : String(error),
+			baseUrl
+		});
+		return null;
+	}
+}
+function shouldAttemptRemoteBlobUpload() {
+	return buildRemoteUrl() !== null;
+}
+async function uploadBlobRemote(buffer, mimeType, context) {
+	const url = buildRemoteUrl();
+	const apiKey = require_fetch.cloudConfig.getApiKey();
+	if (!url || !apiKey) return null;
+	try {
+		const { fetchWithProxy } = await Promise.resolve().then(() => require("./fetch-BTxakTSg.cjs")).then((n) => n.fetch_exports);
+		const response = await fetchWithProxy(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify({
+				data: buffer.toString("base64"),
+				mimeType,
+				context
+			})
+		});
+		if (response.status === 404 || response.status === 400) {
+			require_logger.logger.debug("[RemoteBlob] Remote blob upload unavailable", { status: response.status });
+			return null;
+		}
+		if (!response.ok) {
+			const text = await response.text();
+			require_logger.logger.debug("[RemoteBlob] Failed to upload blob", {
+				status: response.status,
+				statusText: response.statusText,
+				body: text
+			});
+			return null;
+		}
+		const data = await response.json();
+		if (!data?.ref?.hash) {
+			require_logger.logger.debug("[RemoteBlob] Remote upload returned malformed response");
+			return null;
+		}
+		return data;
+	} catch (error) {
+		require_logger.logger.debug("[RemoteBlob] Error uploading blob", { error: error instanceof Error ? error.message : String(error) });
+		return null;
+	}
+}
+//#endregion
+//#region src/blobs/extractor.ts
+const BLOB_URI_REGEX = /^promptfoo:\/\/blob\/([a-f0-9]{64})$/i;
+const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
+function isDataUrl(value) {
+	return /^data:(audio|image)\/[^;]+;base64,/.test(value);
+}
+function extractBase64(value) {
+	const match = value.match(/^data:([^;]+);base64,(.+)$/);
+	if (!match) return null;
+	const mimeType = match[1];
+	try {
+		return {
+			buffer: Buffer.from(match[2], "base64"),
+			mimeType
+		};
+	} catch (error) {
+		require_logger.logger.warn("[BlobExtractor] Failed to parse base64 data URL", { error });
+		return null;
+	}
+}
+function shouldExternalize(buffer) {
+	const size = buffer.length;
+	return size >= 1024 && size <= 52428800;
+}
+function getKindFromMimeType(mimeType) {
+	return mimeType.startsWith("audio/") ? "audio" : "image";
+}
+/**
+* Normalize audio format to proper MIME type.
+* Some providers return just 'wav' instead of 'audio/wav'.
+* @internal Exported for testing
+*/
+function normalizeAudioMimeType(format) {
+	if (!format) return "audio/wav";
+	const trimmedFormat = format.trim();
+	if (/^audio\/[a-z0-9_+-]+$/i.test(trimmedFormat)) return trimmedFormat;
+	const formatLower = trimmedFormat.toLowerCase();
+	const mimeMap = {
+		wav: "audio/wav",
+		mp3: "audio/mpeg",
+		ogg: "audio/ogg",
+		flac: "audio/flac",
+		aac: "audio/aac",
+		m4a: "audio/mp4",
+		webm: "audio/webm"
+	};
+	if (mimeMap[formatLower]) return mimeMap[formatLower];
+	if (!/^[a-z0-9_-]+$/i.test(formatLower)) {
+		require_logger.logger.warn("[BlobExtractor] Invalid audio format, using default", { format });
+		return "audio/wav";
+	}
+	return `audio/${formatLower}`;
+}
+function parseBinary(base64OrDataUrl, defaultMimeType) {
+	if (isDataUrl(base64OrDataUrl)) {
+		const parsed = extractBase64(base64OrDataUrl);
+		if (!parsed) return null;
+		return parsed;
+	}
+	try {
+		return {
+			buffer: Buffer.from(base64OrDataUrl, "base64"),
+			mimeType: defaultMimeType
+		};
+	} catch (error) {
+		require_logger.logger.warn("[BlobExtractor] Failed to parse base64 data", { error });
+		return null;
+	}
+}
+async function maybeStore(base64OrDataUrl, defaultMimeType, context, location, kind) {
+	const parsed = parseBinary(base64OrDataUrl, defaultMimeType);
+	if (!parsed || !shouldExternalize(parsed.buffer)) return null;
+	if (!isBlobStorageEnabled()) return null;
+	const mimeType = parsed.mimeType || "application/octet-stream";
+	const { ref } = await require_blobs.storeBlob(parsed.buffer, mimeType, {
+		...context,
+		location,
+		kind
+	});
+	if (shouldAttemptRemoteBlobUpload()) uploadBlobRemote(parsed.buffer, mimeType, {
+		evalId: context.evalId,
+		testIdx: context.testIdx,
+		promptIdx: context.promptIdx,
+		location,
+		kind
+	}).catch((error) => {
+		require_logger.logger.debug("[BlobExtractor] Cloud upload failed (non-fatal)", {
+			error: error instanceof Error ? error.message : String(error),
+			hash: ref.hash
+		});
+	});
+	return ref;
+}
+async function externalizeDataUrls(value, context, location) {
+	if (typeof value === "string") {
+		if (!isDataUrl(value)) return {
+			value,
+			mutated: false
+		};
+		const parsed = extractBase64(value);
+		if (!parsed || !shouldExternalize(parsed.buffer)) return {
+			value,
+			mutated: false
+		};
+		const storedRef = await maybeStore(parsed.buffer.toString("base64"), parsed.mimeType, context, location, getKindFromMimeType(parsed.mimeType)) || null;
+		if (!storedRef) return {
+			value,
+			mutated: false
+		};
+		return {
+			value: storedRef.uri,
+			mutated: true
+		};
+	}
+	if (Array.isArray(value)) {
+		let mutated = false;
+		const nextValues = await Promise.all(value.map(async (item, idx) => {
+			const { value: nextValue, mutated: childMutated } = await externalizeDataUrls(item, context, `${location}[${idx}]`);
+			mutated ||= childMutated;
+			return nextValue;
+		}));
+		return mutated ? {
+			value: nextValues,
+			mutated
+		} : {
+			value,
+			mutated: false
+		};
+	}
+	if (value && typeof value === "object") {
+		let mutated = false;
+		const nextObject = { ...value };
+		for (const [key, child] of Object.entries(value)) {
+			const { value: nextValue, mutated: childMutated } = await externalizeDataUrls(child, context, location ? `${location}.${key}` : key);
+			if (childMutated) {
+				nextObject[key] = nextValue;
+				mutated = true;
+			}
+		}
+		return mutated ? {
+			value: nextObject,
+			mutated: true
+		} : {
+			value,
+			mutated: false
+		};
+	}
+	return {
+		value,
+		mutated: false
+	};
+}
+/**
+* Best-effort extraction of binary data from provider responses.
+* Currently focuses on audio.data fields and data URL outputs.
+*/
+async function extractAndStoreBinaryData(response, context) {
+	if (!response) return response;
+	let mutated = false;
+	const next = { ...response };
+	const blobContext = context || {};
+	if (response.audio?.data && typeof response.audio.data === "string") {
+		const stored = await maybeStore(response.audio.data, normalizeAudioMimeType(response.audio.format), blobContext, "response.audio.data", "audio");
+		if (stored) {
+			next.audio = {
+				...response.audio,
+				data: void 0,
+				blobRef: stored
+			};
+			mutated = true;
+			require_logger.logger.debug("[BlobExtractor] Stored audio blob", {
+				...context,
+				hash: stored.hash
+			});
+		}
+	}
+	if (response.images?.length) next.images = await Promise.all(response.images.map(async (img, idx) => {
+		if (!img.data || typeof img.data !== "string" || !isDataUrl(img.data)) return img;
+		const stored = await maybeStore(img.data, img.mimeType || "image/png", blobContext, `response.images[${idx}].data`, "image");
+		if (stored) {
+			mutated = true;
+			require_logger.logger.debug("[BlobExtractor] Stored image blob", {
+				...context,
+				hash: stored.hash
+			});
+			return {
+				...img,
+				data: void 0,
+				blobRef: stored
+			};
+		}
+		return img;
+	}));
+	const turns = response.turns;
+	if (Array.isArray(turns)) next.turns = await Promise.all(turns.map(async (turn, idx) => {
+		if (turn?.audio?.data && typeof turn.audio.data === "string") {
+			const stored = await maybeStore(turn.audio.data, normalizeAudioMimeType(turn.audio.format), blobContext, `response.turns[${idx}].audio.data`, "audio");
+			if (stored) {
+				mutated = true;
+				return {
+					...turn,
+					audio: {
+						...turn.audio,
+						data: void 0,
+						blobRef: stored
+					}
+				};
+			}
+		}
+		return turn;
+	}));
+	if (typeof response.output === "string" && isDataUrl(response.output)) {
+		const parsed = extractBase64(response.output);
+		if (parsed && shouldExternalize(parsed.buffer)) {
+			const stored = await maybeStore(parsed.buffer.toString("base64"), parsed.mimeType, blobContext, "response.output", getKindFromMimeType(parsed.mimeType));
+			if (stored) {
+				next.output = stored.uri;
+				mutated = true;
+				require_logger.logger.debug("[BlobExtractor] Stored output blob", {
+					...context,
+					hash: stored.hash
+				});
+			}
+		}
+	}
+	if (typeof response.output === "string" && response.output.trim().startsWith("{") && (response.isBase64 && response.format === "json" || response.output.includes("\"b64_json\"") || response.output.includes("b64_json"))) try {
+		const parsed = JSON.parse(response.output);
+		if (Array.isArray(parsed.data)) {
+			let jsonMutated = false;
+			const storedUris = [];
+			for (const item of parsed.data) if (item?.b64_json && typeof item.b64_json === "string") {
+				const stored = await maybeStore(item.b64_json, "image/png", blobContext, "response.output.data[].b64_json", "image");
+				if (stored) {
+					item.b64_json = stored.uri;
+					storedUris.push(stored.uri);
+					jsonMutated = true;
+					mutated = true;
+					require_logger.logger.debug("[BlobExtractor] Stored image blob from b64_json", {
+						...context,
+						hash: stored.hash
+					});
+				}
+			}
+			if (jsonMutated) {
+				if (storedUris.length === 1) next.output = storedUris[0];
+				else if (storedUris.length > 1) next.output = JSON.stringify(storedUris);
+				else next.output = JSON.stringify(parsed);
+				next.metadata = {
+					...response.metadata || {},
+					blobUris: storedUris,
+					originalFormat: response.format
+				};
+			}
+		}
+	} catch (err) {
+		require_logger.logger.debug("[BlobExtractor] Failed to parse base64 JSON output", {
+			error: err instanceof Error ? err.message : String(err),
+			location: "response.output"
+		});
+	}
+	if (response.metadata) {
+		const { value, mutated: metadataMutated } = await externalizeDataUrls(response.metadata, blobContext, "response.metadata");
+		if (metadataMutated) {
+			next.metadata = value;
+			mutated = true;
+		}
+	}
+	const finalResponse = mutated ? next : response;
+	if (blobContext.evalId) await recordExistingBlobReferences(finalResponse, blobContext, "response");
+	return finalResponse;
+}
+function isBlobStorageEnabled() {
+	return !require_logger.getEnvBool("PROMPTFOO_INLINE_MEDIA", false);
+}
+function parseBlobHashFromValue(value) {
+	if (!value) return null;
+	if (typeof value === "string") {
+		const match = value.match(BLOB_URI_REGEX);
+		return match ? match[1] : null;
+	}
+	if (typeof value === "object") {
+		const candidate = value;
+		if (candidate.hash && BLOB_HASH_REGEX.test(candidate.hash)) return candidate.hash;
+		if (candidate.uri && typeof candidate.uri === "string") {
+			const match = candidate.uri.match(BLOB_URI_REGEX);
+			if (match) return match[1];
+		}
+	}
+	return null;
+}
+async function recordExistingBlobReferences(value, context, location) {
+	const hash = parseBlobHashFromValue(value);
+	if (hash) {
+		await require_blobs.recordBlobReference(hash, {
+			...context,
+			location
+		});
+		return;
+	}
+	if (Array.isArray(value)) {
+		await Promise.all(value.map((child, idx) => recordExistingBlobReferences(child, context, `${location}[${idx}]`)));
+		return;
+	}
+	if (value && typeof value === "object") for (const [key, child] of Object.entries(value)) await recordExistingBlobReferences(child, context, location ? `${location}.${key}` : key);
+}
+//#endregion
+Object.defineProperty(exports, "extractAndStoreBinaryData", {
+	enumerable: true,
+	get: function() {
+		return extractAndStoreBinaryData;
+	}
+});
+Object.defineProperty(exports, "isBlobStorageEnabled", {
+	enumerable: true,
+	get: function() {
+		return isBlobStorageEnabled;
+	}
+});
+Object.defineProperty(exports, "shouldAttemptRemoteBlobUpload", {
+	enumerable: true,
+	get: function() {
+		return shouldAttemptRemoteBlobUpload;
+	}
+});
+
+//# sourceMappingURL=extractor-DnMD3fwt.cjs.map