@plitzi/sdk-server 0.37.2 → 0.37.4

package/dist/modules/functions/sandbox/guest.js

@@ -0,0 +1,660 @@
+//#region src/modules/functions/sandbox/guest.ts
+/**
+* The runtime a space's code finds in an isolate: the web APIs a bare V8 lacks (`Headers`, `Request`, `Response`,
+* `TextEncoder`, `AbortSignal`, timers, `crypto`) and the `ctx` its functions are handed.
+*
+* It is installed by PRINTING this function into the isolate (`installGuest.toString()`), after the prelude that brings
+* `URL`, `atob`, `structuredClone` and `DOMException`. So it may use nothing from outside its own body — no import,
+* no helper beside it — and all it has of the runner is `host`, and the functions in `shared`. Streams are not
+* provided: a body is text or bytes.
+*/
+var installGuest = (scope, host, shared) => {
+	const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+	/**
+	* A refusal: what the code threw to tell whoever asked — a wrong password, a full board — rather than a fault. It is
+	* `ActionRefusal` from `@plitzi/sdk-server/functions`, known here by its name: the bundle carries its own copy of the
+	* class, printed from the platform's (`build.ts`).
+	*/
+	const REFUSAL = "ActionRefusal";
+	const isRefusal = (error) => error instanceof Error && error.name === REFUSAL;
+	const refusal = (message) => Object.assign(new Error(message), { name: REFUSAL });
+	const encodeUtf8 = (text) => {
+		const out = [];
+		for (const char of text) {
+			let code = char.codePointAt(0) ?? 0;
+			if (code >= 55296 && code <= 57343) code = 65533;
+			if (code < 128) out.push(code);
+			else if (code < 2048) out.push(192 | code >> 6, 128 | code & 63);
+			else if (code < 65536) out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+			else out.push(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+		}
+		return new Uint8Array(out);
+	};
+	/** UTF-8, with U+FFFD for every byte that does not belong to a well-formed sequence — what a web `TextDecoder` does. */
+	const decodeUtf8 = (bytes) => {
+		const points = [];
+		let text = "";
+		let index = 0;
+		const continuation = (at) => at < bytes.length && ((bytes[at] ?? 0) & 192) === 128;
+		while (index < bytes.length) {
+			const lead = bytes[index] ?? 0;
+			const length = lead < 128 ? 1 : lead >= 194 && lead < 224 ? 2 : lead >= 224 && lead < 240 ? 3 : lead >= 240 && lead < 245 ? 4 : 0;
+			let code = 65533;
+			let used = 1;
+			if (length === 1) code = lead;
+			else if (length > 1) {
+				let valid = true;
+				let value = lead & 255 >> length + 1;
+				for (let offset = 1; offset < length; offset++) {
+					if (!continuation(index + offset)) {
+						valid = false;
+						used = offset;
+						break;
+					}
+					value = value << 6 | (bytes[index + offset] ?? 0) & 63;
+				}
+				if (valid && value >= (length === 3 ? 2048 : length === 4 ? 65536 : 128) && value <= 1114111 && (value < 55296 || value > 57343)) {
+					code = value;
+					used = length;
+				} else if (valid) used = 1;
+			}
+			points.push(code);
+			index += used;
+			if (points.length >= 4096) {
+				text += String.fromCodePoint(...points);
+				points.length = 0;
+			}
+		}
+		return text + String.fromCodePoint(...points);
+	};
+	const bytesToBase64 = (bytes) => {
+		let binary = "";
+		for (let index = 0; index < bytes.length; index += 32768) binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+		return btoa(binary);
+	};
+	const base64ToBytes = (base64) => {
+		const binary = atob(base64);
+		const bytes = new Uint8Array(binary.length);
+		for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+		return bytes;
+	};
+	const copyBytes = (view) => {
+		const source = view instanceof ArrayBuffer ? new Uint8Array(view) : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+		const bytes = new Uint8Array(source.length);
+		bytes.set(source);
+		return bytes;
+	};
+	class GuestTextEncoder {
+		encoding = "utf-8";
+		encode(text = "") {
+			return encodeUtf8(typeof text === "string" ? text : String(text));
+		}
+	}
+	class GuestTextDecoder {
+		encoding = "utf-8";
+		constructor(label = "utf-8") {
+			if (![
+				"utf-8",
+				"utf8",
+				"unicode-1-1-utf-8"
+			].includes(label.toLowerCase())) throw new RangeError(`This runtime decodes UTF-8 only, not "${label}"`);
+		}
+		decode(input) {
+			if (!input) return "";
+			const text = decodeUtf8(copyBytes(input));
+			return text.startsWith("") ? text.slice(1) : text;
+		}
+	}
+	class GuestEvent {
+		type;
+		constructor(type) {
+			this.type = type;
+		}
+	}
+	class GuestEventTarget {
+		#listeners = /* @__PURE__ */ new Map();
+		addEventListener(type, listener, options) {
+			if (!listener) return;
+			const listeners = this.#listeners.get(type) ?? /* @__PURE__ */ new Map();
+			listeners.set(listener, { once: typeof options === "object" && options.once === true });
+			this.#listeners.set(type, listeners);
+		}
+		removeEventListener(type, listener) {
+			if (listener) this.#listeners.get(type)?.delete(listener);
+		}
+		dispatchEvent(event) {
+			const listeners = this.#listeners.get(event.type);
+			[...listeners ?? /* @__PURE__ */ new Map()].forEach(([listener, { once }]) => {
+				if (once) listeners?.delete(listener);
+				listener.call(this, event);
+			});
+			return true;
+		}
+	}
+	const signals = /* @__PURE__ */ new WeakMap();
+	const CONSTRUCT = Symbol("AbortSignal");
+	class GuestAbortSignal extends GuestEventTarget {
+		onabort = null;
+		constructor(token) {
+			super();
+			if (token !== CONSTRUCT) throw new TypeError("Illegal constructor: an AbortSignal comes from an AbortController");
+			signals.set(this, {
+				aborted: false,
+				reason: void 0
+			});
+		}
+		get aborted() {
+			return signals.get(this)?.aborted ?? false;
+		}
+		get reason() {
+			return signals.get(this)?.reason;
+		}
+		throwIfAborted() {
+			if (this.aborted) throw this.reason;
+		}
+		static abort(reason) {
+			const signal = new GuestAbortSignal(CONSTRUCT);
+			abortSignal(signal, reason);
+			return signal;
+		}
+		static timeout(ms) {
+			const signal = new GuestAbortSignal(CONSTRUCT);
+			guestSetTimeout(() => {
+				abortSignal(signal, new DOMException("The operation timed out.", "TimeoutError"));
+			}, ms);
+			return signal;
+		}
+		static any(sources) {
+			const signal = new GuestAbortSignal(CONSTRUCT);
+			const aborted = sources.find((source) => source.aborted);
+			if (aborted) {
+				abortSignal(signal, aborted.reason);
+				return signal;
+			}
+			sources.forEach((source) => {
+				source.addEventListener("abort", () => abortSignal(signal, source.reason), { once: true });
+			});
+			return signal;
+		}
+	}
+	const abortSignal = (signal, reason) => {
+		const state = signals.get(signal);
+		if (!state || state.aborted) return;
+		state.aborted = true;
+		state.reason = reason === void 0 ? new DOMException("This operation was aborted", "AbortError") : reason;
+		const event = new GuestEvent("abort");
+		signal.onabort?.call(signal, event);
+		signal.dispatchEvent(event);
+	};
+	class GuestAbortController {
+		signal = new GuestAbortSignal(CONSTRUCT);
+		abort(reason) {
+			abortSignal(this.signal, reason);
+		}
+	}
+	const timers = /* @__PURE__ */ new Set();
+	let nextTimer = 1;
+	const delayOf = (ms) => Math.max(0, Number(ms) || 0);
+	const guestSetTimeout = (callback, ms, ...args) => {
+		const id = nextTimer++;
+		timers.add(id);
+		host.sleep(delayOf(ms)).then(() => {
+			if (timers.delete(id)) callback(...args);
+		});
+		return id;
+	};
+	const guestSetInterval = (callback, ms, ...args) => {
+		const id = nextTimer++;
+		timers.add(id);
+		const tick = () => {
+			host.sleep(Math.max(1, delayOf(ms))).then(() => {
+				if (timers.has(id)) {
+					callback(...args);
+					tick();
+				}
+			});
+		};
+		tick();
+		return id;
+	};
+	const clearTimer = (id) => {
+		if (id !== void 0) timers.delete(id);
+	};
+	const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+	class GuestHeaders {
+		#values = /* @__PURE__ */ new Map();
+		constructor(init) {
+			if (init instanceof GuestHeaders) init.forEach((value, name) => this.append(name, value));
+			else if (Array.isArray(init)) init.forEach(([name, value]) => this.append(name, value));
+			else if (init) Object.entries(init).forEach(([name, value]) => this.append(name, value));
+		}
+		#name(name) {
+			if (!TOKEN.test(name)) throw new TypeError(`"${name}" is not a valid header name`);
+			return name.toLowerCase();
+		}
+		append(name, value) {
+			const key = this.#name(name);
+			this.#values.set(key, [...this.#values.get(key) ?? [], String(value).trim()]);
+		}
+		set(name, value) {
+			this.#values.set(this.#name(name), [String(value).trim()]);
+		}
+		get(name) {
+			return this.#values.get(this.#name(name))?.join(", ") ?? null;
+		}
+		getSetCookie() {
+			return [...this.#values.get("set-cookie") ?? []];
+		}
+		has(name) {
+			return this.#values.has(this.#name(name));
+		}
+		delete(name) {
+			this.#values.delete(this.#name(name));
+		}
+		*entries() {
+			for (const name of [...this.#values.keys()].sort()) if (name === "set-cookie") for (const value of this.#values.get(name) ?? []) yield [name, value];
+			else yield [name, this.#values.get(name)?.join(", ") ?? ""];
+		}
+		*keys() {
+			for (const [name] of this.entries()) yield name;
+		}
+		*values() {
+			for (const [, value] of this.entries()) yield value;
+		}
+		forEach(callback) {
+			for (const [name, value] of this.entries()) callback(value, name, this);
+		}
+		[Symbol.iterator]() {
+			return this.entries();
+		}
+	}
+	const sourceOf = (body, headers) => {
+		const typed = (type) => {
+			if (!headers.has("content-type")) headers.set("content-type", type);
+		};
+		if (body === null || body === void 0) return null;
+		if (typeof body === "string") {
+			typed("text/plain;charset=UTF-8");
+			return { text: body };
+		}
+		if (body instanceof URLSearchParams) {
+			typed("application/x-www-form-urlencoded;charset=UTF-8");
+			return { text: body.toString() };
+		}
+		if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return { bytes: copyBytes(body) };
+		throw new TypeError("A body is a string, bytes or URLSearchParams — this runtime has no streams, Blob or FormData");
+	};
+	/** Each body's source and whether it was read, kept out of the objects the code holds. */
+	const bodies = /* @__PURE__ */ new WeakMap();
+	const take = (body) => {
+		const state = bodies.get(body);
+		if (!state) return null;
+		if (state.used) throw new TypeError("Body has already been read");
+		state.used = state.source !== null;
+		return state.source;
+	};
+	/** A body as it was written, to copy it: text stays text and bytes stay bytes. */
+	const peek = (body) => {
+		const source = bodies.get(body)?.source ?? null;
+		if (!source) return null;
+		return "text" in source ? source.text : source.bytes;
+	};
+	class GuestBody {
+		headers;
+		constructor(body, headers) {
+			this.headers = new GuestHeaders(headers);
+			bodies.set(this, {
+				source: sourceOf(body, this.headers),
+				used: false
+			});
+		}
+		get bodyUsed() {
+			return bodies.get(this)?.used ?? false;
+		}
+		get body() {
+			return null;
+		}
+		text() {
+			try {
+				const source = take(this);
+				if (!source) return Promise.resolve("");
+				return Promise.resolve("text" in source ? source.text : decodeUtf8(source.bytes));
+			} catch (error) {
+				return Promise.reject(error instanceof Error ? error : new TypeError(String(error)));
+			}
+		}
+		async json() {
+			return JSON.parse(await this.text());
+		}
+		bytes() {
+			try {
+				const source = take(this);
+				if (!source) return Promise.resolve(/* @__PURE__ */ new Uint8Array(0));
+				return Promise.resolve("text" in source ? encodeUtf8(source.text) : copyBytes(source.bytes));
+			} catch (error) {
+				return Promise.reject(error instanceof Error ? error : new TypeError(String(error)));
+			}
+		}
+		async arrayBuffer() {
+			return (await this.bytes()).buffer;
+		}
+	}
+	const METHODS = [
+		"DELETE",
+		"GET",
+		"HEAD",
+		"OPTIONS",
+		"POST",
+		"PUT",
+		"PATCH"
+	];
+	class GuestRequest extends GuestBody {
+		url;
+		method;
+		signal;
+		constructor(input, init = {}) {
+			const from = input instanceof GuestRequest ? input : void 0;
+			const method = init.method ?? from?.method ?? "GET";
+			const upper = method.toUpperCase();
+			const normal = METHODS.includes(upper) ? upper : method;
+			if ((normal === "GET" || normal === "HEAD") && init.body !== void 0 && init.body !== null) throw new TypeError(`A ${normal} request has no body`);
+			super(init.body, init.headers ?? from?.headers);
+			this.url = new URL(input instanceof GuestRequest ? input.url : input).href;
+			this.method = normal;
+			this.signal = init.signal ?? from?.signal ?? new GuestAbortController().signal;
+		}
+		clone() {
+			return new GuestRequest(this.url, {
+				method: this.method,
+				headers: this.headers,
+				body: peek(this),
+				signal: this.signal
+			});
+		}
+	}
+	class GuestResponse extends GuestBody {
+		status;
+		statusText;
+		type = "default";
+		url = "";
+		redirected = false;
+		constructor(body, init = {}) {
+			super(body, init.headers);
+			const status = init.status ?? 200;
+			if (!Number.isInteger(status) || status < 200 || status > 599) throw new RangeError(`A response status is 200–599, not ${String(status)}`);
+			this.status = status;
+			this.statusText = init.statusText ?? "";
+		}
+		get ok() {
+			return this.status >= 200 && this.status < 300;
+		}
+		clone() {
+			return new GuestResponse(peek(this), {
+				status: this.status,
+				statusText: this.statusText,
+				headers: this.headers
+			});
+		}
+		static json(data, init = {}) {
+			const headers = new GuestHeaders(init.headers);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+			return new GuestResponse(JSON.stringify(data), {
+				...init,
+				headers
+			});
+		}
+		static redirect(url, status = 302) {
+			if (![
+				301,
+				302,
+				303,
+				307,
+				308
+			].includes(status)) throw new RangeError(`${String(status)} is not a redirect status`);
+			return new GuestResponse(null, {
+				status,
+				headers: { location: new URL(String(url)).href }
+			});
+		}
+	}
+	/** Text back as text and bytes as base64: what the code wrote crosses unchanged, and nothing is decided from its type. */
+	const wireOf = (body) => {
+		const source = take(body);
+		if (!source) return null;
+		return "text" in source ? { text: source.text } : { base64: bytesToBase64(source.bytes) };
+	};
+	const headerPairs = (value) => Array.isArray(value) ? value.flatMap((pair) => Array.isArray(pair) && typeof pair[0] === "string" && typeof pair[1] === "string" ? [[pair[0], pair[1]]] : []) : [];
+	const bodyOfWire = (body) => {
+		if (!isRecord(body)) return null;
+		if (typeof body.text === "string") return body.text;
+		return typeof body.base64 === "string" ? base64ToBytes(body.base64) : null;
+	};
+	const getRandomValues = (array) => {
+		if (array.byteLength > 65536) throw new DOMException("At most 65536 bytes at a time", "QuotaExceededError");
+		new Uint8Array(array.buffer, array.byteOffset, array.byteLength).set(host.random(array.byteLength));
+		return array;
+	};
+	const randomUUID = () => {
+		const bytes = getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+		bytes[6] = bytes[6] & 15 | 64;
+		bytes[8] = bytes[8] & 63 | 128;
+		const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+		return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+	};
+	const HASHES = [
+		"SHA-1",
+		"SHA-256",
+		"SHA-384",
+		"SHA-512"
+	];
+	const nameOf = (algorithm) => {
+		const name = typeof algorithm === "string" ? algorithm : isRecord(algorithm) ? algorithm.name : void 0;
+		return typeof name === "string" ? name.toUpperCase() : "";
+	};
+	const hashOf = (algorithm) => {
+		const upper = nameOf(algorithm);
+		if (!HASHES.includes(upper)) throw new DOMException(`${upper || String(algorithm)} is not a supported hash (${HASHES.join(", ")})`, "NotSupportedError");
+		return upper;
+	};
+	/** An HMAC key's length when its algorithm names none: the hash's block, as Web Crypto has it. */
+	const blockBitsOf = (hash) => hash === "SHA-384" || hash === "SHA-512" ? 1024 : 512;
+	/**
+	* The two kinds of key this runtime's `crypto.subtle` makes: HMAC, what signing a webhook needs, and PBKDF2, a
+	* password to derive from — what keeping a password needs.
+	*/
+	class GuestCryptoKey {
+		type = "secret";
+		algorithm;
+		extractable;
+		usages;
+		raw;
+		constructor(raw, algorithm, extractable, usages) {
+			this.raw = raw;
+			this.algorithm = algorithm;
+			this.extractable = extractable;
+			this.usages = usages;
+		}
+	}
+	const bytesOf = (data) => {
+		if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) return copyBytes(data);
+		throw new TypeError("crypto.subtle takes bytes: an ArrayBuffer or a typed array");
+	};
+	const cryptoCall = async (message) => {
+		const answer = JSON.parse(await host.crypto(JSON.stringify(message)));
+		if (!isRecord(answer) || answer.ok !== true || typeof answer.value !== "string") throw new DOMException(isRecord(answer) && typeof answer.error === "string" ? answer.error : "The operation failed", "OperationError");
+		return base64ToBytes(answer.value);
+	};
+	const isKeyOf = (key, name) => key instanceof GuestCryptoKey && key.algorithm.name === name;
+	/** The key an operation was handed, when it is of the kind the operation takes and was imported for it. */
+	const keyFor = (key, name, usage) => {
+		if (!isKeyOf(key, name)) throw new DOMException(`${usage} takes a ${name} key, from crypto.subtle.importKey`, "InvalidAccessError");
+		if (!key.usages.includes(usage)) throw new DOMException(`The key was not imported for ${usage}`, "InvalidAccessError");
+		return key;
+	};
+	const hmacOf = (key, usage, data) => {
+		const { algorithm, raw } = keyFor(key, "HMAC", usage);
+		return cryptoCall({
+			op: "hmac",
+			hash: algorithm.hash.name,
+			key: bytesToBase64(raw),
+			data: bytesToBase64(bytesOf(data))
+		});
+	};
+	/** How many rounds and bits a derivation may take is the runner's to say: it is the one doing the work. */
+	const pbkdf2Of = (algorithm, baseKey, bits, usage) => {
+		if (!isRecord(algorithm) || nameOf(algorithm) !== "PBKDF2") throw new DOMException("This runtime derives with PBKDF2 only", "NotSupportedError");
+		const { raw } = keyFor(baseKey, "PBKDF2", usage);
+		if (typeof algorithm.iterations !== "number" || typeof bits !== "number") throw new TypeError("PBKDF2 takes { name, hash, salt, iterations } and a length in bits");
+		return cryptoCall({
+			op: "pbkdf2",
+			hash: hashOf(algorithm.hash),
+			key: bytesToBase64(raw),
+			salt: bytesToBase64(bytesOf(algorithm.salt)),
+			iterations: String(algorithm.iterations),
+			bits: String(bits)
+		});
+	};
+	/** The key `importKey` makes — thrown, not answered, when it is none this runtime has. */
+	const importedKey = (format, keyData, algorithm, extractable, usages) => {
+		const name = nameOf(algorithm);
+		if (format === "raw" && name === "HMAC" && isRecord(algorithm)) return new GuestCryptoKey(bytesOf(keyData), {
+			name,
+			hash: { name: hashOf(algorithm.hash) }
+		}, extractable, usages);
+		if (format === "raw" && name === "PBKDF2") {
+			if (extractable) throw new DOMException("A PBKDF2 key is never extractable", "SyntaxError");
+			return new GuestCryptoKey(bytesOf(keyData), { name }, false, usages);
+		}
+		throw new DOMException("This runtime imports raw keys for HMAC and PBKDF2 only (format \"raw\", { name: \"HMAC\", hash } or \"PBKDF2\")", "NotSupportedError");
+	};
+	const subtle = {
+		digest: async (algorithm, data) => (await cryptoCall({
+			op: "digest",
+			hash: hashOf(algorithm),
+			data: bytesToBase64(bytesOf(data))
+		})).buffer,
+		importKey: (format, keyData, algorithm, extractable, usages) => new Promise((resolve) => {
+			resolve(importedKey(format, keyData, algorithm, extractable, usages));
+		}),
+		sign: async (_algorithm, key, data) => (await hmacOf(key, "sign", data)).buffer,
+		verify: async (_algorithm, key, signature, data) => {
+			const expected = await hmacOf(key, "verify", data);
+			const given = bytesOf(signature);
+			let difference = expected.length ^ given.length;
+			expected.forEach((byte, index) => {
+				difference |= byte ^ (given[index] ?? 0);
+			});
+			return difference === 0;
+		},
+		deriveBits: async (algorithm, baseKey, length) => (await pbkdf2Of(algorithm, baseKey, length, "deriveBits")).buffer,
+		/** Derives an HMAC key — the one other kind this runtime has. */
+		deriveKey: async (algorithm, baseKey, derivedKeyAlgorithm, extractable, usages) => {
+			if (!isRecord(derivedKeyAlgorithm) || nameOf(derivedKeyAlgorithm) !== "HMAC") throw new DOMException("This runtime derives HMAC keys only", "NotSupportedError");
+			const hash = hashOf(derivedKeyAlgorithm.hash);
+			const length = derivedKeyAlgorithm.length ?? blockBitsOf(hash);
+			const raw = await pbkdf2Of(algorithm, baseKey, length, "deriveKey");
+			return new GuestCryptoKey(raw, {
+				name: "HMAC",
+				hash: { name: hash }
+			}, extractable, usages);
+		}
+	};
+	const call = async (message) => {
+		const answer = JSON.parse(await host.call(JSON.stringify(message)));
+		if (!isRecord(answer) || answer.ok !== true) throw new Error(isRecord(answer) && typeof answer.error === "string" ? answer.error : "The platform refused the call");
+		return answer.value;
+	};
+	const run = new GuestAbortController();
+	const driver = shared.createFunctionsDriver({
+		call,
+		signal: run.signal,
+		responseOf: (wire) => new GuestResponse(bodyOfWire(wire.body), {
+			status: typeof wire.status === "number" ? wire.status : 502,
+			statusText: typeof wire.statusText === "string" ? wire.statusText : "",
+			headers: headerPairs(wire.headers)
+		}),
+		requestOf: (wire) => new GuestRequest(String(wire.url), {
+			method: String(wire.method),
+			headers: headerPairs(wire.headers),
+			body: wire.method === "GET" || wire.method === "HEAD" ? null : bodyOfWire(wire.body),
+			signal: run.signal
+		}),
+		wireOfResponse: (response) => Promise.resolve(response instanceof GuestResponse ? {
+			status: response.status,
+			statusText: response.statusText,
+			headers: [...response.headers],
+			body: wireOf(response)
+		} : void 0),
+		changeKv: shared.changeKv,
+		refusal
+	});
+	const { log } = driver;
+	const refuseFetch = () => Promise.reject(/* @__PURE__ */ new TypeError("Functions reach the network through ctx.fetch, which knows the hosts they may reach"));
+	Object.assign(scope, {
+		TextEncoder: GuestTextEncoder,
+		TextDecoder: GuestTextDecoder,
+		Event: GuestEvent,
+		EventTarget: GuestEventTarget,
+		AbortSignal: GuestAbortSignal,
+		AbortController: GuestAbortController,
+		Headers: GuestHeaders,
+		Request: GuestRequest,
+		Response: GuestResponse,
+		setTimeout: guestSetTimeout,
+		clearTimeout: clearTimer,
+		setInterval: guestSetInterval,
+		clearInterval: clearTimer,
+		queueMicrotask: (callback) => {
+			Promise.resolve().then(callback);
+		},
+		crypto: {
+			getRandomValues,
+			randomUUID,
+			subtle
+		},
+		console: {
+			log,
+			info: log,
+			warn: log,
+			error: log,
+			debug: log
+		},
+		fetch: refuseFetch
+	});
+	const describe = (definition) => JSON.stringify({
+		ok: true,
+		value: shared.describeFunctions(definition)
+	});
+	return {
+		describe,
+		invoke: async (definition, invocationText) => {
+			let answer;
+			try {
+				const invocation = JSON.parse(invocationText);
+				answer = {
+					ok: true,
+					value: await driver.invoke(definition, isRecord(invocation) ? invocation : {})
+				};
+			} catch (error) {
+				answer = {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error),
+					...isRefusal(error) ? { refused: true } : {}
+				};
+			}
+			try {
+				return JSON.stringify(answer);
+			} catch (error) {
+				return JSON.stringify({
+					ok: false,
+					error: `What the function answered is not JSON: ${error instanceof Error ? error.message : String(error)}`
+				});
+			}
+		},
+		abort: (reason) => {
+			run.abort(new DOMException(reason, "AbortError"));
+		}
+	};
+};
+//#endregion
+export { installGuest };

package/dist/modules/functions/sandbox/isolate.d.ts

@@ -0,0 +1,37 @@
+import { FunctionRunner } from '../protocol';
+export type IsolateRunnerOptions = {
+    /**
+     * Invocations running at once; the rest wait their turn. Each isolate may take about twice its `memoryMb`, so this
+     * times that times two is what the runner needs.
+     */
+    concurrency?: number;
+    /**
+     * How many bytes of bundles this runner keeps — their code and V8's cache of it — least recently used let go first.
+     * A bundle it no longer has is asked of the platform again; one it has is never sent twice.
+     */
+    cacheBytes?: number;
+};
+/** The isolates, and what readies them before the first invocation pays for it. */
+export type IsolateRunner = FunctionRunner & {
+    /**
+     * Builds the prelude, the heap every isolate starts from and V8's cache of the guest, and runs a first bundle — what
+     * the first invocation of a fresh process would otherwise spend (~70 ms) on top of its own.
+     */
+    warm: () => Promise<void>;
+};
+/**
+ * The most a PBKDF2 derivation may ask for. The runner does the work, outside the isolate's clock, so each is bounded
+ * here and its time is charged to the run's CPU: a million rounds is past any password guidance, and 1024 bits past
+ * any key.
+ */
+export declare const PBKDF2_MAX_ITERATIONS = 1000000;
+export declare const PBKDF2_MAX_BITS = 1024;
+/**
+ * The runner as V8 isolates in this process — what the runner service serves, and what a deployment may use directly
+ * when the process holds nothing a space's code must not reach (tests, a sandbox of its own).
+ *
+ * ONE ISOLATE PER INVOCATION: each limit is then exactly that invocation's — its CPU, its memory — and stopping it
+ * disposes nothing anybody else was using. No state survives an invocation, by construction. The cost is ~2 ms: the
+ * prelude comes from a V8 snapshot, the guest and the bundle from V8's code cache after their first compile.
+ */
+export declare const createIsolateRunner: ({ concurrency, cacheBytes }?: IsolateRunnerOptions) => IsolateRunner;