@wasm-oj/server 0.2.0

package/dist/chunks/rust-toolchain-CJ3sMxPE.js

@@ -0,0 +1,252 @@
+import { F as RUST_PACKAGE_MANIFEST_ASSET_PATH, I as RUST_PACKAGE_MANIFEST_SHA256, L as RUST_PACKAGE_SHA256, N as RUST_COMPRESSED_PACKAGE_SHA256, P as RUST_PACKAGE_ASSET_PATH, R as RUST_VERSION } from "./toolchains-C6KuA1yM.js";
+/**
+* Accept a mounted output only after byte-identical snapshots have persisted for
+* the complete stability interval. This prevents a valid WebAssembly prefix
+* from being mistaken for the command's final output.
+*/
+var MountedOutputStabilityObserver = class {
+	#stabilityMs;
+	#candidate;
+	#candidateSince = 0;
+	constructor(stabilityMs = 75) {
+		if (!Number.isFinite(stabilityMs) || stabilityMs <= 0) throw new RangeError("Mounted-output stability interval must be positive and finite.");
+		this.#stabilityMs = stabilityMs;
+	}
+	observe(snapshot, monotonicMs) {
+		if (!Number.isFinite(monotonicMs)) throw new RangeError("Mounted-output observation time must be finite.");
+		if (!snapshot) {
+			this.#candidate = void 0;
+			this.#candidateSince = 0;
+			return;
+		}
+		if (!this.#candidate || !bytesEqual(this.#candidate, snapshot)) {
+			this.#candidate = snapshot.slice();
+			this.#candidateSince = monotonicMs;
+			return;
+		}
+		if (monotonicMs - this.#candidateSince < this.#stabilityMs) return void 0;
+		return snapshot.slice();
+	}
+};
+function bytesEqual(left, right) {
+	if (left.byteLength !== right.byteLength) return false;
+	for (let index = 0; index < left.byteLength; index += 1) if (left[index] !== right[index]) return false;
+	return true;
+}
+//#endregion
+//#region src/compiler/rust-linker.ts
+var RUST_LINKER_COMMAND = "wasm-ld";
+var RUST_OBJECT_PATH = "/work/build/main.o";
+var RUST_FINAL_OUTPUT_PATH = "/work/build/main.wasm";
+var RUST_OBJECT_PLACEHOLDER = "__WASM_OJ_RUST_OBJECT__";
+var RUST_ALLOCATOR_PLACEHOLDER = "__WASM_OJ_RUST_ALLOCATOR_BITCODE__";
+var RUST_OUTPUT_PLACEHOLDER = "__WASM_OJ_RUST_OUTPUT__";
+/** Validate the exact linker argv embedded in the digest-pinned Rust manifest. */
+function decodeRustLinkerArgumentContract(value) {
+	if (!isRecord(value)) throw new Error("Pinned Rust linker arguments must be an object.");
+	if (value.objectPlaceholder !== "__WASM_OJ_RUST_OBJECT__") throw new Error("Pinned Rust linker object placeholder does not match the compiler contract.");
+	if (value.outputPlaceholder !== "__WASM_OJ_RUST_OUTPUT__") throw new Error("Pinned Rust linker output placeholder does not match the compiler contract.");
+	if (value.allocatorPlaceholder !== "__WASM_OJ_RUST_ALLOCATOR_BITCODE__") throw new Error("Pinned Rust linker allocator placeholder does not match the compiler contract.");
+	const debug = validateTemplate("debug", value.debug, "-O0");
+	const release = validateTemplate("release", value.release, "-O2");
+	return Object.freeze({
+		objectPlaceholder: RUST_OBJECT_PLACEHOLDER,
+		allocatorPlaceholder: RUST_ALLOCATOR_PLACEHOLDER,
+		outputPlaceholder: RUST_OUTPUT_PLACEHOLDER,
+		debug,
+		release
+	});
+}
+function instantiateRustLinkerArguments(contract, optimization, allocatorBitcodePath) {
+	if (!/^\/work\/build\/main\.[a-z0-9]+\.rcgu\.bc$/i.test(allocatorBitcodePath)) throw new Error(`Rust allocator bitcode has unexpected path '${allocatorBitcodePath}'.`);
+	return (optimization === "release" ? contract.release : contract.debug).map((argument) => {
+		if (argument === contract.objectPlaceholder) return RUST_OBJECT_PATH;
+		if (argument === contract.allocatorPlaceholder) return allocatorBitcodePath;
+		if (argument === contract.outputPlaceholder) return RUST_FINAL_OUTPUT_PATH;
+		return argument;
+	});
+}
+function validateTemplate(label, value, expectedOptimization) {
+	if (!Array.isArray(value) || value.length === 0 || value.some((item) => typeof item !== "string")) throw new Error(`Pinned Rust ${label} linker arguments must be a non-empty string array.`);
+	const args = value;
+	requireExactlyOnce(args, RUST_OBJECT_PLACEHOLDER, `${label} object placeholder`);
+	requireExactlyOnce(args, RUST_ALLOCATOR_PLACEHOLDER, `${label} allocator placeholder`);
+	const outputIndex = requireExactlyOnce(args, RUST_OUTPUT_PLACEHOLDER, `${label} output placeholder`);
+	if (outputIndex === 0 || args[outputIndex - 1] !== "-o") throw new Error(`Pinned Rust ${label} linker output placeholder must follow '-o'.`);
+	requireExactlyOnce(args, expectedOptimization, `${label} linker optimization`);
+	if (!args.includes("--gc-sections") || !args.includes("--shared-memory")) throw new Error(`Pinned Rust ${label} linker arguments omit required WebAssembly flags.`);
+	if (!args.some((argument) => argument.endsWith("/self-contained/crt1-command.o"))) throw new Error(`Pinned Rust ${label} linker arguments omit the WASI command startup object.`);
+	if (!args.some((argument) => argument.startsWith("/rust/") && argument.endsWith(".rlib"))) throw new Error(`Pinned Rust ${label} linker arguments omit the Rust standard library.`);
+	for (const argument of args) {
+		if (!argument || argument.includes("\0")) throw new Error(`Pinned Rust ${label} linker arguments contain an empty or NUL-bearing value.`);
+		if (argument.startsWith("@")) throw new Error(`Pinned Rust ${label} linker arguments unexpectedly use a response file.`);
+		if (argument.startsWith("/") && (!argument.startsWith("/rust/") || argument.split("/").includes(".."))) throw new Error(`Pinned Rust ${label} linker arguments reference unmounted path '${argument}'.`);
+	}
+	return Object.freeze([...args]);
+}
+function requireExactlyOnce(args, value, label) {
+	const indices = args.flatMap((argument, index) => argument === value ? [index] : []);
+	if (indices.length !== 1) throw new Error(`Pinned Rust ${label} must occur exactly once.`);
+	return indices[0];
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/compiler/rust-toolchain.ts
+var RUST_TARGET_TRIPLE = "wasm32-wasip1-threads";
+var RUST_EDITION = "2024";
+var RUST_COMPILE_TIMEOUT_MS = 18e4;
+var RUST_UNINIT_CONST_CHUNK_THRESHOLD = "4294967295";
+var RUST_DETERMINISTIC_REPLACEMENTS = Object.freeze(["wasi_snapshot_preview1.random_get", "wasi_snapshot_preview1.clock_time_get"]);
+var RUST_TOOLCHAIN = Object.freeze({
+	version: RUST_VERSION,
+	packageAsset: RUST_PACKAGE_ASSET_PATH,
+	packageCompressedSha256: RUST_COMPRESSED_PACKAGE_SHA256,
+	packageSha256: RUST_PACKAGE_SHA256,
+	manifestAsset: RUST_PACKAGE_MANIFEST_ASSET_PATH,
+	manifestSha256: RUST_PACKAGE_MANIFEST_SHA256,
+	target: RUST_TARGET_TRIPLE,
+	edition: RUST_EDITION
+});
+function rustcObjectArguments(entry, optimization, rootExterns = []) {
+	const optimizationArguments = optimization === "release" ? [
+		"-C",
+		"opt-level=2",
+		"-C",
+		"debuginfo=0"
+	] : [
+		"-C",
+		"opt-level=0",
+		"-C",
+		"debuginfo=1"
+	];
+	return [
+		"--target",
+		RUST_TARGET_TRIPLE,
+		"--sysroot",
+		"/rust",
+		"-Zno-parallel-backend",
+		"-Z",
+		"threads=1",
+		"-Z",
+		"randomize-layout=no",
+		"-Z",
+		"layout-seed=0",
+		"-Z",
+		`uninit-const-chunk-threshold=${RUST_UNINIT_CONST_CHUNK_THRESHOLD}`,
+		"-C",
+		"codegen-units=1",
+		"-C",
+		"llvm-args=-rng-seed=1",
+		"-C",
+		"metadata=wasm_oj_submission",
+		"-C",
+		"target-feature=+atomics,+bulk-memory,+mutable-globals",
+		`/work/${entry}`,
+		"--crate-name",
+		"wasm_oj_submission",
+		"--crate-type",
+		"bin",
+		"--edition",
+		RUST_EDITION,
+		"--error-format=json",
+		"--json=diagnostic-rendered-ansi",
+		"--remap-path-prefix=/work=.",
+		"-C",
+		"panic=abort",
+		...rootExterns.flatMap((item) => ["--extern", `${item.crateName}=${item.path}`]),
+		...optimizationArguments,
+		"-C",
+		"save-temps=yes",
+		"--emit=obj",
+		"-o",
+		RUST_OBJECT_PATH
+	];
+}
+function rustcDependencyArguments(dependency, optimization) {
+	const optimizationArguments = optimization === "release" ? [
+		"-C",
+		"opt-level=2",
+		"-C",
+		"debuginfo=0"
+	] : [
+		"-C",
+		"opt-level=0",
+		"-C",
+		"debuginfo=1"
+	];
+	return [
+		"--target",
+		RUST_TARGET_TRIPLE,
+		"--sysroot",
+		"/rust",
+		"-Zno-parallel-backend",
+		"-Z",
+		"threads=1",
+		"-Z",
+		"randomize-layout=no",
+		"-Z",
+		"layout-seed=0",
+		"-C",
+		"codegen-units=1",
+		"-C",
+		"llvm-args=-rng-seed=1",
+		"-C",
+		`metadata=${dependency.id}`,
+		"-C",
+		"target-feature=+atomics,+bulk-memory,+mutable-globals",
+		`/work/${dependency.root}`,
+		"--crate-name",
+		dependency.crateName,
+		"--crate-type",
+		"rlib",
+		"--edition",
+		dependency.edition,
+		"--error-format=json",
+		"--json=diagnostic-rendered-ansi",
+		"--remap-path-prefix=/work=.",
+		"-C",
+		"panic=abort",
+		"--cap-lints",
+		"allow",
+		...dependency.features.flatMap((feature) => ["--cfg", `feature=${JSON.stringify(feature)}`]),
+		...dependency.externs.flatMap((item) => ["--extern", `${item.crateName}=${item.path}`]),
+		...optimizationArguments,
+		"--emit=link",
+		"-o",
+		dependency.outputPath
+	];
+}
+function deterministicRustCompilerEnvironment() {
+	return {
+		RUST_MIN_STACK: "16777216",
+		SOURCE_DATE_EPOCH: "946684800",
+		TZ: "UTC",
+		LC_ALL: "C"
+	};
+}
+function deterministicRustLinkerEnvironment() {
+	return {
+		SOURCE_DATE_EPOCH: "946684800",
+		TZ: "UTC",
+		LC_ALL: "C",
+		VSLANG: "1033"
+	};
+}
+function decodeRustToolchainManifest(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 pipeline = asRecord(manifest.pipeline, "pipeline");
+	const output = asRecord(manifest.output, "output");
+	const mounts = asRecord(manifest.filesystemMounts, "filesystemMounts");
+	if (manifest.version !== RUST_TOOLCHAIN.version || manifest.target !== RUST_TOOLCHAIN.target || compiler.command !== "rustc" || JSON.stringify(compiler.deterministicReplacements) !== JSON.stringify(RUST_DETERMINISTIC_REPLACEMENTS) || linker.command !== "wasm-ld" || pipeline.strategy !== "rustc-object-then-wasm-ld" || pipeline.objectEmission !== "rustc --emit=obj -C save-temps=yes" || pipeline.allocatorShim !== "rustc-generated LLVM bitcode" || pipeline.linkArgsSource !== "rustc --print=link-args" || mounts.rust !== "/rust" || mounts.linker !== "/usr" || output.sha256 !== RUST_TOOLCHAIN.packageSha256 || output.compressedSha256 !== RUST_TOOLCHAIN.packageCompressedSha256) throw new Error("Pinned Rust toolchain manifest does not match the compiler contract.");
+	return Object.freeze({ linkerArguments: decodeRustLinkerArgumentContract(linker.arguments) });
+}
+function asRecord(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Pinned Rust toolchain manifest '${label}' field must be an object.`);
+	return value;
+}
+//#endregion
+export { deterministicRustLinkerEnvironment as a, RUST_FINAL_OUTPUT_PATH as c, instantiateRustLinkerArguments as d, MountedOutputStabilityObserver as f, deterministicRustCompilerEnvironment as i, RUST_LINKER_COMMAND as l, RUST_TOOLCHAIN as n, rustcDependencyArguments as o, decodeRustToolchainManifest as r, rustcObjectArguments as s, RUST_COMPILE_TIMEOUT_MS as t, RUST_OBJECT_PATH as u };

package/dist/chunks/toolchains-C6KuA1yM.js

@@ -0,0 +1,224 @@
+import { isBuiltinLanguage } from "@wasm-oj/contracts";
+//#region src/core/toolchains.ts
+var CLANG_VERSION = "22.0.0-git20542-10";
+var CLANG_PACKAGE = `wasm-oj/clang@${CLANG_VERSION}`;
+var CLANG_PACKAGE_ASSET_PATH = `/toolchains/clang-${CLANG_VERSION}.webc.gz.bin`;
+var CLANG_CC1_PINS_ASSET_PATH = `/toolchains/clang-${CLANG_VERSION}.cc1-pins.json`;
+var CLANG_MANIFEST_ASSET_PATH = `/toolchains/clang-${CLANG_VERSION}.manifest.json`;
+var CLANG_LIBCXX_PCH_MANIFEST_ASSET_PATH = `/toolchains/clang-${CLANG_VERSION}.libcxx-pch.json`;
+var CLANG_LIBCXX_PCH_DEBUG_ASSET_PATH = `/toolchains/clang-${CLANG_VERSION}.cpp-debug.pch.gz.bin`;
+var CLANG_LIBCXX_PCH_RELEASE_ASSET_PATH = `/toolchains/clang-${CLANG_VERSION}.cpp-release.pch.gz.bin`;
+var CLANG_COMPRESSED_PACKAGE_SHA256 = "7f10d90b8e52b270f04874641a1d0bf9e94e85b4f6c7573a774cebbc6d32552a";
+/** SHA-256 after browser-side gzip decompression. */
+var CLANG_PACKAGE_SHA256 = "21ded33b9c6d4e1aaad5528c940bdaf6c3e84be77ea8f522f018ca7289a2a224";
+/** SHA-256 of the pinned cc1/wasm-ld argv manifest; regenerated by scripts/pin-clang-cc1-argv.mjs. */
+var CLANG_CC1_PINS_SHA256 = "66c4604dccd3f89d8e1472bf4432367d7396cce4a01279b1a1db445f229dba72";
+var CLANG_MANIFEST_SHA256 = "6382dcdfb6a2da49032a0e08da3b1fb490eb24432be85c3c12e3e871a5065273";
+/** Updated atomically with the generated toolchain-admitted PCH assets. */
+var CLANG_LIBCXX_PCH_MANIFEST_SHA256 = "d126c99e951a7302d4ea2b66da4ed64d3d74e9d319d562518867c8d8c97a06b8";
+var CLANG_LIBCXX_PCH = Object.freeze({
+	"cpp-debug": Object.freeze({
+		path: CLANG_LIBCXX_PCH_DEBUG_ASSET_PATH,
+		sha256: "05a4db721448ba33e65977cb4ac366908ea215ab377e3b6d09f1fd224d515b68",
+		compressedSha256: "a4152027d248412eca8aec3e7e23f6f7c81f95170cae9fd385bcf02e57e91fc9"
+	}),
+	"cpp-release": Object.freeze({
+		path: CLANG_LIBCXX_PCH_RELEASE_ASSET_PATH,
+		sha256: "aec9e778ac527c120ba369b9b0e142cf8206d11365801208847ba0e1c39daa1a",
+		compressedSha256: "18f4ca8ab8ca7888db572ba34146fc1acb213a7e7305000ea6285188f52f99f4"
+	})
+});
+var PYTHON_VERSION = "3.14.6";
+var PYTHON_PACKAGE_SHA256 = "454ffc53936aa13a0d7f4afbb5bd50ada339c8ebd04bbf27ea19e4104cf43207";
+var PYTHON_PACKAGE = `${`wasm-oj/cpython@${PYTHON_VERSION}`}#sha256:${PYTHON_PACKAGE_SHA256}`;
+var PYTHON_PACKAGE_ASSET_PATH = `/toolchains/python-${PYTHON_VERSION}-wasip1.webc.gz.bin`;
+var PYTHON_PACKAGE_MANIFEST_ASSET_PATH = `/toolchains/python-${PYTHON_VERSION}-wasip1.manifest.json`;
+var PYTHON_COMPRESSED_PACKAGE_SHA256 = "218cd20ac4abb443e0700816010a615a345a43eae623a0232da2227135a6c7a6";
+var PYTHON_PACKAGE_MANIFEST_SHA256 = "054eccad04a7cee7ba1661062142ef0d639976850981eab8fc785f48eb26129e";
+var PYTHON_RUNTIME_FILES_ARCHIVE_SHA256 = "44d894f91487f20c2bb04fe496a9343db37d8720fb706472c2b4a7f3300db039";
+var QUICKJS_VERSION = "0.15.1";
+var QUICKJS_PACKAGE = `wasm-oj/quickjs-ng@${QUICKJS_VERSION}`;
+var QUICKJS_ASSET_PATH = `/toolchains/quickjs-${QUICKJS_VERSION}.wasm.gz.bin`;
+var QUICKJS_ASSET_SHA256 = "8c7f0588210490e7d77f198fc91f72c1b94787ab4c359c4786ca59a363c4f5e8";
+var TYPESCRIPT_VERSION = "7.0.2";
+var TYPESCRIPT_ASSET_PATH = `/toolchains/typescript-${TYPESCRIPT_VERSION}.wasm.gz.bin`;
+var TYPESCRIPT_ASSET_SHA256 = "06e58ce887d95d1895055699b8dc96a1cde7d1f2baa48de40f9b790e3271dc16";
+var RUST_VERSION = "1.91.1-dev";
+var RUST_PACKAGE_ASSET_PATH = `/toolchains/rust-${RUST_VERSION}.webc.gz.bin`;
+var RUST_PACKAGE_MANIFEST_ASSET_PATH = `/toolchains/rust-${RUST_VERSION}.manifest.json`;
+var RUST_COMPRESSED_PACKAGE_SHA256 = "cfbdadc67be1315e735aa55bdf8a5a0d00171982a023fefcf7ba586127753887";
+/** SHA-256 after browser-side gzip decompression. */
+var RUST_PACKAGE_SHA256 = "765de8d68d03078e79f69f49dec0dcab1ff96fe3bbe5e9eafebb2ce61a39d3ee";
+var RUST_PACKAGE_MANIFEST_SHA256 = "d5bbdca994e61888679c5738cb9420649c0854ed0eb5d65468bc67d5d550bce1";
+var GO_VERSION = "1.26.5";
+var GO_PACKAGE_ASSET_PATH = `/toolchains/go-${GO_VERSION}-wasip1.webc.gz.bin`;
+var GO_PACKAGE_MANIFEST_ASSET_PATH = `/toolchains/go-${GO_VERSION}-wasip1.manifest.json`;
+var GO_STANDARD_LIBRARY_ASSET_PATH = `/toolchains/go-${GO_VERSION}-wasip1.stdlib.gz.bin`;
+var GO_COMPRESSED_PACKAGE_SHA256 = "70a7e359884b09b2e1a622d6ac5cd6e31c334aab519e6dd80dff5e040a9e09e4";
+var GO_PACKAGE_SHA256 = "c3a97934b6a83fefdea5c31f99141f70f76189eedc9ec0fa9ccd41302e50963b";
+var GO_PACKAGE_MANIFEST_SHA256 = "5d784e9ca640b9525e84b598c0beb97ca110ae908568ca45f6441a441d99a262";
+var GO_COMPRESSED_STANDARD_LIBRARY_SHA256 = "aeffc384fdc624544f174ba5fc3c22395717fdbc3c4387d677d20855b6be80d8";
+var GO_STANDARD_LIBRARY_SHA256 = "e1ec64b08efd02b35b7ffdaf3970875aaae98325fa4795eafca94ebae2d0d192";
+var GO_COMPILER_SHA256 = "9e557f5b86961fd604217d7521461c5d2b7322e383fa30dead5669b77db12201";
+var GO_LINKER_SHA256 = "2eefca10af935a307ab7946447146bd30e0ea0fb5460be54dc1c55844d155580";
+var JAVA_VERSION = "teavm-0.13.1-wasi";
+var JAVA_COMPILER_PACKAGE = `wasm-oj/java-teavm@${JAVA_VERSION}`;
+var JAVA_COMPILER_ASSET_PATH = "/toolchains/java-teavm-0.13.1.wasi.compiler.webc.gz.bin";
+var JAVA_COMPILE_CLASSLIB_ASSET_PATH = "/toolchains/java-teavm-0.13.1.compile-classlib.bin";
+var JAVA_RUNTIME_CLASSLIB_ASSET_PATH = "/toolchains/java-teavm-0.13.1.runtime-classlib.bin";
+var JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256 = "129f1f51d591e58954f88787d36396b856a9a68ba3ae9c9d14f20bd67c2c7722";
+var JAVA_COMPILER_PACKAGE_SHA256 = "f8f86761cf31062565187e4a66f73b6903f257fe84c0ce70ea1cd28441b6c2e9";
+var JAVA_COMPILER_SHA256 = "33a0d662395256f10a5d02ea305fc7b18007b2b8fe8996859017b084d3d19735";
+var JAVA_COMPILE_CLASSLIB_SHA256 = "acfe3fb09e5f2c0c7c8dc2339c66fcdadc1f8e1bf1c74be446926175ef770868";
+var JAVA_RUNTIME_CLASSLIB_SHA256 = "21a9394586e416af2fca4eb0ed08521cbc8924e1d1afaa07863a59a3cfae54ab";
+Object.freeze({
+	[CLANG_PACKAGE_ASSET_PATH]: CLANG_COMPRESSED_PACKAGE_SHA256,
+	[CLANG_CC1_PINS_ASSET_PATH]: CLANG_CC1_PINS_SHA256,
+	[CLANG_MANIFEST_ASSET_PATH]: CLANG_MANIFEST_SHA256,
+	[CLANG_LIBCXX_PCH_MANIFEST_ASSET_PATH]: CLANG_LIBCXX_PCH_MANIFEST_SHA256,
+	[CLANG_LIBCXX_PCH_DEBUG_ASSET_PATH]: CLANG_LIBCXX_PCH["cpp-debug"].compressedSha256,
+	[CLANG_LIBCXX_PCH_RELEASE_ASSET_PATH]: CLANG_LIBCXX_PCH["cpp-release"].compressedSha256,
+	[PYTHON_PACKAGE_ASSET_PATH]: PYTHON_COMPRESSED_PACKAGE_SHA256,
+	[PYTHON_PACKAGE_MANIFEST_ASSET_PATH]: PYTHON_PACKAGE_MANIFEST_SHA256,
+	[QUICKJS_ASSET_PATH]: QUICKJS_ASSET_SHA256,
+	[TYPESCRIPT_ASSET_PATH]: TYPESCRIPT_ASSET_SHA256,
+	[RUST_PACKAGE_ASSET_PATH]: RUST_COMPRESSED_PACKAGE_SHA256,
+	[RUST_PACKAGE_MANIFEST_ASSET_PATH]: RUST_PACKAGE_MANIFEST_SHA256,
+	[GO_PACKAGE_ASSET_PATH]: GO_COMPRESSED_PACKAGE_SHA256,
+	[GO_PACKAGE_MANIFEST_ASSET_PATH]: GO_PACKAGE_MANIFEST_SHA256,
+	[GO_STANDARD_LIBRARY_ASSET_PATH]: GO_COMPRESSED_STANDARD_LIBRARY_SHA256,
+	[JAVA_COMPILER_ASSET_PATH]: JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256,
+	[JAVA_COMPILE_CLASSLIB_ASSET_PATH]: JAVA_COMPILE_CLASSLIB_SHA256,
+	[JAVA_RUNTIME_CLASSLIB_ASSET_PATH]: JAVA_RUNTIME_CLASSLIB_SHA256
+});
+var TOOLCHAIN_CONTENT_SHA256 = Object.freeze({
+	c: Object.freeze([
+		CLANG_COMPRESSED_PACKAGE_SHA256,
+		CLANG_PACKAGE_SHA256,
+		CLANG_CC1_PINS_SHA256,
+		CLANG_MANIFEST_SHA256
+	]),
+	cpp: Object.freeze([
+		CLANG_COMPRESSED_PACKAGE_SHA256,
+		CLANG_PACKAGE_SHA256,
+		CLANG_CC1_PINS_SHA256,
+		CLANG_MANIFEST_SHA256
+	]),
+	rust: Object.freeze([
+		RUST_COMPRESSED_PACKAGE_SHA256,
+		RUST_PACKAGE_SHA256,
+		RUST_PACKAGE_MANIFEST_SHA256
+	]),
+	python: Object.freeze([
+		PYTHON_COMPRESSED_PACKAGE_SHA256,
+		PYTHON_PACKAGE_SHA256,
+		PYTHON_PACKAGE_MANIFEST_SHA256,
+		PYTHON_RUNTIME_FILES_ARCHIVE_SHA256
+	]),
+	javascript: Object.freeze([TYPESCRIPT_ASSET_SHA256, QUICKJS_ASSET_SHA256]),
+	typescript: Object.freeze([TYPESCRIPT_ASSET_SHA256, QUICKJS_ASSET_SHA256]),
+	go: Object.freeze([
+		GO_COMPRESSED_PACKAGE_SHA256,
+		GO_PACKAGE_SHA256,
+		GO_PACKAGE_MANIFEST_SHA256,
+		GO_COMPRESSED_STANDARD_LIBRARY_SHA256,
+		GO_STANDARD_LIBRARY_SHA256,
+		GO_COMPILER_SHA256,
+		GO_LINKER_SHA256
+	])
+});
+/** Exact executable/compiler content used by cache keys and cost calibration. */
+function toolchainContentIdentity(language) {
+	if (language === "java") return [
+		JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256,
+		JAVA_COMPILER_PACKAGE_SHA256,
+		JAVA_COMPILER_SHA256,
+		JAVA_COMPILE_CLASSLIB_SHA256,
+		JAVA_RUNTIME_CLASSLIB_SHA256
+	].join(".");
+	if (!isBuiltinLanguage(language)) throw new Error(`WASM-OJ has no built-in toolchain for '${language}'.`);
+	return TOOLCHAIN_CONTENT_SHA256[language].join(".");
+}
+function freezeToolchain(definition) {
+	return Object.freeze({
+		...definition,
+		compilerPackages: Object.freeze([...definition.compilerPackages]),
+		targets: Object.freeze([...definition.targets])
+	});
+}
+var TOOLCHAINS = Object.freeze({
+	c: freezeToolchain({
+		language: "c",
+		label: "Clang 22",
+		artifact: "wasm",
+		compilerPackages: [CLANG_PACKAGE],
+		targets: ["wasip1", "wasix"],
+		version: CLANG_VERSION,
+		note: "Native wasip1 module via Clang and LLD; directly executable by WASI and WASIX runtimes."
+	}),
+	cpp: freezeToolchain({
+		language: "cpp",
+		label: "Clang++ 22 (C++20)",
+		artifact: "wasm",
+		compilerPackages: [CLANG_PACKAGE],
+		targets: ["wasip1", "wasix"],
+		version: CLANG_VERSION,
+		note: "C++20/libc++ wasip1 module; directly executable by WASI and WASIX runtimes."
+	}),
+	rust: freezeToolchain({
+		language: "rust",
+		label: `Rust ${RUST_VERSION}`,
+		artifact: "wasm",
+		compilerPackages: [`rustc@${RUST_VERSION}#sha256:${RUST_PACKAGE_SHA256}`],
+		targets: ["wasip1"],
+		version: RUST_VERSION,
+		note: "Real rustc, its matching standard library, and a fresh deterministic wasm-ld stage execute as one pinned WebC under Wasmer."
+	}),
+	python: freezeToolchain({
+		language: "python",
+		label: `CPython ${PYTHON_VERSION}`,
+		artifact: "runtime-bundle",
+		compilerPackages: [PYTHON_PACKAGE],
+		runtimePackage: PYTHON_PACKAGE,
+		targets: ["wasip1"],
+		version: PYTHON_VERSION,
+		note: "Byte-compiled project bundled with the source-built CPython wasm32-wasip1 interpreter and standard library."
+	}),
+	javascript: freezeToolchain({
+		language: "javascript",
+		label: "QuickJS-ng",
+		artifact: "runtime-bundle",
+		compilerPackages: [`typescript@${TYPESCRIPT_VERSION}-wasi`],
+		runtimePackage: QUICKJS_PACKAGE,
+		targets: ["wasip1"],
+		version: QUICKJS_VERSION,
+		note: "JavaScript checked by TypeScript/WASI, then executed by the bundled QuickJS-ng/WASI runtime."
+	}),
+	typescript: freezeToolchain({
+		language: "typescript",
+		label: "TypeScript + QuickJS-ng",
+		artifact: "runtime-bundle",
+		compilerPackages: [`typescript@${TYPESCRIPT_VERSION}-wasi`],
+		runtimePackage: QUICKJS_PACKAGE,
+		targets: ["wasip1"],
+		version: TYPESCRIPT_VERSION,
+		note: "The native TypeScript compiler and QuickJS-ng runtime both execute as local WASI modules."
+	}),
+	go: freezeToolchain({
+		language: "go",
+		label: `Go ${GO_VERSION}`,
+		artifact: "wasm",
+		compilerPackages: [`go@${GO_VERSION}#sha256:${GO_PACKAGE_SHA256}`],
+		targets: ["wasip1"],
+		version: GO_VERSION,
+		note: "The standard Go compiler, linker, and pinned wasip1 standard library execute locally as one WebC under Wasmer."
+	})
+});
+function toolchainPackageIdentities(language) {
+	if (language === "java") return [JAVA_COMPILER_PACKAGE];
+	if (!isBuiltinLanguage(language)) throw new Error(`WASM-OJ has no built-in toolchain for '${language}'.`);
+	const toolchain = TOOLCHAINS[language];
+	return [.../* @__PURE__ */ new Set([...toolchain.compilerPackages, ...toolchain.runtimePackage ? [toolchain.runtimePackage] : []])];
+}
+//#endregion
+export { PYTHON_PACKAGE_ASSET_PATH as A, TYPESCRIPT_VERSION as B, JAVA_COMPILE_CLASSLIB_ASSET_PATH as C, JAVA_VERSION as D, JAVA_RUNTIME_CLASSLIB_SHA256 as E, RUST_PACKAGE_MANIFEST_ASSET_PATH as F, toolchainPackageIdentities as H, RUST_PACKAGE_MANIFEST_SHA256 as I, RUST_PACKAGE_SHA256 as L, QUICKJS_PACKAGE as M, RUST_COMPRESSED_PACKAGE_SHA256 as N, PYTHON_COMPRESSED_PACKAGE_SHA256 as O, RUST_PACKAGE_ASSET_PATH as P, RUST_VERSION as R, JAVA_COMPILER_PACKAGE_SHA256 as S, JAVA_RUNTIME_CLASSLIB_ASSET_PATH as T, toolchainContentIdentity as V, GO_STANDARD_LIBRARY_SHA256 as _, CLANG_PACKAGE_ASSET_PATH as a, JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256 as b, GO_COMPILER_SHA256 as c, GO_LINKER_SHA256 as d, GO_PACKAGE_ASSET_PATH as f, GO_STANDARD_LIBRARY_ASSET_PATH as g, GO_PACKAGE_SHA256 as h, CLANG_LIBCXX_PCH_MANIFEST_SHA256 as i, PYTHON_PACKAGE_SHA256 as j, PYTHON_PACKAGE as k, GO_COMPRESSED_PACKAGE_SHA256 as l, GO_PACKAGE_MANIFEST_SHA256 as m, CLANG_CC1_PINS_SHA256 as n, CLANG_PACKAGE_SHA256 as o, GO_PACKAGE_MANIFEST_ASSET_PATH as p, CLANG_LIBCXX_PCH_MANIFEST_ASSET_PATH as r, CLANG_VERSION as s, CLANG_CC1_PINS_ASSET_PATH as t, GO_COMPRESSED_STANDARD_LIBRARY_SHA256 as u, GO_VERSION as v, JAVA_COMPILE_CLASSLIB_SHA256 as w, JAVA_COMPILER_PACKAGE as x, JAVA_COMPILER_ASSET_PATH as y, TYPESCRIPT_ASSET_PATH as z };

package/dist/go-stage.mjs

@@ -0,0 +1,193 @@
+import { a as decodeGoToolchainManifest, c as goCompileDependencyArguments, d as reachableGoDependencies, f as validateGoStandardLibrary, i as GO_TOOLCHAIN, l as goImportConfig, o as deterministicGoCompilerEnvironment, r as GO_OUTPUT_PATH, s as goCompileArguments, t as GO_ARCHIVE_PATH, u as goLinkArguments } from "./chunks/go-toolchain-Dbt-lp2L.js";
+import { writeFileSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { gunzipSync } from "node:zlib";
+//#region src/server/go-stage.mjs
+var COMPILER_MEMORY_LIMIT_BYTES = 536870912;
+var COMPILER_OUTPUT_LIMIT_BYTES = 33554432;
+var COMPILER_RESPONSE_LIMIT_BYTES = 268435456;
+var temporaryDirectory;
+try {
+	const encoded = JSON.parse(await readStdin());
+	const verifiedToolchain = encoded.verifiedToolchain === true;
+	let [packageBytes, manifest, standardLibrary] = await Promise.all([
+		loadGoPackage(requiredToolchainAsset(encoded, GO_TOOLCHAIN.packageAsset), verifiedToolchain),
+		loadGoManifest(requiredToolchainAsset(encoded, GO_TOOLCHAIN.manifestAsset), verifiedToolchain),
+		loadGoStandardLibrary(requiredToolchainAsset(encoded, GO_TOOLCHAIN.standardLibraryAsset), verifiedToolchain)
+	]);
+	validateGoStandardLibrary(standardLibrary, manifest.packages);
+	temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), "wasm-oj-go-toolchain-"));
+	const packagePath = path.join(temporaryDirectory, "go.webc");
+	const standardLibraryPath = path.join(temporaryDirectory, "go-stdlib.wasmojgo");
+	await writeFile(packagePath, packageBytes, {
+		flag: "wx",
+		mode: 384
+	});
+	await writeFile(standardLibraryPath, standardLibrary, {
+		flag: "wx",
+		mode: 384
+	});
+	packageBytes = void 0;
+	standardLibrary = void 0;
+	const sourceFiles = Object.fromEntries(encoded.request.files.map((file) => [`/work/${file.path}`, file.content]));
+	const dependencySourceFiles = Object.fromEntries((encoded.request.dependencyFiles ?? []).map((file) => [`/work/${file.path}`, file.content]));
+	const dependencies = reachableGoDependencies(encoded.request.files, encoded.request.dependencies ?? [], manifest.packages);
+	const importPackages = [...manifest.packages, ...dependencies.map((item) => ({
+		importPath: item.importPath,
+		archivePath: item.archivePath
+	}))];
+	const sharedFilesBase64 = Object.fromEntries(Object.entries({
+		...sourceFiles,
+		...dependencySourceFiles,
+		"/go/VERSION": `go${GO_TOOLCHAIN.version}\n`,
+		"/work/importcfg": goImportConfig(importPackages, false),
+		"/work/importcfg.link": goImportConfig(importPackages, true)
+	}).map(([guestPath, contents]) => [guestPath, Buffer.from(contents).toString("base64")]));
+	const common = {
+		env: deterministicGoCompilerEnvironment(),
+		stdinBase64: "",
+		filesBase64: {},
+		cwd: "/work",
+		outputLimitBytes: COMPILER_OUTPUT_LIMIT_BYTES
+	};
+	const results = (await runCompiler(encoded.compilerExecutable, {
+		schema: encoded.compileBatchSchema,
+		packagePath,
+		memoryLimitBytes: COMPILER_MEMORY_LIMIT_BYTES,
+		sharedFilesArchivePath: standardLibraryPath,
+		sharedFilesBase64,
+		requests: [
+			...dependencies.map((dependency) => ({
+				...common,
+				command: "go-compile",
+				args: goCompileDependencyArguments(dependency, encoded.request.optimization),
+				outputPaths: [dependency.archivePath]
+			})),
+			{
+				...common,
+				command: "go-compile",
+				args: goCompileArguments(encoded.request.files, encoded.request.optimization),
+				outputPaths: [GO_ARCHIVE_PATH]
+			},
+			{
+				...common,
+				command: "go-link",
+				args: goLinkArguments(encoded.request.optimization),
+				outputPaths: [GO_OUTPUT_PATH]
+			}
+		]
+	})).responses.flatMap((response) => response.result ? [response.result] : []);
+	const stdout = results.map((result) => Buffer.from(result.stdoutBase64, "base64").toString("utf8")).join("");
+	const stderr = results.map((result) => Buffer.from(result.stderrBase64, "base64").toString("utf8")).join("");
+	const linked = results.at(-1);
+	const wasmBase64 = linked?.code === 0 ? linked.outputFilesBase64?.[GO_OUTPUT_PATH] : void 0;
+	writeResult({
+		success: results.length === dependencies.length + 2 && results.every((result) => result.code === 0) && typeof wasmBase64 === "string",
+		wasmBase64,
+		stdout,
+		stderr
+	});
+} catch (error) {
+	writeResult(void 0, error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+} finally {
+	if (temporaryDirectory) await rm(temporaryDirectory, {
+		recursive: true,
+		force: true
+	});
+}
+function runCompiler(executable, request) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(executable, [], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		const stdout = [];
+		const stderr = [];
+		let stdoutBytes = 0;
+		let stderrBytes = 0;
+		let failure;
+		const fail = (error) => {
+			failure ??= error;
+			child.kill("SIGKILL");
+		};
+		child.stdout.on("data", (chunk) => {
+			stdoutBytes += chunk.byteLength;
+			if (stdoutBytes > COMPILER_RESPONSE_LIMIT_BYTES) fail(/* @__PURE__ */ new Error(`WASM-OJ compiler response exceeded ${COMPILER_RESPONSE_LIMIT_BYTES} bytes.`));
+			else stdout.push(chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrBytes += chunk.byteLength;
+			if (stderrBytes > COMPILER_OUTPUT_LIMIT_BYTES) fail(/* @__PURE__ */ new Error(`WASM-OJ compiler diagnostics exceeded ${COMPILER_OUTPUT_LIMIT_BYTES} bytes.`));
+			else stderr.push(chunk);
+		});
+		child.on("error", fail);
+		child.stdin.on("error", fail);
+		child.on("close", () => {
+			if (failure) {
+				reject(failure);
+				return;
+			}
+			try {
+				const text = Buffer.concat(stdout).toString("utf8");
+				if (!text) throw new Error(Buffer.concat(stderr).toString("utf8") || "WASM-OJ compiler returned no response.");
+				resolve(JSON.parse(text));
+			} catch (error) {
+				reject(error);
+			}
+		});
+		child.stdin.end(JSON.stringify(request));
+	});
+}
+function writeResult(result, error) {
+	writeFileSync(3, JSON.stringify(result ? {
+		ok: true,
+		result
+	} : {
+		ok: false,
+		error
+	}));
+}
+async function loadGoPackage(file, verifiedToolchain) {
+	const compressed = await readFile(file);
+	if (!verifiedToolchain) verifyDigest(file, compressed, GO_TOOLCHAIN.packageCompressedSha256);
+	const bytes = uint8View(gunzipSync(compressed));
+	if (!verifiedToolchain) verifyDigest("decompressed Go WebC", bytes, GO_TOOLCHAIN.packageSha256);
+	return bytes;
+}
+async function loadGoManifest(file, verifiedToolchain) {
+	const bytes = new Uint8Array(await readFile(file));
+	if (!verifiedToolchain) verifyDigest(file, bytes, GO_TOOLCHAIN.manifestSha256);
+	return decodeGoToolchainManifest(bytes);
+}
+async function loadGoStandardLibrary(file, verifiedToolchain) {
+	const compressed = await readFile(file);
+	if (!verifiedToolchain) verifyDigest(file, compressed, GO_TOOLCHAIN.standardLibraryCompressedSha256);
+	const bytes = uint8View(gunzipSync(compressed));
+	if (!verifiedToolchain) verifyDigest("decompressed Go standard library", bytes, GO_TOOLCHAIN.standardLibrarySha256);
+	return bytes;
+}
+function requiredToolchainAsset(encoded, assetPath) {
+	const file = encoded?.toolchainAssets?.[assetPath];
+	if (typeof file !== "string" || !path.isAbsolute(file)) throw new Error(`The Go compiler stage did not receive absolute asset '${assetPath}'.`);
+	return file;
+}
+function verifyDigest(label, bytes, expected) {
+	const actual = createHash("sha256").update(bytes).digest("hex");
+	if (actual !== expected) throw new Error(`Pinned Go toolchain asset '${label}' has digest ${actual}; expected ${expected}.`);
+}
+function uint8View(bytes) {
+	return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+//#endregion
+export {};