@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/harness-DoKQcF8n.js

@@ -0,0 +1,258 @@
+import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { completeWithPreparedSimpleCompletionModel } from "openclaw/plugin-sdk/simple-completion-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/model-runtime.ts
+const CODEX_APP_SERVER_RUNTIME_MODEL_PARAM = "codexAppServerRuntimeModel";
+function buildCodexRuntimeModelParams(catalogId, runtimeModelId) {
+	return catalogId === runtimeModelId ? void 0 : { [CODEX_APP_SERVER_RUNTIME_MODEL_PARAM]: runtimeModelId };
+}
+function readCodexRuntimeModelId(model, fallbackId) {
+	return normalizeOptionalString(model?.params?.[CODEX_APP_SERVER_RUNTIME_MODEL_PARAM]) ?? model?.id ?? fallbackId;
+}
+//#endregion
+//#region extensions/codex/harness.ts
+const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = /* @__PURE__ */ new Set(["codex", "openai"]);
+const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = Symbol.for("openclaw.codexAppServerClientDisposer");
+const CODEX_TOOL_POLICY_SAFE_DENY_NAMES = [
+	"web_fetch",
+	"x_search",
+	"memory_search",
+	"memory_get",
+	"dashboard",
+	"canvas",
+	"show_widget",
+	"message",
+	"heartbeat_respond",
+	"automations",
+	"gateway",
+	"skill_workshop",
+	"image_generate",
+	"music_generate",
+	"video_generate",
+	"tts"
+];
+const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
+	"bootstrap",
+	"assemble-before-prompt",
+	"after-turn",
+	"maintain",
+	"compact",
+	"runtime-llm-complete",
+	"thread-bootstrap-projection"
+];
+async function runCodexHostPreparedIsolatedCompletion(params) {
+	const timeoutSignal = AbortSignal.timeout(params.timeoutMs);
+	const signal = params.abortSignal ? AbortSignal.any([params.abortSignal, timeoutSignal]) : timeoutSignal;
+	return { assistant: await completeWithPreparedSimpleCompletionModel({
+		model: params.model,
+		auth: params.auth,
+		cfg: params.config,
+		context: {
+			systemPrompt: params.systemPrompt,
+			messages: [{
+				role: "user",
+				content: params.prompt,
+				timestamp: Date.now()
+			}],
+			tools: []
+		},
+		options: {
+			maxTokens: params.streamParams?.maxTokens,
+			temperature: params.streamParams?.temperature,
+			reasoning: params.thinkLevel,
+			signal
+		}
+	}) };
+}
+async function disposeSharedCodexAppServerClients() {
+	const dispose = globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER];
+	await dispose?.();
+}
+/**
+* Creates the Codex app-server harness used for attempts, side questions,
+* compaction, reset, and disposal.
+*/
+function createCodexAppServerAgentHarness(options) {
+	const harnessRuntimeId = options?.id ?? "codex";
+	const normalizedHarnessRuntimeId = harnessRuntimeId.trim().toLowerCase();
+	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
+	const sessionCatalogControlFactory = options.sessionCatalogControlFactory;
+	const sessionRuntime = options.runtime;
+	const resolveAttemptPluginConfig = (config) => resolvePluginConfigObject(config, "codex") ?? options.resolvePluginConfig?.() ?? options.pluginConfig;
+	return {
+		id: harnessRuntimeId,
+		label: options?.label ?? "Codex agent harness",
+		autoSelection: { providerIds: [...providerIds] },
+		cloudPlacement: {
+			mode: "remote-exec",
+			devicePlacement: {
+				requiredNodeCommands: ["codex.exec-server.stdio.v1"],
+				consumesWorkerSlot: false
+			}
+		},
+		delegatedExecutionPluginIds: ["voice-call"],
+		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
+		conversationToolPolicySupport: "exact",
+		conversationToolPolicySafeDenyTools: CODEX_TOOL_POLICY_SAFE_DENY_NAMES,
+		deliveryDefaults: { visibleReplies: "message_tool" },
+		authBootstrap: "harness",
+		...sessionCatalogControlFactory && sessionRuntime ? { sessionFork: {
+			upstreamKinds: ["codex-app-server"],
+			fork: async (params) => {
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-BDVJCLAD.js");
+				return await forkCodexUpstreamSession(params, {
+					bindingStore: options.bindingStore,
+					controlFactory: sessionCatalogControlFactory,
+					harnessRuntimeId,
+					resolveConfig: options.resolveConfig,
+					runtime: sessionRuntime
+				});
+			}
+		} } : {},
+		authBinding: { fingerprint: async (params) => {
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-B4FfbcCg.js").then((n) => n.t);
+			return fingerprintCodexAppServerAuthBinding(params);
+		} },
+		runtimeArtifact: { validate: async (binding) => {
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BvyT1uyd.js");
+			return validateCodexAppServerRuntimeArtifact(binding);
+		} },
+		fetchUsageSnapshot: async (ctx) => {
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-9dKJCgcy.js");
+			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		loadModelCatalog: async (params) => {
+			const { loadCodexAppServerModelCatalog } = await import("./model-catalog-CmGoqVKB.js");
+			return await loadCodexAppServerModelCatalog(params, resolveAttemptPluginConfig(params.config));
+		},
+		loadMcpToolCatalog: async (params) => {
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-4YKn51aG.js");
+			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
+		},
+		supports: (ctx) => {
+			const provider = ctx.provider.trim().toLowerCase();
+			if (!providerIds.has(provider)) return {
+				supported: false,
+				reason: `provider is not one of: ${[...providerIds].toSorted().join(", ")}`
+			};
+			if (ctx.modelProvider?.requestTransportOverrides === "present") return {
+				supported: false,
+				reason: "Codex cannot reproduce authored request transport overrides",
+				fallbackRuntime: "openclaw"
+			};
+			const preparedAuth = ctx.modelProvider?.preparedAuth;
+			const runtimePolicy = ctx.modelProvider?.runtimePolicy;
+			const nativeAccountOwnsUnobservedModel = provider === "openai" && ctx.requestedRuntime === "codex" && Boolean(ctx.modelId?.trim()) && (preparedAuth === void 0 || preparedAuth.source === "harness") && preparedAuth?.mode === void 0 && preparedAuth?.requirement === void 0 && ctx.modelProvider?.api === void 0 && ctx.modelProvider?.baseUrl === void 0 && ctx.modelProvider?.azureApiVersion === void 0 && ctx.modelProvider?.request === void 0;
+			if (runtimePolicy) {
+				if (!runtimePolicy.compatibleIds.some((id) => id.trim().toLowerCase() === normalizedHarnessRuntimeId)) return {
+					supported: false,
+					reason: "Codex cannot reproduce the prepared provider route"
+				};
+			} else if (ctx.modelProvider && provider !== "codex" && !nativeAccountOwnsUnobservedModel) return {
+				supported: false,
+				reason: "provider route compatibility with Codex is not declared"
+			};
+			if (preparedAuth?.requirement === "subscription") {
+				if (!(preparedAuth.source === "profile" && (preparedAuth.mode === "oauth" || preparedAuth.mode === "token"))) return {
+					supported: false,
+					reason: "Codex subscription auth requires a prepared OAuth or token profile"
+				};
+			} else if (preparedAuth?.requirement === "api-key") {
+				if (!(preparedAuth.source !== "none" && preparedAuth.source !== "harness" && (preparedAuth.mode === "api-key" || preparedAuth.mode === "api_key"))) return {
+					supported: false,
+					reason: "Codex Platform auth requires a prepared API key"
+				};
+			}
+			return {
+				supported: true,
+				priority: 100
+			};
+		},
+		runAttempt: async (params) => {
+			const { runCodexAppServerAttempt } = await import("./run-attempt-BV3HzuCf.js");
+			return runCodexAppServerAttempt(params, {
+				bindingStore: options.bindingStore,
+				pluginConfig: resolveAttemptPluginConfig(params.config),
+				runtime: sessionRuntime,
+				runtimeModelId: readCodexRuntimeModelId(params.model, params.modelId),
+				nativeHookRelay: { enabled: true }
+			});
+		},
+		runIsolatedCompletionV2: async (params) => {
+			if (params.authorization.owner === "host") {
+				const { authorization, ...commonParams } = params;
+				return runCodexHostPreparedIsolatedCompletion({
+					...commonParams,
+					model: authorization.model,
+					auth: authorization.auth,
+					...authorization.sourceAuthFingerprint ? { sourceAuthFingerprint: authorization.sourceAuthFingerprint } : {}
+				});
+			}
+			const { runCodexIsolatedCompletion } = await import("./isolated-completion-DPMtlH9r.js");
+			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		runIsolatedCompletion: async (params) => {
+			return runCodexHostPreparedIsolatedCompletion(params);
+		},
+		finalizeSettledTurn: async (params) => {
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-Dx1onIqg.js");
+			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		runSideQuestion: async (params) => {
+			const { runCodexAppServerSideQuestion } = await import("./side-question-DbXkJZzg.js");
+			return runCodexAppServerSideQuestion(params, {
+				bindingStore: options.bindingStore,
+				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
+				runtime: sessionRuntime,
+				runtimeModelId: readCodexRuntimeModelId(params.runtimeModel, params.model),
+				nativeHookRelay: { enabled: true }
+			});
+		},
+		compact: async (params) => {
+			const { maybeCompactCodexAppServerSession } = await import("./compact-COqgBRny.js");
+			return maybeCompactCodexAppServerSession(params, {
+				bindingStore: options.bindingStore,
+				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
+			});
+		},
+		reset: async (params) => {
+			if (params.sessionId) {
+				const [{ reclaimCurrentCodexSessionGeneration, sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-BTrLf9Qm.js").then((n) => n.f), import("./session-retirement-CE4iMiLh.js")]);
+				const identity = sessionBindingIdentity({
+					agentId: params.agentId,
+					sessionId: params.sessionId,
+					sessionKey: params.sessionKey
+				});
+				const resetGeneration = () => retireCodexAppServerSessionGeneration({
+					bindingStore: options.bindingStore,
+					identity,
+					mode: params.reason === "deleted" ? "retire" : "reset"
+				});
+				let reset = await resetGeneration();
+				if (reset === "conflict") {
+					if (await reclaimCurrentCodexSessionGeneration({
+						bindingStore: options.bindingStore,
+						identity,
+						config: options.resolveConfig?.()
+					})) reset = await resetGeneration();
+				}
+				if (reset === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
+			}
+		},
+		dispose: disposeSharedCodexAppServerClients
+	};
+}
+/** Creates the private native-compaction bridge registered in host-owned capability state. */
+function createCodexAppServerNativeCompaction(options) {
+	return async (params) => {
+		const { maybeCompactCodexAppServerSession } = await import("./compact-COqgBRny.js");
+		return maybeCompactCodexAppServerSession(params, {
+			bindingStore: options.bindingStore,
+			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,
+			allowNonManualNativeRequest: true,
+			nativeCompactionRequest: params.nativeCompactionRequest
+		});
+	};
+}
+//#endregion
+export { createCodexAppServerNativeCompaction as n, buildCodexRuntimeModelParams as r, createCodexAppServerAgentHarness as t };

package/dist/harness.js

@@ -1,160 +1,2 @@
-//#region extensions/codex/harness.ts
-const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = /* @__PURE__ */ new Set(["codex", "openai"]);
-const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = Symbol.for("openclaw.codexAppServerClientDisposer");
-const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
-	"bootstrap",
-	"assemble-before-prompt",
-	"after-turn",
-	"maintain",
-	"compact",
-	"runtime-llm-complete",
-	"thread-bootstrap-projection"
-];
-async function disposeSharedCodexAppServerClients() {
-	const dispose = globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER];
-	await dispose?.();
-}
-/**
-* Creates the Codex app-server harness used for attempts, side questions,
-* compaction, reset, and disposal.
-*/
-function createCodexAppServerAgentHarness(options) {
-	const harnessRuntimeId = options?.id ?? "codex";
-	const normalizedHarnessRuntimeId = harnessRuntimeId.trim().toLowerCase();
-	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
-	const sessionCatalogControl = options.sessionCatalogControl;
-	const sessionRuntime = options.runtime;
-	return {
-		id: harnessRuntimeId,
-		label: options?.label ?? "Codex agent harness",
-		autoSelection: { providerIds: [...providerIds] },
-		delegatedExecutionPluginIds: ["voice-call"],
-		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
-		deliveryDefaults: { visibleReplies: "message_tool" },
-		authBootstrap: "harness",
-		...sessionCatalogControl && sessionRuntime ? { sessionFork: {
-			upstreamKinds: ["codex-app-server"],
-			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-Dy4Xvuoj.js");
-				return await forkCodexUpstreamSession(params, {
-					bindingStore: options.bindingStore,
-					control: sessionCatalogControl,
-					harnessRuntimeId,
-					resolveConfig: options.resolveConfig,
-					runtime: sessionRuntime
-				});
-			}
-		} } : {},
-		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-B4FfbcCg.js").then((n) => n.t);
-			return fingerprintCodexAppServerAuthBinding(params);
-		} },
-		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CmtG_t1L.js");
-			return validateCodexAppServerRuntimeArtifact(binding);
-		} },
-		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-CQ6GhD5-.js");
-			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
-		},
-		loadMcpToolCatalog: async (params) => {
-			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-Bbd98Inw.js");
-			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
-		},
-		supports: (ctx) => {
-			const provider = ctx.provider.trim().toLowerCase();
-			if (!providerIds.has(provider)) return {
-				supported: false,
-				reason: `provider is not one of: ${[...providerIds].toSorted().join(", ")}`
-			};
-			if (ctx.modelProvider?.requestTransportOverrides === "present") return {
-				supported: false,
-				reason: "Codex cannot reproduce authored request transport overrides"
-			};
-			const preparedAuth = ctx.modelProvider?.preparedAuth;
-			const runtimePolicy = ctx.modelProvider?.runtimePolicy;
-			if (runtimePolicy) {
-				if (!runtimePolicy.compatibleIds.some((id) => id.trim().toLowerCase() === normalizedHarnessRuntimeId)) return {
-					supported: false,
-					reason: "Codex cannot reproduce the prepared provider route"
-				};
-			} else if (ctx.modelProvider && provider !== "codex") return {
-				supported: false,
-				reason: "provider route compatibility with Codex is not declared"
-			};
-			if (preparedAuth?.requirement === "subscription") {
-				if (!(preparedAuth.source === "profile" && (preparedAuth.mode === "oauth" || preparedAuth.mode === "token"))) return {
-					supported: false,
-					reason: "Codex subscription auth requires a prepared OAuth or token profile"
-				};
-			} else if (preparedAuth?.requirement === "api-key") {
-				if (!(preparedAuth.source !== "none" && preparedAuth.source !== "harness" && (preparedAuth.mode === "api-key" || preparedAuth.mode === "api_key"))) return {
-					supported: false,
-					reason: "Codex Platform auth requires a prepared API key"
-				};
-			}
-			return {
-				supported: true,
-				priority: 100
-			};
-		},
-		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-CY9WlDLc.js");
-			return runCodexAppServerAttempt(params, {
-				bindingStore: options.bindingStore,
-				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
-				nativeHookRelay: { enabled: true }
-			});
-		},
-		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-CXY2Z9dT.js");
-			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
-		},
-		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-_ulBk1AL.js");
-			return runCodexAppServerSideQuestion(params, {
-				bindingStore: options.bindingStore,
-				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
-				nativeHookRelay: { enabled: true }
-			});
-		},
-		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-D_uvHurS.js");
-			return maybeCompactCodexAppServerSession(params, {
-				bindingStore: options.bindingStore,
-				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
-			});
-		},
-		compactAfterContextEngine: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-D_uvHurS.js");
-			return maybeCompactCodexAppServerSession(params, {
-				bindingStore: options.bindingStore,
-				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
-				allowNonManualNativeRequest: true
-			});
-		},
-		reset: async (params) => {
-			if (params.sessionId) {
-				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-BXpo9ymA.js").then((n) => n.f);
-				const identity = sessionBindingIdentity({
-					agentId: params.agentId,
-					sessionId: params.sessionId,
-					sessionKey: params.sessionKey
-				});
-				const resetGeneration = params.reason === "deleted" ? options.bindingStore.retireSessionGeneration.bind(options.bindingStore) : options.bindingStore.resetSessionGeneration.bind(options.bindingStore);
-				let reset = await resetGeneration(identity);
-				if (reset === "conflict") {
-					if (await reclaimCurrentCodexSessionGeneration({
-						bindingStore: options.bindingStore,
-						identity,
-						config: options.resolveConfig?.()
-					})) reset = await resetGeneration(identity);
-				}
-				if (reset === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
-			}
-		},
-		dispose: disposeSharedCodexAppServerClients
-	};
-}
-//#endregion
-export { createCodexAppServerAgentHarness };
+import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./harness-DoKQcF8n.js";
+export { createCodexAppServerAgentHarness, createCodexAppServerNativeCompaction };

package/dist/image-payload-sanitizer-CnfoUPCE.js

@@ -0,0 +1,65 @@
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { INLINE_IMAGE_DATA_URL_PREFIX, sanitizeInlineImageDataUrl } from "openclaw/plugin-sdk/inline-image-data-url-runtime";
+//#region extensions/codex/src/app-server/image-payload-sanitizer.ts
+/**
+* Sanitizes inline image payloads mirrored through Codex history so invalid
+* base64 data becomes readable text instead of poisoning replayed transcripts.
+*/
+const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
+/** Validates and normalizes an inline image data URL for Codex history payloads. */
+function sanitizeInlineImageDataUrl$1(imageUrl) {
+	return sanitizeInlineImageDataUrl(imageUrl);
+}
+/** Builds the replacement text inserted when an inline image payload is invalid. */
+function invalidInlineImageText(label) {
+	return `[${label}] ${IMAGE_OMITTED_TEXT}`;
+}
+function sanitizeImageContentRecord(record, label) {
+	if (record.type === "image" && typeof record.data === "string") {
+		const mimeType = typeof record.mimeType === "string" ? record.mimeType : "image/png";
+		const imageUrl = sanitizeInlineImageDataUrl$1(`data:${mimeType};base64,${record.data}`);
+		if (!imageUrl) return {
+			type: "text",
+			text: invalidInlineImageText(label)
+		};
+		const commaIndex = imageUrl.indexOf(",");
+		const mime = imageUrl.slice(INLINE_IMAGE_DATA_URL_PREFIX.length, commaIndex).split(";")[0] ?? mimeType;
+		return {
+			...record,
+			mimeType: mime,
+			data: imageUrl.slice(commaIndex + 1)
+		};
+	}
+	if (record.type === "inputImage" && typeof record.imageUrl === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl$1(record.imageUrl);
+		return imageUrl ? {
+			...record,
+			imageUrl
+		} : {
+			type: "inputText",
+			text: invalidInlineImageText(label)
+		};
+	}
+	if (record.type === "input_image" && typeof record.image_url === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl$1(record.image_url);
+		return imageUrl ? {
+			...record,
+			image_url: imageUrl
+		} : {
+			type: "input_text",
+			text: invalidInlineImageText(label)
+		};
+	}
+}
+/** Recursively sanitizes all Codex history image shapes while preserving unknown structure. */
+function sanitizeCodexHistoryImagePayloads(value, label) {
+	if (Array.isArray(value)) return value.map((entry) => sanitizeCodexHistoryImagePayloads(entry, label));
+	if (!isRecord(value)) return value;
+	const imageRecord = sanitizeImageContentRecord(value, label);
+	if (imageRecord) return imageRecord;
+	const next = {};
+	for (const [key, child] of Object.entries(value)) next[key] = sanitizeCodexHistoryImagePayloads(child, label);
+	return next;
+}
+//#endregion
+export { sanitizeCodexHistoryImagePayloads as n, sanitizeInlineImageDataUrl$1 as r, invalidInlineImageText as t };