@wasm-oj/server 0.2.1 → 0.2.2

package/dist/rustc-stage.mjs

@@ -1,4 +1,4 @@
-import { a as deterministicRustLinkerEnvironment, c as RUST_FINAL_OUTPUT_PATH, d as instantiateRustLinkerArguments, f as MountedOutputStabilityObserver, i as deterministicRustCompilerEnvironment, l as RUST_LINKER_COMMAND, n as RUST_TOOLCHAIN, o as rustcDependencyArguments, r as decodeRustToolchainManifest, s as rustcObjectArguments, t as RUST_COMPILE_TIMEOUT_MS, u as RUST_OBJECT_PATH } from "./chunks/rust-toolchain-CJ3sMxPE.js";
+import { a as deterministicRustLinkerEnvironment, c as RUST_FINAL_OUTPUT_PATH, d as instantiateRustLinkerArguments, f as MountedOutputStabilityObserver, i as deterministicRustCompilerEnvironment, l as RUST_LINKER_COMMAND, n as RUST_TOOLCHAIN, o as rustcDependencyArguments, r as decodeRustToolchainManifest, s as rustcObjectArguments, t as RUST_COMPILE_TIMEOUT_MS, u as RUST_OBJECT_PATH } from "./chunks/rust-toolchain-CK5h2WT8.js";
 import { writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";

package/dist/server-build-stage.mjs

@@ -1,8 +1,7 @@
-import { A as PYTHON_PACKAGE_ASSET_PATH, B as TYPESCRIPT_VERSION, C as JAVA_COMPILE_CLASSLIB_ASSET_PATH, H as toolchainPackageIdentities, M as QUICKJS_PACKAGE, R as RUST_VERSION, T as JAVA_RUNTIME_CLASSLIB_ASSET_PATH, V as toolchainContentIdentity, a as CLANG_PACKAGE_ASSET_PATH, i as CLANG_LIBCXX_PCH_MANIFEST_SHA256, k as PYTHON_PACKAGE, n as CLANG_CC1_PINS_SHA256, o as CLANG_PACKAGE_SHA256, r as CLANG_LIBCXX_PCH_MANIFEST_ASSET_PATH, s as CLANG_VERSION, t as CLANG_CC1_PINS_ASSET_PATH, v as GO_VERSION, y as JAVA_COMPILER_ASSET_PATH, z as TYPESCRIPT_ASSET_PATH } from "./chunks/toolchains-C6KuA1yM.js";
-import { f as MountedOutputStabilityObserver, n as RUST_TOOLCHAIN, t as RUST_COMPILE_TIMEOUT_MS } from "./chunks/rust-toolchain-CJ3sMxPE.js";
-import { _ as pythonDependencyFiles, g as npmDependencyFiles, h as goDependencyInput, i as GO_TOOLCHAIN, m as cppDependencyInput, n as GO_COMPILE_TIMEOUT_MS, p as assertProjectDependencyEcosystem, v as rustDependencyInput } from "./chunks/go-toolchain-Dbt-lp2L.js";
-import { n as javaMainClass, t as JAVA_COMPILE_TIMEOUT_MS } from "./chunks/java-toolchain-DajoRCHu.js";
-import { t as PYTHON_COMPILE_TIMEOUT_MS } from "./chunks/python-toolchain-Dx834o2A.js";
+import { A as QUICKJS_PACKAGE, B as toolchainPackageIdentities, C as JAVA_COMPILE_CLASSLIB_SHA256, E as JAVA_VERSION, I as RUST_VERSION, L as TYPESCRIPT_ASSET_PATH, O as PYTHON_PACKAGE, R as TYPESCRIPT_VERSION, S as JAVA_COMPILE_CLASSLIB_ASSET_PATH, T as JAVA_RUNTIME_CLASSLIB_SHA256, a as CLANG_PACKAGE_ASSET_PATH, b as JAVA_COMPILER_PACKAGE, i as CLANG_LIBCXX_PCH_MANIFEST_SHA256, n as CLANG_CC1_PINS_SHA256, o as CLANG_PACKAGE_SHA256, r as CLANG_LIBCXX_PCH_MANIFEST_ASSET_PATH, s as CLANG_VERSION, t as CLANG_CC1_PINS_ASSET_PATH, v as GO_VERSION, w as JAVA_RUNTIME_CLASSLIB_ASSET_PATH, x as JAVA_COMPILER_SHA256, y as JAVA_COMPILER_ASSET_PATH, z as toolchainContentIdentity } from "./chunks/toolchains-uz3XbZGI.js";
+import { f as MountedOutputStabilityObserver, n as RUST_TOOLCHAIN, t as RUST_COMPILE_TIMEOUT_MS } from "./chunks/rust-toolchain-CK5h2WT8.js";
+import { _ as pythonDependencyFiles, g as npmDependencyFiles, h as goDependencyInput, i as GO_TOOLCHAIN, m as cppDependencyInput, n as GO_COMPILE_TIMEOUT_MS, p as assertProjectDependencyEcosystem, v as rustDependencyInput } from "./chunks/go-toolchain-DRQSILaC.js";
+import { t as withProcessKeepalive } from "./chunks/process-keepalive-BWLUz55N.js";
 import { constants, writeFileSync } from "node:fs";
 import { deserialize, serialize } from "node:v8";
 import { access, lstat, mkdtemp, open, readFile, rm, writeFile } from "node:fs/promises";
@@ -108,7 +107,7 @@ Object.freeze({
 var decoder$3 = new TextDecoder();
 async function decodeClangPins(bytes) {
 	const digest = await sha256Hex(bytes);
-	if (digest !== "66c4604dccd3f89d8e1472bf4432367d7396cce4a01279b1a1db445f229dba72") throw new Error(`The pinned cc1 manifest drifted from its contract: expected ${CLANG_CC1_PINS_SHA256}, received ${digest}. Regenerate it with scripts/pin-clang-cc1-argv.mjs and update CLANG_CC1_PINS_SHA256.`);
+	if (digest !== "895eee17c63b1112c84adcc4ddbcb38e0c18e53bff15f50a8689b9b82d87b1ff") throw new Error(`The pinned cc1 manifest drifted from its contract: expected ${CLANG_CC1_PINS_SHA256}, received ${digest}. Regenerate it with scripts/pin-clang-cc1-argv.mjs and update CLANG_CC1_PINS_SHA256.`);
 	const parsed = JSON.parse(decoder$3.decode(bytes));
 	if (parsed.schema !== WASM_OJ_SCHEMAS.clangPins) throw new Error(`Unsupported cc1 pin schema '${parsed.schema}'.`);
 	for (const key of [
@@ -562,8 +561,8 @@ Object.freeze({
 });
 new TextEncoder();
 Object.freeze({
-	runtimeCoreWasmSha256: "e4c7fca566ff5ba66931e0cf11cacbf37610d35c36d5f3ee97d719468a2f6466",
-	runtimeSourceRootSha256: "0140ecc6ed5060eae465e73db6822bcde32295734517de84929a537e3c45e663",
+	runtimeCoreWasmSha256: "1e297ad276694e9fb8a23afdc6ccc0b2ae56a223ced19d5cae26fe4661daa11e",
+	runtimeSourceRootSha256: "27c52cb1887aa8a7e0d8a238514fc8881cf86c68267e2a1691f110423692e2b6",
 	wasmerNativeVersion: "7.2.1",
 	wasmerSdkVersion: "0.10.0",
 	wasmerSdkWasmSha256: "49a6646209f5ab5e7c737eac33407d87d9a9959ac83e5ecaaab9261b2323589e",
@@ -574,7 +573,7 @@ Object.freeze({
 * Release verification independently checks the component bytes before this
 * identity is admitted into a calibrated release.
 */
-var WASM_OJ_RUNTIME_IDENTITY_SHA256 = "59414bf4fa5191d0942c0e190c69d32f3a2251461b8eb41aaba32598baab1d5f";
+var WASM_OJ_RUNTIME_IDENTITY_SHA256 = "d3e44cafdc1c17a7e6bd4591ef04ec8161af805a519b5bbff437b15e5accd442";
 //#endregion
 //#region src/core/cost-profile.ts
 function coordinates(language, target, optimization) {
@@ -623,34 +622,6 @@ function parseClangDiagnostics(output) {
 	});
 	return diagnostics;
 }
-function parsePythonDiagnostics(output) {
-	const diagnostics = [];
-	const lines = output.split(/\r?\n/);
-	for (let index = 0; index < lines.length; index += 1) {
-		const location = lines[index].match(/^\s*File "([^"]+)", line (\d+)/);
-		if (!location) continue;
-		let column = 1;
-		let message = "Python compilation failed";
-		const caret = (lines[index + 2] ?? "").indexOf("^");
-		if (caret >= 0) column = caret + 1;
-		for (let cursor = index + 1; cursor < Math.min(lines.length, index + 6); cursor += 1) {
-			const error = lines[cursor].match(/^([A-Za-z]+(?:Error|Exception)):\s*(.+)$/);
-			if (error) {
-				message = `${error[1]}: ${error[2]}`;
-				break;
-			}
-		}
-		diagnostics.push({
-			file: projectPath(location[1]),
-			line: Number(location[2]),
-			column,
-			severity: "error",
-			message,
-			source: "python"
-		});
-	}
-	return diagnostics;
-}
 function parseTypeScriptDiagnostics(output) {
 	const diagnostics = [];
 	const pattern = /^(.*?)\((\d+),(\d+)\):\s+(error|warning|message)\s+TS(\d+):\s+(.+)$/gm;
@@ -774,14 +745,14 @@ var WASM_OJ_LIBCXX_PCH_HEADER = `#pragma once
 var decoder$1 = new TextDecoder();
 async function decodeLibcxxPchManifest(bytes) {
 	const digest = await sha256Hex(bytes);
-	if (digest !== "d126c99e951a7302d4ea2b66da4ed64d3d74e9d319d562518867c8d8c97a06b8") throw new Error(`Pinned libc++ PCH manifest digest mismatch: expected ${CLANG_LIBCXX_PCH_MANIFEST_SHA256}, received ${digest}.`);
+	if (digest !== "9bbe41d77c786f1c36169369c909268530b05726e1581683f6edd9a2983eebd0") throw new Error(`Pinned libc++ PCH manifest digest mismatch: expected ${CLANG_LIBCXX_PCH_MANIFEST_SHA256}, received ${digest}.`);
 	let value;
 	try {
 		value = JSON.parse(decoder$1.decode(bytes));
 	} catch (error) {
 		throw new Error("Pinned libc++ PCH manifest is not valid JSON.", { cause: error });
 	}
-	if (!isRecord(value) || value.schema !== WASM_OJ_SCHEMAS.clangLibcxxPch || value.version !== "22.0.0-git20542-10" || value.clangPackageSha256 !== "21ded33b9c6d4e1aaad5528c940bdaf6c3e84be77ea8f522f018ca7289a2a224" || value.clangPinsSha256 !== "66c4604dccd3f89d8e1472bf4432367d7396cce4a01279b1a1db445f229dba72" || value.header !== WASM_OJ_LIBCXX_PCH_HEADER || !isRecord(value.profiles)) throw new Error("Pinned libc++ PCH manifest is not admitted by the active Clang toolchain contract.");
+	if (!isRecord(value) || value.schema !== WASM_OJ_SCHEMAS.clangLibcxxPch || value.version !== "22.0.0-git20542-10" || value.clangPackageSha256 !== "21ded33b9c6d4e1aaad5528c940bdaf6c3e84be77ea8f522f018ca7289a2a224" || value.clangPinsSha256 !== "895eee17c63b1112c84adcc4ddbcb38e0c18e53bff15f50a8689b9b82d87b1ff" || value.header !== WASM_OJ_LIBCXX_PCH_HEADER || !isRecord(value.profiles)) throw new Error("Pinned libc++ PCH manifest is not admitted by the active Clang toolchain contract.");
 	if (value.headerSha256 !== await sha256Hex(WASM_OJ_LIBCXX_PCH_HEADER)) throw new Error("Pinned libc++ PCH header digest does not match its canonical source.");
 	const manifestProfiles = value.profiles;
 	const profiles = Object.fromEntries(await Promise.all(["cpp-debug", "cpp-release"].map(async (profile) => {
@@ -925,6 +896,7 @@ if hasattr(_os, "getrandom"):
 
 _entry = _sys.argv[1]
 _sys.argv = [_entry, *_sys.argv[2:]]
+_sys.path[0] = _os.path.dirname(_entry)
 _runpy.run_path(_entry, run_name="__main__")
 `;
 //#endregion
@@ -1445,6 +1417,9 @@ function canonicalRuntimeBundleFiles(files) {
 	return canonicalFileRecord(files);
 }
 //#endregion
+//#region src/runtime/quickjs/stdlib.generated.ts
+var QUICKJS_BUFFER_DECLARATION = "declare module \"buffer\" {\nexport class Buffer extends Uint8Array {\n    length: number\n    write(string: string, offset?: number, length?: number, encoding?: string): number;\n    toString(encoding?: string, start?: number, end?: number): string;\n    toJSON(): { type: 'Buffer', data: any[] };\n    equals(otherBuffer: Buffer): boolean;\n    compare(otherBuffer: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;\n    copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;\n    slice(start?: number, end?: number): Buffer;\n    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;\n    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;\n    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;\n    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;\n    readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;\n    readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;\n    readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;\n    readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;\n    readUInt8(offset: number, noAssert?: boolean): number;\n    readUInt16LE(offset: number, noAssert?: boolean): number;\n    readUInt16BE(offset: number, noAssert?: boolean): number;\n    readUInt32LE(offset: number, noAssert?: boolean): number;\n    readUInt32BE(offset: number, noAssert?: boolean): number;\n    readBigUInt64LE(offset: number): BigInt;\n    readBigUInt64BE(offset: number): BigInt;\n    readInt8(offset: number, noAssert?: boolean): number;\n    readInt16LE(offset: number, noAssert?: boolean): number;\n    readInt16BE(offset: number, noAssert?: boolean): number;\n    readInt32LE(offset: number, noAssert?: boolean): number;\n    readInt32BE(offset: number, noAssert?: boolean): number;\n    readBigInt64LE(offset: number): BigInt;\n    readBigInt64BE(offset: number): BigInt;\n    readFloatLE(offset: number, noAssert?: boolean): number;\n    readFloatBE(offset: number, noAssert?: boolean): number;\n    readDoubleLE(offset: number, noAssert?: boolean): number;\n    readDoubleBE(offset: number, noAssert?: boolean): number;\n    reverse(): this;\n    swap16(): Buffer;\n    swap32(): Buffer;\n    swap64(): Buffer;\n    writeUInt8(value: number, offset: number, noAssert?: boolean): number;\n    writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;\n    writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;\n    writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;\n    writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;\n    writeBigUInt64LE(value: number, offset: number): BigInt;\n    writeBigUInt64BE(value: number, offset: number): BigInt;\n    writeInt8(value: number, offset: number, noAssert?: boolean): number;\n    writeInt16LE(value: number, offset: number, noAssert?: boolean): number;\n    writeInt16BE(value: number, offset: number, noAssert?: boolean): number;\n    writeInt32LE(value: number, offset: number, noAssert?: boolean): number;\n    writeInt32BE(value: number, offset: number, noAssert?: boolean): number;\n    writeBigInt64LE(value: number, offset: number): BigInt;\n    writeBigInt64BE(value: number, offset: number): BigInt;\n    writeFloatLE(value: number, offset: number, noAssert?: boolean): number;\n    writeFloatBE(value: number, offset: number, noAssert?: boolean): number;\n    writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;\n    writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;\n    fill(value: any, offset?: number, end?: number): this;\n    indexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;\n    lastIndexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;\n    includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;\n\n    /**\n     * Allocates a new buffer containing the given {str}.\n     *\n     * @param str String to store in buffer.\n     * @param encoding encoding to use, optional.  Default is 'utf8'\n     */\n    constructor (str: string, encoding?: string);\n    /**\n     * Allocates a new buffer of {size} octets.\n     *\n     * @param size count of octets to allocate.\n     */\n    constructor (size: number);\n    /**\n     * Allocates a new buffer containing the given {array} of octets.\n     *\n     * @param array The octets to store.\n     */\n    constructor (array: Uint8Array);\n    /**\n     * Produces a Buffer backed by the same allocated memory as\n     * the given {ArrayBuffer}.\n     *\n     *\n     * @param arrayBuffer The ArrayBuffer with which to share memory.\n     */\n    constructor (arrayBuffer: ArrayBuffer);\n    /**\n     * Allocates a new buffer containing the given {array} of octets.\n     *\n     * @param array The octets to store.\n     */\n    constructor (array: any[]);\n    /**\n     * Copies the passed {buffer} data onto a new {Buffer} instance.\n     *\n     * @param buffer The buffer to copy.\n     */\n    constructor (buffer: Buffer);\n    prototype: Buffer;\n    /**\n     * Allocates a new Buffer using an {array} of octets.\n     *\n     * @param array\n     */\n    static from(array: any[]): Buffer;\n    /**\n     * When passed a reference to the .buffer property of a TypedArray instance,\n     * the newly created Buffer will share the same allocated memory as the TypedArray.\n     * The optional {byteOffset} and {length} arguments specify a memory range\n     * within the {arrayBuffer} that will be shared by the Buffer.\n     *\n     * @param arrayBuffer The .buffer property of a TypedArray or a new ArrayBuffer()\n     * @param byteOffset\n     * @param length\n     */\n    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer;\n    /**\n     * Copies the passed {buffer} data onto a new Buffer instance.\n     *\n     * @param buffer\n     */\n    static from(buffer: Buffer | Uint8Array): Buffer;\n    /**\n     * Creates a new Buffer containing the given JavaScript string {str}.\n     * If provided, the {encoding} parameter identifies the character encoding.\n     * If not provided, {encoding} defaults to 'utf8'.\n     *\n     * @param str\n     */\n    static from(str: string, encoding?: string): Buffer;\n    /**\n     * Returns true if {obj} is a Buffer\n     *\n     * @param obj object to test.\n     */\n    static isBuffer(obj: any): obj is Buffer;\n    /**\n     * Returns true if {encoding} is a valid encoding argument.\n     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'\n     *\n     * @param encoding string to test.\n     */\n    static isEncoding(encoding: string): boolean;\n    /**\n     * Gives the actual byte length of a string. encoding defaults to 'utf8'.\n     * This is not the same as String.prototype.length since that returns the number of characters in a string.\n     *\n     * @param string string to test.\n     * @param encoding encoding used to evaluate (defaults to 'utf8')\n     */\n    static byteLength(string: string, encoding?: string): number;\n    /**\n     * Returns a buffer which is the result of concatenating all the buffers in the list together.\n     *\n     * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.\n     * If the list has exactly one item, then the first item of the list is returned.\n     * If the list has more than one item, then a new Buffer is created.\n     *\n     * @param list An array of Buffer objects to concatenate\n     * @param totalLength Total length of the buffers when concatenated.\n     *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.\n     */\n    static concat(list: Uint8Array[], totalLength?: number): Buffer;\n    /**\n     * The same as buf1.compare(buf2).\n     */\n    static compare(buf1: Uint8Array, buf2: Uint8Array): number;\n    /**\n     * Allocates a new buffer of {size} octets.\n     *\n     * @param size count of octets to allocate.\n     * @param fill if specified, buffer will be initialized by calling buf.fill(fill).\n     *    If parameter is omitted, buffer will be filled with zeros.\n     * @param encoding encoding used for call to buf.fill while initializing\n     */\n    static alloc(size: number, fill?: string | Buffer | number, encoding?: string): Buffer;\n    /**\n     * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents\n     * of the newly created Buffer are unknown and may contain sensitive data.\n     *\n     * @param size count of octets to allocate\n     */\n    static allocUnsafe(size: number): Buffer;\n    /**\n     * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents\n     * of the newly created Buffer are unknown and may contain sensitive data.\n     *\n     * @param size count of octets to allocate\n     */\n    static allocUnsafeSlow(size: number): Buffer;\n}\n\nconst buffer: { Buffer: typeof Buffer }; export default buffer;\n}\n";
+//#endregion
 //#region src/core/quickjs-runtime.ts
 var QUICKJS_STD_MODULE_DECLARATION = String.raw`
 declare module "std" {
@@ -1453,9 +1428,80 @@ declare module "std" {
     in: { readAsString(): string };
     out: { puts(value: string): void };
   };
-  export = std;
+  export default std;
+  export const err: typeof std.err;
+  export const out: typeof std.out;
+  const input: typeof std.in;
+  export { input as in };
 }
 `;
+var QUICKJS_NODE_MODULE_DECLARATION = QUICKJS_BUFFER_DECLARATION + String.raw`
+type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
+type Buffer = import("buffer").Buffer;
+declare const Buffer: typeof import("buffer").Buffer;
+interface NodeReadable extends AsyncIterable<Buffer | string> {
+  on(event: "data", callback: (chunk: Buffer | string) => void): this;
+  on(event: "readable" | "end" | "close", callback: () => void): this;
+  on(event: "error", callback: (error: Error) => void): this;
+  setEncoding(encoding: BufferEncoding): this;
+  read(size?: number): Buffer | string | null;
+  resume(): this;
+  pause(): this;
+  pipe<T extends NodeWritable>(destination: T, options?: { end?: boolean }): T;
+}
+interface NodeWritable {
+  write(value: string | Uint8Array, callback?: (error?: Error | null) => void): boolean;
+  write(value: string | Uint8Array, encoding?: BufferEncoding, callback?: (error?: Error | null) => void): boolean;
+  end(value?: string | Uint8Array): this;
+  on(event: "error", callback: (error: Error) => void): this;
+  on(event: "drain" | "finish" | "close", callback: () => void): this;
+}
+interface NodeProcess {
+  stdin: NodeReadable;
+  stdout: NodeWritable;
+  stderr: NodeWritable;
+  env: Record<string, string | undefined>;
+  argv: string[];
+  nextTick(callback: (...args: any[]) => void, ...args: any[]): void;
+}
+declare const process: NodeProcess;
+declare module "fs" {
+  export function readFileSync(file: number | string, options?: null | { encoding?: null }): Buffer;
+  export function readFileSync(file: number | string, options: BufferEncoding | { encoding: BufferEncoding }): string;
+  export function readSync(fd: number, buffer: ArrayBufferView, offset?: number, length?: number, position?: number | null): number;
+  export function writeFileSync(file: number | string, data: string | ArrayBufferView, options?: BufferEncoding | { encoding?: BufferEncoding }): void;
+  export function writeSync(fd: number, buffer: ArrayBufferView, offset?: number, length?: number, position?: number | null): number;
+  export function writeSync(fd: number, value: string, position?: number | null, encoding?: BufferEncoding): number;
+  const fs: { readFileSync: typeof readFileSync; readSync: typeof readSync; writeFileSync: typeof writeFileSync; writeSync: typeof writeSync };
+  export default fs;
+}
+declare module "node:fs" { export * from "fs"; export { default } from "fs"; }
+declare module "process" { const value: NodeProcess; export default value; export const stdin: NodeReadable; export const stdout: NodeWritable; export const stderr: NodeWritable; export const nextTick: NodeProcess["nextTick"]; export const env: NodeProcess["env"]; export const argv: string[]; }
+declare module "node:process" { export * from "process"; export { default } from "process"; }
+declare module "node:buffer" { export * from "buffer"; export { default } from "buffer"; }
+declare module "readline" {
+  export class Interface implements AsyncIterable<string> {
+    constructor(options: { input: NodeReadable; output?: NodeWritable; terminal?: boolean; crlfDelay?: number });
+    on(event: "line", callback: (line: string) => void): this;
+    on(event: "close" | "pause" | "resume", callback: () => void): this;
+    on(event: "error", callback: (error: Error) => void): this;
+    close(): void;
+    pause(): this;
+    resume(): this;
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+  }
+  export function createInterface(options: { input: NodeReadable; output?: NodeWritable; terminal?: boolean; crlfDelay?: number }): Interface;
+  const readline: { createInterface: typeof createInterface; Interface: typeof Interface };
+  export default readline;
+}
+declare module "node:readline" { export * from "readline"; export { default } from "readline"; }
+`;
+var QUICKJS_COMMONJS_DECLARATION = String.raw`
+declare function require(name: "fs" | "node:fs"): typeof import("fs");
+declare function require(name: "readline" | "node:readline"): typeof import("readline");
+declare function require(name: "buffer" | "node:buffer"): typeof import("buffer");
+declare function require(name: "process" | "node:process"): NodeProcess;
+`;
 //#endregion
 //#region src/compiler/language-driver.ts
 /** Internal registry for WASM-OJ's built-in compiler pipelines. */
@@ -1577,50 +1623,29 @@ function sumFileSize(files) {
 async function buildPython(project, cacheKey, requestId) {
 	const started = performance.now();
 	const dependencies = pythonDependencyFiles(project);
-	const compilerFiles = [...project.files, ...dependencies.sourceFiles];
-	const pythonFiles = compilerFiles.filter((file) => file.path.endsWith(".py"));
-	progress(requestId, "compiling", `Byte-compiling ${pythonFiles.length} Python file${pythonFiles.length === 1 ? "" : "s"}`, .55);
-	const frontend = await requireHost().compilePython({ files: compilerFiles });
-	if (!frontend.success) return {
-		success: false,
-		diagnostics: ensureFailureDiagnostic(frontend.diagnostics, {
-			file: project.config.entry,
-			source: "python",
-			message: frontend.stderr.trim() || "Python byte-compilation failed without a diagnostic."
-		}),
-		stdout: frontend.stdout,
-		stderr: frontend.stderr,
-		cacheHit: false
-	};
+	progress(requestId, "compiling", "Packaging Python sources", .55);
 	const files = Object.fromEntries(project.files.map((file) => [file.path, file.content]));
-	Object.assign(files, dependencies.artifactFiles);
+	Object.assign(files, dependencies);
 	files[PYTHON_RUNNER_PATH] = PYTHON_DETERMINISTIC_RUNNER;
-	for (const file of pythonFiles) {
-		const compiledPath = `build/${file.path.replace(/\.py$/, ".pyc")}`;
-		const bytecode = frontend.bytecode[compiledPath];
-		if (!bytecode) throw new Error(`Python stage omitted '${compiledPath}'.`);
-		files[compiledPath] = bytecode;
-	}
-	const entry = `build/${project.config.entry.replace(/\.py$/, ".pyc")}`;
+	const entry = project.config.entry;
 	const manifest = createRuntimeBundleManifest(project, PYTHON_PACKAGE, "python", entry);
 	files["wasm-oj.manifest.json"] = manifest;
 	const bundleFiles = canonicalRuntimeBundleFiles(files);
-	const artifact = {
-		kind: "runtime-bundle",
-		...createArtifactBase(project, cacheKey, started, sumFileSize(bundleFiles), toolchainPackageIdentities("python")),
-		name: `${project.name}.python-${project.config.target}.json`,
-		runtimePackage: PYTHON_PACKAGE,
-		command: "python",
-		entry,
-		files: bundleFiles,
-		manifest
-	};
 	return {
 		success: true,
-		diagnostics: frontend.diagnostics,
-		artifact,
-		stdout: frontend.stdout,
-		stderr: frontend.stderr,
+		diagnostics: [],
+		artifact: {
+			kind: "runtime-bundle",
+			...createArtifactBase(project, cacheKey, started, sumFileSize(bundleFiles), toolchainPackageIdentities("python")),
+			name: `${project.name}.python-${project.config.target}.json`,
+			runtimePackage: PYTHON_PACKAGE,
+			command: "python",
+			entry,
+			files: bundleFiles,
+			manifest
+		},
+		stdout: "",
+		stderr: "",
 		cacheHit: false
 	};
 }
@@ -1677,7 +1702,7 @@ async function buildJava(project, cacheKey, requestId) {
 		stderr: "",
 		cacheHit: false
 	};
-	progress(requestId, "compiling", `Compiling Java ${javaMainClass(entry.path, entry.content)}`, .3);
+	progress(requestId, "compiling", `Compiling Java ${entry.path}`, .3);
 	const compiled = await requireHost().compileJava({
 		entry: project.config.entry,
 		files: project.files,
@@ -1732,9 +1757,8 @@ async function transpileScriptProject(project, requestId) {
 		files: {
 			...Object.fromEntries(project.files.map((file) => [`/project/${file.path}`, file.content])),
 			...Object.fromEntries(Object.entries(dependencyFiles).filter(([, contents]) => typeof contents === "string").map(([path, contents]) => [`/project/${path}`, contents])),
-			[declarationPath]: QUICKJS_STD_MODULE_DECLARATION
+			[declarationPath]: QUICKJS_STD_MODULE_DECLARATION + QUICKJS_NODE_MODULE_DECLARATION + QUICKJS_COMMONJS_DECLARATION
 		},
-		javascript: project.config.language === "javascript",
 		sources: [
 			declarationPath,
 			...scriptFiles.map((file) => `/project/${file.path}`),
@@ -1776,40 +1800,54 @@ async function buildScript(project, cacheKey, requestId) {
 		stderr: "",
 		cacheHit: false
 	};
-	progress(requestId, "compiling", `Compiling ${project.config.language === "typescript" ? "TypeScript" : "JavaScript"} with TypeScript/WASI`, .5);
-	const { files, output, response } = await transpileScriptProject(project, requestId);
-	const diagnostics = parseTypeScriptDiagnostics(response?.diagnostics ?? "");
-	const emittedOutputsPresent = emittedSourceFiles(project).every((file) => Object.hasOwn(files, emittedScriptPath(file.path)));
-	if (!output.ok || !response || response.status !== 0 || !emittedOutputsPresent || diagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
-		success: false,
-		diagnostics: ensureFailureDiagnostic(diagnostics, {
-			file: project.config.entry,
-			source: "typescript",
-			message: output.stderr.trim() || response?.diagnostics.trim() || `TypeScript 7.0.2 did not return every compiled output.`
-		}),
-		stdout: "",
-		stderr: output.stderr,
-		cacheHit: false
-	};
+	let files;
+	let diagnostics = [];
+	let stderr = "";
+	if (project.config.language === "javascript") {
+		progress(requestId, "compiling", "Preparing JavaScript modules", .5);
+		files = {
+			...Object.fromEntries(emittedSourceFiles(project).map((file) => [file.path, file.content])),
+			...npmDependencyFiles(project)
+		};
+	} else {
+		progress(requestId, "compiling", "Compiling TypeScript with TypeScript/WASI", .5);
+		const transpiled = await transpileScriptProject(project, requestId);
+		files = transpiled.files;
+		stderr = transpiled.output.stderr;
+		diagnostics = parseTypeScriptDiagnostics(transpiled.response?.diagnostics ?? "");
+		const emittedOutputsPresent = emittedSourceFiles(project).every((file) => Object.hasOwn(files, emittedScriptPath(file.path)));
+		if (!transpiled.output.ok || !transpiled.response || transpiled.response.status !== 0 || !emittedOutputsPresent || diagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+			success: false,
+			diagnostics: ensureFailureDiagnostic(diagnostics, {
+				file: project.config.entry,
+				source: "typescript",
+				message: stderr.trim() || transpiled.response?.diagnostics.trim() || `TypeScript 7.0.2 did not return every compiled output.`
+			}),
+			stdout: "",
+			stderr,
+			cacheHit: false
+		};
+	}
 	const entry = emittedScriptPath(project.config.entry);
 	const manifest = createRuntimeBundleManifest(project, QUICKJS_PACKAGE, "qjs", entry);
 	files["wasm-oj.manifest.json"] = manifest;
 	const bundleFiles = canonicalRuntimeBundleFiles(files);
+	const artifact = {
+		kind: "runtime-bundle",
+		...createArtifactBase(project, cacheKey, started, sumFileSize(bundleFiles), toolchainPackageIdentities(project.config.language)),
+		name: `${project.name}.${project.config.language === "typescript" ? "typescript" : "javascript"}-${project.config.target}.json`,
+		runtimePackage: QUICKJS_PACKAGE,
+		command: "qjs",
+		entry,
+		files: bundleFiles,
+		manifest
+	};
 	return {
 		success: true,
 		diagnostics,
-		artifact: {
-			kind: "runtime-bundle",
-			...createArtifactBase(project, cacheKey, started, sumFileSize(bundleFiles), toolchainPackageIdentities(project.config.language)),
-			name: `${project.name}.${project.config.language === "typescript" ? "typescript" : "javascript"}-${project.config.target}.json`,
-			runtimePackage: QUICKJS_PACKAGE,
-			command: "qjs",
-			entry,
-			files: bundleFiles,
-			manifest
-		},
+		artifact,
 		stdout: "",
-		stderr: output.stderr,
+		stderr,
 		cacheHit: false
 	};
 }
@@ -1880,6 +1918,19 @@ function clearCompilerHostCaches() {
 	typescriptCompilerBytes = void 0;
 }
 //#endregion
+//#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,
+	compilerSha256: JAVA_COMPILER_SHA256,
+	compileClasslibAsset: JAVA_COMPILE_CLASSLIB_ASSET_PATH,
+	compileClasslibSha256: JAVA_COMPILE_CLASSLIB_SHA256,
+	runtimeClasslibAsset: JAVA_RUNTIME_CLASSLIB_ASSET_PATH,
+	runtimeClasslibSha256: JAVA_RUNTIME_CLASSLIB_SHA256
+});
+//#endregion
 //#region src/server/wasmer-runtime.ts
 var initialization;
 async function initializeServerWasmerSdk() {
@@ -2045,7 +2096,6 @@ function sameRecord(expected, actual) {
 var SERVER_STAGE_SCRIPTS = Object.freeze([
 	"server-build-stage.mjs",
 	"server-runner-stage.mjs",
-	"python-stage.mjs",
 	"rustc-stage.mjs",
 	"go-stage.mjs",
 	"java-stage.mjs"
@@ -2137,7 +2187,6 @@ var ServerCompiler = class {
 				loadToolchainAsset: (assetPath) => this.loadToolchainAsset(assetPath),
 				loadToolchainFile: (assetPath) => this.loadToolchainFile(assetPath),
 				compileRust: (request) => this.compileRust(request),
-				compilePython: (request) => this.compilePython(request),
 				compileGo: (request) => this.compileGo(request),
 				compileJava: (request) => this.compileJava(request),
 				progress: (_requestId, phase, label, value) => {
@@ -2339,14 +2388,6 @@ var ServerCompiler = class {
 			wasm: result.wasmBase64 ? new Uint8Array(Buffer.from(result.wasmBase64, "base64")) : void 0
 		};
 	}
-	async compilePython(request) {
-		const result = await this.runCompilerStage("python-stage.mjs", { request }, PYTHON_COMPILE_TIMEOUT_MS, [PYTHON_PACKAGE_ASSET_PATH]);
-		return {
-			...result,
-			bytecode: Object.fromEntries(Object.entries(result.bytecodeBase64).map(([path, base64]) => [path, new Uint8Array(Buffer.from(base64, "base64"))])),
-			diagnostics: parsePythonDiagnostics(`${result.stderr}\n${result.stdout}`)
-		};
-	}
 	async compileGo(request) {
 		const result = await this.runCompilerStage("go-stage.mjs", {
 			compilerExecutable: this.compilerExecutable,
@@ -2512,21 +2553,6 @@ async function buildServerProjectInProcess(options, project, cacheKey, onProgres
 	}
 }
 //#endregion
-//#region src/server/process-keepalive.mjs
-/**
-* Keep Node alive while a promise is backed only by a foreign async runtime.
-* Top-level await does not itself create a referenced libuv handle, so Node can
-* otherwise exit with code 13 while a Wasmer SDK operation is still pending.
-*/
-async function withProcessKeepalive(promise) {
-	const keepalive = setInterval(() => void 0, 6e4);
-	try {
-		return await promise;
-	} finally {
-		clearInterval(keepalive);
-	}
-}
-//#endregion
 //#region src/server/server-build-stage.mjs
 var SERVER_BUILD_REQUEST_LIMIT_BYTES = 805306368;
 try {

package/dist/server-runner-stage.mjs

@@ -1,4 +1,5 @@
-import { O as PYTHON_COMPRESSED_PACKAGE_SHA256, j as PYTHON_PACKAGE_SHA256, k as PYTHON_PACKAGE } from "./chunks/toolchains-C6KuA1yM.js";
+import { D as PYTHON_COMPRESSED_PACKAGE_SHA256, O as PYTHON_PACKAGE, k as PYTHON_PACKAGE_SHA256 } from "./chunks/toolchains-uz3XbZGI.js";
+import { t as withProcessKeepalive } from "./chunks/process-keepalive-BWLUz55N.js";
 import { writeFileSync } from "node:fs";
 import { serialize } from "node:v8";
 import { readFile } from "node:fs/promises";
@@ -17,14 +18,14 @@ var response;
 var exitCode = 0;
 try {
 	const input = parseInput(JSON.parse(await readStdin()));
-	await init({ log: "warn" });
+	await withProcessKeepalive(init({ log: "warn" }));
 	runtime = new Runtime({ registry: null });
 	const packagePath = input.toolchainAsset;
 	const compressed = await readFile(packagePath);
 	if (!input.verifiedToolchain) verifyDigest(packagePath, compressed, PYTHON_COMPRESSED_PACKAGE_SHA256);
 	const expanded = uint8View(gunzipSync(compressed));
 	if (!input.verifiedToolchain) verifyDigest(packagePath, expanded, PYTHON_PACKAGE_SHA256);
-	pkg = await Wasmer.fromFile(expanded, runtime);
+	pkg = await withProcessKeepalive(Wasmer.fromFile(expanded, runtime));
 	const commandMap = pkg.commands;
 	commands = uniqueCommands(commandMap);
 	const command = commandMap[input.request.command];
@@ -34,14 +35,15 @@ try {
 		bytes = command.binary().slice();
 		if (!WebAssembly.validate(bytes)) throw new Error(`Package '${input.request.packageSpecifier}' command '${input.request.command}' returned invalid WebAssembly.`);
 	} else {
-		const output = await (await command.run({
+		const instance = await withProcessKeepalive(command.run({
 			args: input.request.args,
 			env: {
 				PYTHONHOME: "/usr/local",
 				PYTHONHASHSEED: "0",
 				PYTHONDONTWRITEBYTECODE: "1"
 			}
-		})).wait();
+		}));
+		const output = await withProcessKeepalive(instance.wait());
 		if (!output.ok) throw new Error(`Unable to export runtime files from ${input.request.packageSpecifier}: exit ${output.code}: ${boundedText(output.stderr)}`);
 		bytes = output.stdoutBytes.slice();
 	}