@wasm-oj/server 0.2.0

package/dist/chunks/go-toolchain-Dbt-lp2L.js

@@ -0,0 +1,426 @@
+import { _ as GO_STANDARD_LIBRARY_SHA256, c as GO_COMPILER_SHA256, d as GO_LINKER_SHA256, f as GO_PACKAGE_ASSET_PATH, g as GO_STANDARD_LIBRARY_ASSET_PATH, h as GO_PACKAGE_SHA256, l as GO_COMPRESSED_PACKAGE_SHA256, m as GO_PACKAGE_MANIFEST_SHA256, p as GO_PACKAGE_MANIFEST_ASSET_PATH, u as GO_COMPRESSED_STANDARD_LIBRARY_SHA256, v as GO_VERSION } from "./toolchains-C6KuA1yM.js";
+import { WASM_OJ_SCHEMAS } from "@wasm-oj/contracts";
+//#region src/compiler/dependency-input.ts
+var ECOSYSTEM_BY_LANGUAGE = Object.freeze({
+	c: "cpp",
+	cpp: "cpp",
+	rust: "cargo",
+	python: "pypi",
+	javascript: "npm",
+	typescript: "npm",
+	go: "go"
+});
+function assertProjectDependencyEcosystem(project) {
+	if (!project.dependencies) return;
+	const expected = ECOSYSTEM_BY_LANGUAGE[project.config.language];
+	if (!expected) throw new Error(`Compiler '${project.config.language}' does not declare a dependency ecosystem.`);
+	const mismatch = project.dependencies.packages.find((item) => item.package.ecosystem !== expected);
+	if (mismatch) throw new Error(`${project.config.language} projects accept only '${expected}' dependencies; '${mismatch.package.id}' is '${mismatch.package.ecosystem}'.`);
+}
+function projectDependencyPackages(project, ecosystem) {
+	assertProjectDependencyEcosystem(project);
+	return project.dependencies?.packages.filter((item) => item.package.ecosystem === ecosystem) ?? [];
+}
+function pythonDependencyFiles(project) {
+	const sourceFiles = [];
+	const artifactFiles = {};
+	for (const item of projectDependencyPackages(project, "pypi")) for (const [path, bytes] of Object.entries(item.files)) {
+		const installedPath = `site-packages/${path}`;
+		artifactFiles[installedPath] = bytes.slice();
+		if (path.endsWith(".py")) sourceFiles.push({
+			path: installedPath,
+			language: "python",
+			content: decodeDependencyText(bytes, item.package.id, path)
+		});
+	}
+	return {
+		sourceFiles,
+		artifactFiles
+	};
+}
+function npmDependencyFiles(project) {
+	const files = {};
+	const names = /* @__PURE__ */ new Set();
+	const untyped = [];
+	for (const item of projectDependencyPackages(project, "npm")) {
+		if (names.has(item.package.name)) throw new Error(`npm dependency '${item.package.name}' resolves to multiple versions in a flat runtime graph.`);
+		names.add(item.package.name);
+		const manifestBytes = item.files["package.json"];
+		if (!manifestBytes) throw new Error(`npm dependency '${item.package.id}' omits package.json.`);
+		const manifestText = decodeDependencyText(manifestBytes, item.package.id, "package.json");
+		if (JSON.parse(manifestText).type === "module") throw new Error(`npm dependency '${item.package.id}' uses unsupported ESM package semantics.`);
+		if (!Object.keys(item.files).some((path) => path.endsWith(".d.ts"))) untyped.push(item.package.name);
+		for (const [path, bytes] of Object.entries(item.files)) {
+			const installedPath = `node_modules/${item.package.name}/${path}`;
+			files[installedPath] = isNpmTextPath(path) ? decodeDependencyText(bytes, item.package.id, path) : bytes.slice();
+		}
+	}
+	if (untyped.length > 0) files[".wasm-oj/npm-untyped-modules.d.ts"] = untyped.sort().flatMap((name) => [`declare module ${JSON.stringify(name)} { const value: any; export = value; }`, `declare module ${JSON.stringify(`${name}/*`)} { const value: any; export = value; }`]).join("\n");
+	return files;
+}
+function cppDependencyInput(project) {
+	const files = /* @__PURE__ */ new Map();
+	const includeDirectories = [];
+	const sources = [];
+	for (const [index, item] of projectDependencyPackages(project, "cpp").entries()) {
+		const root = `.wasm-oj/dependencies/cpp/${String(index).padStart(4, "0")}`;
+		includeDirectories.push(`/project/${root}`);
+		if (Object.keys(item.files).some((path) => path.startsWith("include/"))) includeDirectories.push(`/project/${root}/include`);
+		for (const [path, bytes] of Object.entries(item.files)) {
+			if (!isCppCompilerPath(path)) continue;
+			decodeDependencyText(bytes, item.package.id, path);
+			const installedPath = `${root}/${path}`;
+			files.set(installedPath, bytes.slice());
+			if (isCppSourcePath(path)) {
+				if (project.config.language === "c" && !path.endsWith(".c")) throw new Error(`C dependency '${item.package.id}' contains C++ source '${path}'.`);
+				sources.push(installedPath);
+			}
+		}
+	}
+	return {
+		files,
+		includeDirectories: Object.freeze(includeDirectories),
+		sources: Object.freeze(sources)
+	};
+}
+function rustDependencyInput(project) {
+	const packages = projectDependencyPackages(project, "cargo");
+	const packageById = new Map(packages.map((item) => [item.package.id, item]));
+	const ordered = topologicalPackages(packages);
+	const descriptorById = /* @__PURE__ */ new Map();
+	const files = [];
+	for (const [index, item] of ordered.entries()) {
+		const prefix = `.wasm-oj/dependencies/cargo/${String(index).padStart(4, "0")}`;
+		const manifestBytes = item.files["Cargo.toml"];
+		const manifest = decodeDependencyText(manifestBytes, item.package.id, "Cargo.toml");
+		if (/\bpackage\s*=\s*"/m.test(dependencySections(manifest))) throw new Error(`Cargo dependency '${item.package.id}' uses unsupported renamed dependencies.`);
+		const libSection = tomlSection(manifest, "lib");
+		const crateName = rustIdentifier(tomlString(libSection, "name") ?? item.package.name, item.package.id);
+		const rootRelative = tomlString(libSection, "path") ?? "src/lib.rs";
+		if (!item.files[rootRelative]) throw new Error(`Cargo dependency '${item.package.id}' omits '${rootRelative}'.`);
+		const edition = tomlString(tomlSection(manifest, "package"), "edition") ?? "2015";
+		if (!/^(?:2015|2018|2021|2024)$/.test(edition)) throw new Error(`Cargo dependency '${item.package.id}' has unsupported Rust edition '${edition}'.`);
+		const outputPath = `/work/build/deps/lib${String(index).padStart(4, "0")}_${crateName}.rlib`;
+		descriptorById.set(item.package.id, {
+			id: item.package.id,
+			crateName,
+			root: `${prefix}/${rootRelative}`,
+			edition,
+			outputPath,
+			features: Object.freeze([...item.package.features ?? []])
+		});
+		for (const [path, bytes] of Object.entries(item.files)) {
+			if (!isCargoCompilerText(path)) continue;
+			files.push({
+				path: `${prefix}/${path}`,
+				language: "rust",
+				content: decodeDependencyText(bytes, item.package.id, path)
+			});
+		}
+	}
+	const crates = ordered.map((item) => {
+		const descriptor = descriptorById.get(item.package.id);
+		return Object.freeze({
+			...descriptor,
+			externs: Object.freeze(item.package.dependencies.map((id) => {
+				const dependency = descriptorById.get(id);
+				if (!dependency) throw new Error(`Cargo dependency '${item.package.id}' refers to unavailable '${id}'.`);
+				return Object.freeze({
+					crateName: dependency.crateName,
+					path: dependency.outputPath
+				});
+			}))
+		});
+	});
+	const roots = project.dependencies?.lock.roots.map((id) => {
+		if (!packageById.has(id)) throw new Error(`Cargo root '${id}' is unavailable.`);
+		const descriptor = descriptorById.get(id);
+		return Object.freeze({
+			crateName: descriptor.crateName,
+			path: descriptor.outputPath
+		});
+	}) ?? [];
+	return {
+		files,
+		crates: Object.freeze(crates),
+		roots: Object.freeze(roots)
+	};
+}
+function goDependencyInput(project) {
+	const files = [];
+	const packages = [];
+	for (const [moduleIndex, item] of projectDependencyPackages(project, "go").entries()) {
+		const moduleRoot = `.wasm-oj/dependencies/go/${String(moduleIndex).padStart(4, "0")}`;
+		const directories = /* @__PURE__ */ new Map();
+		for (const [path, bytes] of Object.entries(item.files)) {
+			if (!path.endsWith(".go") || path.endsWith("_test.go") || path.split("/").includes("vendor")) continue;
+			const content = decodeDependencyText(bytes, item.package.id, path);
+			if (/^\s*\/\/(?:go:build|\s*\+build)\b/m.test(content)) throw new Error(`Go dependency '${item.package.id}' uses unsupported build constraints in '${path}'.`);
+			if (/import\s+(?:[._A-Za-z][A-Za-z0-9_]*\s+)?["`]C["`]/.test(content)) throw new Error(`Go dependency '${item.package.id}' uses unsupported cgo in '${path}'.`);
+			const directory = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+			const group = directories.get(directory) ?? [];
+			group.push({
+				path,
+				content
+			});
+			directories.set(directory, group);
+			files.push({
+				path: `${moduleRoot}/${path}`,
+				language: "go",
+				content
+			});
+		}
+		for (const [directory, sourceFiles] of [...directories].sort(([left], [right]) => left.localeCompare(right))) {
+			const packageNames = new Set(sourceFiles.map((file) => goPackageName(file.content, item.package.id, file.path)));
+			if (packageNames.size !== 1) throw new Error(`Go dependency '${item.package.id}' directory '${directory || "."}' contains multiple packages.`);
+			if ([...packageNames][0] === "main") continue;
+			const importPath = directory ? `${item.package.name}/${directory}` : item.package.name;
+			const index = packages.length;
+			packages.push(Object.freeze({
+				id: `${item.package.id}:${directory || "."}`,
+				importPath,
+				sourcePaths: Object.freeze(sourceFiles.map((file) => `${moduleRoot}/${file.path}`).sort()),
+				imports: Object.freeze([...new Set(sourceFiles.flatMap((file) => goImports(file.content)))].sort()),
+				archivePath: `/work/build/deps/${String(index).padStart(4, "0")}.a`
+			}));
+		}
+	}
+	return {
+		files,
+		packages: Object.freeze(packages)
+	};
+}
+function decodeDependencyText(bytes, id, path) {
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch (error) {
+		throw new Error(`Dependency '${id}' compiler file '${path}' is not valid UTF-8.`, { cause: error });
+	}
+}
+function isNpmTextPath(path) {
+	return /(?:^|\/)(?:package\.json)$/.test(path) || /\.(?:js|cjs|d\.ts|json)$/i.test(path);
+}
+function isCppCompilerPath(path) {
+	return /\.(?:h|hh|hpp|hxx|inc|c|cc|cpp|cxx)$/i.test(path);
+}
+function isCppSourcePath(path) {
+	return /\.(?:c|cc|cpp|cxx)$/i.test(path);
+}
+function topologicalPackages(packages) {
+	const byId = new Map(packages.map((item) => [item.package.id, item]));
+	const state = /* @__PURE__ */ new Map();
+	const ordered = [];
+	const visit = (id) => {
+		const current = state.get(id);
+		if (current === "visited") return;
+		if (current === "visiting") throw new Error(`Dependency graph contains a cycle at '${id}'.`);
+		const item = byId.get(id);
+		if (!item) throw new Error(`Dependency graph refers to unavailable package '${id}'.`);
+		state.set(id, "visiting");
+		for (const dependency of item.package.dependencies) visit(dependency);
+		state.set(id, "visited");
+		ordered.push(item);
+	};
+	for (const item of packages) visit(item.package.id);
+	return ordered;
+}
+function tomlSection(manifest, name) {
+	return manifest.match(new RegExp(`(?:^|\\n)\\[${name.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}\\]\\s*\\n([\\s\\S]*?)(?=\\n\\[|$)`))?.[1] ?? "";
+}
+function tomlString(section, key) {
+	return section.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"]+)"\\s*(?:#.*)?$`, "m"))?.[1];
+}
+function dependencySections(manifest) {
+	return manifest.split(/\n(?=\[)/).filter((section) => /\bdependencies\]/.test(section.split("\n", 1)[0])).join("\n");
+}
+function rustIdentifier(name, id) {
+	const normalized = name.replaceAll("-", "_");
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(normalized)) throw new Error(`Cargo dependency '${id}' has unsupported crate name '${name}'.`);
+	return normalized;
+}
+function isCargoCompilerText(path) {
+	return path.endsWith(".rs") || path.endsWith(".md") || path.endsWith(".txt") || path === "Cargo.toml";
+}
+function goPackageName(source, id, path) {
+	const match = source.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)\b/m);
+	if (!match) throw new Error(`Go dependency '${id}' source '${path}' has no package declaration.`);
+	return match[1];
+}
+function goImports(source) {
+	const imports = [];
+	const blockPattern = /\bimport\s*\(([\s\S]*?)\)/g;
+	for (const block of source.matchAll(blockPattern)) for (const match of block[1].matchAll(/(?:^|\n)\s*(?:[._A-Za-z][A-Za-z0-9_]*\s+)?["`]([^"`]+)["`]/g)) imports.push(match[1]);
+	const withoutBlocks = source.replace(blockPattern, "");
+	for (const match of withoutBlocks.matchAll(/\bimport\s+(?:[._A-Za-z][A-Za-z0-9_]*\s+)?["`]([^"`]+)["`]/g)) imports.push(match[1]);
+	return imports;
+}
+//#endregion
+//#region src/compiler/go-toolchain.ts
+var GO_LANGUAGE_VERSION = `go${GO_VERSION.split(".").slice(0, 2).join(".")}`;
+var GO_COMPILE_TIMEOUT_MS = 18e4;
+var GO_ARCHIVE_PATH = "/work/build/main.a";
+var GO_OUTPUT_PATH = "/work/build/app.wasm";
+var GO_TOOLCHAIN = Object.freeze({
+	version: GO_VERSION,
+	target: "wasip1/wasm",
+	packageAsset: GO_PACKAGE_ASSET_PATH,
+	packageCompressedSha256: GO_COMPRESSED_PACKAGE_SHA256,
+	packageSha256: GO_PACKAGE_SHA256,
+	manifestAsset: GO_PACKAGE_MANIFEST_ASSET_PATH,
+	manifestSha256: GO_PACKAGE_MANIFEST_SHA256,
+	standardLibraryAsset: GO_STANDARD_LIBRARY_ASSET_PATH,
+	standardLibraryCompressedSha256: GO_COMPRESSED_STANDARD_LIBRARY_SHA256,
+	standardLibrarySha256: GO_STANDARD_LIBRARY_SHA256,
+	compilerSha256: GO_COMPILER_SHA256,
+	linkerSha256: GO_LINKER_SHA256
+});
+function decodeGoToolchainManifest(bytes) {
+	const manifest = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	const compiler = asRecord(manifest.compiler, "compiler");
+	const linker = asRecord(manifest.linker, "linker");
+	const output = asRecord(manifest.output, "output");
+	const standardLibrary = asRecord(manifest.standardLibrary, "standardLibrary");
+	if (manifest.schema !== WASM_OJ_SCHEMAS.goToolchain || manifest.version !== GO_TOOLCHAIN.version || manifest.target !== GO_TOOLCHAIN.target || compiler.command !== "go-compile" || compiler.sha256 !== GO_TOOLCHAIN.compilerSha256 || linker.command !== "go-link" || linker.sha256 !== GO_TOOLCHAIN.linkerSha256 || JSON.stringify(manifest.deterministicReplacements) !== JSON.stringify([
+		"wasi_snapshot_preview1.random_get",
+		"wasi_snapshot_preview1.clock_time_get",
+		"wasi_snapshot_preview1.sock_accept",
+		"wasi_snapshot_preview1.sock_shutdown"
+	]) || manifest.filesystemMount !== null || output.sha256 !== GO_TOOLCHAIN.packageSha256 || output.compressedSha256 !== GO_TOOLCHAIN.packageCompressedSha256 || standardLibrary.sha256 !== GO_TOOLCHAIN.standardLibrarySha256 || standardLibrary.compressedSha256 !== GO_TOOLCHAIN.standardLibraryCompressedSha256 || standardLibrary.format !== "WOJGO002") throw new Error("Pinned Go toolchain manifest does not match the compiler contract.");
+	if (!Array.isArray(manifest.packages) || manifest.packages.length < 200) throw new Error("Pinned Go toolchain manifest has an incomplete standard library.");
+	let previous = "";
+	const packages = manifest.packages.map((value) => {
+		const item = asRecord(value, "packages[]");
+		if (typeof item.importPath !== "string" || item.importPath <= previous || typeof item.archivePath !== "string" || item.archivePath !== `/go/pkg/${item.importPath}.a` || typeof item.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(item.sha256)) throw new Error("Pinned Go toolchain manifest contains a non-canonical package entry.");
+		previous = item.importPath;
+		return Object.freeze({
+			importPath: item.importPath,
+			archivePath: item.archivePath,
+			sha256: item.sha256
+		});
+	});
+	return Object.freeze({ packages: Object.freeze(packages) });
+}
+function validateGoStandardLibrary(bytes, packages) {
+	goStandardLibraryLayout(bytes, packages);
+}
+function goStandardLibraryLayout(bytes, packages) {
+	if (bytes.byteLength < 12 || new TextDecoder().decode(bytes.subarray(0, 8)) !== "WOJGO002") throw new Error("Pinned Go standard library has an invalid format header.");
+	const dataOffset = 12 + new DataView(bytes.buffer, bytes.byteOffset + 8, 4).getUint32(0, true);
+	if (dataOffset > bytes.byteLength) throw new Error("Pinned Go standard-library index exceeds its archive.");
+	const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(12, dataOffset)));
+	if (!Array.isArray(parsed) || parsed.length !== packages.length) throw new Error("Pinned Go standard-library index does not match the manifest.");
+	const entries = [];
+	let expectedOffset = 0;
+	for (let index = 0; index < packages.length; index += 1) {
+		const entry = asRecord(parsed[index], "standardLibrary[]");
+		const declared = packages[index];
+		if (entry.importPath !== declared.importPath || entry.archivePath !== declared.archivePath || entry.sha256 !== declared.sha256 || !Number.isSafeInteger(entry.offset) || entry.offset !== expectedOffset || !Number.isSafeInteger(entry.length) || entry.length <= 8 || dataOffset + entry.offset + entry.length > bytes.byteLength) throw new Error("Pinned Go standard-library index contains a non-canonical archive entry.");
+		entries.push(entry);
+		expectedOffset += entry.length;
+	}
+	if (dataOffset + expectedOffset !== bytes.byteLength) throw new Error("Pinned Go standard library contains trailing or missing archive bytes.");
+	return {
+		dataOffset,
+		entries: Object.freeze(entries)
+	};
+}
+function goImportConfig(packages, includeMain) {
+	const lines = packages.map((item) => `packagefile ${item.importPath}=${item.archivePath}`);
+	if (includeMain) lines.push(`packagefile command-line-arguments=${GO_ARCHIVE_PATH}`);
+	return `${lines.join("\n")}\n`;
+}
+function reachableGoDependencies(projectFiles, dependencies, standardLibrary) {
+	const byImport = new Map(dependencies.map((item) => [item.importPath, item]));
+	const standard = new Set(standardLibrary.map((item) => item.importPath));
+	const state = /* @__PURE__ */ new Map();
+	const ordered = [];
+	const visitImport = (importPath, importer) => {
+		if (standard.has(importPath)) return;
+		const dependency = byImport.get(importPath);
+		if (!dependency) throw new Error(`Go package '${importer}' imports unlocked package '${importPath}'.`);
+		const current = state.get(importPath);
+		if (current === "visited") return;
+		if (current === "visiting") throw new Error(`Go dependency import cycle contains '${importPath}'.`);
+		state.set(importPath, "visiting");
+		for (const nested of dependency.imports) visitImport(nested, importPath);
+		state.set(importPath, "visited");
+		ordered.push(dependency);
+	};
+	for (const source of projectFiles.filter((file) => file.path.endsWith(".go"))) for (const importPath of goImports(source.content)) visitImport(importPath, "main");
+	return ordered;
+}
+function goCompileDependencyArguments(dependency, optimization) {
+	return [
+		"-o",
+		dependency.archivePath,
+		"-p",
+		dependency.importPath,
+		"-lang",
+		GO_LANGUAGE_VERSION,
+		"-complete",
+		`-buildid=wasm_oj_dependency_${dependency.importPath}`,
+		"-c=1",
+		"-dwarf=false",
+		"-trimpath",
+		"/work=.",
+		"-importcfg",
+		"/work/importcfg",
+		"-pack",
+		...optimization === "debug" ? ["-N", "-l"] : [],
+		...dependency.sourcePaths.map((path) => `/work/${path}`)
+	];
+}
+function goCompileArguments(files, optimization) {
+	const sources = files.filter((file) => file.path.endsWith(".go")).map((file) => `/work/${file.path}`).sort();
+	if (sources.length === 0) throw new Error("A Go project must contain at least one .go source file.");
+	return [
+		"-o",
+		GO_ARCHIVE_PATH,
+		"-p",
+		"main",
+		"-lang",
+		GO_LANGUAGE_VERSION,
+		"-complete",
+		"-buildid=wasm_oj_submission",
+		"-c=1",
+		"-dwarf=false",
+		"-trimpath",
+		"/work=.",
+		"-importcfg",
+		"/work/importcfg",
+		"-pack",
+		...optimization === "debug" ? ["-N", "-l"] : [],
+		...sources
+	];
+}
+function goLinkArguments(optimization) {
+	return [
+		"-o",
+		GO_OUTPUT_PATH,
+		"-importcfg",
+		"/work/importcfg.link",
+		"-buildmode=exe",
+		"-buildid=",
+		...optimization === "release" ? ["-s", "-w"] : [],
+		GO_ARCHIVE_PATH
+	];
+}
+function deterministicGoCompilerEnvironment() {
+	return {
+		GOOS: "wasip1",
+		GOARCH: "wasm",
+		GOROOT: "/go",
+		GOENV: "off",
+		GOTOOLCHAIN: "local",
+		PWD: "/work",
+		SOURCE_DATE_EPOCH: "946684800",
+		TZ: "UTC",
+		LC_ALL: "C"
+	};
+}
+function asRecord(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Pinned Go toolchain manifest '${label}' field must be an object.`);
+	return value;
+}
+//#endregion
+export { pythonDependencyFiles as _, decodeGoToolchainManifest as a, goCompileDependencyArguments as c, reachableGoDependencies as d, validateGoStandardLibrary as f, npmDependencyFiles as g, goDependencyInput as h, GO_TOOLCHAIN as i, goImportConfig as l, cppDependencyInput as m, GO_COMPILE_TIMEOUT_MS as n, deterministicGoCompilerEnvironment as o, assertProjectDependencyEcosystem as p, GO_OUTPUT_PATH as r, goCompileArguments as s, GO_ARCHIVE_PATH as t, goLinkArguments as u, rustDependencyInput as v };

package/dist/chunks/java-toolchain-DajoRCHu.js

@@ -0,0 +1,44 @@
+import { C as JAVA_COMPILE_CLASSLIB_ASSET_PATH, D as JAVA_VERSION, E as JAVA_RUNTIME_CLASSLIB_SHA256, S as JAVA_COMPILER_PACKAGE_SHA256, T as JAVA_RUNTIME_CLASSLIB_ASSET_PATH, b as JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256, w as JAVA_COMPILE_CLASSLIB_SHA256, x as JAVA_COMPILER_PACKAGE, y as JAVA_COMPILER_ASSET_PATH } from "./toolchains-C6KuA1yM.js";
+//#region src/compiler/java-toolchain.ts
+var JAVA_COMPILE_TIMEOUT_MS = 18e4;
+Object.freeze({
+	version: JAVA_VERSION,
+	package: JAVA_COMPILER_PACKAGE,
+	compilerAsset: JAVA_COMPILER_ASSET_PATH,
+	compilerCompressedSha256: JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256,
+	compilerPackageSha256: JAVA_COMPILER_PACKAGE_SHA256,
+	compileClasslibAsset: JAVA_COMPILE_CLASSLIB_ASSET_PATH,
+	compileClasslibSha256: JAVA_COMPILE_CLASSLIB_SHA256,
+	runtimeClasslibAsset: JAVA_RUNTIME_CLASSLIB_ASSET_PATH,
+	runtimeClasslibSha256: JAVA_RUNTIME_CLASSLIB_SHA256
+});
+function javaMainClass(entry, source) {
+	const className = entry.split("/").at(-1)?.replace(/\.java$/u, "") ?? "";
+	if (!/^[A-Za-z_$][\w$]*$/u.test(className)) throw new Error(`Java entry '${entry}' must name a valid .java class file.`);
+	const packageName = source.match(/^\s*package\s+([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*;/m)?.[1];
+	return packageName ? `${packageName}.${className}` : className;
+}
+function parseJavaDiagnostics(output, fallbackFile) {
+	const diagnostics = [];
+	const pattern = /^(.*?\.java):(\d+)(?::(\d+))?:\s*(?:(error|warning):\s*)?(.+)$/gim;
+	let match;
+	while ((match = pattern.exec(output)) !== null) diagnostics.push({
+		severity: match[4]?.toLowerCase() === "warning" ? "warning" : "error",
+		message: match[5],
+		file: match[1].replace(/^\/?(?:project|workspace)\//u, ""),
+		line: Number(match[2]),
+		column: Number(match[3] ?? 1),
+		source: "java"
+	});
+	if (diagnostics.length === 0 && /(?:error|exception|failed)/iu.test(output)) diagnostics.push({
+		severity: "error",
+		message: output.trim().split(/\r?\n/u).filter(Boolean).at(-1) ?? "Java compilation failed.",
+		file: fallbackFile,
+		line: 1,
+		column: 1,
+		source: "java"
+	});
+	return diagnostics;
+}
+//#endregion
+export { javaMainClass as n, parseJavaDiagnostics as r, JAVA_COMPILE_TIMEOUT_MS as t };

package/dist/chunks/python-toolchain-Dx834o2A.js

@@ -0,0 +1,4 @@
+//#region src/compiler/python-toolchain.ts
+var PYTHON_COMPILE_TIMEOUT_MS = 18e4;
+//#endregion
+export { PYTHON_COMPILE_TIMEOUT_MS as t };