@jigs.design/runtime 0.0.0-stage → 0.1.1

package/dist/runtime-core.js

@@ -0,0 +1,735 @@
+//#region src/runtime-core.ts
+/**
+* The runtime that executes compiled programs inside the sandbox worker.
+*
+* It is shipped to the worker with `createRuntime.toString()`, so the body
+* must not reference anything declared outside it (type imports are erased
+* and fine). `FunctionCtor` is passed in because the worker removes dynamic
+* code evaluation from its globals before any program runs.
+*
+* A small React-style reconciler: programs build a tree with `__pickle.jsx`,
+* the runtime diffs it against the previous render by position and type, and
+* posts the differences as `Op`s. Each render also reports the queries it read
+* and the mutations its handlers called; the page runs those through the
+* client and sends the results back.
+*/
+function createRuntime(post, FunctionCtor) {
+	/** The items `each` made, so `expand` can tell them from the program's own objects. */
+	const keyedItems = /* @__PURE__ */ new WeakSet();
+	const keyedItem = (key, value) => {
+		const item = {
+			key,
+			value
+		};
+		keyedItems.add(item);
+		return item;
+	};
+	const isKeyedItem = (value) => typeof value === "object" && value !== null && keyedItems.has(value);
+	const FRAGMENT = "#fragment";
+	const TEXT = "#text";
+	const ROOT = 0;
+	const MAX_INPUT = 1e4;
+	/** Distinct `useMutation` declarations per render; list rows reuse theirs. */
+	const MAX_MUTATIONS = 50;
+	const MAX_MUTATIONS_PER_EVENT = 5;
+	const MAX_QUERIES = 20;
+	/** State and mutation slots one render may use, list rows included. */
+	const MAX_SLOTS = 2e3;
+	/** Results in a row whose arrival changed the input of the query that asked for them. */
+	const MAX_INPUT_CHURN = 3;
+	const MAX_COMPONENT_DEPTH = 16;
+	const MAX_EACH = 500;
+	const MAX_ROWS = 500;
+	const MAX_ROW_KEYS = 20;
+	const MAX_NODES = 1e4;
+	const MAX_OPS = 3 * MAX_NODES;
+	const MAX_TEXT = 1e4;
+	let program = null;
+	let programCode = null;
+	let prose = {};
+	let procedures = {};
+	let previous = [];
+	let rootElement;
+	let nextId = 1;
+	let autoKey = 0;
+	let mutationKey = 0;
+	let errors = [];
+	let handlers = /* @__PURE__ */ new Map();
+	let nextHandlers = /* @__PURE__ */ new Map();
+	const slots = /* @__PURE__ */ new Map();
+	const setters = /* @__PURE__ */ new Map();
+	const queryResults = /* @__PURE__ */ new Map();
+	let reads = /* @__PURE__ */ new Map();
+	const mutationSlots = /* @__PURE__ */ new Map();
+	const mutationById = /* @__PURE__ */ new Map();
+	const mutateFns = /* @__PURE__ */ new Map();
+	/** Slot keys the current render used, and its mutation declarations. */
+	let visited = /* @__PURE__ */ new Set();
+	let mutationNames = /* @__PURE__ */ new Set();
+	/** Each `useQuery` call site's last key, and how often a result for it was followed by another key. */
+	let querySites = /* @__PURE__ */ new Map();
+	let nextQuerySites = /* @__PURE__ */ new Map();
+	const unstableSites = /* @__PURE__ */ new Set();
+	/** The query whose result this render answers, if any. */
+	let settledKey = null;
+	let nextMutationId = 0;
+	let calls = [];
+	let inHandler = false;
+	let componentDepth = 0;
+	let componentWhere = null;
+	/** Component and `<each>` segments. Empty means page state. */
+	const pathStack = [];
+	/** JSON with sorted keys, so `{ a, b }` and `{ b, a }` share a request. */
+	const stableKey = (value) => JSON.stringify(value, (_, inner) => typeof inner === "object" && inner !== null && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).toSorted(([a], [b]) => a < b ? -1 : 1)) : inner) ?? "null";
+	const pending = Object.freeze({
+		data: null,
+		error: null,
+		status: "pending"
+	});
+	/** Input as plain JSON data, or a thrown error the handler reports. */
+	const plainInput = (input, label) => {
+		if (input === void 0) return null;
+		let raw;
+		try {
+			raw = JSON.stringify(input);
+		} catch {
+			throw new Error(`${label} input must be plain data`);
+		}
+		if (typeof raw !== "string") throw new Error(`${label} input must be plain data`);
+		if (raw.length >= MAX_INPUT) throw new Error(`${label} input must be under ${MAX_INPUT} characters`);
+		return JSON.parse(raw);
+	};
+	const unknownProcedure = (name, kind) => ({
+		code: "UNKNOWN_PROCEDURE",
+		message: `"${name}" is not a ${kind} on this host`
+	});
+	const isProcedure = (name, kind) => Object.hasOwn(procedures, name) && (procedures[name]?.kind === kind || kind === "mutation" && procedures[name]?.kind === "action");
+	const reportError = (line, error) => {
+		const text = String(error);
+		errors.push({
+			line,
+			message: componentWhere === null ? text : `in <${componentWhere}>: ${text}`
+		});
+	};
+	const pathKey = (base) => pathStack.length === 0 ? base : `${base}@${pathStack.join("/")}`;
+	/** Counts `key` against this render's slots; throws past the limit. */
+	const visit = (key, hook) => {
+		if (visited.has(key)) return;
+		if (visited.size >= MAX_SLOTS) throw new Error(`${hook} is limited to ${MAX_SLOTS} slots per render`);
+		visited.add(key);
+	};
+	const useState = (initial, options) => {
+		const key = pathKey(options?.key ?? `auto:${autoKey++}`);
+		visit(key, "useState");
+		if (!slots.has(key)) slots.set(key, initial);
+		let setter = setters.get(key);
+		if (setter === void 0) {
+			setter = (next) => {
+				slots.set(key, typeof next === "function" ? next(slots.get(key)) : next);
+			};
+			setters.set(key, setter);
+		}
+		return [slots.get(key), setter];
+	};
+	/** Whether `useQuery`'s options say to wait: `{ enabled }` with a falsy value. */
+	const waits = (options) => typeof options === "object" && options !== null && "enabled" in options && !options.enabled;
+	const useQuery = (name, input, options) => {
+		if (typeof name !== "string" || name === "") throw new Error("useQuery needs a query name, e.g. useQuery(\"orders\")");
+		if (!isProcedure(name, "query")) return Object.freeze({
+			data: null,
+			error: unknownProcedure(name, "query"),
+			status: "error"
+		});
+		const base = pathKey(`query:${name}`);
+		if (waits(options)) {
+			let waitingSite = base;
+			for (let index = 1; nextQuerySites.has(waitingSite); index++) waitingSite = `${base}#${index}`;
+			nextQuerySites.set(waitingSite, {
+				churn: 0,
+				key: `${name}:waiting`
+			});
+			return pending;
+		}
+		const plain = plainInput(input, "useQuery");
+		const key = `${name}:${stableKey(plain)}`;
+		let site = base;
+		for (let index = 1; nextQuerySites.has(site); index++) site = `${base}#${index}`;
+		const last = querySites.get(site);
+		const churn = last !== void 0 && last.key !== key && last.key === settledKey ? last.churn + 1 : 0;
+		nextQuerySites.set(site, {
+			churn,
+			key
+		});
+		if (churn >= MAX_INPUT_CHURN && !unstableSites.has(site)) {
+			unstableSites.add(site);
+			reportError(null, `useQuery("${name}") gets a different input every time its data arrives, so it never shows data, and it was stopped. Build the input from state, not from Date.now(), Math.random() or new Date()`);
+		}
+		if (unstableSites.has(site)) return Object.freeze({
+			data: null,
+			error: Object.freeze({
+				code: "BAD_INPUT",
+				message: `useQuery("${name}") was stopped: its input changes on every render`
+			}),
+			status: "error"
+		});
+		if (!reads.has(key)) {
+			if (reads.size >= MAX_QUERIES) throw new Error(`useQuery is limited to ${MAX_QUERIES} different requests`);
+			reads.set(key, {
+				input: plain,
+				key,
+				name
+			});
+		}
+		return queryResults.get(key) ?? pending;
+	};
+	const useMutation = (name, options) => {
+		if (typeof name !== "string" || name === "") throw new Error("useMutation needs a mutation name, e.g. useMutation(\"archiveOrder\")");
+		const declaration = `mutation:${options?.key ?? `auto:${mutationKey++}`}`;
+		if (!mutationNames.has(declaration)) {
+			if (mutationNames.size >= MAX_MUTATIONS) throw new Error(`useMutation is limited to ${MAX_MUTATIONS} declarations`);
+			mutationNames.add(declaration);
+		}
+		const key = pathKey(declaration);
+		visit(key, "useMutation");
+		let state = mutationSlots.get(key);
+		if (state === void 0) {
+			state = {
+				data: null,
+				error: null,
+				id: 0,
+				input: null,
+				name,
+				status: "idle"
+			};
+			mutationSlots.set(key, state);
+		}
+		state.name = name;
+		const known = isProcedure(name, "mutation");
+		let mutate = mutateFns.get(key);
+		if (mutate === void 0) {
+			mutate = (input) => {
+				if (!inHandler) throw new Error("mutate() only works inside event handlers such as onClick");
+				const current = mutationSlots.get(key);
+				if (current === void 0 || current.status === "pending" || !isProcedure(current.name, "mutation")) return;
+				const plain = plainInput(input, "mutate()");
+				if (calls.length >= MAX_MUTATIONS_PER_EVENT) throw new Error(`mutate() is limited to ${MAX_MUTATIONS_PER_EVENT} calls per event`);
+				if (current.id !== 0) mutationById.delete(current.id);
+				const id = ++nextMutationId;
+				current.data = null;
+				current.error = null;
+				current.id = id;
+				current.input = plain;
+				current.status = "pending";
+				mutationById.set(id, key);
+				calls.push({
+					id,
+					input: plain,
+					name: current.name
+				});
+			};
+			mutateFns.set(key, mutate);
+		}
+		if (!known) return Object.freeze({
+			data: null,
+			error: unknownProcedure(name, "mutation"),
+			input: null,
+			mutate,
+			status: "error"
+		});
+		return Object.freeze({
+			data: state.data,
+			error: state.error,
+			input: state.input,
+			mutate,
+			status: state.status
+		});
+	};
+	const Pickle = Object.freeze({
+		render: (element) => {
+			rootElement = element;
+		},
+		reportError,
+		useConstants: () => prose,
+		useMutation,
+		useQuery,
+		useState
+	});
+	/** `#id` stays with the item; a bare index is only the fallback. */
+	const eachSegment = (item, index) => {
+		if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+			const record = item;
+			const id = record.id;
+			if (typeof id === "string" || typeof id === "number") return `#${id}`;
+			const key = record.key;
+			if (typeof key === "string" || typeof key === "number") return `#${key}`;
+		}
+		return String(index);
+	};
+	const callSegment = (name, key, ordinal, at) => {
+		if (key !== void 0) {
+			if (typeof key === "string" || typeof key === "number") return `${name}=${key}`;
+			reportError(at, `<${name}> key must be a string or number`);
+		}
+		return `${name}#${ordinal}`;
+	};
+	const each = (items, render, line) => {
+		let list;
+		if (items === null || items === void 0) list = [];
+		else if (typeof items === "number") list = Array.from({ length: Math.max(0, Math.min(Math.floor(items), 501)) }, (_, index) => index);
+		else if (Array.isArray(items)) list = items;
+		else {
+			reportError(line, "<each of> must be a list or a count");
+			return [];
+		}
+		if (list.length > MAX_EACH) {
+			reportError(line, `<each> shows the first ${MAX_EACH} items only`);
+			list = list.slice(0, MAX_EACH);
+		}
+		/** One item drawn under its path segment; a throw is reported and draws nothing. */
+		const draw = (item, index, segment) => {
+			pathStack.push(segment);
+			try {
+				return render(item, index);
+			} catch (error) {
+				reportError(line, error);
+				return null;
+			} finally {
+				pathStack.pop();
+			}
+		};
+		return list.map((item, index) => {
+			const segment = eachSegment(item, index);
+			const drawnItem = draw(item, index, segment);
+			return segment.startsWith("#") ? keyedItem(`${line}${segment}`, drawnItem) : drawnItem;
+		});
+	};
+	/** One component invocation; see the prototype runtime for the identity rules. */
+	const callComponent = (fn, props, children, at, ordinal, name, fromLibrary) => {
+		if (componentDepth >= MAX_COMPONENT_DEPTH) throw new Error("component nesting is deeper than 16");
+		componentDepth++;
+		const previousWhere = componentWhere;
+		const label = typeof name === "string" ? name : "component";
+		componentWhere = fromLibrary === true ? label : null;
+		const source = props ?? {};
+		const body = {};
+		for (const key of Object.keys(source)) if (key !== "key") body[key] = source[key];
+		pathStack.push(callSegment(label, source.key, ordinal ?? 0, at));
+		try {
+			return fn(body, children, at);
+		} catch (error) {
+			reportError(at, error);
+			return null;
+		} finally {
+			pathStack.pop();
+			componentWhere = previousWhere;
+			componentDepth--;
+		}
+	};
+	const pickle = Object.freeze({
+		call: callComponent,
+		each,
+		Fragment: FRAGMENT,
+		jsx: (type, props, ...children) => ({
+			children,
+			props: props ?? {},
+			type
+		})
+	});
+	const pickleSafe = (evaluate, fallback, line) => {
+		try {
+			return evaluate();
+		} catch (error) {
+			reportError(line ?? null, error);
+			return fallback;
+		}
+	};
+	const isVNode = (value) => typeof value === "object" && value !== null && "type" in value && "props" in value && "children" in value;
+	/** Nodes the current render has drawn, against `MAX_NODES`. */
+	let drawn = 0;
+	const countNode = () => {
+		drawn++;
+		if (drawn > MAX_NODES) throw new Error(`the page draws more than ${MAX_NODES} elements; show fewer, for example by paging or limiting a list`);
+	};
+	const expand = (node, out) => {
+		if (node === null || node === void 0 || typeof node === "boolean") return;
+		if (isKeyedItem(node)) {
+			const start = out.length;
+			expand(node.value, out);
+			out.slice(start).forEach((drawnNode, index) => {
+				drawnNode.key = `${node.key}/${drawnNode.key ?? index}`;
+			});
+			return;
+		}
+		if (Array.isArray(node)) {
+			for (const child of node) expand(child, out);
+			return;
+		}
+		if (typeof node === "string" || typeof node === "number") {
+			countNode();
+			let text = String(node);
+			if (text.length > MAX_TEXT) {
+				text = text.slice(0, MAX_TEXT);
+				reportError(null, `text longer than ${MAX_TEXT} characters was cut`);
+			}
+			out.push({
+				children: [],
+				id: 0,
+				props: {},
+				text,
+				type: TEXT,
+				wire: {}
+			});
+			return;
+		}
+		if (!isVNode(node)) return;
+		if (typeof node.type === "function") {
+			expand(node.type(node.props), out);
+			return;
+		}
+		if (node.type === FRAGMENT) {
+			expand(node.children, out);
+			return;
+		}
+		if (typeof node.type === "string") {
+			countNode();
+			const children = [];
+			expand(node.children, children);
+			out.push({
+				children,
+				id: 0,
+				props: node.props,
+				text: "",
+				type: node.type,
+				wire: {}
+			});
+		}
+	};
+	/** Copies a list of objects keeping only flat fields; the page checks it again. */
+	const toRows = (list) => list.slice(0, MAX_ROWS).map((item) => {
+		const row = {};
+		if (typeof item === "object" && item !== null) {
+			for (const [key, value] of Object.entries(item).slice(0, MAX_ROW_KEYS)) if (value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value)) row[key] = typeof value === "string" ? value.slice(0, 500) : value;
+		}
+		return row;
+	});
+	const toWire = (id, props) => {
+		const wire = {};
+		for (const [name, value] of Object.entries(props)) {
+			if (name === "key") continue;
+			if (typeof value === "function") {
+				const fn = `${id}.${name}`;
+				nextHandlers.set(fn, (...args) => value(...args));
+				wire[name] = { fn };
+			} else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") wire[name] = value;
+			else if (Array.isArray(value)) wire[name] = { rows: toRows(value) };
+		}
+		return wire;
+	};
+	const sameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+	const create = (node, ops) => {
+		node.id = nextId++;
+		if (node.type === TEXT) {
+			ops.push({
+				id: node.id,
+				op: "createText",
+				text: node.text
+			});
+			return;
+		}
+		node.wire = toWire(node.id, node.props);
+		ops.push({
+			id: node.id,
+			op: "create",
+			props: node.wire,
+			type: node.type
+		});
+		node.children.forEach((child, index) => {
+			create(child, ops);
+			ops.push({
+				id: child.id,
+				index,
+				op: "place",
+				parent: node.id
+			});
+		});
+	};
+	/** Brings a node the last render drew up to date with its new version. */
+	const update = (old, node, ops) => {
+		node.id = old.id;
+		if (node.type === TEXT) {
+			if (old.text !== node.text) ops.push({
+				id: node.id,
+				op: "text",
+				text: node.text
+			});
+			return;
+		}
+		node.wire = toWire(node.id, node.props);
+		const changed = {};
+		let dirty = false;
+		for (const name of /* @__PURE__ */ new Set([...Object.keys(old.wire), ...Object.keys(node.wire)])) if (!sameValue(old.wire[name], node.wire[name])) {
+			changed[name] = node.wire[name] ?? null;
+			dirty = true;
+		}
+		if (dirty) ops.push({
+			id: node.id,
+			op: "set",
+			props: changed
+		});
+		reconcile(node.id, old.children, node.children, ops);
+	};
+	/**
+	* Which entries of `sequence` (old positions, -1 for none) form its
+	* longest increasing run: the reused nodes that keep their order and
+	* need no `place`. Patience sorting, O(n log n).
+	*/
+	const keptInOrder = (sequence) => {
+		const tails = [];
+		const previousOf = [];
+		for (const [index, value] of sequence.entries()) {
+			if (value === -1) continue;
+			let low = 0;
+			let high = tails.length;
+			while (low < high) {
+				const middle = low + high >> 1;
+				if ((sequence[tails[middle] ?? 0] ?? 0) < value) low = middle + 1;
+				else high = middle;
+			}
+			previousOf[index] = low > 0 ? tails[low - 1] ?? -1 : -1;
+			tails[low] = index;
+		}
+		const kept = /* @__PURE__ */ new Set();
+		for (let index = tails.at(-1) ?? -1; index !== -1; index = previousOf[index] ?? -1) kept.add(index);
+		return kept;
+	};
+	/**
+	* Makes `before` into `after` under `parent`. A node an `<each>` item
+	* drew is matched by its item's key, so a row inserted at the top of a
+	* list costs that row's ops rather than one per row below it; other nodes
+	* are matched in order among themselves, as by position. Unmatched old
+	* nodes are removed, new ones created, and only nodes out of their old
+	* order are placed again.
+	*/
+	const reconcile = (parent, before, after, ops) => {
+		const byKey = /* @__PURE__ */ new Map();
+		const unkeyed = [];
+		for (const [index, old] of before.entries()) if (old.key === void 0) unkeyed.push(index);
+		else if (!byKey.has(old.key)) byKey.set(old.key, index);
+		const used = /* @__PURE__ */ new Set();
+		let nextUnkeyed = 0;
+		const matched = after.map((node) => {
+			const candidate = node.key === void 0 ? unkeyed[nextUnkeyed++] : byKey.get(node.key);
+			const old = candidate === void 0 ? void 0 : before[candidate];
+			if (candidate === void 0 || old?.type !== node.type || used.has(candidate)) return -1;
+			used.add(candidate);
+			return candidate;
+		});
+		for (const [index, old] of before.entries()) if (!used.has(index)) ops.push({
+			id: old.id,
+			op: "remove"
+		});
+		const kept = keptInOrder(matched);
+		for (const [index, node] of after.entries()) {
+			const from = matched[index] ?? -1;
+			const old = from === -1 ? void 0 : before[from];
+			if (old === void 0) create(node, ops);
+			else {
+				update(old, node, ops);
+				if (kept.has(index)) continue;
+			}
+			ops.push({
+				id: node.id,
+				index,
+				op: "place",
+				parent
+			});
+		}
+	};
+	/**
+	* Frees slots this render didn't use, once there are more than one render
+	* may hold. Not before: a document streaming in renders without the parts
+	* that haven't arrived yet, and their state must survive until they do.
+	*/
+	const pruneSlots = () => {
+		if (slots.size + mutationSlots.size <= MAX_SLOTS) return;
+		for (const key of slots.keys()) if (!visited.has(key)) {
+			slots.delete(key);
+			setters.delete(key);
+		}
+		for (const [key, state] of mutationSlots) if (!visited.has(key)) {
+			mutationSlots.delete(key);
+			mutateFns.delete(key);
+			mutationById.delete(state.id);
+		}
+	};
+	/**
+	* Drops every state slot and mutation status, for a program that starts a
+	* new UI rather than editing the last one. A result still on its way for
+	* a dropped mutation finds no slot and is ignored. Query results stay:
+	* they are the server's data, not the UI's.
+	*/
+	const forgetState = () => {
+		slots.clear();
+		setters.clear();
+		mutationSlots.clear();
+		mutationById.clear();
+		mutateFns.clear();
+	};
+	const render = (run) => {
+		rootElement = void 0;
+		autoKey = 0;
+		mutationKey = 0;
+		componentDepth = 0;
+		componentWhere = null;
+		pathStack.length = 0;
+		nextHandlers = /* @__PURE__ */ new Map();
+		drawn = 0;
+		visited = /* @__PURE__ */ new Set();
+		mutationNames = /* @__PURE__ */ new Set();
+		nextQuerySites = /* @__PURE__ */ new Map();
+		const previousReads = reads;
+		reads = /* @__PURE__ */ new Map();
+		const next = [];
+		try {
+			run(Pickle, pickle, pickleSafe);
+			expand(rootElement, next);
+		} catch (error) {
+			reads = previousReads;
+			return {
+				message: String(error),
+				ok: false
+			};
+		}
+		querySites = nextQuerySites;
+		pruneSlots();
+		for (const key of queryResults.keys()) if (!reads.has(key)) queryResults.delete(key);
+		const ops = [];
+		reconcile(ROOT, previous, next, ops);
+		if (ops.length > MAX_OPS) {
+			reads = previousReads;
+			return {
+				message: `Error: the page changed more than ${MAX_OPS} things at once`,
+				ok: false
+			};
+		}
+		previous = next;
+		handlers = nextHandlers;
+		return {
+			ok: true,
+			ops
+		};
+	};
+	const handle = (message) => {
+		errors = [];
+		calls = [];
+		const result = (ops) => post({
+			errors,
+			mutations: calls,
+			ops,
+			queries: [...reads.values()],
+			seq: message.seq,
+			type: "result"
+		});
+		const settle = (run) => {
+			if (run === null) {
+				result([]);
+				return;
+			}
+			const outcome = render(run);
+			if (outcome.ok) result(outcome.ops);
+			else post({
+				message: outcome.message,
+				seq: message.seq,
+				type: "failed"
+			});
+		};
+		if (message.type === "query") {
+			if (reads.has(message.key)) queryResults.set(message.key, Object.freeze(message.result));
+			settledKey = message.key;
+			try {
+				settle(program);
+			} finally {
+				settledKey = null;
+			}
+			return;
+		}
+		if (message.type === "mutation") {
+			const key = mutationById.get(message.id);
+			const state = key === void 0 ? void 0 : mutationSlots.get(key);
+			if (state !== void 0 && state.id === message.id) {
+				mutationById.delete(message.id);
+				if (message.result.status === "success") {
+					state.data = message.result.data;
+					state.error = null;
+					state.status = "success";
+				} else {
+					state.data = null;
+					state.error = message.result.error;
+					state.status = "error";
+				}
+			}
+			settle(program);
+			return;
+		}
+		if (message.type === "update") {
+			if (message.fresh) forgetState();
+			const previousProse = prose;
+			const previousProcedures = procedures;
+			prose = message.prose;
+			procedures = message.procedures;
+			let candidate = program;
+			if (message.code !== programCode) {
+				unstableSites.clear();
+				querySites = /* @__PURE__ */ new Map();
+				try {
+					candidate = new FunctionCtor("Pickle", "__pickle", "__pickleSafe", message.code);
+				} catch (error) {
+					prose = previousProse;
+					procedures = previousProcedures;
+					post({
+						message: String(error),
+						seq: message.seq,
+						type: "failed"
+					});
+					return;
+				}
+			}
+			if (candidate === null) {
+				result([]);
+				return;
+			}
+			const outcome = render(candidate);
+			if (!outcome.ok) {
+				prose = previousProse;
+				procedures = previousProcedures;
+				post({
+					message: outcome.message,
+					seq: message.seq,
+					type: "failed"
+				});
+				return;
+			}
+			program = candidate;
+			programCode = message.code;
+			result(outcome.ops);
+			return;
+		}
+		const handler = handlers.get(message.fn);
+		if (handler === void 0 || program === null) {
+			result([]);
+			return;
+		}
+		inHandler = true;
+		try {
+			handler(...message.args);
+		} catch (error) {
+			reportError(null, error);
+		} finally {
+			inHandler = false;
+		}
+		settle(program);
+	};
+	return { handle };
+}
+//#endregion
+export { createRuntime };