npm - @ox-content/code-play - Versions diffs - 3.0.0-alpha.1 - Mend

@ox-content/code-play 3.0.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/dist/client.mjs ADDED Viewed

@@ -0,0 +1,1071 @@
+import { a as escapeHtml, l as mergeConfig, p as resolveLanguage, u as resolveCodePlayOptions } from "./payload.mjs";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/timing.ts
+var PhaseTracker = class {
+	startedAt;
+	phases = [];
+	current;
+	constructor(now = nowMs) {
+		this.now = now;
+		this.startedAt = now();
+	}
+	now;
+	start(id, label) {
+		this.stop();
+		this.current = {
+			id,
+			label,
+			startMs: this.now() - this.startedAt
+		};
+	}
+	stop() {
+		if (!this.current) return;
+		const durationMs = Math.max(0, this.now() - this.startedAt - this.current.startMs);
+		this.phases.push({
+			id: this.current.id,
+			label: this.current.label,
+			startMs: this.current.startMs,
+			durationMs
+		});
+		this.current = void 0;
+	}
+	report() {
+		this.stop();
+		return {
+			totalMs: Math.max(0, this.now() - this.startedAt),
+			phases: this.phases.slice()
+		};
+	}
+};
+function nowMs() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function emptyTiming() {
+	return {
+		totalMs: 0,
+		phases: []
+	};
+}
+//#endregion
+//#region src/framework.ts
+const RUNTIMES = {
+	vue: {
+		specifier: "vue",
+		cdn: "https://esm.sh/vue@3"
+	},
+	react: {
+		specifier: "react",
+		cdn: "https://esm.sh/react@19"
+	},
+	svelte: {
+		specifier: "svelte",
+		cdn: "https://esm.sh/svelte@5"
+	},
+	solid: {
+		specifier: "solid-js",
+		cdn: "https://esm.sh/solid-js@1"
+	}
+};
+async function runFramework(request) {
+	const tracker = new PhaseTracker();
+	tracker.start("compile", "Compile preview");
+	const framework = request.definition.framework ?? "vue";
+	const html = buildPreviewDocument(framework, request.code);
+	tracker.stop();
+	return {
+		status: "ok",
+		stdio: [],
+		diagnostics: [],
+		provenance: {
+			compile: {
+				host: "local",
+				runtime: `${framework}-preview`
+			},
+			execute: {
+				host: "iframe",
+				runtime: framework,
+				sandbox: "srcdoc"
+			}
+		},
+		timing: tracker.report(),
+		preview: {
+			kind: "html",
+			html
+		}
+	};
+}
+function buildPreviewDocument(framework, code) {
+	const runtime = RUNTIMES[framework];
+	return `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>${escapeHtml(framework)} preview</title>
+  <script type="importmap">${JSON.stringify({ imports: { [runtime.specifier]: runtime.cdn } })}<\/script>
+  <style>html,body{margin:0;padding:1rem;font:14px/1.5 system-ui,sans-serif;}</style>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module">
+${indentPreview(code)}
+  <\/script>
+</body>
+</html>
+`;
+}
+function indentPreview(code) {
+	return code.replace(/<\/script/gi, "<\\/script").split("\n").map((line) => `    ${line}`).join("\n");
+}
+//#endregion
+//#region src/stdio.ts
+var StdioBuffer = class {
+	events = [];
+	startedAt;
+	constructor(startedAt = 0) {
+		this.startedAt = startedAt;
+	}
+	push(stream, text, timestampMs = elapsed(this.startedAt)) {
+		const event = {
+			stream,
+			text,
+			timestampMs
+		};
+		this.events.push(event);
+		return event;
+	}
+	snapshot() {
+		return this.events.slice();
+	}
+};
+function joinStream(events, stream) {
+	return events.filter((event) => event.stream === stream).map((event) => event.text).join("");
+}
+function selectStream(events, stream) {
+	return events.filter((event) => event.stream === stream);
+}
+function withStdioText(result) {
+	return {
+		...result,
+		stdout: joinStream(result.stdio, "stdout"),
+		stderr: joinStream(result.stdio, "stderr")
+	};
+}
+function formatConsoleArgs(args) {
+	return `${args.map(formatConsoleArg).join(" ")}\n`;
+}
+function formatConsoleArg(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return Object.prototype.toString.call(value);
+	}
+}
+function elapsed(startedAt) {
+	const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+	return Math.max(0, now - startedAt);
+}
+//#endregion
+//#region src/go.ts
+async function runGo(request, mode) {
+	const tracker = new PhaseTracker();
+	const stdio = new StdioBuffer(tracker.startedAt);
+	const params = new URLSearchParams({
+		version: "2",
+		body: request.code,
+		withVet: request.config.withVet === false ? "false" : "true"
+	});
+	tracker.start(mode === "typecheck" ? "typecheck" : "compile", mode === "typecheck" ? "Typecheck" : "Compile");
+	const response = await request.transport.request({
+		url: request.endpoints.go,
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: params.toString(),
+		signal: request.signal
+	});
+	tracker.start("collect", "Collect output");
+	const parsed = parseResponse$2(response.text);
+	const diagnostics = [...parseGoErrors(parsed.Errors ?? "", "go"), ...parseGoErrors(parsed.VetErrors ?? "", "vet")];
+	for (const event of parsed.Events ?? []) {
+		const stream = event.Kind === "stderr" ? "stderr" : "stdout";
+		stdio.push(stream, event.Message ?? "");
+	}
+	if (parsed.Errors) stdio.push("stderr", parsed.Errors);
+	tracker.stop();
+	return {
+		status: diagnostics.some((item) => item.severity === "error") || !response.ok ? "error" : "ok",
+		stdio: stdio.snapshot(),
+		diagnostics,
+		provenance: {
+			compile: {
+				host: hostFromUrl$3(request.endpoints.go),
+				runtime: "go"
+			},
+			execute: mode === "execute" ? {
+				host: hostFromUrl$3(request.endpoints.go),
+				runtime: "go-playground",
+				sandbox: "playground"
+			} : void 0
+		},
+		timing: tracker.report()
+	};
+}
+function parseResponse$2(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { Errors: text };
+	}
+}
+function parseGoErrors(output, source) {
+	if (!output.trim()) return [];
+	return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+		const match = /^(?:prog\.go:)?(\d+)(?::(\d+))?:\s*(.*)$/.exec(line);
+		return {
+			message: match?.[3] ?? line,
+			severity: "error",
+			line: match?.[1] ? Number(match[1]) : void 0,
+			column: match?.[2] ? Number(match[2]) : void 0,
+			source
+		};
+	});
+}
+function hostFromUrl$3(url) {
+	try {
+		return new URL(url, "https://code-play.local").host || url;
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region src/transport.ts
+function createFetchTransport(fetchImpl = fetch) {
+	return { async request(input) {
+		const response = await fetchImpl(input.url, {
+			method: input.method,
+			headers: input.headers,
+			body: input.body,
+			signal: input.signal
+		});
+		return {
+			ok: response.ok,
+			status: response.status,
+			text: await response.text()
+		};
+	} };
+}
+function createMemoryTransport(handler) {
+	return { async request(input) {
+		if (input.signal?.aborted) throw abortError();
+		return handler(input);
+	} };
+}
+var MissingTransportError = class extends Error {
+	constructor(host) {
+		super(`No Code Play transport is configured for ${host}.`);
+		this.name = "MissingTransportError";
+	}
+};
+function abortError() {
+	const error = /* @__PURE__ */ new Error("The Code Play run was cancelled.");
+	error.name = "AbortError";
+	return error;
+}
+function isAbortError(error) {
+	return Boolean(error && typeof error === "object" && "name" in error && error.name === "AbortError");
+}
+function createUnavailableTransport() {
+	return { request(input) {
+		if (input.signal?.aborted) return Promise.reject(abortError());
+		return Promise.reject(new MissingTransportError(input.url));
+	} };
+}
+//#endregion
+//#region src/javascript-sandbox.ts
+const JS_SANDBOX_FLAGS = "allow-scripts";
+function embedJson(value) {
+	return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function buildJavaScriptSandboxDocument(code, messageId) {
+	return `<!doctype html><html><head><meta charset="utf-8"></head><body><script>
+(function () {
+  var id = ${embedJson(messageId)};
+  var stdout = [];
+  var stderr = [];
+  function format(args) {
+    return Array.prototype.map.call(args, function (value) {
+      if (typeof value === "string") return value;
+      if (value === undefined) return "undefined";
+      if (value === null) return "null";
+      try { return JSON.stringify(value); } catch (error) { return String(value); }
+    }).join(" ") + "\\n";
+  }
+  var consoleLike = {
+    log: function () { stdout.push(format(arguments)); },
+    info: function () { stdout.push(format(arguments)); },
+    warn: function () { stderr.push(format(arguments)); },
+    error: function () { stderr.push(format(arguments)); }
+  };
+  try {
+    var run = new Function("console", ${embedJson(`"use strict";\n${code}`)});
+    var value = run(consoleLike);
+    parent.postMessage({
+      id: id,
+      stdout: stdout,
+      stderr: stderr,
+      value: value === undefined ? undefined : String(value)
+    }, "*");
+  } catch (error) {
+    var message = error && error.message ? String(error.message) : String(error);
+    parent.postMessage({ id: id, stdout: stdout, stderr: stderr, error: message }, "*");
+  }
+})();
+<\/script></body></html>`;
+}
+function applySandboxStreams(stdio, message) {
+	for (const text of message.stdout ?? []) stdio.push("stdout", text);
+	for (const text of message.stderr ?? []) stdio.push("stderr", text);
+}
+async function executeInSandboxIframe(code, timeoutMs, stdio, signal) {
+	if (typeof document === "undefined" || typeof window === "undefined") throw new Error("JavaScript sandbox iframe needs a document.");
+	if (signal?.aborted) throw abortError();
+	const messageId = `ox-code-play-${Math.random().toString(36).slice(2)}`;
+	return new Promise((resolve, reject) => {
+		const frame = document.createElement("iframe");
+		frame.setAttribute("sandbox", JS_SANDBOX_FLAGS);
+		frame.setAttribute("title", "Code Play JavaScript sandbox");
+		frame.hidden = true;
+		const cleanup = () => {
+			window.clearTimeout(timer);
+			window.removeEventListener("message", onMessage);
+			signal?.removeEventListener("abort", onAbort);
+			frame.remove();
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(abortError());
+		};
+		const onMessage = (event) => {
+			if (event.source !== frame.contentWindow || event.data?.id !== messageId) return;
+			cleanup();
+			applySandboxStreams(stdio, event.data);
+			if (event.data.error) {
+				reject(new Error(event.data.error));
+				return;
+			}
+			resolve(event.data.value);
+		};
+		const timer = window.setTimeout(() => {
+			cleanup();
+			reject(Object.assign(/* @__PURE__ */ new Error("JavaScript execution timed out."), { code: "ERR_SCRIPT_EXECUTION_TIMEOUT" }));
+		}, timeoutMs);
+		window.addEventListener("message", onMessage);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		frame.srcdoc = buildJavaScriptSandboxDocument(code, messageId);
+		document.body.append(frame);
+	});
+}
+//#endregion
+//#region src/runtime-host.ts
+/** True when the current isolate can load `node:vm`. */
+function hasNodeVm() {
+	return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
+//#endregion
+//#region src/javascript.ts
+async function runJavaScript(request) {
+	const tracker = new PhaseTracker();
+	tracker.start("execute", "Execute");
+	const stdio = new StdioBuffer(tracker.startedAt);
+	const provenance = { execute: {
+		host: "local",
+		runtime: hasNodeVm() ? "node:vm" : "iframe",
+		sandbox: hasNodeVm() ? "vm" : "srcdoc"
+	} };
+	try {
+		const value = await executeScript(request.code, request.timeoutMs, stdio, request.signal);
+		tracker.stop();
+		return {
+			status: "ok",
+			stdio: stdio.snapshot(),
+			diagnostics: [],
+			provenance,
+			timing: tracker.report(),
+			value: value === void 0 ? void 0 : String(value)
+		};
+	} catch (error) {
+		if (isAbortError(error) || request.signal?.aborted) throw error;
+		tracker.stop();
+		const diagnostic = toDiagnostic(error);
+		stdio.push("stderr", `${diagnostic.message}\n`);
+		return {
+			status: isTimeout(error) ? "timeout" : "error",
+			stdio: stdio.snapshot(),
+			diagnostics: [diagnostic],
+			provenance,
+			timing: tracker.report()
+		};
+	}
+}
+async function executeScript(code, timeoutMs, stdio, signal) {
+	const consoleLike = {
+		log: (...args) => stdio.push("stdout", formatConsoleArgs(args)),
+		info: (...args) => stdio.push("stdout", formatConsoleArgs(args)),
+		warn: (...args) => stdio.push("stderr", formatConsoleArgs(args)),
+		error: (...args) => stdio.push("stderr", formatConsoleArgs(args))
+	};
+	if (signal?.aborted) throw abortError();
+	if (javascriptExecuteRuntime(hasNodeVm(), typeof document !== "undefined") === "vm") {
+		const vm = await import("node:vm");
+		const context = vm.createContext({ console: consoleLike });
+		return vm.runInContext(code, context, {
+			timeout: timeoutMs,
+			displayErrors: true
+		});
+	}
+	return executeInSandboxIframe(code, timeoutMs, stdio, signal);
+}
+function javascriptExecuteRuntime(hasVm, hasDocument) {
+	if (hasVm) return "vm";
+	if (hasDocument) return "iframe";
+	throw new Error("JavaScript execute needs node:vm or a document for the sandbox iframe.");
+}
+function isTimeout(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT");
+}
+function toDiagnostic(error) {
+	if (isErrorLike(error)) return {
+		message: error.message,
+		severity: "error",
+		source: "javascript"
+	};
+	return {
+		message: String(error),
+		severity: "error",
+		source: "javascript"
+	};
+}
+function isErrorLike(error) {
+	return Boolean(error && typeof error === "object" && "message" in error && typeof error.message === "string" && error.message.length > 0);
+}
+//#endregion
+//#region src/remote.ts
+async function runRemote(request) {
+	const tracker = new PhaseTracker();
+	const stdio = new StdioBuffer(tracker.startedAt);
+	const endpoint = request.enabled.endpoint;
+	const language = request.definition.remote?.pistonLanguage ?? request.definition.id;
+	if (!endpoint) {
+		tracker.stop();
+		return {
+			status: "unsupported",
+			stdio: [],
+			diagnostics: [{
+				message: `${request.definition.name} execution needs a configured HTTP executor. Pass languages.${request.definition.id}.endpoint (Piston-compatible).`,
+				severity: "error",
+				source: "code-play"
+			}],
+			provenance: {},
+			timing: tracker.report()
+		};
+	}
+	tracker.start("queue", "Queue");
+	tracker.start("compile", "Compile / execute");
+	const response = await request.transport.request({
+		url: joinEndpoint(endpoint, "execute"),
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			language,
+			version: request.config.version ?? request.definition.remote?.pistonVersion ?? "*",
+			files: [{ content: request.code }]
+		}),
+		signal: request.signal
+	});
+	tracker.start("collect", "Collect output");
+	const parsed = parseResponse$1(response.text);
+	if (parsed.compile?.stdout) stdio.push("stdout", parsed.compile.stdout);
+	if (parsed.compile?.stderr) stdio.push("stderr", parsed.compile.stderr);
+	if (parsed.run?.stdout) stdio.push("stdout", parsed.run.stdout);
+	if (parsed.run?.stderr) stdio.push("stderr", parsed.run.stderr);
+	if (parsed.message && !parsed.run && !parsed.compile) stdio.push("stderr", `${parsed.message}\n`);
+	const compileFailed = (parsed.compile?.code ?? 0) !== 0;
+	const runFailed = (parsed.run?.code ?? 0) !== 0 || Boolean(parsed.run?.signal);
+	const failed = !response.ok || compileFailed || runFailed || Boolean(parsed.message && !parsed.run);
+	tracker.stop();
+	return {
+		status: failed ? "error" : "ok",
+		stdio: stdio.snapshot(),
+		diagnostics: failed ? [{
+			message: parsed.message ?? parsed.run?.stderr ?? parsed.compile?.stderr ?? "Remote execution failed.",
+			severity: "error",
+			source: language
+		}] : [],
+		provenance: {
+			compile: parsed.compile ? {
+				host: hostFromUrl$2(endpoint),
+				runtime: language,
+				sandbox: "piston"
+			} : void 0,
+			execute: {
+				host: hostFromUrl$2(endpoint),
+				runtime: language,
+				sandbox: "piston"
+			}
+		},
+		timing: tracker.report()
+	};
+}
+function parseResponse$1(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { message: text };
+	}
+}
+function joinEndpoint(endpoint, action) {
+	const trimmed = endpoint.replace(/\/+$/, "");
+	return trimmed.endsWith(action) ? trimmed : `${trimmed}/${action}`;
+}
+function hostFromUrl$2(url) {
+	try {
+		return new URL(url, "https://code-play.local").host || url;
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region src/rust.ts
+async function runRust(request, mode) {
+	const tracker = new PhaseTracker();
+	const stdio = new StdioBuffer(tracker.startedAt);
+	const crateType = resolveCrateType(request.code, String(request.config.crateType ?? "auto"));
+	const body = {
+		channel: request.config.channel ?? "stable",
+		mode: request.config.mode ?? "debug",
+		edition: String(request.config.edition ?? "2024"),
+		crateType,
+		tests: false,
+		code: request.code,
+		backtrace: false
+	};
+	tracker.start(mode === "typecheck" ? "typecheck" : "compile", mode === "typecheck" ? "Typecheck" : "Compile");
+	const response = await request.transport.request({
+		url: request.endpoints.rust,
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+		signal: request.signal
+	});
+	tracker.start("collect", "Collect output");
+	const parsed = parseResponse(response.text);
+	const diagnostics = parseRustcDiagnostics(parsed.stderr ?? parsed.error ?? "");
+	if (parsed.stdout) stdio.push("stdout", parsed.stdout);
+	if (parsed.stderr) stdio.push("stderr", parsed.stderr);
+	if (parsed.error && !parsed.stderr) stdio.push("stderr", parsed.error);
+	const success = parsed.success === true && response.ok;
+	const compileFailed = diagnostics.some((item) => item.severity === "error") || !success;
+	tracker.stop();
+	return {
+		status: compileFailed ? "error" : "ok",
+		stdio: stdio.snapshot(),
+		diagnostics,
+		provenance: {
+			compile: {
+				host: hostFromUrl$1(request.endpoints.rust),
+				runtime: "rustc",
+				version: String(request.config.channel ?? "stable"),
+				target: crateType
+			},
+			execute: mode === "execute" ? {
+				host: hostFromUrl$1(request.endpoints.rust),
+				runtime: "rust-playground",
+				sandbox: "playground"
+			} : void 0
+		},
+		timing: tracker.report()
+	};
+}
+function resolveCrateType(code, configured) {
+	if (configured === "bin" || configured === "lib") return configured;
+	return /(?:^|\b)(?:async\s+)?fn\s+main\s*\(/.test(code) ? "bin" : "lib";
+}
+function parseResponse(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return {
+			success: false,
+			error: text
+		};
+	}
+}
+function parseRustcDiagnostics(stderr) {
+	const diagnostics = [];
+	for (const match of stderr.matchAll(/^(error|warning|note)(?:\[([^\]]+)\])?:\s+(.*)$/gm)) {
+		const severity = match[1] === "warning" ? "warning" : match[1] === "note" ? "info" : "error";
+		diagnostics.push({
+			message: match[3] ?? "",
+			severity,
+			source: match[2] ? `rustc ${match[2]}` : "rustc"
+		});
+	}
+	return diagnostics;
+}
+function hostFromUrl$1(url) {
+	try {
+		return new URL(url, "https://code-play.local").host || url;
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region src/strip-typescript.ts
+/**
+* Conservative TypeScript-to-JavaScript stripper for documentation samples.
+* Full checking goes through tsgo; this path only needs to run the snippet.
+*/
+function stripTypeScript(code) {
+	return code.replace(/^\s*import\s+type\s+.*$/gm, "").replace(/^\s*export\s+type\s+\w[\s\S]*?;\s*$/gm, "").replace(/^\s*type\s+\w[\s\S]*?;\s*$/gm, "").replace(/^\s*(?:export\s+)?interface\s+\w[\s\S]*?\{[\s\S]*?\n\}\s*$/gm, "").replace(/\s+as\s+const\b/g, "").replace(/\s+as\s+[^=,;)\n]+/g, "").replace(/\s+satisfies\s+[^=,;)\n]+/g, "").replace(/\)\s*:\s*[^{;=\n]+/g, ")").replace(/([?]?)\s*:\s*[^,)=;{\n]+/g, "$1");
+}
+//#endregion
+//#region src/typescript.ts
+function resolveTypecheckBackend(hasVm, typecheckUrl) {
+	if (typecheckUrl && !hasVm) return "endpoint";
+	if (!hasVm) return "unavailable";
+	return "tsgo";
+}
+async function typecheckTypeScript(request) {
+	const tracker = new PhaseTracker();
+	tracker.start("typecheck", "Typecheck");
+	const backend = resolveTypecheckBackend(hasNodeVm(), request.endpoints.typecheck);
+	if (backend === "endpoint") return typecheckViaEndpoint(request, tracker);
+	if (backend === "unavailable") {
+		tracker.stop();
+		return {
+			status: "unsupported",
+			stdio: [],
+			diagnostics: [{
+				message: "Typecheck needs a reachable endpoints.typecheck. The Vite /__ox-code-play/typecheck proxy exists only during vite dev.",
+				severity: "error",
+				source: "tsgo"
+			}],
+			provenance: { compile: {
+				host: "local",
+				runtime: "tsgo"
+			} },
+			timing: tracker.report()
+		};
+	}
+	try {
+		const diagnostics = await typecheckWithTsgo(request.code, String(request.config.tsgoCommand ?? "tsgo"));
+		tracker.stop();
+		return {
+			status: diagnostics.some((item) => item.severity === "error") ? "error" : "ok",
+			stdio: [],
+			diagnostics,
+			provenance: { compile: {
+				host: "local",
+				runtime: "tsgo"
+			} },
+			timing: tracker.report()
+		};
+	} catch (error) {
+		if (isAbortError(error) || request.signal?.aborted) throw error;
+		tracker.stop();
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			status: message.includes("ENOENT") ? "unsupported" : "error",
+			stdio: [],
+			diagnostics: [{
+				message: message.includes("ENOENT") ? "tsgo is not available. Install @typescript/native-preview or set languages.typescript.config.tsgoCommand." : message,
+				severity: "error",
+				source: "tsgo"
+			}],
+			provenance: { compile: {
+				host: "local",
+				runtime: "tsgo"
+			} },
+			timing: tracker.report()
+		};
+	}
+}
+async function runTypeScript(request) {
+	const tracker = new PhaseTracker();
+	const stdio = new StdioBuffer(tracker.startedAt);
+	tracker.start("compile", "Strip types");
+	const javascript = stripTypeScript(request.code);
+	tracker.start("execute", "Execute");
+	try {
+		const value = await executeScript(javascript, request.timeoutMs, stdio, request.signal);
+		tracker.stop();
+		return {
+			status: "ok",
+			stdio: stdio.snapshot(),
+			diagnostics: [],
+			provenance: {
+				compile: {
+					host: "local",
+					runtime: "strip-types"
+				},
+				execute: {
+					host: "local",
+					runtime: hasNodeVm() ? "node:vm" : "iframe",
+					sandbox: hasNodeVm() ? "vm" : "srcdoc"
+				}
+			},
+			timing: tracker.report(),
+			value: value === void 0 ? void 0 : String(value)
+		};
+	} catch (error) {
+		if (isAbortError(error) || request.signal?.aborted) throw error;
+		tracker.stop();
+		const message = error instanceof Error ? error.message : String(error);
+		stdio.push("stderr", `${message}\n`);
+		return {
+			status: "error",
+			stdio: stdio.snapshot(),
+			diagnostics: [{
+				message,
+				severity: "error",
+				source: "javascript"
+			}],
+			provenance: {
+				compile: {
+					host: "local",
+					runtime: "strip-types"
+				},
+				execute: {
+					host: "local",
+					runtime: hasNodeVm() ? "node:vm" : "iframe",
+					sandbox: hasNodeVm() ? "vm" : "srcdoc"
+				}
+			},
+			timing: tracker.report()
+		};
+	}
+}
+async function typecheckViaEndpoint(request, tracker) {
+	const url = request.endpoints.typecheck ?? "";
+	const response = await request.transport.request({
+		url,
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			language: "typescript",
+			code: request.code,
+			config: request.config
+		}),
+		signal: request.signal
+	});
+	tracker.stop();
+	return adapterResultFromTypecheckResponse(response, url, tracker);
+}
+function typecheckEndpointFailureMessage(status, text) {
+	if (status === 404 || status === 405) return "Typecheck needs a reachable endpoints.typecheck. The Vite /__ox-code-play/typecheck proxy exists only during vite dev.";
+	return text.trim() || "Typecheck endpoint failed.";
+}
+function adapterResultFromTypecheckResponse(response, url, tracker) {
+	if (!response.ok) return {
+		status: "error",
+		stdio: [],
+		diagnostics: [{
+			message: typecheckEndpointFailureMessage(response.status, response.text),
+			severity: "error",
+			source: "tsgo"
+		}],
+		provenance: { compile: {
+			host: hostFromUrl(url),
+			runtime: "tsgo"
+		} },
+		timing: tracker.report()
+	};
+	try {
+		return JSON.parse(response.text);
+	} catch {
+		return {
+			status: "error",
+			stdio: [],
+			diagnostics: [{
+				message: response.text || "Typecheck endpoint failed.",
+				severity: "error",
+				source: "tsgo"
+			}],
+			provenance: { compile: {
+				host: hostFromUrl(url),
+				runtime: "tsgo"
+			} },
+			timing: tracker.report()
+		};
+	}
+}
+async function typecheckWithTsgo(code, command = "tsgo") {
+	const [{ mkdtemp, rm, writeFile }, { tmpdir }, { join }, { execFile }, { promisify }] = await Promise.all([
+		import("node:fs/promises"),
+		import("node:os"),
+		import("node:path"),
+		import("node:child_process"),
+		import("node:util")
+	]);
+	const execFileAsync = promisify(execFile);
+	const dir = await mkdtemp(join(tmpdir(), "ox-code-play-"));
+	const file = join(dir, "snippet.ts");
+	await writeFile(file, code);
+	try {
+		await execFileAsync(command, [
+			"--noEmit",
+			"--pretty",
+			"false",
+			"--strict",
+			file
+		], {
+			cwd: dir,
+			maxBuffer: 1048576
+		});
+		return [];
+	} catch (error) {
+		const output = commandOutput(error);
+		if (error.code === "ENOENT") throw error;
+		return parseTsgoOutput(output);
+	} finally {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function parseTsgoOutput(output) {
+	const diagnostics = [];
+	for (const match of output.matchAll(/^(?:.*[\\/])?snippet\.ts\((\d+),(\d+)\):\s+(error|warning|info)\s+TS\d+:\s+(.*)$/gm)) diagnostics.push({
+		message: match[4] ?? output,
+		severity: match[3] === "warning" ? "warning" : match[3] === "info" ? "info" : "error",
+		line: Number(match[1]),
+		column: Number(match[2]),
+		source: "tsgo"
+	});
+	if (diagnostics.length === 0 && output.trim()) diagnostics.push({
+		message: output.trim(),
+		severity: "error",
+		source: "tsgo"
+	});
+	return diagnostics;
+}
+function commandOutput(error) {
+	if (!error || typeof error !== "object") return String(error);
+	const value = error;
+	return [
+		value.stdout,
+		value.stderr,
+		value.message
+	].filter((part) => typeof part === "string" && part.trim().length > 0).join("\n").trim();
+}
+function hostFromUrl(url) {
+	try {
+		return new URL(url, "https://code-play.local").host || url;
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region src/adapters.ts
+async function executeAdapter(request) {
+	if (!request.enabled.execute) return capabilityDisabled(request, "execute");
+	switch (request.definition.backend) {
+		case "javascript": return runJavaScript(request);
+		case "typescript": return runTypeScript(request);
+		case "framework": return runFramework(request);
+		case "rust-playground": return runRust(request, "execute");
+		case "go-playground": return runGo(request, "execute");
+		case "remote": return runRemote(request);
+		default: return capabilityDisabled(request, "execute");
+	}
+}
+async function typecheckAdapter(request) {
+	if (!request.enabled.typecheck || !request.definition.capabilities.typecheck) return capabilityDisabled(request, "typecheck");
+	switch (request.definition.backend) {
+		case "typescript": return typecheckTypeScript(request);
+		case "rust-playground": return runRust(request, "typecheck");
+		case "go-playground": return runGo(request, "typecheck");
+		default: return capabilityDisabled(request, "typecheck");
+	}
+}
+function capabilityDisabled(request, action) {
+	return {
+		status: "unsupported",
+		stdio: [],
+		diagnostics: [{
+			message: `${request.definition.name} ${action} is not enabled.`,
+			severity: "error",
+			source: "code-play"
+		}],
+		provenance: {},
+		timing: {
+			totalMs: 0,
+			phases: []
+		}
+	};
+}
+//#endregion
+//#region src/result.ts
+function errorMessage(error) {
+	return error instanceof Error && error.message ? error.message : String(error);
+}
+function friendlyTransportMessage(error) {
+	const message = errorMessage(error);
+	if ((error instanceof TypeError || error instanceof Error && error.name === "TypeError") && /failed to fetch|networkerror|load failed|network request failed/i.test(message)) return "The executor could not be reached from this page (often CORS). Set endpoints to a host that allows browser POST, or use the Vite dev proxy.";
+	return message;
+}
+function errorResult(message, source = "code-play", status = "error") {
+	return withStdioText({
+		status,
+		stdio: [],
+		diagnostics: [{
+			message,
+			severity: status === "cancelled" ? "info" : "error",
+			source
+		}],
+		provenance: {},
+		timing: emptyTiming()
+	});
+}
+//#endregion
+//#region src/session.ts
+var CodePlaySession = class {
+	language;
+	code;
+	config;
+	lastResult;
+	/** Last run's concatenated stdout (same as `lastResult.stdout`). */
+	get stdout() {
+		return this.lastResult?.stdout ?? "";
+	}
+	/** Last run's concatenated stderr (same as `lastResult.stderr`). */
+	get stderr() {
+		return this.lastResult?.stderr ?? "";
+	}
+	enabled;
+	timeoutMs;
+	transport;
+	endpoints;
+	loadTypeScript;
+	listeners = /* @__PURE__ */ new Map();
+	abort;
+	constructor(input) {
+		this.language = input.definition;
+		this.enabled = input.enabled;
+		this.code = input.code;
+		this.config = mergeConfig(input.definition.id, input.enabled, input.config);
+		this.timeoutMs = input.timeoutMs;
+		this.transport = input.transport;
+		this.endpoints = input.endpoints;
+		this.loadTypeScript = input.loadTypeScript;
+	}
+	on(event, listener) {
+		const bucket = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+		bucket.add(listener);
+		this.listeners.set(event, bucket);
+		return () => bucket.delete(listener);
+	}
+	setCode(code) {
+		this.code = code;
+	}
+	setConfig(config) {
+		this.config = {
+			...this.config,
+			...config
+		};
+		this.emit("config", this.config);
+	}
+	async run() {
+		return this.dispatch("execute");
+	}
+	async typecheck() {
+		return this.dispatch("typecheck");
+	}
+	cancel() {
+		this.abort?.abort();
+	}
+	async dispatch(action) {
+		this.abort?.abort();
+		this.abort = new AbortController();
+		const { signal } = this.abort;
+		const request = {
+			definition: this.language,
+			enabled: this.enabled,
+			code: this.code,
+			config: this.config,
+			timeoutMs: this.timeoutMs,
+			transport: this.transport,
+			loadTypeScript: this.loadTypeScript,
+			endpoints: this.endpoints,
+			signal
+		};
+		try {
+			const result = withStdioText(action === "typecheck" ? await typecheckAdapter(request) : await executeAdapter(request));
+			return this.finish(result);
+		} catch (error) {
+			if (signal.aborted || isAbortError(error)) return this.finish(errorResult("Run cancelled.", "code-play", "cancelled"));
+			return this.finish(errorResult(friendlyTransportMessage(error)));
+		}
+	}
+	finish(result) {
+		this.lastResult = result;
+		for (const event of result.stdio) this.emit("stdio", event);
+		this.emit("result", result);
+		return result;
+	}
+	emit(event, value) {
+		for (const listener of this.listeners.get(event) ?? []) listener(value);
+	}
+};
+//#endregion
+//#region src/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({ createCodePlay: () => createCodePlay });
+function createCodePlay(options = {}) {
+	const resolved = resolveCodePlayOptions(options);
+	const transport = options.transport ?? defaultTransport();
+	return {
+		options: resolved,
+		hasLanguage(language) {
+			const definition = resolveLanguage(language);
+			return Boolean(definition && resolved.languages.has(definition.id));
+		},
+		createSession(input) {
+			const definition = resolveLanguage(input.language);
+			if (!definition) throw new Error(`Unknown Code Play language: ${input.language}.`);
+			const enabled = resolved.languages.get(definition.id);
+			if (!enabled) throw new Error(`${definition.name} is not enabled. Pass languages.${definition.id}: true to createCodePlay().`);
+			return new CodePlaySession({
+				...input,
+				definition,
+				enabled,
+				timeoutMs: resolved.timeoutMs,
+				transport,
+				endpoints: resolved.endpoints,
+				loadTypeScript: options.loadTypeScript
+			});
+		}
+	};
+}
+function defaultTransport() {
+	if (typeof fetch === "function") return createFetchTransport();
+	return createUnavailableTransport();
+}
+//#endregion
+export { errorResult as a, createMemoryTransport as c, withStdioText as d, PhaseTracker as f, errorMessage as i, joinStream as l, createCodePlay as n, JS_SANDBOX_FLAGS as o, CodePlaySession as r, createFetchTransport as s, client_exports as t, selectStream as u };
+//# sourceMappingURL=client.mjs.map