@mica-js/compiler 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1886 @@
+//#region src/values.ts
+function createEnum(_name, member) {
+	return member;
+}
+function createRecord(fields) {
+	return Object.freeze(Object.fromEntries(fields));
+}
+function createBytes(elements) {
+	const bytes = new Uint8Array(elements.length);
+	for (let index = 0; index < elements.length; index++) {
+		const value = elements[index];
+		if (typeof value !== "number" || !Number.isInteger(value)) throw new TypeError("Byte value must be an integer number");
+		if (value < 0 || value > 255) throw new RangeError("Byte value must be in [0, 255]");
+		bytes[index] = value;
+	}
+	return bytes;
+}
+function combineIntents(values) {
+	const branches = [];
+	for (const value of values) if (Array.isArray(value)) for (const branch of value) branches.push(branch);
+	else branches.push(value);
+	return Object.freeze(branches);
+}
+/** Structural comparison deliberately does not shortcut identical objects containing NaN. */
+function equalValues(left, right) {
+	if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return left === right;
+	if (isByteSequence(left) || isByteSequence(right)) {
+		if (!isByteSequence(left) || !isByteSequence(right) || left.length !== right.length) return false;
+		for (let i = 0; i < left.length; i++) if (left[i] !== right[i]) return false;
+		return true;
+	}
+	const a = left;
+	const b = right;
+	const keys = Object.keys(a);
+	if (keys.length !== Object.keys(b).length) return false;
+	for (const key of keys) if (!Object.hasOwn(b, key) || !equalValues(a[key], b[key])) return false;
+	return true;
+}
+function isByteSequence(value) {
+	return Array.isArray(value) || ArrayBuffer.isView(value) || "length" in value && Symbol.iterator in value;
+}
+function readIndex(value, index) {
+	if (typeof index !== "number" || !Number.isSafeInteger(index)) throw new TypeError("Index must be a safe integer number");
+	if (index < 0 || index >= value.length) throw new RangeError("Index is outside the value");
+	return value[index];
+}
+function nonNull(value) {
+	if (value === null) throw new TypeError("Expected a non-null value");
+	return value;
+}
+function checkBoolean(value) {
+	if (typeof value !== "boolean") throw new TypeError("Condition must be a boolean");
+	return value;
+}
+function checkDuration(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) throw new TypeError("Duration must be a finite integer number");
+	if (value < 0 || value > 72e14) throw new RangeError("Duration must be in [0, 7200000000000000] picoseconds");
+	return value;
+}
+function checkPc(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError("Redirect target must be a finite number");
+	return value;
+}
+function reactionValue(frame, binding) {
+	if (!frame) throw new TypeError("Reaction value requires a reaction frame");
+	return frame[binding];
+}
+function reactionCapture(frame, index) {
+	if (!frame || index >= frame.captures.length) throw new RangeError("Reaction capture is not available");
+	return frame.captures[index];
+}
+var terminated = Symbol("terminated call");
+/** Propagate terminal control across yield* even if a driver mistakenly resumes it. */
+function* delegate(generator) {
+	let done = false;
+	try {
+		let step = generator.next();
+		while (!step.done) {
+			const signal = step.value;
+			const input = yield signal;
+			if (signal.kind === "stop" || signal.kind === "redirect") return terminated;
+			step = generator.next(input);
+		}
+		done = true;
+		return step.value;
+	} finally {
+		if (!done) generator.return(void 0);
+	}
+}
+var runtimeHelpers = Object.freeze({
+	createEnum,
+	createRecord,
+	createBytes,
+	combineIntents,
+	equalValues,
+	readIndex,
+	nonNull,
+	checkBoolean,
+	checkDuration,
+	checkPc,
+	reactionValue,
+	reactionCapture,
+	delegate,
+	terminated
+});
+//#endregion
+//#region src/analysis.ts
+function sourceSnapshot(source) {
+	return source.uri === void 0 ? Object.freeze({ ...source }) : Object.freeze({
+		...source,
+		range: Object.freeze({
+			start: Object.freeze({ ...source.range.start }),
+			end: Object.freeze({ ...source.range.end })
+		})
+	});
+}
+function typeSnapshot(type) {
+	return type.kind === "optional" ? Object.freeze({
+		...type,
+		inner: Object.freeze({ ...type.inner })
+	}) : Object.freeze({ ...type });
+}
+function inputs(op) {
+	switch (op.kind) {
+		case "unary":
+		case "field":
+		case "length":
+		case "optional":
+		case "isNone":
+		case "nonNull":
+		case "localWrite":
+		case "write":
+		case "writeIntent":
+		case "send":
+		case "match":
+		case "returnValue":
+		case "yield": return [op.value];
+		case "binary": return [op.left, op.right];
+		case "numeric": return [...op.args];
+		case "record": return op.fields.map((field) => field.value);
+		case "bytes": return [...op.elements];
+		case "index": return [op.value, op.index];
+		case "local": return [op.initial];
+		case "load8":
+		case "load16le":
+		case "load16be":
+		case "load32le":
+		case "load32be": return [op.offset];
+		case "store8":
+		case "store16le":
+		case "store16be":
+		case "store32le":
+		case "store32be": return [op.offset, op.value];
+		case "copyBytes": return [op.offset, op.length];
+		case "resistor": return [op.resistance];
+		case "combineIntents": return [...op.values];
+		case "call":
+		case "callValue": return op.args.flatMap((arg) => arg.kind === "value" ? [arg.value] : []);
+		case "if":
+		case "select":
+		case "assert": return [op.condition];
+		case "and":
+		case "or": return [op.left];
+		case "wait":
+		case "elapse": return [op.duration];
+		case "redirect": return [op.target, op.delay];
+		default: return [];
+	}
+}
+function argumentUses(op) {
+	const uses = [];
+	const ref = (input) => {
+		if (input.kind === "parameter") uses.push(`argument:${input.index}`);
+	};
+	if ("memory" in op) ref(op.memory);
+	if ("pin" in op) ref(op.pin);
+	if (op.kind === "resistor") ref(op.to);
+	if (op.kind === "refEqual") {
+		ref(op.left);
+		ref(op.right);
+	}
+	if (op.kind === "call" || op.kind === "callValue") op.args.forEach((arg) => {
+		if (arg.kind !== "value") ref(arg);
+	});
+	if (op.kind === "parameter") uses.push(`argument:${op.index}`);
+	if (op.kind === "reactionValue" || op.kind === "reactionCapture") uses.push("reaction");
+	return uses;
+}
+function resourceName(ref) {
+	return ref.kind === "parameter" ? `$${ref.index}` : ref.name;
+}
+function effects(op) {
+	const reads = [], writes = [], calls = [];
+	const call = op.kind === "call" || op.kind === "callValue";
+	const maySuspend = call || [
+		"wait",
+		"elapse",
+		"receive",
+		"waitUntil",
+		"redirect"
+	].includes(op.kind);
+	const mayThrow = call || [
+		"read",
+		"write",
+		"readSample",
+		"writeIntent",
+		"resistor",
+		"bytes",
+		"index",
+		"nonNull",
+		"field",
+		"length",
+		"memoryLength",
+		"copyBytes",
+		"send",
+		"receive",
+		"notify",
+		"now",
+		"random",
+		"reactionValue",
+		"reactionCapture",
+		"if",
+		"select",
+		"and",
+		"or",
+		"assert",
+		"wait",
+		"elapse",
+		"redirect"
+	].includes(op.kind) || op.kind.startsWith("load") || op.kind.startsWith("store");
+	if (op.kind === "read") reads.push(`${op.resource}:${op.name}`);
+	if (op.kind === "write") writes.push(`state:${op.name}`);
+	if ("memory" in op) (op.kind.startsWith("store") ? writes : reads).push(`memory:${resourceName(op.memory)}`);
+	if (op.kind === "readSample") reads.push(`pin:${resourceName(op.pin)}`);
+	if (op.kind === "writeIntent") writes.push(`pin:${resourceName(op.pin)}`);
+	if (op.kind === "send") writes.push(`channel:${op.channel}`);
+	if (op.kind === "receive") {
+		reads.push(`channel:${op.channel}`);
+		writes.push(`channel:${op.channel}`);
+	}
+	if (op.kind === "notify") writes.push(`notification:${op.notification}`);
+	if (op.kind === "waitUntil") {
+		reads.push("*");
+		calls.push(op.predicate);
+	}
+	if (call) {
+		calls.push(op.name);
+		reads.push("*");
+		writes.push("*");
+	}
+	return Object.freeze({
+		reads: Object.freeze(reads),
+		writes: Object.freeze(writes),
+		calls: Object.freeze(calls),
+		operations: Object.freeze([op.kind]),
+		maySuspend,
+		mayThrow,
+		mayRedirect: call || op.kind === "redirect",
+		mayStop: call || op.kind === "stop",
+		timeDependent: call || op.kind === "now",
+		random: call || op.kind === "random"
+	});
+}
+function fold(op, known) {
+	const values = inputs(op);
+	if (values.some((id) => !known.has(id))) return void 0;
+	const a = known.get(values[0]), b = known.get(values[1]);
+	switch (op.kind) {
+		case "constant": {
+			const c = op.constant;
+			if (c.kind === "none") return { value: null };
+			if (c.kind === "enum") return { value: c.member };
+			if (c.kind === "number" || c.kind === "bool" || c.kind === "string") return { value: c.value };
+			return;
+		}
+		case "optional": return { value: a };
+		case "isNone": return { value: a === null };
+		case "nonNull": return a === null ? void 0 : { value: a };
+		case "unary":
+			switch (op.operator) {
+				case "positive": return { value: +a };
+				case "negate": return { value: -a };
+				case "not": return { value: !a };
+				case "bitNot": return { value: ~a };
+			}
+			break;
+		case "binary": {
+			const x = a, y = b;
+			switch (op.operator) {
+				case "add": return { value: x + y };
+				case "subtract": return { value: x - y };
+				case "multiply": return { value: x * y };
+				case "divide": return { value: x / y };
+				case "remainder": return { value: x % y };
+				case "power": return { value: x ** y };
+				case "lessThan": return { value: x < y };
+				case "lessThanOrEqual": return { value: x <= y };
+				case "greaterThan": return { value: x > y };
+				case "greaterThanOrEqual": return { value: x >= y };
+				case "equal": return { value: a === b };
+				case "notEqual": return { value: a !== b };
+				case "concat": return { value: a + b };
+				case "bitAnd": return { value: x & y };
+				case "bitOr": return { value: x | y };
+				case "bitXor": return { value: x ^ y };
+				case "shiftLeft": return { value: x << y };
+				case "shiftRight": return { value: x >> y };
+				case "shiftRightUnsigned": return { value: x >>> y };
+			}
+			break;
+		}
+		case "numeric": {
+			const args = op.args.map((id) => known.get(id));
+			if (op.builtin === "isNaN") return { value: Number.isNaN(args[0]) };
+			if (op.builtin === "isFinite") return { value: Number.isFinite(args[0]) };
+			if (op.builtin === "isInteger") return { value: Number.isInteger(args[0]) };
+			if (op.builtin === "isSafeInteger") return { value: Number.isSafeInteger(args[0]) };
+			const fn = Math[op.builtin];
+			return { value: fn(...args) };
+		}
+	}
+}
+function removable(op, types, folded) {
+	switch (op.kind) {
+		case "constant": return op.constant.kind !== "bytes" && op.constant.kind !== "record";
+		case "parameter":
+		case "localRead":
+		case "optional":
+		case "isNone":
+		case "unary":
+		case "numeric": return true;
+		case "nonNull": return folded.has(op.result);
+		case "binary": {
+			if (op.operator !== "equal" && op.operator !== "notEqual") return true;
+			let type = types.get(op.left);
+			if (type?.kind === "optional") type = type.inner;
+			return !!type && [
+				"number",
+				"string",
+				"bool",
+				"enum"
+			].includes(type.kind);
+		}
+		default: return false;
+	}
+}
+function attributes(op) {
+	const copy = (value) => {
+		if (value === null || typeof value !== "object") return value;
+		if (Array.isArray(value)) return Object.freeze(value.map(copy));
+		return Object.freeze(Object.fromEntries(Object.entries(value).filter(([, value]) => value !== void 0).map(([key, value]) => [key, copy(value)])));
+	};
+	return Object.freeze(Object.fromEntries(Object.entries(op).flatMap(([key, value]) => {
+		if ([
+			"kind",
+			"type",
+			"source",
+			"body",
+			"test",
+			"message",
+			"yes",
+			"no"
+		].includes(key) || value === void 0 || key === "right" && typeof value === "object") return [];
+		return [[key, copy(key === "arms" ? op.arms.map((arm) => arm.pattern) : value)]];
+	})));
+}
+function analyzeBody(body, options, metadata = true) {
+	return new Analyzer(body, options.optimize !== false, metadata).analyze();
+}
+var Analyzer = class {
+	optimize;
+	metadata;
+	nodes = [];
+	regions = [];
+	blocks = [];
+	blockSpecs = [];
+	buildingGraph = false;
+	edges = [];
+	byOperation = /* @__PURE__ */ new Map();
+	folded = /* @__PURE__ */ new Map();
+	eliminated = /* @__PURE__ */ new Set();
+	root;
+	throwExit;
+	stopExit;
+	redirectExit;
+	constructor(body, optimize, metadata) {
+		this.optimize = optimize;
+		this.metadata = metadata;
+		this.root = this.index(body, [], null, body.source);
+		this.throwExit = this.block(0, "throw");
+		this.stopExit = this.block(0, "stop");
+		this.redirectExit = this.block(0, "redirect");
+	}
+	block(region, role, position = null) {
+		const id = this.blockSpecs.length;
+		const spec = {
+			id,
+			region,
+			role,
+			position
+		};
+		this.blockSpecs.push(spec);
+		if (this.buildingGraph) this.blocks.push(this.allocateBlock(spec));
+		return id;
+	}
+	allocateBlock(spec) {
+		return {
+			...spec,
+			uses: /* @__PURE__ */ new Set(),
+			definitions: /* @__PURE__ */ new Set(),
+			liveIn: /* @__PURE__ */ new Set(),
+			liveOut: /* @__PURE__ */ new Set()
+		};
+	}
+	edge(from, to, kind, extra = {}) {
+		this.edges.push(Object.freeze({
+			from,
+			to,
+			kind,
+			...extra
+		}));
+	}
+	index(input, path, parent, inherited) {
+		const id = this.regions.length;
+		const region = {
+			id,
+			parent,
+			path: Object.freeze([...path]),
+			entry: this.block(id, "entry"),
+			exit: this.block(id, "exit"),
+			nodes: []
+		};
+		this.regions.push(region);
+		input.operations.forEach((operation, index) => {
+			const position = this.nodes.length;
+			const block = this.block(id, "operation", position);
+			const source = this.metadata ? operation.source ?? input.source ?? inherited : void 0;
+			let effectSummary;
+			const node = {
+				operation,
+				position,
+				block,
+				definitionBlock: block,
+				region: id,
+				path: Object.freeze([
+					...path,
+					"operations",
+					index
+				]),
+				inputs: Object.freeze(inputs(operation)),
+				get effects() {
+					return effectSummary ??= effects(operation);
+				},
+				children: /* @__PURE__ */ new Map(),
+				...source ? { source: sourceSnapshot(source) } : {}
+			};
+			region.nodes.push(node);
+			this.nodes.push(node);
+			this.byOperation.set(operation, node);
+			const child = (key, body, suffix = [key], inherited = source) => {
+				node.children.set(key, this.index(body, [...node.path, ...suffix], id, inherited));
+			};
+			switch (operation.kind) {
+				case "if":
+					child("yes", operation.yes);
+					if (operation.no) child("no", operation.no);
+					break;
+				case "match":
+					operation.arms.forEach((arm, i) => child(`arm${i}`, arm.body, [
+						"arms",
+						i,
+						"body"
+					], arm.source ?? source));
+					if (operation.otherwise) child("otherwise", operation.otherwise);
+					break;
+				case "while":
+					child("test", operation.test.body, ["test", "body"]);
+					child("body", operation.body);
+					break;
+				case "loop":
+					child("body", operation.body);
+					break;
+				case "select":
+					child("yes", operation.yes.body, ["yes", "body"]);
+					child("no", operation.no.body, ["no", "body"]);
+					break;
+				case "and":
+				case "or":
+					child("right", operation.right.body, ["right", "body"]);
+					break;
+				case "assert": if (operation.message) child("message", operation.message.body, ["message", "body"]);
+			}
+		});
+		return region;
+	}
+	link(region, target, context, exitKind = "next") {
+		this.edge(region.entry, region.nodes[0]?.block ?? region.exit, "next");
+		if (target !== null) this.edge(region.exit, target, exitKind);
+		region.nodes.forEach((node, index) => {
+			const op = node.operation, head = node.block;
+			const next = region.nodes[index + 1]?.block ?? region.exit;
+			const child = (key, destination = next, ctx = context, kind = "next") => {
+				const nested = node.children.get(key);
+				this.link(nested, destination, ctx, kind);
+				return nested;
+			};
+			const valueChild = (key, destination) => {
+				const nested = node.children.get(key);
+				this.link(nested, destination, { yieldTo: nested.exit });
+				return nested;
+			};
+			if (node.effects.mayThrow && op.kind !== "assert") this.edge(head, this.throwExit, "throw");
+			switch (op.kind) {
+				case "if":
+					this.edge(head, child("yes").entry, "true");
+					this.edge(head, node.children.has("no") ? child("no").entry : next, "false");
+					break;
+				case "match":
+					op.arms.forEach((_, i) => this.edge(head, child(`arm${i}`).entry, "arm", { arm: i }));
+					if (op.otherwise) this.edge(head, child("otherwise").entry, "default");
+					break;
+				case "while": {
+					const test = valueChild("test", null);
+					const loopContext = {
+						...context,
+						breakTo: next,
+						continueTo: test.entry
+					};
+					const body = child("body", test.entry, loopContext, "backedge");
+					this.edge(head, test.entry, "next");
+					this.edge(test.exit, body.entry, "true");
+					this.edge(test.exit, next, "false");
+					break;
+				}
+				case "loop": {
+					const body = node.children.get("body");
+					child("body", body.entry, {
+						...context,
+						breakTo: next,
+						continueTo: body.entry
+					}, "backedge");
+					this.edge(head, body.entry, "next");
+					break;
+				}
+				case "select":
+				case "and":
+				case "or": {
+					const join = this.block(region.id, "join", node.position);
+					node.definitionBlock = join;
+					this.edge(join, next, "next");
+					if (op.kind === "select") {
+						this.edge(head, valueChild("yes", join).entry, "true");
+						this.edge(head, valueChild("no", join).entry, "false");
+					} else {
+						const right = valueChild("right", join);
+						this.edge(head, right.entry, op.kind === "and" ? "true" : "false");
+						this.edge(head, join, op.kind === "and" ? "false" : "true", { value: op.left });
+					}
+					break;
+				}
+				case "assert": {
+					const failure = this.block(region.id, "throw", node.position);
+					node.failureBlock = failure;
+					this.edge(head, next, "true");
+					this.edge(failure, this.throwExit, "throw");
+					this.edge(head, op.message ? valueChild("message", failure).entry : failure, "false");
+					break;
+				}
+				case "break":
+					if (context.breakTo === void 0) throw new TypeError("Break has no loop target");
+					this.edge(head, context.breakTo, "break");
+					break;
+				case "continue":
+					if (context.continueTo === void 0) throw new TypeError("Continue has no loop target");
+					this.edge(head, context.continueTo, "continue");
+					break;
+				case "yield":
+					if (context.yieldTo === void 0) throw new TypeError("Yield has no value-region target");
+					this.edge(head, context.yieldTo, "yield", { value: op.value });
+					break;
+				case "return":
+				case "returnValue":
+					this.edge(head, this.root.exit, "return");
+					break;
+				case "redirect":
+					this.edge(head, this.redirectExit, "redirect");
+					break;
+				case "stop":
+					this.edge(head, this.stopExit, "stop");
+					break;
+				case "wait":
+				case "elapse":
+				case "receive":
+				case "waitUntil":
+				case "call":
+				case "callValue": {
+					const resume = this.block(region.id, "resume", node.position);
+					node.resumeBlock = resume;
+					const call = op.kind === "call" || op.kind === "callValue";
+					this.edge(head, resume, "suspend");
+					if (call) {
+						const completion = this.block(region.id, "join", node.position);
+						node.completionBlock = completion;
+						node.definitionBlock = completion;
+						this.edge(head, completion, "next");
+						this.edge(resume, resume, "suspend");
+						this.edge(resume, completion, "resume");
+						this.edge(completion, next, "next");
+						for (const from of [head, resume]) {
+							this.edge(from, this.redirectExit, "redirect");
+							this.edge(from, this.stopExit, "stop");
+						}
+						this.edge(resume, this.throwExit, "throw");
+					} else {
+						if (op.kind === "receive") node.definitionBlock = resume;
+						this.edge(resume, op.kind === "waitUntil" ? this.root.exit : next, "resume");
+						if (op.kind === "elapse") this.edge(head, next, "next");
+					}
+					break;
+				}
+				default: this.edge(head, next, "next");
+			}
+		});
+	}
+	analyze() {
+		const types = /* @__PURE__ */ new Map();
+		for (const node of this.nodes) if ("result" in node.operation) types.set(node.operation.result, node.operation.type);
+		const known = /* @__PURE__ */ new Map();
+		if (this.optimize) {
+			for (const node of this.nodes) {
+				if (!("result" in node.operation)) continue;
+				const constant = fold(node.operation, known);
+				if (constant) {
+					known.set(node.operation.result, constant.value);
+					if (node.operation.kind !== "constant") this.folded.set(node.position, constant.value);
+				}
+			}
+			const foldedByResult = /* @__PURE__ */ new Map();
+			for (const node of this.nodes) if ("result" in node.operation && this.folded.has(node.position)) foldedByResult.set(node.operation.result, this.folded.get(node.position));
+			const definitions = new Map(this.nodes.flatMap((node) => "result" in node.operation ? [[node.operation.result, node]] : []));
+			const required = /* @__PURE__ */ new Set();
+			const queue = [];
+			const require = (id) => {
+				if (!required.has(id)) {
+					required.add(id);
+					queue.push(id);
+				}
+			};
+			for (const node of this.nodes) if (!this.folded.has(node.position)) node.inputs.forEach(require);
+			for (let i = 0; i < queue.length; i++) {
+				const node = definitions.get(queue[i]);
+				if (node && !this.folded.has(node.position)) node.inputs.forEach(require);
+			}
+			for (const node of this.nodes) if ("result" in node.operation && !required.has(node.operation.result) && removable(node.operation, types, foldedByResult)) this.eliminated.add(node.position);
+		}
+		let completed;
+		const complete = () => completed ??= this.complete(known);
+		return {
+			nodes: this.nodes,
+			byOperation: this.byOperation,
+			folded: this.folded,
+			constants: known,
+			eliminated: this.eliminated,
+			optimizations: Object.freeze({
+				enabled: this.optimize,
+				foldedPositions: Object.freeze([...this.folded.keys()].filter((id) => !this.eliminated.has(id))),
+				eliminatedPositions: Object.freeze([...this.eliminated])
+			}),
+			get graph() {
+				return complete().graph;
+			},
+			get effects() {
+				return complete().effects;
+			},
+			get resources() {
+				return complete().resources;
+			}
+		};
+	}
+	complete(known) {
+		this.buildingGraph = true;
+		this.blocks = this.blockSpecs.map((spec) => this.allocateBlock(spec));
+		this.link(this.root, null, {});
+		for (const node of this.nodes) {
+			if (this.eliminated.has(node.position)) continue;
+			const block = this.blocks[node.block], op = node.operation;
+			if (!this.folded.has(node.position)) {
+				node.inputs.forEach((id) => block.uses.add(`value:${id}`));
+				argumentUses(op).forEach((key) => block.uses.add(key));
+				if (op.kind === "localRead") block.uses.add(`local:${op.local}`);
+			}
+			if ("result" in op) this.blocks[node.definitionBlock].definitions.add(`value:${op.result}`);
+			if (op.kind === "local" || op.kind === "localWrite") block.definitions.add(`local:${op.local}`);
+		}
+		const regionOutputs = /* @__PURE__ */ new Map();
+		for (const node of this.nodes) {
+			const child = node.operation.kind === "while" ? node.children.get("test") : node.operation.kind === "assert" ? node.children.get("message") : void 0;
+			if (!child) continue;
+			const key = `region:${child.id}`;
+			regionOutputs.set(child.exit, key);
+			this.blocks[node.failureBlock ?? child.exit].uses.add(key);
+		}
+		for (const edge of this.edges) if (edge.kind === "yield" && regionOutputs.has(edge.to)) this.blocks[edge.from].definitions.add(regionOutputs.get(edge.to));
+		const outgoing = this.blocks.map(() => []), incoming = this.blocks.map(() => []);
+		this.edges.forEach((edge) => {
+			outgoing[edge.from].push(edge.to);
+			incoming[edge.to].push(edge.from);
+		});
+		const baselineUses = this.blocks.map((block) => new Set([...block.uses].filter((key) => key.startsWith("region:"))));
+		const baselineDefinitions = this.blocks.map((block) => new Set([...block.definitions].filter((key) => key.startsWith("region:"))));
+		for (const node of this.nodes) {
+			const op = node.operation;
+			node.inputs.forEach((id) => baselineUses[node.block].add(`value:${id}`));
+			argumentUses(op).forEach((key) => baselineUses[node.block].add(key));
+			if (op.kind === "localRead") baselineUses[node.block].add(`local:${op.local}`);
+			if ("result" in op) baselineDefinitions[node.definitionBlock].add(`value:${op.result}`);
+			if (op.kind === "local" || op.kind === "localWrite") baselineDefinitions[node.block].add(`local:${op.local}`);
+		}
+		const liveness = (uses, definitions) => {
+			const input = this.blocks.map(() => /* @__PURE__ */ new Set());
+			const output = this.blocks.map(() => /* @__PURE__ */ new Set());
+			let changed = true;
+			while (changed) {
+				changed = false;
+				for (let i = this.blocks.length - 1; i >= 0; i--) {
+					const out = new Set(outgoing[i].flatMap((id) => [...input[id]]));
+					const incoming = /* @__PURE__ */ new Set([...uses[i], ...[...out].filter((key) => !definitions[i].has(key))]);
+					if (out.size !== output[i].size || [...out].some((key) => !output[i].has(key)) || incoming.size !== input[i].size || [...incoming].some((key) => !input[i].has(key))) {
+						changed = true;
+						output[i] = out;
+						input[i] = incoming;
+					}
+				}
+			}
+			return {
+				input,
+				output
+			};
+		};
+		const optimizedLive = liveness(this.blocks.map((block) => block.uses), this.blocks.map((block) => block.definitions));
+		const baselineLive = liveness(baselineUses, baselineDefinitions);
+		this.blocks.forEach((block, index) => {
+			block.liveIn = optimizedLive.input[index];
+			block.liveOut = optimizedLive.output[index];
+		});
+		const yieldInputs = /* @__PURE__ */ new Map();
+		for (const edge of this.edges) if (edge.kind === "yield" && edge.value !== void 0) {
+			const values = yieldInputs.get(edge.to) ?? [];
+			values.push(edge.value);
+			yieldInputs.set(edge.to, values);
+		}
+		const users = /* @__PURE__ */ new Map();
+		for (const node of this.nodes) for (const input of node.inputs) {
+			const positions = users.get(input) ?? [];
+			positions.push(node.position);
+			users.set(input, positions);
+		}
+		const values = this.nodes.flatMap((node) => {
+			const op = node.operation;
+			if (!("result" in op)) return [];
+			const phi = op.kind === "select" || op.kind === "and" || op.kind === "or";
+			const phiInputs = phi ? [...node.children.values()].flatMap((region) => yieldInputs.get(region.exit) ?? []) : [];
+			if (op.kind === "and" || op.kind === "or") phiInputs.unshift(op.left);
+			return [Object.freeze({
+				result: op.result,
+				type: typeSnapshot(op.type),
+				position: node.position,
+				region: node.region,
+				block: node.definitionBlock,
+				form: phi ? "phi" : "operation",
+				inputs: Object.freeze(phi ? phiInputs : [...node.inputs]),
+				users: Object.freeze(users.get(op.result) ?? []),
+				eliminated: this.eliminated.has(node.position),
+				folded: this.folded.has(node.position)
+			})];
+		});
+		const graph = Object.freeze({
+			entry: this.root.entry,
+			normalExit: this.root.exit,
+			regions: Object.freeze(this.regions.map(({ id, parent, path, entry, exit }) => Object.freeze({
+				id,
+				parent,
+				path,
+				entry,
+				exit
+			}))),
+			blocks: Object.freeze(this.blocks.map((block) => Object.freeze({
+				...block,
+				predecessors: Object.freeze([...new Set(incoming[block.id])]),
+				successors: Object.freeze([...new Set(outgoing[block.id])]),
+				uses: Object.freeze([...block.uses]),
+				definitions: Object.freeze([...block.definitions]),
+				liveIn: Object.freeze([...block.liveIn]),
+				liveOut: Object.freeze([...block.liveOut]),
+				baselineLiveIn: Object.freeze([...baselineLive.input[block.id]]),
+				baselineLiveOut: Object.freeze([...baselineLive.output[block.id]])
+			}))),
+			edges: Object.freeze([...this.edges]),
+			values: Object.freeze(values),
+			operations: Object.freeze(this.nodes.map((node) => Object.freeze({
+				position: node.position,
+				block: node.block,
+				region: node.region,
+				kind: node.operation.kind,
+				path: node.path,
+				...node.source ? { source: node.source } : {},
+				inputs: node.inputs,
+				attributes: attributes(node.operation),
+				regions: Object.freeze([...node.children].map(([role, region]) => Object.freeze({
+					role,
+					region: region.id
+				}))),
+				effects: node.effects,
+				eliminated: this.eliminated.has(node.position),
+				folded: this.folded.has(node.position)
+			})))
+		});
+		const summaries = this.nodes.map((node) => node.effects);
+		const union = (key) => Object.freeze([...new Set(summaries.flatMap((summary) => summary[key]))]);
+		const effectMetadata = Object.freeze({
+			reads: union("reads"),
+			writes: union("writes"),
+			calls: union("calls"),
+			operations: union("operations"),
+			maySuspend: summaries.some((e) => e.maySuspend),
+			mayRedirect: summaries.some((e) => e.mayRedirect),
+			mayStop: summaries.some((e) => e.mayStop),
+			timeDependent: summaries.some((e) => e.timeDependent),
+			random: summaries.some((e) => e.random)
+		});
+		const resources = new Set([...effectMetadata.reads, ...effectMetadata.writes].filter((key) => key !== "*"));
+		for (const node of this.nodes) {
+			const op = node.operation;
+			if (op.kind === "resistor") resources.add(`pin:${resourceName(op.to)}`);
+			if (op.kind === "refEqual") for (const ref of [op.left, op.right]) resources.add(`${ref.kind === "parameter" ? ref.resource : ref.kind}:${resourceName(ref)}`);
+			if (op.kind === "call" || op.kind === "callValue") {
+				for (const arg of op.args) if (arg.kind !== "value") resources.add(`${arg.kind === "parameter" ? arg.resource : arg.kind}:${resourceName(arg)}`);
+			}
+		}
+		return {
+			nodes: this.nodes,
+			byOperation: this.byOperation,
+			graph,
+			folded: this.folded,
+			constants: known,
+			eliminated: this.eliminated,
+			effects: effectMetadata,
+			resources: Object.freeze([...resources]),
+			optimizations: Object.freeze({
+				enabled: this.optimize,
+				foldedPositions: Object.freeze([...this.folded.keys()].filter((id) => !this.eliminated.has(id))),
+				eliminatedPositions: Object.freeze([...this.eliminated])
+			})
+		};
+	}
+};
+//#endregion
+//#region src/metadata.ts
+function layoutMetadata(analysis, ranges, resume, source, options, temporaries) {
+	const slots = [];
+	const byKey = /* @__PURE__ */ new Map();
+	const slotTypes = /* @__PURE__ */ new Map();
+	for (const node of analysis.nodes) {
+		const op = node.operation;
+		if ("result" in op) slotTypes.set(`value:${op.result}`, typeSnapshot(op.type));
+		if (op.kind === "local") slotTypes.set(`local:${op.local}`, typeSnapshot(op.type));
+		if (op.kind === "parameter") slotTypes.set(`argument:${op.index}`, typeSnapshot(op.type));
+		const resource = (ref) => {
+			if (ref.kind === "parameter" && ref.resource) slotTypes.set(`argument:${ref.index}`, Object.freeze({ kind: ref.resource }));
+		};
+		if ("memory" in op) resource(op.memory);
+		if ("pin" in op) resource(op.pin);
+		if (op.kind === "resistor") resource(op.to);
+		if (op.kind === "refEqual") {
+			resource(op.left);
+			resource(op.right);
+		}
+		if (op.kind === "call" || op.kind === "callValue") op.args.forEach((arg) => {
+			if (arg.kind !== "value") resource(arg);
+		});
+	}
+	const slot = (key, kind, name, region, definition, materialized = true) => {
+		if (byKey.has(key)) return;
+		byKey.set(key, slots.length);
+		slots.push(Object.freeze({
+			id: slots.length,
+			key,
+			kind,
+			name,
+			region,
+			definition,
+			materialized,
+			...slotTypes.has(key) ? { type: slotTypes.get(key) } : {}
+		}));
+	};
+	for (const node of analysis.nodes) {
+		const op = node.operation;
+		if ("result" in op) slot(`value:${op.result}`, "value", `v${op.result}`, node.region, node.position, !analysis.eliminated.has(node.position));
+		if (op.kind === "local") slot(`local:${op.local}`, "local", `l${op.local}`, node.region, node.position);
+	}
+	for (const temporary of temporaries) {
+		slotTypes.set(temporary.key, typeSnapshot(temporary.type));
+		slot(temporary.key, "temporary", temporary.name, temporary.region, temporary.definition);
+	}
+	for (const block of analysis.graph.blocks) for (const key of [
+		...block.uses,
+		...block.liveIn,
+		...block.baselineLiveIn
+	]) {
+		if (key.startsWith("argument:")) slot(key, "argument", `args[${key.slice(9)}]`, 0, null);
+		if (key === "reaction") slot(key, "reaction", "reaction", 0, null);
+	}
+	const materializations = Object.freeze([...analysis.constants].flatMap(([result, value]) => {
+		const id = byKey.get(`value:${result}`);
+		return id === void 0 ? [] : [Object.freeze({
+			slot: id,
+			kind: "constant",
+			value
+		})];
+	}));
+	const materializedConstants = new Set(materializations.map((item) => item.slot));
+	const requiredSlots = (keys) => Object.freeze(keys.flatMap((key) => {
+		const id = byKey.get(key);
+		return id === void 0 ? [] : [id];
+	}).sort((a, b) => a - b));
+	const captureSlots = (keys) => Object.freeze(requiredSlots(keys).filter((id) => slots[id].materialized && !materializedConstants.has(id)));
+	const liveSlots = (keys) => Object.freeze(keys.flatMap((key) => {
+		const id = byKey.get(key);
+		return id === void 0 || !slots[id].materialized ? [] : [id];
+	}).sort((a, b) => a - b));
+	const baseline = (node, phase, block = node.block) => Object.freeze({
+		position: node.position,
+		block,
+		phase
+	});
+	const nodeByPath = new Map(analysis.nodes.map((node) => [JSON.stringify(node.path), node]));
+	const lines = source.split("\n");
+	const lineRange = (line) => Object.freeze({
+		start: Object.freeze({
+			line,
+			column: (lines[line - 1]?.search(/\S/) ?? 0) + 1
+		}),
+		end: Object.freeze({
+			line,
+			column: (lines[line - 1]?.length ?? 0) + 1
+		})
+	});
+	const resumeMap = Object.freeze({ entries: Object.freeze(resume.map((point) => {
+		const node = nodeByPath.get(JSON.stringify(point.path));
+		const terminal = node.operation.kind === "redirect" || node.operation.kind === "stop" || node.operation.kind === "waitUntil";
+		const keys = terminal ? [] : analysis.graph.blocks[node.resumeBlock].liveIn;
+		return Object.freeze({
+			id: point.id,
+			kind: point.kind,
+			suspended: baseline(node, "before"),
+			baseline: baseline(node, point.delegated ? "delegate" : "after", node.resumeBlock ?? node.block),
+			generated: lineRange(point.line),
+			continuation: Object.freeze({
+				line: point.delegated ? point.line : Math.min(point.line + 1, lines.length),
+				column: point.delegated ? point.column : (lines[point.line]?.search(/\S/) ?? 0) + 1
+			}),
+			liveSlots: liveSlots(keys),
+			delegated: point.delegated,
+			terminal
+		});
+	})) });
+	const exitMap = [];
+	const exit = (node, reason, range, block = node.block) => {
+		exitMap.push(Object.freeze({
+			baseline: baseline(node, "before", block),
+			reason,
+			generated: range,
+			requiredSlots: requiredSlots(analysis.graph.blocks[block].baselineLiveIn),
+			captureSlots: captureSlots(analysis.graph.blocks[block].baselineLiveIn)
+		}));
+	};
+	for (const node of analysis.nodes) {
+		const range = ranges.get(node.position);
+		if (!range) continue;
+		exit(node, "deopt", lineRange(range.start.line));
+		if (node.effects.mayThrow && !analysis.folded.has(node.position)) {
+			if (node.operation.kind === "assert") {
+				let failureLine = range.start.line;
+				for (let line = range.start.line; line <= range.end.line; line++) if (lines[line - 1]?.includes("host.assert(")) failureLine = line;
+				exit(node, "throw", lineRange(failureLine), node.failureBlock);
+			} else exit(node, "throw", lineRange(range.start.line));
+		}
+		if (node.operation.kind === "return" || node.operation.kind === "returnValue") exit(node, "return", lineRange(range.start.line));
+	}
+	for (const point of resumeMap.entries) {
+		const keys = point.terminal ? [] : analysis.graph.blocks[point.baseline.block].baselineLiveIn;
+		exitMap.push(Object.freeze({
+			baseline: point.baseline,
+			reason: point.kind === "redirect" ? "redirect" : point.kind === "stop" ? "stop" : "suspend",
+			generated: point.generated,
+			requiredSlots: requiredSlots(keys),
+			captureSlots: captureSlots(keys)
+		}));
+	}
+	for (const point of exitMap) for (const id of point.requiredSlots) if (!slots[id].materialized && !materializedConstants.has(id)) throw new Error(`Missing baseline value for frame slot ${id} at position ${point.baseline.position}`);
+	const binding = options.binding ? Object.freeze({
+		...options.binding,
+		...options.binding.instruction ? { instruction: Object.freeze({ ...options.binding.instruction }) } : {}
+	}) : null;
+	return {
+		dependencies: Object.freeze({
+			binding,
+			reads: analysis.effects.reads,
+			writes: analysis.effects.writes,
+			calls: analysis.effects.calls,
+			resources: analysis.resources,
+			unresolvedCalls: analysis.effects.calls.length !== 0
+		}),
+		sourceMap: Object.freeze({ entries: Object.freeze(analysis.nodes.map((node) => Object.freeze({
+			position: node.position,
+			block: node.block,
+			path: node.path,
+			kind: node.operation.kind,
+			...node.source ? { source: node.source } : {},
+			generated: ranges.get(node.position) ?? null,
+			eliminated: analysis.eliminated.has(node.position),
+			folded: analysis.folded.has(node.position)
+		}))) }),
+		frameLayout: Object.freeze({
+			storage: "native-generator",
+			serializable: false,
+			slots: Object.freeze(slots),
+			materializations
+		}),
+		resumeMap,
+		exitMap: Object.freeze(exitMap)
+	};
+}
+//#endregion
+//#region src/compiler.ts
+var binaryOperators = {
+	add: "+",
+	subtract: "-",
+	multiply: "*",
+	divide: "/",
+	remainder: "%",
+	power: "**",
+	lessThan: "<",
+	lessThanOrEqual: "<=",
+	greaterThan: ">",
+	greaterThanOrEqual: ">=",
+	concat: "+",
+	bitAnd: "&",
+	bitOr: "|",
+	bitXor: "^",
+	shiftLeft: "<<",
+	shiftRight: ">>",
+	shiftRightUnsigned: ">>>"
+};
+var numericBuiltins = /* @__PURE__ */ new Set([
+	"isNaN",
+	"isFinite",
+	"isInteger",
+	"isSafeInteger",
+	"abs",
+	"floor",
+	"ceil",
+	"trunc",
+	"round",
+	"sqrt",
+	"min",
+	"max",
+	"pow"
+]);
+var numberBuiltins = /* @__PURE__ */ new Set([
+	"isNaN",
+	"isFinite",
+	"isInteger",
+	"isSafeInteger"
+]);
+/** Inputs must already have passed device-model validation and contextual binding. */
+function compileBody(region, options = {}) {
+	return new Emitter(analyzeBody(region, options, false), options, false).compileExecutable(region);
+}
+function compileBodyArtifact(region, options = {}) {
+	return new Emitter(analyzeBody(region, options), options).compile(region);
+}
+function compileComputation(computation, options = {}) {
+	return completeComputation(compileBody(computation.body, options));
+}
+function compileComputationArtifact(computation, options = {}) {
+	const body = compileBodyArtifact(computation.source && !computation.body.source ? {
+		...computation.body,
+		source: computation.source
+	} : computation.body, options);
+	return Object.freeze(Object.defineProperties({}, {
+		...Object.getOwnPropertyDescriptors(body),
+		execute: {
+			value: completeComputation(body.execute),
+			enumerable: true
+		}
+	}));
+}
+function completeComputation(body) {
+	return (host) => {
+		const generator = body(host);
+		const result = generator.next();
+		if (!result.done) {
+			generator.return(void 0);
+			throw new TypeError(`Computation unexpectedly suspended with ${result.value.kind}`);
+		}
+		return result.value;
+	};
+}
+function name(prefix, id) {
+	if (!Number.isSafeInteger(id) || id < 0) throw new TypeError("IR identifiers must be nonnegative safe integers");
+	return `${prefix}${id}`;
+}
+var value = (id) => name("v", id);
+var local = (id) => name("l", id);
+var quote = (text) => JSON.stringify(text);
+function snapshotSource(source) {
+	if (source.uri !== void 0) return Object.freeze({
+		...source,
+		range: Object.freeze({
+			start: Object.freeze({ ...source.range.start }),
+			end: Object.freeze({ ...source.range.end })
+		})
+	});
+	return Object.freeze({ ...source });
+}
+var Emitter = class {
+	analysis;
+	options;
+	captureMetadata;
+	constructor(analysis, options, captureMetadata = true) {
+		this.analysis = analysis;
+		this.options = options;
+		this.captureMetadata = captureMetadata;
+	}
+	ranges = /* @__PURE__ */ new Map();
+	temporaries = [];
+	lines = [];
+	constants = [];
+	primitiveConstants = /* @__PURE__ */ new Map();
+	negativeZero = Symbol("negative zero");
+	positions = [];
+	resume = [];
+	types = /* @__PURE__ */ new Map();
+	indent = 0;
+	serial = 0;
+	compileExecutable(region) {
+		return this.generate(region).execute;
+	}
+	compile(region) {
+		const generated = this.generate(region);
+		const analysis = this.analysis;
+		let layout;
+		const metadata = () => layout ??= layoutMetadata(analysis, this.ranges, this.resume, generated.source, this.options, this.temporaries);
+		return Object.freeze({
+			...generated,
+			positions: Object.freeze(this.positions.slice()),
+			resume: Object.freeze(this.resume.slice()),
+			optimizations: analysis.optimizations,
+			get effects() {
+				return analysis.effects;
+			},
+			get mir() {
+				return analysis.graph;
+			},
+			get dependencies() {
+				return metadata().dependencies;
+			},
+			get sourceMap() {
+				return metadata().sourceMap;
+			},
+			get frameLayout() {
+				return metadata().frameLayout;
+			},
+			get resumeMap() {
+				return metadata().resumeMap;
+			},
+			get exitMap() {
+				return metadata().exitMap;
+			}
+		});
+	}
+	generate(region) {
+		this.line("function* compiledBody(host, args = [], reaction) {");
+		this.indent++;
+		this.region(region, []);
+		this.indent--;
+		this.line("}");
+		const source = this.lines.join("\n");
+		const constants = Object.freeze(this.constants.slice());
+		return {
+			execute: new Function("C", "H", `"use strict"; return (${source});`)(constants, runtimeHelpers),
+			source,
+			constants
+		};
+	}
+	line(text) {
+		this.lines.push(`${"  ".repeat(this.indent)}${text}`);
+	}
+	block(header, body) {
+		this.line(`${header} {`);
+		this.indent++;
+		body();
+		this.indent--;
+		this.line("}");
+	}
+	capture(input) {
+		const primitive = input === null || typeof input !== "object";
+		const key = Object.is(input, -0) ? this.negativeZero : input;
+		const existing = primitive ? this.primitiveConstants.get(key) : void 0;
+		if (existing !== void 0) return `C[${existing}]`;
+		const index = this.constants.push(input) - 1;
+		if (primitive) this.primitiveConstants.set(key, index);
+		return `C[${index}]`;
+	}
+	ref(ref) {
+		return ref.kind === "parameter" ? `args[${ref.index}]` : this.capture(ref.name);
+	}
+	argument(argument) {
+		return argument.kind === "value" ? value(argument.value) : this.ref(argument);
+	}
+	constant(constant) {
+		switch (constant.kind) {
+			case "number":
+			case "bool":
+			case "string": return constant.value;
+			case "none": return null;
+			case "enum": return createEnum(constant.name, constant.member);
+			case "bytes": return Object.freeze(Array.from(createBytes(constant.value)));
+			case "record": return createRecord(constant.fields.map((field) => [field.name, field.value]));
+			default: return exhaustive(constant);
+		}
+	}
+	position(operation, path) {
+		const position = Object.freeze({
+			path: Object.freeze([...path]),
+			kind: operation.kind,
+			line: this.lines.length + 1,
+			column: this.indent * 2 + 1,
+			...this.analysis.byOperation.get(operation)?.source ? { source: snapshotSource(this.analysis.byOperation.get(operation).source) } : {}
+		});
+		this.positions.push(position);
+		return position;
+	}
+	suspension(position, delegated = false) {
+		if (!position) return;
+		this.resume.push(Object.freeze({
+			...position,
+			line: this.lines.length + 1,
+			column: this.indent * 2 + 1,
+			id: this.resume.length,
+			delegated
+		}));
+	}
+	region(region, path, output) {
+		region.operations.forEach((operation, index) => {
+			this.operation(operation, [
+				...path,
+				"operations",
+				index
+			], output);
+		});
+	}
+	valueRegion(region, slot, path) {
+		if (this.captureMetadata && !slot.startsWith("v")) {
+			const key = JSON.stringify([...path, "body"]);
+			const owner = this.analysis.nodes.find((node) => [...node.children.values()].some((child) => JSON.stringify(child.path) === key));
+			const nested = [...owner.children.values()].find((child) => JSON.stringify(child.path) === key);
+			this.temporaries.push({
+				key: `region:${nested.id}`,
+				name: slot,
+				region: owner.region,
+				definition: owner.position,
+				type: region.type
+			});
+		}
+		const label = `valueRegion${this.serial++}`;
+		this.block(`${label}:`, () => this.region(region.body, [...path, "body"], {
+			slot,
+			label
+		}));
+	}
+	equality(left, right) {
+		let type = this.types.get(left);
+		if (type?.kind === "optional") type = type.inner;
+		if (type && (type.kind === "number" || type.kind === "string" || type.kind === "bool")) return `(${value(left)} === ${value(right)})`;
+		return `H.equalValues(${value(left)}, ${value(right)})`;
+	}
+	operation(operation, path, output) {
+		if ("result" in operation) this.types.set(operation.result, operation.type);
+		const node = this.analysis.byOperation.get(operation);
+		if (this.analysis.eliminated.has(node.position)) return;
+		const position = this.captureMetadata ? this.position(operation, path) : void 0;
+		try {
+			if ("result" in operation && this.analysis.folded.has(node.position)) this.line(`const ${value(operation.result)} = ${this.capture(this.analysis.folded.get(node.position))};`);
+			else this.emitOperation(operation, path, position, output);
+		} finally {
+			if (position) this.ranges.set(node.position, Object.freeze({
+				start: Object.freeze({
+					line: position.line,
+					column: position.column
+				}),
+				end: Object.freeze({
+					line: this.lines.length,
+					column: this.lines[this.lines.length - 1].length + 1
+				})
+			}));
+		}
+	}
+	emitOperation(operation, path, position, output) {
+		const assign = (expression) => {
+			if (!("result" in operation)) throw new TypeError("Expected a result-producing operation");
+			this.line(`const ${value(operation.result)} = ${expression};`);
+		};
+		const child = (region, key) => this.region(region, [...path, key], output);
+		switch (operation.kind) {
+			case "constant": {
+				const captured = this.capture(this.constant(operation.constant));
+				assign(operation.constant.kind === "bytes" ? `H.createBytes(${captured})` : captured);
+				break;
+			}
+			case "read":
+				assign(`host.read(${this.capture(operation.resource)}, ${this.capture(operation.name)})`);
+				break;
+			case "parameter":
+				assign(`args[${operation.index}]`);
+				break;
+			case "reactionValue":
+				assign(`H.reactionValue(reaction, ${quote(operation.binding)})`);
+				break;
+			case "reactionCapture":
+				assign(`H.reactionCapture(reaction, ${operation.index})`);
+				break;
+			case "unary": {
+				const operator = {
+					positive: "+",
+					negate: "-",
+					not: "!",
+					bitNot: "~"
+				}[operation.operator];
+				if (!operator) throw new TypeError("Unknown unary operator");
+				assign(`(${operator}${value(operation.value)})`);
+				break;
+			}
+			case "binary":
+				if (operation.operator === "equal" || operation.operator === "notEqual") assign(`${operation.operator === "notEqual" ? "!" : ""}${this.equality(operation.left, operation.right)}`);
+				else {
+					const operator = binaryOperators[operation.operator];
+					if (!operator) throw new TypeError("Unknown binary operator");
+					assign(`(${value(operation.left)} ${operator} ${value(operation.right)})`);
+				}
+				break;
+			case "numeric":
+				if (!numericBuiltins.has(operation.builtin)) throw new TypeError("Unknown numeric builtin");
+				assign(`${numberBuiltins.has(operation.builtin) ? "Number" : "Math"}.${operation.builtin}(${operation.args.map(value).join(", ")})`);
+				break;
+			case "record":
+				assign(`H.createRecord([${operation.fields.map((field) => `[${this.capture(field.name)}, ${value(field.value)}]`).join(", ")}])`);
+				break;
+			case "field":
+				assign(`${value(operation.value)}[${this.capture(operation.field)}]`);
+				break;
+			case "bytes":
+				assign(`H.createBytes([${operation.elements.map(value).join(", ")}])`);
+				break;
+			case "length":
+				assign(`${value(operation.value)}.length`);
+				break;
+			case "index":
+				assign(`H.readIndex(${value(operation.value)}, ${value(operation.index)})`);
+				break;
+			case "optional":
+				assign(value(operation.value));
+				break;
+			case "isNone":
+				assign(`(${value(operation.value)} === null)`);
+				break;
+			case "nonNull":
+				assign(`H.nonNull(${value(operation.value)})`);
+				break;
+			case "localRead":
+				assign(local(operation.local));
+				break;
+			case "local":
+				this.line(`let ${local(operation.local)} = ${value(operation.initial)};`);
+				break;
+			case "localWrite":
+				this.line(`${local(operation.local)} = ${value(operation.value)};`);
+				break;
+			case "write":
+				this.line(`host.write(${this.capture(operation.name)}, ${value(operation.value)});`);
+				break;
+			case "memoryLength":
+				assign(`host.memoryLength(${this.ref(operation.memory)})`);
+				break;
+			case "load8":
+			case "load16le":
+			case "load16be":
+			case "load32le":
+			case "load32be":
+				assign(`host.load(${quote(operation.kind)}, ${this.ref(operation.memory)}, ${value(operation.offset)})`);
+				break;
+			case "store8":
+			case "store16le":
+			case "store16be":
+			case "store32le":
+			case "store32be":
+				this.line(`host.store(${quote(operation.kind)}, ${this.ref(operation.memory)}, ${value(operation.offset)}, ${value(operation.value)});`);
+				break;
+			case "copyBytes":
+				assign(`host.copyBytes(${this.ref(operation.memory)}, ${value(operation.offset)}, ${value(operation.length)})`);
+				break;
+			case "readSample":
+				assign(`host.sample(${this.ref(operation.pin)})`);
+				break;
+			case "resistor":
+				assign(`host.resistor(${this.ref(operation.to)}, ${value(operation.resistance)})`);
+				break;
+			case "combineIntents":
+				assign(`H.combineIntents([${operation.values.map(value).join(", ")}])`);
+				break;
+			case "refEqual":
+				assign(`(${this.ref(operation.left)} === ${this.ref(operation.right)})`);
+				break;
+			case "writeIntent":
+				this.line(`host.intent(${this.ref(operation.pin)}, ${value(operation.value)});`);
+				break;
+			case "call":
+			case "callValue": {
+				this.suspension(position, true);
+				const slot = `call${this.serial++}`;
+				this.line(`const ${slot} = yield* H.delegate(host.call(${this.capture(operation.name)}, [${operation.args.map((argument) => this.argument(argument)).join(", ")}]));`);
+				this.line(`if (${slot} === H.terminated) return;`);
+				if (operation.kind === "callValue") assign(slot);
+				break;
+			}
+			case "send":
+				this.line(`host.send(${this.capture(operation.channel)}, ${value(operation.value)});`);
+				break;
+			case "notify":
+				this.line(`host.notify(${this.capture(operation.notification)});`);
+				break;
+			case "receive":
+				this.suspension(position);
+				assign(`yield { kind: "receive", channel: ${this.capture(operation.channel)} }`);
+				break;
+			case "now":
+				assign("host.now()");
+				break;
+			case "random":
+				assign("host.random()");
+				break;
+			case "if":
+				this.block(`if (H.checkBoolean(${value(operation.condition)}))`, () => child(operation.yes, "yes"));
+				if (operation.no) this.block("else", () => child(operation.no, "no"));
+				break;
+			case "match":
+				operation.arms.forEach((arm, index) => {
+					const pattern = arm.pattern;
+					const constant = pattern.kind === "none" ? null : pattern.kind === "enum" ? createEnum(pattern.name, pattern.member) : pattern.value;
+					this.block(`${index ? "else if" : "if"} (H.equalValues(${value(operation.value)}, ${this.capture(constant)}))`, () => {
+						this.region(arm.body, [
+							...path,
+							"arms",
+							index,
+							"body"
+						], output);
+					});
+				});
+				if (operation.otherwise) this.block(operation.arms.length ? "else" : "", () => child(operation.otherwise, "otherwise"));
+				break;
+			case "while":
+				this.block("while (true)", () => {
+					const slot = `condition${this.serial++}`;
+					this.line(`let ${slot};`);
+					this.valueRegion(operation.test, slot, [...path, "test"]);
+					this.line(`if (!H.checkBoolean(${slot})) break;`);
+					this.block("", () => child(operation.body, "body"));
+				});
+				break;
+			case "loop":
+				this.block("while (true)", () => child(operation.body, "body"));
+				break;
+			case "and":
+			case "or": {
+				const slot = value(operation.result);
+				this.line(`let ${slot} = H.checkBoolean(${value(operation.left)});`);
+				this.block(`if (${operation.kind === "or" ? "!" : ""}${slot})`, () => {
+					this.valueRegion(operation.right, slot, [...path, "right"]);
+					this.line(`${slot} = H.checkBoolean(${slot});`);
+				});
+				break;
+			}
+			case "select": {
+				const slot = value(operation.result);
+				this.line(`let ${slot};`);
+				this.block(`if (H.checkBoolean(${value(operation.condition)}))`, () => this.valueRegion(operation.yes, slot, [...path, "yes"]));
+				this.block("else", () => this.valueRegion(operation.no, slot, [...path, "no"]));
+				break;
+			}
+			case "assert":
+				this.block(`if (!H.checkBoolean(${value(operation.condition)}))`, () => {
+					if (operation.message) {
+						const slot = `message${this.serial++}`;
+						this.line(`let ${slot};`);
+						this.valueRegion(operation.message, slot, [...path, "message"]);
+						this.line(`host.assert(false, ${slot});`);
+					} else this.line("host.assert(false, undefined);");
+				});
+				break;
+			case "wait":
+			case "elapse": {
+				const duration = `duration${this.serial++}`;
+				this.line(`const ${duration} = H.checkDuration(${value(operation.duration)});`);
+				this.suspension(position);
+				const signal = `yield { kind: ${quote(operation.kind === "wait" ? "ticks" : "elapse")}, duration: ${duration} };`;
+				if (operation.kind === "elapse") this.line(`if (${duration} !== 0) ${signal}`);
+				else this.line(signal);
+				break;
+			}
+			case "waitUntil":
+				this.suspension(position);
+				this.line(`yield { kind: "waitUntil", predicate: ${this.capture(operation.predicate)} };`);
+				this.line("return;");
+				break;
+			case "redirect":
+				this.suspension(position);
+				this.line(`yield { kind: "redirect", pc: H.checkPc(${value(operation.target)}), delay: H.checkDuration(${value(operation.delay)}) };`);
+				this.line("return;");
+				break;
+			case "stop":
+				this.suspension(position);
+				this.line("yield { kind: \"stop\" };");
+				this.line("return;");
+				break;
+			case "return":
+				this.line("return;");
+				break;
+			case "returnValue":
+				this.line(`return ${value(operation.value)};`);
+				break;
+			case "break":
+				this.line("break;");
+				break;
+			case "continue":
+				this.line("continue;");
+				break;
+			case "yield":
+				if (!output) throw new TypeError("Value-region yield is outside a value region");
+				this.line(`${output.slot} = ${value(operation.value)};`);
+				this.line(`break ${output.label};`);
+				break;
+			default: exhaustive(operation);
+		}
+	}
+};
+function exhaustive(value) {
+	throw new TypeError(`Unsupported IR operation: ${String(value.kind)}`);
+}
+//#endregion
+//#region src/direct-jit.ts
+var binary = {
+	add: "+",
+	subtract: "-",
+	multiply: "*",
+	divide: "/",
+	remainder: "%",
+	power: "**",
+	lessThan: "<",
+	lessThanOrEqual: "<=",
+	greaterThan: ">",
+	greaterThanOrEqual: ">=",
+	equal: "===",
+	notEqual: "!==",
+	bitAnd: "&",
+	bitOr: "|",
+	bitXor: "^",
+	shiftLeft: "<<",
+	shiftRight: ">>",
+	shiftRightUnsigned: ">>>"
+};
+var numeric = /* @__PURE__ */ new Set([
+	"isNaN",
+	"isFinite",
+	"isInteger",
+	"isSafeInteger",
+	"abs",
+	"floor",
+	"ceil",
+	"trunc",
+	"round",
+	"sqrt",
+	"min",
+	"max",
+	"pow"
+]);
+var predicates = /* @__PURE__ */ new Set([
+	"isNaN",
+	"isFinite",
+	"isInteger",
+	"isSafeInteger"
+]);
+function offset(memory, value) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new TypeError("offset must be a safe integer");
+	if (value < 0) throw new RangeError("offset must be nonnegative");
+	if (value >= memory.length) throw new RangeError("Memory range is out of bounds");
+	return value;
+}
+function byte(value) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new TypeError("stored value must be a safe integer");
+	return value;
+}
+var helpers = Object.freeze({
+	checkBoolean,
+	checkPc,
+	offset,
+	byte
+});
+var unsupported = Symbol("unsupported direct instruction");
+/** Inputs have already passed model validation and contextual binding. */
+function compileDirectJit(instructions, binding) {
+	if (!validIndex(binding.pc.index) || binding.states.get(binding.pc.name) !== binding.pc.index) return void 0;
+	const constants = [];
+	const capture = (value) => `C[${constants.push(value) - 1}]`;
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const instruction of instructions) {
+		if (!Number.isFinite(instruction.pc) || seen.has(instruction.pc)) continue;
+		seen.add(instruction.pc);
+		if (!Number.isFinite(instruction.nextPc)) continue;
+		try {
+			entries.push(new Instruction(binding, capture).compile(instruction));
+		} catch (error) {
+			if (error !== unsupported) throw error;
+		}
+	}
+	if (!entries.length) return void 0;
+	const localCount = Math.max(...entries.map((entry) => entry.slots.length));
+	const registers = Array.from({ length: localCount }, (_, index) => `v${index}`);
+	const lines = [
+		"function run(F, deadline) {",
+		"const S = F.states, M = F.memories, L = F.locals, SD = F.stateDirty, MD = F.memoryDirty;",
+		...registers.length ? [`let ${registers.join(",")};`] : [],
+		"while (true) {",
+		"if (F.time >= deadline) return \"deadline\";",
+		"if (F.resume !== 0) {",
+		"if (F.due >= deadline) { F.time = deadline; return \"deadline\"; }",
+		"F.time = Math.max(F.time, F.due);",
+		"switch (F.resume) {"
+	];
+	entries.forEach((entry, index) => {
+		lines.push(`case ${index + 1}: {`);
+		entry.slots.forEach((slot, slotIndex) => lines.push(`${slot} = L[${slotIndex}];`));
+		lines.push("F.resume = 0;", ...entry.suffix, finish(entry.stop), "}");
+	});
+	lines.push("default: throw new TypeError(\"Unknown direct JIT continuation\");", "}", "}", "if (F.stopAfterInstruction) return \"invalidated\";", `switch (H.checkPc(S[${binding.pc.index}])) {`);
+	entries.forEach((entry, index) => {
+		lines.push(`case ${entry.pc}: {`, `S[${binding.pc.index}] = ${entry.nextPc};`, dirty("SD", binding.pc.index), ...entry.prefix);
+		if (entry.duration !== void 0) {
+			lines.push(`F.due = F.time + ${entry.duration};`, "if (F.due > 7200000000000000) throw new RangeError(\"Time out of range\");", "if (F.due >= deadline) {");
+			entry.slots.forEach((slot, slotIndex) => lines.push(`L[${slotIndex}] = ${slot};`));
+			lines.push(`F.resume = ${index + 1};`, "F.time = deadline;", "return \"deadline\";", "}");
+			lines.push("F.time = F.due;");
+		}
+		lines.push(...entry.suffix, finish(entry.stop), "}");
+	});
+	lines.push("default: return \"fallback\";", "}", "}", "}");
+	const factory = new Function("C", "H", `"use strict"; return (${lines.join("\n")});`);
+	const names = (field) => Object.freeze([...new Set(entries.flatMap((entry) => [...entry[field]]))]);
+	return Object.freeze({
+		run: factory(Object.freeze(constants), helpers),
+		localCount,
+		readStates: names("readStates"),
+		writeStates: names("writeStates"),
+		readMemories: names("readMemories"),
+		writeMemories: names("writeMemories")
+	});
+}
+function finish(stop) {
+	return stop ? "return \"stopped\";" : "if (F.stopAfterInstruction) return \"invalidated\"; continue;";
+}
+function dirty(bank, index) {
+	return `${bank}[${index >>> 5}] |= ${1 << (index & 31)};`;
+}
+function validIndex(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var Instruction = class {
+	binding;
+	capture;
+	readStates = /* @__PURE__ */ new Set();
+	writeStates = /* @__PURE__ */ new Set();
+	readMemories = /* @__PURE__ */ new Set();
+	writeMemories = /* @__PURE__ */ new Set();
+	slots = [];
+	prefix = [];
+	suffix = [];
+	pc = "";
+	nextPc = "";
+	duration;
+	stop = false;
+	values = /* @__PURE__ */ new Map();
+	locals = /* @__PURE__ */ new Map();
+	literals = /* @__PURE__ */ new Map();
+	labels = 0;
+	constructor(binding, capture) {
+		this.binding = binding;
+		this.capture = capture;
+	}
+	compile(instruction) {
+		this.pc = this.capture(instruction.pc);
+		this.nextPc = this.capture(instruction.nextPc);
+		this.readStates.add(this.binding.pc.name);
+		this.state(this.binding.pc.name, true);
+		let output = this.prefix;
+		let terminal = false;
+		for (const operation of instruction.body.operations) {
+			if (terminal) throw unsupported;
+			if (operation.kind === "elapse") {
+				if (this.duration !== void 0) throw unsupported;
+				this.duration = this.delay(operation.duration);
+				output = this.suffix;
+			} else if (operation.kind === "redirect") {
+				if (this.duration !== void 0) throw unsupported;
+				const duration = this.delay(operation.delay);
+				output.push(`S[${this.binding.pc.index}] = H.checkPc(${this.value(operation.target)});`, dirty("SD", this.binding.pc.index));
+				this.duration = duration;
+				output = this.suffix;
+				terminal = true;
+			} else if (operation.kind === "stop") {
+				this.stop = true;
+				terminal = true;
+			} else this.operation(operation, output);
+		}
+		if (this.duration === void 0 && !this.stop) throw unsupported;
+		return this;
+	}
+	delay(id) {
+		const duration = this.literals.get(id);
+		if (typeof duration !== "number") throw unsupported;
+		try {
+			checkDuration(duration);
+		} catch {
+			throw unsupported;
+		}
+		if (duration <= 0) throw unsupported;
+		return this.capture(duration);
+	}
+	value(id) {
+		const slot = this.values.get(id);
+		if (!slot) throw unsupported;
+		return slot;
+	}
+	slot() {
+		const slot = `v${this.slots.length}`;
+		this.slots.push(slot);
+		return slot;
+	}
+	state(name, write) {
+		const index = this.binding.states.get(name);
+		if (!validIndex(index) || write && this.binding.blockedStates?.has(name)) throw unsupported;
+		(write ? this.writeStates : this.readStates).add(name);
+		return index;
+	}
+	memory(operation) {
+		if (operation.memory.kind !== "memory") throw unsupported;
+		const name = operation.memory.name;
+		const index = this.binding.memories.get(name);
+		if (!validIndex(index) || operation.kind !== "load8" && this.binding.blockedMemories?.has(name)) throw unsupported;
+		(operation.kind === "load8" ? this.readMemories : this.writeMemories).add(name);
+		return index;
+	}
+	region(region, lines, output) {
+		for (const operation of region.operations) if (operation.kind === "yield") {
+			if (!output) throw unsupported;
+			lines.push(`${output.slot} = ${this.value(operation.value)}; break ${output.label};`);
+		} else this.operation(operation, lines, output);
+	}
+	operation(operation, lines, output) {
+		let result;
+		if ("result" in operation) {
+			if (operation.type.kind !== "number" && operation.type.kind !== "bool") throw unsupported;
+			result = this.slot();
+			this.values.set(operation.result, result);
+		}
+		const assign = (expression) => {
+			lines.push(`${result} = ${expression};`);
+		};
+		switch (operation.kind) {
+			case "constant":
+				if (operation.constant.kind !== "number" && operation.constant.kind !== "bool") throw unsupported;
+				this.literals.set(operation.result, operation.constant.value);
+				assign(this.capture(operation.constant.value));
+				break;
+			case "read":
+				if (operation.resource !== "state") throw unsupported;
+				assign(`S[${this.state(operation.name, false)}]`);
+				break;
+			case "write": {
+				const index = this.state(operation.name, true);
+				lines.push(`S[${index}] = ${this.value(operation.value)};`, dirty("SD", index));
+				break;
+			}
+			case "unary": {
+				const operator = {
+					positive: "+",
+					negate: "-",
+					not: "!",
+					bitNot: "~"
+				}[operation.operator];
+				if (!operator) throw unsupported;
+				assign(`(${operator}${this.value(operation.value)})`);
+				break;
+			}
+			case "binary": {
+				const operator = binary[operation.operator];
+				if (!operator) throw unsupported;
+				assign(`(${this.value(operation.left)} ${operator} ${this.value(operation.right)})`);
+				break;
+			}
+			case "numeric":
+				if (!numeric.has(operation.builtin)) throw unsupported;
+				assign(`${predicates.has(operation.builtin) ? "Number" : "Math"}.${operation.builtin}(${operation.args.map((id) => this.value(id)).join(",")})`);
+				break;
+			case "local": {
+				if (operation.type.kind !== "number" && operation.type.kind !== "bool") throw unsupported;
+				const slot = this.slot();
+				this.locals.set(operation.local, slot);
+				lines.push(`${slot} = ${this.value(operation.initial)};`);
+				break;
+			}
+			case "localRead": {
+				const slot = this.locals.get(operation.local);
+				if (!slot) throw unsupported;
+				assign(slot);
+				break;
+			}
+			case "localWrite": {
+				const slot = this.locals.get(operation.local);
+				if (!slot) throw unsupported;
+				lines.push(`${slot} = ${this.value(operation.value)};`);
+				break;
+			}
+			case "load8": {
+				const memory = `M[${this.memory(operation)}]`;
+				assign(`${memory}[H.offset(${memory},${this.value(operation.offset)})]`);
+				break;
+			}
+			case "store8": {
+				const index = this.memory(operation);
+				const memory = `M[${index}]`;
+				lines.push(`${memory}[H.offset(${memory},${this.value(operation.offset)})] = H.byte(${this.value(operation.value)});`, dirty("MD", index));
+				break;
+			}
+			case "if":
+				lines.push(`if (H.checkBoolean(${this.value(operation.condition)})) {`);
+				this.region(operation.yes, lines, output);
+				if (operation.no) {
+					lines.push("} else {");
+					this.region(operation.no, lines, output);
+				}
+				lines.push("}");
+				break;
+			case "select": {
+				const label = `select${this.labels++}`;
+				lines.push(`${label}: {`, `if (H.checkBoolean(${this.value(operation.condition)})) {`);
+				this.region(operation.yes.body, lines, {
+					slot: result,
+					label
+				});
+				lines.push("} else {");
+				this.region(operation.no.body, lines, {
+					slot: result,
+					label
+				});
+				lines.push("}", "}");
+				break;
+			}
+			default: throw unsupported;
+		}
+	}
+};
+//#endregion
+export { checkBoolean, checkDuration, checkPc, combineIntents, compileBody, compileBodyArtifact, compileComputation, compileComputationArtifact, compileDirectJit, createBytes, createEnum, createRecord, equalValues, nonNull, reactionCapture, reactionValue, readIndex };
+
+//# sourceMappingURL=index.js.map