@mica-js/core 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,10 +1,2438 @@
-//#region src/index.ts
+import { SCALAR_TYPES, createIRInterpreter, evaluateFloatInstruction, evaluateScalarInstruction } from "@mica-js/ir";
+//#region src/scheduler/time.ts
+var MAX_TIME_PS = 72e14;
+var factors = {
+	ps: 1,
+	ns: 1e3,
+	us: 1e6,
+	ms: 1e9,
+	s: 0xe8d4a51000
+};
+function checked(value, name) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) throw new TypeError(`${name}=${String(value)} must be a finite integer number of picoseconds`);
+	if (value < 0 || value > 72e14) throw new RangeError(`${name}=${value} must be in [0, ${MAX_TIME_PS}] ps`);
+	return value === 0 ? 0 : value;
+}
+function timePs(value) {
+	return checked(value, "time");
+}
+function toTimePs(value, unit) {
+	if (typeof unit !== "string" || !Object.hasOwn(factors, unit)) throw new TypeError(`unit=${String(unit)} must be ps, ns, us, ms, or s`);
+	checked(value, `input (${unit})`);
+	return checked(value * factors[unit], `conversion ${String(value)} ${unit} to ps`);
+}
+function addTime(left, right) {
+	checked(left, "left");
+	checked(right, "right");
+	return checked(left + right, `addition ${left} + ${right}`);
+}
+function subtractTime(later, earlier) {
+	checked(later, "later");
+	checked(earlier, "earlier");
+	return checked(later - earlier, `subtraction ${later} - ${earlier}`);
+}
+//#endregion
+//#region src/scheduler/errors.ts
+var SchedulerError = class extends Error {
+	code;
+	name = "SchedulerError";
+	instanceId;
+	targetName;
+	timePs;
+	phase;
+	eventId;
+	steps;
+	entriesAtTime;
+	cause;
+	constructor(code, message, details) {
+		super(message, { cause: details.cause });
+		this.code = code;
+		this.instanceId = details.instanceId;
+		this.targetName = details.targetName;
+		this.timePs = details.timePs;
+		this.phase = details.phase;
+		this.eventId = details.eventId;
+		this.steps = details.steps ?? 0;
+		this.entriesAtTime = details.entriesAtTime ?? 0;
+		this.cause = details.cause;
+	}
+};
+//#endregion
+//#region src/scheduler/queue.ts
+var MinHeap = class {
+	compare;
+	#items = [];
+	constructor(compare) {
+		this.compare = compare;
+	}
+	peek() {
+		return this.#items[0];
+	}
+	/** Drops non-matching items so callers can release references while preserving heap order. */
+	retain(predicate) {
+		const kept = this.#items.filter(predicate);
+		this.#items.length = 0;
+		for (const item of kept) this.push(item);
+	}
+	push(item) {
+		const items = this.#items;
+		let index = items.length;
+		items.push(item);
+		while (index > 0) {
+			const parent = Math.floor((index - 1) / 2);
+			if (this.compare(items[parent], item) <= 0) break;
+			items[index] = items[parent];
+			index = parent;
+		}
+		items[index] = item;
+	}
+	pop() {
+		const items = this.#items;
+		const first = items[0];
+		const last = items.pop();
+		if (items.length === 0 || last === void 0) return first;
+		let index = 0;
+		while (index * 2 + 1 < items.length) {
+			let child = index * 2 + 1;
+			if (child + 1 < items.length && this.compare(items[child + 1], items[child]) < 0) child += 1;
+			if (this.compare(last, items[child]) <= 0) break;
+			items[index] = items[child];
+			index = child;
+		}
+		items[index] = last;
+		return first;
+	}
+};
+var EventIdPool = class {
+	maximum;
+	#highest = 0;
+	#released = [];
+	#head = 0;
+	constructor(maximum = 4294967295) {
+		this.maximum = maximum;
+	}
+	allocated(id) {
+		return id <= this.#highest;
+	}
+	take() {
+		if (this.#head < this.#released.length) {
+			const id = this.#released[this.#head++];
+			if (this.#head >= 1024 && this.#head * 2 >= this.#released.length) {
+				this.#released = this.#released.slice(this.#head);
+				this.#head = 0;
+			}
+			return id;
+		}
+		if (this.#highest === this.maximum) return void 0;
+		this.#highest += 1;
+		return this.#highest;
+	}
+	release(id) {
+		this.#released.push(id);
+	}
+};
+//#endregion
+//#region src/scheduler/values.ts
+function scalarType(value) {
+	return typeof value === "string" && SCALAR_TYPES.includes(value);
+}
+function captureArgs(types, args) {
+	if (!Array.isArray(args) || args.length !== types.length) throw new TypeError(`Expected ${types.length} scalar arguments`);
+	return Object.freeze(types.map((type, index) => {
+		const input = { type };
+		const node = {
+			op: "select",
+			operands: [
+				{
+					kind: "ssa",
+					value: { type: "bool" }
+				},
+				{
+					kind: "ssa",
+					value: input
+				},
+				{
+					kind: "ssa",
+					value: input
+				}
+			],
+			results: [input]
+		};
+		const value = args[index];
+		const result = type === "f32" || type === "f64" ? evaluateFloatInstruction(node, [
+			true,
+			value,
+			value
+		]) : evaluateScalarInstruction(node, [
+			true,
+			value,
+			value
+		]);
+		return typeof result === "object" ? Object.freeze({
+			type: result.type,
+			bits: result.bits
+		}) : result;
+	}));
+}
+function synchronous(fn) {
+	return typeof fn === "function" && Object.prototype.toString.call(fn) === "[object Function]";
+}
+function returnedSynchronously(value) {
+	if (value === void 0) return true;
+	if (typeof value === "object" && value !== null || typeof value === "function") {
+		if (typeof value.then === "function") Promise.resolve(value).catch(() => void 0);
+	}
+	return false;
+}
+//#endregion
+//#region src/scheduler/runtime.ts
+function compare(left, right) {
+	if (left.time !== right.time) return left.time < right.time ? -1 : 1;
+	if (left.target.kind !== right.target.kind) return left.target.kind === "control" ? -1 : 1;
+	if (left.round !== right.round) return left.round < right.round ? -1 : 1;
+	return left.sequence < right.sequence ? -1 : left.sequence === right.sequence ? 0 : 1;
+}
+function limit(value, fallback, name) {
+	const result = value === void 0 ? fallback : value;
+	if (!Number.isSafeInteger(result) || result < 0) throw new SchedulerError("invalid-options", `${name}=${String(result)} must be a non-negative safe integer`, { timePs: 0 });
+	return result;
+}
+function createScheduler(options = {}) {
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw new SchedulerError("invalid-options", "Expected scheduler options", { timePs: 0 });
+	return new DeterministicScheduler(limit(options.maxStepsPerEntry, 1e6, "maxStepsPerEntry"), limit(options.maxEntriesPerTime, 1e6, "maxEntriesPerTime"));
+}
+var DeterministicScheduler = class {
+	#queue = new MinHeap(compare);
+	#instances = /* @__PURE__ */ new Map();
+	#identities = /* @__PURE__ */ new Set();
+	#destruction = /* @__PURE__ */ new Set();
+	#maxSteps;
+	#maxEntries;
+	#now = timePs(0);
+	#state = "paused";
+	#error;
+	#sequence = 0n;
+	#ordinaryRound = 0n;
+	#controlRound = 0n;
+	#ordinaryStarted = false;
+	#controlStarted = false;
+	#entries = 0;
+	#steps = 0;
+	#current;
+	#pauseRequested = false;
+	constructor(maxSteps, maxEntries) {
+		this.#maxSteps = maxSteps;
+		this.#maxEntries = maxEntries;
+		Object.freeze(this);
+	}
+	get now() {
+		return this.#now;
+	}
+	get state() {
+		return this.#state;
+	}
+	get error() {
+		return this.#error;
+	}
+	addInstance(definition) {
+		return this.#boundary(() => {
+			if (definition === null || typeof definition !== "object") throw this.#problem("invalid-instance", "Expected instance definition");
+			const { instanceId, targets, executor } = definition;
+			if (typeof instanceId !== "string" || instanceId.length === 0 || this.#identities.has(instanceId)) throw this.#problem("invalid-instance", `instanceId=${String(instanceId)} must be nonempty and never reused`);
+			if (!Array.isArray(targets)) throw this.#problem("invalid-target", "Expected target declarations");
+			const captured = /* @__PURE__ */ new Map();
+			for (const target of targets) {
+				if (target === null || typeof target !== "object" || captured.has(target)) throw this.#problem("invalid-target", "Expected distinct target declaration objects");
+				const { name, kind, params } = target;
+				if (typeof name !== "string" || name.length === 0 || kind !== "event" && kind !== "control" || !Array.isArray(params) || !Array.from(params).every(scalarType)) throw this.#problem("invalid-target", "Target requires name, event/control kind, and scalar params");
+				const snapshot = Object.freeze({
+					name,
+					kind,
+					params: Object.freeze([...params])
+				});
+				captured.set(target, snapshot);
+				captured.set(snapshot, snapshot);
+			}
+			if (executor === null || typeof executor !== "object" || !synchronous(executor.execute)) throw this.#problem("executor-contract", "Executor.execute must be a synchronous non-generator method");
+			const execute = executor.execute;
+			const handle = Object.freeze({
+				instanceId,
+				at: (target, deadline, args) => this.#boundary(() => this.#at(this.#instance(handle), target, deadline, args)),
+				cancel: (id) => this.#boundary(() => this.#cancel(this.#instance(handle), id))
+			});
+			const instance = {
+				handle,
+				targets: captured,
+				execute,
+				receiver: executor,
+				ids: new EventIdPool(),
+				active: /* @__PURE__ */ new Map(),
+				destroyRequested: false,
+				destroyed: false
+			};
+			this.#identities.add(instanceId);
+			this.#instances.set(handle, instance);
+			return handle;
+		});
+	}
+	enqueueControl(handle, target, args) {
+		this.#boundary(() => {
+			const instance = this.#instance(handle);
+			const captured = this.#target(instance, target, "control");
+			const inputs = this.#arguments(captured, args);
+			this.#queue.push({
+				instance,
+				target: captured,
+				args: inputs,
+				time: this.#now,
+				round: this.#controlStarted ? this.#controlRound + 1n : 0n,
+				sequence: this.#sequence++,
+				id: 0,
+				status: "pending"
+			});
+		});
+	}
+	destroyInstance(handle) {
+		const instance = this.#instances.get(handle);
+		if (instance === void 0 || instance.destroyed || instance.destroyRequested) {
+			if (this.#error !== void 0) throw this.#problem("scheduler-faulted", "Scheduler faulted; rebuild instead of resuming", this.#error);
+			throw this.#problem("invalid-instance", "Instance is foreign, destroyed, or stopping");
+		}
+		instance.destroyRequested = true;
+		this.#destruction.add(instance);
+		if (this.#current === void 0) this.#flushDestruction();
+	}
+	start(options = {}) {
+		return this.#boundary(() => {
+			if (this.#state === "running") throw this.#problem("reentrant-execution", "Cannot recursively start or step the scheduler");
+			if (options === null || typeof options !== "object" || Array.isArray(options)) throw this.#problem("invalid-options", "Expected run options");
+			const until = options.until === void 0 ? void 0 : this.#deadline(options.until);
+			const maxEntries = limit(options.maxEntries, Number.MAX_SAFE_INTEGER, "maxEntries");
+			this.#state = "running";
+			this.#pauseRequested = false;
+			let executed = 0;
+			const result = (reason) => Object.freeze({
+				timePs: this.#now,
+				executed,
+				reason
+			});
+			try {
+				for (;;) {
+					if (this.#pauseRequested) return result("paused");
+					if (executed >= maxEntries) return result("entry-limit");
+					const work = this.#next();
+					if (work === void 0 || until !== void 0 && work.time > until) {
+						if (until !== void 0) {
+							this.#setTime(until);
+							return result("until");
+						}
+						return result("empty");
+					}
+					this.#setTime(work.time);
+					this.#execute(work);
+					executed += 1;
+				}
+			} finally {
+				if (this.#error === void 0) this.#state = "paused";
+			}
+		});
+	}
+	pause() {
+		if (this.#state === "running") this.#pauseRequested = true;
+	}
+	step() {
+		return this.start({ maxEntries: 1 });
+	}
+	#at(instance, target, deadline, args) {
+		const captured = this.#target(instance, target, "event");
+		const time = this.#deadline(deadline);
+		const inputs = this.#arguments(captured, args);
+		const id = instance.ids.take();
+		if (id === void 0) throw this.#problem("event-id-exhausted", "All nonzero u32 event IDs are occupied");
+		const work = {
+			instance,
+			target: captured,
+			args: inputs,
+			time,
+			round: time === this.#now && this.#ordinaryStarted ? this.#ordinaryRound + 1n : 0n,
+			sequence: this.#sequence++,
+			id,
+			status: "pending"
+		};
+		instance.active.set(id, work);
+		this.#queue.push(work);
+		return id;
+	}
+	#cancel(instance, id) {
+		if (typeof id !== "number" || !Number.isInteger(id) || id < 0 || id > 4294967295 || !instance.ids.allocated(id)) throw this.#problem("invalid-event-id", `eventId=${String(id)} must be 0 or a previously allocated u32 in this instance`);
+		if (id === 0) return;
+		const work = instance.active.get(id);
+		if (work === void 0 || work.status !== "pending") return;
+		work.status = "cancelled";
+		instance.active.delete(id);
+		instance.ids.release(id);
+	}
+	#target(instance, target, kind) {
+		const captured = instance.targets.get(target);
+		if (captured === void 0 || captured.kind !== kind) throw this.#problem("invalid-target", `Expected this instance's registered ${kind} target`);
+		return captured;
+	}
+	#arguments(target, args) {
+		try {
+			return captureArgs(target.params, args);
+		} catch (cause) {
+			throw this.#problem("invalid-argument", `Arguments for ${target.name} must match its scalar signature`, cause);
+		}
+	}
+	#instance(handle) {
+		const instance = this.#instances.get(handle);
+		if (instance === void 0 || instance.destroyed || instance.destroyRequested) throw this.#problem("invalid-instance", "Instance is foreign, destroyed, or stopping");
+		return instance;
+	}
+	#deadline(value) {
+		const deadline = timePs(value);
+		if (deadline < this.#now) throw new RangeError(`deadline=${deadline} ps must be in [${this.#now}, ${MAX_TIME_PS}] ps (not in the past)`);
+		return deadline;
+	}
+	#next() {
+		for (;;) {
+			const work = this.#queue.peek();
+			if (work === void 0) return void 0;
+			if (work.status === "pending" && !work.instance.destroyed) return work;
+			this.#queue.pop();
+		}
+	}
+	#setTime(time) {
+		if (time === this.#now) return;
+		this.#now = time;
+		this.#entries = 0;
+		this.#ordinaryRound = 0n;
+		this.#controlRound = 0n;
+		this.#ordinaryStarted = false;
+		this.#controlStarted = false;
+	}
+	#execute(work) {
+		this.#current = work;
+		this.#steps = 0;
+		try {
+			if (this.#entries >= this.#maxEntries) throw this.#problem("time-budget-exhausted", `Exceeded ${this.#maxEntries} entries at ${this.#now} ps`);
+			if (this.#maxSteps === 0) throw this.#problem("entry-budget-exhausted", "Entry reference step budget is 0");
+			this.#queue.pop();
+			work.status = "running";
+			this.#entries += 1;
+			if (work.target.kind === "event") {
+				this.#ordinaryRound = work.round;
+				this.#ordinaryStarted = true;
+			} else {
+				this.#controlRound = work.round;
+				this.#controlStarted = true;
+			}
+			const remainingSteps = () => this.#maxSteps - this.#steps;
+			const context = Object.freeze({
+				instanceId: work.instance.handle.instanceId,
+				timePs: this.#now,
+				phase: work.target.kind,
+				eventId: work.id,
+				get remainingSteps() {
+					return remainingSteps();
+				},
+				consumeSteps: (count = 1) => this.#boundary(() => {
+					if (this.#current !== work || work.status !== "running") throw this.#problem("executor-contract", "Execution context is only valid during its entry");
+					if (!Number.isSafeInteger(count) || count < 0) throw this.#problem("executor-contract", "Step count must be a non-negative safe integer");
+					if (count > this.#maxSteps - this.#steps) throw this.#problem("entry-budget-exhausted", `Exceeded ${this.#maxSteps} reference steps`);
+					this.#steps += count;
+				})
+			});
+			if (!returnedSynchronously(work.instance.execute.call(work.instance.receiver, work.target, work.args, context))) throw this.#problem("executor-contract", "Executor must return synchronously with no result");
+			if (this.#error !== void 0) throw this.#error;
+			work.status = "completed";
+			if (work.id !== 0) {
+				work.instance.active.delete(work.id);
+				work.instance.ids.release(work.id);
+			}
+		} catch (cause) {
+			if (work.status === "running") work.status = "failed";
+			this.#fault(cause);
+			throw this.#error;
+		} finally {
+			this.#current = void 0;
+			this.#flushDestruction();
+		}
+	}
+	#flushDestruction() {
+		for (const instance of this.#destruction) {
+			for (const work of instance.active.values()) if (work.status === "pending") work.status = "cancelled";
+			instance.active.clear();
+			instance.destroyed = true;
+			this.#instances.delete(instance.handle);
+		}
+		this.#destruction.clear();
+		this.#queue.retain((work) => work.status === "pending" && !work.instance.destroyed);
+	}
+	#problem(code, message, cause) {
+		const current = this.#current;
+		return new SchedulerError(code, message, {
+			timePs: this.#now,
+			steps: current === void 0 ? 0 : this.#steps,
+			entriesAtTime: this.#entries,
+			cause,
+			...current === void 0 ? {} : {
+				instanceId: current.instance.handle.instanceId,
+				targetName: current.target.name,
+				phase: current.target.kind,
+				eventId: current.id
+			}
+		});
+	}
+	#fault(cause) {
+		if (cause === this.#error && this.#error !== void 0) return;
+		const previous = this.#error;
+		const code = previous?.code ?? (cause instanceof SchedulerError ? cause.code : "execution-failed");
+		const message = previous?.message ?? (cause instanceof Error ? cause.message : "Entry execution failed");
+		this.#error = this.#problem(code, message, cause);
+		this.#state = "faulted";
+	}
+	#boundary(action) {
+		if (this.#error !== void 0) throw this.#problem("scheduler-faulted", "Scheduler faulted; rebuild instead of resuming", this.#error);
+		try {
+			return action();
+		} catch (cause) {
+			if (this.#current !== void 0) this.#fault(cause);
+			throw cause;
+		}
+	}
+};
+//#endregion
+//#region src/scheduler/ir-adapter.ts
+var unknownTarget = Object.freeze({
+	name: "unregistered",
+	kind: "event",
+	params: []
+});
+function createIRSchedulerInstance(scheduler, definition) {
+	if (definition === null || typeof definition !== "object") throw new SchedulerError("invalid-instance", "Expected IR instance definition", { timePs: scheduler.now });
+	const { instanceId, module, validation } = definition;
+	const captured = {
+		memories: module.memories,
+		functions: module.functions,
+		domainDeclarations: module.domainDeclarations,
+		instructions: module.instructions
+	};
+	const targets = /* @__PURE__ */ new Map();
+	const entries = /* @__PURE__ */ new Map();
+	for (const fn of captured.functions) {
+		if (fn.category !== "entry" && fn.category !== "lifecycle") continue;
+		const target = Object.freeze({
+			name: fn.name,
+			kind: fn.category === "entry" ? "event" : "control",
+			params: Object.freeze([...fn.params])
+		});
+		targets.set(fn.ref, target);
+		entries.set(fn.name, fn.ref);
+	}
+	let active;
+	const context = () => {
+		if (active === void 0) throw new SchedulerError("executor-contract", "IR kernel bridge requires an active scheduler entry", { timePs: scheduler.now });
+		return active;
+	};
+	const interpreter = createIRInterpreter(captured, {
+		validation,
+		maxSteps: Number.MAX_SAFE_INTEGER,
+		eventHost: {
+			now: () => context().timePs,
+			at: (target, deadline, args) => {
+				context();
+				return instance.at(targets.get(target) ?? unknownTarget, deadline, args);
+			},
+			cancel: (id) => {
+				context();
+				instance.cancel(id);
+			}
+		},
+		stepObserver: { beforeStep: () => context().consumeSteps() }
+	});
+	const instance = scheduler.addInstance({
+		instanceId,
+		targets: [...targets.values()],
+		executor: { execute(target, args, executionContext) {
+			active = executionContext;
+			try {
+				interpreter.execute(entries.get(target.name), args, {
+					instanceId: executionContext.instanceId,
+					virtualTime: executionContext.timePs
+				});
+			} finally {
+				active = void 0;
+			}
+		} }
+	});
+	return Object.freeze({
+		instance,
+		storage: interpreter.storage,
+		at: (target, deadline, args) => instance.at(targets.get(target) ?? unknownTarget, deadline, args),
+		cancel: (id) => instance.cancel(id),
+		enqueueControl: (target, args) => scheduler.enqueueControl(instance, targets.get(target) ?? unknownTarget, args)
+	});
+}
+//#endregion
+//#region src/electrical/validation.ts
+function invalidType(path, value, constraint) {
+	let display;
+	try {
+		display = String(value);
+	} catch {
+		display = "<unprintable>";
+	}
+	throw new TypeError(`${path}: ${display} must ${constraint}`);
+}
+function checkIdentity(value, path) {
+	if (typeof value !== "string" || value.length === 0) invalidType(path, value, "be a nonempty string");
+}
+function checkFinite(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) invalidType(path, value, "be a finite number");
+}
+function checkRange(value, min, max, path) {
+	if (value < min || value > max) throw new RangeError(`${path}: ${value} must be within [${min}, ${max}]`);
+}
+function checkInteger(value, min, max, path) {
+	checkFinite(value, path);
+	if (!Number.isInteger(value)) invalidType(path, value, "be an integer");
+	checkRange(value, min, max, path);
+}
+function checkSupply(value) {
+	checkFinite(value, "supplyVoltage");
+	if (value < 0) throw new RangeError(`supplyVoltage: ${value} must be nonnegative`);
+}
+function checkRecord(value, path, fields) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) invalidType(path, value, "be an object");
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !fields.includes(key)) invalidType(`${path}.${String(key)}`, Reflect.get(value, key), "be a supported field");
+}
+function checkBoolean(value, path) {
+	if (typeof value !== "boolean") invalidType(path, value, "be a boolean");
+}
+function checkChoice(value, choices, path) {
+	if (typeof value !== "string" || !choices.includes(value)) invalidType(path, value, `be one of ${choices.join(", ")}`);
+	return value;
+}
+//#endregion
+//#region src/electrical/network.ts
+function compareText$3(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareSources(left, right) {
+	return compareText$3(left.instanceId, right.instanceId) || compareText$3(left.pinName, right.pinName);
+}
+var PIN_FIELDS = [
+	"instanceId",
+	"pinName",
+	"powerReady",
+	"mode",
+	"outputEnabled",
+	"pull",
+	"digitalIntent",
+	"voltageIntent",
+	"model"
+];
+var MODEL_FIELDS = [
+	"kind",
+	"minVoltage",
+	"maxVoltage",
+	"lowVoltage",
+	"highVoltage"
+];
+var PIN_MODES = [
+	"high-z",
+	"push-pull",
+	"open-drain",
+	"analog"
+];
+var PULLS = [
+	"none",
+	"up",
+	"down"
+];
+var VOLTAGE_MODELS = ["ideal-voltage"];
+function snapshotModel(value, path) {
+	checkRecord(value, path, MODEL_FIELDS);
+	const kind = checkChoice(value.kind, VOLTAGE_MODELS, `${path}.kind`);
+	const minVoltage = value.minVoltage;
+	const maxVoltage = value.maxVoltage;
+	const lowVoltage = value.lowVoltage;
+	const highVoltage = value.highVoltage;
+	checkFinite(minVoltage, `${path}.minVoltage`);
+	checkFinite(maxVoltage, `${path}.maxVoltage`);
+	if (minVoltage > maxVoltage) throw new RangeError(`${path}.minVoltage: ${minVoltage} must be <= maxVoltage ${maxVoltage}`);
+	checkFinite(lowVoltage, `${path}.lowVoltage`);
+	checkFinite(highVoltage, `${path}.highVoltage`);
+	checkRange(lowVoltage, minVoltage, maxVoltage, `${path}.lowVoltage`);
+	checkRange(highVoltage, minVoltage, maxVoltage, `${path}.highVoltage`);
+	if (lowVoltage > highVoltage) throw new RangeError(`${path}.lowVoltage: ${lowVoltage} must be <= highVoltage ${highVoltage}`);
+	return Object.freeze({
+		kind,
+		minVoltage,
+		maxVoltage,
+		lowVoltage,
+		highVoltage
+	});
+}
+/** Internal value capture shared with the topology layer; not exported from the package root. */
+function snapshotElectricalPin(value, path) {
+	checkRecord(value, path, PIN_FIELDS);
+	const instanceId = value.instanceId;
+	const pinName = value.pinName;
+	const powerReady = value.powerReady;
+	const outputEnabled = value.outputEnabled;
+	const mode = checkChoice(value.mode, PIN_MODES, `${path}.mode`);
+	const pull = checkChoice(value.pull, PULLS, `${path}.pull`);
+	checkIdentity(instanceId, `${path}.instanceId`);
+	checkIdentity(pinName, `${path}.pinName`);
+	checkBoolean(powerReady, `${path}.powerReady`);
+	checkBoolean(outputEnabled, `${path}.outputEnabled`);
+	const model = snapshotModel(value.model, `${path}.model`);
+	let digitalIntent;
+	if ("digitalIntent" in value) {
+		const candidate = value.digitalIntent;
+		checkBoolean(candidate, `${path}.digitalIntent`);
+		digitalIntent = candidate;
+	}
+	let voltageIntent;
+	if ("voltageIntent" in value) {
+		const candidate = value.voltageIntent;
+		checkFinite(candidate, `${path}.voltageIntent`);
+		checkRange(candidate, model.minVoltage, model.maxVoltage, `${path}.voltageIntent`);
+		voltageIntent = candidate;
+	}
+	return Object.freeze({
+		instanceId,
+		pinName,
+		powerReady,
+		mode,
+		outputEnabled,
+		pull,
+		...digitalIntent === void 0 ? {} : { digitalIntent },
+		...voltageIntent === void 0 ? {} : { voltageIntent },
+		model
+	});
+}
+function snapshotNetwork(input) {
+	checkRecord(input, "network", ["networkId", "pins"]);
+	checkIdentity(input.networkId, "network.networkId");
+	if (!Array.isArray(input.pins)) invalidType("network.pins", input.pins, "be an array");
+	const sources = /* @__PURE__ */ new Map();
+	const pins = [];
+	for (let index = 0; index < input.pins.length; index += 1) {
+		const path = `network.pins[${index}]`;
+		const pin = snapshotElectricalPin(input.pins[index], path);
+		const names = sources.get(pin.instanceId) ?? /* @__PURE__ */ new Set();
+		if (names.has(pin.pinName)) invalidType(`${path}.pinName`, pin.pinName, `be unique within instance ${pin.instanceId}`);
+		names.add(pin.pinName);
+		sources.set(pin.instanceId, names);
+		pins.push(pin);
+	}
+	return Object.freeze({
+		networkId: input.networkId,
+		pins: Object.freeze(pins.sort(compareSources))
+	});
+}
+function snapshotContributions(contributions) {
+	return Object.freeze(contributions.map((contribution) => Object.freeze({
+		instanceId: contribution.instanceId,
+		pinName: contribution.pinName,
+		kind: contribution.kind,
+		strength: contribution.strength,
+		voltage: contribution.voltage
+	})).sort((left, right) => compareSources(left, right) || compareText$3(left.kind, right.kind)));
+}
+var ElectricalConflictError = class extends Error {
+	name = "ElectricalConflictError";
+	network;
+	contributions;
+	constructor(network, contributions) {
+		super(`Network ${network.networkId}: highest-priority voltage spread must be <= 0.001 V`);
+		this.network = snapshotNetwork(network);
+		this.contributions = snapshotContributions(contributions);
+		Object.freeze(this);
+	}
+};
+function activeVoltage(pin) {
+	if (!pin.outputEnabled) return void 0;
+	switch (pin.mode) {
+		case "high-z": return;
+		case "push-pull": return pin.digitalIntent === void 0 ? void 0 : pin.digitalIntent ? pin.model.highVoltage : pin.model.lowVoltage;
+		case "open-drain": return pin.digitalIntent === false ? pin.model.lowVoltage : void 0;
+		case "analog": return pin.voltageIntent;
+	}
+}
+function resolveElectricalNetwork(input) {
+	const network = snapshotNetwork(input);
+	const contributions = [];
+	for (const pin of network.pins) {
+		if (!pin.powerReady) continue;
+		const source = {
+			instanceId: pin.instanceId,
+			pinName: pin.pinName
+		};
+		const voltage = activeVoltage(pin);
+		if (voltage !== void 0) contributions.push({
+			...source,
+			kind: "drive",
+			strength: "strong",
+			voltage
+		});
+		if (pin.pull !== "none") contributions.push({
+			...source,
+			kind: "pull",
+			strength: "weak",
+			voltage: pin.pull === "up" ? pin.model.highVoltage : pin.model.lowVoltage
+		});
+	}
+	const snapshot = snapshotContributions(contributions);
+	if (snapshot.length === 0) return Object.freeze({
+		state: "floating",
+		digitalFallback: false,
+		contributions: snapshot
+	});
+	const strength = snapshot.some((contribution) => contribution.strength === "strong") ? "strong" : "weak";
+	let min = Infinity;
+	let max = -Infinity;
+	for (const contribution of snapshot) {
+		if (contribution.strength !== strength) continue;
+		min = Math.min(min, contribution.voltage);
+		max = Math.max(max, contribution.voltage);
+	}
+	if (max - min > .001) throw new ElectricalConflictError(network, snapshot);
+	return Object.freeze({
+		state: "driven",
+		voltage: min,
+		strength,
+		contributions: snapshot
+	});
+}
+//#endregion
+//#region src/electrical/floating-input.ts
+function hash32(text) {
+	let hash = 2166136261;
+	for (const byte of new TextEncoder().encode(text)) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+	return hash;
+}
+function xorshift32(state) {
+	state ^= state << 13;
+	state ^= state >>> 17;
+	state ^= state << 5;
+	return state >>> 0;
+}
+function mix32(value) {
+	value = Math.imul(value ^ value >>> 16, 2146121005);
+	value = Math.imul(value ^ value >>> 15, 2221713035);
+	return (value ^ value >>> 16) >>> 0;
+}
+function createFloatingInput(seed, instanceId, pinName) {
+	checkInteger(seed, 0, 4294967295, "seed");
+	checkIdentity(instanceId, "instanceId");
+	checkIdentity(pinName, "pinName");
+	let floatingCount = 0;
+	let episodeSeed = 0;
+	let initialVoltage;
+	let hasEpisode = false;
+	function beginFloating(supplyVoltage) {
+		if (supplyVoltage !== void 0) checkSupply(supplyVoltage);
+		floatingCount = floatingCount + 1 >>> 0;
+		episodeSeed = hash32(JSON.stringify([
+			"mica-floating-v2",
+			seed,
+			instanceId,
+			pinName,
+			floatingCount
+		])) || 1;
+		initialVoltage = supplyVoltage === void 0 ? void 0 : xorshift32(episodeSeed) / 4294967296 * supplyVoltage;
+		hasEpisode = true;
+	}
+	function sample(supplyVoltage, timePs, enabled = true) {
+		checkBoolean(enabled, "enabled");
+		if (!enabled) return Object.freeze({ state: "disabled" });
+		checkSupply(supplyVoltage);
+		checkInteger(timePs, 0, 72e14, "timePs");
+		if (!hasEpisode) throw new Error("Call beginFloating before sampling");
+		if (initialVoltage === void 0) initialVoltage = xorshift32(episodeSeed) / 4294967296 * supplyVoltage;
+		const low = timePs >>> 0;
+		const high = Math.floor(timePs / 4294967296);
+		const noise = (mix32(mix32(episodeSeed ^ low) ^ high) / 4294967296 * 2 - 1) * .1;
+		return Object.freeze({
+			state: "ready",
+			voltage: Math.min(supplyVoltage, Math.max(0, initialVoltage + noise))
+		});
+	}
+	return Object.freeze({
+		beginFloating,
+		sample
+	});
+}
+//#endregion
+//#region src/topology/runtime.ts
+var PIN_KINDS = [
+	"signal",
+	"power",
+	"gnd"
+];
+var CONNECTION_STATES = ["open", "closed"];
+function compareText$2(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function comparePins(left, right) {
+	return compareText$2(left.instanceId, right.instanceId) || compareText$2(left.pinName, right.pinName);
+}
+function pinKey$1(instanceId, pinName) {
+	return JSON.stringify([instanceId, pinName]);
+}
+function connectionKey(instanceId, connectionId) {
+	return JSON.stringify([instanceId, connectionId]);
+}
+/**
+* Escapes the two characters that carry structure in a network ID. Unlike
+* `encodeURIComponent`, this accepts every JavaScript string, including lone surrogates.
+*/
+function escapeNetworkIdentity(value) {
+	return value.replaceAll("%", "%25").replaceAll("/", "%2F");
+}
+function capturePinReference(value, path, pinsByKey) {
+	checkRecord(value, path, ["instanceId", "pinName"]);
+	const instanceId = value.instanceId;
+	const pinName = value.pinName;
+	checkIdentity(instanceId, `${path}.instanceId`);
+	checkIdentity(pinName, `${path}.pinName`);
+	const declared = pinsByKey.get(pinKey$1(instanceId, pinName));
+	if (declared === void 0) throw new RangeError(`${path}: (${JSON.stringify(instanceId)}, ${JSON.stringify(pinName)}) must reference a declared pin`);
+	return declared;
+}
+function captureDefinition(value) {
+	checkRecord(value, "definition", [
+		"pins",
+		"wires",
+		"connections"
+	]);
+	const rawPins = value.pins;
+	if (!Array.isArray(rawPins)) invalidType("definition.pins", rawPins, "be an array");
+	const pins = [];
+	const pinsByKey = /* @__PURE__ */ new Map();
+	const instances = /* @__PURE__ */ new Set();
+	for (let index = 0; index < rawPins.length; index += 1) {
+		const path = `definition.pins[${index}]`;
+		const entry = rawPins[index];
+		checkRecord(entry, path, [
+			"instanceId",
+			"pinName",
+			"kind"
+		]);
+		const instanceId = entry.instanceId;
+		const pinName = entry.pinName;
+		checkIdentity(instanceId, `${path}.instanceId`);
+		checkIdentity(pinName, `${path}.pinName`);
+		const kind = checkChoice(entry.kind, PIN_KINDS, `${path}.kind`);
+		const key = pinKey$1(instanceId, pinName);
+		if (pinsByKey.has(key)) invalidType(`${path}.pinName`, pinName, `be unique for instance ${JSON.stringify(instanceId)}`);
+		const ref = Object.freeze({
+			instanceId,
+			pinName
+		});
+		const pin = Object.freeze({
+			instanceId,
+			pinName,
+			kind,
+			key,
+			ref
+		});
+		pinsByKey.set(key, pin);
+		pins.push(pin);
+		instances.add(instanceId);
+	}
+	const rawWires = value.wires;
+	if (!Array.isArray(rawWires)) invalidType("definition.wires", rawWires, "be an array");
+	const wires = [];
+	const wireIds = /* @__PURE__ */ new Set();
+	for (let index = 0; index < rawWires.length; index += 1) {
+		const path = `definition.wires[${index}]`;
+		const entry = rawWires[index];
+		checkRecord(entry, path, [
+			"wireId",
+			"pins",
+			"globalGnd"
+		]);
+		const wireId = entry.wireId;
+		checkIdentity(wireId, `${path}.wireId`);
+		if (wireIds.has(wireId)) invalidType(`${path}.wireId`, wireId, "be unique among external wires");
+		wireIds.add(wireId);
+		const rawWirePins = entry.pins;
+		if (!Array.isArray(rawWirePins)) invalidType(`${path}.pins`, rawWirePins, "be an array");
+		if (rawWirePins.length === 0) throw new RangeError(`${path}.pins: expected at least one pin`);
+		const wirePins = [];
+		const wirePinKeys = /* @__PURE__ */ new Set();
+		for (let pinIndex = 0; pinIndex < rawWirePins.length; pinIndex += 1) {
+			const pin = capturePinReference(rawWirePins[pinIndex], `${path}.pins[${pinIndex}]`, pinsByKey);
+			if (wirePinKeys.has(pin.key)) invalidType(`${path}.pins[${pinIndex}].pinName`, pin.pinName, `be unique within wire ${JSON.stringify(wireId)}`);
+			wirePinKeys.add(pin.key);
+			wirePins.push(pin);
+		}
+		let globalGnd = false;
+		if ("globalGnd" in entry) {
+			checkBoolean(entry.globalGnd, `${path}.globalGnd`);
+			globalGnd = entry.globalGnd;
+		}
+		wires.push(Object.freeze({
+			wireId,
+			pins: Object.freeze(wirePins),
+			globalGnd
+		}));
+	}
+	const rawConnections = value.connections;
+	if (!Array.isArray(rawConnections)) invalidType("definition.connections", rawConnections, "be an array");
+	const connections = [];
+	const connectionsByKey = /* @__PURE__ */ new Map();
+	for (let index = 0; index < rawConnections.length; index += 1) {
+		const path = `definition.connections[${index}]`;
+		const entry = rawConnections[index];
+		checkRecord(entry, path, [
+			"instanceId",
+			"connectionId",
+			"pins",
+			"initial"
+		]);
+		const instanceId = entry.instanceId;
+		const connectionId = entry.connectionId;
+		checkIdentity(instanceId, `${path}.instanceId`);
+		checkIdentity(connectionId, `${path}.connectionId`);
+		if (!instances.has(instanceId)) throw new RangeError(`${path}.instanceId: ${JSON.stringify(instanceId)} must reference a declared instance`);
+		const key = connectionKey(instanceId, connectionId);
+		if (connectionsByKey.has(key)) invalidType(`${path}.connectionId`, connectionId, `be unique for instance ${JSON.stringify(instanceId)}`);
+		const rawEndpoints = entry.pins;
+		if (!Array.isArray(rawEndpoints) || rawEndpoints.length !== 2) invalidType(`${path}.pins`, rawEndpoints, "be an array of exactly two pin names");
+		const first = rawEndpoints[0];
+		const second = rawEndpoints[1];
+		checkIdentity(first, `${path}.pins[0]`);
+		checkIdentity(second, `${path}.pins[1]`);
+		if (first === second) invalidType(`${path}.pins[1]`, second, `differ from ${JSON.stringify(first)}`);
+		const pinA = pinsByKey.get(pinKey$1(instanceId, first));
+		if (pinA === void 0) throw new RangeError(`${path}.pins[0]: ${JSON.stringify(first)} must reference a pin declared by instance ${JSON.stringify(instanceId)}`);
+		const pinB = pinsByKey.get(pinKey$1(instanceId, second));
+		if (pinB === void 0) throw new RangeError(`${path}.pins[1]: ${JSON.stringify(second)} must reference a pin declared by instance ${JSON.stringify(instanceId)}`);
+		let initial = "open";
+		if ("initial" in entry) initial = checkChoice(entry.initial, CONNECTION_STATES, `${path}.initial`);
+		const connection = Object.freeze({
+			instanceId,
+			connectionId,
+			pinA,
+			pinB,
+			initial,
+			key
+		});
+		connectionsByKey.set(key, connection);
+		connections.push(connection);
+	}
+	connections.sort((left, right) => compareText$2(left.instanceId, right.instanceId) || compareText$2(left.connectionId, right.connectionId));
+	return Object.freeze({
+		pins: Object.freeze(pins),
+		pinsByKey,
+		instances,
+		wires: Object.freeze(wires),
+		connections: Object.freeze(connections),
+		connectionsByKey
+	});
+}
 /**
-* Placeholder export so the build and test pipeline has something to verify.
-* Replace with the virtual time and event scheduler API.
+* Internal single-read snapshot shared with the power layer; not exported from the package root.
+* Passing this frozen value to `createTopologyRuntime` cannot observe later input mutation.
 */
+function captureTopologyDefinition(value) {
+	const captured = captureDefinition(value);
+	return Object.freeze({
+		pins: Object.freeze(captured.pins.map((pin) => Object.freeze({
+			instanceId: pin.instanceId,
+			pinName: pin.pinName,
+			kind: pin.kind
+		}))),
+		wires: Object.freeze(captured.wires.map((wire) => Object.freeze({
+			wireId: wire.wireId,
+			pins: Object.freeze(wire.pins.map((pin) => pin.ref)),
+			globalGnd: wire.globalGnd
+		}))),
+		connections: Object.freeze(captured.connections.map((connection) => Object.freeze({
+			instanceId: connection.instanceId,
+			connectionId: connection.connectionId,
+			pins: Object.freeze([connection.pinA.pinName, connection.pinB.pinName]),
+			initial: connection.initial
+		})))
+	});
+}
+function capturePatch(value, definition) {
+	checkRecord(value, "patch", ["instanceId", "connections"]);
+	const instanceId = value.instanceId;
+	checkIdentity(instanceId, "patch.instanceId");
+	if (!definition.instances.has(instanceId)) throw new RangeError(`patch.instanceId: ${JSON.stringify(instanceId)} must reference a declared instance`);
+	const rawConnections = value.connections;
+	if (!Array.isArray(rawConnections)) invalidType("patch.connections", rawConnections, "be an array");
+	if (rawConnections.length === 0) throw new RangeError("patch.connections: expected at least one connection update");
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (let index = 0; index < rawConnections.length; index += 1) {
+		const path = `patch.connections[${index}]`;
+		const entry = rawConnections[index];
+		checkRecord(entry, path, ["connectionId", "state"]);
+		const connectionId = entry.connectionId;
+		checkIdentity(connectionId, `${path}.connectionId`);
+		const state = checkChoice(entry.state, CONNECTION_STATES, `${path}.state`);
+		const key = connectionKey(instanceId, connectionId);
+		if (!definition.connectionsByKey.has(key)) throw new RangeError(`${path}.connectionId: ${JSON.stringify(connectionId)} must reference a connection declared by instance ${JSON.stringify(instanceId)}`);
+		if (seen.has(key)) invalidType(`${path}.connectionId`, connectionId, `be unique within patch for instance ${JSON.stringify(instanceId)}`);
+		seen.add(key);
+		entries.push(Object.freeze({
+			key,
+			state
+		}));
+	}
+	return Object.freeze({
+		instanceId,
+		entries: Object.freeze(entries)
+	});
+}
+function capturePinState(value, path, definition) {
+	const state = snapshotElectricalPin(value, path);
+	const key = pinKey$1(state.instanceId, state.pinName);
+	if (!definition.pinsByKey.has(key)) throw new RangeError(`${path}: (${JSON.stringify(state.instanceId)}, ${JSON.stringify(state.pinName)}) must reference a declared pin`);
+	return Object.freeze({
+		key,
+		state
+	});
+}
+function captureFloating(options) {
+	if (!("floating" in options)) return void 0;
+	const value = options.floating;
+	checkRecord(value, "options.floating", [
+		"seed",
+		"supplyVoltage",
+		"samplingEnabled"
+	]);
+	const seed = value.seed;
+	checkInteger(seed, 0, 4294967295, "options.floating.seed");
+	const supplyVoltage = value.supplyVoltage;
+	if (typeof supplyVoltage !== "function") invalidType("options.floating.supplyVoltage", supplyVoltage, "be a function");
+	let samplingEnabled = () => true;
+	if ("samplingEnabled" in value) {
+		const candidate = value.samplingEnabled;
+		if (typeof candidate !== "function") invalidType("options.floating.samplingEnabled", candidate, "be a function");
+		samplingEnabled = candidate;
+	}
+	return Object.freeze({
+		seed,
+		supplyVoltage,
+		samplingEnabled
+	});
+}
+function initialConnectionStates(definition) {
+	const states = /* @__PURE__ */ new Map();
+	for (const connection of definition.connections) states.set(connection.key, connection.initial);
+	return states;
+}
+function buildComponents(definition, connectionStates) {
+	const orderedPins = [...definition.pins].sort(comparePins);
+	const indices = /* @__PURE__ */ new Map();
+	orderedPins.forEach((pin, index) => indices.set(pin.key, index));
+	const parent = orderedPins.map((_, index) => index);
+	const find = (node) => {
+		let root = node;
+		while (parent[root] !== root) {
+			const next = parent[root];
+			parent[root] = parent[next];
+			root = next;
+		}
+		return root;
+	};
+	const union = (left, right) => {
+		const leftRoot = find(left);
+		const rightRoot = find(right);
+		if (leftRoot !== rightRoot) parent[rightRoot] = leftRoot;
+	};
+	for (const wire of definition.wires) {
+		const first = wire.pins[0];
+		if (first === void 0) continue;
+		const firstIndex = indices.get(first.key);
+		if (firstIndex === void 0) continue;
+		for (let index = 1; index < wire.pins.length; index += 1) {
+			const pin = wire.pins[index];
+			const pinIndex = pin === void 0 ? void 0 : indices.get(pin.key);
+			if (pinIndex !== void 0) union(firstIndex, pinIndex);
+		}
+	}
+	for (const connection of definition.connections) {
+		if (connectionStates.get(connection.key) !== "closed") continue;
+		const left = indices.get(connection.pinA.key);
+		const right = indices.get(connection.pinB.key);
+		if (left !== void 0 && right !== void 0) union(left, right);
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const pin of orderedPins) {
+		const index = indices.get(pin.key);
+		if (index === void 0) continue;
+		const root = find(index);
+		const group = groups.get(root);
+		if (group === void 0) groups.set(root, [pin]);
+		else group.push(pin);
+	}
+	const groundedRoots = /* @__PURE__ */ new Set();
+	for (const wire of definition.wires) {
+		if (!wire.globalGnd) continue;
+		const first = wire.pins[0];
+		const firstIndex = first === void 0 ? void 0 : indices.get(first.key);
+		if (firstIndex !== void 0) groundedRoots.add(find(firstIndex));
+	}
+	const components = [];
+	for (const [root, pins] of groups) {
+		const canonical = pins[0];
+		if (canonical === void 0) continue;
+		components.push(Object.freeze({
+			networkId: `net:${escapeNetworkIdentity(canonical.instanceId)}/${escapeNetworkIdentity(canonical.pinName)}`,
+			pins: Object.freeze(pins),
+			groundReady: pins.some((pin) => pin.kind === "gnd") && groundedRoots.has(root)
+		}));
+	}
+	components.sort((left, right) => compareText$2(left.networkId, right.networkId));
+	return Object.freeze(components);
+}
+function indexComponents(components) {
+	const byPin = /* @__PURE__ */ new Map();
+	for (const component of components) for (const pin of component.pins) byPin.set(pin.key, component);
+	return byPin;
+}
+function resolveComponent(component, pinStates) {
+	const pins = component.pins.map((pin) => {
+		const state = pinStates.get(pin.key);
+		if (state === void 0) throw new Error(`Invariant: missing committed pin state for (${pin.instanceId}, ${pin.pinName})`);
+		return state;
+	});
+	return resolveElectricalNetwork({
+		networkId: component.networkId,
+		pins
+	});
+}
+function readySupply(options, pin) {
+	if (!options.samplingEnabled(pin)) return void 0;
+	return options.supplyVoltage(pin);
+}
+var TopologyRuntimeImpl = class {
+	#scheduler;
+	#definition;
+	#floatingOptions;
+	#target;
+	#instance;
+	#connectionStates;
+	#pinStates;
+	#components;
+	#componentByPin;
+	#results;
+	#floating = /* @__PURE__ */ new Map();
+	#commands = [];
+	#destroyed = false;
+	constructor(scheduler, definitionInput, optionsInput) {
+		const definition = captureDefinition(definitionInput);
+		checkRecord(optionsInput, "options", [
+			"instanceId",
+			"pinStates",
+			"floating"
+		]);
+		const instanceId = optionsInput.instanceId;
+		checkIdentity(instanceId, "options.instanceId");
+		const rawPinStates = optionsInput.pinStates;
+		if (!Array.isArray(rawPinStates)) invalidType("options.pinStates", rawPinStates, "be an array");
+		const pinStates = /* @__PURE__ */ new Map();
+		for (let index = 0; index < rawPinStates.length; index += 1) {
+			const path = `options.pinStates[${index}]`;
+			const captured = capturePinState(rawPinStates[index], path, definition);
+			if (pinStates.has(captured.key)) invalidType(`${path}.pinName`, captured.state.pinName, "be unique among initial pin states");
+			pinStates.set(captured.key, captured.state);
+		}
+		for (const pin of definition.pins) if (!pinStates.has(pin.key)) throw new RangeError(`options.pinStates: missing state for (${JSON.stringify(pin.instanceId)}, ${JSON.stringify(pin.pinName)})`);
+		const floatingOptions = captureFloating(optionsInput);
+		const connectionStates = initialConnectionStates(definition);
+		const components = buildComponents(definition, connectionStates);
+		const results = /* @__PURE__ */ new Map();
+		for (const component of components) results.set(component.networkId, resolveComponent(component, pinStates));
+		this.#scheduler = scheduler;
+		this.#definition = definition;
+		this.#floatingOptions = floatingOptions;
+		this.#connectionStates = connectionStates;
+		this.#pinStates = pinStates;
+		this.#components = components;
+		this.#componentByPin = indexComponents(components);
+		this.#results = results;
+		this.#updateFloating(components, results);
+		this.#target = Object.freeze({
+			name: "topology.commit",
+			kind: "control",
+			params: Object.freeze([])
+		});
+		this.#instance = scheduler.addInstance({
+			instanceId,
+			targets: [this.#target],
+			executor: { execute: () => this.#runNextCommand() }
+		});
+		Object.freeze(this);
+	}
+	get instance() {
+		return this.#instance;
+	}
+	submit(patch) {
+		this.#enqueue({
+			kind: "patch",
+			patch: capturePatch(patch, this.#definition)
+		});
+	}
+	updatePinStates(states) {
+		if (!Array.isArray(states)) invalidType("states", states, "be an array");
+		if (states.length === 0) return;
+		const updates = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (let index = 0; index < states.length; index += 1) {
+			const captured = capturePinState(states[index], `states[${index}]`, this.#definition);
+			if (seen.has(captured.key)) invalidType(`states[${index}].pinName`, captured.state.pinName, "be unique within one pin-state update");
+			seen.add(captured.key);
+			updates.push(captured);
+		}
+		this.#enqueue({
+			kind: "pins",
+			updates: Object.freeze(updates)
+		});
+	}
+	refresh(pins) {
+		if (pins === void 0) {
+			this.#enqueue({
+				kind: "refresh",
+				pins: void 0
+			});
+			return;
+		}
+		if (!Array.isArray(pins)) invalidType("pins", pins, "be an array");
+		if (pins.length === 0) return;
+		const captured = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (let index = 0; index < pins.length; index += 1) {
+			const pin = capturePinReference(pins[index], `pins[${index}]`, this.#definition.pinsByKey);
+			if (seen.has(pin.key)) continue;
+			seen.add(pin.key);
+			captured.push(pin);
+		}
+		this.#enqueue({
+			kind: "refresh",
+			pins: Object.freeze(captured)
+		});
+	}
+	connectionState(instanceId, connectionId) {
+		checkIdentity(instanceId, "instanceId");
+		checkIdentity(connectionId, "connectionId");
+		const state = this.#connectionStates.get(connectionKey(instanceId, connectionId));
+		if (state === void 0) throw new RangeError(`(${JSON.stringify(instanceId)}, ${JSON.stringify(connectionId)}) must reference a declared connection`);
+		return state;
+	}
+	networks() {
+		return Object.freeze(this.#components.map((component) => this.#snapshot(component)));
+	}
+	networkOf(pin) {
+		const captured = capturePinReference(pin, "pin", this.#definition.pinsByKey);
+		const component = this.#componentByPin.get(captured.key);
+		return component === void 0 ? void 0 : this.#snapshot(component);
+	}
+	floatingInput(pin) {
+		const captured = capturePinReference(pin, "pin", this.#definition.pinsByKey);
+		if (this.#floatingOptions === void 0) return void 0;
+		return this.#track(captured).input;
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#commands.length = 0;
+		this.#scheduler.destroyInstance(this.#instance);
+	}
+	#enqueue(command) {
+		this.#commands.push(command);
+		try {
+			this.#scheduler.enqueueControl(this.#instance, this.#target, []);
+		} catch (cause) {
+			this.#commands.pop();
+			throw cause;
+		}
+	}
+	#runNextCommand() {
+		const command = this.#commands.shift();
+		if (command === void 0) throw new Error("Topology control entry has no pending command");
+		switch (command.kind) {
+			case "patch":
+				this.#applyPatch(command.patch);
+				return;
+			case "pins":
+				this.#applyPinStates(command.updates);
+				return;
+			case "refresh":
+				this.#applyRefresh(command.pins);
+				return;
+		}
+	}
+	#applyPatch(patch) {
+		let nextStates;
+		const changed = /* @__PURE__ */ new Set();
+		for (const entry of patch.entries) {
+			const current = this.#connectionStates.get(entry.key);
+			if (current === void 0) throw new Error("Invariant: patch references an unknown connection state");
+			if (current === entry.state) continue;
+			if (nextStates === void 0) nextStates = new Map(this.#connectionStates);
+			nextStates.set(entry.key, entry.state);
+			const connection = this.#definition.connectionsByKey.get(entry.key);
+			if (connection === void 0) throw new Error("Invariant: patch references an unknown connection declaration");
+			changed.add(connection.pinA.key);
+			changed.add(connection.pinB.key);
+		}
+		if (nextStates === void 0) return;
+		const nextComponents = buildComponents(this.#definition, nextStates);
+		const nextByPin = indexComponents(nextComponents);
+		const affected = /* @__PURE__ */ new Set();
+		for (const key of changed) {
+			const before = this.#componentByPin.get(key);
+			const after = nextByPin.get(key);
+			if (before !== void 0) affected.add(before.networkId);
+			if (after !== void 0) affected.add(after.networkId);
+		}
+		const targets = nextComponents.filter((component) => affected.has(component.networkId));
+		let nextResults;
+		try {
+			nextResults = this.#resolve(targets, this.#pinStates);
+		} catch (cause) {
+			this.#connectionStates = nextStates;
+			this.#components = nextComponents;
+			this.#componentByPin = nextByPin;
+			this.#pruneResults(nextComponents);
+			this.#clearResults(targets);
+			throw cause;
+		}
+		this.#connectionStates = nextStates;
+		this.#components = nextComponents;
+		this.#componentByPin = nextByPin;
+		this.#pruneResults(nextComponents);
+		for (const [networkId, result] of nextResults) this.#results.set(networkId, result);
+		this.#updateFloating(targets, nextResults);
+	}
+	#applyPinStates(updates) {
+		const nextStates = new Map(this.#pinStates);
+		const updated = /* @__PURE__ */ new Set();
+		for (const update of updates) {
+			nextStates.set(update.key, update.state);
+			updated.add(update.key);
+		}
+		const targets = this.#components.filter((component) => component.pins.some((pin) => updated.has(pin.key)));
+		let nextResults;
+		try {
+			nextResults = this.#resolve(targets, nextStates);
+		} catch (cause) {
+			this.#pinStates = nextStates;
+			this.#clearResults(targets);
+			throw cause;
+		}
+		this.#pinStates = nextStates;
+		for (const [networkId, result] of nextResults) this.#results.set(networkId, result);
+		this.#updateFloating(targets, nextResults);
+	}
+	#applyRefresh(pins) {
+		let targets;
+		if (pins === void 0) targets = this.#components;
+		else {
+			const keys = new Set(pins.map((pin) => pin.key));
+			targets = this.#components.filter((component) => component.pins.some((pin) => keys.has(pin.key)));
+		}
+		let nextResults;
+		try {
+			nextResults = this.#resolve(targets, this.#pinStates);
+		} catch (cause) {
+			this.#clearResults(targets);
+			throw cause;
+		}
+		for (const [networkId, result] of nextResults) this.#results.set(networkId, result);
+		this.#updateFloating(targets, nextResults);
+	}
+	#resolve(targets, pinStates) {
+		const results = /* @__PURE__ */ new Map();
+		for (const component of targets) results.set(component.networkId, resolveComponent(component, pinStates));
+		return results;
+	}
+	#clearResults(targets) {
+		for (const component of targets) this.#results.delete(component.networkId);
+	}
+	#pruneResults(components) {
+		const ids = new Set(components.map((component) => component.networkId));
+		for (const networkId of [...this.#results.keys()]) if (!ids.has(networkId)) this.#results.delete(networkId);
+	}
+	#updateFloating(targets, results) {
+		const options = this.#floatingOptions;
+		if (options === void 0) return;
+		const now = this.#scheduler.now;
+		for (const component of targets) {
+			const result = results.get(component.networkId);
+			if (result === void 0) continue;
+			const floating = result.state === "floating";
+			for (const pin of component.pins) {
+				const track = this.#track(pin);
+				if (!floating) {
+					track.physical = "driven";
+					track.pendingInitialization = false;
+					continue;
+				}
+				if (track.physical !== "floating") {
+					const supply = readySupply(options, pin.ref);
+					if (supply === void 0) {
+						track.input.beginFloating();
+						track.pendingInitialization = true;
+					} else {
+						track.input.beginFloating(supply);
+						track.pendingInitialization = false;
+					}
+					track.physical = "floating";
+				} else if (track.pendingInitialization) {
+					const supply = readySupply(options, pin.ref);
+					if (supply !== void 0) {
+						track.input.sample(supply, now, true);
+						track.pendingInitialization = false;
+					}
+				}
+			}
+		}
+	}
+	#track(pin) {
+		let track = this.#floating.get(pin.key);
+		if (track === void 0) {
+			const options = this.#floatingOptions;
+			if (options === void 0) throw new Error("Invariant: floating track requested without floating options");
+			track = {
+				input: createFloatingInput(options.seed, pin.instanceId, pin.pinName),
+				physical: "unknown",
+				pendingInitialization: false
+			};
+			this.#floating.set(pin.key, track);
+		}
+		return track;
+	}
+	#snapshot(component) {
+		return Object.freeze({
+			networkId: component.networkId,
+			pins: Object.freeze(component.pins.map((pin) => pin.ref)),
+			groundReady: component.groundReady,
+			result: this.#results.get(component.networkId)
+		});
+	}
+};
+function createTopologyRuntime(scheduler, definition, options) {
+	return new TopologyRuntimeImpl(scheduler, definition, options);
+}
+//#endregion
+//#region src/power/validation.ts
+var INPUT_MODES = ["two-state", "three-state"];
+var DOMAIN_FIELDS = [
+	"supply",
+	"ground",
+	"voltage",
+	"dependsOn"
+];
+var VOLTAGE_FIELDS = ["turnOn", "turnOff"];
+var BINDING_FIELDS = ["powerDomain", "levels"];
+var LEVEL_FIELDS = ["low", "high"];
+var DEVICE_FIELDS = [
+	"instanceId",
+	"powerDomains",
+	"pins"
+];
+var DEFINITION_FIELDS = ["topology", "devices"];
+var OPTION_FIELDS = [
+	"instanceId",
+	"topologyInstanceId",
+	"pinStates",
+	"floating",
+	"inputMode",
+	"maxPropagationRounds",
+	"observer"
+];
+var FLOATING_FIELDS = ["seed"];
+var DEFAULT_MAX_PROPAGATION_ROUNDS = 1e4;
+function compareText$1(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareRefs(left, right) {
+	return compareText$1(left.instanceId, right.instanceId) || compareText$1(left.pinName, right.pinName);
+}
+function pinKey(instanceId, pinName) {
+	return JSON.stringify([instanceId, pinName]);
+}
+function domainKey(instanceId, domainId) {
+	return JSON.stringify([instanceId, domainId]);
+}
+function captureEntries(value, path) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) invalidType(path, value, "be an object");
+	const entries = [];
+	for (const key of Reflect.ownKeys(value)) {
+		if (typeof key !== "string") invalidType(`${path}.${String(key)}`, Reflect.get(value, key), "use a string key");
+		if (key.length === 0) throw new RangeError(`${path}: map keys must be nonempty strings`);
+		entries.push([key, Reflect.get(value, key)]);
+	}
+	entries.sort(([left], [right]) => compareText$1(left, right));
+	return Object.freeze(entries);
+}
+function captureLevels(value, path) {
+	checkRecord(value, path, LEVEL_FIELDS);
+	const low = value.low;
+	const high = value.high;
+	checkFinite(low, `${path}.low`);
+	checkFinite(high, `${path}.high`);
+	if (low < 0 || low > 1) throw new RangeError(`${path}.low: ${low} must be within [0, 1]`);
+	if (high < 0 || high > 1) throw new RangeError(`${path}.high: ${high} must be within [0, 1]`);
+	if (low >= high) throw new RangeError(`${path}.low: ${low} must be less than high ${high}`);
+	return Object.freeze({
+		low,
+		high
+	});
+}
+function captureVoltage(value, path) {
+	checkRecord(value, path, VOLTAGE_FIELDS);
+	const turnOn = value.turnOn;
+	const turnOff = value.turnOff;
+	checkFinite(turnOn, `${path}.turnOn`);
+	checkFinite(turnOff, `${path}.turnOff`);
+	if (turnOff < 0) throw new RangeError(`${path}.turnOff: ${turnOff} must be nonnegative`);
+	if (turnOn <= turnOff) throw new RangeError(`${path}.turnOn: ${turnOn} must be greater than turnOff ${turnOff}`);
+	return Object.freeze({
+		turnOn,
+		turnOff
+	});
+}
+function resolveDeclaredPin(value, path, instanceId, declared, kind) {
+	checkIdentity(value, path);
+	const key = pinKey(instanceId, value);
+	const pin = declared.get(key);
+	if (pin === void 0) throw new RangeError(`${path}: ${JSON.stringify(value)} must reference a pin declared by instance ${JSON.stringify(instanceId)}`);
+	if (pin.kind !== kind) throw new RangeError(`${path}: pin ${JSON.stringify(value)} must have kind ${JSON.stringify(kind)}`);
+	return pin.ref;
+}
+function captureDomains(deviceValue, path, instanceId, declared) {
+	const rawDomains = deviceValue.powerDomains;
+	const entries = captureEntries(rawDomains, `${path}.powerDomains`);
+	const interim = /* @__PURE__ */ new Map();
+	for (const [domainId, declaration] of entries) {
+		const domainPath = `${path}.powerDomains.${domainId}`;
+		checkRecord(declaration, domainPath, DOMAIN_FIELDS);
+		const supply = resolveDeclaredPin(declaration.supply, `${domainPath}.supply`, instanceId, declared, "power");
+		const ground = resolveDeclaredPin(declaration.ground, `${domainPath}.ground`, instanceId, declared, "gnd");
+		const { turnOn, turnOff } = captureVoltage(declaration.voltage, `${domainPath}.voltage`);
+		let dependsOnIds = Object.freeze([]);
+		if ("dependsOn" in declaration) {
+			const rawDependsOn = declaration.dependsOn;
+			if (!Array.isArray(rawDependsOn)) invalidType(`${domainPath}.dependsOn`, rawDependsOn, "be an array");
+			const seen = /* @__PURE__ */ new Set();
+			for (let index = 0; index < rawDependsOn.length; index += 1) {
+				const dependency = rawDependsOn[index];
+				checkIdentity(dependency, `${domainPath}.dependsOn[${index}]`);
+				if (dependency === domainId) throw new RangeError(`${domainPath}.dependsOn: domain must not depend on itself`);
+				if (seen.has(dependency)) invalidType(`${domainPath}.dependsOn[${index}]`, dependency, "be unique within the dependency set");
+				seen.add(dependency);
+			}
+			dependsOnIds = Object.freeze([...seen].sort(compareText$1));
+		}
+		interim.set(domainId, Object.freeze({
+			instanceId,
+			domainId,
+			supply,
+			ground,
+			turnOn,
+			turnOff,
+			dependsOnIds
+		}));
+	}
+	for (const [domainId, domain] of interim) for (const dependency of domain.dependsOnIds) if (!interim.has(dependency)) throw new RangeError(`${path}.powerDomains.${domainId}.dependsOn: ${JSON.stringify(dependency)} must reference a domain declared by the same device`);
+	const indegree = /* @__PURE__ */ new Map();
+	const dependents = /* @__PURE__ */ new Map();
+	for (const [domainId, domain] of interim) {
+		indegree.set(domainId, domain.dependsOnIds.length);
+		for (const dependency of domain.dependsOnIds) {
+			const list = dependents.get(dependency);
+			if (list === void 0) dependents.set(dependency, [domainId]);
+			else list.push(domainId);
+		}
+	}
+	const ready = [...indegree.keys()].filter((domainId) => indegree.get(domainId) === 0);
+	const order = [];
+	while (ready.length > 0) {
+		ready.sort(compareText$1);
+		const domainId = ready.shift();
+		order.push(domainId);
+		for (const dependent of dependents.get(domainId) ?? []) {
+			const next = indegree.get(dependent) - 1;
+			indegree.set(dependent, next);
+			if (next === 0) ready.push(dependent);
+		}
+	}
+	if (order.length !== interim.size) {
+		const remaining = [...interim.keys()].filter((domainId) => !order.includes(domainId));
+		throw new RangeError(`${path}.powerDomains.dependsOn: dependency graph must be acyclic; cycle involves ${remaining.sort(compareText$1).map((domainId) => JSON.stringify(domainId)).join(", ")}`);
+	}
+	const domainsById = /* @__PURE__ */ new Map();
+	const domains = [];
+	for (const domainId of order) {
+		const domain = interim.get(domainId);
+		const dependsOn = Object.freeze(domain.dependsOnIds.map((dependency) => domainsById.get(dependency)));
+		let depth = 0;
+		for (const dependency of dependsOn) depth = Math.max(depth, dependency.depth + 1);
+		const captured = Object.freeze({
+			instanceId: domain.instanceId,
+			domainId: domain.domainId,
+			key: domainKey(domain.instanceId, domain.domainId),
+			supply: domain.supply,
+			ground: domain.ground,
+			turnOn: domain.turnOn,
+			turnOff: domain.turnOff,
+			dependsOn,
+			depth
+		});
+		domainsById.set(domainId, captured);
+		domains.push(captured);
+	}
+	return Object.freeze(domains);
+}
+function capturePinBindings(deviceValue, path, instanceId, domainsById, declared) {
+	const result = /* @__PURE__ */ new Map();
+	if (!("pins" in deviceValue)) return result;
+	const entries = captureEntries(deviceValue.pins, `${path}.pins`);
+	for (const [pinName, binding] of entries) {
+		const bindingPath = `${path}.pins.${pinName}`;
+		checkRecord(binding, bindingPath, BINDING_FIELDS);
+		const key = pinKey(instanceId, pinName);
+		const pin = declared.get(key);
+		if (pin === void 0) throw new RangeError(`${bindingPath}: ${JSON.stringify(pinName)} must reference a pin declared by instance ${JSON.stringify(instanceId)}`);
+		if (pin.kind !== "signal") throw new RangeError(`${bindingPath}: powerDomain is only supported on kind 'signal' pins`);
+		let domain;
+		if ("powerDomain" in binding) {
+			const domainId = binding.powerDomain;
+			checkIdentity(domainId, `${bindingPath}.powerDomain`);
+			domain = domainsById.get(domainId);
+			if (domain === void 0) throw new RangeError(`${bindingPath}.powerDomain: ${JSON.stringify(domainId)} must reference a domain declared by the same device`);
+		}
+		let levels;
+		if ("levels" in binding) {
+			if (domain === void 0) throw new RangeError(`${bindingPath}.levels requires a powerDomain binding`);
+			levels = captureLevels(binding.levels, `${bindingPath}.levels`);
+		}
+		if (domain !== void 0) result.set(key, Object.freeze({
+			domain,
+			levels
+		}));
+	}
+	return result;
+}
+function capturePowerDefinition(value) {
+	checkRecord(value, "definition", DEFINITION_FIELDS);
+	const topology = captureTopologyDefinition(value.topology);
+	const declared = /* @__PURE__ */ new Map();
+	const instances = /* @__PURE__ */ new Set();
+	for (const pin of topology.pins) {
+		const ref = Object.freeze({
+			instanceId: pin.instanceId,
+			pinName: pin.pinName
+		});
+		declared.set(pinKey(pin.instanceId, pin.pinName), Object.freeze({
+			ref,
+			kind: pin.kind
+		}));
+		instances.add(pin.instanceId);
+	}
+	const rawDevices = value.devices;
+	if (!Array.isArray(rawDevices)) invalidType("definition.devices", rawDevices, "be an array");
+	const devices = [];
+	const devicesById = /* @__PURE__ */ new Map();
+	const bindingsByKey = /* @__PURE__ */ new Map();
+	for (let index = 0; index < rawDevices.length; index += 1) {
+		const path = `definition.devices[${index}]`;
+		const deviceValue = rawDevices[index];
+		checkRecord(deviceValue, path, DEVICE_FIELDS);
+		const instanceId = deviceValue.instanceId;
+		checkIdentity(instanceId, `${path}.instanceId`);
+		if (devicesById.has(instanceId)) invalidType(`${path}.instanceId`, instanceId, "be unique among power device definitions");
+		if (!instances.has(instanceId)) throw new RangeError(`${path}.instanceId: ${JSON.stringify(instanceId)} must reference a declared topology instance`);
+		const domains = captureDomains(deviceValue, path, instanceId, declared);
+		const domainsById = new Map(domains.map((domain) => [domain.domainId, domain]));
+		const device = Object.freeze({
+			instanceId,
+			domains,
+			domainsById
+		});
+		devices.push(device);
+		devicesById.set(instanceId, device);
+		const bindings = capturePinBindings(deviceValue, path, instanceId, domainsById, declared);
+		for (const [key, binding] of bindings) bindingsByKey.set(key, binding);
+	}
+	devices.sort((left, right) => compareText$1(left.instanceId, right.instanceId));
+	const domainsInOrder = [];
+	for (const device of devices) domainsInOrder.push(...device.domains);
+	const domainsByKey = new Map(domainsInOrder.map((domain) => [domain.key, domain]));
+	const pins = [];
+	for (const [key, pin] of declared) {
+		const binding = bindingsByKey.get(key);
+		pins.push(Object.freeze({
+			ref: pin.ref,
+			key,
+			kind: pin.kind,
+			domain: binding?.domain,
+			levels: binding?.levels
+		}));
+	}
+	pins.sort((left, right) => compareRefs(left.ref, right.ref));
+	const pinsByKey = new Map(pins.map((pin) => [pin.key, pin]));
+	return Object.freeze({
+		topology,
+		devices: Object.freeze(devices),
+		devicesById,
+		domainsInOrder: Object.freeze(domainsInOrder),
+		domainsByKey,
+		pins: Object.freeze(pins),
+		pinsByKey,
+		instances
+	});
+}
+function captureObserver(value, path) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") invalidType(path, value, "be an object");
+	const notify = Reflect.get(value, "onPowerDomainChange");
+	if (typeof notify !== "function") invalidType(`${path}.onPowerDomainChange`, notify, "be a function");
+	return Object.freeze({
+		receiver: value,
+		notify
+	});
+}
+function captureLimit(value, fallback, path) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "number" || !Number.isFinite(value)) invalidType(path, value, "be a finite number");
+	if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${path}: ${value} must be a non-negative safe integer`);
+	return value;
+}
+function capturePowerOptions(value, definition) {
+	checkRecord(value, "options", OPTION_FIELDS);
+	const instanceId = value.instanceId;
+	checkIdentity(instanceId, "options.instanceId");
+	let topologyInstanceId = `${instanceId}:topology`;
+	if ("topologyInstanceId" in value) {
+		const candidate = value.topologyInstanceId;
+		checkIdentity(candidate, "options.topologyInstanceId");
+		topologyInstanceId = candidate;
+	}
+	if (topologyInstanceId === instanceId) throw new RangeError("options.topologyInstanceId must differ from options.instanceId");
+	const rawStates = value.pinStates;
+	if (!Array.isArray(rawStates)) invalidType("options.pinStates", rawStates, "be an array");
+	const intents = /* @__PURE__ */ new Map();
+	for (let index = 0; index < rawStates.length; index += 1) {
+		const path = `options.pinStates[${index}]`;
+		const state = snapshotElectricalPin(rawStates[index], path);
+		const key = pinKey(state.instanceId, state.pinName);
+		if (!definition.pinsByKey.has(key)) throw new RangeError(`${path}: (${JSON.stringify(state.instanceId)}, ${JSON.stringify(state.pinName)}) must reference a declared pin`);
+		if (intents.has(key)) invalidType(`${path}.pinName`, state.pinName, `be unique within instance ${JSON.stringify(state.instanceId)}`);
+		intents.set(key, state);
+	}
+	const initialStates = [];
+	for (const pin of definition.pins) {
+		const intent = intents.get(pin.key);
+		if (intent === void 0) throw new RangeError(`options.pinStates: missing state for (${JSON.stringify(pin.ref.instanceId)}, ${JSON.stringify(pin.ref.pinName)})`);
+		initialStates.push(pin.domain === void 0 ? intent : Object.freeze({
+			...intent,
+			powerReady: false
+		}));
+	}
+	let floating;
+	if ("floating" in value) {
+		const rawFloating = value.floating;
+		checkRecord(rawFloating, "options.floating", FLOATING_FIELDS);
+		const seed = rawFloating.seed;
+		checkInteger(seed, 0, 4294967295, "options.floating.seed");
+		floating = Object.freeze({ seed });
+	}
+	let inputMode = "three-state";
+	if ("inputMode" in value) inputMode = checkChoice(value.inputMode, INPUT_MODES, "options.inputMode");
+	const maxPropagationRounds = captureLimit(value.maxPropagationRounds, DEFAULT_MAX_PROPAGATION_ROUNDS, "options.maxPropagationRounds");
+	let observer;
+	if ("observer" in value) observer = captureObserver(value.observer, "options.observer");
+	return Object.freeze({
+		instanceId,
+		topologyInstanceId,
+		intents,
+		initialStates: Object.freeze(initialStates),
+		floating,
+		inputMode,
+		maxPropagationRounds,
+		observer
+	});
+}
+//#endregion
+//#region src/power/runtime.ts
+var NO_OPENED = Object.freeze([]);
+var NO_REASONS = Object.freeze([]);
+var GATED_DIGITAL = Object.freeze({
+	value: 0,
+	ready: false,
+	source: "gated"
+});
+var GATED_VOLTAGE = Object.freeze({
+	voltage: 0,
+	ready: false,
+	source: "gated"
+});
+function compareText(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareSnapshots(left, right) {
+	return compareText(left.instanceId, right.instanceId) || compareText(left.domainId, right.domainId);
+}
+function nextState(voltage, groundReady, dependenciesReady, previous, turnOn, turnOff) {
+	if (!groundReady || voltage === null || !dependenciesReady) return "off";
+	if (voltage <= turnOff) return "off";
+	if (voltage >= turnOn) return "on";
+	return previous;
+}
+function downReasons(domain, snapshot) {
+	const reasons = [];
+	if (!snapshot.groundReady) reasons.push("ground-not-ready");
+	else if (snapshot.voltage === null) reasons.push("supply-indeterminate");
+	if (!snapshot.dependenciesReady) reasons.push("dependency-off");
+	if (snapshot.groundReady && snapshot.voltage !== null && snapshot.voltage <= domain.turnOff) reasons.push("below-turn-off");
+	return Object.freeze(reasons);
+}
+function sortChanges(changes, domainsByKey) {
+	const depth = (change) => domainsByKey.get(domainKey(change.instanceId, change.domainId))?.depth ?? 0;
+	const down = changes.filter((change) => change.state === "off").sort((left, right) => compareText(left.instanceId, right.instanceId) || depth(right) - depth(left) || compareText(left.domainId, right.domainId));
+	const up = changes.filter((change) => change.state === "on").sort((left, right) => compareText(left.instanceId, right.instanceId) || depth(left) - depth(right) || compareText(left.domainId, right.domainId));
+	return Object.freeze([...down, ...up]);
+}
+function sortStates(states) {
+	return Object.freeze([...states.entries()].sort(([left], [right]) => compareText(left, right)).map(([, state]) => state));
+}
+var PowerFeedbackError = class extends Error {
+	name = "PowerFeedbackError";
+	timePs;
+	rounds;
+	maxRounds;
+	domains;
+	constructor(timePs, rounds, maxRounds, domains) {
+		super(`Power propagation exceeded ${maxRounds} rounds at ${timePs} ps`);
+		this.timePs = timePs;
+		this.rounds = rounds;
+		this.maxRounds = maxRounds;
+		this.domains = Object.freeze(domains.map((domain) => Object.freeze({ ...domain })));
+		Object.freeze(this);
+	}
+};
+var PowerRuntimeImpl = class {
+	#scheduler;
+	#definition;
+	#topology;
+	#target;
+	#instance;
+	#inputMode;
+	#maxPropagationRounds;
+	#signalPins;
+	#intents;
+	#effective;
+	#submittedGate;
+	#notified = /* @__PURE__ */ new Map();
+	#pendingOpen = /* @__PURE__ */ new Set();
+	#digital = /* @__PURE__ */ new Map();
+	#memory = /* @__PURE__ */ new Map();
+	#dirty = /* @__PURE__ */ new Set();
+	#commands = [];
+	#domains = /* @__PURE__ */ new Map();
+	#observer;
+	#topologyReady = false;
+	#destroyed = false;
+	#budgetTime;
+	#rounds = 0;
+	#topologyEpoch = 0;
+	#appliedEpoch = 0;
+	constructor(scheduler, definitionInput, optionsInput) {
+		const definition = capturePowerDefinition(definitionInput);
+		const options = capturePowerOptions(optionsInput, definition);
+		this.#scheduler = scheduler;
+		this.#definition = definition;
+		this.#inputMode = options.inputMode;
+		this.#maxPropagationRounds = options.maxPropagationRounds;
+		this.#observer = options.observer;
+		this.#intents = new Map(options.intents);
+		this.#effective = new Map(options.initialStates.map((state) => [pinKey(state.instanceId, state.pinName), state]));
+		this.#submittedGate = new Map(options.initialStates.map((state) => [pinKey(state.instanceId, state.pinName), state.powerReady]));
+		this.#signalPins = Object.freeze(definition.pins.filter((pin) => pin.kind === "signal"));
+		for (const pin of this.#signalPins) this.#memory.set(pin.key, 0);
+		for (const domain of definition.domainsInOrder) this.#notified.set(domain.key, "off");
+		this.#target = Object.freeze({
+			name: "power.propagate",
+			kind: "control",
+			params: Object.freeze([])
+		});
+		let instance;
+		let topology;
+		try {
+			instance = scheduler.addInstance({
+				instanceId: options.instanceId,
+				targets: [this.#target],
+				executor: { execute: () => this.#runNextCommand() }
+			});
+			this.#instance = instance;
+			topology = createTopologyRuntime(scheduler, definition.topology, {
+				instanceId: options.topologyInstanceId,
+				pinStates: options.initialStates,
+				...options.floating === void 0 ? {} : { floating: {
+					seed: options.floating.seed,
+					supplyVoltage: (pin) => this.#floatingSupply(pin),
+					samplingEnabled: (pin) => this.#floatingSamplingEnabled(pin)
+				} }
+			});
+			this.#topology = topology;
+			this.#domains = this.#computeDomains();
+			for (const domain of definition.domainsInOrder) if (this.#domains.get(domain.key)?.state === "on") this.#pendingOpen.add(domain.key);
+			this.#topologyReady = true;
+			this.#interpretPins();
+			this.#enqueuePropagate(0, NO_OPENED);
+		} catch (cause) {
+			if (topology !== void 0) try {
+				topology.destroy();
+			} catch {}
+			if (instance !== void 0) try {
+				scheduler.destroyInstance(instance);
+			} catch {}
+			throw cause;
+		}
+		Object.freeze(this);
+	}
+	get instance() {
+		return this.#instance;
+	}
+	get inputMode() {
+		return this.#inputMode;
+	}
+	submit(patch) {
+		this.#assertAlive();
+		this.#topology.submit(patch);
+		this.#topologyEpoch += 1;
+		this.#enqueuePropagate(this.#topologyEpoch, NO_OPENED);
+	}
+	updatePinStates(states) {
+		this.#assertAlive();
+		if (!Array.isArray(states)) invalidType("states", states, "be an array");
+		if (states.length === 0) return;
+		const updates = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (let index = 0; index < states.length; index += 1) {
+			const state = snapshotElectricalPin(states[index], `states[${index}]`);
+			const key = pinKey(state.instanceId, state.pinName);
+			if (!this.#definition.pinsByKey.has(key)) throw new RangeError(`states[${index}]: (${JSON.stringify(state.instanceId)}, ${JSON.stringify(state.pinName)}) must reference a declared pin`);
+			if (seen.has(key)) invalidType(`states[${index}].pinName`, state.pinName, `be unique within instance ${JSON.stringify(state.instanceId)}`);
+			seen.add(key);
+			updates.push(Object.freeze({
+				key,
+				state
+			}));
+		}
+		for (const update of updates) {
+			this.#intents.set(update.key, update.state);
+			this.#dirty.add(update.key);
+		}
+		this.#enqueuePropagate(this.#topologyEpoch, NO_OPENED);
+	}
+	refresh(pins) {
+		this.#assertAlive();
+		if (pins !== void 0) {
+			if (!Array.isArray(pins)) invalidType("pins", pins, "be an array");
+			if (pins.length === 0) return;
+		}
+		this.#topology.refresh(pins);
+		this.#topologyEpoch += 1;
+		this.#enqueuePropagate(this.#topologyEpoch, NO_OPENED);
+	}
+	connectionState(instanceId, connectionId) {
+		return this.#topology.connectionState(instanceId, connectionId);
+	}
+	networks() {
+		return this.#topology.networks();
+	}
+	networkOf(pin) {
+		return this.#topology.networkOf(pin);
+	}
+	floatingInput(pin) {
+		return this.#topology.floatingInput(pin);
+	}
+	domain(instanceId, domainId) {
+		checkIdentity(instanceId, "instanceId");
+		checkIdentity(domainId, "domainId");
+		const key = domainKey(instanceId, domainId);
+		if (!this.#definition.domainsByKey.has(key)) throw new RangeError(`(${JSON.stringify(instanceId)}, ${JSON.stringify(domainId)}) must reference a declared power domain`);
+		return this.#domains.get(key);
+	}
+	domains(instanceId) {
+		const snapshot = this.#snapshots();
+		if (instanceId === void 0) return snapshot;
+		checkIdentity(instanceId, "instanceId");
+		if (!this.#definition.instances.has(instanceId)) throw new RangeError(`${JSON.stringify(instanceId)} must reference a declared topology instance`);
+		return Object.freeze(snapshot.filter((domain) => domain.instanceId === instanceId));
+	}
+	pinGate(pin) {
+		const captured = this.#signalPin(pin, "pin");
+		const gate = this.#gateFor(captured);
+		return Object.freeze({
+			instanceId: captured.ref.instanceId,
+			pinName: captured.ref.pinName,
+			domainId: gate.domainId,
+			ready: gate.ready,
+			reason: gate.reason
+		});
+	}
+	pinIntent(pin) {
+		const captured = this.#resolvePin(pin, "pin");
+		return this.#intents.get(captured.key);
+	}
+	sampleDigital(pin) {
+		const captured = this.#signalPin(pin, "pin");
+		const sample = this.#digital.get(captured.key);
+		if (sample === void 0) throw new Error(`Invariant: missing digital interpretation for (${JSON.stringify(captured.ref.instanceId)}, ${JSON.stringify(captured.ref.pinName)})`);
+		return sample;
+	}
+	sampleVoltage(pin) {
+		const captured = this.#signalPin(pin, "pin");
+		if (!this.#gateFor(captured).ready) return GATED_VOLTAGE;
+		const result = this.#topology.networkOf(captured.ref)?.result;
+		if (result === void 0) throw new Error(`Invariant: network result missing for (${JSON.stringify(captured.ref.instanceId)}, ${JSON.stringify(captured.ref.pinName)})`);
+		if (result.state === "driven") return Object.freeze({
+			voltage: result.voltage,
+			ready: true,
+			source: "sampled"
+		});
+		const floating = this.#topology.floatingInput(captured.ref);
+		if (floating === void 0) throw new Error(`Floating voltage sampling for (${JSON.stringify(captured.ref.instanceId)}, ${JSON.stringify(captured.ref.pinName)}) requires PowerOptions.floating`);
+		const supply = this.#floatingSupply(captured.ref);
+		if (supply === void 0) throw new RangeError(`Floating voltage sampling for (${JSON.stringify(captured.ref.instanceId)}, ${JSON.stringify(captured.ref.pinName)}) requires a nonnegative supply`);
+		const sample = floating.sample(supply, this.#scheduler.now, true);
+		if (sample.state !== "ready") throw new Error(`Invariant: enabled floating sampling returned disabled for (${JSON.stringify(captured.ref.instanceId)}, ${JSON.stringify(captured.ref.pinName)})`);
+		return Object.freeze({
+			voltage: sample.voltage,
+			ready: true,
+			source: "floating"
+		});
+	}
+	observe(observer) {
+		this.#assertAlive();
+		this.#observer = observer === void 0 ? void 0 : captureObserver(observer, "observer");
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#observer = void 0;
+		this.#commands.length = 0;
+		this.#topology.destroy();
+		this.#scheduler.destroyInstance(this.#instance);
+	}
+	#assertAlive() {
+		if (this.#destroyed) throw new Error("Power runtime is destroyed");
+	}
+	#enqueue(command) {
+		this.#commands.push(command);
+		try {
+			this.#scheduler.enqueueControl(this.#instance, this.#target, []);
+		} catch (cause) {
+			this.#commands.pop();
+			throw cause;
+		}
+	}
+	#enqueuePropagate(epoch, opened) {
+		this.#enqueue(Object.freeze({
+			kind: "propagate",
+			epoch,
+			opened
+		}));
+	}
+	#runNextCommand() {
+		const command = this.#commands.shift();
+		if (command === void 0) throw new Error("Power control entry has no pending command");
+		if (command.kind === "notify") {
+			this.#notify();
+			return;
+		}
+		this.#propagate(command.epoch, command.opened);
+	}
+	#propagate(epoch, opened) {
+		const now = this.#scheduler.now;
+		if (this.#budgetTime !== now) {
+			this.#budgetTime = now;
+			this.#rounds = 0;
+		}
+		this.#rounds += 1;
+		if (this.#rounds > this.#maxPropagationRounds) throw new PowerFeedbackError(now, this.#rounds, this.#maxPropagationRounds, this.#snapshots());
+		if (epoch > this.#appliedEpoch) this.#appliedEpoch = epoch;
+		if (this.#appliedEpoch < this.#topologyEpoch) {
+			this.#enqueuePropagate(this.#topologyEpoch, opened);
+			return;
+		}
+		for (const key of opened) this.#pendingOpen.delete(key);
+		this.#domains = this.#computeDomains();
+		const updates = this.#desiredUpdates();
+		if (updates.off.size > 0) {
+			this.#submitUpdates(updates.off, false);
+			this.#enqueuePropagate(this.#topologyEpoch, NO_OPENED);
+			return;
+		}
+		if (this.#hasNotificationChange()) {
+			this.#enqueue(Object.freeze({ kind: "notify" }));
+			return;
+		}
+		if (updates.on.size > 0) {
+			const openedDomains = this.#submitUpdates(updates.on, true);
+			this.#enqueuePropagate(this.#topologyEpoch, openedDomains);
+			return;
+		}
+		this.#interpretPins();
+	}
+	#notify() {
+		if (this.#appliedEpoch < this.#topologyEpoch) {
+			this.#enqueuePropagate(this.#topologyEpoch, NO_OPENED);
+			return;
+		}
+		let updates = this.#desiredUpdates();
+		if (updates.off.size > 0) {
+			this.#submitUpdates(updates.off, false);
+			this.#enqueuePropagate(this.#topologyEpoch, NO_OPENED);
+			return;
+		}
+		const changes = this.#notificationChanges();
+		const opened = /* @__PURE__ */ new Set();
+		for (const change of changes) {
+			const key = domainKey(change.instanceId, change.domainId);
+			if (change.state === "on") {
+				this.#pendingOpen.add(key);
+				opened.add(key);
+			} else this.#pendingOpen.delete(key);
+		}
+		if (changes.length > 0) {
+			this.#interpretPins();
+			const ordered = sortChanges(changes, this.#definition.domainsByKey);
+			if (this.#observer !== void 0) this.#observer.notify.call(this.#observer.receiver, ordered, this.#snapshots());
+			for (const change of changes) this.#notified.set(domainKey(change.instanceId, change.domainId), change.state);
+		}
+		updates = this.#desiredUpdates();
+		if (updates.off.size > 0) this.#submitUpdates(updates.off, false);
+		if (updates.on.size > 0) for (const key of this.#submitUpdates(updates.on, true)) opened.add(key);
+		if (opened.size > 0 || updates.on.size > 0 || updates.off.size > 0) {
+			this.#enqueuePropagate(this.#topologyEpoch, Object.freeze([...opened].sort(compareText)));
+			return;
+		}
+		this.#interpretPins();
+	}
+	#notificationChanges() {
+		const changes = [];
+		const now = this.#scheduler.now;
+		for (const domain of this.#definition.domainsInOrder) {
+			const previous = this.#notified.get(domain.key) ?? "off";
+			const snapshot = this.#domains.get(domain.key);
+			if (snapshot.state === previous) continue;
+			changes.push(Object.freeze({
+				...snapshot,
+				timePs: now,
+				previousState: previous,
+				reasons: snapshot.state === "off" ? downReasons(domain, snapshot) : NO_REASONS
+			}));
+		}
+		return changes;
+	}
+	#hasNotificationChange() {
+		for (const domain of this.#definition.domainsInOrder) {
+			const previous = this.#notified.get(domain.key) ?? "off";
+			if (this.#domains.get(domain.key).state !== previous) return true;
+		}
+		return false;
+	}
+	#desiredUpdates() {
+		const off = /* @__PURE__ */ new Map();
+		const on = /* @__PURE__ */ new Map();
+		for (const pin of this.#definition.pins) {
+			const intent = this.#intents.get(pin.key);
+			const desired = pin.domain === void 0 ? intent.powerReady : this.#domains.get(pin.domain.key)?.state === "on";
+			if (!this.#dirty.has(pin.key) && this.#submittedGate.get(pin.key) === desired) continue;
+			const state = pin.domain === void 0 ? intent : Object.freeze({
+				...intent,
+				powerReady: desired
+			});
+			if (desired) on.set(pin.key, state);
+			else off.set(pin.key, state);
+		}
+		return {
+			off,
+			on
+		};
+	}
+	#submitUpdates(updates, desired) {
+		if (updates.size === 0) return NO_OPENED;
+		const opened = /* @__PURE__ */ new Set();
+		for (const [key, state] of updates) {
+			const pin = this.#definition.pinsByKey.get(key);
+			const wasSubmitted = this.#submittedGate.get(key) === true;
+			this.#effective.set(key, state);
+			this.#submittedGate.set(key, desired);
+			this.#dirty.delete(key);
+			if (pin.domain === void 0) continue;
+			if (desired) {
+				if (!wasSubmitted) {
+					this.#pendingOpen.add(pin.domain.key);
+					opened.add(pin.domain.key);
+				}
+			} else this.#pendingOpen.delete(pin.domain.key);
+		}
+		this.#topology.updatePinStates(sortStates(updates));
+		this.#topologyEpoch += 1;
+		return Object.freeze([...opened].sort(compareText));
+	}
+	#computeDomains() {
+		const next = /* @__PURE__ */ new Map();
+		for (const domain of this.#definition.domainsInOrder) {
+			const groundNetwork = this.#topology.networkOf(domain.ground);
+			const supplyNetwork = this.#topology.networkOf(domain.supply);
+			const groundReady = groundNetwork?.groundReady === true;
+			const supply = supplyNetwork?.result;
+			const voltage = groundReady && supply?.state === "driven" ? supply.voltage : null;
+			const dependenciesReady = domain.dependsOn.every((dependency) => next.get(dependency.key)?.state === "on");
+			const state = nextState(voltage, groundReady, dependenciesReady, this.#domains.get(domain.key)?.state ?? "off", domain.turnOn, domain.turnOff);
+			next.set(domain.key, Object.freeze({
+				instanceId: domain.instanceId,
+				domainId: domain.domainId,
+				state,
+				voltage,
+				groundReady,
+				dependenciesReady
+			}));
+		}
+		return next;
+	}
+	#snapshots() {
+		return Object.freeze([...this.#domains.values()].sort(compareSnapshots));
+	}
+	#interpretPins() {
+		for (const pin of this.#signalPins) this.#interpretPin(pin);
+	}
+	#interpretPin(pin) {
+		if (!this.#gateFor(pin).ready) {
+			this.#digital.set(pin.key, GATED_DIGITAL);
+			return;
+		}
+		const result = this.#topology.networkOf(pin.ref)?.result;
+		if (result === void 0) throw new Error(`Invariant: network result missing for (${JSON.stringify(pin.ref.instanceId)}, ${JSON.stringify(pin.ref.pinName)})`);
+		if (result.state === "floating") {
+			this.#digital.set(pin.key, Object.freeze({
+				value: 0,
+				ready: true,
+				source: "floating"
+			}));
+			return;
+		}
+		let low;
+		let high;
+		if (pin.levels !== void 0) {
+			const domain = pin.domain === void 0 ? void 0 : this.#domains.get(pin.domain.key);
+			if (domain === void 0 || domain.voltage === null) throw new Error(`Invariant: missing domain voltage for (${JSON.stringify(pin.key)})`);
+			low = pin.levels.low * domain.voltage;
+			high = pin.levels.high * domain.voltage;
+		} else {
+			const effective = this.#effective.get(pin.key);
+			if (effective === void 0) throw new Error(`Invariant: missing effective pin state for (${JSON.stringify(pin.key)})`);
+			low = effective.model.lowVoltage;
+			high = effective.model.highVoltage;
+		}
+		const voltage = result.voltage;
+		let value;
+		let source;
+		if (voltage <= low) {
+			value = 0;
+			source = "sampled";
+		} else if (voltage >= high) {
+			value = 1;
+			source = "sampled";
+		} else if (this.#inputMode === "three-state") {
+			value = this.#memory.get(pin.key) ?? 0;
+			source = "threshold-range";
+		} else {
+			value = 0;
+			source = "sampled";
+		}
+		if (source === "sampled") this.#memory.set(pin.key, value);
+		this.#digital.set(pin.key, Object.freeze({
+			value,
+			ready: true,
+			source
+		}));
+	}
+	#gateFor(pin) {
+		if (pin.domain === void 0) return {
+			domainId: null,
+			ready: true,
+			reason: "no-domain"
+		};
+		const snapshot = this.#domains.get(pin.domain.key);
+		if (snapshot === void 0 || snapshot.state === "off") return {
+			domainId: pin.domain.domainId,
+			ready: false,
+			reason: "domain-off"
+		};
+		if (this.#pendingOpen.has(pin.domain.key)) return {
+			domainId: pin.domain.domainId,
+			ready: false,
+			reason: "opening"
+		};
+		return {
+			domainId: pin.domain.domainId,
+			ready: true,
+			reason: "powered"
+		};
+	}
+	#resolvePin(value, path) {
+		checkRecord(value, path, ["instanceId", "pinName"]);
+		const instanceId = value.instanceId;
+		const pinName = value.pinName;
+		checkIdentity(instanceId, `${path}.instanceId`);
+		checkIdentity(pinName, `${path}.pinName`);
+		const captured = this.#definition.pinsByKey.get(pinKey(instanceId, pinName));
+		if (captured === void 0) throw new RangeError(`${path}: (${JSON.stringify(instanceId)}, ${JSON.stringify(pinName)}) must reference a declared pin`);
+		return captured;
+	}
+	#signalPin(value, path) {
+		const pin = this.#resolvePin(value, path);
+		if (pin.kind !== "signal") throw new RangeError(`${path}: (${JSON.stringify(pin.ref.instanceId)}, ${JSON.stringify(pin.ref.pinName)}) must be a kind 'signal' pin`);
+		return pin;
+	}
+	#floatingSupply(pin) {
+		const captured = this.#definition.pinsByKey.get(pinKey(pin.instanceId, pin.pinName));
+		if (captured === void 0) return void 0;
+		if (captured.domain !== void 0) {
+			if (!this.#topologyReady) return void 0;
+			const snapshot = this.#domains.get(captured.domain.key);
+			if (snapshot === void 0 || snapshot.state !== "on") return void 0;
+			return snapshot.voltage ?? void 0;
+		}
+		const effective = this.#effective.get(captured.key);
+		if (effective === void 0) return void 0;
+		const maxVoltage = effective.model.maxVoltage;
+		return maxVoltage >= 0 ? maxVoltage : void 0;
+	}
+	#floatingSamplingEnabled(pin) {
+		const captured = this.#definition.pinsByKey.get(pinKey(pin.instanceId, pin.pinName));
+		if (captured === void 0) return false;
+		if (captured.domain === void 0) return true;
+		if (!this.#topologyReady) return false;
+		return this.#domains.get(captured.domain.key)?.state === "on";
+	}
+};
+function createPowerRuntime(scheduler, definition, options) {
+	return new PowerRuntimeImpl(scheduler, definition, options);
+}
+//#endregion
+//#region src/index.ts
 var MICA_CORE_VERSION = "0.0.0";
 //#endregion
-export { MICA_CORE_VERSION };
+export { ElectricalConflictError, MAX_TIME_PS, MICA_CORE_VERSION, PowerFeedbackError, SchedulerError, addTime, createFloatingInput, createIRSchedulerInstance, createPowerRuntime, createScheduler, createTopologyRuntime, resolveElectricalNetwork, subtractTime, timePs, toTimePs };
 
 //# sourceMappingURL=index.js.map