@mica-js/device-model 0.0.0-stage → 0.5.0

package/dist/index.js

@@ -0,0 +1,3433 @@
+//#region src/errors.ts
+function snapshot(input, ancestors = /* @__PURE__ */ new Set(), path = []) {
+	if (input === null || typeof input !== "object") {
+		if (typeof input === "function" || typeof input === "symbol" || typeof input === "bigint") fail("IR_SCHEMA", "Expected ordinary IR data.", path);
+		return input;
+	}
+	if (ancestors.has(input)) fail("IR_SCHEMA", "Cyclic IR data is not supported.", path);
+	ancestors.add(input);
+	let output;
+	if (input instanceof Uint8Array) output = Object.freeze(Array.from(Uint8Array.prototype.values.call(input)));
+	else if (Array.isArray(input)) {
+		if (Object.getPrototypeOf(input) !== Array.prototype) fail("IR_SCHEMA", "Expected an ordinary IR array.");
+		const result = [];
+		for (const key of Reflect.ownKeys(input)) {
+			if (key === "length") continue;
+			if (typeof key !== "string" || !/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= input.length) fail("IR_SCHEMA", "IR arrays cannot contain extra properties.");
+			if (!("value" in Object.getOwnPropertyDescriptor(input, key))) fail("IR_SCHEMA", "IR arrays cannot contain accessors.");
+		}
+		for (let i = 0; i < input.length; i++) {
+			if (!Object.hasOwn(input, i)) fail("IR_SCHEMA", "IR arrays cannot be sparse.");
+			result.push(snapshot(Object.getOwnPropertyDescriptor(input, i).value, ancestors, [...path, i]));
+		}
+		output = Object.freeze(result);
+	} else {
+		const prototype = Object.getPrototypeOf(input);
+		if (prototype !== Object.prototype && prototype !== null) fail("IR_SCHEMA", "Expected an ordinary data object.");
+		const result = {};
+		for (const key of Reflect.ownKeys(input)) {
+			const descriptor = Object.getOwnPropertyDescriptor(input, key);
+			if (typeof key !== "string" || !("value" in descriptor)) fail("IR_SCHEMA", "IR data cannot contain symbols or accessors.");
+			Object.defineProperty(result, key, {
+				value: snapshot(descriptor.value, ancestors, [...path, key]),
+				enumerable: true
+			});
+		}
+		output = Object.freeze(result);
+	}
+	ancestors.delete(input);
+	return output;
+}
+var BuildError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		if (!diagnostics.length) throw new TypeError("BuildError requires at least one diagnostic.");
+		super(diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.name = "BuildError";
+		this.diagnostics = snapshot(diagnostics);
+	}
+};
+function fail(code, message, path = [], phase = "finalize", source) {
+	throw new BuildError([{
+		code,
+		message,
+		path,
+		phase,
+		related: [],
+		...source === void 0 ? {} : { source }
+	}]);
+}
+//#endregion
+//#region src/schema.ts
+var builtins = Object.freeze({
+	Logic: [
+		"low",
+		"high",
+		"unknown"
+	],
+	SampleStatus: ["valid", "floating"],
+	Overflow: [
+		"drop_new",
+		"drop_oldest",
+		"error"
+	]
+});
+var unary = [
+	"positive",
+	"negate",
+	"not",
+	"bitNot"
+];
+var binary = [
+	"add",
+	"subtract",
+	"multiply",
+	"divide",
+	"remainder",
+	"power",
+	"lessThan",
+	"lessThanOrEqual",
+	"greaterThan",
+	"greaterThanOrEqual",
+	"equal",
+	"notEqual",
+	"concat",
+	"bitAnd",
+	"bitOr",
+	"bitXor",
+	"shiftLeft",
+	"shiftRight",
+	"shiftRightUnsigned"
+];
+var numeric = [
+	"isNaN",
+	"isFinite",
+	"isInteger",
+	"isSafeInteger",
+	"abs",
+	"floor",
+	"ceil",
+	"trunc",
+	"round",
+	"sqrt",
+	"min",
+	"max",
+	"pow"
+];
+var loads = [
+	"load8",
+	"load16le",
+	"load16be",
+	"load32le",
+	"load32be"
+];
+var stores = [
+	"store8",
+	"store16le",
+	"store16be",
+	"store32le",
+	"store32be"
+];
+var valueKinds = [
+	"number",
+	"bool",
+	"string",
+	"bytes",
+	"sample",
+	"intent",
+	"enum",
+	"record"
+];
+function object(value, path) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) fail("IR_SCHEMA", "Expected a data object.", path);
+}
+function fields(n, required, optional, p, located = true) {
+	for (const key of required) if (!Object.hasOwn(n, key)) fail("IR_SCHEMA", `Missing field ${key}.`, [...p, key]);
+	for (const key of Object.keys(n)) if (![
+		...required,
+		...optional,
+		...located ? ["source"] : []
+	].includes(key)) fail("IR_SCHEMA", `Unexpected field ${key}.`, [...p, key]);
+	if (Object.hasOwn(n, "source")) source(n.source, [...p, "source"]);
+}
+function text(v, p) {
+	if (typeof v !== "string") fail("IR_SCHEMA", "Expected a string.", p);
+}
+function bool(v, p) {
+	if (typeof v !== "boolean") fail("IR_SCHEMA", "Expected a boolean.", p);
+}
+function num(v, p) {
+	if (typeof v !== "number") fail("IR_SCHEMA", "Expected a number.", p);
+}
+function id(v, p) {
+	if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0) fail("IR_SCHEMA", "Expected a nonnegative safe integer.", p);
+}
+function choice(v, choices, p) {
+	if (!choices.includes(v)) fail("IR_SCHEMA", `Expected one of ${choices.join(", ")}.`, p);
+}
+function list(v, p, visit) {
+	if (!Array.isArray(v)) fail("IR_SCHEMA", "Expected an array.", p);
+	for (let i = 0; i < v.length; i++) visit(v[i], [...p, i]);
+}
+function source(v, p) {
+	object(v, p);
+	const hasUri = Object.hasOwn(v, "uri");
+	for (const key of Object.keys(v)) if (![
+		"uri",
+		"range",
+		"label"
+	].includes(key)) fail("IR_SCHEMA", "Invalid source field.", [...p, key]);
+	if (Object.hasOwn(v, "label")) text(v.label, [...p, "label"]);
+	if (!hasUri) {
+		if (!Object.hasOwn(v, "label") || Object.hasOwn(v, "range")) fail("IR_SCHEMA", "Source requires a label or URI and range.", p);
+		return;
+	}
+	text(v.uri, [...p, "uri"]);
+	object(v.range, [...p, "range"]);
+	const r = v.range;
+	for (const key of Object.keys(r)) if (!["start", "end"].includes(key)) fail("IR_SCHEMA", "Invalid range field.", [
+		...p,
+		"range",
+		key
+	]);
+	for (const key of ["start", "end"]) {
+		const position = r[key];
+		object(position, [
+			...p,
+			"range",
+			key
+		]);
+		for (const k of Object.keys(position)) if (!["line", "column"].includes(k)) fail("IR_SCHEMA", "Invalid position field.", [
+			...p,
+			"range",
+			key,
+			k
+		]);
+		for (const k of ["line", "column"]) if (!Number.isSafeInteger(position[k]) || position[k] < 1) fail("IR_SCHEMA", "Positions start at one.", [
+			...p,
+			"range",
+			key,
+			k
+		]);
+	}
+	const { start, end } = r;
+	if (end.line < start.line || end.line === start.line && end.column < start.column) fail("IR_SCHEMA", "Source range is reversed.", p);
+}
+function valueType(v, p, optional = true) {
+	object(v, p);
+	if (v.kind === "optional" && optional) {
+		fields(v, ["kind", "inner"], [], p);
+		valueType(v.inner, [...p, "inner"], false);
+	} else {
+		choice(v.kind, valueKinds, [...p, "kind"]);
+		fields(v, ["kind", ...["enum", "record"].includes(v.kind) ? ["name"] : []], [], p);
+		if (["enum", "record"].includes(v.kind)) text(v.name, [...p, "name"]);
+	}
+	if (Object.hasOwn(v, "source")) fail("IR_SCHEMA", "Type descriptors cannot carry source information.", p);
+}
+function ref(v, p, category) {
+	object(v, p);
+	if (Object.hasOwn(v, "source")) fail("IR_SCHEMA", "Resource references cannot carry source information.", p);
+	choice(v.kind, [
+		"pin",
+		"memory",
+		"parameter"
+	], [...p, "kind"]);
+	if (v.kind === "parameter") {
+		fields(v, [
+			"kind",
+			"resource",
+			"index"
+		], [], p);
+		choice(v.resource, ["pin", "memory"], [...p, "resource"]);
+		id(v.index, [...p, "index"]);
+		if (category && v.resource !== category) fail("IR_REFERENCE", "Resource category does not match.", p);
+	} else {
+		fields(v, ["kind", "name"], [], p);
+		text(v.name, [...p, "name"]);
+		if (category && v.kind !== category) fail("IR_REFERENCE", "Resource category does not match.", p);
+	}
+}
+function constant(v, p, pattern = false) {
+	object(v, p);
+	if (Object.hasOwn(v, "source")) fail("IR_SCHEMA", "Constants and patterns cannot carry source information.", p);
+	const choices = pattern ? [
+		"number",
+		"bool",
+		"string",
+		"enum",
+		"none"
+	] : [
+		"number",
+		"bool",
+		"string",
+		"bytes",
+		"enum",
+		"record",
+		"none"
+	];
+	choice(v.kind, choices, [...p, "kind"]);
+	switch (v.kind) {
+		case "none":
+			fields(v, ["kind"], [], p);
+			break;
+		case "enum":
+			fields(v, [
+				"kind",
+				"name",
+				"member"
+			], [], p);
+			text(v.name, [...p, "name"]);
+			text(v.member, [...p, "member"]);
+			break;
+		case "record":
+			fields(v, [
+				"kind",
+				"name",
+				"fields"
+			], [], p);
+			text(v.name, [...p, "name"]);
+			list(v.fields, [...p, "fields"], (f, q) => {
+				object(f, q);
+				fields(f, ["name", "value"], [], q);
+				text(f.name, [...q, "name"]);
+				if (!["number", "boolean"].includes(typeof f.value)) fail("IR_SCHEMA", "Expected a number or boolean field.", [...q, "value"]);
+			});
+			break;
+		case "bytes":
+			fields(v, ["kind", "value"], [], p);
+			list(v.value, [...p, "value"], (n, q) => {
+				if (!Number.isInteger(n) || n < 0 || n > 255) fail("IR_SCHEMA", "Expected a byte.", q);
+			});
+			break;
+		default:
+			fields(v, ["kind", "value"], [], p);
+			if (v.kind === "number") {
+				num(v.value, [...p, "value"]);
+				if (pattern && !Number.isFinite(v.value)) fail("IR_CONTROL_FLOW", "Numeric match patterns must be finite.", p);
+			} else if (v.kind === "bool") bool(v.value, [...p, "value"]);
+			else text(v.value, [...p, "value"]);
+	}
+}
+function region(v, p) {
+	object(v, p);
+	fields(v, ["operations"], [], p);
+	list(v.operations, [...p, "operations"], operation);
+}
+function computation(v, p) {
+	object(v, p);
+	fields(v, ["type", "body"], [], p);
+	valueType(v.type, [...p, "type"]);
+	region(v.body, [...p, "body"]);
+}
+function operation(v, p) {
+	object(v, p);
+	text(v.kind, [...p, "kind"]);
+	let required = [], optional = [], result = false;
+	const resultFields = (names) => {
+		required = names;
+		result = true;
+	};
+	switch (v.kind) {
+		case "constant":
+			resultFields(["constant"]);
+			constant(v.constant, [...p, "constant"]);
+			break;
+		case "read":
+			resultFields(["resource", "name"]);
+			choice(v.resource, [
+				"property",
+				"const",
+				"state",
+				"derived"
+			], [...p, "resource"]);
+			text(v.name, [...p, "name"]);
+			break;
+		case "parameter":
+		case "reactionCapture":
+			resultFields(["index"]);
+			id(v.index, [...p, "index"]);
+			break;
+		case "reactionValue":
+			resultFields(["binding"]);
+			choice(v.binding, ["previous", "current"], [...p, "binding"]);
+			break;
+		case "unary":
+			resultFields(["operator", "value"]);
+			choice(v.operator, unary, [...p, "operator"]);
+			break;
+		case "binary":
+			resultFields([
+				"operator",
+				"left",
+				"right"
+			]);
+			choice(v.operator, binary, [...p, "operator"]);
+			break;
+		case "numeric":
+			resultFields(["builtin", "args"]);
+			choice(v.builtin, numeric, [...p, "builtin"]);
+			list(v.args, [...p, "args"], id);
+			break;
+		case "record":
+			resultFields(["fields"]);
+			list(v.fields, [...p, "fields"], (f, q) => {
+				object(f, q);
+				fields(f, ["name", "value"], [], q);
+				text(f.name, [...q, "name"]);
+				id(f.value, [...q, "value"]);
+			});
+			break;
+		case "field":
+			resultFields(["value", "field"]);
+			text(v.field, [...p, "field"]);
+			break;
+		case "bytes":
+			resultFields(["elements"]);
+			list(v.elements, [...p, "elements"], id);
+			break;
+		case "length":
+		case "optional":
+		case "isNone":
+		case "nonNull":
+			resultFields(["value"]);
+			break;
+		case "index":
+			resultFields(["value", "index"]);
+			id(v.index, [...p, "index"]);
+			break;
+		case "localRead":
+			resultFields(["local"]);
+			id(v.local, [...p, "local"]);
+			break;
+		case "local":
+			required = [
+				"local",
+				"type",
+				"initial"
+			];
+			id(v.local, [...p, "local"]);
+			valueType(v.type, [...p, "type"]);
+			break;
+		case "localWrite":
+			required = ["local", "value"];
+			id(v.local, [...p, "local"]);
+			break;
+		case "write":
+			required = [
+				"resource",
+				"name",
+				"value"
+			];
+			choice(v.resource, ["state"], [...p, "resource"]);
+			text(v.name, [...p, "name"]);
+			break;
+		case "memoryLength":
+			resultFields(["memory"]);
+			ref(v.memory, [...p, "memory"], "memory");
+			break;
+		case "load8":
+		case "load16le":
+		case "load16be":
+		case "load32le":
+		case "load32be":
+			resultFields(["memory", "offset"]);
+			ref(v.memory, [...p, "memory"], "memory");
+			break;
+		case "store8":
+		case "store16le":
+		case "store16be":
+		case "store32le":
+		case "store32be":
+			required = [
+				"memory",
+				"offset",
+				"value"
+			];
+			ref(v.memory, [...p, "memory"], "memory");
+			break;
+		case "copyBytes":
+			resultFields([
+				"memory",
+				"offset",
+				"length"
+			]);
+			ref(v.memory, [...p, "memory"], "memory");
+			break;
+		case "readSample":
+			resultFields(["pin"]);
+			ref(v.pin, [...p, "pin"], "pin");
+			break;
+		case "resistor":
+			resultFields(["to", "resistance"]);
+			ref(v.to, [...p, "to"], "pin");
+			break;
+		case "combineIntents":
+			resultFields(["values"]);
+			list(v.values, [...p, "values"], id);
+			break;
+		case "refEqual":
+			resultFields(["left", "right"]);
+			ref(v.left, [...p, "left"]);
+			ref(v.right, [...p, "right"]);
+			break;
+		case "writeIntent":
+			required = ["pin", "value"];
+			ref(v.pin, [...p, "pin"], "pin");
+			break;
+		case "call":
+		case "callValue":
+			required = [
+				"name",
+				"pure",
+				"args"
+			];
+			result = v.kind === "callValue";
+			text(v.name, [...p, "name"]);
+			bool(v.pure, [...p, "pure"]);
+			list(v.args, [...p, "args"], (a, q) => {
+				object(a, q);
+				if (a.kind === "value") {
+					fields(a, ["kind", "value"], [], q);
+					id(a.value, [...q, "value"]);
+				} else ref(a, q);
+			});
+			break;
+		case "send":
+			required = ["channel", "value"];
+			text(v.channel, [...p, "channel"]);
+			break;
+		case "notify":
+			required = ["notification"];
+			text(v.notification, [...p, "notification"]);
+			break;
+		case "receive":
+			resultFields(["channel"]);
+			text(v.channel, [...p, "channel"]);
+			break;
+		case "now":
+		case "random":
+			resultFields([]);
+			break;
+		case "if":
+			required = ["condition", "yes"];
+			optional = ["no"];
+			region(v.yes, [...p, "yes"]);
+			if (Object.hasOwn(v, "no")) region(v.no, [...p, "no"]);
+			break;
+		case "match":
+			required = ["value", "arms"];
+			optional = ["otherwise"];
+			list(v.arms, [...p, "arms"], (a, q) => {
+				object(a, q);
+				fields(a, ["pattern", "body"], [], q);
+				constant(a.pattern, [...q, "pattern"], true);
+				region(a.body, [...q, "body"]);
+			});
+			if (Object.hasOwn(v, "otherwise")) region(v.otherwise, [...p, "otherwise"]);
+			break;
+		case "while":
+			required = ["test", "body"];
+			computation(v.test, [...p, "test"]);
+			region(v.body, [...p, "body"]);
+			break;
+		case "loop":
+			required = ["body"];
+			region(v.body, [...p, "body"]);
+			break;
+		case "and":
+		case "or":
+			resultFields(["left", "right"]);
+			computation(v.right, [...p, "right"]);
+			break;
+		case "select":
+			resultFields([
+				"condition",
+				"yes",
+				"no"
+			]);
+			computation(v.yes, [...p, "yes"]);
+			computation(v.no, [...p, "no"]);
+			break;
+		case "assert":
+			required = ["condition"];
+			optional = ["message"];
+			if (Object.hasOwn(v, "message")) computation(v.message, [...p, "message"]);
+			break;
+		case "wait":
+		case "elapse":
+			required = ["duration"];
+			break;
+		case "waitUntil":
+			required = ["predicate"];
+			text(v.predicate, [...p, "predicate"]);
+			break;
+		case "redirect":
+			required = ["target", "delay"];
+			break;
+		case "return":
+		case "break":
+		case "continue":
+		case "stop": break;
+		case "returnValue":
+		case "yield":
+			required = ["value"];
+			break;
+		default: fail("IR_SCHEMA", `Unknown operation ${v.kind}.`, [...p, "kind"]);
+	}
+	fields(v, [
+		"kind",
+		...required,
+		...result ? ["result", "type"] : []
+	], optional, p);
+	if (result) {
+		id(v.result, [...p, "result"]);
+		valueType(v.type, [...p, "type"]);
+	}
+	for (const key of [
+		"value",
+		"left",
+		"right",
+		"condition",
+		"initial",
+		"offset",
+		"length",
+		"resistance",
+		"duration",
+		"target",
+		"delay"
+	]) if (Object.hasOwn(v, key) && typeof v[key] !== "object" && !(key === "value" && ["constant", "read"].includes(v.kind))) id(v[key], [...p, key]);
+	else if (Object.hasOwn(v, key) && typeof v[key] === "object" && ![
+		"refEqual",
+		"and",
+		"or"
+	].includes(v.kind)) fail("IR_SCHEMA", "Expected a result identifier.", [...p, key]);
+}
+function deviceSchema(v) {
+	object(v, []);
+	fields(v, [
+		"kind",
+		"name",
+		"declarations"
+	], [], []);
+	choice(v.kind, ["device"], ["kind"]);
+	text(v.name, ["name"]);
+	list(v.declarations, ["declarations"], (d, p) => {
+		object(d, p);
+		text(d.kind, [...p, "kind"]);
+		const required = ["kind"];
+		let optional = [];
+		if (!["start", "assert"].includes(d.kind)) {
+			required.push("name");
+			text(d.name, [...p, "name"]);
+		}
+		switch (d.kind) {
+			case "enum":
+				required.push("members");
+				list(d.members, [...p, "members"], text);
+				break;
+			case "record":
+				required.push("fields");
+				list(d.fields, [...p, "fields"], (f, q) => {
+					object(f, q);
+					fields(f, ["name", "type"], [], q);
+					text(f.name, [...q, "name"]);
+					choice(f.type, ["number", "bool"], [...q, "type"]);
+				});
+				break;
+			case "property":
+				required.push("type");
+				optional = ["default"];
+				if (Object.hasOwn(d, "default")) computation(d.default, [...p, "default"]);
+				break;
+			case "const":
+			case "derived":
+				required.push("type", "value");
+				computation(d.value, [...p, "value"]);
+				break;
+			case "state":
+				required.push("type", "initial");
+				computation(d.initial, [...p, "initial"]);
+				break;
+			case "pin":
+				optional = [
+					"initial",
+					"low",
+					"high"
+				];
+				for (const k of optional) if (Object.hasOwn(d, k)) computation(d[k], [...p, k]);
+				if (Object.hasOwn(d, "low") !== Object.hasOwn(d, "high")) fail("IR_SCHEMA", "Pin thresholds must be provided together.", p);
+				break;
+			case "memory":
+				required.push("public", "length");
+				bool(d.public, [...p, "public"]);
+				computation(d.length, [...p, "length"]);
+				break;
+			case "channel":
+				required.push("direction", "type", "capacity");
+				optional = ["maxLength", "overflow"];
+				computation(d.capacity, [...p, "capacity"]);
+				for (const k of optional) if (Object.hasOwn(d, k)) computation(d[k], [...p, k]);
+				break;
+			case "notification":
+				required.push("direction");
+				break;
+			case "function":
+				required.push("pure", "params", "body");
+				optional = ["returns"];
+				bool(d.pure, [...p, "pure"]);
+				list(d.params, [...p, "params"], (param, q) => {
+					object(param, q);
+					fields(param, ["name", "type"], [], q);
+					text(param.name, [...q, "name"]);
+					object(param.type, [...q, "type"]);
+					if (["pin", "memory"].includes(param.type.kind)) fields(param.type, ["kind"], [], [...q, "type"]);
+					else valueType(param.type, [...q, "type"]);
+				});
+				if (Object.hasOwn(d, "returns")) valueType(d.returns, [...p, "returns"]);
+				region(d.body, [...p, "body"]);
+				break;
+			case "start":
+			case "assert":
+				required.push("body");
+				region(d.body, [...p, "body"]);
+				break;
+			case "on":
+				required.push("sourcePath", "body");
+				list(d.sourcePath, [...p, "sourcePath"], text);
+				region(d.body, [...p, "body"]);
+				break;
+			case "reaction":
+				required.push("sourcePath", "sourceType", "previous", "current", "captures", "body");
+				list(d.sourcePath, [...p, "sourcePath"], text);
+				valueType(d.sourceType, [...p, "sourceType"]);
+				text(d.previous, [...p, "previous"]);
+				text(d.current, [...p, "current"]);
+				list(d.captures, [...p, "captures"], (c, q) => {
+					object(c, q);
+					fields(c, ["name", "value"], [], q);
+					text(c.name, [...q, "name"]);
+					computation(c.value, [...q, "value"]);
+				});
+				region(d.body, [...p, "body"]);
+				break;
+			default: fail("IR_SCHEMA", `Unknown declaration ${d.kind}.`, [...p, "kind"]);
+		}
+		fields(d, required, optional, p);
+		if (Object.hasOwn(d, "type")) valueType(d.type, [...p, "type"]);
+		if (["channel", "notification"].includes(d.kind)) choice(d.direction, ["input", "output"], [...p, "direction"]);
+	});
+}
+function blockSchema(v) {
+	object(v, []);
+	fields(v, ["kind", "instructions"], [], []);
+	choice(v.kind, ["block"], ["kind"]);
+	list(v.instructions, ["instructions"], (instruction, p) => {
+		object(instruction, p);
+		fields(instruction, [
+			"pc",
+			"nextPc",
+			"body"
+		], [], p);
+		for (const key of ["pc", "nextPc"]) if (typeof instruction[key] !== "number" || !Number.isFinite(instruction[key])) fail("IR_SCHEMA", "Instruction positions must be finite numbers.", [...p, key]);
+		region(instruction.body, [...p, "body"]);
+	});
+	const instructions = v.instructions;
+	if (!instructions.length) fail("IR_JIT_BOUNDARY", "A block requires at least one instruction.", ["instructions"]);
+	for (let i = 1; i < instructions.length; i++) if (instructions[i - 1].nextPc !== instructions[i].pc) fail("IR_JIT_BOUNDARY", "Adjacent instruction boundaries do not match.", [
+		"instructions",
+		i,
+		"pc"
+	]);
+}
+//#endregion
+//#region src/validation.ts
+var numberType = { kind: "number" };
+var boolType = { kind: "bool" };
+var stringType = { kind: "string" };
+var bytesType = { kind: "bytes" };
+var intentType = { kind: "intent" };
+var sampleType = { kind: "sample" };
+var reserved = /* @__PURE__ */ new Set([
+	"device",
+	"default",
+	"const",
+	"let",
+	"enum",
+	"record",
+	"state",
+	"derived",
+	"pin",
+	"memory",
+	"fn",
+	"pure",
+	"process",
+	"on",
+	"reaction",
+	"as",
+	"capture",
+	"if",
+	"else",
+	"match",
+	"while",
+	"loop",
+	"break",
+	"continue",
+	"return",
+	"await",
+	"assert",
+	"redirect",
+	"true",
+	"false",
+	"none",
+	"start",
+	"number",
+	"bool",
+	"string",
+	"bytes",
+	"sample",
+	"intent",
+	"NaN",
+	"Infinity",
+	...Object.keys(builtins),
+	...numeric,
+	...loads,
+	...stores,
+	"resistor",
+	"copyBytes",
+	"now",
+	"random",
+	"ticks"
+]);
+function sameType(a, b) {
+	const left = a;
+	const right = b;
+	return left?.kind === right?.kind && (left?.kind === "optional" ? sameType(left.inner, right?.inner) : left?.kind === "enum" || left?.kind === "record" ? left.name === right?.name : true);
+}
+function inner(t) {
+	return t.kind === "optional" ? t.inner : t;
+}
+function comparable(t) {
+	return inner(t).kind !== "intent";
+}
+function copy(s) {
+	return {
+		facts: new Map(s.facts),
+		locals: new Map(s.locals)
+	};
+}
+function intersect(maps) {
+	const out = new Map(maps[0]);
+	for (const [k, v] of out) if (maps.some((map) => map.get(k) !== v)) out.delete(k);
+	return out;
+}
+function lexical(flow, visible) {
+	for (const state of [
+		flow.normal,
+		...flow.breaks,
+		...flow.continues,
+		...flow.yieldStates
+	]) if (state) {
+		for (const id of state.locals.keys()) if (!visible.has(id)) state.locals.delete(id);
+	}
+	return flow;
+}
+function merge(states) {
+	if (!states.length) return void 0;
+	const out = copy(states[0]);
+	out.facts = intersect(states.map((s) => s.facts));
+	for (const [id, slot] of out.locals) {
+		const candidates = states.map((s) => s.locals.get(id));
+		if (candidates.some((c) => !c)) {
+			out.locals.delete(id);
+			continue;
+		}
+		if (candidates.some((c) => c.value.key !== slot.value.key)) {
+			const info = {
+				type: slot.type,
+				key: `join:${id}:${candidates.map((c) => c.value.key).join("|")}`
+			};
+			const facts = candidates.map((c, i) => states[i].facts.get(c.value.key));
+			if (facts.every((f) => f === true)) out.facts.set(info.key, true);
+			if (facts.every((f) => f === false)) out.facts.set(info.key, false);
+			out.locals.set(id, {
+				type: slot.type,
+				value: info
+			});
+		}
+	}
+	return out;
+}
+function walk(region, visit, path = []) {
+	region.operations.forEach((op, i) => {
+		const p = [
+			...path,
+			"operations",
+			i
+		];
+		visit(op, p);
+		for (const key of [
+			"yes",
+			"no",
+			"otherwise",
+			"body"
+		]) {
+			const nested = key in op ? op[key] : void 0;
+			if (nested) {
+				const valueRegion = "body" in nested;
+				walk(valueRegion ? nested.body : nested, visit, [
+					...p,
+					key,
+					...valueRegion ? ["body"] : []
+				]);
+			}
+		}
+		if (op.kind === "while") walk(op.test.body, visit, [
+			...p,
+			"test",
+			"body"
+		]);
+		if (op.kind === "assert" && op.message) walk(op.message.body, visit, [
+			...p,
+			"message",
+			"body"
+		]);
+		if (op.kind === "and" || op.kind === "or") walk(op.right.body, visit, [
+			...p,
+			"right",
+			"body"
+		]);
+		if (op.kind === "match") op.arms.forEach((a, j) => walk(a.body, visit, [
+			...p,
+			"arms",
+			j,
+			"body"
+		]));
+	});
+}
+var Validator = class {
+	device;
+	declarations = /* @__PURE__ */ new Map();
+	paths = /* @__PURE__ */ new Map();
+	enums = new Map(Object.entries(builtins));
+	records = /* @__PURE__ */ new Map();
+	functions = /* @__PURE__ */ new Map();
+	effectChecked = /* @__PURE__ */ new Set();
+	receiveOwners = /* @__PURE__ */ new Map();
+	constructor(device) {
+		this.device = device;
+		if (!device) return;
+		this.name(device.name, ["name"]);
+		let starts = 0;
+		device.declarations.forEach((d, i) => {
+			const p = ["declarations", i];
+			if (d.kind === "start") {
+				if (++starts > 1) this.error("IR_REFERENCE", "Only one start process is allowed.", p);
+				return;
+			}
+			if (d.kind === "assert") return;
+			this.name(d.name, [...p, "name"]);
+			if (this.declarations.has(d.name)) this.error("IR_REFERENCE", `Duplicate declaration ${d.name}.`, p);
+			this.declarations.set(d.name, d);
+			this.paths.set(d.name, p);
+			if (d.kind === "enum") {
+				this.uniqueNames(d.members, [...p, "members"]);
+				if (!d.members.length) this.error("IR_TYPE", "An enum must have at least one member.", p);
+				this.enums.set(d.name, d.members);
+			}
+			if (d.kind === "record") {
+				this.uniqueNames(d.fields.map((f) => f.name), [...p, "fields"]);
+				this.records.set(d.name, d.fields);
+			}
+			if (d.kind === "function") this.functions.set(d.name, d);
+		});
+	}
+	error(code, message, path, node) {
+		return fail(code, message, path, "finalize", node?.source);
+	}
+	name(name, p) {
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || reserved.has(name)) this.error("IR_REFERENCE", `Invalid or reserved identifier ${name}.`, p);
+	}
+	uniqueNames(names, p, members = false) {
+		const seen = /* @__PURE__ */ new Set();
+		names.forEach((name, i) => {
+			if (members) {
+				if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) this.error("IR_REFERENCE", "Invalid member name.", [...p, i]);
+			} else this.name(name, [...p, i]);
+			if (seen.has(name)) this.error("IR_REFERENCE", `Duplicate name ${name}.`, [...p, i]);
+			seen.add(name);
+		});
+	}
+	type(t, p) {
+		const v = inner(t);
+		if (v.kind === "enum" && !this.enums.has(v.name) && this.device) this.error("IR_REFERENCE", `Unknown enum ${v.name}.`, p);
+		if (v.kind === "record" && !this.records.has(v.name) && this.device) this.error("IR_REFERENCE", `Unknown record ${v.name}.`, p);
+	}
+	expect(actual, expected, p, node) {
+		if (!sameType(actual, expected)) this.error("IR_TYPE", `Expected ${this.describe(expected)}, received ${this.describe(actual)}.`, p, node);
+	}
+	describe(t) {
+		const type = t;
+		return !type ? "no value" : type.kind === "optional" ? `${this.describe(type.inner)}?` : String(type.name ?? type.kind);
+	}
+	declaration(name, kind, p) {
+		if (!this.device) return void 0;
+		const d = this.declarations.get(name);
+		if (!d || d.kind !== kind) this.error("IR_REFERENCE", `Expected ${kind} declaration ${name}.`, p);
+		return d;
+	}
+	ref(ref, category, c, p) {
+		const kind = ref.kind === "parameter" ? ref.resource : ref.kind;
+		if (category && kind !== category) this.error("IR_REFERENCE", "Resource category does not match.", p);
+		if (ref.kind === "parameter") {
+			const param = c.params[ref.index];
+			if (!param) this.error("IR_SCOPE", "Resource parameter is outside the current function.", p);
+			if (param.type.kind !== kind) this.error("IR_REFERENCE", "Resource parameter category does not match.", p);
+		} else this.declaration(ref.name, kind, p);
+		return kind;
+	}
+	field(t, field, p) {
+		if (t.kind === "sample") {
+			const fields = {
+				voltage: {
+					kind: "optional",
+					inner: numberType
+				},
+				level: {
+					kind: "enum",
+					name: "Logic"
+				},
+				status: {
+					kind: "enum",
+					name: "SampleStatus"
+				}
+			};
+			if (!fields[field]) this.error("IR_REFERENCE", `Unknown sample field ${field}.`, p);
+			return fields[field];
+		}
+		if (t.kind !== "record") this.error("IR_TYPE", "Field access requires a record or sample.", p);
+		const fields = this.records.get(t.name);
+		if (!fields && !this.device) return numberType;
+		const f = fields?.find((f) => f.name === field);
+		if (!f) this.error("IR_REFERENCE", `Unknown record field ${field}.`, p);
+		return { kind: f.type };
+	}
+	constant(k, t, p) {
+		if (k.kind === "none") {
+			if (t.kind !== "optional") this.error("IR_TYPE", "none requires an optional result type.", p);
+			return;
+		}
+		if (t.kind === "optional") this.error("IR_TYPE", "Non-null constants require a nonoptional type and explicit optional lift.", p);
+		if (k.kind !== t.kind || (k.kind === "enum" || k.kind === "record") && k.name !== ("name" in t ? t.name : void 0)) this.error("IR_TYPE", "Constant and result types do not match.", p);
+		if (k.kind === "enum") {
+			const members = this.enums.get(k.name);
+			if (members && !members.includes(k.member)) this.error("IR_REFERENCE", `Unknown enum member ${k.member}.`, p);
+		}
+		if (k.kind === "record") this.recordFields(k.fields, t, p, (f) => ({ kind: typeof f.value === "boolean" ? "bool" : "number" }));
+	}
+	recordFields(fields, t, p, get) {
+		if (t.kind !== "record") this.error("IR_TYPE", "Record construction requires a named record type.", p);
+		const expected = this.records.get(t.name);
+		const seen = /* @__PURE__ */ new Set();
+		for (let i = 0; i < fields.length; i++) {
+			const f = fields[i];
+			if (seen.has(f.name)) this.error("IR_REFERENCE", "Duplicate record field.", [
+				...p,
+				"fields",
+				i
+			]);
+			seen.add(f.name);
+			if (expected) {
+				const declaration = expected.find((e) => e.name === f.name);
+				if (!declaration) this.error("IR_REFERENCE", `Unknown record field ${f.name}.`, [
+					...p,
+					"fields",
+					i
+				]);
+				this.expect(get(f), { kind: declaration.type }, [
+					...p,
+					"fields",
+					i
+				]);
+			} else get(f);
+		}
+		if (expected && expected.length !== fields.length) this.error("IR_TYPE", "Record fields are incomplete.", p);
+	}
+	context(mode, returns) {
+		return {
+			mode,
+			params: [],
+			...returns ? { returns } : {},
+			loop: 0,
+			results: /* @__PURE__ */ new Map(),
+			resultIds: /* @__PURE__ */ new Set(),
+			localIds: /* @__PURE__ */ new Set(),
+			tail: true,
+			finalInstruction: true,
+			computation: false
+		};
+	}
+	body(body, c, p) {
+		const out = this.region(body, c, {
+			facts: /* @__PURE__ */ new Map(),
+			locals: /* @__PURE__ */ new Map()
+		}, p);
+		if (c.returns && out.normal) this.error("IR_CONTROL_FLOW", "A value-returning body has a normal path without returnValue.", p, body);
+		this.effects(body, c.mode, p);
+	}
+	computation(value, expected, mode, p) {
+		this.type(value.type, [...p, "type"]);
+		this.expect(value.type, expected, [...p, "type"]);
+		const c = this.context(mode, expected);
+		c.computation = true;
+		this.body(value.body, c, [...p, "body"]);
+	}
+	conditioned(s, info, truth) {
+		const out = copy(s), facts = truth ? info.yes : info.no;
+		if (facts) for (const [key, value] of facts) out.facts.set(key, value);
+		return out;
+	}
+	region(body, c, initial, p) {
+		let state = copy(initial);
+		const flow = {
+			breaks: [],
+			continues: [],
+			yielded: [],
+			yieldStates: []
+		};
+		const results = new Map(c.results);
+		c = {
+			...c,
+			results
+		};
+		for (let i = 0; i < body.operations.length; i++) {
+			const op = body.operations[i], q = [
+				...p,
+				"operations",
+				i
+			];
+			if (!state) this.error("IR_CONTROL_FLOW", "Operation follows an unconditional path terminator.", q, op);
+			const s = state;
+			const get = (id, expected) => {
+				const info = results.get(id);
+				if (!info) this.error("IR_SCOPE", `Result ${id} is not visible or is used before its definition.`, q, op);
+				if (expected) this.expect(info.type, expected, q, op);
+				return info;
+			};
+			const result = (t, details = {}) => {
+				const output = op;
+				this.expect(output.type, t, [...q, "type"], op);
+				const value = {
+					type: output.type,
+					key: `v:${output.result}`,
+					...details
+				};
+				results.set(output.result, value);
+				return value;
+			};
+			if ("result" in op) {
+				this.type(op.type, [...q, "type"]);
+				if (c.resultIds.has(op.result)) this.error("IR_SCOPE", `Duplicate result ${op.result}.`, [...q, "result"], op);
+				c.resultIds.add(op.result);
+			}
+			const slot = (id) => {
+				const v = s.locals.get(id);
+				if (!v) this.error("IR_SCOPE", "Local is not visible or not initialized.", [...q, "local"], op);
+				return v;
+			};
+			const child = (region, branch, key, overrides = {}) => lexical(this.region(region, {
+				...c,
+				tail: c.tail && i === body.operations.length - 1,
+				...overrides
+			}, branch, [...q, key]), branch.locals);
+			const accumulate = (f) => {
+				flow.breaks.push(...f.breaks);
+				flow.continues.push(...f.continues);
+				flow.yielded.push(...f.yielded);
+				flow.yieldStates.push(...f.yieldStates);
+			};
+			const valueRegion = (value, expected, branch, key) => {
+				this.type(value.type, [
+					...q,
+					key,
+					"type"
+				]);
+				this.expect(value.type, expected, [
+					...q,
+					key,
+					"type"
+				]);
+				const f = lexical(this.region(value.body, {
+					...c,
+					valueRegion: expected,
+					loop: 0,
+					tail: false
+				}, branch, [
+					...q,
+					key,
+					"body"
+				]), branch.locals);
+				if (f.normal) this.error("IR_CONTROL_FLOW", "A value region has a normal path without yield.", [...q, key], value);
+				return {
+					flow: f,
+					...f.yielded.length ? { value: {
+						type: expected,
+						key: `region:${"result" in op ? op.result : void 0}:${key}`,
+						yes: intersect(f.yielded.map((v) => v.yes ?? /* @__PURE__ */ new Map())),
+						no: intersect(f.yielded.map((v) => v.no ?? /* @__PURE__ */ new Map()))
+					} } : {}
+				};
+			};
+			switch (op.kind) {
+				case "constant": {
+					this.constant(op.constant, op.type, [...q, "constant"]);
+					const info = result(op.type, { none: op.constant.kind === "none" });
+					if (op.constant.kind === "none") s.facts.set(info.key, false);
+					break;
+				}
+				case "read":
+					result(this.declaration(op.name, op.resource, q)?.type ?? op.type);
+					break;
+				case "parameter": {
+					const param = c.params[op.index];
+					if (!param) this.error("IR_SCOPE", "Parameter index is outside the current function.", q, op);
+					if (param.type.kind === "pin" || param.type.kind === "memory") this.error("IR_TYPE", "Resource parameters cannot be read as values.", q, op);
+					result(param.type, { key: `parameter:${op.index}` });
+					break;
+				}
+				case "reactionValue":
+					if (!c.reaction) this.error("IR_SCOPE", "Reaction bindings are only visible inside their response body.", q, op);
+					result(c.reaction.sourceType, { key: `reaction:${op.binding}` });
+					break;
+				case "reactionCapture":
+					if (!c.reaction) this.error("IR_SCOPE", "Reaction captures are only visible inside their response body.", q, op);
+					if (!c.reaction.captures[op.index]) this.error("IR_SCOPE", "Reaction capture index is out of range.", q, op);
+					result(c.reaction.captures[op.index].value.type, { key: `capture:${op.index}` });
+					break;
+				case "unary": {
+					const info = get(op.value, op.operator === "not" ? boolType : numberType);
+					result(op.operator === "not" ? boolType : numberType, op.operator === "not" ? {
+						yes: info.no ?? /* @__PURE__ */ new Map(),
+						no: info.yes ?? /* @__PURE__ */ new Map()
+					} : {});
+					break;
+				}
+				case "binary": {
+					const left = get(op.left), right = get(op.right);
+					if (["equal", "notEqual"].includes(op.operator)) {
+						this.expect(left.type, right.type, q, op);
+						if (!comparable(left.type) && !(left.type.kind === "optional" && (left.none || right.none))) this.error("IR_TYPE", "Intent values do not support content equality.", q, op);
+						const tested = left.none ? right : right.none ? left : void 0;
+						const equal = op.operator === "equal";
+						result(boolType, tested ? {
+							yes: /* @__PURE__ */ new Map([[tested.key, !equal]]),
+							no: /* @__PURE__ */ new Map([[tested.key, equal]])
+						} : {});
+					} else if (op.operator === "concat") {
+						get(op.left, stringType);
+						get(op.right, stringType);
+						result(stringType);
+					} else {
+						get(op.left, numberType);
+						get(op.right, numberType);
+						result([
+							"lessThan",
+							"lessThanOrEqual",
+							"greaterThan",
+							"greaterThanOrEqual"
+						].includes(op.operator) ? boolType : numberType);
+					}
+					break;
+				}
+				case "numeric":
+					if (op.args.length !== ([
+						"min",
+						"max",
+						"pow"
+					].includes(op.builtin) ? 2 : 1)) this.error("IR_TYPE", "Numeric builtin argument count does not match.", q, op);
+					op.args.forEach((arg) => get(arg, numberType));
+					result(op.builtin.startsWith("is") ? boolType : numberType);
+					break;
+				case "record":
+					this.recordFields(op.fields, op.type, q, (f) => get(f.value).type);
+					result(op.type);
+					break;
+				case "field": {
+					const value = get(op.value), t = value.type;
+					result(t.kind === "record" && !this.device ? op.type : this.field(t, op.field, q), { key: `field:${value.key}:${op.field}` });
+					break;
+				}
+				case "bytes":
+					op.elements.forEach((id) => get(id, numberType));
+					result(bytesType);
+					break;
+				case "length": {
+					const t = get(op.value).type;
+					if (!["string", "bytes"].includes(t.kind)) this.error("IR_TYPE", "length requires string or bytes.", q, op);
+					result(numberType);
+					break;
+				}
+				case "index": {
+					const t = get(op.value).type;
+					if (!["string", "bytes"].includes(t.kind)) this.error("IR_TYPE", "index requires string or bytes.", q, op);
+					get(op.index, numberType);
+					result(t.kind === "string" ? stringType : numberType);
+					break;
+				}
+				case "optional": {
+					const t = get(op.value).type;
+					if (t.kind === "optional") this.error("IR_TYPE", "Optional types cannot be nested.", q, op);
+					const v = result({
+						kind: "optional",
+						inner: t
+					});
+					s.facts.set(v.key, true);
+					break;
+				}
+				case "isNone": {
+					const v = get(op.value);
+					if (v.type.kind !== "optional") this.error("IR_TYPE", "isNone requires an optional value.", q, op);
+					result(boolType, {
+						yes: /* @__PURE__ */ new Map([[v.key, false]]),
+						no: /* @__PURE__ */ new Map([[v.key, true]])
+					});
+					break;
+				}
+				case "nonNull": {
+					const v = get(op.value);
+					if (v.type.kind !== "optional" || s.facts.get(v.key) !== true) this.error("IR_TYPE", "nonNull requires a dominating non-null proof.", q, op);
+					result(v.type.inner);
+					break;
+				}
+				case "local": {
+					if (c.localIds.has(op.local)) this.error("IR_SCOPE", "Duplicate local identifier.", q, op);
+					c.localIds.add(op.local);
+					this.type(op.type, [...q, "type"]);
+					const info = get(op.initial, op.type);
+					s.locals.set(op.local, {
+						type: op.type,
+						value: info
+					});
+					break;
+				}
+				case "localRead": {
+					const local = slot(op.local);
+					result(local.type, { ...local.value });
+					break;
+				}
+				case "localWrite": {
+					const local = slot(op.local);
+					const info = get(op.value, local.type);
+					s.locals.set(op.local, {
+						type: local.type,
+						value: info
+					});
+					break;
+				}
+				case "write": {
+					const d = this.declaration(op.name, "state", q);
+					get(op.value, d?.type);
+					break;
+				}
+				case "memoryLength":
+					this.ref(op.memory, "memory", c, q);
+					result(numberType);
+					break;
+				case "load8":
+				case "load16le":
+				case "load16be":
+				case "load32le":
+				case "load32be":
+					this.ref(op.memory, "memory", c, q);
+					get(op.offset, numberType);
+					result(numberType);
+					break;
+				case "store8":
+				case "store16le":
+				case "store16be":
+				case "store32le":
+				case "store32be":
+					this.ref(op.memory, "memory", c, q);
+					get(op.offset, numberType);
+					get(op.value, numberType);
+					break;
+				case "copyBytes":
+					this.ref(op.memory, "memory", c, q);
+					get(op.offset, numberType);
+					get(op.length, numberType);
+					result(bytesType);
+					break;
+				case "readSample":
+					this.ref(op.pin, "pin", c, q);
+					result(sampleType);
+					break;
+				case "resistor":
+					this.ref(op.to, "pin", c, q);
+					get(op.resistance, numberType);
+					result(intentType);
+					break;
+				case "combineIntents":
+					op.values.forEach((id) => get(id, intentType));
+					result(intentType);
+					break;
+				case "refEqual":
+					this.expect({ kind: this.ref(op.left, void 0, c, q) }, { kind: this.ref(op.right, void 0, c, q) }, q);
+					result(boolType);
+					break;
+				case "writeIntent":
+					this.ref(op.pin, "pin", c, q);
+					get(op.value, intentType);
+					break;
+				case "call":
+				case "callValue": {
+					const target = this.declaration(op.name, "function", q);
+					if (target && op.pure && !target.pure) this.error("IR_EFFECT", "A pure call must target an explicitly pure function.", q, op);
+					if (target && op.args.length !== target.params.length) this.error("IR_TYPE", "Call argument count does not match.", q, op);
+					op.args.forEach((arg, index) => {
+						const param = target?.params[index];
+						if (arg.kind === "value") {
+							if (param && (param.type.kind === "pin" || param.type.kind === "memory")) this.error("IR_TYPE", "Resource argument required.", q, op);
+							get(arg.value, param?.type);
+						} else {
+							if (param && !(param.type.kind === "pin" || param.type.kind === "memory")) this.error("IR_TYPE", "Value argument required.", q, op);
+							this.ref(arg, param?.type.kind, c, q);
+						}
+					});
+					if (op.kind === "callValue") {
+						if (target && !target.returns) this.error("IR_TYPE", "callValue requires a value-returning function.", q, op);
+						result(target?.returns ?? op.type);
+					} else if (target?.returns) this.error("IR_TYPE", "call cannot discard the return type of a value-returning function.", q, op);
+					break;
+				}
+				case "send": {
+					const channel = this.declaration(op.channel, "channel", q);
+					if (channel?.direction === "input") this.error("IR_REFERENCE", "send requires an output channel.", q, op);
+					get(op.value, channel?.type);
+					break;
+				}
+				case "notify":
+					if (this.declaration(op.notification, "notification", q)?.direction === "input") this.error("IR_REFERENCE", "notify requires an output notification.", q, op);
+					break;
+				case "receive": {
+					const channel = this.declaration(op.channel, "channel", q);
+					if (channel?.direction === "output") this.error("IR_REFERENCE", "receive requires an input channel.", q, op);
+					result(channel?.type ?? op.type);
+					break;
+				}
+				case "now":
+				case "random":
+					result(numberType);
+					break;
+				case "if": {
+					const condition = get(op.condition, boolType);
+					const yes = child(op.yes, this.conditioned(s, condition, true), "yes");
+					const no = op.no ? child(op.no, this.conditioned(s, condition, false), "no") : {
+						normal: this.conditioned(s, condition, false),
+						breaks: [],
+						continues: [],
+						yielded: [],
+						yieldStates: []
+					};
+					accumulate(yes);
+					accumulate(no);
+					state = merge([yes.normal, no.normal].filter((v) => !!v));
+					break;
+				}
+				case "match": {
+					const value = get(op.value), base = inner(value.type);
+					const seen = /* @__PURE__ */ new Set();
+					const branches = [];
+					for (let j = 0; j < op.arms.length; j++) {
+						const arm = op.arms[j], pattern = arm.pattern;
+						this.constant(pattern, pattern.kind === "none" ? value.type : base, [
+							...q,
+							"arms",
+							j,
+							"pattern"
+						]);
+						const key = pattern.kind === "enum" ? `${pattern.name}.${pattern.member}` : `${pattern.kind}:${String("value" in pattern ? pattern.value : void 0)}`;
+						if (seen.has(key)) this.error("IR_CONTROL_FLOW", "Duplicate match pattern.", [
+							...q,
+							"arms",
+							j
+						]);
+						seen.add(key);
+						const branch = copy(s);
+						if (value.type.kind === "optional") branch.facts.set(value.key, pattern.kind !== "none");
+						const f = lexical(this.region(arm.body, {
+							...c,
+							tail: c.tail && i === body.operations.length - 1
+						}, branch, [
+							...q,
+							"arms",
+							j,
+							"body"
+						]), branch.locals);
+						accumulate(f);
+						if (f.normal) branches.push(f.normal);
+					}
+					const complete = (base.kind === "bool" ? seen.has("bool:true") && seen.has("bool:false") : base.kind === "enum" ? this.enums.get(base.name)?.every((m) => seen.has(`${base.name}.${m}`)) : false) && (value.type.kind !== "optional" || seen.has("none:undefined"));
+					if (op.otherwise) {
+						const branch = copy(s);
+						if (value.type.kind === "optional" && seen.has("none:undefined")) branch.facts.set(value.key, true);
+						const f = child(op.otherwise, branch, "otherwise");
+						accumulate(f);
+						if (f.normal) branches.push(f.normal);
+					} else if (!complete) this.error("IR_CONTROL_FLOW", "Match requires exhaustive patterns or a default region.", q, op);
+					state = merge(branches);
+					break;
+				}
+				case "while":
+				case "loop": {
+					const written = /* @__PURE__ */ new Set();
+					walk(op.body, (nested) => {
+						if (nested.kind === "localWrite" && s.locals.has(nested.local)) written.add(nested.local);
+					});
+					if (op.kind === "while") walk(op.test.body, (nested) => {
+						if (nested.kind === "localWrite" && s.locals.has(nested.local)) written.add(nested.local);
+					});
+					const header = (backedges) => {
+						const next = copy(s), incoming = [s, ...backedges];
+						for (const id of written) {
+							const slot = s.locals.get(id);
+							const value = {
+								type: slot.type,
+								key: `loop:${q.join(".")}:${id}`
+							};
+							next.locals.set(id, {
+								type: slot.type,
+								value
+							});
+							const facts = incoming.map((state) => {
+								const v = state.locals.get(id)?.value;
+								return v ? state.facts.get(v.key) : void 0;
+							});
+							if (facts.every((fact) => fact === true)) next.facts.set(value.key, true);
+							else if (facts.every((fact) => fact === false)) next.facts.set(value.key, false);
+						}
+						return next;
+					};
+					let loopState = header([]);
+					const resultIds = new Set(c.resultIds), localIds = new Set(c.localIds);
+					let test;
+					let f;
+					for (;;) {
+						c.resultIds.clear();
+						for (const id of resultIds) c.resultIds.add(id);
+						c.localIds.clear();
+						for (const id of localIds) c.localIds.add(id);
+						test = op.kind === "while" ? valueRegion(op.test, boolType, loopState, "test") : void 0;
+						const afterTest = test ? merge(test.flow.yieldStates) ?? loopState : loopState;
+						const entry = test?.value ? this.conditioned(afterTest, test.value, true) : afterTest;
+						f = child(op.body, entry, "body", {
+							loop: c.loop + 1,
+							tail: false
+						});
+						const next = header([f.normal, ...f.continues].filter((value) => !!value));
+						if ([...written].every((id) => {
+							const key = next.locals.get(id).value.key;
+							return next.facts.get(key) === loopState.facts.get(key);
+						})) break;
+						loopState = next;
+					}
+					flow.yielded.push(...f.yielded);
+					flow.yieldStates.push(...f.yieldStates);
+					const exits = [...f.breaks];
+					if (op.kind === "while" && test?.value) {
+						const afterTest = merge(test.flow.yieldStates) ?? loopState;
+						exits.push(this.conditioned(afterTest, test.value, false));
+					}
+					state = merge(exits);
+					break;
+				}
+				case "and":
+				case "or": {
+					const left = get(op.left, boolType), isAnd = op.kind === "and";
+					const right = valueRegion(op.right, boolType, this.conditioned(s, left, isAnd), "right");
+					const rightInfo = right.value;
+					const combine = (a, b) => new Map([...a ?? [], ...b ?? []]);
+					result(boolType, {
+						yes: isAnd ? combine(left.yes, rightInfo?.yes) : intersect([left.yes ?? /* @__PURE__ */ new Map(), combine(left.no, rightInfo?.yes)]),
+						no: isAnd ? intersect([left.no ?? /* @__PURE__ */ new Map(), combine(left.yes, rightInfo?.no)]) : combine(left.no, rightInfo?.no)
+					});
+					state = merge([this.conditioned(s, left, !isAnd), ...right.flow.yieldStates]);
+					break;
+				}
+				case "select": {
+					const condition = get(op.condition, boolType);
+					const yes = valueRegion(op.yes, op.type, this.conditioned(s, condition, true), "yes");
+					const no = valueRegion(op.no, op.type, this.conditioned(s, condition, false), "no");
+					result(op.type);
+					state = merge([...yes.flow.yieldStates, ...no.flow.yieldStates]);
+					break;
+				}
+				case "assert": {
+					const condition = get(op.condition, boolType);
+					if (op.message) valueRegion(op.message, stringType, this.conditioned(s, condition, false), "message");
+					state = this.conditioned(s, condition, true);
+					break;
+				}
+				case "wait":
+					if (c.valueRegion || c.mode !== "process") this.error("IR_EFFECT", "wait is only allowed in a process statement region.", q, op);
+					get(op.duration, numberType);
+					break;
+				case "elapse":
+					if (c.valueRegion || c.mode !== "jit") this.error("IR_EFFECT", "elapse is only allowed in a JIT statement region.", q, op);
+					get(op.duration, numberType);
+					break;
+				case "waitUntil":
+					if (c.mode !== "jit") this.error("IR_EFFECT", "waitUntil requires a JIT instruction.", q, op);
+					if (c.valueRegion || c.loop || !c.tail || i !== body.operations.length - 1 || !c.finalInstruction) this.error("IR_JIT_BOUNDARY", "waitUntil must be on the final instruction tail path.", q, op);
+					{
+						const fn = this.declaration(op.predicate, "function", q);
+						if (fn && (!fn.pure || fn.params.length || !sameType(fn.returns, boolType))) this.error("IR_TYPE", "waitUntil requires a zero-parameter pure bool function.", q, op);
+					}
+					state = void 0;
+					break;
+				case "redirect":
+					if (!["jit", "sync"].includes(c.mode)) this.error("IR_EFFECT", "redirect is not permitted in this context.", q, op);
+					get(op.target, numberType);
+					get(op.delay, numberType);
+					state = void 0;
+					break;
+				case "stop":
+					if (c.mode !== "jit" || c.valueRegion) this.error("IR_EFFECT", "stop requires a JIT statement region.", q, op);
+					state = void 0;
+					break;
+				case "return":
+					if (c.valueRegion || c.returns || c.mode === "jit" || c.computation || c.mode === "creation" || c.mode === "initial") this.error("IR_CONTROL_FLOW", "Void return is not valid in this body.", q, op);
+					state = void 0;
+					break;
+				case "returnValue":
+					if (c.valueRegion || !c.returns) this.error("IR_CONTROL_FLOW", "returnValue is not valid in this body.", q, op);
+					get(op.value, c.returns);
+					state = void 0;
+					break;
+				case "yield":
+					if (!c.valueRegion) this.error("IR_CONTROL_FLOW", "yield requires a value region.", q, op);
+					{
+						const value = get(op.value, c.valueRegion);
+						flow.yielded.push(value);
+						flow.yieldStates.push(s);
+					}
+					state = void 0;
+					break;
+				case "break":
+				case "continue":
+					if (!c.loop) this.error("IR_CONTROL_FLOW", `${op.kind} requires an enclosing loop in this region.`, q, op);
+					(op.kind === "break" ? flow.breaks : flow.continues).push(s);
+					state = void 0;
+			}
+		}
+		if (state) flow.normal = state;
+		return flow;
+	}
+	effects(body, mode, path) {
+		walk(body, (op, p) => {
+			const pure = [
+				"creation",
+				"initial",
+				"pure"
+			].includes(mode), creation = ["creation", "initial"].includes(mode);
+			const effect = [
+				"write",
+				"writeIntent",
+				"send",
+				"notify",
+				"now",
+				"random",
+				"wait",
+				"receive",
+				"elapse",
+				"waitUntil",
+				"stop",
+				"redirect",
+				...stores
+			].includes(op.kind);
+			if (pure && effect) this.error("IR_EFFECT", `${op.kind} is not allowed in ${mode} code.`, p, op);
+			if (creation && (op.kind === "read" && !["property", "const"].includes(op.resource) || [
+				"readSample",
+				"memoryLength",
+				"copyBytes",
+				...loads
+			].includes(op.kind))) this.error("IR_EFFECT", "Creation computations cannot read runtime resources.", p, op);
+			if (mode === "creation" && ([
+				"resistor",
+				"combineIntents",
+				"refEqual"
+			].includes(op.kind) || (op.kind === "call" || op.kind === "callValue") && op.args.some((a) => a.kind !== "value"))) this.error("IR_EFFECT", "Ordinary creation computations cannot use resource references or intents.", p, op);
+			if (["reaction", "process"].includes(mode) && op.kind === "redirect") this.error("IR_EFFECT", "Control redirection requires a bound JIT entry.", p, op);
+			if ([
+				"sync",
+				"reaction",
+				"pure"
+			].includes(mode) && [
+				"wait",
+				"receive",
+				"elapse",
+				"waitUntil",
+				"stop"
+			].includes(op.kind)) this.error("IR_EFFECT", "Synchronous code cannot suspend or use JIT control.", p, op);
+			if (mode === "process" && [
+				"elapse",
+				"waitUntil",
+				"stop"
+			].includes(op.kind)) this.error("IR_EFFECT", "Process code cannot use JIT control.", p, op);
+			if (mode === "jit" && ["wait", "receive"].includes(op.kind)) this.error("IR_EFFECT", "JIT code cannot use process suspension.", p, op);
+			if (op.kind === "call" || op.kind === "callValue" || op.kind === "waitUntil") {
+				const name = op.kind === "waitUntil" ? op.predicate : op.name;
+				const fn = this.functions.get(name);
+				if (fn && pure && !fn.pure) this.error("IR_EFFECT", "Pure contexts can only call explicitly pure functions.", p, op);
+				if (fn) {
+					const key = `${mode}:${name}`;
+					if (!this.effectChecked.has(key)) {
+						this.effectChecked.add(key);
+						this.effects(fn.body, mode, [...this.paths.get(name) ?? [], "body"]);
+					}
+				}
+			}
+		}, path);
+	}
+	source(path, p, notification) {
+		if (!path.length) this.error("IR_SCHEMA", "An observation source path cannot be empty.", p);
+		const declaration = this.declarations.get(path[0]);
+		if (!declaration) this.error("IR_REFERENCE", "Observation source does not exist.", p);
+		let type;
+		let start = 1;
+		if (declaration.kind === "notification" && notification) {
+			if (declaration.direction !== "input" || path.length !== 1) this.error("IR_REFERENCE", "Only input notifications can trigger a process.", p);
+			return;
+		}
+		if (declaration.kind === "pin") {
+			if (path[1] !== "sample") this.error("IR_REFERENCE", "Pin observation must select sample.", p);
+			type = sampleType;
+			start = 2;
+		} else if (declaration.kind === "state" || declaration.kind === "derived") type = declaration.type;
+		else this.error("IR_REFERENCE", "An observation source must be state, derived, pin.sample or an input notification.", p);
+		for (let i = start; i < path.length; i++) type = this.field(type, path[i], [...p, i]);
+		if (!comparable(type)) this.error("IR_TYPE", "Observation sources must be comparable.", p);
+		return type;
+	}
+	cycle(graph, label) {
+		const active = /* @__PURE__ */ new Set(), done = /* @__PURE__ */ new Set();
+		const visit = (name) => {
+			if (active.has(name)) this.error("IR_DEPENDENCY", `${label} dependency cycle includes ${name}.`, this.paths.get(name) ?? []);
+			if (done.has(name)) return;
+			active.add(name);
+			for (const next of graph.get(name) ?? []) if (graph.has(next)) visit(next);
+			active.delete(name);
+			done.add(name);
+		};
+		for (const key of graph.keys()) visit(key);
+	}
+	dependencies(body, resources, seen = /* @__PURE__ */ new Set()) {
+		const deps = /* @__PURE__ */ new Set();
+		walk(body, (op) => {
+			if (op.kind === "read" && resources.includes(op.resource)) deps.add(op.name);
+			if ((op.kind === "call" || op.kind === "callValue") && !seen.has(op.name)) {
+				seen.add(op.name);
+				const fn = this.functions.get(op.name);
+				if (fn) for (const name of this.dependencies(fn.body, resources, seen)) deps.add(name);
+			}
+		});
+		return deps;
+	}
+	validateDevice() {
+		const graph = /* @__PURE__ */ new Map();
+		for (const [name, fn] of this.functions) {
+			const targets = /* @__PURE__ */ new Set();
+			walk(fn.body, (op) => {
+				if (op.kind === "call" || op.kind === "callValue") targets.add(op.name);
+			});
+			graph.set(name, targets);
+		}
+		this.cycle(graph, "Synchronous call");
+		const creationGraph = /* @__PURE__ */ new Map(), derivedGraph = /* @__PURE__ */ new Map();
+		this.device.declarations.forEach((d, i) => {
+			const p = ["declarations", i];
+			if ("type" in d && d.type) this.type(d.type, [...p, "type"]);
+			if (d.kind === "property" || d.kind === "const" || d.kind === "state") {
+				const base = inner(d.type);
+				if (["sample", "intent"].includes(base.kind) || d.kind === "property" && base.kind === "record") this.error("IR_TYPE", "Type is not valid at this declaration position.", [...p, "type"], d);
+				const key = d.kind === "property" ? "default" : d.kind === "const" ? "value" : "initial";
+				const initialization = d.kind === "property" ? d.default : d.kind === "const" ? d.value : d.initial;
+				if (initialization) {
+					this.computation(initialization, d.type, "creation", [...p, key]);
+					creationGraph.set(d.name, this.dependencies(initialization.body, ["property", "const"]));
+				}
+			} else if (d.kind === "derived") {
+				this.computation(d.value, d.type, "pure", [...p, "value"]);
+				derivedGraph.set(d.name, this.dependencies(d.value.body, ["derived"]));
+			} else if (d.kind === "pin") {
+				for (const key of ["low", "high"]) if (d[key]) this.computation(d[key], numberType, "creation", [...p, key]);
+				if (d.initial) this.computation(d.initial, intentType, "initial", [...p, "initial"]);
+			} else if (d.kind === "memory") this.computation(d.length, numberType, "creation", [...p, "length"]);
+			else if (d.kind === "channel") {
+				if (![
+					"number",
+					"bool",
+					"record",
+					"bytes"
+				].includes(d.type.kind)) this.error("IR_TYPE", "Invalid channel payload type.", [...p, "type"], d);
+				if (d.type.kind === "bytes" !== !!d.maxLength) this.error("IR_TYPE", "Only bytes channels require maxLength.", p, d);
+				this.computation(d.capacity, numberType, "creation", [...p, "capacity"]);
+				if (d.maxLength) this.computation(d.maxLength, numberType, "creation", [...p, "maxLength"]);
+				if (d.overflow) this.computation(d.overflow, {
+					kind: "enum",
+					name: "Overflow"
+				}, "creation", [...p, "overflow"]);
+			} else if (d.kind === "function") {
+				this.uniqueNames(d.params.map((param) => param.name), [...p, "params"]);
+				d.params.forEach((param, j) => {
+					if (this.declarations.has(param.name)) this.error("IR_REFERENCE", "A parameter cannot shadow a device member.", [
+						...p,
+						"params",
+						j
+					]);
+					if (!(param.type.kind === "pin" || param.type.kind === "memory")) this.type(param.type, [
+						...p,
+						"params",
+						j,
+						"type"
+					]);
+				});
+				if (d.returns) this.type(d.returns, [...p, "returns"]);
+				const c = this.context(d.pure ? "pure" : "sync", d.returns);
+				c.params = d.params;
+				this.body(d.body, c, [...p, "body"]);
+			} else if (d.kind === "start" || d.kind === "on") {
+				if (d.kind === "on") this.source(d.sourcePath, [...p, "sourcePath"], true);
+				this.body(d.body, this.context("process"), [...p, "body"]);
+				walk(d.body, (op) => {
+					if (op.kind === "receive") {
+						const owner = `${i}`;
+						const old = this.receiveOwners.get(op.channel);
+						if (old && old !== owner) {
+							const error = new BuildError([{
+								code: "IR_REFERENCE",
+								message: "An input channel cannot have multiple consumer processes.",
+								phase: "finalize",
+								path: p,
+								related: []
+							}]);
+							Object.defineProperty(error, "code", { value: "CHANNEL_CONSUMER_CONFLICT" });
+							throw error;
+						}
+						this.receiveOwners.set(op.channel, owner);
+					}
+				});
+			} else if (d.kind === "reaction") {
+				const source = this.source(d.sourcePath, [...p, "sourcePath"], false);
+				this.expect(d.sourceType, source, [...p, "sourceType"]);
+				this.type(d.sourceType, [...p, "sourceType"]);
+				const names = [
+					d.previous,
+					d.current,
+					...d.captures.map((capture) => capture.name)
+				];
+				d.captures.forEach((capture, j) => {
+					if (!comparable(capture.value.type)) this.error("IR_TYPE", "Capture results must be comparable.", [
+						...p,
+						"captures",
+						j
+					]);
+					this.computation(capture.value, capture.value.type, "pure", [
+						...p,
+						"captures",
+						j,
+						"value"
+					]);
+				});
+				const c = this.context("reaction");
+				c.reaction = d;
+				this.body(d.body, c, [...p, "body"]);
+				this.uniqueNames(names, p);
+				for (const name of names) if (this.declarations.has(name)) this.error("IR_REFERENCE", "Reaction bindings cannot shadow device members.", p);
+			} else if (d.kind === "assert") this.body(d.body, this.context("creation"), [...p, "body"]);
+		});
+		this.cycle(creationGraph, "Creation");
+		this.cycle(derivedGraph, "Derived");
+	}
+	validateBlock(block) {
+		block.instructions.forEach((instruction, i) => {
+			const c = this.context("jit");
+			c.finalInstruction = i === block.instructions.length - 1;
+			this.body(instruction.body, c, [
+				"instructions",
+				i,
+				"body"
+			]);
+		});
+	}
+};
+function locateError(error, input) {
+	if (!(error instanceof BuildError)) throw error;
+	const located = new BuildError(error.diagnostics.map((diagnostic) => {
+		if (diagnostic.source) return diagnostic;
+		let node = input, source;
+		const consider = () => {
+			const candidate = node?.source;
+			if (candidate && typeof candidate === "object" && (typeof candidate.label === "string" && candidate.uri === void 0 && candidate.range === void 0 || typeof candidate.uri === "string" && candidate.range?.start?.line >= 1 && candidate.range?.start?.column >= 1 && candidate.range?.end?.line >= 1 && candidate.range?.end?.column >= 1)) source = candidate;
+		};
+		consider();
+		for (const part of diagnostic.path) {
+			node = node?.[part];
+			consider();
+		}
+		return source ? {
+			...diagnostic,
+			source
+		} : diagnostic;
+	}));
+	const runtimeCode = Object.getOwnPropertyDescriptor(error, "code");
+	if (runtimeCode?.value === "CHANNEL_CONSUMER_CONFLICT") Object.defineProperty(located, "code", runtimeCode);
+	throw located;
+}
+var validatedDevices = /* @__PURE__ */ new WeakSet();
+var validatedBlocks = /* @__PURE__ */ new WeakSet();
+var boundBlocks = /* @__PURE__ */ new WeakMap();
+function validateDeviceIR(input) {
+	if (typeof input === "object" && input !== null && validatedDevices.has(input)) return input;
+	const captured = snapshot(input);
+	try {
+		deviceSchema(captured);
+		new Validator(captured).validateDevice();
+		const result = captured;
+		validatedDevices.add(result);
+		return result;
+	} catch (error) {
+		return locateError(error, captured);
+	}
+}
+function validateBlockIR(input) {
+	if (typeof input === "object" && input !== null && validatedBlocks.has(input)) return input;
+	const captured = snapshot(input);
+	try {
+		blockSchema(captured);
+		new Validator().validateBlock(captured);
+		const result = captured;
+		validatedBlocks.add(result);
+		return result;
+	} catch (error) {
+		return locateError(error, captured);
+	}
+}
+/** Adds instance-definition reference and function-signature checks to a structurally valid block. */
+function validateBoundBlockIR(input, device) {
+	try {
+		const captured = validateBlockIR(input);
+		const definition = validateDeviceIR(device);
+		if (boundBlocks.get(captured)?.has(definition)) return captured;
+		new Validator(definition).validateBlock(captured);
+		let definitions = boundBlocks.get(captured);
+		if (!definitions) {
+			definitions = /* @__PURE__ */ new WeakSet();
+			boundBlocks.set(captured, definitions);
+		}
+		definitions.add(definition);
+		return captured;
+	} catch (error) {
+		if (error instanceof BuildError) {
+			const bound = new BuildError(error.diagnostics.map((d) => ({
+				...d,
+				phase: "bind"
+			})));
+			const runtimeCode = Object.getOwnPropertyDescriptor(error, "code");
+			if (runtimeCode?.value === "CHANNEL_CONSUMER_CONFLICT") Object.defineProperty(bound, "code", runtimeCode);
+			throw bound;
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/builder.ts
+var typeData = /* @__PURE__ */ new WeakMap();
+var values = /* @__PURE__ */ new WeakMap();
+var locals = /* @__PURE__ */ new WeakMap();
+var refs = /* @__PURE__ */ new WeakMap();
+var enumValues = /* @__PURE__ */ new WeakMap();
+var primitive = (kind) => {
+	const descriptor = Object.freeze({});
+	typeData.set(descriptor, { type: { kind } });
+	return descriptor;
+};
+function enumType(name, members, owner) {
+	const membersObject = {};
+	for (const member of members) {
+		const token = Object.freeze({});
+		enumValues.set(token, {
+			name,
+			member,
+			...owner ? { owner } : {}
+		});
+		Object.defineProperty(membersObject, member, {
+			value: token,
+			enumerable: true
+		});
+	}
+	const descriptor = Object.freeze({
+		name,
+		members: Object.freeze(membersObject)
+	});
+	typeData.set(descriptor, {
+		type: {
+			kind: "enum",
+			name
+		},
+		members: Object.freeze([...members]),
+		...owner ? { owner } : {}
+	});
+	return descriptor;
+}
+function recordType(name, fields, owner) {
+	const descriptor = Object.freeze({
+		name,
+		fields: Object.freeze({ ...fields })
+	});
+	typeData.set(descriptor, {
+		type: {
+			kind: "record",
+			name
+		},
+		fields: descriptor.fields,
+		...owner ? { owner } : {}
+	});
+	return descriptor;
+}
+var factory = {
+	number: primitive("number"),
+	bool: primitive("bool"),
+	string: primitive("string"),
+	bytes: primitive("bytes"),
+	intent: primitive("intent"),
+	sample: primitive("sample"),
+	pin: Object.freeze({ kind: "pin" }),
+	memory: Object.freeze({ kind: "memory" }),
+	logic: enumType("Logic", builtins.Logic),
+	sampleStatus: enumType("SampleStatus", builtins.SampleStatus),
+	overflow: enumType("Overflow", builtins.Overflow),
+	optional(descriptor) {
+		const info = typeData.get(descriptor);
+		if (!info || info.type.kind === "optional") fail("IR_TYPE", "optional requires a nonoptional value type.", [], "construct");
+		const result = Object.freeze({});
+		typeData.set(result, {
+			...info,
+			type: {
+				kind: "optional",
+				inner: info.type
+			}
+		});
+		return result;
+	},
+	namedEnum(name, members) {
+		if (typeof name !== "string" || !Array.isArray(members) || !members.length || members.some((m) => typeof m !== "string") || new Set(members).size !== members.length) fail("IR_TYPE", "Invalid named enum description.", [], "construct");
+		return enumType(name, members);
+	},
+	namedRecord(name, fields) {
+		if (typeof name !== "string" || !fields || typeof fields !== "object" || Array.isArray(fields)) fail("IR_TYPE", "Invalid named record description.", [], "construct");
+		for (const field of Object.values(fields)) if (!["number", "bool"].includes(typeData.get(field)?.type.kind ?? "")) fail("IR_TYPE", "Record fields must be number or bool types.", [], "construct");
+		return recordType(name, fields);
+	}
+};
+var types = Object.freeze(factory);
+var n = { kind: "number" };
+var b = { kind: "bool" };
+var str = { kind: "string" };
+var bytes = { kind: "bytes" };
+var intent = { kind: "intent" };
+var sample = { kind: "sample" };
+function descendant(scope, parent) {
+	for (let s = scope; s; s = s.parent) if (s === parent) return true;
+	return false;
+}
+function infoOf(value) {
+	return typeof value === "object" && value !== null ? values.get(value) : void 0;
+}
+function enumOf(value) {
+	return typeof value === "object" && value !== null ? enumValues.get(value) : void 0;
+}
+function referenceOf(value) {
+	return typeof value === "object" && value !== null ? refs.get(value) : void 0;
+}
+function fresh(map, info) {
+	const handle = Object.freeze({});
+	map.set(handle, info);
+	return handle;
+}
+function alias(value) {
+	return value.alias ? alias(value.alias) : value;
+}
+function joinFacts(branches) {
+	const result = new Map(branches[0]);
+	for (const [k, v] of result) if (branches.some((f) => f.get(k) !== v)) result.delete(k);
+	return result;
+}
+var definitionOwners = /* @__PURE__ */ new WeakMap();
+var Root = class {
+	options;
+	device;
+	jit;
+	closed = false;
+	active;
+	source;
+	declarations = [];
+	names = /* @__PURE__ */ new Map();
+	expectedTypes = /* @__PURE__ */ new Set();
+	pending = [];
+	instructions = [];
+	constructor(options, device, jit = false) {
+		this.options = options;
+		this.device = device;
+		this.jit = jit;
+		if (options.source !== void 0) this.source = snapshot(options.source);
+	}
+	error(code, message, path = []) {
+		this.closed = true;
+		return fail(code, message, path, "construct", this.active?.source ?? this.source);
+	}
+	check() {
+		if (this.closed) this.error("IR_LIFECYCLE", "This Builder is closed.");
+	}
+	guard(action) {
+		this.check();
+		try {
+			return action();
+		} catch (error) {
+			this.closed = true;
+			if (error instanceof BuildError && error.diagnostics.some((d) => d.phase !== "construct")) throw new BuildError(error.diagnostics.map((d) => ({
+				...d,
+				phase: "construct"
+			})));
+			throw error;
+		}
+	}
+	type(descriptor) {
+		const info = typeData.get(descriptor);
+		if (!info) this.error("IR_TYPE", "Expected a Builder type descriptor.");
+		if (info.owner && info.owner !== this && (!this.device || definitionOwners.get(this.device) !== info.owner)) this.error("IR_SCOPE", "Named type belongs to another device definition.");
+		this.expectedTypes.add(info);
+		if (info.fields) for (const f of Object.values(info.fields)) this.type(f);
+		return info.type;
+	}
+	sourceFor(options) {
+		const source = options?.source ?? this.source;
+		return source === void 0 ? {} : { source: snapshot(source) };
+	}
+	body(mode, emit, returns, source, setup) {
+		const body = new Body(this, mode, {
+			result: 0,
+			local: 0
+		}, {}, void 0, returns);
+		body.source = source === void 0 ? this.source : snapshot(source);
+		const previous = this.active;
+		this.active = body;
+		try {
+			setup?.(body);
+			emit(body.view());
+		} finally {
+			body.closed = true;
+			this.active = previous;
+		}
+		this.check();
+		return {
+			operations: body.operations,
+			...body.source ? { source: snapshot(body.source) } : {}
+		};
+	}
+	creation(type, input, mode = "creation", source) {
+		return {
+			type,
+			body: this.body(mode, (view) => {
+				if (typeof input === "function") input(view);
+				else view.returnValue(input);
+			}, type, source)
+		};
+	}
+	declarationType(name) {
+		const declaration = this.names.get(name);
+		return declaration && "type" in declaration ? declaration.type : void 0;
+	}
+	add(declaration) {
+		if (declaration.name !== void 0) {
+			if (this.names.has(declaration.name)) this.error("IR_REFERENCE", `Duplicate declaration ${declaration.name}.`);
+			this.names.set(declaration.name, declaration);
+		}
+		if (declaration.kind === "start" && this.declarations.some((d) => d.kind === "start")) this.error("IR_REFERENCE", "Only one start process is allowed.");
+		this.declarations.push(declaration);
+	}
+	resolve() {
+		for (const pending of this.pending) {
+			const fn = this.names.get(pending.call);
+			if (!fn || fn.kind !== "function") {
+				if (this.jit && pending.requiresSignature) fail("IR_TYPE", "A null or record call argument requires a bound function signature or an explicitly typed Value.");
+				continue;
+			}
+			const parameter = fn.params[pending.index];
+			if (!parameter || parameter.type.kind === "pin" || parameter.type.kind === "memory") this.error("IR_TYPE", "A value argument requires a value parameter.");
+			if (parameter.type.kind === "optional" && pending.value !== null) {
+				const data = pending.body.constantData(parameter.type.inner, pending.value);
+				const id = pending.body.space.result++;
+				const constant = {
+					kind: "constant",
+					result: id,
+					type: parameter.type.inner,
+					constant: data,
+					...pending.node.source ? { source: pending.node.source } : {}
+				};
+				const insert = (value) => {
+					if (Array.isArray(value)) {
+						const index = value.indexOf(pending.node);
+						if (index >= 0) {
+							value.splice(index, 0, constant);
+							return true;
+						}
+						return value.some(insert);
+					}
+					return value !== null && typeof value === "object" && Object.values(value).some(insert);
+				};
+				if (!insert(this.jit ? this.instructions : this.declarations)) fail("IR_SCHEMA", "Pending call argument is not part of this definition.");
+				delete pending.node.constant;
+				Object.assign(pending.node, {
+					kind: "optional",
+					type: parameter.type,
+					value: id
+				});
+			} else {
+				const data = pending.body.constantData(parameter.type, pending.value);
+				Object.assign(pending.node, {
+					type: parameter.type,
+					constant: data
+				});
+			}
+		}
+		for (const description of this.expectedTypes) {
+			const type = description.type.kind === "optional" ? description.type.inner : description.type;
+			if (!["enum", "record"].includes(type.kind)) continue;
+			const name = type.name;
+			const declaration = this.names.get(name);
+			if (builtins[name] && type.kind === "enum") {
+				if (description.members && (description.members.length !== builtins[name].length || description.members.some((m, i) => m !== builtins[name][i]))) fail("IR_TYPE", "Builtin enum description does not match its members.");
+				continue;
+			}
+			if (!declaration) continue;
+			if (declaration.kind !== type.kind) fail("IR_REFERENCE", "Named type category does not match its declaration.");
+			if (description.members && (description.members.length !== declaration.members.length || description.members.some((m, i) => m !== declaration.members[i]))) fail("IR_TYPE", "Forward enum description does not match its declaration.");
+			if (description.fields) {
+				const expected = Object.entries(description.fields);
+				if (expected.length !== declaration.fields.length || expected.some(([name, t]) => !declaration.fields.some((field) => field.name === name && field.type === typeData.get(t)?.type.kind))) fail("IR_TYPE", "Forward record description does not match its declaration.");
+			}
+		}
+	}
+};
+var Body = class Body {
+	root;
+	mode;
+	space;
+	scope;
+	parent;
+	returns;
+	closed = false;
+	ended = false;
+	endedByWaitUntil = false;
+	source;
+	operations = [];
+	facts = /* @__PURE__ */ new Map();
+	localValues = /* @__PURE__ */ new Map();
+	loop = 0;
+	calculate = false;
+	yielded = false;
+	constructor(root, mode, space, scope, parent, returns) {
+		this.root = root;
+		this.mode = mode;
+		this.space = space;
+		this.scope = scope;
+		this.parent = parent;
+		this.returns = returns;
+	}
+	view() {
+		return new Proxy(Object.create(null), { get: (_target, key) => typeof key === "string" ? (...args) => this.root.guard(() => {
+			if (this.closed) this.root.error("IR_LIFECYCLE", "This body Builder is closed.");
+			if (this.root.active !== this) this.root.error("IR_SCOPE", "A captured outer Builder cannot emit into a nested callback.");
+			if (this.ended) this.root.error(this.endedByWaitUntil ? "IR_JIT_BOUNDARY" : "IR_CONTROL_FLOW", "Cannot append an operation after a path terminator.");
+			return this.invoke(key, args);
+		}) : void 0 });
+	}
+	node(node) {
+		const withSource = {
+			...node,
+			...node.source === void 0 && this.source !== void 0 ? { source: snapshot(this.source) } : {}
+		};
+		operation(withSource, []);
+		this.operations.push(withSource);
+	}
+	result(type, node, extra = {}) {
+		const id = this.space.result++;
+		this.node({
+			...node,
+			result: id,
+			type
+		});
+		return fresh(values, {
+			root: this.root,
+			scope: this.scope,
+			space: this.space,
+			type,
+			id,
+			...extra
+		});
+	}
+	handle(value, expected) {
+		const info = infoOf(value);
+		if (!info || info.root !== this.root || info.space !== this.space || !descendant(this.scope, info.scope)) this.root.error("IR_SCOPE", "Value is not visible in the current execution body or scope.");
+		if (expected && !sameType(info.type, expected)) this.root.error("IR_TYPE", "Operand type does not match the expected type.");
+		return info;
+	}
+	localHandle(value) {
+		const info = locals.get(value);
+		if (!info || info.root !== this.root || info.space !== this.space || !descendant(this.scope, info.scope)) this.root.error("IR_SCOPE", "Local is not visible in this execution body or scope.");
+		return info;
+	}
+	infer(value) {
+		if (infoOf(value)) return this.handle(value).type;
+		const member = enumOf(value);
+		if (member) {
+			if (member.owner && member.owner !== this.root && (!this.root.device || definitionOwners.get(this.root.device) !== member.owner)) this.root.error("IR_SCOPE", "Enum member belongs to another device definition.");
+			return {
+				kind: "enum",
+				name: member.name
+			};
+		}
+		if (typeof value === "number") return n;
+		if (typeof value === "boolean") return b;
+		if (typeof value === "string") return str;
+		if (Array.isArray(value) || value instanceof Uint8Array) return bytes;
+		this.root.error("IR_TYPE", "A null or record literal requires an explicit target type.");
+	}
+	constantData(type, value) {
+		if (type.kind === "optional") {
+			if (value !== null) this.root.error("IR_TYPE", "Optional constants must be lifted from a non-null value.");
+			return { kind: "none" };
+		}
+		if (type.kind === "number" || type.kind === "bool" || type.kind === "string") {
+			if (typeof value !== (type.kind === "bool" ? "boolean" : type.kind)) this.root.error("IR_TYPE", "Constant value does not match its target type.");
+			return {
+				kind: type.kind,
+				value
+			};
+		}
+		if (type.kind === "enum") {
+			const member = enumOf(value);
+			if (!member || member.name !== type.name) this.root.error("IR_TYPE", "Enum constants require a matching enum member token.");
+			if (member.owner && member.owner !== this.root && (!this.root.device || definitionOwners.get(this.root.device) !== member.owner)) this.root.error("IR_SCOPE", "Enum member belongs to another definition.");
+			return {
+				kind: "enum",
+				name: member.name,
+				member: member.member
+			};
+		}
+		if (type.kind === "record") {
+			if (value === null || typeof value !== "object" || Array.isArray(value)) this.root.error("IR_TYPE", "A record constant requires a field object.");
+			const info = [...this.root.expectedTypes].find((info) => {
+				const base = info.type.kind === "optional" ? info.type.inner : info.type;
+				return base.kind === "record" && base.name === type.name && info.fields;
+			});
+			const declaration = this.root.names.get(type.name);
+			const expected = info?.fields ? Object.entries(info.fields).map(([name, t]) => ({
+				name,
+				type: typeData.get(t).type.kind
+			})) : declaration?.kind === "record" ? declaration.fields : void 0;
+			if (!expected) this.root.error("IR_TYPE", "Record constants require a complete named type descriptor.");
+			const input = value;
+			if (Object.keys(input).length !== expected.length || expected.some((field) => !Object.hasOwn(input, field.name) || typeof input[field.name] !== (field.type === "bool" ? "boolean" : "number"))) this.root.error("IR_TYPE", "Record constant fields do not match the target type.");
+			return {
+				kind: "record",
+				name: type.name,
+				fields: Object.keys(input).map((name) => ({
+					name,
+					value: input[name]
+				}))
+			};
+		}
+		if (type.kind === "bytes") {
+			if (!(value instanceof Uint8Array) && !Array.isArray(value)) this.root.error("IR_TYPE", "bytes constants require a Uint8Array or number array.");
+			const array = Array.from(value);
+			if (array.some((element) => !Number.isInteger(element) || element < 0 || element > 255)) this.root.error("IR_TYPE", "Every bytes element must be an integer from zero to 255.");
+			return {
+				kind: "bytes",
+				value: Object.freeze(array)
+			};
+		}
+		this.root.error("IR_TYPE", "sample and intent cannot be constructed from host constants.");
+	}
+	operand(value, expected) {
+		if (infoOf(value)) {
+			const info = this.handle(value);
+			if (expected && expected.kind === "optional" && sameType(info.type, expected.inner)) {
+				const lifted = this.handle(this.result(expected, {
+					kind: "optional",
+					value: info.id
+				}));
+				this.facts.set(alias(lifted), true);
+				return lifted;
+			}
+			if (expected && !sameType(info.type, expected)) this.root.error("IR_TYPE", "Operand type does not match the expected type.");
+			return info;
+		}
+		const type = expected ?? this.infer(value);
+		if (type.kind === "optional" && value !== null) {
+			const constant = this.operand(value, type.inner);
+			const lifted = this.handle(this.result(type, {
+				kind: "optional",
+				value: constant.id
+			}));
+			this.facts.set(alias(lifted), true);
+			return lifted;
+		}
+		return this.handle(this.result(type, {
+			kind: "constant",
+			constant: this.constantData(type, value)
+		}, { none: value === null }));
+	}
+	ref(value, category) {
+		if (typeof value === "string") return {
+			kind: category,
+			name: value
+		};
+		const info = referenceOf(value);
+		if (!info || info.root !== this.root || info.space !== this.space || !descendant(this.scope, info.scope)) this.root.error("IR_SCOPE", "Resource reference is not visible in this body.");
+		if ((info.ref.kind === "parameter" ? info.ref.resource : info.ref.kind) !== category) this.root.error("IR_REFERENCE", "Resource reference category does not match.");
+		return info.ref;
+	}
+	refHandle(name, category) {
+		return fresh(refs, {
+			root: this.root,
+			scope: this.scope,
+			space: this.space,
+			ref: {
+				kind: category,
+				name
+			}
+		});
+	}
+	requireRead() {
+		if (["creation", "initial"].includes(this.mode)) this.root.error("IR_EFFECT", "Runtime resource reads are not available in creation code.");
+	}
+	requireEffect() {
+		if ([
+			"creation",
+			"initial",
+			"pure"
+		].includes(this.mode)) this.root.error("IR_EFFECT", "Runtime effects are not available in pure or creation code.");
+	}
+	branch(emit, condition, compute, loop = false) {
+		if (typeof emit !== "function") this.root.error("IR_SCHEMA", "A body callback is required.");
+		const body = new Body(this.root, this.mode, this.space, { parent: this.scope }, this, this.returns);
+		body.source = this.source;
+		body.loop = compute ? 0 : this.loop + (loop ? 1 : 0);
+		body.calculate = !!compute || this.calculate;
+		body.facts = new Map(this.facts);
+		body.localValues = new Map(this.localValues);
+		if (condition) for (const [value, fact] of (condition.truth ? condition.info.yes : condition.info.no) ?? []) body.facts.set(alias(value), fact);
+		const previous = this.root.active;
+		this.root.active = body;
+		let returned;
+		try {
+			returned = emit(body.view());
+			if (compute) {
+				if (returned === void 0) {
+					if (!body.ended) this.root.error("IR_CONTROL_FLOW", "A compute callback must produce a value on every normal path.");
+				} else if (!body.ended) {
+					const value = body.operand(returned, compute);
+					body.node({
+						kind: "yield",
+						value: value.id
+					});
+					body.yielded = true;
+					body.ended = true;
+				}
+			}
+		} finally {
+			body.closed = true;
+			this.root.active = previous;
+		}
+		this.root.check();
+		return {
+			body: {
+				operations: body.operations,
+				...body.source ? { source: snapshot(body.source) } : {}
+			},
+			builder: body,
+			returned
+		};
+	}
+	merge(branches) {
+		const live = branches.filter((branch) => !branch.ended);
+		if (!live.length) {
+			this.ended = true;
+			this.endedByWaitUntil = branches.some((branch) => branch.endedByWaitUntil);
+			return;
+		}
+		this.facts = joinFacts(live.map((branch) => branch.facts));
+		for (const [local, old] of this.localValues) {
+			const candidates = live.map((branch) => branch.localValues.get(local) ?? old);
+			if (candidates.every((value) => value === candidates[0])) this.localValues.set(local, candidates[0]);
+			else {
+				const merged = {
+					...old,
+					alias: void 0
+				};
+				this.localValues.set(local, merged);
+				if (candidates.every((value, i) => live[i].facts.get(alias(value)) === true)) this.facts.set(merged, true);
+			}
+		}
+	}
+	mergeComputations(branches, includeCurrent = false) {
+		const live = branches.filter((branch) => branch.yielded);
+		if (includeCurrent) live.push(this);
+		if (!live.length) {
+			this.ended = true;
+			return;
+		}
+		this.facts = joinFacts(live.map((branch) => branch.facts));
+		for (const [local, old] of this.localValues) {
+			const candidates = live.map((branch) => branch.localValues.get(local) ?? old);
+			if (candidates.every((value) => value === candidates[0])) this.localValues.set(local, candidates[0]);
+			else {
+				const unknown = {
+					...old,
+					alias: void 0
+				};
+				this.localValues.set(local, unknown);
+				if (candidates.every((value, i) => live[i].facts.get(alias(value)) === true)) this.facts.set(unknown, true);
+			}
+		}
+	}
+	invoke(method, args) {
+		if (unary.includes(method)) {
+			const value = this.operand(args[0], method === "not" ? b : n);
+			return this.result(method === "not" ? b : n, {
+				kind: "unary",
+				operator: method,
+				value: value.id
+			}, method === "not" ? {
+				yes: value.no ?? /* @__PURE__ */ new Map(),
+				no: value.yes ?? /* @__PURE__ */ new Map()
+			} : {});
+		}
+		if (binary.includes(method)) {
+			const equality = ["equal", "notEqual"].includes(method);
+			const type = equality ? this.root.type(args.shift()) : method === "concat" ? str : n;
+			const left = this.operand(args[0], type), right = this.operand(args[1], type);
+			if (equality && (type.kind === "intent" || type.kind === "optional" && type.inner.kind === "intent" && !left.none && !right.none)) this.root.error("IR_TYPE", "Intent values do not support content equality.");
+			const tested = left.none ? right : right.none ? left : void 0;
+			const comparison = equality || [
+				"lessThan",
+				"lessThanOrEqual",
+				"greaterThan",
+				"greaterThanOrEqual"
+			].includes(method);
+			return this.result(comparison ? b : type, {
+				kind: "binary",
+				operator: method,
+				left: left.id,
+				right: right.id
+			}, tested ? {
+				yes: /* @__PURE__ */ new Map([[alias(tested), method !== "equal"]]),
+				no: /* @__PURE__ */ new Map([[alias(tested), method === "equal"]])
+			} : {});
+		}
+		if (numeric.includes(method)) {
+			const count = [
+				"min",
+				"max",
+				"pow"
+			].includes(method) ? 2 : 1;
+			if (args.length !== count) this.root.error("IR_TYPE", "Numeric builtin argument count does not match.");
+			return this.result(method.startsWith("is") ? b : n, {
+				kind: "numeric",
+				builtin: method,
+				args: args.map((value) => this.operand(value, n).id)
+			});
+		}
+		if (loads.includes(method) || stores.includes(method)) {
+			this.requireRead();
+			const memory = this.ref(args[0], "memory"), offset = this.operand(args[1], n);
+			if (stores.includes(method)) {
+				this.requireEffect();
+				this.node({
+					kind: method,
+					memory,
+					offset: offset.id,
+					value: this.operand(args[2], n).id
+				});
+				return;
+			}
+			return this.result(n, {
+				kind: method,
+				memory,
+				offset: offset.id
+			});
+		}
+		switch (method) {
+			case "withSource": {
+				const [source, emit] = args;
+				const view = new Body(this.root, this.mode, this.space, this.scope, this.parent, this.returns);
+				view.source = snapshot(source);
+				view.loop = this.loop;
+				view.calculate = this.calculate;
+				view.facts = this.facts;
+				view.localValues = this.localValues;
+				const previous = this.root.active;
+				this.root.active = view;
+				try {
+					emit(view.view());
+				} finally {
+					view.closed = true;
+					this.root.active = previous;
+				}
+				this.operations.push(...view.operations);
+				this.ended = view.ended;
+				this.endedByWaitUntil = view.endedByWaitUntil;
+				this.facts = view.facts;
+				this.localValues = view.localValues;
+				return;
+			}
+			case "constant":
+				if (infoOf(args[1])) this.root.error("IR_TYPE", "constant requires a host constant, not a Value handle.");
+				return this.objectOperand(args[1], this.root.type(args[0]));
+			case "readProperty":
+			case "readConst":
+			case "readState":
+			case "readDerived": {
+				if (["readState", "readDerived"].includes(method)) this.requireRead();
+				const resource = method.slice(4).toLowerCase();
+				return this.result(this.root.type(args[1]), {
+					kind: "read",
+					resource,
+					name: args[0]
+				});
+			}
+			case "local": {
+				const type = this.root.type(args[0]), initial = this.operand(args[1], type), id = this.space.local++;
+				this.node({
+					kind: "local",
+					local: id,
+					type,
+					initial: initial.id
+				});
+				const data = {
+					root: this.root,
+					space: this.space,
+					scope: this.scope,
+					type,
+					id
+				};
+				this.localValues.set(data, initial);
+				return fresh(locals, data);
+			}
+			case "getLocal": {
+				const local = this.localHandle(args[0]), current = this.localValues.get(local);
+				return this.result(local.type, {
+					kind: "localRead",
+					local: local.id
+				}, {
+					alias: alias(current),
+					yes: current.yes ?? /* @__PURE__ */ new Map(),
+					no: current.no ?? /* @__PURE__ */ new Map(),
+					none: current.none ?? false
+				});
+			}
+			case "setLocal": {
+				const local = this.localHandle(args[0]), value = this.operand(args[1], local.type);
+				this.node({
+					kind: "localWrite",
+					local: local.id,
+					value: value.id
+				});
+				this.localValues.set(local, value);
+				return;
+			}
+			case "record": {
+				const type = this.root.type(args[0]), descriptor = typeData.get(args[0]);
+				const input = args[1];
+				if (type.kind !== "record" || !descriptor.fields || !input || typeof input !== "object" || Object.keys(input).length !== Object.keys(descriptor.fields).length || Object.keys(descriptor.fields).some((key) => !Object.hasOwn(input, key))) this.root.error("IR_TYPE", "Record fields must exactly match the descriptor.");
+				return this.result(type, {
+					kind: "record",
+					fields: Object.keys(input).map((name) => ({
+						name,
+						value: this.operand(input[name], this.root.type(descriptor.fields[name])).id
+					}))
+				});
+			}
+			case "field": {
+				const value = this.handle(args[0]), field = args[1];
+				let type;
+				if (value.type.kind === "sample") type = {
+					voltage: {
+						kind: "optional",
+						inner: n
+					},
+					level: {
+						kind: "enum",
+						name: "Logic"
+					},
+					status: {
+						kind: "enum",
+						name: "SampleStatus"
+					}
+				}[field];
+				else if (value.type.kind === "record") {
+					const name = value.type.name;
+					const f = [...this.root.expectedTypes].find((info) => {
+						const base = info.type.kind === "optional" ? info.type.inner : info.type;
+						return base.kind === "record" && base.name === name && info.fields;
+					})?.fields?.[field];
+					if (f) type = this.root.type(f);
+					else {
+						const declaration = this.root.names.get(name);
+						const found = declaration?.kind === "record" ? declaration.fields.find((f) => f.name === field) : void 0;
+						if (found) type = { kind: found.type };
+					}
+				}
+				if (!type) this.root.error("IR_REFERENCE", "Unknown record or sample field.");
+				const parent = alias(value);
+				parent.fields ??= /* @__PURE__ */ new Map();
+				const previous = parent.fields.get(field);
+				const output = this.result(type, {
+					kind: "field",
+					value: value.id,
+					field
+				}, previous ? { alias: previous } : {});
+				if (!previous) parent.fields.set(field, this.handle(output));
+				return output;
+			}
+			case "bytes": return this.result(bytes, {
+				kind: "bytes",
+				elements: args.map((value) => this.operand(value, n).id)
+			});
+			case "length": {
+				const value = this.handle(args[0]);
+				if (!["string", "bytes"].includes(value.type.kind)) this.root.error("IR_TYPE", "length requires string or bytes.");
+				return this.result(n, {
+					kind: "length",
+					value: value.id
+				});
+			}
+			case "index": {
+				const value = this.handle(args[0]);
+				if (!["string", "bytes"].includes(value.type.kind)) this.root.error("IR_TYPE", "index requires string or bytes.");
+				return this.result(value.type.kind === "string" ? str : n, {
+					kind: "index",
+					value: value.id,
+					index: this.operand(args[1], n).id
+				});
+			}
+			case "optional": {
+				const value = this.handle(args[0]);
+				if (value.type.kind === "optional") this.root.error("IR_TYPE", "Optional types cannot be nested.");
+				const output = this.result({
+					kind: "optional",
+					inner: value.type
+				}, {
+					kind: "optional",
+					value: value.id
+				});
+				this.facts.set(alias(this.handle(output)), true);
+				return output;
+			}
+			case "isNone": {
+				const value = this.handle(args[0]);
+				if (value.type.kind !== "optional") this.root.error("IR_TYPE", "isNone requires an optional value.");
+				return this.result(b, {
+					kind: "isNone",
+					value: value.id
+				}, {
+					yes: /* @__PURE__ */ new Map([[alias(value), false]]),
+					no: /* @__PURE__ */ new Map([[alias(value), true]])
+				});
+			}
+			case "nonNull": {
+				const value = this.handle(args[0]);
+				if (value.type.kind !== "optional" || this.facts.get(alias(value)) !== true) this.root.error("IR_TYPE", "nonNull requires a dominating non-null proof.");
+				return this.result(value.type.inner, {
+					kind: "nonNull",
+					value: value.id
+				});
+			}
+			case "pin":
+				if (this.mode === "creation") this.root.error("IR_EFFECT", "Pin references are not available in ordinary creation computations.");
+				return this.refHandle(args[0], "pin");
+			case "memory":
+				this.requireRead();
+				return this.refHandle(args[0], "memory");
+			case "memoryLength":
+				this.requireRead();
+				return this.result(n, {
+					kind: "memoryLength",
+					memory: this.ref(args[0], "memory")
+				});
+			case "copyBytes":
+				this.requireRead();
+				return this.result(bytes, {
+					kind: "copyBytes",
+					memory: this.ref(args[0], "memory"),
+					offset: this.operand(args[1], n).id,
+					length: this.operand(args[2], n).id
+				});
+			case "readSample":
+				this.requireRead();
+				return this.result(sample, {
+					kind: "readSample",
+					pin: this.ref(args[0], "pin")
+				});
+			case "resistor":
+				if (this.mode === "creation") this.root.error("IR_EFFECT", "Intent construction requires initial-intent or runtime code.");
+				return this.result(intent, {
+					kind: "resistor",
+					to: this.ref(args[0], "pin"),
+					resistance: this.operand(args[1], n).id
+				});
+			case "combineIntents":
+				if (this.mode === "creation") this.root.error("IR_EFFECT", "Intent construction is not available here.");
+				return this.result(intent, {
+					kind: "combineIntents",
+					values: args.map((value) => this.operand(value, intent).id)
+				});
+			case "refEqual": {
+				this.requireRead();
+				const left = referenceOf(args[0]), right = referenceOf(args[1]);
+				if (!left || !right) this.root.error("IR_TYPE", "refEqual requires resource reference handles.");
+				const category = left.ref.kind === "parameter" ? left.ref.resource : left.ref.kind;
+				return this.result(b, {
+					kind: "refEqual",
+					left: this.ref(args[0], category),
+					right: this.ref(args[1], category)
+				});
+			}
+			case "writeState":
+				this.requireEffect();
+				this.node({
+					kind: "write",
+					resource: "state",
+					name: args[0],
+					value: this.operand(args[1], this.root.declarationType(args[0])).id
+				});
+				return;
+			case "writeIntent":
+				this.requireEffect();
+				this.node({
+					kind: "writeIntent",
+					pin: this.ref(args[0], "pin"),
+					value: this.operand(args[1], intent).id
+				});
+				return;
+			case "send":
+				this.requireEffect();
+				this.node({
+					kind: "send",
+					channel: args[0],
+					value: this.operand(args[1], this.root.declarationType(args[0])).id
+				});
+				return;
+			case "notify":
+				this.requireEffect();
+				this.node({
+					kind: "notify",
+					notification: args[0]
+				});
+				return;
+			case "now":
+			case "random":
+				this.requireEffect();
+				return this.result(n, { kind: method });
+			case "call":
+			case "callValue":
+			case "callPure":
+			case "callPureValue": {
+				const pure = method.startsWith("callPure"), hasValue = method.endsWith("Value");
+				if (!pure) this.requireEffect();
+				const name = args.shift(), type = hasValue ? this.root.type(args.shift()) : void 0;
+				const signature = this.root.names.get(name);
+				const parameters = signature?.kind === "function" ? signature.params : void 0;
+				const argumentsIR = args.map((value, index) => {
+					const ref = referenceOf(value);
+					if (ref) {
+						if (this.mode === "creation") this.root.error("IR_EFFECT", "Resource arguments are not available in ordinary creation code.");
+						return this.ref(value, ref.ref.kind === "parameter" ? ref.ref.resource : ref.ref.kind);
+					}
+					const expected = parameters?.[index]?.type;
+					if (expected && ["pin", "memory"].includes(expected.kind)) this.root.error("IR_TYPE", "A resource reference argument is required.");
+					if (!expected && !infoOf(value)) {
+						const requiresSignature = value === null || typeof value === "object" && !enumOf(value) && !Array.isArray(value) && !(value instanceof Uint8Array);
+						const inferred = requiresSignature ? n : this.infer(value);
+						const node = {
+							kind: "constant",
+							result: this.space.result++,
+							type: inferred,
+							constant: requiresSignature ? {
+								kind: "number",
+								value: 0
+							} : this.constantData(inferred, value),
+							...this.source ? { source: snapshot(this.source) } : {}
+						};
+						this.operations.push(node);
+						this.root.pending.push({
+							node,
+							call: name,
+							index,
+							value: enumOf(value) ? value : snapshot(value),
+							body: this,
+							requiresSignature
+						});
+						return {
+							kind: "value",
+							value: node.result
+						};
+					}
+					return {
+						kind: "value",
+						value: this.operand(value, expected).id
+					};
+				});
+				const node = {
+					kind: hasValue ? "callValue" : "call",
+					name,
+					pure,
+					args: argumentsIR
+				};
+				if (hasValue) return this.result(type, node);
+				this.node(node);
+				return;
+			}
+			case "receive":
+				if (this.calculate || this.mode !== "process") this.root.error("IR_EFFECT", "receive requires a process statement region.");
+				return this.result(this.root.type(args[1]), {
+					kind: "receive",
+					channel: args[0]
+				});
+			case "if": {
+				const condition = this.operand(args[0], b);
+				const yes = this.branch(args[1], {
+					info: condition,
+					truth: true
+				});
+				const no = this.branch(args[2] ?? (() => {}), {
+					info: condition,
+					truth: false
+				});
+				this.node({
+					kind: "if",
+					condition: condition.id,
+					yes: yes.body,
+					...args[2] ? { no: no.body } : {}
+				});
+				this.merge([yes.builder, no.builder]);
+				return;
+			}
+			case "match": {
+				const value = this.handle(args[0]), arms = args[1];
+				if (!Array.isArray(arms)) this.root.error("IR_SCHEMA", "match arms must be an array.");
+				const builders = [];
+				const nodes = arms.map((arm) => {
+					const pattern = arm.pattern === null ? { kind: "none" } : this.constantData(value.type.kind === "optional" ? value.type.inner : value.type, arm.pattern);
+					if (![
+						"none",
+						"number",
+						"bool",
+						"string",
+						"enum"
+					].includes(pattern.kind)) this.root.error("IR_TYPE", "Invalid match pattern.");
+					const condition = {
+						...value,
+						yes: /* @__PURE__ */ new Map([[alias(value), pattern.kind !== "none"]])
+					};
+					const branch = this.branch(arm.emit, {
+						info: condition,
+						truth: true
+					});
+					builders.push(branch.builder);
+					return {
+						pattern,
+						body: branch.body
+					};
+				});
+				const defaultCondition = nodes.some((node) => node.pattern.kind === "none") ? {
+					info: {
+						...value,
+						yes: /* @__PURE__ */ new Map([[alias(value), true]])
+					},
+					truth: true
+				} : void 0;
+				const fallback = args[2] ? this.branch(args[2], defaultCondition) : void 0;
+				if (fallback) builders.push(fallback.builder);
+				this.node({
+					kind: "match",
+					value: value.id,
+					arms: nodes,
+					...fallback ? { otherwise: fallback.body } : {}
+				});
+				this.merge(builders.length ? builders : [this]);
+				return;
+			}
+			case "while":
+			case "loop": {
+				const before = new Map(this.localValues);
+				const test = method === "while" ? this.branch(args[0], void 0, b) : void 0;
+				const body = this.branch(args[method === "while" ? 1 : 0], void 0, void 0, true);
+				this.node({
+					kind: method,
+					...test ? { test: {
+						type: b,
+						body: test.body
+					} } : {},
+					body: body.body
+				});
+				for (const [local, old] of before) if (body.builder.localValues.get(local) !== old || test && test.builder.localValues.get(local) !== old) this.localValues.set(local, {
+					...old,
+					alias: void 0
+				});
+				if (test && !test.builder.yielded) this.ended = true;
+				return;
+			}
+			case "and":
+			case "or": {
+				const left = this.operand(args[0], b), isAnd = method === "and";
+				const branch = this.branch(args[1], {
+					info: left,
+					truth: isAnd
+				}, b);
+				const right = infoOf(branch.returned);
+				const combine = (a, b) => new Map([...a ?? [], ...b ?? []]);
+				const yes = isAnd ? combine(left.yes, right?.yes) : joinFacts([left.yes ?? /* @__PURE__ */ new Map(), combine(left.no, right?.yes)]);
+				const no = isAnd ? joinFacts([left.no ?? /* @__PURE__ */ new Map(), combine(left.yes, right?.no)]) : combine(left.no, right?.no);
+				const value = this.result(b, {
+					kind: method,
+					left: left.id,
+					right: {
+						type: b,
+						body: branch.body
+					}
+				}, {
+					yes,
+					no
+				});
+				this.mergeComputations([branch.builder], true);
+				return value;
+			}
+			case "select": {
+				const type = this.root.type(args[0]), condition = this.operand(args[1], b);
+				const yes = this.branch(args[2], {
+					info: condition,
+					truth: true
+				}, type), no = this.branch(args[3], {
+					info: condition,
+					truth: false
+				}, type);
+				const value = this.result(type, {
+					kind: "select",
+					condition: condition.id,
+					yes: {
+						type,
+						body: yes.body
+					},
+					no: {
+						type,
+						body: no.body
+					}
+				});
+				this.mergeComputations([yes.builder, no.builder]);
+				return value;
+			}
+			case "assert": {
+				const condition = this.operand(args[0], b), message = args[1] ? this.branch(args[1], {
+					info: condition,
+					truth: false
+				}, str) : void 0;
+				this.node({
+					kind: "assert",
+					condition: condition.id,
+					...message ? { message: {
+						type: str,
+						body: message.body
+					} } : {}
+				});
+				for (const [value, fact] of condition.yes ?? []) this.facts.set(alias(value), fact);
+				return;
+			}
+			case "wait":
+			case "elapse":
+				if (this.calculate || (method === "wait" ? this.mode !== "process" : this.mode !== "jit")) this.root.error("IR_EFFECT", `${method} is not permitted in this context.`);
+				this.node({
+					kind: method,
+					duration: this.operand(args[0], n).id
+				});
+				return;
+			case "waitUntil":
+				if (this.mode !== "jit" || this.calculate || this.loop) this.root.error("IR_JIT_BOUNDARY", "waitUntil requires a JIT tail path outside loops and computations.");
+				this.node({
+					kind: "waitUntil",
+					predicate: args[0]
+				});
+				this.ended = true;
+				this.endedByWaitUntil = true;
+				return;
+			case "redirect":
+				if (!["jit", "sync"].includes(this.mode)) this.root.error("IR_EFFECT", "redirect requires a JIT-capable context.");
+				this.node({
+					kind: "redirect",
+					target: this.operand(args[0], n).id,
+					delay: this.operand(args[1] ?? 0, n).id
+				});
+				this.ended = true;
+				return;
+			case "stop":
+				if (this.mode !== "jit" || this.calculate) this.root.error("IR_EFFECT", "stop requires a JIT statement region.");
+				this.node({ kind: "stop" });
+				this.ended = true;
+				return;
+			case "break":
+			case "continue":
+				if (!this.loop) this.root.error("IR_CONTROL_FLOW", `${method} requires an enclosing loop.`);
+				this.node({ kind: method });
+				this.ended = true;
+				return;
+			case "return":
+				if (this.calculate || this.returns || [
+					"jit",
+					"creation",
+					"initial"
+				].includes(this.mode)) this.root.error("IR_CONTROL_FLOW", "Void return is not permitted in this body.");
+				this.node({ kind: "return" });
+				this.ended = true;
+				return;
+			case "returnValue":
+				if (this.calculate || !this.returns) this.root.error("IR_CONTROL_FLOW", "returnValue is not permitted in this body.");
+				this.node({
+					kind: "returnValue",
+					value: this.operand(args[0], this.returns).id
+				});
+				this.ended = true;
+				return;
+			default: this.root.error("IR_SCHEMA", `Unknown Builder operation ${method}.`);
+		}
+	}
+	objectOperand(value, type) {
+		return fresh(values, this.operand(value, type));
+	}
+};
+function deviceView(root, temporary = { closed: false }) {
+	return new Proxy(Object.create(null), { get: (_target, method) => typeof method === "string" ? (...args) => {
+		if (method === "finish") {
+			root.check();
+			if (temporary.closed) root.error("IR_LIFECYCLE", "This source view is closed.");
+			if (root.active) root.error("IR_SCOPE", "Cannot finish a device while a body callback is active.");
+			root.closed = true;
+			root.resolve();
+			const definition = validateDeviceIR({
+				kind: "device",
+				name: root.options.name,
+				declarations: root.declarations,
+				...root.sourceFor()
+			});
+			definitionOwners.set(definition, root);
+			return definition;
+		}
+		return root.guard(() => {
+			if (temporary.closed) root.error("IR_LIFECYCLE", "This source view is closed.");
+			if (root.active) root.error("IR_SCOPE", "Cannot add declarations inside an executable body callback.");
+			if (method === "withSource") {
+				const previous = root.source, viewState = { closed: false };
+				root.source = snapshot(args[0]);
+				try {
+					args[1](deviceView(root, viewState));
+				} finally {
+					viewState.closed = true;
+					root.source = previous;
+				}
+				return;
+			}
+			const options = args[0] ?? {}, source = options.source ?? root.source;
+			const base = {
+				name: options.name,
+				...root.sourceFor(options)
+			};
+			if (method === "enum") {
+				const descriptor = factory.namedEnum(options.name, options.members);
+				const data = typeData.get(descriptor);
+				data.owner = root;
+				const owned = enumType(options.name, options.members, root);
+				root.add({
+					kind: "enum",
+					...base,
+					members: [...options.members]
+				});
+				return owned;
+			}
+			if (method === "record") {
+				factory.namedRecord(options.name, options.fields);
+				for (const type of Object.values(options.fields)) root.type(type);
+				const descriptor = recordType(options.name, options.fields, root);
+				root.add({
+					kind: "record",
+					...base,
+					fields: Object.entries(options.fields).map(([name, type]) => ({
+						name,
+						type: root.type(type).kind
+					}))
+				});
+				return descriptor;
+			}
+			if ([
+				"property",
+				"constant",
+				"state"
+			].includes(method)) {
+				const type = root.type(options.type), key = method === "property" ? "default" : method === "constant" ? "value" : "initial";
+				if (key !== "default" && !Object.hasOwn(options, key)) root.error("IR_SCHEMA", `Missing ${key}.`);
+				root.add({
+					kind: method === "constant" ? "const" : method,
+					...base,
+					type,
+					...Object.hasOwn(options, key) ? { [key]: root.creation(type, options[key], "creation", source) } : {}
+				});
+				return;
+			}
+			if (method === "derived") {
+				const type = root.type(options.type);
+				root.add({
+					kind: "derived",
+					...base,
+					type,
+					value: {
+						type,
+						body: root.body("pure", args[1], type, source)
+					}
+				});
+				return;
+			}
+			if (method === "pin") {
+				if (Object.hasOwn(options, "low") !== Object.hasOwn(options, "high")) root.error("IR_SCHEMA", "Pin thresholds must be specified together.");
+				root.add({
+					kind: "pin",
+					...base,
+					...Object.hasOwn(options, "low") ? {
+						low: root.creation(n, options.low, "creation", source),
+						high: root.creation(n, options.high, "creation", source)
+					} : {},
+					...Object.hasOwn(options, "initial") ? { initial: root.creation(intent, options.initial, "initial", source) } : {}
+				});
+				return;
+			}
+			if (method === "memory") {
+				root.add({
+					kind: "memory",
+					...base,
+					public: options.public ?? false,
+					length: root.creation(n, options.length, "creation", source)
+				});
+				return;
+			}
+			if (method === "channel") {
+				const type = root.type(options.type);
+				root.add({
+					kind: "channel",
+					...base,
+					direction: options.direction,
+					type,
+					capacity: root.creation(n, options.capacity, "creation", source),
+					...Object.hasOwn(options, "maxLength") ? { maxLength: root.creation(n, options.maxLength, "creation", source) } : {},
+					...Object.hasOwn(options, "overflow") ? { overflow: root.creation({
+						kind: "enum",
+						name: "Overflow"
+					}, options.overflow, "creation", source) } : {}
+				});
+				return;
+			}
+			if (method === "notification") {
+				root.add({
+					kind: "notification",
+					...base,
+					direction: options.direction
+				});
+				return;
+			}
+			if (method === "fn" || method === "pureFn") {
+				const pure = method === "pureFn", returns = Object.hasOwn(options, "returns") ? root.type(options.returns) : void 0;
+				if (!Array.isArray(options.params)) root.error("IR_SCHEMA", "Function parameters must be an array.");
+				const params = options.params.map((param) => ({
+					name: param.name,
+					type: param.type === types.pin ? { kind: "pin" } : param.type === types.memory ? { kind: "memory" } : root.type(param.type)
+				}));
+				let bindings = {};
+				const body = root.body(pure ? "pure" : "sync", (view) => args[1](view, bindings), returns, source, (body) => {
+					bindings = Object.create(null);
+					params.forEach((param, index) => {
+						bindings[param.name] = param.type.kind === "pin" || param.type.kind === "memory" ? fresh(refs, {
+							root,
+							scope: body.scope,
+							space: body.space,
+							ref: {
+								kind: "parameter",
+								resource: param.type.kind,
+								index
+							}
+						}) : body.result(param.type, {
+							kind: "parameter",
+							index
+						});
+					});
+				});
+				root.add({
+					kind: "function",
+					...base,
+					pure,
+					params,
+					...returns ? { returns } : {},
+					body
+				});
+				return;
+			}
+			if (method === "start") {
+				root.add({
+					kind: "start",
+					body: root.body("process", args[0]),
+					...root.sourceFor()
+				});
+				return;
+			}
+			if (method === "on") {
+				root.add({
+					kind: "on",
+					...base,
+					sourcePath: snapshot(options.sourcePath),
+					body: root.body("process", args[1], void 0, source)
+				});
+				return;
+			}
+			if (method === "reaction") {
+				if (!Array.isArray(options.captures) || !args[1] || typeof args[1] !== "object") root.error("IR_SCHEMA", "Reaction captures require descriptors and an emitter object.");
+				const emitters = args[1];
+				const names = options.captures.map((capture) => capture.name);
+				const keys = Object.keys(args[1]);
+				if (keys.length !== names.length || keys.some((key) => !names.includes(key)) || names.some((name) => typeof emitters[name] !== "function")) root.error("IR_SCHEMA", "Reaction capture emitter keys must exactly match descriptor names.");
+				const sourceType = root.type(options.sourceType);
+				const captures = options.captures.map((capture) => {
+					const type = root.type(capture.type);
+					return {
+						name: capture.name,
+						value: {
+							type,
+							body: root.body("pure", emitters[capture.name], type, capture.source ?? source)
+						},
+						...root.sourceFor(capture)
+					};
+				});
+				let bindings = {};
+				const body = root.body("reaction", (view) => args[2](view, bindings), void 0, source, (body) => {
+					bindings = {
+						previous: body.result(sourceType, {
+							kind: "reactionValue",
+							binding: "previous"
+						}),
+						current: body.result(sourceType, {
+							kind: "reactionValue",
+							binding: "current"
+						}),
+						captures: Object.create(null)
+					};
+					captures.forEach((capture, index) => {
+						bindings.captures[capture.name] = body.result(capture.value.type, {
+							kind: "reactionCapture",
+							index
+						});
+					});
+				});
+				root.add({
+					kind: "reaction",
+					...base,
+					sourcePath: snapshot(options.sourcePath),
+					sourceType,
+					previous: options.previous,
+					current: options.current,
+					captures,
+					body
+				});
+				return;
+			}
+			if (method === "assert") {
+				root.add({
+					kind: "assert",
+					body: root.body("creation", args[0]),
+					...root.sourceFor()
+				});
+				return;
+			}
+			root.error("IR_SCHEMA", `Unknown device Builder method ${method}.`);
+		});
+	} : void 0 });
+}
+function createDeviceBuilder(options) {
+	if (options === void 0) options = { name: "GeneratedDevice" };
+	if (!options || typeof options.name !== "string") fail("IR_SCHEMA", "A device name is required.", [], "construct");
+	return deviceView(new Root({
+		name: options.name,
+		...options.source ? { source: snapshot(options.source) } : {}
+	}));
+}
+/** Runtime integration factory; only existing resources can be referenced by the returned view. */
+function createJitBlockBuilder(options = {}) {
+	const root = new Root({
+		name: "JitBlock",
+		...options.source ? { source: options.source } : {}
+	}, options.device, true);
+	if (options.device) {
+		for (const declaration of options.device.declarations) if ("name" in declaration) root.names.set(declaration.name, declaration);
+	}
+	const view = (state = { closed: false }) => new Proxy(Object.create(null), { get: (_target, method) => typeof method === "string" ? (...args) => {
+		if (method === "finish") {
+			root.check();
+			if (state.closed) root.error("IR_LIFECYCLE", "This source view is closed.");
+			if (root.active) root.error("IR_SCOPE", "Cannot finish a block inside an instruction callback.");
+			root.closed = true;
+			root.resolve();
+			const block = {
+				kind: "block",
+				instructions: root.instructions,
+				...root.sourceFor()
+			};
+			return options.device ? validateBoundBlockIR(block, options.device) : validateBlockIR(block);
+		}
+		return root.guard(() => {
+			if (state.closed) root.error("IR_LIFECYCLE", "This source view is closed.");
+			if (root.active) root.error("IR_SCOPE", "Cannot add instructions inside an instruction callback.");
+			if (method === "withSource") {
+				const old = root.source, nested = { closed: false };
+				root.source = snapshot(args[0]);
+				try {
+					args[1](view(nested));
+				} finally {
+					nested.closed = true;
+					root.source = old;
+				}
+				return;
+			}
+			if (method !== "instruction") root.error("IR_SCHEMA", `Unknown block Builder method ${method}.`);
+			const boundary = args[0];
+			if (!boundary || !Number.isFinite(boundary.pc) || !Number.isFinite(boundary.nextPc)) root.error("IR_SCHEMA", "Instruction boundaries require finite pc and nextPc.");
+			const previous = root.instructions.at(-1);
+			if (previous && previous.nextPc !== boundary.pc) root.error("IR_JIT_BOUNDARY", "Adjacent instruction boundaries must match.");
+			const body = root.body("jit", args[1], void 0, boundary.source ?? root.source);
+			root.instructions.push({
+				pc: boundary.pc,
+				nextPc: boundary.nextPc,
+				body,
+				...root.sourceFor(boundary)
+			});
+		});
+	} : void 0 });
+	return view();
+}
+//#endregion
+export { BuildError, createDeviceBuilder, createJitBlockBuilder, types, validateBlockIR, validateBoundBlockIR, validateDeviceIR };
+
+//# sourceMappingURL=index.js.map