@openclaw/diffs 2026.5.27-beta.1 → 2026.5.28-beta.1

package/dist/index.js

@@ -4,17 +4,18 @@ import { createRequire } from "node:module";
 import { buildPluginConfigSchema } from "openclaw/plugin-sdk/plugin-entry";
 import { mapPluginConfigIssues } from "openclaw/plugin-sdk/extension-shared";
 import { z } from "zod";
+import fs, { constants } from "node:fs";
 import path from "node:path";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
-import fs from "node:fs/promises";
+import fs$1 from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { root, writeExternalFileWithinRoot } from "openclaw/plugin-sdk/security-runtime";
-import { stringEnum } from "openclaw/plugin-sdk/channel-actions";
+import { optionalFiniteNumberSchema, stringEnum } from "openclaw/plugin-sdk/channel-actions";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { readFiniteNumberParam } from "openclaw/plugin-sdk/param-readers";
 import { Type } from "typebox";
-import { constants } from "node:fs";
 import { chromium } from "playwright-core";
 import { RegisteredCustomThemes, ResolvedThemes, ResolvingThemes, parsePatchFiles, resolveLanguage } from "@pierre/diffs";
 import { preloadFileDiff, preloadMultiFileDiff } from "@pierre/diffs/ssr";
@@ -304,15 +305,20 @@ function resolveDiffImageRenderOptions(params) {
 const VIEWER_ASSET_PREFIX = "/plugins/diffs/assets/";
 const VIEWER_LOADER_PATH = `${VIEWER_ASSET_PREFIX}viewer.js`;
 const VIEWER_RUNTIME_PATH = `${VIEWER_ASSET_PREFIX}viewer-runtime.js`;
+const LANGUAGE_PACK_VIEWER_ASSET_PREFIX = "/plugins/diffs-language-pack/assets/";
+const LANGUAGE_PACK_VIEWER_LOADER_PATH = `${LANGUAGE_PACK_VIEWER_ASSET_PREFIX}viewer.js`;
+const LANGUAGE_PACK_VIEWER_RUNTIME_PATH = `${LANGUAGE_PACK_VIEWER_ASSET_PREFIX}viewer-runtime.js`;
 const VIEWER_RUNTIME_RELATIVE_IMPORT_PATH = "./viewer-runtime.js";
 const VIEWER_RUNTIME_CANDIDATE_RELATIVE_PATHS = ["./assets/viewer-runtime.js", "../assets/viewer-runtime.js"];
+const LANGUAGE_PACK_RUNTIME_CANDIDATE_RELATIVE_PATHS = ["../../diffs-language-pack/assets/viewer-runtime.js", "../diffs-language-pack/assets/viewer-runtime.js"];
 let runtimeAssetCache = null;
+let languagePackRuntimeAssetCache = null;
 function isMissingFileError(error) {
 	return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 async function resolveViewerRuntimeFileUrl(params = {}) {
 	const baseUrl = params.baseUrl ?? import.meta.url;
-	const stat = params.stat ?? ((path) => fs.stat(path));
+	const stat = params.stat ?? ((path) => fs$1.stat(path));
 	let missingFileError = null;
 	for (const relativePath of VIEWER_RUNTIME_CANDIDATE_RELATIVE_PATHS) {
 		const candidateUrl = new URL(relativePath, baseUrl);
@@ -343,18 +349,70 @@ async function getServedViewerAsset(pathname) {
 	};
 	return null;
 }
+async function getServedLanguagePackViewerAsset(pathname) {
+	if (pathname !== LANGUAGE_PACK_VIEWER_LOADER_PATH && pathname !== LANGUAGE_PACK_VIEWER_RUNTIME_PATH) return null;
+	let assets;
+	try {
+		assets = await loadRuntimeAssets({
+			runtimeUrl: await resolveRuntimeFileUrl(LANGUAGE_PACK_RUNTIME_CANDIDATE_RELATIVE_PATHS),
+			cache: languagePackRuntimeAssetCache,
+			updateCache: (cache) => {
+				languagePackRuntimeAssetCache = cache;
+			}
+		});
+	} catch (error) {
+		if (isMissingFileError(error)) return null;
+		throw error;
+	}
+	if (pathname === LANGUAGE_PACK_VIEWER_LOADER_PATH) return {
+		body: assets.loaderBody,
+		contentType: "text/javascript; charset=utf-8"
+	};
+	return {
+		body: assets.runtimeBody,
+		contentType: "text/javascript; charset=utf-8"
+	};
+}
 async function loadViewerAssets() {
-	const runtimePath = fileURLToPath(await resolveViewerRuntimeFileUrl());
-	const runtimeStat = await fs.stat(runtimePath);
-	if (runtimeAssetCache && runtimeAssetCache.mtimeMs === runtimeStat.mtimeMs) return runtimeAssetCache;
-	const runtimeBody = await fs.readFile(runtimePath);
+	return loadRuntimeAssets({
+		runtimeUrl: await resolveViewerRuntimeFileUrl(),
+		cache: runtimeAssetCache,
+		updateCache: (cache) => {
+			runtimeAssetCache = cache;
+		}
+	});
+}
+async function loadRuntimeAssets(params) {
+	const runtimePath = fileURLToPath(params.runtimeUrl);
+	const runtimeStat = await fs$1.stat(runtimePath);
+	if (params.cache && params.cache.mtimeMs === runtimeStat.mtimeMs) return params.cache;
+	const runtimeBody = await fs$1.readFile(runtimePath);
 	const hash = crypto.createHash("sha1").update(runtimeBody).digest("hex").slice(0, 12);
-	runtimeAssetCache = {
+	const cache = {
 		mtimeMs: runtimeStat.mtimeMs,
 		runtimeBody,
 		loaderBody: `import "${VIEWER_RUNTIME_RELATIVE_IMPORT_PATH}?v=${hash}";\n`
 	};
-	return runtimeAssetCache;
+	params.updateCache(cache);
+	return cache;
+}
+async function resolveRuntimeFileUrl(relativePaths) {
+	let missingFileError = null;
+	for (const relativePath of relativePaths) {
+		const candidateUrl = new URL(relativePath, import.meta.url);
+		try {
+			await fs$1.stat(fileURLToPath(candidateUrl));
+			return candidateUrl;
+		} catch (error) {
+			if (isMissingFileError(error)) {
+				missingFileError = error;
+				continue;
+			}
+			throw error;
+		}
+	}
+	if (missingFileError) throw missingFileError;
+	throw new Error("viewer runtime asset candidates were not checked");
 }
 //#endregion
 //#region extensions/diffs/src/http.ts
@@ -700,7 +758,7 @@ var DiffArtifactStore = class {
 		}));
 	}
 	async ensureRoot() {
-		await fs.mkdir(this.rootDir, { recursive: true });
+		await fs$1.mkdir(this.rootDir, { recursive: true });
 	}
 	async artifactRoot() {
 		await this.ensureRoot();
@@ -765,7 +823,7 @@ var DiffArtifactStore = class {
 		}
 	}
 	async deleteArtifact(id) {
-		await fs.rm(this.artifactDir(id), {
+		await fs$1.rm(this.artifactDir(id), {
 			recursive: true,
 			force: true
 		}).catch(() => {});
@@ -865,12 +923,14 @@ var PlaywrightDiffScreenshotter = class {
 						await route.abort();
 						return;
 					}
-					if (!parsed.pathname.startsWith("/plugins/diffs/assets/")) {
+					const isBaseViewerAsset = parsed.pathname.startsWith(VIEWER_ASSET_PREFIX);
+					const isLanguagePackViewerAsset = parsed.pathname.startsWith(LANGUAGE_PACK_VIEWER_ASSET_PREFIX);
+					if (!isBaseViewerAsset && !isLanguagePackViewerAsset) {
 						await route.abort();
 						return;
 					}
 					const pathname = parsed.pathname;
-					const asset = await getServedViewerAsset(pathname);
+					const asset = isLanguagePackViewerAsset ? await getServedLanguagePackViewerAsset(pathname) : await getServedViewerAsset(pathname);
 					if (!asset) {
 						await route.abort();
 						return;
@@ -1005,7 +1065,7 @@ var PlaywrightDiffScreenshotter = class {
 };
 async function writeExternalArtifactFile(params) {
 	const rootDir = path.dirname(params.outputPath);
-	await fs.mkdir(rootDir, { recursive: true });
+	await fs$1.mkdir(rootDir, { recursive: true });
 	await writeExternalFileWithinRoot({
 		rootDir,
 		path: path.basename(params.outputPath),
@@ -1192,24 +1252,251 @@ async function assertExecutable(candidate, label) {
 }
 async function isExecutable(candidate) {
 	try {
-		await fs.access(candidate, constants.X_OK);
+		await fs$1.access(candidate, constants.X_OK);
 		return true;
 	} catch {
 		return false;
 	}
 }
 //#endregion
+//#region extensions/diffs/src/shiki-curated-languages.ts
+const javascript = () => import("@shikijs/langs/javascript");
+const typescript = () => import("@shikijs/langs/typescript");
+const tsx = () => import("@shikijs/langs/tsx");
+const jsx = () => import("@shikijs/langs/jsx");
+const json = () => import("@shikijs/langs/json");
+const markdown = () => import("@shikijs/langs/markdown");
+const yaml = () => import("@shikijs/langs/yaml");
+const css = () => import("@shikijs/langs/css");
+const html = () => import("@shikijs/langs/html");
+const sh = () => import("@shikijs/langs/sh");
+const python = () => import("@shikijs/langs/python");
+const go = () => import("@shikijs/langs/go");
+const rust = () => import("@shikijs/langs/rust");
+const java = () => import("@shikijs/langs/java");
+const c = () => import("@shikijs/langs/c");
+const cpp = () => import("@shikijs/langs/cpp");
+const csharp = () => import("@shikijs/langs/csharp");
+const php = () => import("@shikijs/langs/php");
+const sql = () => import("@shikijs/langs/sql");
+const docker = () => import("@shikijs/langs/docker");
+const ruby = () => import("@shikijs/langs/ruby");
+const swift = () => import("@shikijs/langs/swift");
+const kotlin = () => import("@shikijs/langs/kotlin");
+const r = () => import("@shikijs/langs/r");
+const dart = () => import("@shikijs/langs/dart");
+const lua = () => import("@shikijs/langs/lua");
+const powershell = () => import("@shikijs/langs/powershell");
+const xml = () => import("@shikijs/langs/xml");
+const toml = () => import("@shikijs/langs/toml");
+const bundledLanguagesInfo = [
+	{
+		id: "javascript",
+		name: "JavaScript",
+		aliases: [
+			"js",
+			"mjs",
+			"cjs"
+		],
+		import: javascript
+	},
+	{
+		id: "typescript",
+		name: "TypeScript",
+		aliases: [
+			"ts",
+			"mts",
+			"cts"
+		],
+		import: typescript
+	},
+	{
+		id: "tsx",
+		name: "TSX",
+		import: tsx
+	},
+	{
+		id: "jsx",
+		name: "JSX",
+		import: jsx
+	},
+	{
+		id: "json",
+		name: "JSON",
+		aliases: [
+			"jsonc",
+			"json5",
+			"jsonl"
+		],
+		import: json
+	},
+	{
+		id: "markdown",
+		name: "Markdown",
+		aliases: ["md"],
+		import: markdown
+	},
+	{
+		id: "yaml",
+		name: "YAML",
+		aliases: ["yml"],
+		import: yaml
+	},
+	{
+		id: "css",
+		name: "CSS",
+		import: css
+	},
+	{
+		id: "html",
+		name: "HTML",
+		import: html
+	},
+	{
+		id: "sh",
+		name: "Shell",
+		aliases: [
+			"bash",
+			"shell",
+			"shellscript",
+			"zsh"
+		],
+		import: sh
+	},
+	{
+		id: "python",
+		name: "Python",
+		aliases: ["py"],
+		import: python
+	},
+	{
+		id: "go",
+		name: "Go",
+		import: go
+	},
+	{
+		id: "rust",
+		name: "Rust",
+		aliases: ["rs"],
+		import: rust
+	},
+	{
+		id: "java",
+		name: "Java",
+		import: java
+	},
+	{
+		id: "c",
+		name: "C",
+		import: c
+	},
+	{
+		id: "cpp",
+		name: "C++",
+		aliases: ["c++"],
+		import: cpp
+	},
+	{
+		id: "csharp",
+		name: "C#",
+		aliases: ["c#", "cs"],
+		import: csharp
+	},
+	{
+		id: "php",
+		name: "PHP",
+		import: php
+	},
+	{
+		id: "sql",
+		name: "SQL",
+		import: sql
+	},
+	{
+		id: "docker",
+		name: "Docker",
+		aliases: ["dockerfile"],
+		import: docker
+	},
+	{
+		id: "ruby",
+		name: "Ruby",
+		aliases: ["rb"],
+		import: ruby
+	},
+	{
+		id: "swift",
+		name: "Swift",
+		import: swift
+	},
+	{
+		id: "kotlin",
+		name: "Kotlin",
+		aliases: ["kt", "kts"],
+		import: kotlin
+	},
+	{
+		id: "r",
+		name: "R",
+		import: r
+	},
+	{
+		id: "dart",
+		name: "Dart",
+		import: dart
+	},
+	{
+		id: "lua",
+		name: "Lua",
+		import: lua
+	},
+	{
+		id: "powershell",
+		name: "PowerShell",
+		aliases: ["ps", "ps1"],
+		import: powershell
+	},
+	{
+		id: "xml",
+		name: "XML",
+		import: xml
+	},
+	{
+		id: "toml",
+		name: "TOML",
+		import: toml
+	}
+];
+const bundledLanguagesBase = Object.fromEntries(bundledLanguagesInfo.map((language) => [language.id, language.import]));
+function getBundledLanguageAliases(language) {
+	return "aliases" in language ? language.aliases : [];
+}
+const bundledLanguagesAlias = Object.fromEntries(bundledLanguagesInfo.flatMap((language) => getBundledLanguageAliases(language).map((alias) => [alias, language.import])));
+({
+	...bundledLanguagesBase,
+	...bundledLanguagesAlias
+});
+//#endregion
 //#region extensions/diffs/src/language-hints.ts
-const PASSTHROUGH_LANGUAGE_HINTS = new Set(["ansi", "text"]);
+const BASE_DIFF_VIEWER_LANGUAGE_HINTS = [
+	...Object.keys(bundledLanguagesBase),
+	"text",
+	"ansi"
+];
+const BASE_LANGUAGE_HINTS = new Set(BASE_DIFF_VIEWER_LANGUAGE_HINTS);
+const BASE_LANGUAGE_ALIASES = new Map(bundledLanguagesInfo.flatMap((language) => getBundledLanguageAliases(language).map((alias) => [alias, language.id])));
 function normalizeOptionalString$1(value) {
 	if (typeof value !== "string") return;
 	const trimmed = value.trim();
 	return trimmed ? trimmed : void 0;
 }
-async function normalizeSupportedLanguageHint(value) {
+async function normalizeSupportedLanguageHint(value, options = {}) {
 	const normalized = normalizeOptionalString$1(value);
 	if (!normalized) return;
-	if (PASSTHROUGH_LANGUAGE_HINTS.has(normalized)) return normalized;
+	const baseAlias = BASE_LANGUAGE_ALIASES.get(normalized);
+	if (baseAlias) return baseAlias;
+	if (BASE_LANGUAGE_HINTS.has(normalized)) return normalized;
+	if (!options.languagePackAvailable) return;
 	try {
 		await resolveLanguage(normalized);
 		return normalized;
@@ -1220,7 +1507,7 @@ async function normalizeSupportedLanguageHint(value) {
 async function normalizeSupportedLanguageHints(values, options) {
 	const supported = /* @__PURE__ */ new Set();
 	for (const value of values) {
-		const normalized = await normalizeSupportedLanguageHint(value);
+		const normalized = await normalizeSupportedLanguageHint(value, options);
 		if (!normalized) continue;
 		supported.add(normalized);
 	}
@@ -1234,10 +1521,10 @@ function collectDiffPayloadLanguageHints(payload) {
 	if (payload.newFile?.lang) langs.add(payload.newFile.lang);
 	return [...langs];
 }
-async function normalizeDiffPayloadFileLanguage(file) {
+async function normalizeDiffPayloadFileLanguage(file, options) {
 	if (!file) return;
 	if (typeof file.lang !== "string") return file;
-	const normalized = await normalizeSupportedLanguageHint(file.lang);
+	const normalized = await normalizeSupportedLanguageHint(file.lang, options);
 	if (file.lang === normalized) return file;
 	if (!normalized) return {
 		...file,
@@ -1248,12 +1535,15 @@ async function normalizeDiffPayloadFileLanguage(file) {
 		lang: normalized
 	};
 }
-async function normalizeDiffViewerPayloadLanguages(payload) {
+async function normalizeDiffViewerPayloadLanguages(payload, options = {}) {
 	const [fileDiff, oldFile, newFile, payloadLangs] = await Promise.all([
-		normalizeDiffPayloadFileLanguage(payload.fileDiff),
-		normalizeDiffPayloadFileLanguage(payload.oldFile),
-		normalizeDiffPayloadFileLanguage(payload.newFile),
-		normalizeSupportedLanguageHints(payload.langs, { fallbackToText: false })
+		normalizeDiffPayloadFileLanguage(payload.fileDiff, options),
+		normalizeDiffPayloadFileLanguage(payload.oldFile, options),
+		normalizeDiffPayloadFileLanguage(payload.newFile, options),
+		normalizeSupportedLanguageHints(payload.langs, {
+			fallbackToText: false,
+			...options
+		})
 	]);
 	const langs = new Set(payloadLangs);
 	for (const lang of collectDiffPayloadLanguageHints({
@@ -1270,6 +1560,9 @@ async function normalizeDiffViewerPayloadLanguages(payload) {
 		langs: [...langs]
 	};
 }
+function isBaseDiffViewerLanguage(lang) {
+	return BASE_LANGUAGE_HINTS.has(lang);
+}
 //#endregion
 //#region extensions/diffs/src/pierre-themes.ts
 const themeRequire = createRequire(import.meta.url);
@@ -1305,6 +1598,7 @@ const DEFAULT_FILE_NAME = "diff.txt";
 const MAX_PATCH_FILE_COUNT = 128;
 const MAX_PATCH_TOTAL_LINES = 12e4;
 const VIEWER_LOADER_DOCUMENT_PATH = "../../assets/viewer.js";
+const LANGUAGE_PACK_VIEWER_LOADER_DOCUMENT_PATH = "../../../diffs-language-pack/assets/viewer.js";
 function escapeCssString(value) {
 	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
 }
@@ -1443,6 +1737,7 @@ function renderDiffCard(payload) {
   </section>`;
 }
 function buildHtmlDocument(params) {
+	const viewerLoaderPath = params.viewerRuntime === "language-pack" ? LANGUAGE_PACK_VIEWER_LOADER_DOCUMENT_PATH : VIEWER_LOADER_DOCUMENT_PATH;
 	return `<!doctype html>
 <html lang="en">
   <head>
@@ -1536,14 +1831,18 @@ function buildHtmlDocument(params) {
         ${params.bodyHtml}
       </div>
     </main>
-    <script type="module" src="${VIEWER_LOADER_DOCUMENT_PATH}"><\/script>
+    <script type="module" src="${viewerLoaderPath}"><\/script>
   </body>
 </html>`;
 }
+function payloadUsesLanguagePack(payload) {
+	return payload?.langs.some((lang) => !isBaseDiffViewerLanguage(lang)) ?? false;
+}
 function buildRenderedSection(params) {
 	return {
 		...params.viewerPayload ? { viewer: renderDiffCard(params.viewerPayload) } : {},
-		...params.imagePayload ? { image: renderDiffCard(params.imagePayload) } : {}
+		...params.imagePayload ? { image: renderDiffCard(params.imagePayload) } : {},
+		usesLanguagePack: payloadUsesLanguagePack(params.viewerPayload) || payloadUsesLanguagePack(params.imagePayload)
 	};
 }
 function buildRenderedBodies(sections) {
@@ -1556,7 +1855,8 @@ function buildRenderedBodies(sections) {
 }
 async function renderBeforeAfterDiff(input, options, target) {
 	ensurePierreThemesRegistered();
-	const lang = await normalizeSupportedLanguageHint(input.lang);
+	const languagePackAvailable = options.languagePackAvailable === true;
+	const lang = await normalizeSupportedLanguageHint(input.lang, { languagePackAvailable });
 	const fileName = resolveBeforeAfterFileName({
 		input,
 		lang
@@ -1593,7 +1893,7 @@ async function renderBeforeAfterDiff(input, options, target) {
 			oldFile: viewerResult.oldFile,
 			newFile: viewerResult.newFile
 		})
-	}) : Promise.resolve(void 0), imageResult && imageOptions ? normalizeDiffViewerPayloadLanguages({
+	}, { languagePackAvailable }) : Promise.resolve(void 0), imageResult && imageOptions ? normalizeDiffViewerPayloadLanguages({
 		prerenderedHTML: imageResult.prerenderedHTML,
 		oldFile: imageResult.oldFile,
 		newFile: imageResult.newFile,
@@ -1602,18 +1902,21 @@ async function renderBeforeAfterDiff(input, options, target) {
 			oldFile: imageResult.oldFile,
 			newFile: imageResult.newFile
 		})
-	}) : Promise.resolve(void 0)]);
+	}, { languagePackAvailable }) : Promise.resolve(void 0)]);
+	const section = buildRenderedSection({
+		...viewerPayload ? { viewerPayload } : {},
+		...imagePayload ? { imagePayload } : {}
+	});
 	return {
-		...buildRenderedBodies([buildRenderedSection({
-			...viewerPayload ? { viewerPayload } : {},
-			...imagePayload ? { imagePayload } : {}
-		})]),
-		fileCount: 1
+		...buildRenderedBodies([section]),
+		fileCount: 1,
+		usesLanguagePack: section.usesLanguagePack === true
 	};
 }
 async function renderPatchDiff(input, options, target) {
 	ensurePierreThemesRegistered();
-	const files = parsePatchFiles(input.patch).flatMap((entry) => entry.files ?? []);
+	const languagePackAvailable = options.languagePackAvailable === true;
+	const files = await Promise.all(parsePatchFiles(input.patch).flatMap((entry) => entry.files ?? []).map((fileDiff) => normalizePatchFileLanguage(fileDiff, { languagePackAvailable })));
 	if (files.length === 0) throw new Error("Patch input did not contain any file diffs.");
 	if (files.length > MAX_PATCH_FILE_COUNT) throw new Error(`Patch input contains too many files (max ${MAX_PATCH_FILE_COUNT}).`);
 	if (files.reduce((sum, fileDiff) => {
@@ -1625,55 +1928,69 @@ async function renderPatchDiff(input, options, target) {
 		options,
 		target
 	});
+	const sections = await Promise.all(files.map(async (fileDiff) => {
+		const [viewerResult, imageResult] = await Promise.all([viewerOptions ? preloadFileDiffWithFallback({
+			fileDiff,
+			options: viewerOptions
+		}) : Promise.resolve(void 0), imageOptions ? preloadFileDiffWithFallback({
+			fileDiff,
+			options: imageOptions
+		}) : Promise.resolve(void 0)]);
+		const [viewerPayload, imagePayload] = await Promise.all([viewerResult && viewerOptions ? normalizeDiffViewerPayloadLanguages({
+			prerenderedHTML: viewerResult.prerenderedHTML,
+			fileDiff: viewerResult.fileDiff,
+			options: viewerOptions,
+			langs: collectDiffPayloadLanguageHints({ fileDiff: viewerResult.fileDiff })
+		}, { languagePackAvailable }) : Promise.resolve(void 0), imageResult && imageOptions ? normalizeDiffViewerPayloadLanguages({
+			prerenderedHTML: imageResult.prerenderedHTML,
+			fileDiff: imageResult.fileDiff,
+			options: imageOptions,
+			langs: collectDiffPayloadLanguageHints({ fileDiff: imageResult.fileDiff })
+		}, { languagePackAvailable }) : Promise.resolve(void 0)]);
+		return buildRenderedSection({
+			...viewerPayload ? { viewerPayload } : {},
+			...imagePayload ? { imagePayload } : {}
+		});
+	}));
 	return {
-		...buildRenderedBodies(await Promise.all(files.map(async (fileDiff) => {
-			const [viewerResult, imageResult] = await Promise.all([viewerOptions ? preloadFileDiffWithFallback({
-				fileDiff,
-				options: viewerOptions
-			}) : Promise.resolve(void 0), imageOptions ? preloadFileDiffWithFallback({
-				fileDiff,
-				options: imageOptions
-			}) : Promise.resolve(void 0)]);
-			const [viewerPayload, imagePayload] = await Promise.all([viewerResult && viewerOptions ? normalizeDiffViewerPayloadLanguages({
-				prerenderedHTML: viewerResult.prerenderedHTML,
-				fileDiff: viewerResult.fileDiff,
-				options: viewerOptions,
-				langs: collectDiffPayloadLanguageHints({ fileDiff: viewerResult.fileDiff })
-			}) : Promise.resolve(void 0), imageResult && imageOptions ? normalizeDiffViewerPayloadLanguages({
-				prerenderedHTML: imageResult.prerenderedHTML,
-				fileDiff: imageResult.fileDiff,
-				options: imageOptions,
-				langs: collectDiffPayloadLanguageHints({ fileDiff: imageResult.fileDiff })
-			}) : Promise.resolve(void 0)]);
-			return buildRenderedSection({
-				...viewerPayload ? { viewerPayload } : {},
-				...imagePayload ? { imagePayload } : {}
-			});
-		}))),
-		fileCount: files.length
+		...buildRenderedBodies(sections),
+		fileCount: files.length,
+		usesLanguagePack: sections.some((section) => section.usesLanguagePack === true)
+	};
+}
+async function normalizePatchFileLanguage(fileDiff, options) {
+	const lang = await normalizeSupportedLanguageHint(fileDiff.lang, options);
+	if (lang === fileDiff.lang) return fileDiff;
+	return {
+		...fileDiff,
+		...lang ? { lang } : { lang: "text" }
 	};
 }
 async function renderDiffDocument(input, options, target = "both") {
 	const title = buildDiffTitle(input);
 	const rendered = input.kind === "before_after" ? await renderBeforeAfterDiff(input, options, target) : await renderPatchDiff(input, options, target);
+	const viewerRuntime = rendered.usesLanguagePack ? "language-pack" : "base";
 	return {
 		...rendered.viewerBodyHtml ? { html: buildHtmlDocument({
 			title,
 			bodyHtml: rendered.viewerBodyHtml,
 			theme: options.presentation.theme,
 			imageMaxWidth: options.image.maxWidth,
-			runtimeMode: "viewer"
+			runtimeMode: "viewer",
+			viewerRuntime
 		}) } : {},
 		...rendered.imageBodyHtml ? { imageHtml: buildHtmlDocument({
 			title,
 			bodyHtml: rendered.imageBodyHtml,
 			theme: options.presentation.theme,
 			imageMaxWidth: options.image.maxWidth,
-			runtimeMode: "image"
+			runtimeMode: "image",
+			viewerRuntime
 		}) } : {},
 		title,
 		fileCount: rendered.fileCount,
-		inputKind: input.kind
+		inputKind: input.kind,
+		viewerRuntime
 	};
 }
 function shouldFallbackToClientHydration(error) {
@@ -1733,16 +2050,16 @@ const DiffsToolSchema = Type.Object({
 	layout: Type.Optional(stringEnum(DIFF_LAYOUTS, { description: "Diff layout. Default: unified." })),
 	fileQuality: Type.Optional(stringEnum(DIFF_IMAGE_QUALITY_PRESETS, { description: "File quality preset: standard, hq, or print." })),
 	fileFormat: Type.Optional(stringEnum(DIFF_OUTPUT_FORMATS, { description: "Rendered file format: png or pdf." })),
-	fileScale: Type.Optional(Type.Number({
+	fileScale: optionalFiniteNumberSchema({
 		description: "Optional rendered-file device scale factor override (1-4).",
 		minimum: 1,
 		maximum: 4
-	})),
-	fileMaxWidth: Type.Optional(Type.Number({
+	}),
+	fileMaxWidth: optionalFiniteNumberSchema({
 		description: "Optional rendered-file max width in CSS pixels (640-2400).",
 		minimum: 640,
 		maximum: 2400
-	})),
+	}),
 	/** @deprecated Use fileQuality. */
 	imageQuality: Type.Optional(stringEnum(DIFF_IMAGE_QUALITY_PRESETS, {
 		description: "Deprecated alias for fileQuality.",
@@ -1754,25 +2071,25 @@ const DiffsToolSchema = Type.Object({
 		deprecated: true
 	})),
 	/** @deprecated Use fileScale. */
-	imageScale: Type.Optional(Type.Number({
+	imageScale: optionalFiniteNumberSchema({
 		description: "Deprecated alias for fileScale.",
 		deprecated: true,
 		minimum: 1,
 		maximum: 4
-	})),
+	}),
 	/** @deprecated Use fileMaxWidth. */
-	imageMaxWidth: Type.Optional(Type.Number({
+	imageMaxWidth: optionalFiniteNumberSchema({
 		description: "Deprecated alias for fileMaxWidth.",
 		deprecated: true,
 		minimum: 640,
 		maximum: 2400
-	})),
+	}),
 	expandUnchanged: Type.Optional(Type.Boolean({ description: "Expand unchanged sections instead of collapsing them." })),
-	ttlSeconds: Type.Optional(Type.Number({
+	ttlSeconds: optionalFiniteNumberSchema({
 		description: "Artifact lifetime in seconds. Default: 1800. Maximum: 21600.",
 		minimum: 1,
 		maximum: 21600
-	})),
+	}),
 	baseUrl: Type.Optional(Type.String({ description: "Optional gateway base URL override used when building the viewer URL. Overrides configured viewerBaseUrl, for example https://gateway.example.com." }))
 }, { additionalProperties: false });
 function createDiffsTool(params) {
@@ -1783,19 +2100,23 @@ function createDiffsTool(params) {
 		parameters: DiffsToolSchema,
 		execute: async (_toolCallId, rawParams) => {
 			const toolParams = rawParams;
+			const rawRecord = rawParams;
 			const artifactContext = buildArtifactContext(params.context);
 			const input = normalizeDiffInput(toolParams);
 			const mode = normalizeMode(toolParams.mode, params.defaults.mode);
 			const theme = normalizeTheme(toolParams.theme, params.defaults.theme);
 			const layout = normalizeLayout(toolParams.layout, params.defaults.layout);
 			const expandUnchanged = toolParams.expandUnchanged === true;
-			const ttlMs = normalizeTtlMs(toolParams.ttlSeconds ?? params.defaults.ttlSeconds);
+			const ttlSeconds = readFiniteNumberParam(rawRecord, "ttlSeconds") ?? params.defaults.ttlSeconds;
+			const fileScale = readFiniteNumberParam(rawRecord, "fileScale") ?? readFiniteNumberParam(rawRecord, "imageScale");
+			const fileMaxWidth = readFiniteNumberParam(rawRecord, "fileMaxWidth") ?? readFiniteNumberParam(rawRecord, "imageMaxWidth");
+			const ttlMs = normalizeTtlMs(ttlSeconds);
 			const image = resolveDiffImageRenderOptions({
 				defaults: params.defaults,
 				fileFormat: normalizeOutputFormat(toolParams.fileFormat ?? toolParams.imageFormat ?? toolParams.format),
 				fileQuality: normalizeFileQuality(toolParams.fileQuality ?? toolParams.imageQuality),
-				fileScale: toolParams.fileScale ?? toolParams.imageScale,
-				fileMaxWidth: toolParams.fileMaxWidth ?? toolParams.imageMaxWidth
+				fileScale,
+				fileMaxWidth
 			});
 			const renderTarget = resolveRenderTarget(mode);
 			const rendered = await renderDiffDocument(input, {
@@ -1805,7 +2126,8 @@ function createDiffsTool(params) {
 					theme
 				},
 				image,
-				expandUnchanged
+				expandUnchanged,
+				languagePackAvailable: params.languagePackAvailable
 			}, renderTarget);
 			const screenshotter = params.screenshotter ?? new PlaywrightDiffScreenshotter({ config: params.api.config });
 			if (isArtifactOnlyMode(mode)) {
@@ -1974,7 +2296,7 @@ async function renderDiffArtifactFile(params) {
 	});
 	return {
 		path: outputPath,
-		bytes: (await fs.stat(outputPath)).size,
+		bytes: (await fs$1.stat(outputPath)).size,
 		...standaloneArtifact?.id ? { artifactId: standaloneArtifact.id } : {},
 		...standaloneArtifact?.expiresAt ? { expiresAt: standaloneArtifact.expiresAt } : {}
 	};
@@ -2056,6 +2378,7 @@ var PluginToolInputError = class extends Error {
 };
 //#endregion
 //#region extensions/diffs/src/plugin.ts
+const DIFFS_LANGUAGE_PACK_PLUGIN_ID = "diffs-language-pack";
 function registerDiffsPlugin(api) {
 	const store = new DiffArtifactStore({
 		rootDir: path.join(resolvePreferredOpenClawTmpDir(), "openclaw-diffs"),
@@ -2078,6 +2401,7 @@ function registerDiffsPlugin(api) {
 			store,
 			defaults: resolveDiffsPluginDefaults(pluginConfig),
 			viewerBaseUrl: resolveDiffsPluginViewerBaseUrl(pluginConfig),
+			languagePackAvailable: resolveDiffsLanguagePackAvailability(api),
 			context: ctx
 		});
 	}, { name: "diffs" });
@@ -2096,6 +2420,20 @@ function registerDiffsPlugin(api) {
 	});
 	api.on("before_prompt_build", async () => ({ prependSystemContext: DIFFS_AGENT_GUIDANCE }));
 }
+function resolveDiffsLanguagePackAvailability(api) {
+	const plugins = (api.runtime.config?.current?.() ?? api.config).plugins;
+	if (plugins?.enabled === false) return false;
+	if (plugins?.deny?.includes(DIFFS_LANGUAGE_PACK_PLUGIN_ID)) return false;
+	if (plugins?.allow && !plugins.allow.includes(DIFFS_LANGUAGE_PACK_PLUGIN_ID)) return false;
+	if (plugins?.entries?.[DIFFS_LANGUAGE_PACK_PLUGIN_ID]?.enabled === false) return false;
+	return hasSiblingLanguagePackRuntime(api.rootDir);
+}
+function hasSiblingLanguagePackRuntime(rootDir) {
+	if (!rootDir) return false;
+	const languagePackRoot = path.join(path.dirname(rootDir), DIFFS_LANGUAGE_PACK_PLUGIN_ID);
+	const runtimePaths = [path.join(languagePackRoot, "assets", "viewer-runtime.js"), path.join(languagePackRoot, "dist", "assets", "viewer-runtime.js")];
+	return fs.existsSync(path.join(languagePackRoot, "openclaw.plugin.json")) && runtimePaths.some((runtimePath) => fs.existsSync(runtimePath));
+}
 //#endregion
 //#region extensions/diffs/index.ts
 var diffs_default = definePluginEntry({