remoteclaw 0.1.0-next.da482d8 → 0.1.0-next.db8a792

package/dist/extensionAPI.js

@@ -637,6 +637,8 @@ function createEmptyPluginRegistry() {
 		typedHooks: [],
 		channels: [],
 		providers: [],
+		sttProviders: [],
+		ttsProviders: [],
 		gatewayHandlers: {},
 		httpHandlers: [],
 		httpRoutes: [],
@@ -3896,6 +3898,8 @@ function loadPluginManifest(rootDir) {
 	const channels = normalizeStringList(raw.channels);
 	const providers = normalizeStringList(raw.providers);
 	const skills = normalizeStringList(raw.skills);
+	const stt = normalizeStringList(raw.stt);
+	const tts = normalizeStringList(raw.tts);
 	let uiHints;
 	if (isRecord(raw.uiHints)) uiHints = raw.uiHints;
 	return {
@@ -3907,6 +3911,8 @@ function loadPluginManifest(rootDir) {
 			channels,
 			providers,
 			skills,
+			stt,
+			tts,
 			name,
 			description,
 			version,
@@ -4412,6 +4418,8 @@ function buildRecord(params) {
 		channels: params.manifest.channels ?? [],
 		providers: params.manifest.providers ?? [],
 		skills: params.manifest.skills ?? [],
+		stt: params.manifest.stt ?? [],
+		tts: params.manifest.tts ?? [],
 		origin: params.candidate.origin,
 		workspaceDir: params.candidate.workspaceDir,
 		rootDir: params.candidate.rootDir,
@@ -4641,30 +4649,6 @@ function parseDurationMs(raw, opts) {
 	return ms;
 }
 
-//#endregion
-//#region src/config/zod-schema.allowdeny.ts
-const AllowDenyActionSchema = z.union([z.literal("allow"), z.literal("deny")]);
-const AllowDenyChatTypeSchema = z.union([
-	z.literal("direct"),
-	z.literal("group"),
-	z.literal("channel"),
-	z.literal("dm")
-]).optional();
-function createAllowDenyChannelRulesSchema() {
-	return z.object({
-		default: AllowDenyActionSchema.optional(),
-		rules: z.array(z.object({
-			action: AllowDenyActionSchema,
-			match: z.object({
-				channel: z.string().optional(),
-				chatType: AllowDenyChatTypeSchema,
-				keyPrefix: z.string().optional(),
-				rawKeyPrefix: z.string().optional()
-			}).strict().optional()
-		}).strict()).optional()
-	}).strict().optional();
-}
-
 //#endregion
 //#region src/config/zod-schema.sensitive.ts
 const sensitive = z.registry();
@@ -4749,11 +4733,7 @@ const MarkdownTableModeSchema = z.enum([
 	"code"
 ]);
 const MarkdownConfigSchema = z.object({ tables: MarkdownTableModeSchema.optional() }).strict().optional();
-const TtsProviderSchema = z.enum([
-	"elevenlabs",
-	"openai",
-	"edge"
-]);
+const TtsProviderSchema = z.string().min(1);
 const TtsModeSchema = z.enum(["final", "all"]);
 const TtsAutoSchema = z.enum([
 	"off",
@@ -4931,22 +4911,6 @@ const TranscribeAudioSchema = z.object({
 }).strict().optional();
 const HexColorSchema = z.string().regex(/^#?[0-9a-fA-F]{6}$/, "expected hex color (RRGGBB)");
 const ExecutableTokenSchema = z.string().refine(isSafeExecutableValue, "expected safe executable name or path");
-const MediaUnderstandingScopeSchema = createAllowDenyChannelRulesSchema();
-const MediaUnderstandingCapabilitiesSchema = z.array(z.union([
-	z.literal("image"),
-	z.literal("audio"),
-	z.literal("video")
-])).optional();
-const MediaUnderstandingAttachmentsSchema = z.object({
-	mode: z.union([z.literal("first"), z.literal("all")]).optional(),
-	maxAttachments: z.number().int().positive().optional(),
-	prefer: z.union([
-		z.literal("first"),
-		z.literal("last"),
-		z.literal("path"),
-		z.literal("url")
-	]).optional()
-}).strict().optional();
 const DeepgramAudioSchema = z.object({
 	detectLanguage: z.boolean().optional(),
 	punctuate: z.boolean().optional(),
@@ -4970,7 +4934,6 @@ const MediaUnderstandingRuntimeFields = {
 const MediaUnderstandingModelSchema = z.object({
 	provider: z.string().optional(),
 	model: z.string().optional(),
-	capabilities: MediaUnderstandingCapabilitiesSchema,
 	type: z.union([z.literal("provider"), z.literal("cli")]).optional(),
 	command: z.string().optional(),
 	args: z.array(z.string()).optional(),
@@ -4982,33 +4945,12 @@ const MediaUnderstandingModelSchema = z.object({
 }).strict().optional();
 const ToolsMediaUnderstandingSchema = z.object({
 	enabled: z.boolean().optional(),
-	scope: MediaUnderstandingScopeSchema,
 	maxBytes: z.number().int().positive().optional(),
 	maxChars: z.number().int().positive().optional(),
 	...MediaUnderstandingRuntimeFields,
-	attachments: MediaUnderstandingAttachmentsSchema,
 	models: z.array(MediaUnderstandingModelSchema).optional()
 }).strict().optional();
-const ToolsMediaSchema = z.object({
-	models: z.array(MediaUnderstandingModelSchema).optional(),
-	concurrency: z.number().int().positive().optional(),
-	image: ToolsMediaUnderstandingSchema.optional(),
-	audio: ToolsMediaUnderstandingSchema.optional(),
-	video: ToolsMediaUnderstandingSchema.optional()
-}).strict().optional();
-const LinkModelSchema = z.object({
-	type: z.literal("cli").optional(),
-	command: z.string().min(1),
-	args: z.array(z.string()).optional(),
-	timeoutSeconds: z.number().int().positive().optional()
-}).strict();
-const ToolsLinksSchema = z.object({
-	enabled: z.boolean().optional(),
-	scope: MediaUnderstandingScopeSchema,
-	maxLinks: z.number().int().positive().optional(),
-	timeoutSeconds: z.number().int().positive().optional(),
-	models: z.array(LinkModelSchema).optional()
-}).strict().optional();
+const ToolsMediaSchema = z.object({ audio: ToolsMediaUnderstandingSchema.optional() }).strict().optional();
 const NativeCommandsSettingSchema = z.union([z.boolean(), z.literal("auto")]);
 const ProviderCommandsSchema = z.object({ native: NativeCommandsSettingSchema.optional() }).strict().optional();
 
@@ -5195,7 +5137,6 @@ const AgentEntrySchema = z.object({
 const ToolsSchema = z.object({
 	...CommonToolPolicyFields,
 	media: ToolsMediaSchema,
-	links: ToolsLinksSchema,
 	sessions: z.object({ visibility: z.enum([
 		"self",
 		"tree",
@@ -6632,6 +6573,30 @@ const ChannelsSchema = z.object({
 	msteams: MSTeamsConfigSchema.optional()
 }).passthrough().optional();
 
+//#endregion
+//#region src/config/zod-schema.allowdeny.ts
+const AllowDenyActionSchema = z.union([z.literal("allow"), z.literal("deny")]);
+const AllowDenyChatTypeSchema = z.union([
+	z.literal("direct"),
+	z.literal("group"),
+	z.literal("channel"),
+	z.literal("dm")
+]).optional();
+function createAllowDenyChannelRulesSchema() {
+	return z.object({
+		default: AllowDenyActionSchema.optional(),
+		rules: z.array(z.object({
+			action: AllowDenyActionSchema,
+			match: z.object({
+				channel: z.string().optional(),
+				chatType: AllowDenyChatTypeSchema,
+				keyPrefix: z.string().optional(),
+				rawKeyPrefix: z.string().optional()
+			}).strict().optional()
+		}).strict()).optional()
+	}).strict().optional();
+}
+
 //#endregion
 //#region src/config/zod-schema.session.ts
 const SessionResetConfigSchema = z.object({
@@ -10925,6 +10890,12 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 		this.command = command;
 		this.timeoutMs = timeoutMs;
 	}
+	/**
+	* Construct a custom stdin payload for the subprocess.
+	* When this returns a string, it is written to stdin instead of
+	* the default large-prompt fallback.  Subclasses may override.
+	*/
+	buildStdinPayload(_params) {}
 	/** Whether this CLI accepts prompts via stdin. Subclasses may override. */
 	get supportsStdinPrompt() {
 		return true;
@@ -11026,7 +10997,11 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 				});
 			});
 		});
-		if (this.supportsStdinPrompt && params.prompt.length > CLIRuntimeBase.STDIN_PROMPT_THRESHOLD && child.stdin) {
+		const customStdin = this.buildStdinPayload(params);
+		if (customStdin !== void 0 && child.stdin) {
+			logDebug(`[agent-runtime] pid=${child.pid}: delivering custom stdin payload (${customStdin.length} chars)`);
+			child.stdin.write(customStdin);
+		} else if (this.supportsStdinPrompt && params.prompt.length > CLIRuntimeBase.STDIN_PROMPT_THRESHOLD && child.stdin) {
 			logDebug(`[agent-runtime] pid=${child.pid}: delivering prompt via stdin (${params.prompt.length} chars)`);
 			child.stdin.write(params.prompt);
 		}
@@ -11108,7 +11083,8 @@ var ClaudeCliRuntime = class extends CLIRuntimeBase {
 	}
 	async *execute(params) {
 		this.resetState();
-		for await (const event of super.execute(params)) {
+		const prepared = await this.prepareMedia(params);
+		for await (const event of super.execute(prepared)) {
 			if (event.type === "done") this.enrichDoneEvent(event);
 			yield event;
 		}
@@ -11122,9 +11098,34 @@ var ClaudeCliRuntime = class extends CLIRuntimeBase {
 		];
 		if (params.sessionId) args.push("--resume", params.sessionId);
 		if (params.mcpServers && Object.keys(params.mcpServers).length > 0) args.push("--mcp-config", JSON.stringify({ mcpServers: params.mcpServers }));
-		args.push("--print", params.prompt);
+		if (params.media?.some((m) => m.mimeType.startsWith("image/") && m.base64)) args.push("-p", "--input-format", "stream-json");
+		else args.push("--print", params.prompt);
 		return args;
 	}
+	buildStdinPayload(params) {
+		const images = params.media?.filter((m) => m.mimeType.startsWith("image/") && m.base64);
+		if (!images?.length) return;
+		const content = images.map((img) => ({
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: img.mimeType,
+				data: img.base64
+			}
+		}));
+		content.push({
+			type: "text",
+			text: params.prompt
+		});
+		const envelope = {
+			type: "user",
+			message: {
+				role: "user",
+				content
+			}
+		};
+		return JSON.stringify(envelope) + "\n";
+	}
 	extractEvent(line) {
 		const parsed = JSON.parse(line);
 		if (!isObject$3(parsed)) return null;
@@ -11236,6 +11237,37 @@ var ClaudeCliRuntime = class extends CLIRuntimeBase {
 		if (this.resultData?.durationApiMs !== void 0) result.apiDurationMs = this.resultData.durationApiMs;
 		if (this.resultData?.numTurns !== void 0) result.numTurns = this.resultData.numTurns;
 	}
+	/**
+	* Read image files referenced by media attachments and populate their base64 field.
+	* Non-image media types are filtered out (audio/video are not supported natively).
+	*/
+	async prepareMedia(params) {
+		if (!params.media?.length) return params;
+		const prepared = [];
+		for (const attachment of params.media) {
+			if (!attachment.mimeType.startsWith("image/")) continue;
+			if (attachment.base64) {
+				prepared.push(attachment);
+				continue;
+			}
+			if (attachment.filePath) {
+				try {
+					const buffer = await readFile(attachment.filePath);
+					prepared.push({
+						...attachment,
+						base64: buffer.toString("base64")
+					});
+				} catch {
+					logDebug(`[claude-runtime] failed to read media file: ${attachment.filePath}`);
+				}
+				continue;
+			}
+		}
+		return {
+			...params,
+			media: prepared.length > 0 ? prepared : void 0
+		};
+	}
 	resetState() {
 		this.currentSessionId = void 0;
 		this.accumulatedText = "";
@@ -11273,7 +11305,7 @@ var CodexCliRuntime = class extends CLIRuntimeBase {
 	constructor() {
 		super("codex");
 		this.mediaCapabilities = {
-			acceptsInbound: [],
+			acceptsInbound: ["image/"],
 			emitsOutbound: false
 		};
 		this.accumulatedText = "";
@@ -11304,13 +11336,17 @@ var CodexCliRuntime = class extends CLIRuntimeBase {
 			params.sessionId,
 			params.prompt
 		];
-		return [
+		const args = [
 			"exec",
 			"--json",
 			"--color",
-			"never",
-			params.prompt
+			"never"
 		];
+		if (params.media) {
+			for (const attachment of params.media) if (attachment.mimeType.startsWith("image/") && attachment.filePath) args.push("--image", attachment.filePath);
+		}
+		args.push(params.prompt);
+		return args;
 	}
 	extractEvent(line) {
 		const parsed = JSON.parse(line);

package/dist/fetch-B3EQXbTa.js

@@ -0,0 +1,67 @@
+import { t as bindAbortRelay } from "./fetch-timeout-DkT3EnRA.js";
+
+//#region src/infra/fetch.ts
+const wrapFetchWithAbortSignalMarker = Symbol.for("remoteclaw.fetch.abort-signal-wrapped");
+function withDuplex(init, input) {
+	const hasInitBody = init?.body != null;
+	const hasRequestBody = !hasInitBody && typeof Request !== "undefined" && input instanceof Request && input.body != null;
+	if (!hasInitBody && !hasRequestBody) return init;
+	if (init && "duplex" in init) return init;
+	return init ? {
+		...init,
+		duplex: "half"
+	} : { duplex: "half" };
+}
+function wrapFetchWithAbortSignal(fetchImpl) {
+	if (fetchImpl[wrapFetchWithAbortSignalMarker]) return fetchImpl;
+	const wrapped = ((input, init) => {
+		const patchedInit = withDuplex(init, input);
+		const signal = patchedInit?.signal;
+		if (!signal) return fetchImpl(input, patchedInit);
+		if (typeof AbortSignal !== "undefined" && signal instanceof AbortSignal) return fetchImpl(input, patchedInit);
+		if (typeof AbortController === "undefined") return fetchImpl(input, patchedInit);
+		if (typeof signal.addEventListener !== "function") return fetchImpl(input, patchedInit);
+		const controller = new AbortController();
+		const onAbort = bindAbortRelay(controller);
+		let listenerAttached = false;
+		if (signal.aborted) controller.abort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			listenerAttached = true;
+		}
+		const cleanup = () => {
+			if (!listenerAttached || typeof signal.removeEventListener !== "function") return;
+			listenerAttached = false;
+			try {
+				signal.removeEventListener("abort", onAbort);
+			} catch {}
+		};
+		try {
+			return fetchImpl(input, {
+				...patchedInit,
+				signal: controller.signal
+			}).finally(cleanup);
+		} catch (error) {
+			cleanup();
+			throw error;
+		}
+	});
+	const wrappedFetch = Object.assign(wrapped, fetchImpl);
+	const fetchWithPreconnect = fetchImpl;
+	wrappedFetch.preconnect = typeof fetchWithPreconnect.preconnect === "function" ? fetchWithPreconnect.preconnect.bind(fetchWithPreconnect) : () => {};
+	Object.defineProperty(wrappedFetch, wrapFetchWithAbortSignalMarker, {
+		value: true,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return wrappedFetch;
+}
+function resolveFetch(fetchImpl) {
+	const resolved = fetchImpl ?? globalThis.fetch;
+	if (!resolved) return;
+	return wrapFetchWithAbortSignal(resolved);
+}
+
+//#endregion
+export { wrapFetchWithAbortSignal as n, resolveFetch as t };

package/dist/fetch-BPeSHPvr.js

@@ -0,0 +1,281 @@
+import { t as bindAbortRelay } from "./fetch-timeout-CPe2rPLq.js";
+import { n as extensionForMime, t as detectMime } from "./mime-mSgQeDnC.js";
+import { i as logWarn } from "./logger-9I2fg5mr.js";
+import { i as resolvePinnedHostnameWithPolicy, n as closeDispatcher, r as createPinnedDispatcher, t as SsrFBlockedError } from "./ssrf-DZi4qw5c.js";
+import path from "node:path";
+
+//#region src/infra/net/fetch-guard.ts
+const DEFAULT_MAX_REDIRECTS = 3;
+const CROSS_ORIGIN_REDIRECT_SENSITIVE_HEADERS = [
+	"authorization",
+	"proxy-authorization",
+	"cookie",
+	"cookie2"
+];
+function isRedirectStatus(status) {
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function stripSensitiveHeadersForCrossOriginRedirect(init) {
+	if (!init?.headers) return init;
+	const headers = new Headers(init.headers);
+	for (const header of CROSS_ORIGIN_REDIRECT_SENSITIVE_HEADERS) headers.delete(header);
+	return {
+		...init,
+		headers
+	};
+}
+function buildAbortSignal(params) {
+	const { timeoutMs, signal } = params;
+	if (!timeoutMs && !signal) return {
+		signal: void 0,
+		cleanup: () => {}
+	};
+	if (!timeoutMs) return {
+		signal,
+		cleanup: () => {}
+	};
+	const controller = new AbortController();
+	const timeoutId = setTimeout(controller.abort.bind(controller), timeoutMs);
+	const onAbort = bindAbortRelay(controller);
+	if (signal) if (signal.aborted) controller.abort();
+	else signal.addEventListener("abort", onAbort, { once: true });
+	const cleanup = () => {
+		clearTimeout(timeoutId);
+		if (signal) signal.removeEventListener("abort", onAbort);
+	};
+	return {
+		signal: controller.signal,
+		cleanup
+	};
+}
+async function fetchWithSsrFGuard(params) {
+	const fetcher = params.fetchImpl ?? globalThis.fetch;
+	if (!fetcher) throw new Error("fetch is not available");
+	const maxRedirects = typeof params.maxRedirects === "number" && Number.isFinite(params.maxRedirects) ? Math.max(0, Math.floor(params.maxRedirects)) : DEFAULT_MAX_REDIRECTS;
+	const { signal, cleanup } = buildAbortSignal({
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	let released = false;
+	const release = async (dispatcher) => {
+		if (released) return;
+		released = true;
+		cleanup();
+		await closeDispatcher(dispatcher ?? void 0);
+	};
+	const visited = /* @__PURE__ */ new Set();
+	let currentUrl = params.url;
+	let currentInit = params.init ? { ...params.init } : void 0;
+	let redirectCount = 0;
+	while (true) {
+		let parsedUrl;
+		try {
+			parsedUrl = new URL(currentUrl);
+		} catch {
+			await release();
+			throw new Error("Invalid URL: must be http or https");
+		}
+		if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+			await release();
+			throw new Error("Invalid URL: must be http or https");
+		}
+		let dispatcher = null;
+		try {
+			const pinned = await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
+				lookupFn: params.lookupFn,
+				policy: params.policy
+			});
+			if (params.pinDns !== false) dispatcher = createPinnedDispatcher(pinned);
+			const init = {
+				...currentInit ? { ...currentInit } : {},
+				redirect: "manual",
+				...dispatcher ? { dispatcher } : {},
+				...signal ? { signal } : {}
+			};
+			const response = await fetcher(parsedUrl.toString(), init);
+			if (isRedirectStatus(response.status)) {
+				const location = response.headers.get("location");
+				if (!location) {
+					await release(dispatcher);
+					throw new Error(`Redirect missing location header (${response.status})`);
+				}
+				redirectCount += 1;
+				if (redirectCount > maxRedirects) {
+					await release(dispatcher);
+					throw new Error(`Too many redirects (limit: ${maxRedirects})`);
+				}
+				const nextParsedUrl = new URL(location, parsedUrl);
+				const nextUrl = nextParsedUrl.toString();
+				if (visited.has(nextUrl)) {
+					await release(dispatcher);
+					throw new Error("Redirect loop detected");
+				}
+				if (nextParsedUrl.origin !== parsedUrl.origin) currentInit = stripSensitiveHeadersForCrossOriginRedirect(currentInit);
+				visited.add(nextUrl);
+				response.body?.cancel();
+				await closeDispatcher(dispatcher);
+				currentUrl = nextUrl;
+				continue;
+			}
+			return {
+				response,
+				finalUrl: currentUrl,
+				release: async () => release(dispatcher)
+			};
+		} catch (err) {
+			if (err instanceof SsrFBlockedError) logWarn(`security: blocked URL fetch (${params.auditContext ?? "url-fetch"}) target=${parsedUrl.origin}${parsedUrl.pathname} reason=${err.message}`);
+			await release(dispatcher);
+			throw err;
+		}
+	}
+}
+
+//#endregion
+//#region src/media/read-response-with-limit.ts
+async function readResponseWithLimit(res, maxBytes, opts) {
+	const onOverflow = opts?.onOverflow ?? ((params) => /* @__PURE__ */ new Error(`Content too large: ${params.size} bytes (limit: ${params.maxBytes} bytes)`));
+	const body = res.body;
+	if (!body || typeof body.getReader !== "function") {
+		const fallback = Buffer.from(await res.arrayBuffer());
+		if (fallback.length > maxBytes) throw onOverflow({
+			size: fallback.length,
+			maxBytes,
+			res
+		});
+		return fallback;
+	}
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value?.length) {
+				total += value.length;
+				if (total > maxBytes) {
+					try {
+						await reader.cancel();
+					} catch {}
+					throw onOverflow({
+						size: total,
+						maxBytes,
+						res
+					});
+				}
+				chunks.push(value);
+			}
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+}
+
+//#endregion
+//#region src/media/fetch.ts
+var MediaFetchError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "MediaFetchError";
+	}
+};
+function stripQuotes(value) {
+	return value.replace(/^["']|["']$/g, "");
+}
+function parseContentDispositionFileName(header) {
+	if (!header) return;
+	const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
+	if (starMatch?.[1]) {
+		const cleaned = stripQuotes(starMatch[1].trim());
+		const encoded = cleaned.split("''").slice(1).join("''") || cleaned;
+		try {
+			return path.basename(decodeURIComponent(encoded));
+		} catch {
+			return path.basename(encoded);
+		}
+	}
+	const match = /filename\s*=\s*([^;]+)/i.exec(header);
+	if (match?.[1]) return path.basename(stripQuotes(match[1].trim()));
+}
+async function readErrorBodySnippet(res, maxChars = 200) {
+	try {
+		const text = await res.text();
+		if (!text) return;
+		const collapsed = text.replace(/\s+/g, " ").trim();
+		if (!collapsed) return;
+		if (collapsed.length <= maxChars) return collapsed;
+		return `${collapsed.slice(0, maxChars)}…`;
+	} catch {
+		return;
+	}
+}
+async function fetchRemoteMedia(options) {
+	const { url, fetchImpl, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
+	let res;
+	let finalUrl = url;
+	let release = null;
+	try {
+		const result = await fetchWithSsrFGuard({
+			url,
+			fetchImpl,
+			maxRedirects,
+			policy: ssrfPolicy,
+			lookupFn
+		});
+		res = result.response;
+		finalUrl = result.finalUrl;
+		release = result.release;
+	} catch (err) {
+		throw new MediaFetchError("fetch_failed", `Failed to fetch media from ${url}: ${String(err)}`);
+	}
+	try {
+		if (!res.ok) {
+			const statusText = res.statusText ? ` ${res.statusText}` : "";
+			const redirected = finalUrl !== url ? ` (redirected to ${finalUrl})` : "";
+			let detail = `HTTP ${res.status}${statusText}`;
+			if (!res.body) detail = `HTTP ${res.status}${statusText}; empty response body`;
+			else {
+				const snippet = await readErrorBodySnippet(res);
+				if (snippet) detail += `; body: ${snippet}`;
+			}
+			throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
+		}
+		const contentLength = res.headers.get("content-length");
+		if (maxBytes && contentLength) {
+			const length = Number(contentLength);
+			if (Number.isFinite(length) && length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
+		}
+		const buffer = maxBytes ? await readResponseWithLimit(res, maxBytes, { onOverflow: ({ maxBytes, res }) => new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || url}: payload exceeds maxBytes ${maxBytes}`) }) : Buffer.from(await res.arrayBuffer());
+		let fileNameFromUrl;
+		try {
+			const parsed = new URL(finalUrl);
+			fileNameFromUrl = path.basename(parsed.pathname) || void 0;
+		} catch {}
+		const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+		let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : void 0);
+		const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : filePathHint ?? finalUrl;
+		const contentType = await detectMime({
+			buffer,
+			headerMime: res.headers.get("content-type"),
+			filePath: filePathForMime
+		});
+		if (fileName && !path.extname(fileName) && contentType) {
+			const ext = extensionForMime(contentType);
+			if (ext) fileName = `${fileName}${ext}`;
+		}
+		return {
+			buffer,
+			contentType: contentType ?? void 0,
+			fileName
+		};
+	} finally {
+		if (release) await release();
+	}
+}
+
+//#endregion
+export { fetchWithSsrFGuard as i, fetchRemoteMedia as n, readResponseWithLimit as r, MediaFetchError as t };