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

package/dist/client.mjs

@@ -1,4 +1,4 @@
-import { a as escapeHtml, l as mergeConfig, p as resolveLanguage, u as resolveCodePlayOptions } from "./payload.mjs";
+import { a as escapeHtml, d as mergeConfig, f as resolveCodePlayOptions, h as resolveLanguage } from "./payload.mjs";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -336,10 +336,115 @@ function buildJavaScriptSandboxDocument(code, messageId) {
 })();
 <\/script></body></html>`;
 }
+function buildJavaScriptWorkerSource() {
+	return `
+(function () {
+  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";
+  }
+  self.onmessage = function (event) {
+    var data = event.data || {};
+    if (!data.id) return;
+    var stdout = [];
+    var stderr = [];
+    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", '"use strict";\\n' + String(data.code || ""));
+      var value = run(consoleLike);
+      self.postMessage({
+        id: data.id,
+        stdout: stdout,
+        stderr: stderr,
+        value: value === undefined ? undefined : String(value)
+      });
+    } catch (error) {
+      var message = error && error.message ? String(error.message) : String(error);
+      self.postMessage({ id: data.id, stdout: stdout, stderr: stderr, error: message });
+    }
+  };
+})();
+`;
+}
 function applySandboxStreams(stdio, message) {
 	for (const text of message.stdout ?? []) stdio.push("stdout", text);
 	for (const text of message.stderr ?? []) stdio.push("stderr", text);
 }
+const WORKER_UNAVAILABLE_CODE = "ERR_SCRIPT_WORKER_UNAVAILABLE";
+function workerUnavailableError(error) {
+	const message = error instanceof Error && error.message ? error.message : "JavaScript worker sandbox is unavailable.";
+	return Object.assign(new Error(message), { code: WORKER_UNAVAILABLE_CODE });
+}
+function isSandboxWorkerUnavailable(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === WORKER_UNAVAILABLE_CODE);
+}
+function canUseSandboxWorker() {
+	return typeof Worker !== "undefined" && typeof Blob !== "undefined" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function" && typeof URL.revokeObjectURL === "function";
+}
+async function executeInSandboxWorker(code, timeoutMs, stdio, signal) {
+	if (!canUseSandboxWorker()) throw workerUnavailableError(/* @__PURE__ */ new Error("JavaScript worker sandbox needs Worker, Blob, and object URLs."));
+	if (signal?.aborted) throw abortError();
+	const messageId = `ox-code-play-${Math.random().toString(36).slice(2)}`;
+	const url = URL.createObjectURL(new Blob([buildJavaScriptWorkerSource()], { type: "text/javascript" }));
+	let worker;
+	try {
+		worker = new Worker(url);
+	} catch (error) {
+		URL.revokeObjectURL(url);
+		throw workerUnavailableError(error);
+	}
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			worker.onmessage = null;
+			worker.onerror = null;
+			worker.terminate();
+			URL.revokeObjectURL(url);
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(abortError());
+		};
+		const onMessage = (event) => {
+			if (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 onError = (event) => {
+			cleanup();
+			reject(workerUnavailableError(new Error(event.message || "JavaScript worker sandbox failed.")));
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			reject(Object.assign(/* @__PURE__ */ new Error("JavaScript execution timed out."), { code: "ERR_SCRIPT_EXECUTION_TIMEOUT" }));
+		}, timeoutMs);
+		worker.onmessage = onMessage;
+		worker.onerror = onError;
+		signal?.addEventListener("abort", onAbort, { once: true });
+		worker.postMessage({
+			id: messageId,
+			code
+		});
+	});
+}
 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();
@@ -391,24 +496,23 @@ 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"
-	} };
+	const runtime = currentJavaScriptRuntime();
+	let executedRuntime = runtime;
 	try {
-		const value = await executeScript(request.code, request.timeoutMs, stdio, request.signal);
+		const result = await executeScriptWithRuntime(request.code, request.timeoutMs, stdio, request.signal, runtime);
+		executedRuntime = result.runtime;
 		tracker.stop();
 		return {
 			status: "ok",
 			stdio: stdio.snapshot(),
 			diagnostics: [],
-			provenance,
+			provenance: { execute: javascriptRuntimeProvenance(executedRuntime) },
 			timing: tracker.report(),
-			value: value === void 0 ? void 0 : String(value)
+			value: result.value === void 0 ? void 0 : String(result.value)
 		};
 	} catch (error) {
 		if (isAbortError(error) || request.signal?.aborted) throw error;
+		executedRuntime = executionRuntimeFromError(error) ?? executedRuntime;
 		tracker.stop();
 		const diagnostic = toDiagnostic(error);
 		stdio.push("stderr", `${diagnostic.message}\n`);
@@ -416,12 +520,30 @@ async function runJavaScript(request) {
 			status: isTimeout(error) ? "timeout" : "error",
 			stdio: stdio.snapshot(),
 			diagnostics: [diagnostic],
-			provenance,
+			provenance: { execute: javascriptRuntimeProvenance(executedRuntime) },
 			timing: tracker.report()
 		};
 	}
 }
-async function executeScript(code, timeoutMs, stdio, signal) {
+async function executeScriptWithRuntime(code, timeoutMs, stdio, signal, runtime = currentJavaScriptRuntime()) {
+	try {
+		return {
+			value: await executeScriptInRuntime(code, timeoutMs, stdio, signal, runtime),
+			runtime
+		};
+	} catch (error) {
+		if (runtime === "worker" && isSandboxWorkerUnavailable(error) && typeof document !== "undefined") try {
+			return {
+				value: await executeScriptInRuntime(code, timeoutMs, stdio, signal, "iframe"),
+				runtime: "iframe"
+			};
+		} catch (fallbackError) {
+			throw withExecutionRuntime(fallbackError, "iframe");
+		}
+		throw withExecutionRuntime(error, runtime);
+	}
+}
+async function executeScriptInRuntime(code, timeoutMs, stdio, signal, runtime) {
 	const consoleLike = {
 		log: (...args) => stdio.push("stdout", formatConsoleArgs(args)),
 		info: (...args) => stdio.push("stdout", formatConsoleArgs(args)),
@@ -429,7 +551,7 @@ async function executeScript(code, timeoutMs, stdio, signal) {
 		error: (...args) => stdio.push("stderr", formatConsoleArgs(args))
 	};
 	if (signal?.aborted) throw abortError();
-	if (javascriptExecuteRuntime(hasNodeVm(), typeof document !== "undefined") === "vm") {
+	if (runtime === "vm") {
 		const vm = await import("node:vm");
 		const context = vm.createContext({ console: consoleLike });
 		return vm.runInContext(code, context, {
@@ -437,12 +559,45 @@ async function executeScript(code, timeoutMs, stdio, signal) {
 			displayErrors: true
 		});
 	}
+	if (runtime === "worker") return executeInSandboxWorker(code, timeoutMs, stdio, signal);
 	return executeInSandboxIframe(code, timeoutMs, stdio, signal);
 }
-function javascriptExecuteRuntime(hasVm, hasDocument) {
+function currentJavaScriptRuntime() {
+	return javascriptExecuteRuntime(hasNodeVm(), canUseSandboxWorker(), typeof document !== "undefined");
+}
+function javascriptExecuteRuntime(hasVm, hasWorker, hasDocument) {
 	if (hasVm) return "vm";
+	if (hasWorker) return "worker";
 	if (hasDocument) return "iframe";
-	throw new Error("JavaScript execute needs node:vm or a document for the sandbox iframe.");
+	throw new Error("JavaScript execute needs node:vm, a browser worker sandbox, or a document for the sandbox iframe.");
+}
+function javascriptRuntimeProvenance(runtime) {
+	if (runtime === "vm") return {
+		host: "local",
+		runtime: "node:vm",
+		sandbox: "vm"
+	};
+	if (runtime === "worker") return {
+		host: "local",
+		runtime: "web-worker",
+		sandbox: "worker"
+	};
+	return {
+		host: "local",
+		runtime: "iframe",
+		sandbox: "srcdoc"
+	};
+}
+function withExecutionRuntime(error, runtime) {
+	if (error instanceof Error) return Object.assign(error, { executionRuntime: runtime });
+	if (isErrorLike(error)) return Object.assign(error, { executionRuntime: runtime });
+	return Object.assign(new Error(String(error)), { executionRuntime: runtime });
+}
+function executionRuntimeFromError(error) {
+	if (error && typeof error === "object" && "executionRuntime" in error && isJavaScriptExecutionRuntime(error.executionRuntime)) return error.executionRuntime;
+}
+function isJavaScriptExecutionRuntime(value) {
+	return value === "vm" || value === "worker" || value === "iframe";
 }
 function isTimeout(error) {
 	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT");
@@ -709,9 +864,12 @@ async function runTypeScript(request) {
 	const stdio = new StdioBuffer(tracker.startedAt);
 	tracker.start("compile", "Strip types");
 	const javascript = stripTypeScript(request.code);
+	const runtime = currentJavaScriptRuntime();
+	let executedRuntime = runtime;
 	tracker.start("execute", "Execute");
 	try {
-		const value = await executeScript(javascript, request.timeoutMs, stdio, request.signal);
+		const result = await executeScriptWithRuntime(javascript, request.timeoutMs, stdio, request.signal, runtime);
+		executedRuntime = result.runtime;
 		tracker.stop();
 		return {
 			status: "ok",
@@ -722,14 +880,10 @@ async function runTypeScript(request) {
 					host: "local",
 					runtime: "strip-types"
 				},
-				execute: {
-					host: "local",
-					runtime: hasNodeVm() ? "node:vm" : "iframe",
-					sandbox: hasNodeVm() ? "vm" : "srcdoc"
-				}
+				execute: javascriptRuntimeProvenance(executedRuntime)
 			},
 			timing: tracker.report(),
-			value: value === void 0 ? void 0 : String(value)
+			value: result.value === void 0 ? void 0 : String(result.value)
 		};
 	} catch (error) {
 		if (isAbortError(error) || request.signal?.aborted) throw error;
@@ -749,11 +903,7 @@ async function runTypeScript(request) {
 					host: "local",
 					runtime: "strip-types"
 				},
-				execute: {
-					host: "local",
-					runtime: hasNodeVm() ? "node:vm" : "iframe",
-					sandbox: hasNodeVm() ? "vm" : "srcdoc"
-				}
+				execute: javascriptRuntimeProvenance(executedRuntime)
 			},
 			timing: tracker.report()
 		};
@@ -926,9 +1076,12 @@ function errorMessage(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.";
+	if (isOfflineError(error)) return "The executor is offline or unreachable from this page (for example, CORS). Set endpoints to a host that allows browser POST, or use the Vite dev proxy.";
 	return message;
 }
+function transportFailureStatus(error) {
+	return isOfflineError(error) ? "offline" : "error";
+}
 function errorResult(message, source = "code-play", status = "error") {
 	return withStdioText({
 		status,
@@ -942,6 +1095,14 @@ function errorResult(message, source = "code-play", status = "error") {
 		timing: emptyTiming()
 	});
 }
+function isOfflineError(error) {
+	const message = errorMessage(error);
+	const name = error && typeof error === "object" && "name" in error ? String(error.name) : void 0;
+	const typeError = error instanceof TypeError || name === "TypeError";
+	if (name === "MissingTransportError") return true;
+	if (typeError && /failed to fetch|networkerror|load failed|network request failed/i.test(message)) return true;
+	return /\boffline\b|no code play transport|network request failed/i.test(message);
+}
 //#endregion
 //#region src/session.ts
 var CodePlaySession = class {
@@ -961,6 +1122,7 @@ var CodePlaySession = class {
 	timeoutMs;
 	transport;
 	endpoints;
+	project;
 	loadTypeScript;
 	listeners = /* @__PURE__ */ new Map();
 	abort;
@@ -972,6 +1134,7 @@ var CodePlaySession = class {
 		this.timeoutMs = input.timeoutMs;
 		this.transport = input.transport;
 		this.endpoints = input.endpoints;
+		this.project = input.project;
 		this.loadTypeScript = input.loadTypeScript;
 	}
 	on(event, listener) {
@@ -1012,6 +1175,7 @@ var CodePlaySession = class {
 			transport: this.transport,
 			loadTypeScript: this.loadTypeScript,
 			endpoints: this.endpoints,
+			project: this.project,
 			signal
 		};
 		try {
@@ -1019,7 +1183,7 @@ var CodePlaySession = class {
 			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)));
+			return this.finish(errorResult(friendlyTransportMessage(error), "code-play", transportFailureStatus(error)));
 		}
 	}
 	finish(result) {