@mica-js/document 0.0.0-stage → 0.1.0

package/dist/schematic/index.js

@@ -0,0 +1,2845 @@
+import { c as isAssetReference, i as assetPathError, n as throwIfErrors, o as base64Error, r as ASSET_MODES, s as isAssetMode, t as SchematicError } from "../errors-7cnIjhnV.js";
+import { a as readArrayField, c as readObjectField, d as readStringField, f as report, h as parseInput, i as isRecord, l as readPoint, m as isUuidV4, n as forbidUnknownFields, o as readIntegerField, p as toPointer, r as hasErrors, s as readNumberField, t as checkDuplicateIds, u as readProperties } from "../validate-Cz-ZbbEr.js";
+//#region src/format/types.ts
+/**
+* Schema version of the `.sch` contract (see x-botlab/mica-js#6).
+*
+* 2D placement lives in the separate `.cnv` canvas contract (see x-botlab/mica-js#67 and
+* `@mica-js/document/canvas`).
+*/
+var SCHEMATIC_VERSION = 1;
+//#endregion
+//#region src/schematic/device/reference.ts
+var LABEL_DEVICE = "builtin:label";
+var POWER_DEVICE = "builtin:power";
+var GROUND_DEVICE = "builtin:ground";
+/** Free-standing annotation; it is not a connection point and never joins a net. */
+var TEXT_DEVICE = "builtin:text";
+var RESERVED_PACKAGE_NAMESPACE = "builtin";
+var BUILTIN_DEVICES = {
+	[LABEL_DEVICE]: "label",
+	[POWER_DEVICE]: "power",
+	[GROUND_DEVICE]: "ground"
+};
+var DEFAULT_POWER_LABEL = "VCC";
+var DEFAULT_GROUND_LABEL = "GND";
+var DEFAULT_TEXT_CONTENT = "文本";
+var PACKAGE_NAMESPACE_PATTERN = /^@[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var PACKAGE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var DEVICE_ID_PATTERN = /^(?:[A-Za-z0-9][A-Za-z0-9._+-]*|-[A-Za-z0-9-]*)$/;
+/**
+* Splits `<packageId>:<deviceId>`. Package ids follow npm conventions and may be scoped
+* (`@scope/name`); device ids accept metadata identifiers plus the legacy identifier charset.
+*/
+function parseDeviceReference(raw) {
+	const separator = raw.indexOf(":");
+	if (separator <= 0 || separator === raw.length - 1) return;
+	if (raw.indexOf(":", separator + 1) !== -1) return;
+	const packageId = raw.slice(0, separator);
+	const deviceId = raw.slice(separator + 1);
+	if (!isValidPackageId(packageId) || !DEVICE_ID_PATTERN.test(deviceId)) return;
+	return {
+		raw,
+		packageId,
+		deviceId
+	};
+}
+function isValidPackageId(packageId) {
+	if (packageId.startsWith("@")) {
+		const parts = packageId.split("/");
+		if (parts.length !== 2) return false;
+		const [scope, name] = parts;
+		return scope !== void 0 && name !== void 0 && PACKAGE_NAMESPACE_PATTERN.test(scope) && PACKAGE_NAME_PATTERN.test(name);
+	}
+	return PACKAGE_NAME_PATTERN.test(packageId);
+}
+/** `builtin` is reserved for loader-provided symbols such as `builtin:label`. */
+function isReservedPackageId(packageId) {
+	return packageId === "builtin" || packageId.startsWith(`builtin/`);
+}
+function isLabelDevice(raw) {
+	return raw === LABEL_DEVICE;
+}
+/** True for the free-standing text annotation (`builtin:text`). */
+function isTextDevice(raw) {
+	return raw === TEXT_DEVICE;
+}
+/** Text of a `builtin:text` symbol, falling back to a placeholder. */
+function textDeviceContent(symbol) {
+	const text = symbol.properties?.["text"];
+	return typeof text === "string" && text.length > 0 ? text : DEFAULT_TEXT_CONTENT;
+}
+/** Returns the builtin kind for `builtin:label` / `builtin:power` / `builtin:ground`. */
+function builtinSymbolKind(raw) {
+	return BUILTIN_DEVICES[raw];
+}
+function isBuiltinDevice(raw) {
+	return builtinSymbolKind(raw) !== void 0;
+}
+/** Role of a symbol, derived from its device reference; unknown devices are components. */
+function symbolRole(device) {
+	switch (builtinSymbolKind(device)) {
+		case "label": return "net-label";
+		case "power": return "power";
+		case "ground": return "ground";
+		default: return isTextDevice(device) ? "text" : "component";
+	}
+}
+/** Only components are annotated with a reference designator. */
+function hasDesignator(role) {
+	return role === "component";
+}
+/** Net labels, power and ground ports name the net they attach to. */
+function namesNet(role) {
+	return role === "net-label" || role === "power" || role === "ground";
+}
+/** Reference designator of a component; `undefined` for symbols that have none. */
+function designatorOf(symbol) {
+	return hasDesignator(symbolRole(symbol.device)) ? symbol.designator ?? symbol.id : void 0;
+}
+/** Net name of a label / power / ground symbol; `undefined` when the symbol names no net. */
+function netNameOf(symbol) {
+	switch (symbolRole(symbol.device)) {
+		case "power": return symbol.net ?? "VCC";
+		case "ground": return symbol.net ?? "GND";
+		case "net-label": return symbol.net;
+		default: return;
+	}
+}
+/** Net name a freshly placed symbol of `role` gets when none is given. */
+function defaultNetName(role) {
+	switch (role) {
+		case "power": return "VCC";
+		case "ground": return "GND";
+		default: return;
+	}
+}
+function formatDeviceReference(packageId, deviceId) {
+	return `${packageId}:${deviceId}`;
+}
+//#endregion
+//#region src/schematic/format/parse-schematic.ts
+/** @throws {SchematicError} when the input does not match the `.sch` contract. */
+function parseSchematic(input) {
+	const diagnostics = [];
+	const parsed = parseInput(input, diagnostics);
+	if (!parsed.ok) throw new SchematicError(diagnostics);
+	const value = readDocument(parsed.value, diagnostics);
+	if (value === void 0 || hasErrors(diagnostics)) throw new SchematicError(diagnostics);
+	return value;
+}
+function readDocument(value, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "json/not-object", "Schematic must be a JSON object.", []);
+		return;
+	}
+	forbidUnknownFields(value, ["version", "sheet"], [], diagnostics);
+	const version = readVersion(value, diagnostics);
+	const sheet = readSheet(readObjectField(value, "sheet", [], diagnostics), diagnostics);
+	if (version === void 0 || sheet === void 0) return;
+	return {
+		version,
+		sheet
+	};
+}
+function readVersion(value, diagnostics) {
+	const version = readIntegerField(value, "version", [], diagnostics);
+	if (version === void 0) return;
+	if (version !== 1) {
+		report(diagnostics, "schema/unsupported-version", `Unsupported version ${version}; expected 1.`, ["version"]);
+		return;
+	}
+	return 1;
+}
+function readSheet(value, diagnostics) {
+	if (value === void 0) return;
+	forbidUnknownFields(value, [
+		"symbols",
+		"wires",
+		"junctions"
+	], ["sheet"], diagnostics);
+	const rawSymbols = readArrayField(value, "symbols", ["sheet"], diagnostics) ?? [];
+	const rawWires = readArrayField(value, "wires", ["sheet"], diagnostics) ?? [];
+	const rawJunctions = readArrayField(value, "junctions", ["sheet"], diagnostics) ?? [];
+	const symbols = [];
+	const symbolIds = [];
+	rawSymbols.forEach((item, index) => {
+		const path = [
+			"sheet",
+			"symbols",
+			String(index)
+		];
+		const symbol = readSymbol(item, path, diagnostics);
+		if (symbol !== void 0) {
+			symbols.push(symbol);
+			symbolIds.push({
+				id: symbol.id,
+				path: [...path, "id"]
+			});
+		}
+	});
+	const wires = [];
+	const wireIds = [];
+	rawWires.forEach((item, index) => {
+		const path = [
+			"sheet",
+			"wires",
+			String(index)
+		];
+		const wire = readWire(item, path, diagnostics);
+		if (wire !== void 0) {
+			wires.push(wire);
+			wireIds.push({
+				id: wire.id,
+				path: [...path, "id"]
+			});
+		}
+	});
+	const knownWireIds = new Set(wires.map((wire) => wire.id));
+	const junctions = [];
+	const junctionIds = [];
+	rawJunctions.forEach((item, index) => {
+		const path = [
+			"sheet",
+			"junctions",
+			String(index)
+		];
+		const junction = readJunction(item, path, diagnostics);
+		if (junction === void 0) return;
+		const seenWireIds = /* @__PURE__ */ new Set();
+		junction.wires.forEach((wireId, wireIndex) => {
+			const wirePath = [
+				...path,
+				"wires",
+				String(wireIndex)
+			];
+			if (seenWireIds.has(wireId)) report(diagnostics, "junction/duplicate-wire", `Junction "${junction.id}" references wire "${wireId}" more than once.`, wirePath, {
+				kind: "junction",
+				id: junction.id
+			});
+			else seenWireIds.add(wireId);
+			if (!knownWireIds.has(wireId)) report(diagnostics, "junction/unknown-wire", `Junction "${junction.id}" references unknown wire "${wireId}".`, wirePath, {
+				kind: "junction",
+				id: junction.id
+			});
+		});
+		junctions.push(junction);
+		junctionIds.push({
+			id: junction.id,
+			path: [...path, "id"]
+		});
+	});
+	checkDuplicateIds(symbolIds, "symbol", diagnostics);
+	checkDuplicateDesignators(symbols, diagnostics);
+	checkDuplicateIds(wireIds, "wire", diagnostics);
+	checkDuplicateIds(junctionIds, "junction", diagnostics);
+	return {
+		symbols,
+		wires,
+		junctions
+	};
+}
+/** Two components must not share a reference designator. */
+function checkDuplicateDesignators(symbols, diagnostics) {
+	const seen = /* @__PURE__ */ new Set();
+	symbols.forEach((symbol, index) => {
+		const designator = designatorOf(symbol);
+		if (designator === void 0) return;
+		if (seen.has(designator)) {
+			report(diagnostics, "symbol/designator-duplicate", `Reference designator ${JSON.stringify(designator)} is used more than once.`, [
+				"sheet",
+				"symbols",
+				String(index),
+				"designator"
+			], {
+				kind: "symbol",
+				id: symbol.id
+			});
+			return;
+		}
+		seen.add(designator);
+	});
+}
+function readSymbol(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "schema/invalid-type", "Symbol must be an object.", path);
+		return;
+	}
+	forbidUnknownFields(value, [
+		"id",
+		"device",
+		"x",
+		"y",
+		"rotation",
+		"properties",
+		"designator",
+		"net",
+		"reference"
+	], path, diagnostics);
+	const id = readId(value, path, diagnostics);
+	const device = readStringField(value, "device", path, diagnostics, { nonEmpty: true });
+	const x = readNumberField(value, "x", path, diagnostics);
+	const y = readNumberField(value, "y", path, diagnostics);
+	const rotation = readNumberField(value, "rotation", path, diagnostics);
+	const properties = value["properties"] === void 0 ? void 0 : readProperties(value["properties"], [...path, "properties"], diagnostics);
+	const reference = value["reference"] === void 0 ? void 0 : readPoint(value["reference"], [...path, "reference"], diagnostics);
+	const designator = readRoleField(value, "designator", device, path, diagnostics, hasDesignator);
+	const net = readRoleField(value, "net", device, path, diagnostics, namesNet);
+	if (device !== void 0) {
+		const role = symbolRole(device);
+		if (namesNet(role) && net === void 0 && value["net"] === void 0) report(diagnostics, "symbol/missing-net", `Symbols of role "${role}" must name the net they attach to.`, [...path, "net"]);
+		if (!hasDesignator(role) && value["reference"] !== void 0) report(diagnostics, "symbol/unsupported-field", `Symbols of role "${role}" carry no reference designator.`, [...path, "reference"]);
+	}
+	if (id === void 0 || device === void 0 || x === void 0 || y === void 0 || rotation === void 0 || value["reference"] !== void 0 && reference === void 0) return;
+	return {
+		id,
+		device,
+		x,
+		y,
+		rotation,
+		...properties === void 0 ? {} : { properties },
+		...designator === void 0 ? {} : { designator },
+		...net === void 0 ? {} : { net },
+		...reference === void 0 ? {} : { reference }
+	};
+}
+/**
+* Reads a field that only some symbol roles may carry, so the format cannot describe a power
+* symbol with a reference designator or a resistor with a net name.
+*/
+function readRoleField(value, field, device, path, diagnostics, allowed) {
+	if (value[field] === void 0 || device === void 0) return;
+	const role = symbolRole(device);
+	if (!allowed(role)) {
+		report(diagnostics, "symbol/unsupported-field", `Symbols of role "${role}" must not declare "${field}".`, [...path, field]);
+		return;
+	}
+	return readStringField(value, field, path, diagnostics, { nonEmpty: true });
+}
+function readWire(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "schema/invalid-type", "Wire must be an object.", path);
+		return;
+	}
+	forbidUnknownFields(value, ["id", "points"], path, diagnostics);
+	const id = readId(value, path, diagnostics);
+	const rawPoints = readArrayField(value, "points", path, diagnostics);
+	const points = [];
+	if (rawPoints !== void 0) {
+		if (rawPoints.length < 2) report(diagnostics, "wire/invalid-points", "Wire must contain at least two points.", [...path, "points"]);
+		rawPoints.forEach((item, index) => {
+			const point = readPoint(item, [
+				...path,
+				"points",
+				String(index)
+			], diagnostics);
+			if (point !== void 0) points.push(point);
+		});
+	}
+	if (id === void 0 || rawPoints === void 0) return;
+	for (let index = 1; index < points.length; index += 1) {
+		const previous = points[index - 1];
+		const current = points[index];
+		if (previous === void 0 || current === void 0) continue;
+		if (previous.x !== current.x && previous.y !== current.y) {
+			report(diagnostics, "wire/not-orthogonal", "Wire segments must be horizontal or vertical.", [
+				...path,
+				"points",
+				String(index)
+			]);
+			return;
+		}
+	}
+	return {
+		id,
+		points
+	};
+}
+function readJunction(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "schema/invalid-type", "Junction must be an object.", path);
+		return;
+	}
+	forbidUnknownFields(value, [
+		"id",
+		"x",
+		"y",
+		"wires"
+	], path, diagnostics);
+	const id = readId(value, path, diagnostics);
+	const x = readNumberField(value, "x", path, diagnostics);
+	const y = readNumberField(value, "y", path, diagnostics);
+	const rawWires = readArrayField(value, "wires", path, diagnostics);
+	const wires = [];
+	if (rawWires !== void 0) {
+		if (rawWires.length < 2) report(diagnostics, "schema/invalid-value", "Junction must reference at least two wires.", [...path, "wires"]);
+		rawWires.forEach((item, index) => {
+			const wirePath = [
+				...path,
+				"wires",
+				String(index)
+			];
+			if (typeof item !== "string") {
+				report(diagnostics, "schema/invalid-type", "Junction wire reference must be a string.", wirePath);
+				return;
+			}
+			if (item.length === 0) {
+				report(diagnostics, "schema/invalid-value", "Junction wire reference must not be empty.", wirePath);
+				return;
+			}
+			wires.push(item);
+		});
+	}
+	if (id === void 0 || x === void 0 || y === void 0 || rawWires === void 0) return;
+	return {
+		id,
+		x,
+		y,
+		wires
+	};
+}
+function readId(value, path, diagnostics) {
+	const id = readStringField(value, "id", path, diagnostics, { nonEmpty: true });
+	if (id === void 0) return;
+	if (!isUuidV4(id)) {
+		report(diagnostics, "schema/invalid-value", "Field \"id\" must be a UUID v4.", [...path, "id"]);
+		return;
+	}
+	return id;
+}
+//#endregion
+//#region src/schematic/format/serialize.ts
+/** Serializes with a fixed field order and 2-space indentation, matching the examples in #6. */
+function serializeSchematic(document) {
+	const serializable = {
+		version: document.version,
+		sheet: {
+			symbols: document.sheet.symbols.map((symbol) => {
+				const serialized = {
+					id: symbol.id,
+					device: symbol.device,
+					x: symbol.x,
+					y: symbol.y,
+					rotation: symbol.rotation
+				};
+				if (symbol.properties !== void 0 && Object.keys(symbol.properties).length > 0) serialized["properties"] = sortProperties(symbol.properties);
+				if (symbol.designator !== void 0) serialized["designator"] = symbol.designator;
+				if (symbol.net !== void 0) serialized["net"] = symbol.net;
+				if (symbol.reference !== void 0) serialized["reference"] = {
+					x: symbol.reference.x,
+					y: symbol.reference.y
+				};
+				return serialized;
+			}),
+			wires: document.sheet.wires.map((wire) => ({
+				id: wire.id,
+				points: wire.points.map((point) => ({
+					x: point.x,
+					y: point.y
+				}))
+			})),
+			junctions: document.sheet.junctions.map((junction) => ({
+				id: junction.id,
+				x: junction.x,
+				y: junction.y,
+				wires: [...junction.wires]
+			}))
+		}
+	};
+	return `${JSON.stringify(serializable, null, 2)}\n`;
+}
+function sortProperties(properties) {
+	const sorted = Object.create(null);
+	for (const key of Object.keys(properties).sort()) {
+		const value = properties[key];
+		if (value !== void 0) sorted[key] = value;
+	}
+	return sorted;
+}
+//#endregion
+//#region src/schematic/geometry/point.ts
+/** Default comparison tolerance, in page units. */
+var DEFAULT_TOLERANCE = 0;
+function distance(a, b) {
+	return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function samePoint(a, b) {
+	return a.x === b.x && a.y === b.y;
+}
+function pointsEqual(a, b, tolerance = 0) {
+	return distance(a, b) <= tolerance;
+}
+/** Closest point on the closed segment `a`–`b`, plus its position `t` in `[0, 1]`. */
+function projectOnSegment(point, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const lengthSquared = dx * dx + dy * dy;
+	if (lengthSquared === 0) return {
+		x: a.x,
+		y: a.y,
+		t: 0
+	};
+	const raw = ((point.x - a.x) * dx + (point.y - a.y) * dy) / lengthSquared;
+	const t = raw < 0 ? 0 : raw > 1 ? 1 : raw;
+	return {
+		x: a.x + dx * t,
+		y: a.y + dy * t,
+		t
+	};
+}
+/** Closest point on a polyline, with the segment it belongs to; `undefined` when empty. */
+function nearestPointOnPolyline(points, point) {
+	let best;
+	for (let index = 1; index < points.length; index += 1) {
+		const a = points[index - 1];
+		const b = points[index];
+		if (a === void 0 || b === void 0) continue;
+		const projected = projectOnSegment(point, a, b);
+		const candidate = {
+			point: {
+				x: projected.x,
+				y: projected.y
+			},
+			segment: index - 1,
+			t: projected.t,
+			distance: distance(point, projected)
+		};
+		if (best === void 0 || candidate.distance < best.distance) best = candidate;
+	}
+	const only = points[0];
+	if (best === void 0 && only !== void 0) return {
+		point: only,
+		segment: 0,
+		t: 0,
+		distance: distance(point, only)
+	};
+	return best;
+}
+/** Point at position `t` along segment `segment` of a polyline. */
+function pointOnPolylineAt(points, segment, t) {
+	const a = points[segment];
+	if (a === void 0) return;
+	const b = points[segment + 1] ?? a;
+	return {
+		x: a.x + (b.x - a.x) * t,
+		y: a.y + (b.y - a.y) * t
+	};
+}
+/** True when `point` lies on the closed segment `a`–`b`, within `tolerance`. */
+function pointOnSegment(point, a, b, tolerance = 0) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const length = Math.hypot(dx, dy);
+	if (length === 0) return pointsEqual(point, a, tolerance);
+	const area = (point.x - a.x) * dy - (point.y - a.y) * dx;
+	if (Math.abs(area) / length > tolerance) return false;
+	const projection = ((point.x - a.x) * dx + (point.y - a.y) * dy) / (length * length);
+	const overhang = tolerance / length;
+	if (projection < -overhang || projection > 1 + overhang) return false;
+	return distanceToSegment(point, a, b) <= tolerance;
+}
+function distanceToSegment(point, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const lengthSquared = dx * dx + dy * dy;
+	if (lengthSquared === 0) return distance(point, a);
+	const t = ((point.x - a.x) * dx + (point.y - a.y) * dy) / lengthSquared;
+	const clamped = t < 0 ? 0 : t > 1 ? 1 : t;
+	return distance(point, {
+		x: a.x + clamped * dx,
+		y: a.y + clamped * dy
+	});
+}
+/** True when `point` lies on any segment of the polyline, endpoints included. */
+function pointOnPolyline(points, point, tolerance = 0) {
+	if (points.length === 1) {
+		const [only] = points;
+		return only !== void 0 && pointsEqual(only, point, tolerance);
+	}
+	for (let index = 1; index < points.length; index += 1) {
+		const previous = points[index - 1];
+		const current = points[index];
+		if (previous !== void 0 && current !== void 0 && pointOnSegment(point, previous, current, tolerance)) return true;
+	}
+	return false;
+}
+function boundsOfPoints(points) {
+	const [first, ...rest] = points;
+	if (first === void 0) return;
+	let minX = first.x;
+	let minY = first.y;
+	let maxX = first.x;
+	let maxY = first.y;
+	for (const point of rest) {
+		minX = Math.min(minX, point.x);
+		minY = Math.min(minY, point.y);
+		maxX = Math.max(maxX, point.x);
+		maxY = Math.max(maxY, point.y);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+function unionBounds(a, b) {
+	if (a === void 0) return b;
+	if (b === void 0) return a;
+	const minX = Math.min(a.x, b.x);
+	const minY = Math.min(a.y, b.y);
+	const maxX = Math.max(a.x + a.width, b.x + b.width);
+	const maxY = Math.max(a.y + a.height, b.y + b.height);
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+//#endregion
+//#region src/schematic/geometry/transform.ts
+/** Rotates counter-clockwise around the origin. Rotation is expressed in degrees. */
+function rotatePoint(point, degrees) {
+	const radians = degrees * Math.PI / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	return {
+		x: point.x * cos - point.y * sin,
+		y: point.x * sin + point.y * cos
+	};
+}
+/** Applies a symbol placement to a pre-placement anchor. */
+function symbolPinPosition(placement, anchor) {
+	const rotated = rotatePoint(anchor, placement.rotation);
+	return {
+		x: placement.x + rotated.x,
+		y: placement.y + rotated.y
+	};
+}
+/**
+* Local anchor of a symbol's reference designator: the explicit override, else the body's
+* top-left corner lifted by {@link REFERENCE_DEFAULT_OFFSET}.
+*/
+function referenceAnchor(outline, override) {
+	if (override !== void 0) return {
+		x: override.x,
+		y: override.y
+	};
+	if (outline === void 0) return {
+		x: 0,
+		y: -4
+	};
+	return {
+		x: outline.x,
+		y: outline.y - 4
+	};
+}
+/** World position of a symbol's reference designator anchor. */
+function referencePosition(placement, outline, override) {
+	return symbolPinPosition(placement, referenceAnchor(outline, override));
+}
+/** Bounding box of a symbol: its transformed outline, else its pins, else its origin. */
+function symbolBounds(placement, outline, pins) {
+	if (outline !== void 0) return boundsOfPoints([
+		{
+			x: outline.x,
+			y: outline.y
+		},
+		{
+			x: outline.x + outline.width,
+			y: outline.y
+		},
+		{
+			x: outline.x,
+			y: outline.y + outline.height
+		},
+		{
+			x: outline.x + outline.width,
+			y: outline.y + outline.height
+		}
+	].map((corner) => symbolPinPosition(placement, corner)));
+	const anchors = Object.values(pins).map((anchor) => symbolPinPosition(placement, anchor));
+	if (anchors.length > 0) return boundsOfPoints(anchors);
+	return {
+		x: placement.x,
+		y: placement.y,
+		width: 0,
+		height: 0
+	};
+}
+//#endregion
+//#region src/schematic/netlist/derive.ts
+/**
+* Derives nets from wires, explicit junctions and symbol connection points (#6).
+*
+* @throws {SchematicError} when a device cannot be resolved or a net has conflicting labels.
+*/
+function deriveSchematicTopology(document, options = {}) {
+	const diagnostics = [];
+	const tolerance = options.tolerance ?? 0;
+	const { devices } = options;
+	const { symbols, wires, junctions } = document.sheet;
+	const connections = [];
+	let bounds;
+	for (const symbol of symbols) {
+		bounds = unionBounds(bounds, {
+			x: symbol.x,
+			y: symbol.y,
+			width: 0,
+			height: 0
+		});
+		const builtin = builtinSymbolKind(symbol.device);
+		if (builtin !== void 0) {
+			const net = netNameOf(symbol);
+			if (net !== void 0) connections.push({
+				kind: builtin,
+				symbolId: symbol.id,
+				point: {
+					x: symbol.x,
+					y: symbol.y
+				},
+				name: net
+			});
+			continue;
+		}
+		const reference = parseDeviceReference(symbol.device);
+		if (reference === void 0) {
+			if (devices !== void 0) diagnostics.push({
+				severity: "error",
+				code: "device/invalid-reference",
+				message: `Symbol "${symbol.id}" has an invalid device reference ${JSON.stringify(symbol.device)}.`,
+				entity: {
+					kind: "symbol",
+					id: symbol.id
+				}
+			});
+			continue;
+		}
+		if (devices === void 0) continue;
+		const definition = devices.getDeviceSymbol(reference);
+		if (devices.getDeviceName(reference) === void 0) {
+			diagnostics.push({
+				severity: "error",
+				code: "device/unresolved",
+				message: `Symbol "${symbol.id}" references unresolved device ${JSON.stringify(symbol.device)}.`,
+				entity: {
+					kind: "symbol",
+					id: symbol.id
+				}
+			});
+			continue;
+		}
+		if (definition === void 0) continue;
+		bounds = unionBounds(bounds, symbolBounds(symbol, definition.bounds, definition.pins));
+		for (const [pinId, anchor] of Object.entries(definition.pins)) {
+			const position = symbolPinPosition(symbol, anchor);
+			connections.push({
+				kind: "pin",
+				symbolId: symbol.id,
+				pinId,
+				point: position
+			});
+			bounds = unionBounds(bounds, {
+				x: position.x,
+				y: position.y,
+				width: 0,
+				height: 0
+			});
+		}
+	}
+	for (const wire of wires) bounds = unionBounds(bounds, boundsOfPoints(wire.points));
+	const wireIndex = /* @__PURE__ */ new Map();
+	wires.forEach((wire, index) => wireIndex.set(wire.id, index));
+	const wireCount = wires.length;
+	const parent = new Array(wireCount + connections.length);
+	for (let index = 0; index < parent.length; index += 1) parent[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 = (a, b) => {
+		const rootA = find(a);
+		const rootB = find(b);
+		if (rootA !== rootB) parent[rootB] = rootA;
+	};
+	for (const junction of junctions) {
+		const [first, ...rest] = junction.wires.map((wireId) => wireIndex.get(wireId)).filter((index) => index !== void 0);
+		if (first === void 0) continue;
+		for (const target of rest) union(first, target);
+	}
+	/** Wire index → connection indexes attached to it. */
+	const wireAttachments = /* @__PURE__ */ new Map();
+	connections.forEach((connection, connectionIndex) => {
+		wires.forEach((wire, index) => {
+			if (!pointOnPolyline(wire.points, connection.point, tolerance)) return;
+			union(index, wireCount + connectionIndex);
+			const attached = wireAttachments.get(index);
+			if (attached === void 0) wireAttachments.set(index, [connectionIndex]);
+			else attached.push(connectionIndex);
+		});
+	});
+	const groups = /* @__PURE__ */ new Map();
+	const groupOf = (root) => {
+		const existing = groups.get(root);
+		if (existing !== void 0) return existing;
+		const created = {
+			wires: [],
+			connections: []
+		};
+		groups.set(root, created);
+		return created;
+	};
+	wires.forEach((_, index) => {
+		groupOf(find(index)).wires.push(index);
+	});
+	connections.forEach((_, connectionIndex) => {
+		groupOf(find(wireCount + connectionIndex)).connections.push(connectionIndex);
+	});
+	const netOfConnection = /* @__PURE__ */ new Map();
+	const nets = [];
+	for (const group of mergeGroupsByName(groups, connections, diagnostics)) {
+		const connected = group.wires.length > 0 || group.connections.length >= 2;
+		if (group.connections.length === 0 || !connected) continue;
+		const name = group.name;
+		const members = group.connections.map((index) => connections[index]).map((connection) => {
+			if (connection === void 0) return;
+			return connection.kind === "pin" ? {
+				kind: "pin",
+				symbolId: connection.symbolId,
+				pinId: connection.pinId
+			} : {
+				kind: connection.kind,
+				symbolId: connection.symbolId
+			};
+		}).filter((member) => member !== void 0).sort(compareMembers);
+		const net = {
+			name,
+			wireIds: group.wires.map((index) => wires[index]?.id).filter((id) => id !== void 0).sort(),
+			members
+		};
+		nets.push(net);
+		for (const index of group.connections) netOfConnection.set(index, net);
+	}
+	const pins = [];
+	connections.forEach((connection, index) => {
+		if (connection.kind !== "pin") return;
+		const net = netOfConnection.get(index);
+		pins.push({
+			symbolId: connection.symbolId,
+			pinId: connection.pinId,
+			position: connection.point,
+			open: net === void 0,
+			netName: net?.name ?? null
+		});
+	});
+	pins.sort((a, b) => a.symbolId.localeCompare(b.symbolId) || a.pinId.localeCompare(b.pinId));
+	const danglingWireEnds = [];
+	wires.forEach((wire, index) => {
+		const endpoints = [{
+			end: "start",
+			point: wire.points[0]
+		}, {
+			end: "end",
+			point: wire.points[wire.points.length - 1]
+		}];
+		for (const { end, point } of endpoints) {
+			if (point === void 0) continue;
+			const attached = (wireAttachments.get(index) ?? []).some((connectionIndex) => {
+				const connection = connections[connectionIndex];
+				return connection !== void 0 && pointsEqual(connection.point, point, tolerance);
+			});
+			const junctioned = junctions.some((junction) => junction.wires.includes(wire.id) && pointsEqual({
+				x: junction.x,
+				y: junction.y
+			}, point, tolerance));
+			if (!attached && !junctioned) danglingWireEnds.push({
+				wireId: wire.id,
+				end,
+				point
+			});
+		}
+	});
+	danglingWireEnds.sort((a, b) => a.wireId.localeCompare(b.wireId) || a.end.localeCompare(b.end));
+	throwIfErrors(diagnostics);
+	return {
+		nets: nets.sort((a, b) => compareNetNames(a.name, b.name) || compareMembers(a.members[0], b.members[0])),
+		pins,
+		danglingWireEnds,
+		bounds
+	};
+}
+/**
+* Folds groups that carry the same net name into one group: net names are the merge key, so two
+* `VCC` ports on separate wires are the same net (KiCad-style name-based connectivity).
+* A group that declares two different names is an error.
+*/
+function mergeGroupsByName(groups, connections, diagnostics) {
+	const byName = /* @__PURE__ */ new Map();
+	const merged = [];
+	for (const group of groups.values()) {
+		const names = group.connections.map((index) => connections[index]).filter((connection) => connection !== void 0 && connection.kind !== "pin").map((connection) => connection.name).sort();
+		if (names.length > 1) diagnostics.push({
+			severity: "error",
+			code: "net/naming-conflict",
+			message: `Net has conflicting names: ${names.map((item) => JSON.stringify(item)).join(", ")}.`
+		});
+		const name = names.length === 1 ? names[0] : null;
+		if (name === null || group.wires.length === 0 && group.connections.length < 2) {
+			merged.push({
+				wires: group.wires,
+				connections: group.connections,
+				name
+			});
+			continue;
+		}
+		const existing = byName.get(name);
+		if (existing === void 0) {
+			const created = {
+				wires: [...group.wires],
+				connections: [...group.connections]
+			};
+			byName.set(name, created);
+			merged.push({
+				...created,
+				name
+			});
+			continue;
+		}
+		existing.wires.push(...group.wires);
+		existing.connections.push(...group.connections);
+	}
+	return merged;
+}
+var KIND_ORDER = [
+	"label",
+	"power",
+	"ground",
+	"pin"
+];
+function compareMembers(a, b) {
+	if (a === void 0 || b === void 0) return a === void 0 ? b === void 0 ? 0 : 1 : -1;
+	if (a.kind !== b.kind) return KIND_ORDER.indexOf(a.kind) - KIND_ORDER.indexOf(b.kind);
+	const bySymbol = a.symbolId.localeCompare(b.symbolId);
+	if (bySymbol !== 0) return bySymbol;
+	const pinA = a.kind === "pin" ? a.pinId : "";
+	const pinB = b.kind === "pin" ? b.pinId : "";
+	return pinA.localeCompare(pinB);
+}
+function compareNetNames(a, b) {
+	if (a === null || b === null) return a === null ? b === null ? 0 : 1 : -1;
+	return a.localeCompare(b);
+}
+//#endregion
+//#region src/schematic/load/load.ts
+/** Parses a schematic and derives its topology. @throws {SchematicError} on any contract violation. */
+function loadSchematic(source, options = {}) {
+	const document = parseSchematic(source);
+	return {
+		document,
+		topology: deriveSchematicTopology(document, options)
+	};
+}
+//#endregion
+//#region src/schematic/device/properties.ts
+/** Property value types a device may declare (#7). */
+var PROPERTY_TYPES = [
+	"string",
+	"integer",
+	"number",
+	"boolean",
+	"color",
+	"enum",
+	"image",
+	"binary"
+];
+var COLOR_PATTERN = /^#([0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function isPropertyType(value) {
+	return typeof value === "string" && PROPERTY_TYPES.includes(value);
+}
+/** Uppercases a `#RRGGBB` / `#RRGGBBAA` color; `undefined` when the text is not a color. */
+function normalizeColor(value) {
+	return COLOR_PATTERN.test(value) ? value.toUpperCase() : void 0;
+}
+/** Parses one declared property; `undefined` when the type is unknown or the descriptor unusable. */
+function parsePropertyDescriptor(key, raw) {
+	if (!isRecord(raw)) return;
+	const type = raw["type"];
+	if (!isPropertyType(type)) return;
+	const draft = {
+		key,
+		type
+	};
+	const title = readText(raw["title"]);
+	if (title !== void 0) draft.title = title;
+	const description = readText(raw["description"]);
+	if (description !== void 0) draft.description = description;
+	if (raw["nullable"] === true) draft.nullable = true;
+	if (type === "string") {
+		const maxLength = readCount(raw["maxLength"]);
+		if (maxLength !== void 0) draft.maxLength = maxLength;
+	}
+	if (type === "integer" || type === "number") {
+		const min = readFinite(raw["min"]);
+		if (min !== void 0) draft.min = min;
+		const max = readFinite(raw["max"]);
+		if (max !== void 0) draft.max = max;
+		const step = readFinite(raw["step"]);
+		if (step !== void 0 && step > 0) draft.step = step;
+		if (type === "number") {
+			const exclusiveMin = readFinite(raw["exclusiveMin"]);
+			if (exclusiveMin !== void 0) draft.exclusiveMin = exclusiveMin;
+			const unit = readText(raw["unit"]);
+			if (unit !== void 0) draft.unit = unit;
+		}
+	}
+	if (type === "color" && raw["alpha"] === true) draft.alpha = true;
+	if (type === "enum") {
+		const options = readOptions(raw["options"]);
+		if (options === void 0) return;
+		draft.options = options;
+	}
+	if (type === "image" || type === "binary") {
+		const maxBytes = readCount(raw["maxBytes"]);
+		if (maxBytes !== void 0) draft.maxBytes = maxBytes;
+		if (type === "image") {
+			const maxPixels = readCount(raw["maxPixels"]);
+			if (maxPixels !== void 0) draft.maxPixels = maxPixels;
+		}
+	}
+	const defaultValue = raw["default"];
+	if (defaultValue !== void 0 && propertyValueProblem(draft, defaultValue) === void 0) draft.default = defaultValue;
+	return draft;
+}
+/** Parses the `properties` object of a device description, skipping unusable declarations. */
+function readPropertyDescriptors(raw) {
+	const descriptors = /* @__PURE__ */ new Map();
+	if (!isRecord(raw)) return descriptors;
+	for (const [key, value] of Object.entries(raw)) {
+		if (key.length === 0) continue;
+		const descriptor = parsePropertyDescriptor(key, value);
+		if (descriptor !== void 0) descriptors.set(key, descriptor);
+	}
+	return descriptors;
+}
+/** Constraint violation of `value` for `descriptor`; `undefined` when the value is acceptable. */
+function propertyValueProblem(descriptor, value) {
+	const key = descriptor.key;
+	if (value === null) return descriptor.nullable === true ? void 0 : {
+		code: "schema/invalid-value",
+		message: `Property "${key}" is not nullable.`
+	};
+	switch (descriptor.type) {
+		case "string": {
+			if (typeof value !== "string") return {
+				code: "schema/invalid-type",
+				message: `Property "${key}" must be a string.`
+			};
+			const maxLength = descriptor.maxLength;
+			if (maxLength !== void 0 && [...value].length > maxLength) return {
+				code: "schema/invalid-value",
+				message: `Property "${key}" must be at most ${String(maxLength)} characters.`
+			};
+			return;
+		}
+		case "integer":
+			if (typeof value !== "number" || !Number.isSafeInteger(value)) return {
+				code: "schema/invalid-type",
+				message: `Property "${key}" must be a safe integer.`
+			};
+			return boundProblem(descriptor, value);
+		case "number":
+			if (typeof value !== "number" || !Number.isFinite(value)) return {
+				code: "schema/invalid-type",
+				message: `Property "${key}" must be a finite number.`
+			};
+			if (descriptor.exclusiveMin !== void 0 && value <= descriptor.exclusiveMin) return {
+				code: "schema/invalid-value",
+				message: `Property "${key}" must be greater than ${String(descriptor.exclusiveMin)}.`
+			};
+			return boundProblem(descriptor, value);
+		case "boolean": return typeof value === "boolean" ? void 0 : {
+			code: "schema/invalid-type",
+			message: `Property "${key}" must be a boolean.`
+		};
+		case "color": {
+			if (typeof value !== "string") return {
+				code: "schema/invalid-type",
+				message: `Property "${key}" must be a string.`
+			};
+			const normalized = normalizeColor(value);
+			if (normalized === void 0) return {
+				code: "schema/invalid-value",
+				message: `Property "${key}" must be a "#RRGGBB" color.`
+			};
+			if (descriptor.alpha !== true && normalized.length === 9) return {
+				code: "schema/invalid-value",
+				message: `Property "${key}" does not accept alpha; use "#RRGGBB".`
+			};
+			return;
+		}
+		case "enum": {
+			if (typeof value !== "string") return {
+				code: "schema/invalid-type",
+				message: `Property "${key}" must be a string.`
+			};
+			const allowed = (descriptor.options ?? []).map((option) => option.value);
+			return allowed.includes(value) ? void 0 : {
+				code: "schema/invalid-value",
+				message: `Property "${key}" must be one of ${allowed.map((entry) => JSON.stringify(entry)).join(", ")}.`
+			};
+		}
+		case "image":
+		case "binary": return isAssetReference(value) ? void 0 : {
+			code: "schema/invalid-type",
+			message: `Property "${key}" must be a resource reference { "src", "mode" }.`
+		};
+	}
+}
+/** Canonical stored value: colors are uppercased, everything else is stored as given. */
+function normalizePropertyValue(descriptor, value) {
+	if (descriptor.type === "color" && typeof value === "string") return normalizeColor(value) ?? value;
+	return value;
+}
+function boundProblem(descriptor, value) {
+	const key = descriptor.key;
+	if (descriptor.min !== void 0 && value < descriptor.min) return {
+		code: "schema/invalid-value",
+		message: `Property "${key}" must be at least ${String(descriptor.min)}.`
+	};
+	if (descriptor.max !== void 0 && value > descriptor.max) return {
+		code: "schema/invalid-value",
+		message: `Property "${key}" must be at most ${String(descriptor.max)}.`
+	};
+}
+function readText(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readFinite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function readOptions(value) {
+	if (!Array.isArray(value) || value.length === 0) return;
+	const options = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of value) {
+		if (!isRecord(entry)) return;
+		const optionValue = entry["value"];
+		const label = entry["label"];
+		if (typeof optionValue !== "string" || optionValue.length === 0 || typeof label !== "string" || label.length === 0 || seen.has(optionValue)) return;
+		seen.add(optionValue);
+		options.push({
+			value: optionValue,
+			label
+		});
+	}
+	return options;
+}
+//#endregion
+//#region src/schematic/edit/ids.ts
+function usedIds(document, kind) {
+	const ids = kind === "symbol" ? document.sheet.symbols.map((symbol) => symbol.id) : kind === "wire" ? document.sheet.wires.map((wire) => wire.id) : document.sheet.junctions.map((junction) => junction.id);
+	return new Set(ids);
+}
+/**
+* Random UUID v4, falling back to `getRandomValues` (or `Math.random` in ancient runtimes).
+* Ids are opaque identity: they never collide with the designators and net names users edit.
+*/
+function createUuid() {
+	const source = randomSource();
+	if (typeof source?.randomUUID === "function") return source.randomUUID();
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	if (typeof source?.getRandomValues === "function") source.getRandomValues(bytes);
+	else for (let index = 0; index < bytes.length; index += 1) bytes[index] = Math.floor(Math.random() * 256);
+	bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return [
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		hex.slice(12, 16),
+		hex.slice(16, 20),
+		hex.slice(20)
+	].join("-");
+}
+function randomSource() {
+	return globalThis.crypto;
+}
+/** Fresh UUID v4 that no element of `kind` uses yet. */
+var defaultElementIdFactory = (kind, document) => {
+	const used = usedIds(document, kind);
+	let id = createUuid();
+	while (used.has(id)) id = createUuid();
+	return id;
+};
+//#endregion
+//#region src/schematic/edit/commands.ts
+/**
+* Applies an edit command to a copy of `document`.
+*
+* @throws {SchematicError} when the command is invalid; the input document is never mutated.
+*/
+function applySchematicCommand(document, command, options = {}) {
+	const symbols = [...document.sheet.symbols];
+	const wires = [...document.sheet.wires];
+	const junctions = [...document.sheet.junctions];
+	const diagnostics = [];
+	const effects = [];
+	const createId = options.createId ?? defaultElementIdFactory;
+	const draft = () => ({
+		...document,
+		sheet: {
+			symbols,
+			wires,
+			junctions
+		}
+	});
+	switch (command.type) {
+		case "add-symbol": {
+			const device = requireDevice(command.device, diagnostics);
+			const id = command.id ?? createId("symbol", draft());
+			const properties = normalizeProperties(command.properties, deviceDescriptors(device, options), diagnostics);
+			const reference = resolveReference(command.reference, void 0, ["sheet", "symbols"], diagnostics);
+			if (device !== void 0) {
+				const role = symbolRole(device);
+				const designator = resolveDesignator(command.designator, role, id, diagnostics);
+				const net = resolveNet(command.net, role, diagnostics);
+				symbols.push(withProperties({
+					id,
+					device,
+					x: command.x,
+					y: command.y,
+					rotation: command.rotation ?? 0,
+					...designator === void 0 ? {} : { designator },
+					...net === void 0 ? {} : { net },
+					...hasDesignator(role) && reference !== void 0 ? { reference } : {}
+				}, properties));
+			}
+			break;
+		}
+		case "update-symbol": {
+			const index = findIndex(symbols, command.id, "symbol", diagnostics);
+			const current = index === -1 ? void 0 : symbols[index];
+			if (current !== void 0) {
+				const device = command.device === void 0 ? current.device : requireDevice(command.device, diagnostics);
+				const properties = command.properties === void 0 ? current.properties : normalizeProperties(command.properties, deviceDescriptors(device, options), diagnostics);
+				const reference = resolveReference(command.reference, current.reference, [
+					"sheet",
+					"symbols",
+					String(index)
+				], diagnostics);
+				if (device !== void 0) {
+					const role = symbolRole(device);
+					const designator = resolveOptionalText(command.designator, current.designator, hasDesignator(role), "designator", diagnostics);
+					const net = resolveOptionalText(command.net, current.net, namesNet(role), "net", diagnostics);
+					symbols[index] = withProperties({
+						id: current.id,
+						device,
+						x: command.x ?? current.x,
+						y: command.y ?? current.y,
+						rotation: command.rotation ?? current.rotation,
+						...designator === void 0 ? {} : { designator },
+						...net === void 0 ? {} : { net },
+						...hasDesignator(role) && reference !== void 0 ? { reference } : {}
+					}, properties);
+				}
+			}
+			break;
+		}
+		case "remove-symbol": {
+			const index = findIndex(symbols, command.id, "symbol", diagnostics);
+			if (index !== -1) symbols.splice(index, 1);
+			break;
+		}
+		case "set-symbol-property": {
+			const index = findIndex(symbols, command.id, "symbol", diagnostics);
+			const current = index === -1 ? void 0 : symbols[index];
+			if (current !== void 0) {
+				const value = checkPropertyValue(command.key, command.value, deviceDescriptors(current.device, options)?.get(command.key), diagnostics);
+				if (value !== void 0) symbols[index] = withProperties(baseOf(current), {
+					...current.properties ?? {},
+					[command.key]: value
+				});
+			}
+			break;
+		}
+		case "remove-symbol-property": {
+			const index = findIndex(symbols, command.id, "symbol", diagnostics);
+			const current = index === -1 ? void 0 : symbols[index];
+			if (current !== void 0) {
+				const properties = { ...current.properties ?? {} };
+				if (!Object.prototype.hasOwnProperty.call(properties, command.key)) diagnostics.push({
+					severity: "error",
+					code: "edit/unknown-entity",
+					message: `Symbol "${current.id}" has no property ${JSON.stringify(command.key)}.`,
+					entity: {
+						kind: "symbol",
+						id: current.id
+					}
+				});
+				else {
+					delete properties[command.key];
+					symbols[index] = withProperties(baseOf(current), properties);
+				}
+			}
+			break;
+		}
+		case "add-wire": {
+			const wire = makeWire(command.id ?? createId("wire", draft()), command.points, diagnostics);
+			if (wire !== void 0) wires.push(wire);
+			break;
+		}
+		case "set-wire-points": {
+			const index = findIndex(wires, command.id, "wire", diagnostics);
+			if (index !== -1) {
+				const wire = makeWire(command.id, command.points, diagnostics);
+				if (wire !== void 0) wires[index] = wire;
+			}
+			break;
+		}
+		case "remove-wire": {
+			const index = findIndex(wires, command.id, "wire", diagnostics);
+			if (index !== -1) {
+				wires.splice(index, 1);
+				for (let junctionIndex = junctions.length - 1; junctionIndex >= 0; junctionIndex -= 1) {
+					const junction = junctions[junctionIndex];
+					if (junction === void 0 || !junction.wires.includes(command.id)) continue;
+					effects.push({
+						kind: "junction-removed",
+						id: junction.id,
+						reason: "wire-removed"
+					});
+					junctions.splice(junctionIndex, 1);
+				}
+			}
+			break;
+		}
+		case "add-junction": {
+			const junction = makeJunction(command.id ?? createId("junction", draft()), command.x, command.y, command.wires, diagnostics);
+			if (junction !== void 0) junctions.push(junction);
+			break;
+		}
+		case "update-junction": {
+			const index = findIndex(junctions, command.id, "junction", diagnostics);
+			const current = index === -1 ? void 0 : junctions[index];
+			if (current !== void 0) {
+				const junction = makeJunction(current.id, command.x ?? current.x, command.y ?? current.y, command.wires ?? current.wires, diagnostics);
+				if (junction !== void 0) junctions[index] = junction;
+			}
+			break;
+		}
+		case "remove-junction": {
+			const index = findIndex(junctions, command.id, "junction", diagnostics);
+			if (index !== -1) junctions.splice(index, 1);
+			break;
+		}
+		default: diagnostics.push({
+			severity: "error",
+			code: "edit/invalid-command",
+			message: `Unsupported command ${JSON.stringify(command.type)}.`
+		});
+	}
+	throwIfErrors(diagnostics);
+	const result = validateSheet(draft(), options, diagnostics, effects);
+	throwIfErrors(diagnostics);
+	for (const effect of effects) options.onEffect?.(effect);
+	return result;
+}
+function validateSheet(candidate, options, diagnostics, effects) {
+	const parsed = parseSchematic(candidate);
+	const tolerance = options.tolerance ?? 0;
+	const wireById = new Map(parsed.sheet.wires.map((wire) => [wire.id, wire]));
+	const survivingJunctions = [];
+	let cascaded = false;
+	for (const junction of parsed.sheet.junctions) {
+		if (!junction.wires.some((wireId) => {
+			const wire = wireById.get(wireId);
+			return wire === void 0 || !pointOnPolyline(wire.points, {
+				x: junction.x,
+				y: junction.y
+			}, tolerance);
+		})) {
+			survivingJunctions.push(junction);
+			continue;
+		}
+		if (options.onJunctionConflict === "remove") {
+			cascaded = true;
+			effects.push({
+				kind: "junction-removed",
+				id: junction.id,
+				reason: "junction-detached"
+			});
+			continue;
+		}
+		diagnostics.push({
+			severity: "error",
+			code: "junction/off-wire",
+			message: `Junction "${junction.id}" no longer lies on every referenced wire.`,
+			pointer: toPointer(["sheet", "junctions"]),
+			entity: {
+				kind: "junction",
+				id: junction.id
+			}
+		});
+	}
+	if (!cascaded) return parsed;
+	return {
+		...parsed,
+		sheet: {
+			...parsed.sheet,
+			junctions: survivingJunctions
+		}
+	};
+}
+function makeWire(id, points, diagnostics) {
+	if (points.length < 2) {
+		diagnostics.push({
+			severity: "error",
+			code: "wire/invalid-points",
+			message: `Wire "${id}" must contain at least two points.`,
+			entity: {
+				kind: "wire",
+				id
+			}
+		});
+		return;
+	}
+	return {
+		id,
+		points: points.map((point) => ({
+			x: point.x,
+			y: point.y
+		}))
+	};
+}
+function makeJunction(id, x, y, wires, diagnostics) {
+	if (wires.length < 2) {
+		diagnostics.push({
+			severity: "error",
+			code: "schema/invalid-value",
+			message: `Junction "${id}" must reference at least two wires.`,
+			entity: {
+				kind: "junction",
+				id
+			}
+		});
+		return;
+	}
+	return {
+		id,
+		x,
+		y,
+		wires: [...wires]
+	};
+}
+function requireDevice(device, diagnostics) {
+	if (parseDeviceReference(device) === void 0) {
+		diagnostics.push({
+			severity: "error",
+			code: "device/invalid-reference",
+			message: `Invalid device reference ${JSON.stringify(device)}.`
+		});
+		return;
+	}
+	return device;
+}
+function baseOf(symbol) {
+	return {
+		id: symbol.id,
+		device: symbol.device,
+		x: symbol.x,
+		y: symbol.y,
+		rotation: symbol.rotation,
+		...symbol.designator === void 0 ? {} : { designator: symbol.designator },
+		...symbol.net === void 0 ? {} : { net: symbol.net }
+	};
+}
+/**
+* Reference designator for a new symbol: components keep `undefined` (the id doubles as the
+* default designator), everything else must not have one.
+*/
+function resolveDesignator(value, role, id, diagnostics) {
+	if (!hasDesignator(role)) {
+		if (value !== void 0) diagnostics.push({
+			severity: "error",
+			code: "symbol/unsupported-field",
+			message: `Symbols of role "${role}" carry no reference designator.`
+		});
+		return;
+	}
+	const trimmed = value?.trim();
+	return trimmed === void 0 || trimmed.length === 0 || trimmed === id ? void 0 : trimmed;
+}
+/** Net name for a new symbol; labels need one, power and ground fall back to their default. */
+function resolveNet(value, role, diagnostics) {
+	if (!namesNet(role)) {
+		if (value !== void 0) diagnostics.push({
+			severity: "error",
+			code: "symbol/unsupported-field",
+			message: `Symbols of role "${role}" name no net.`
+		});
+		return;
+	}
+	const trimmed = value?.trim();
+	if (trimmed !== void 0 && trimmed.length > 0) return trimmed;
+	const fallback = defaultNetName(role);
+	if (fallback === void 0) diagnostics.push({
+		severity: "error",
+		code: "symbol/missing-net",
+		message: `Symbols of role "${role}" must name the net they attach to.`
+	});
+	return fallback;
+}
+/** `null` clears the field, `undefined` keeps it, and unsupported roles cannot set it. */
+function resolveOptionalText(value, current, supported, field, diagnostics) {
+	if (value === void 0) return current;
+	if (!supported) {
+		diagnostics.push({
+			severity: "error",
+			code: "symbol/unsupported-field",
+			message: `This symbol must not declare "${field}".`
+		});
+		return;
+	}
+	if (value === null) return;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) {
+		diagnostics.push({
+			severity: "error",
+			code: "schema/invalid-value",
+			message: `${field === "net" ? "Net name" : "Reference designator"} must not be empty.`
+		});
+		return;
+	}
+	return trimmed;
+}
+function withProperties(symbol, properties) {
+	if (properties === void 0 || Object.keys(properties).length === 0) return symbol;
+	return {
+		...symbol,
+		properties
+	};
+}
+/** `reference: null` clears the override and falls back to the default anchor. */
+function resolveReference(value, current, path, diagnostics) {
+	if (value === void 0) return current;
+	if (value === null) return;
+	if (typeof value !== "object" || !Number.isFinite(value.x) || !Number.isFinite(value.y)) {
+		diagnostics.push({
+			severity: "error",
+			code: "schema/invalid-value",
+			message: "Symbol reference must contain finite x and y numbers.",
+			pointer: toPointer([...path, "reference"])
+		});
+		return;
+	}
+	return {
+		x: value.x,
+		y: value.y
+	};
+}
+/** Property descriptors of `device`, when the caller supplied a device registry (#7). */
+function deviceDescriptors(device, options) {
+	const reference = device === void 0 ? void 0 : parseDeviceReference(device);
+	return reference === void 0 ? void 0 : options.devices?.getDevicePropertyDescriptors?.(reference);
+}
+function normalizeProperties(properties, descriptors, diagnostics) {
+	if (properties === void 0) return;
+	const normalized = {};
+	for (const [key, value] of Object.entries(properties)) {
+		if (key.length === 0) {
+			diagnostics.push({
+				severity: "error",
+				code: "schema/invalid-value",
+				message: "Property keys must not be empty."
+			});
+			continue;
+		}
+		const checked = checkPropertyValue(key, value, descriptors?.get(key), diagnostics);
+		if (checked !== void 0) normalized[key] = checked;
+	}
+	return normalized;
+}
+function checkPropertyValue(key, value, descriptor, diagnostics) {
+	if (key.length === 0) {
+		diagnostics.push({
+			severity: "error",
+			code: "schema/invalid-value",
+			message: "Property keys must not be empty."
+		});
+		return;
+	}
+	if (descriptor !== void 0) {
+		const problem = propertyValueProblem(descriptor, value);
+		if (problem !== void 0) {
+			diagnostics.push({
+				severity: "error",
+				code: problem.code,
+				message: problem.message
+			});
+			return;
+		}
+		return normalizePropertyValue(descriptor, value);
+	}
+	if (typeof value === "string" || typeof value === "boolean" || value === null) return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			diagnostics.push({
+				severity: "error",
+				code: "schema/invalid-value",
+				message: `Property "${key}" must be a finite number.`
+			});
+			return;
+		}
+		return value;
+	}
+	if (isAssetReference(value)) return value;
+	diagnostics.push({
+		severity: "error",
+		code: "schema/invalid-value",
+		message: `Property "${key}" must be a string, finite number, boolean, resource reference or null.`
+	});
+}
+function findIndex(items, id, kind, diagnostics) {
+	const index = items.findIndex((item) => item.id === id);
+	if (index === -1) diagnostics.push({
+		severity: "error",
+		code: "edit/unknown-entity",
+		message: `Unknown ${kind} "${id}".`,
+		entity: {
+			kind,
+			id
+		}
+	});
+	return index;
+}
+//#endregion
+//#region src/schematic/edit/junctions.ts
+/**
+* Junctions that must let go of `wireId`: its new geometry no longer passes through them.
+*
+* A junction left with fewer than two wires is dropped instead of being kept dangling. Pure
+* geometry: the caller applies the resulting commands.
+*/
+function planJunctionRelease(document, wireId, points, options = {}) {
+	const tolerance = options.tolerance ?? 0;
+	const releases = [];
+	for (const junction of document.sheet.junctions) {
+		if (!junction.wires.includes(wireId)) continue;
+		if (pointOnPolyline(points, {
+			x: junction.x,
+			y: junction.y
+		}, tolerance)) continue;
+		const remaining = junction.wires.filter((id) => id !== wireId);
+		releases.push({
+			id: junction.id,
+			wires: remaining.length < 2 ? void 0 : remaining
+		});
+	}
+	return releases;
+}
+/**
+* The junction sitting exactly at `point`, extended with `wireId`, so a wire that ends on an
+* existing junction actually joins it. `undefined` when there is nothing to join.
+*/
+function joinJunctionAt(document, wireId, point) {
+	const junction = document.sheet.junctions.find((candidate) => candidate.x === point.x && candidate.y === point.y);
+	if (junction === void 0 || junction.wires.includes(wireId)) return;
+	return {
+		id: junction.id,
+		wires: [...junction.wires, wireId]
+	};
+}
+//#endregion
+//#region src/schematic/edit/wires.ts
+/**
+* Splits `wireId` at `point`, which must lie strictly inside the polyline.
+* Junctions that only touch the second half are re-pointed to the new wire.
+*
+* @throws {SchematicError} when the wire is unknown or `point` is not an interior point.
+*/
+function splitWireAt(document, wireId, point, options = {}) {
+	const tolerance = options.tolerance ?? 0;
+	const wire = document.sheet.wires.find((candidate) => candidate.id === wireId);
+	if (wire === void 0) throw new SchematicError([{
+		severity: "error",
+		code: "edit/unknown-entity",
+		message: `Unknown wire "${wireId}".`,
+		entity: {
+			kind: "wire",
+			id: wireId
+		}
+	}]);
+	const split = splitPoints(wire.points, point, tolerance);
+	if (split === void 0) throw new SchematicError([{
+		severity: "error",
+		code: "wire/invalid-points",
+		message: `Point (${point.x}, ${point.y}) is not an interior point of wire "${wireId}".`,
+		entity: {
+			kind: "wire",
+			id: wireId
+		}
+	}]);
+	const firstWireId = wireId;
+	const secondWireId = options.createId?.("wire", document) ?? defaultElementIdFactory("wire", document);
+	if (secondWireId === firstWireId) throw new SchematicError([{
+		severity: "error",
+		code: "edit/invalid-command",
+		message: `Generated wire id "${secondWireId}" collides with the split wire.`,
+		entity: {
+			kind: "wire",
+			id: wireId
+		}
+	}]);
+	const [firstPoints, secondPoints] = split;
+	const wires = [];
+	for (const candidate of document.sheet.wires) {
+		if (candidate.id !== wireId) {
+			wires.push(candidate);
+			continue;
+		}
+		wires.push({
+			id: firstWireId,
+			points: firstPoints
+		});
+		wires.push({
+			id: secondWireId,
+			points: secondPoints
+		});
+	}
+	const junctions = document.sheet.junctions.map((junction) => remapJunction(junction, wireId, firstWireId, secondWireId, firstPoints, secondPoints, point, tolerance));
+	return {
+		document: validate({
+			...document,
+			sheet: {
+				...document.sheet,
+				wires,
+				junctions
+			}
+		}),
+		firstWireId,
+		secondWireId
+	};
+}
+/**
+* Merges the two collinear wires meeting at `junctionId` into one wire and removes the junction.
+* Returns `undefined` when the junction does not describe such a splice.
+*
+* @throws {SchematicError} when the junction is unknown.
+*/
+function mergeWiresAtJunction(document, junctionId, options = {}) {
+	const tolerance = options.tolerance ?? 0;
+	const junction = document.sheet.junctions.find((candidate) => candidate.id === junctionId);
+	if (junction === void 0) throw new SchematicError([{
+		severity: "error",
+		code: "edit/unknown-entity",
+		message: `Unknown junction "${junctionId}".`,
+		entity: {
+			kind: "junction",
+			id: junctionId
+		}
+	}]);
+	if (junction.wires.length !== 2) return;
+	const [firstId, secondId] = junction.wires;
+	const first = document.sheet.wires.find((wire) => wire.id === firstId);
+	const second = document.sheet.wires.find((wire) => wire.id === secondId);
+	if (first === void 0 || second === void 0) return;
+	const merged = mergePoints(first.points, second.points, junction, tolerance);
+	if (merged === void 0) return;
+	const wires = [];
+	for (const candidate of document.sheet.wires) {
+		if (candidate.id === secondId) continue;
+		wires.push(candidate.id === firstId ? {
+			id: firstId,
+			points: merged
+		} : candidate);
+	}
+	const junctions = document.sheet.junctions.filter((candidate) => candidate.id !== junctionId).map((candidate) => candidate.wires.includes(secondId) ? {
+		...candidate,
+		wires: candidate.wires.map((id) => id === secondId ? firstId : id)
+	} : candidate);
+	return {
+		document: validate({
+			...document,
+			sheet: {
+				...document.sheet,
+				wires,
+				junctions
+			}
+		}),
+		wireId: firstId,
+		removedWireId: secondId,
+		removedJunctionId: junctionId
+	};
+}
+function validate(document) {
+	return parseSchematic(document);
+}
+function splitPoints(points, point, tolerance) {
+	const first = points[0];
+	const last = points[points.length - 1];
+	if (first === void 0 || last === void 0) return;
+	if (pointsEqual(first, point, tolerance) || pointsEqual(last, point, tolerance)) return;
+	if (!pointOnPolyline(points, point, tolerance)) return;
+	for (let index = 1; index < points.length; index += 1) {
+		const previous = points[index - 1];
+		const current = points[index];
+		if (previous === void 0 || current === void 0) continue;
+		if (!pointOnPolyline([previous, current], point, tolerance)) continue;
+		return [[...points.slice(0, index), {
+			x: point.x,
+			y: point.y
+		}], [{
+			x: point.x,
+			y: point.y
+		}, ...points.slice(index)]];
+	}
+}
+function remapJunction(junction, wireId, firstWireId, secondWireId, firstPoints, secondPoints, splitPoint, tolerance) {
+	if (!junction.wires.includes(wireId)) return junction;
+	const point = {
+		x: junction.x,
+		y: junction.y
+	};
+	if (pointsEqual(point, splitPoint, tolerance)) {
+		const others = junction.wires.filter((id) => id !== wireId);
+		return {
+			...junction,
+			wires: [
+				firstWireId,
+				secondWireId,
+				...others
+			]
+		};
+	}
+	const onFirst = pointOnPolyline(firstPoints, point, tolerance);
+	const onSecond = pointOnPolyline(secondPoints, point, tolerance);
+	if (onFirst && !onSecond) return junction;
+	if (onSecond && !onFirst) return {
+		...junction,
+		wires: junction.wires.map((id) => id === wireId ? secondWireId : id)
+	};
+	return junction;
+}
+function mergePoints(first, second, junction, tolerance) {
+	const at = {
+		x: junction.x,
+		y: junction.y
+	};
+	const firstStart = first[0];
+	const firstEnd = first[first.length - 1];
+	const secondStart = second[0];
+	const secondEnd = second[second.length - 1];
+	if (firstStart === void 0 || firstEnd === void 0 || secondStart === void 0 || secondEnd === void 0) return;
+	const firstStartsAt = pointsEqual(firstStart, at, tolerance);
+	const firstEndsAt = pointsEqual(firstEnd, at, tolerance);
+	const secondStartsAt = pointsEqual(secondStart, at, tolerance);
+	const secondEndsAt = pointsEqual(secondEnd, at, tolerance);
+	let head;
+	let tail;
+	if (firstEndsAt && secondStartsAt) {
+		head = first;
+		tail = second;
+	} else if (secondEndsAt && firstStartsAt) {
+		head = second;
+		tail = first;
+	} else if (firstEndsAt && secondEndsAt) {
+		head = first;
+		tail = [...second].reverse();
+	} else if (firstStartsAt && secondStartsAt) {
+		head = [...first].reverse();
+		tail = second;
+	}
+	if (head === void 0 || tail === void 0 || !isContinuous(head, tail)) return;
+	return [...head, ...tail.slice(1)];
+}
+/** True when the last segment of `a` and the first segment of `b` are collinear. */
+function isContinuous(a, b) {
+	const a1 = a[a.length - 2];
+	const a2 = a[a.length - 1];
+	const b1 = b[0];
+	const b2 = b[1];
+	if (a1 === void 0 || a2 === void 0 || b1 === void 0 || b2 === void 0) return false;
+	const ax = a2.x - a1.x;
+	const ay = a2.y - a1.y;
+	const bx = b2.x - b1.x;
+	const by = b2.y - b1.y;
+	const cross = ax * by - ay * bx;
+	const scale = Math.hypot(ax, ay) * Math.hypot(bx, by);
+	if (scale === 0) return false;
+	return Math.abs(cross) / scale <= 1e-9 && ax * bx + ay * by > 0;
+}
+//#endregion
+//#region src/schematic/geometry/reroute.ts
+/**
+* Moves a wire endpoint to `to` while keeping every segment horizontal or vertical.
+*
+* The displacement is absorbed segment by segment (the classic orthogonal drag): the point after
+* the moved end is shifted just enough to restore the original orientation, and the correction is
+* passed on until a segment can take it. No extra points are inserted, so the wire never doubles
+* back on itself.
+*/
+function rerouteWireEndpoint(wire, from, to) {
+	const points = wire.points;
+	const first = points[0];
+	const last = points[points.length - 1];
+	if (first === void 0 || last === void 0) return;
+	if (samePoint$1(first, from)) return rerouteFrom(points, to, "start");
+	if (samePoint$1(last, from)) return rerouteFrom(points, to, "end");
+}
+function rerouteFrom(points, target, end) {
+	const next = points.map((point) => ({
+		x: point.x,
+		y: point.y
+	}));
+	const first = next[0];
+	const last = next[next.length - 1];
+	if (first === void 0 || last === void 0) return {
+		points: next,
+		moves: []
+	};
+	if (end === "start") {
+		next[0] = {
+			x: target.x,
+			y: target.y
+		};
+		for (let index = 0; index < next.length - 1; index += 1) {
+			const a = next[index];
+			const b = next[index + 1];
+			if (a === void 0 || b === void 0 || a.x === b.x || a.y === b.y) break;
+			const horizontal = points[index]?.y === points[index + 1]?.y;
+			next[index + 1] = horizontal ? {
+				x: b.x,
+				y: a.y
+			} : {
+				x: a.x,
+				y: b.y
+			};
+		}
+	} else {
+		next[next.length - 1] = {
+			x: target.x,
+			y: target.y
+		};
+		for (let index = next.length - 1; index > 0; index -= 1) {
+			const a = next[index - 1];
+			const b = next[index];
+			if (a === void 0 || b === void 0 || a.x === b.x || a.y === b.y) break;
+			const horizontal = points[index - 1]?.y === points[index]?.y;
+			next[index - 1] = horizontal ? {
+				x: a.x,
+				y: b.y
+			} : {
+				x: b.x,
+				y: a.y
+			};
+		}
+	}
+	const moves = [];
+	for (let index = 0; index < points.length; index += 1) {
+		const before = points[index];
+		const after = next[index];
+		if (before !== void 0 && after !== void 0 && !samePoint$1(before, after)) moves.push({
+			from: before,
+			to: after
+		});
+	}
+	return {
+		points: dropRepeatedPoints(next),
+		moves
+	};
+}
+function dropRepeatedPoints(points) {
+	const result = [];
+	for (const point of points) {
+		const previous = result[result.length - 1];
+		if (previous === void 0 || !samePoint$1(previous, point)) result.push(point);
+	}
+	return result.length >= 2 ? result : points;
+}
+/**
+* Moves a wire endpoint to `to` by stretching or bending it, leaving the original run in place.
+*
+* Unlike {@link rerouteWireEndpoint}, which absorbs the move by shifting the neighbouring points,
+* this keeps every existing point: a move along the attached segment only changes its length, and a
+* perpendicular move appends an orthogonal fold at the moved end. That is the behaviour net labels
+* and power ports need while being dragged — the wire follows them instead of sliding away.
+*/
+function stretchWireEndpoint(wire, from, to) {
+	const points = wire.points;
+	const first = points[0];
+	const last = points[points.length - 1];
+	if (first === void 0 || last === void 0) return;
+	if (samePoint$1(first, from)) return stretchAt(points, to, "start");
+	if (samePoint$1(last, from)) return stretchAt(points, to, "end");
+}
+function stretchAt(points, target, end) {
+	const anchor = end === "start" ? points[0] : points[points.length - 1];
+	const neighbor = end === "start" ? points[1] : points[points.length - 2];
+	if (anchor === void 0) return {
+		points,
+		moves: []
+	};
+	if (neighbor === void 0) {
+		const next = points.map((point) => ({
+			x: point.x,
+			y: point.y
+		}));
+		if (end === "start") next[0] = {
+			x: target.x,
+			y: target.y
+		};
+		else next[next.length - 1] = {
+			x: target.x,
+			y: target.y
+		};
+		return {
+			points: next,
+			moves: [{
+				from: anchor,
+				to: target
+			}]
+		};
+	}
+	const horizontal = neighbor.y === anchor.y;
+	if (!(horizontal ? target.y !== anchor.y : target.x !== anchor.x)) {
+		const next = points.map((point) => ({
+			x: point.x,
+			y: point.y
+		}));
+		if (end === "start") next[0] = {
+			x: target.x,
+			y: target.y
+		};
+		else next[next.length - 1] = {
+			x: target.x,
+			y: target.y
+		};
+		return {
+			points: dropRepeatedPoints(next),
+			moves: [{
+				from: anchor,
+				to: target
+			}]
+		};
+	}
+	const elbow = horizontal ? {
+		x: anchor.x,
+		y: target.y
+	} : {
+		x: target.x,
+		y: anchor.y
+	};
+	const turn = samePoint$1(elbow, target) ? [] : [elbow];
+	return {
+		points: dropRepeatedPoints(end === "start" ? [
+			target,
+			...turn,
+			...points
+		] : [
+			...points,
+			...turn,
+			target
+		]),
+		moves: []
+	};
+}
+function samePoint$1(left, right) {
+	return left.x === right.x && left.y === right.y;
+}
+//#endregion
+//#region src/schematic/device/synthesis.ts
+var DEFAULT_PIN_SIDE = "left";
+/** Half height of a centred glyph box, in `characterWidth` units. */
+var NAME_HALF_EXTENT = 1;
+/**
+* Derives symbol geometry from pin declarations: no coordinates or body size are authored.
+* Pins keep their declaration order within a side and snap to `pinPitch`.
+*/
+function synthesizeDeviceSymbol(input, options = {}) {
+	const pinPitch = options.pinPitch ?? 10;
+	const stubLength = options.stubLength ?? 10;
+	const minWidth = options.minWidth ?? 60;
+	const minHeight = options.minHeight ?? 40;
+	const horizontalPadding = options.horizontalPadding ?? 10;
+	const verticalPadding = options.verticalPadding ?? 10;
+	const characterWidth = options.characterWidth ?? 5.5;
+	const labelCharacterWidth = options.labelCharacterWidth ?? 4.5;
+	const nameGap = options.nameGap ?? 12;
+	const labelInset = options.labelInset ?? 10;
+	const sides = {
+		left: [],
+		right: [],
+		top: [],
+		bottom: []
+	};
+	for (const [pinId, declaration] of Object.entries(input.pins)) sides[declaration.side ?? DEFAULT_PIN_SIDE].push(pinId);
+	const rows = Math.max(sides.left.length, sides.right.length);
+	const columns = Math.max(sides.top.length, sides.bottom.length);
+	const height = Math.max(minHeight, verticalPadding * 2 + Math.max(rows - 1, 0) * pinPitch + pinPitch, 2 * (NAME_HALF_EXTENT * characterWidth + pinPitch / 2 + labelInset + rotatedHalf(sides, labelCharacterWidth)));
+	const width = Math.max(minWidth, horizontalPadding * 2 + Math.max(columns - 1, 0) * pinPitch + pinPitch);
+	const contentWidth = (longest(sides.left) + longest(sides.right)) * labelCharacterWidth + input.name.length * characterWidth + horizontalPadding * 2 + nameGap * 2;
+	const bodyWidth = Math.ceil(Math.max(width, contentWidth) / pinPitch) * pinPitch;
+	const bodyHeight = Math.ceil(height / pinPitch) * pinPitch;
+	const body = {
+		x: -bodyWidth / 2,
+		y: -bodyHeight / 2,
+		width: bodyWidth,
+		height: bodyHeight
+	};
+	const pins = Object.create(null);
+	const placeVertical = (pinIds, side) => {
+		const start = -((pinIds.length - 1) * pinPitch) / 2;
+		pinIds.forEach((pinId, index) => {
+			const y = start + index * pinPitch;
+			const x = side === "left" ? body.x - stubLength : body.x + body.width + stubLength;
+			pins[pinId] = {
+				x,
+				y,
+				side
+			};
+		});
+	};
+	placeVertical(sides.left, "left");
+	placeVertical(sides.right, "right");
+	const placeHorizontal = (pinIds, side) => {
+		const start = -((pinIds.length - 1) * pinPitch) / 2;
+		pinIds.forEach((pinId, index) => {
+			const x = start + index * pinPitch;
+			const y = side === "top" ? body.y - stubLength : body.y + body.height + stubLength;
+			pins[pinId] = {
+				x,
+				y,
+				side
+			};
+		});
+	};
+	placeHorizontal(sides.top, "top");
+	placeHorizontal(sides.bottom, "bottom");
+	return {
+		name: input.name,
+		pins,
+		bounds: body
+	};
+}
+function longest(pinIds) {
+	return pinIds.reduce((max, pinId) => Math.max(max, pinId.length), 0);
+}
+function rotatedHalf(sides, characterWidth) {
+	return Math.max(longest(sides.top), longest(sides.bottom)) * characterWidth / 2;
+}
+//#endregion
+//#region src/schematic/device/symbol.ts
+/** Bounding box of a device's pins; `undefined` when it declares none. */
+function pinsBounds(pins) {
+	const points = Object.values(pins);
+	if (points.length === 0) return;
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of points) {
+		minX = Math.min(minX, point.x);
+		minY = Math.min(minY, point.y);
+		maxX = Math.max(maxX, point.x);
+		maxY = Math.max(maxY, point.y);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+/** Side a pin is drawn on: its declared side, else the closest edge of the body outline. */
+function pinSide(pin, outline) {
+	if (pin.side !== void 0) return pin.side;
+	if (outline === void 0) return;
+	const dx = (pin.x - (outline.x + outline.width / 2)) / Math.max(outline.width / 2, 1e-6);
+	const dy = (pin.y - (outline.y + outline.height / 2)) / Math.max(outline.height / 2, 1e-6);
+	if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
+	return dy >= 0 ? "bottom" : "top";
+}
+/**
+* Inner end of a pin stub, where it meets the body outline. Together with the anchor it forms the
+* grabbable pin: rendering draws that line and hit testing accepts clicks anywhere along it.
+*/
+function pinStubEnd(body, anchor, side) {
+	switch (side) {
+		case "left": return {
+			x: body.x,
+			y: anchor.y
+		};
+		case "right": return {
+			x: body.x + body.width,
+			y: anchor.y
+		};
+		case "top": return {
+			x: anchor.x,
+			y: body.y
+		};
+		case "bottom": return {
+			x: anchor.x,
+			y: body.y + body.height
+		};
+	}
+}
+//#endregion
+//#region src/schematic/device/metadata.ts
+var fail = (path, diagnostics, message) => {
+	diagnostics.push({
+		severity: "error",
+		code: "device/invalid-description",
+		pointer: path,
+		message
+	});
+};
+var text = (v, p, d) => {
+	if (typeof v !== "string") fail(p, d, "Expected a string.");
+};
+var nonempty = (v, p, d) => {
+	if (typeof v !== "string" || v.length === 0) fail(p, d, "Expected a nonempty string.");
+};
+var number = (v, p, d) => {
+	if (typeof v !== "number" || !Number.isFinite(v)) fail(p, d, "Expected a finite number.");
+};
+var positive = (v, p, d) => {
+	number(v, p, d);
+	if (typeof v === "number" && v <= 0) fail(p, d, "Expected a positive number.");
+};
+var boolean = (v, p, d) => {
+	if (typeof v !== "boolean") fail(p, d, "Expected a boolean.");
+};
+var choice = (...values) => (v, p, d) => {
+	if (!values.includes(v)) fail(p, d, `Expected one of ${values.join(", ")}.`);
+};
+var pointer = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
+var object = (fields, required = []) => (v, p, d) => {
+	if (!isRecord(v)) {
+		fail(p, d, "Expected an object.");
+		return;
+	}
+	for (const key of required) if (!Object.hasOwn(v, key)) fail(`${p}/${pointer(key)}`, d, "Required field is missing.");
+	for (const [key, value] of Object.entries(v)) {
+		const check = Object.hasOwn(fields, key) ? fields[key] : void 0;
+		if (check === void 0) fail(`${p}/${pointer(key)}`, d, "Unknown field.");
+		else check(value, `${p}/${pointer(key)}`, d);
+	}
+};
+var map = (check) => (v, p, d) => {
+	if (!isRecord(v)) {
+		fail(p, d, "Expected a map.");
+		return;
+	}
+	for (const [key, value] of Object.entries(v)) check(value, `${p}/${pointer(key)}`, d);
+};
+var tuple = (v, p, d) => {
+	if (!Array.isArray(v) || v.length !== 2) {
+		fail(p, d, "Expected two coordinates.");
+		return;
+	}
+	v.forEach((value, index) => number(value, `${p}/${index}`, d));
+};
+var strings = (v, p, d) => {
+	if (!Array.isArray(v)) {
+		fail(p, d, "Expected an array.");
+		return;
+	}
+	v.forEach((value, index) => nonempty(value, `${p}/${index}`, d));
+	if (new Set(v).size !== v.length) fail(p, d, "Values must be unique.");
+};
+var align = choice("left", "center", "right");
+var label = object({
+	visible: boolean,
+	position: tuple,
+	align
+}, ["visible"]);
+var editor = (v, p, d) => {
+	const fields = { kind: choice("number", "text", "textarea", "checkbox", "file", "select") };
+	if (isRecord(v) && v.kind === "number") Object.assign(fields, {
+		min: number,
+		max: number,
+		step: positive
+	});
+	if (isRecord(v) && v.kind === "select") fields.labels = map(text);
+	object(fields, ["kind"])(v, p, d);
+};
+var property = (v, p, d) => {
+	object({
+		type: choice("number", "boolean", "string", "enum", "bytes"),
+		required: boolean,
+		nullable: boolean,
+		default: () => {},
+		enumName: nonempty,
+		values: strings,
+		title: text,
+		description: text,
+		unit: text,
+		group: text,
+		order: (value, path, diagnostics) => {
+			if (typeof value !== "number" || !Number.isInteger(value) || value < 0) fail(path, diagnostics, "Expected a nonnegative integer.");
+		},
+		editor
+	}, ["type", "required"])(v, p, d);
+	if (!isRecord(v)) return;
+	if (v.required === true && Object.hasOwn(v, "default")) fail(`${p}/default`, d, "Required properties cannot declare defaults.");
+	if (v.type === "enum") {
+		if (!Object.hasOwn(v, "enumName") || !Object.hasOwn(v, "values")) fail(p, d, "Enum properties require enumName and values.");
+		if (Array.isArray(v.values) && v.values.length === 0) fail(`${p}/values`, d, "Enum values cannot be empty.");
+	} else if (Object.hasOwn(v, "enumName") || Object.hasOwn(v, "values")) fail(p, d, "Only enum properties declare enumName and values.");
+};
+var graphic = (v, p, d) => {
+	const common = {
+		type: choice("line", "polyline", "rect", "circle", "arc", "text"),
+		fill: choice("none", "foreground", "background"),
+		strokeWidth: positive
+	};
+	const variants = {
+		line: {
+			fields: {
+				from: tuple,
+				to: tuple
+			},
+			required: ["from", "to"]
+		},
+		polyline: {
+			fields: {
+				points: (value, path, diagnostics) => {
+					if (!Array.isArray(value) || value.length < 2) {
+						fail(path, diagnostics, "Expected at least two points.");
+						return;
+					}
+					value.forEach((point, index) => tuple(point, `${path}/${index}`, diagnostics));
+				},
+				closed: boolean
+			},
+			required: ["points"]
+		},
+		rect: {
+			fields: {
+				x: number,
+				y: number,
+				width: positive,
+				height: positive
+			},
+			required: [
+				"x",
+				"y",
+				"width",
+				"height"
+			]
+		},
+		circle: {
+			fields: {
+				center: tuple,
+				radius: positive
+			},
+			required: ["center", "radius"]
+		},
+		arc: {
+			fields: {
+				center: tuple,
+				radius: positive,
+				startAngle: number,
+				sweepAngle: (value, path, diagnostics) => {
+					number(value, path, diagnostics);
+					if (typeof value === "number" && (value === 0 || value < -360 || value > 360)) fail(path, diagnostics, "Sweep must be nonzero and within [-360, 360].");
+				}
+			},
+			required: [
+				"center",
+				"radius",
+				"startAngle",
+				"sweepAngle"
+			]
+		},
+		text: {
+			fields: {
+				position: tuple,
+				text,
+				align,
+				fontSize: positive
+			},
+			required: ["position", "text"]
+		}
+	};
+	const variant = isRecord(v) && typeof v.type === "string" && Object.hasOwn(variants, v.type) ? variants[v.type] : void 0;
+	object({
+		...common,
+		...variant?.fields
+	}, ["type", ...variant?.required ?? []])(v, p, d);
+};
+var graphics = (v, p, d) => {
+	if (!Array.isArray(v)) fail(p, d, "Expected graphics array.");
+	else v.forEach((value, i) => graphic(value, `${p}/${i}`, d));
+};
+var annotations = object({ designator: object({
+	position: tuple,
+	align
+}, ["position"]) });
+/** Shared validation for optional presentation data on legacy normalized geometry. */
+function validateSymbolPresentation(value, diagnostics) {
+	if (value.graphics !== void 0) graphics(value.graphics, "/symbol/graphics", diagnostics);
+	if (value.annotations !== void 0) annotations(value.annotations, "/symbol/annotations", diagnostics);
+	if (!isRecord(value.pins)) return;
+	for (const [id, pin] of Object.entries(value.pins)) {
+		if (!isRecord(pin)) continue;
+		const path = `/symbol/pins/${pointer(id)}`;
+		if (pin.label !== void 0) label(pin.label, `${path}/label`, diagnostics);
+		if (pin.displayName !== void 0) text(pin.displayName, `${path}/displayName`, diagnostics);
+	}
+}
+var checkMetadata = object({
+	kind: choice("device"),
+	id: (v, p, d) => {
+		if (typeof v !== "string" || !/^[A-Za-z0-9-]+$/.test(v)) fail(p, d, "Invalid device id.");
+	},
+	version: nonempty,
+	displayName: nonempty,
+	description: nonempty,
+	license: nonempty,
+	tags: strings,
+	designatorPrefix: (v, p, d) => {
+		if (typeof v !== "string" || !/^\S+$/.test(v)) fail(p, d, "Expected a nonempty prefix without whitespace.");
+	},
+	properties: map(property),
+	pins: map(object({
+		label: text,
+		description: text,
+		group: text
+	})),
+	ports: map(object({
+		direction: choice("input", "output"),
+		type: choice("boolean", "number", "string", "vec2d", "vec3d", "bytes", "bytes<rgb565>", "bytes<segments>"),
+		title: text,
+		description: text,
+		delivery: choice("level", "message")
+	}, ["direction", "type"])),
+	symbol: object({
+		bounds: object({
+			x: number,
+			y: number,
+			width: positive,
+			height: positive
+		}, [
+			"x",
+			"y",
+			"width",
+			"height"
+		]),
+		graphics,
+		pins: map(object({
+			position: tuple,
+			direction: choice("left", "right", "up", "down"),
+			label
+		}, ["position", "direction"])),
+		annotations
+	}, [
+		"bounds",
+		"graphics",
+		"pins"
+	])
+}, [
+	"kind",
+	"id",
+	"version",
+	"displayName"
+]);
+/** Validates JSON text or an object, throwing the existing diagnostic-bearing format error. */
+function parseDeviceMetadata(input) {
+	const diagnostics = [];
+	const parsed = parseInput(input, diagnostics);
+	if (parsed.ok) checkMetadata(parsed.value, "", diagnostics);
+	if (diagnostics.length > 0) throw new SchematicError(diagnostics);
+	return parsed.value;
+}
+function deviceMetadataPropertyDescriptors(metadata) {
+	return new Map(Object.entries(metadata.properties ?? {}).map(([key, value]) => {
+		const descriptor = {
+			key,
+			type: value.type === "bytes" ? "binary" : value.type,
+			required: value.required,
+			...value.nullable === void 0 ? {} : { nullable: value.nullable },
+			...value.title === void 0 ? {} : { title: value.title },
+			...value.description === void 0 ? {} : { description: value.description },
+			...value.unit === void 0 ? {} : { unit: value.unit },
+			...value.group === void 0 ? {} : { group: value.group },
+			...value.order === void 0 ? {} : { order: value.order },
+			...value.editor === void 0 ? {} : { editor: value.editor },
+			...value.type === "number" && value.editor?.kind === "number" ? {
+				...value.editor.min === void 0 ? {} : { min: value.editor.min },
+				...value.editor.max === void 0 ? {} : { max: value.editor.max },
+				...value.editor.step === void 0 ? {} : { step: value.editor.step }
+			} : {},
+			...value.type === "enum" ? { options: value.values.map((option) => ({
+				value: option,
+				label: value.editor?.kind === "select" ? value.editor.labels?.[option] ?? option : option
+			})) } : {}
+		};
+		if (Object.hasOwn(value, "default") && propertyValueProblem(descriptor, value.default) === void 0) return [key, {
+			...descriptor,
+			default: value.default
+		}];
+		return [key, descriptor];
+	}));
+}
+function deviceMetadataSymbol(metadata) {
+	const symbol = metadata.symbol;
+	const base = symbol === void 0 ? synthesizeDeviceSymbol({
+		name: metadata.displayName,
+		pins: Object.fromEntries(Object.keys(metadata.pins ?? {}).map((id) => [id, {}]))
+	}) : void 0;
+	const pins = Object.create(null);
+	for (const [id, pin] of Object.entries(symbol?.pins ?? base.pins)) {
+		const caption = metadata.pins?.[id]?.label;
+		if (symbol !== void 0) {
+			const custom = symbol.pins[id];
+			pins[id] = {
+				x: custom.position[0],
+				y: custom.position[1],
+				side: custom.direction === "up" ? "top" : custom.direction === "down" ? "bottom" : custom.direction,
+				...custom.label === void 0 ? {} : { label: custom.label },
+				...caption === void 0 ? {} : { displayName: caption }
+			};
+		} else pins[id] = {
+			...pin,
+			...caption === void 0 ? {} : { displayName: caption }
+		};
+	}
+	return symbol === void 0 ? {
+		...base,
+		pins
+	} : {
+		name: metadata.displayName,
+		bounds: symbol.bounds,
+		graphics: symbol.graphics,
+		pins,
+		...symbol.annotations === void 0 ? {} : { annotations: symbol.annotations }
+	};
+}
+//#endregion
+//#region src/schematic/device/registry.ts
+var PIN_SIDES = [
+	"left",
+	"right",
+	"top",
+	"bottom"
+];
+function createDeviceRegistry(packages = []) {
+	const stored = /* @__PURE__ */ new Map();
+	const registrationDiagnostics = [];
+	const getDeviceName = (reference) => {
+		const device = lookup(reference);
+		return device?.symbol?.name ?? device?.displayName;
+	};
+	const lookup = (reference) => {
+		return stored.get(reference.packageId)?.devices.get(reference.deviceId);
+	};
+	const registry = {
+		registerPackage(registration, options) {
+			const diagnostics = [];
+			const packageId = registration.packageId;
+			if (!isValidPackageId(packageId)) throw new SchematicError([{
+				severity: "error",
+				code: "device/invalid-package",
+				message: `Invalid package id ${JSON.stringify(packageId)}.`
+			}]);
+			if (isReservedPackageId(packageId)) throw new SchematicError([{
+				severity: "error",
+				code: "device/reserved-namespace",
+				message: `Package id ${JSON.stringify(packageId)} uses the reserved "builtin" namespace.`
+			}]);
+			if (stored.has(packageId) && options?.replace !== true) throw new SchematicError([{
+				severity: "error",
+				code: "device/duplicate-package",
+				message: `Package ${JSON.stringify(packageId)} is already registered.`
+			}]);
+			const devices = /* @__PURE__ */ new Map();
+			const reportedUnknownPins = /* @__PURE__ */ new Set();
+			for (const entry of registration.devices) {
+				const deviceId = typeof entry.id === "string" ? entry.id : "";
+				if (deviceId.length === 0) {
+					diagnostics.push({
+						severity: "error",
+						code: "device/invalid-description",
+						message: `Package ${JSON.stringify(packageId)} contains a device without an id.`
+					});
+					continue;
+				}
+				const devicePath = `${packageId}:${deviceId}`;
+				if (devices.has(deviceId)) {
+					diagnostics.push({
+						severity: "error",
+						code: "device/duplicate-device",
+						message: `Device ${JSON.stringify(devicePath)} is declared more than once.`
+					});
+					continue;
+				}
+				const raw = isRecord(entry.raw) ? entry.raw : Object.create(null);
+				if (raw.kind === "device") {
+					try {
+						const metadata = parseDeviceMetadata(raw);
+						if (metadata.id !== deviceId) {
+							diagnostics.push({
+								severity: "error",
+								code: "device/invalid-description",
+								message: `Device ${JSON.stringify(devicePath)} metadata id does not match its registration id.`
+							});
+							continue;
+						}
+						devices.set(deviceId, {
+							reference: {
+								raw: formatDeviceReference(packageId, deviceId),
+								packageId,
+								deviceId
+							},
+							packageId,
+							deviceId,
+							displayName: metadata.displayName,
+							description: metadata.description,
+							designatorPrefix: metadata.designatorPrefix,
+							propertyDescriptors: deviceMetadataPropertyDescriptors(metadata),
+							symbol: deviceMetadataSymbol(metadata),
+							raw
+						});
+					} catch (error) {
+						if (!(error instanceof SchematicError)) throw error;
+						diagnostics.push(...error.diagnostics);
+					}
+					continue;
+				}
+				const displayName = typeof entry.displayName === "string" && entry.displayName.length > 0 ? entry.displayName : deviceId;
+				const symbol = readSymbolGeometry(entry, raw, devicePath, diagnostics, reportedUnknownPins);
+				const designatorPrefix = readDesignatorPrefix(entry, raw);
+				devices.set(deviceId, {
+					reference: {
+						raw: formatDeviceReference(packageId, deviceId),
+						packageId,
+						deviceId
+					},
+					packageId,
+					deviceId,
+					displayName,
+					description: typeof entry.description === "string" ? entry.description : void 0,
+					designatorPrefix,
+					propertyDescriptors: readPropertyDescriptors(raw["properties"]),
+					symbol,
+					raw
+				});
+			}
+			registrationDiagnostics.push(...diagnostics);
+			throwIfErrors(diagnostics);
+			stored.set(packageId, {
+				packageId,
+				devices
+			});
+		},
+		resolve(reference) {
+			const parsed = typeof reference === "string" ? parseDeviceReference(reference) : reference;
+			if (parsed === void 0) return;
+			return lookup(parsed);
+		},
+		listDevices(packageId) {
+			const packages = packageId === void 0 ? [...stored.values()] : [stored.get(packageId)];
+			const devices = [];
+			for (const pkg of packages) {
+				if (pkg === void 0) continue;
+				devices.push(...pkg.devices.values());
+			}
+			return devices.sort((a, b) => a.packageId.localeCompare(b.packageId) || a.deviceId.localeCompare(b.deviceId));
+		},
+		getDeviceSymbol(reference) {
+			return lookup(reference)?.symbol;
+		},
+		getDeviceName,
+		getDeviceDesignatorPrefix(reference) {
+			return lookup(reference)?.designatorPrefix;
+		},
+		getDevicePropertyDescriptors(reference) {
+			return lookup(reference)?.propertyDescriptors;
+		},
+		get diagnostics() {
+			return registrationDiagnostics;
+		}
+	};
+	for (const registration of packages) registry.registerPackage(registration);
+	return registry;
+}
+/** Designator prefix declared on the entry, else inside `raw`, else `undefined` (caller defaults). */
+function readDesignatorPrefix(entry, raw) {
+	const declared = entry.designatorPrefix ?? raw["designatorPrefix"];
+	if (typeof declared !== "string") return;
+	const trimmed = declared.trim();
+	return trimmed.length === 0 ? void 0 : trimmed;
+}
+function readSymbolGeometry(entry, raw, devicePath, diagnostics, reportedUnknownPins) {
+	const displayName = typeof entry.displayName === "string" && entry.displayName.length > 0 ? entry.displayName : entry.id;
+	const symbol = entry.symbol;
+	if (symbol === void 0) {
+		const declarations = readPinDeclarations(raw["pins"]);
+		if (declarations === void 0) {
+			diagnostics.push({
+				severity: "warning",
+				code: "device/no-symbol",
+				message: `Device ${JSON.stringify(devicePath)} has neither symbol geometry nor pin declarations.`
+			});
+			return;
+		}
+		return synthesizeDeviceSymbol({
+			name: displayName,
+			pins: declarations
+		});
+	}
+	if (!isRecord(symbol)) {
+		diagnostics.push({
+			severity: "error",
+			code: "device/invalid-description",
+			message: `Device ${JSON.stringify(devicePath)} has an invalid symbol definition.`
+		});
+		return;
+	}
+	validateSymbolPresentation(symbol, diagnostics);
+	const pins = readPins(symbol.pins, devicePath, diagnostics);
+	if (pins === void 0) return;
+	const declaredPins = readDeclaredPinIds(raw.pins);
+	if (declaredPins !== void 0) {
+		for (const pinId of Object.keys(pins)) if (!declaredPins.has(pinId) && !reportedUnknownPins.has(`${devicePath}\u0000${pinId}`)) {
+			reportedUnknownPins.add(`${devicePath}\u0000${pinId}`);
+			diagnostics.push({
+				severity: "error",
+				code: "device/unknown-pin",
+				message: `Device ${JSON.stringify(devicePath)} symbol declares pin ${JSON.stringify(pinId)} which is absent from the pin declaration.`
+			});
+		}
+	}
+	const bounds = readBounds(symbol.bounds, devicePath, diagnostics);
+	return {
+		name: (typeof symbol.name === "string" && symbol.name.length > 0 ? symbol.name : void 0) ?? displayName,
+		pins,
+		...bounds === void 0 ? {} : { bounds },
+		...symbol.graphics === void 0 ? {} : { graphics: symbol.graphics },
+		...symbol.annotations === void 0 ? {} : { annotations: symbol.annotations }
+	};
+}
+function readPinDeclarations(value) {
+	if (!isRecord(value) || Object.keys(value).length === 0) return;
+	const declarations = Object.create(null);
+	for (const [pinId, pin] of Object.entries(value)) {
+		if (pinId.length === 0 || !isRecord(pin)) return;
+		const declaration = {};
+		if (PIN_SIDES.includes(pin.side)) declaration.side = pin.side;
+		declarations[pinId] = declaration;
+	}
+	return declarations;
+}
+function readPins(value, devicePath, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push({
+			severity: "error",
+			code: "device/invalid-description",
+			message: `Device ${JSON.stringify(devicePath)} symbol must declare a pins object.`
+		});
+		return;
+	}
+	const pins = Object.create(null);
+	let failed = false;
+	for (const [pinId, anchor] of Object.entries(value)) {
+		if (pinId.length === 0) {
+			diagnostics.push({
+				severity: "error",
+				code: "device/invalid-description",
+				message: `Device ${JSON.stringify(devicePath)} symbol declares an empty pin id.`
+			});
+			failed = true;
+			continue;
+		}
+		if (!isRecord(anchor) || !Number.isFinite(anchor.x) || !Number.isFinite(anchor.y)) {
+			diagnostics.push({
+				severity: "error",
+				code: "device/invalid-description",
+				message: `Device ${JSON.stringify(devicePath)} pin ${JSON.stringify(pinId)} must have finite x and y anchors.`
+			});
+			failed = true;
+			continue;
+		}
+		const side = anchor.side;
+		if (side !== void 0 && !PIN_SIDES.includes(side)) {
+			diagnostics.push({
+				severity: "error",
+				code: "device/invalid-description",
+				message: `Device ${JSON.stringify(devicePath)} pin ${JSON.stringify(pinId)} has invalid side ${JSON.stringify(side)}.`
+			});
+			failed = true;
+			continue;
+		}
+		const presentation = anchor;
+		pins[pinId] = {
+			x: anchor.x,
+			y: anchor.y,
+			...side === void 0 ? {} : { side },
+			...presentation.label === void 0 ? {} : { label: presentation.label },
+			...presentation.displayName === void 0 ? {} : { displayName: presentation.displayName }
+		};
+	}
+	return failed ? void 0 : pins;
+}
+function readBounds(value, devicePath, diagnostics) {
+	if (value === void 0) return;
+	if (!isRecord(value) || !Number.isFinite(value.x) || !Number.isFinite(value.y) || !Number.isFinite(value.width) || !Number.isFinite(value.height)) {
+		diagnostics.push({
+			severity: "error",
+			code: "device/invalid-description",
+			message: `Device ${JSON.stringify(devicePath)} symbol bounds must have finite x, y, width and height.`
+		});
+		return;
+	}
+	return {
+		x: value.x,
+		y: value.y,
+		width: value.width,
+		height: value.height
+	};
+}
+function readDeclaredPinIds(value) {
+	if (!isRecord(value)) return;
+	return new Set(Object.keys(value));
+}
+//#endregion
+//#region src/schematic/device/designator.ts
+/** Prefix used when neither the host nor the device description provides one. */
+var DEFAULT_DESIGNATOR_PREFIX = "U";
+/** Smallest unused `<prefix><n>` designator. */
+function nextDesignator(document, prefix = "U") {
+	const used = new Set(document.sheet.symbols.map((symbol) => designatorOf(symbol)).filter((designator) => designator !== void 0));
+	for (let index = 1; index < Number.MAX_SAFE_INTEGER; index += 1) {
+		const candidate = `${prefix}${index}`;
+		if (!used.has(candidate)) return candidate;
+	}
+	return prefix;
+}
+/**
+* Designator policy derived from the device descriptions: `<device prefix><n>`, falling back to
+* `U` for devices that declare none.
+*/
+function createDesignatorFactory(devices) {
+	return (device, document) => nextDesignator(document, designatorPrefixOf(devices, device));
+}
+/** Prefix the device declares, else {@link DEFAULT_DESIGNATOR_PREFIX}. */
+function designatorPrefixOf(devices, device) {
+	const reference = parseDeviceReference(device);
+	return (reference === void 0 ? void 0 : devices?.getDeviceDesignatorPrefix?.(reference)) ?? "U";
+}
+/** Default policy for providers without device data: `U1`, `U2`, … */
+var defaultDesignatorFactory = (device, document) => nextDesignator(document);
+//#endregion
+export { ASSET_MODES, DEFAULT_DESIGNATOR_PREFIX, DEFAULT_GROUND_LABEL, DEFAULT_POWER_LABEL, DEFAULT_TEXT_CONTENT, DEFAULT_TOLERANCE, GROUND_DEVICE, LABEL_DEVICE, POWER_DEVICE, PROPERTY_TYPES, RESERVED_PACKAGE_NAMESPACE, SCHEMATIC_VERSION, SchematicError, TEXT_DEVICE, applySchematicCommand, assetPathError, base64Error, builtinSymbolKind, createDesignatorFactory, createDeviceRegistry, defaultDesignatorFactory, defaultElementIdFactory, defaultNetName, deriveSchematicTopology, designatorOf, designatorPrefixOf, deviceMetadataPropertyDescriptors, deviceMetadataSymbol, distanceToSegment, formatDeviceReference, hasDesignator, isAssetMode, isAssetReference, isBuiltinDevice, isLabelDevice, isPropertyType, isReservedPackageId, isTextDevice, isValidPackageId, joinJunctionAt, loadSchematic, mergeWiresAtJunction, namesNet, nearestPointOnPolyline, netNameOf, nextDesignator, normalizeColor, normalizePropertyValue, parseDeviceMetadata, parseDeviceReference, parsePropertyDescriptor, parseSchematic, pinSide, pinStubEnd, pinsBounds, planJunctionRelease, pointOnPolyline, pointOnPolylineAt, pointsEqual, projectOnSegment, propertyValueProblem, readPropertyDescriptors, referenceAnchor, referencePosition, rerouteWireEndpoint, rotatePoint, samePoint, serializeSchematic, splitWireAt, stretchWireEndpoint, symbolBounds, symbolPinPosition, symbolRole, synthesizeDeviceSymbol, textDeviceContent };
+
+//# sourceMappingURL=index.js.map