@vessel-dsp/core 0.5.0 → 0.6.1

package/{src/formats/interchange/parser.ts → dist/formats/interchange/parser.js}

@@ -1,84 +1,53 @@
-import { isParsedQuantity } from '../../model/properties';
-import type {
-    CircuitDocument,
-    CircuitDocumentDevice,
-    CircuitDocumentDeviceKind,
-    Component,
-    ComponentKind,
-    ControlApplicabilityPredicate,
-    ControlContext,
-    ControlGroup,
-    DeviceInterface,
-    DeviceInterfaceBinding,
-    DeviceInterfaceControlKind,
-    ControlInterface,
-    ControlInterfaceAssignmentHint,
-    ControlInterfaceConnector,
-    ControlInterfacePolarity,
-    ControlInterfaceRole,
-    ControlOutput,
-    ControlOutputSwitchMode,
-    DocumentSource,
-    PanelColumnOrder,
-    PanelControlKind,
-    PanelElementBinding,
-    PanelGridLayout,
-    PanelGridIndexing,
-    PanelGridPosition,
-    PanelPlacementMetadata,
-    PanelRowOrder,
-    ParsedQuantity,
-    Point,
-    PropertyValue,
-    Rotation,
-    Terminal,
-    Warning,
-    Wire,
-} from '../../model/types';
-
-type YamlScalar = string | number | boolean | null;
-type YamlValue = YamlScalar | readonly YamlValue[] | YamlObject;
-type YamlObject = { [key: string]: YamlValue };
-
-type YamlLine = Readonly<{
-    indent: number;
-    text: string;
-    lineNumber: number;
-}>;
-
-type Cursor = {
-    index: number;
-};
-
-type ParsedPair = Readonly<{
-    key: string;
-    rest: string;
-}>;
-
-const INTERCHANGE_SCHEMA = 'circuit-interchange/v2';
-
-export function parseInterchangeYaml(source: string): CircuitDocument {
+import { isParsedQuantity } from '../../model/properties.js';
+const INTERCHANGE_SCHEMA_V2 = 'circuit-interchange/v2';
+const INTERCHANGE_SCHEMA_V3 = 'circuit-interchange/v3';
+const V3_ONLY_TOP_LEVEL_FIELDS = [
+    'mechanical',
+    'build',
+    'bom',
+    'partProfiles',
+    'footprints',
+    'offBoardWiring',
+    'boards',
+];
+export function parseInterchangeYaml(source) {
     const value = parseYamlSubset(source);
     const root = expectObject(value, 'root');
     const schema = expectString(root.schema, 'schema');
-    if (schema !== INTERCHANGE_SCHEMA) {
+    if (schema !== INTERCHANGE_SCHEMA_V2 && schema !== INTERCHANGE_SCHEMA_V3) {
         throw new Error(`unsupported interchange schema: ${schema}`);
     }
-
-    const panel = parsePanel(root.panel);
+    const isV3 = schema === INTERCHANGE_SCHEMA_V3;
+    if (!isV3) {
+        rejectV3OnlyTopLevelFields(root);
+    }
+    const panel = parsePanel(root.panel, isV3);
     const controlInterfaces = parseControlInterfaces(root.controlInterfaces);
     const device = parseDevice(root.device);
     const controlOutputs = parseControlOutputs(root.controlOutputs);
     const controlGroups = parseControlGroups(root.controlGroups);
     const controlContexts = parseControlContexts(root.controlContexts);
     const deviceInterface = parseDeviceInterface(root.deviceInterface);
-
+    const mechanical = isV3 ? parseMechanical(root.mechanical) : undefined;
+    const build = isV3 ? parseBuild(root.build) : undefined;
+    const bom = isV3 ? parseBom(root.bom) : undefined;
+    const partProfiles = isV3 ? parsePartProfiles(root.partProfiles) : undefined;
+    const footprints = isV3 ? parseFootprints(root.footprints) : undefined;
+    const offBoardWiring = isV3 ? parseOffBoardWiring(root.offBoardWiring) : undefined;
+    const boards = isV3 ? parseBoards(root.boards) : undefined;
     return {
         metadata: parseMetadata(root.metadata),
         source: parseSource(root.source),
         ...(device === undefined ? {} : { device }),
         ...(controlGroups === undefined ? {} : { controlGroups }),
         ...(controlContexts === undefined ? {} : { controlContexts }),
+        ...(mechanical === undefined ? {} : { mechanical }),
+        ...(build === undefined ? {} : { build }),
+        ...(bom === undefined ? {} : { bom }),
+        ...(partProfiles === undefined ? {} : { partProfiles }),
+        ...(footprints === undefined ? {} : { footprints }),
+        ...(offBoardWiring === undefined ? {} : { offBoardWiring }),
+        ...(boards === undefined ? {} : { boards }),
         ...(deviceInterface === undefined ? {} : { deviceInterface }),
         ...(panel === undefined ? {} : { panel }),
         ...(controlInterfaces === undefined ? {} : { controlInterfaces }),
@@ -90,8 +59,463 @@ export function parseInterchangeYaml(source: string): CircuitDocument {
         rawAttributes: parseStringRecord(root.rawAttributes, 'rawAttributes'),
     };
 }
-
-function parseControlGroups(value: YamlValue | undefined): readonly ControlGroup[] | undefined {
+function rejectV3OnlyTopLevelFields(root) {
+    for (const field of V3_ONLY_TOP_LEVEL_FIELDS) {
+        if (root[field] !== undefined) {
+            throw new Error(`${field}: requires schema ${INTERCHANGE_SCHEMA_V3}`);
+        }
+    }
+}
+function parseMechanical(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const mechanical = expectObject(value, 'mechanical');
+    return {
+        ...parseBuildDataObject(mechanical, 'mechanical'),
+        ...(mechanical.schema === undefined ? {} : { schema: expectString(mechanical.schema, 'mechanical.schema') }),
+        ...(mechanical.units === undefined ? {} : { units: expectString(mechanical.units, 'mechanical.units') }),
+    };
+}
+function parseBuild(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const build = expectObject(value, 'build');
+    return {
+        ...parseBuildDataObject(build, 'build'),
+        schema: parseLiteralString(build.schema, 'build.schema', 'build-scope/v1'),
+        ...(build.intent === undefined ? {} : { intent: parseBuildIntent(build.intent, 'build.intent') }),
+        ...(build.completeness === undefined
+            ? {}
+            : { completeness: parseBuildCompleteness(build.completeness, 'build.completeness') }),
+        ...(build.selectedBoardId === undefined
+            ? {}
+            : { selectedBoardId: expectString(build.selectedBoardId, 'build.selectedBoardId') }),
+        ...(build.selectedOffBoardWiringHarnessIds === undefined
+            ? {}
+            : {
+                selectedOffBoardWiringHarnessIds: parseOptionalStringArray(build.selectedOffBoardWiringHarnessIds, 'build.selectedOffBoardWiringHarnessIds') ?? [],
+            }),
+        ...(build.alternateBoardIds === undefined
+            ? {}
+            : { alternateBoardIds: parseOptionalStringArray(build.alternateBoardIds, 'build.alternateBoardIds') ?? [] }),
+        ...(build.bomScope === undefined ? {} : { bomScope: expectString(build.bomScope, 'build.bomScope') }),
+    };
+}
+function parseBuildIntent(value, path) {
+    const intent = expectString(value, path);
+    if (intent === 'diy-build-artifact' || intent === 'schema-review-sample') {
+        return intent;
+    }
+    throw new Error(`${path}: expected diy-build-artifact or schema-review-sample`);
+}
+function parseBuildCompleteness(value, path) {
+    const completeness = expectString(value, path);
+    if (completeness === 'complete-selected-build' || completeness === 'partial-offboard-wiring') {
+        return completeness;
+    }
+    throw new Error(`${path}: expected complete-selected-build or partial-offboard-wiring`);
+}
+function parseBom(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const bom = expectObject(value, 'bom');
+    return {
+        ...parseBuildDataObject(bom, 'bom'),
+        schema: parseLiteralString(bom.schema, 'bom.schema', 'build-bom/v1'),
+        items: optionalArray(bom.items, 'bom.items').map(parseBomItem),
+    };
+}
+function parseBomItem(value, index) {
+    const path = `bom.items[${index}]`;
+    const item = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(item, path),
+        id: expectString(item.id, `${path}.id`),
+        refs: optionalArray(item.refs, `${path}.refs`).map((ref, refIndex) => parseBomRef(ref, `${path}.refs[${refIndex}]`)),
+        quantity: expectNumber(item.quantity, `${path}.quantity`),
+        ...(item.value === undefined ? {} : { value: expectString(item.value, `${path}.value`) }),
+        ...(item.partProfileId === undefined
+            ? {}
+            : { partProfileId: expectString(item.partProfileId, `${path}.partProfileId`) }),
+        ...(item.category === undefined ? {} : { category: expectString(item.category, `${path}.category`) }),
+        ...(item.sku === undefined ? {} : { sku: expectString(item.sku, `${path}.sku`) }),
+    };
+}
+function parseBomRef(value, path) {
+    const ref = expectObject(value, path);
+    const kind = expectString(ref.kind, `${path}.kind`);
+    switch (kind) {
+        case 'component':
+        case 'device-interface-control':
+        case 'panel-element':
+        case 'board':
+        case 'freeform-build-item':
+            return {
+                ...parseBuildDataObject(ref, path),
+                kind,
+                ...(ref.componentId === undefined ? {} : { componentId: expectString(ref.componentId, `${path}.componentId`) }),
+                ...(ref.controlId === undefined ? {} : { controlId: expectString(ref.controlId, `${path}.controlId`) }),
+                ...(ref.panelElementId === undefined
+                    ? {}
+                    : { panelElementId: expectString(ref.panelElementId, `${path}.panelElementId`) }),
+                ...(ref.boardId === undefined ? {} : { boardId: expectString(ref.boardId, `${path}.boardId`) }),
+                ...(ref.label === undefined ? {} : { label: expectString(ref.label, `${path}.label`) }),
+            };
+        default:
+            throw new Error(`${path}.kind: expected component, device-interface-control, panel-element, board, or freeform-build-item`);
+    }
+}
+function parsePartProfiles(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const catalog = expectObject(value, 'partProfiles');
+    return {
+        ...parseBuildDataObject(catalog, 'partProfiles'),
+        schema: parseLiteralString(catalog.schema, 'partProfiles.schema', 'part-profile-catalog/v1'),
+        ...(catalog.resolution === undefined
+            ? {}
+            : { resolution: expectString(catalog.resolution, 'partProfiles.resolution') }),
+        ...(catalog.units === undefined ? {} : { units: expectString(catalog.units, 'partProfiles.units') }),
+        profiles: optionalArray(catalog.profiles, 'partProfiles.profiles').map((profile, index) => parsePartProfile(profile, index)),
+    };
+}
+function parsePartProfile(value, index) {
+    const path = `partProfiles.profiles[${index}]`;
+    const profile = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(profile, path),
+        id: expectString(profile.id, `${path}.id`),
+        ...(profile.kind === undefined ? {} : { kind: expectString(profile.kind, `${path}.kind`) }),
+    };
+}
+function parseFootprints(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const catalog = expectObject(value, 'footprints');
+    return {
+        ...parseBuildDataObject(catalog, 'footprints'),
+        schema: parseLiteralString(catalog.schema, 'footprints.schema', 'board-footprint-catalog/v1'),
+        ...(catalog.resolution === undefined ? {} : { resolution: expectString(catalog.resolution, 'footprints.resolution') }),
+        ...(catalog.units === undefined ? {} : { units: expectString(catalog.units, 'footprints.units') }),
+        footprints: optionalArray(catalog.footprints, 'footprints.footprints').map((footprint, index) => parseFootprint(footprint, index)),
+    };
+}
+function parseFootprint(value, index) {
+    const path = `footprints.footprints[${index}]`;
+    const footprint = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(footprint, path),
+        id: expectString(footprint.id, `${path}.id`),
+        ...(footprint.boardApplicability === undefined
+            ? {}
+            : { boardApplicability: parseBoardApplicability(footprint.boardApplicability, `${path}.boardApplicability`) }),
+    };
+}
+function parseBoardApplicability(value, path) {
+    const applicability = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(applicability, path),
+        family: parseBoardFamily(applicability.family, `${path}.family`),
+        kind: parseBoardKind(applicability.kind, `${path}.kind`),
+        ...(applicability.subtype === undefined
+            ? {}
+            : { subtype: parseBoardSubtype(applicability.subtype, `${path}.subtype`) }),
+    };
+}
+function parseOffBoardWiring(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const plan = expectObject(value, 'offBoardWiring');
+    return {
+        ...parseBuildDataObject(plan, 'offBoardWiring'),
+        schema: parseLiteralString(plan.schema, 'offBoardWiring.schema', 'offboard-wiring/v1'),
+        ...(plan.source === undefined ? {} : { source: expectString(plan.source, 'offBoardWiring.source') }),
+        ...(plan.coverage === undefined
+            ? {}
+            : { coverage: parseOffBoardWiringCoverage(plan.coverage, 'offBoardWiring.coverage') }),
+        harnesses: optionalArray(plan.harnesses, 'offBoardWiring.harnesses').map(parseOffBoardWiringHarness),
+    };
+}
+function parseOffBoardWiringCoverage(value, path) {
+    const coverage = expectString(value, path);
+    if (coverage === 'selected-build-complete' || coverage === 'representative-selected-build-endpoints') {
+        return coverage;
+    }
+    throw new Error(`${path}: expected selected-build-complete or representative-selected-build-endpoints`);
+}
+function parseOffBoardWiringHarness(value, index) {
+    const path = `offBoardWiring.harnesses[${index}]`;
+    const harness = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(harness, path),
+        id: expectString(harness.id, `${path}.id`),
+        ...(harness.status === undefined
+            ? {}
+            : { status: parseOffBoardWiringHarnessStatus(harness.status, `${path}.status`) }),
+        ...(harness.notes === undefined ? {} : { notes: expectString(harness.notes, `${path}.notes`) }),
+        endpoints: optionalArray(harness.endpoints, `${path}.endpoints`).map((endpoint, endpointIndex) => parseOffBoardWiringEndpoint(endpoint, `${path}.endpoints[${endpointIndex}]`)),
+        connections: optionalArray(harness.connections, `${path}.connections`).map((connection, connectionIndex) => parseOffBoardWiringConnection(connection, `${path}.connections[${connectionIndex}]`)),
+    };
+}
+function parseOffBoardWiringHarnessStatus(value, path) {
+    const status = expectString(value, path);
+    if (status === 'complete' || status === 'partial' || status === 'candidate') {
+        return status;
+    }
+    throw new Error(`${path}: expected complete, partial, or candidate`);
+}
+function parseOffBoardWiringEndpoint(value, path) {
+    const endpoint = expectObject(value, path);
+    const kind = expectString(endpoint.kind, `${path}.kind`);
+    switch (kind) {
+        case 'panel-component-terminal':
+        case 'board-terminal':
+        case 'power-terminal':
+        case 'footswitch-terminal':
+        case 'free-wire-label':
+            return {
+                ...parseBuildDataObject(endpoint, path),
+                id: expectString(endpoint.id, `${path}.id`),
+                kind,
+                ...(endpoint.componentId === undefined
+                    ? {}
+                    : { componentId: expectString(endpoint.componentId, `${path}.componentId`) }),
+                ...(endpoint.terminalName === undefined
+                    ? {}
+                    : { terminalName: expectString(endpoint.terminalName, `${path}.terminalName`) }),
+                ...(endpoint.panelElementId === undefined
+                    ? {}
+                    : { panelElementId: expectString(endpoint.panelElementId, `${path}.panelElementId`) }),
+                ...(endpoint.boardId === undefined ? {} : { boardId: expectString(endpoint.boardId, `${path}.boardId`) }),
+                ...(endpoint.terminalId === undefined
+                    ? {}
+                    : { terminalId: expectString(endpoint.terminalId, `${path}.terminalId`) }),
+                ...(endpoint.label === undefined ? {} : { label: expectString(endpoint.label, `${path}.label`) }),
+            };
+        default:
+            throw new Error(`${path}.kind: expected a supported off-board wiring endpoint kind`);
+    }
+}
+function parseOffBoardWiringConnection(value, path) {
+    const connection = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(connection, path),
+        id: expectString(connection.id, `${path}.id`),
+        fromEndpointId: expectString(connection.fromEndpointId, `${path}.fromEndpointId`),
+        toEndpointId: expectString(connection.toEndpointId, `${path}.toEndpointId`),
+        ...(connection.signalRef === undefined
+            ? {}
+            : { signalRef: parseBuildDataObject(connection.signalRef, `${path}.signalRef`) }),
+        ...(connection.wire === undefined ? {} : { wire: parseBuildDataObject(connection.wire, `${path}.wire`) }),
+    };
+}
+function parseBoards(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return optionalArray(value, 'boards').map(parseBoard);
+}
+function parseBoard(value, index) {
+    const path = `boards[${index}]`;
+    const board = expectObject(value, path);
+    const sourceCircuit = board.sourceCircuit === undefined
+        ? undefined
+        : parseBoardSourceCircuit(board.sourceCircuit, `${path}.sourceCircuit`);
+    return {
+        ...parseBuildDataObject(board, path),
+        id: expectString(board.id, `${path}.id`),
+        schema: parseLiteralString(board.schema, `${path}.schema`, 'circuit-board/v1'),
+        family: parseBoardFamily(board.family, `${path}.family`),
+        kind: parseBoardKind(board.kind, `${path}.kind`),
+        ...(board.subtype === undefined ? {} : { subtype: parseBoardSubtype(board.subtype, `${path}.subtype`) }),
+        ...(board.source === undefined ? {} : { source: expectString(board.source, `${path}.source`) }),
+        ...(board.units === undefined ? {} : { units: expectString(board.units, `${path}.units`) }),
+        ...(board.locked === undefined ? {} : { locked: expectBoolean(board.locked, `${path}.locked`) }),
+        ...(sourceCircuit === undefined ? {} : { sourceCircuit }),
+        edgeTerminals: optionalArray(board.edgeTerminals, `${path}.edgeTerminals`).map((terminal, terminalIndex) => parseBoardEdgeTerminal(terminal, `${path}.edgeTerminals[${terminalIndex}]`)),
+        footprintPlacements: optionalArray(board.footprintPlacements, `${path}.footprintPlacements`).map((placement, placementIndex) => parseBoardFootprintPlacement(placement, `${path}.footprintPlacements[${placementIndex}]`)),
+        ...(board.netlist === undefined ? {} : { netlist: parseBoardNetlist(board.netlist, `${path}.netlist`) }),
+        routes: optionalArray(board.routes, `${path}.routes`).map((route, routeIndex) => parseBoardRoute(route, `${path}.routes[${routeIndex}]`)),
+        ...(board.zones === undefined ? {} : { zones: parseBuildDataObjectArray(board.zones, `${path}.zones`) }),
+        ...(board.drills === undefined ? {} : { drills: parseBuildDataObjectArray(board.drills, `${path}.drills`) }),
+        ...(board.review === undefined ? {} : { review: parseBuildDataObject(board.review, `${path}.review`) }),
+    };
+}
+function parseBoardSourceCircuit(value, path) {
+    const sourceCircuit = expectObject(value, path);
+    const hash = expectString(sourceCircuit.hash, `${path}.hash`);
+    if (!/^sha256:[0-9a-f]{64}$/.test(hash)) {
+        throw new Error(`${path}.hash: expected sha256:<64 lowercase hex characters>`);
+    }
+    return {
+        ...parseBuildDataObject(sourceCircuit, path),
+        schema: parseLiteralString(sourceCircuit.schema, `${path}.schema`, 'canonical-circuit-facts-hash/v1'),
+        hashAlgorithm: parseLiteralString(sourceCircuit.hashAlgorithm, `${path}.hashAlgorithm`, 'sha256'),
+        hash,
+    };
+}
+function parseBoardEdgeTerminal(value, path) {
+    const terminal = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(terminal, path),
+        id: expectString(terminal.id, `${path}.id`),
+        ...(terminal.role === undefined ? {} : { role: expectString(terminal.role, `${path}.role`) }),
+        ...(terminal.terminalRef === undefined
+            ? {}
+            : { terminalRef: parseComponentTerminalRef(terminal.terminalRef, `${path}.terminalRef`) }),
+        ...(terminal.hole === undefined ? {} : { hole: parseBoardHole(terminal.hole, `${path}.hole`) }),
+    };
+}
+function parseBoardFootprintPlacement(value, path) {
+    const placement = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(placement, path),
+        componentId: expectString(placement.componentId, `${path}.componentId`),
+        footprintId: expectString(placement.footprintId, `${path}.footprintId`),
+        ...(placement.atGrid === undefined ? {} : { atGrid: parseBoardHole(placement.atGrid, `${path}.atGrid`) }),
+        ...(placement.atMm === undefined ? {} : { atMm: parsePoint(placement.atMm, `${path}.atMm`) }),
+        ...(placement.rotationDeg === undefined ? {} : { rotationDeg: expectNumber(placement.rotationDeg, `${path}.rotationDeg`) }),
+        pads: optionalArray(placement.pads, `${path}.pads`).map((pad, padIndex) => parseBoardPlacedPad(pad, `${path}.pads[${padIndex}]`)),
+    };
+}
+function parseBoardPlacedPad(value, path) {
+    const pad = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(pad, path),
+        padId: expectString(pad.padId, `${path}.padId`),
+        ...(pad.terminalName === undefined ? {} : { terminalName: expectString(pad.terminalName, `${path}.terminalName`) }),
+        ...(pad.hole === undefined ? {} : { hole: parseBoardHole(pad.hole, `${path}.hole`) }),
+        ...(pad.positionMm === undefined ? {} : { positionMm: parsePoint(pad.positionMm, `${path}.positionMm`) }),
+    };
+}
+function parseBoardNetlist(value, path) {
+    const netlist = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(netlist, path),
+        ...(netlist.source === undefined ? {} : { source: expectString(netlist.source, `${path}.source`) }),
+        nets: optionalArray(netlist.nets, `${path}.nets`).map((net, netIndex) => parseBoardNet(net, `${path}.nets[${netIndex}]`)),
+    };
+}
+function parseBoardNet(value, path) {
+    const net = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(net, path),
+        id: expectString(net.id, `${path}.id`),
+        ...(net.name === undefined ? {} : { name: expectString(net.name, `${path}.name`) }),
+        members: optionalArray(net.members, `${path}.members`).map((member, memberIndex) => parseBoardNetMember(member, `${path}.members[${memberIndex}]`)),
+    };
+}
+function parseBoardNetMember(value, path) {
+    const member = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(member, path),
+        componentId: expectString(member.componentId, `${path}.componentId`),
+        terminalName: expectString(member.terminalName, `${path}.terminalName`),
+        ...(member.padId === undefined ? {} : { padId: expectString(member.padId, `${path}.padId`) }),
+        ...(member.terminalId === undefined ? {} : { terminalId: expectString(member.terminalId, `${path}.terminalId`) }),
+    };
+}
+function parseBoardRoute(value, path) {
+    const route = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(route, path),
+        id: expectString(route.id, `${path}.id`),
+        ...(route.netRef === undefined ? {} : { netRef: parseBuildDataObject(route.netRef, `${path}.netRef`) }),
+        ...(route.locked === undefined ? {} : { locked: expectBoolean(route.locked, `${path}.locked`) }),
+        ...(route.conductors === undefined
+            ? {}
+            : { conductors: parseBuildDataObjectArray(route.conductors, `${path}.conductors`) }),
+        ...(route.copper === undefined ? {} : { copper: parseBuildDataObjectArray(route.copper, `${path}.copper`) }),
+        ...(route.vias === undefined ? {} : { vias: parseBuildDataObjectArray(route.vias, `${path}.vias`) }),
+        ...(route.zones === undefined ? {} : { zones: parseBuildDataObjectArray(route.zones, `${path}.zones`) }),
+        ...(route.drills === undefined ? {} : { drills: parseBuildDataObjectArray(route.drills, `${path}.drills`) }),
+    };
+}
+function parseComponentTerminalRef(value, path) {
+    const ref = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(ref, path),
+        componentId: expectString(ref.componentId, `${path}.componentId`),
+        terminalName: expectString(ref.terminalName, `${path}.terminalName`),
+    };
+}
+function parseBoardHole(value, path) {
+    const hole = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(hole, path),
+        row: expectPositiveInteger(hole.row, `${path}.row`),
+        column: expectPositiveInteger(hole.column, `${path}.column`),
+    };
+}
+function parseBoardFamily(value, path) {
+    const family = expectString(value, path);
+    if (family === 'prototype-board' || family === 'fabricated-board') {
+        return family;
+    }
+    throw new Error(`${path}: expected prototype-board or fabricated-board`);
+}
+function parseBoardKind(value, path) {
+    const kind = expectString(value, path);
+    switch (kind) {
+        case 'stripboard':
+        case 'perfboard':
+        case 'breadboard-pattern':
+        case 'pcb':
+            return kind;
+        default:
+            throw new Error(`${path}: expected stripboard, perfboard, breadboard-pattern, or pcb`);
+    }
+}
+function parseBoardSubtype(value, path) {
+    const subtype = expectString(value, path);
+    switch (subtype) {
+        case 'veroboard':
+        case 'isolated-pad':
+        case 'solderable-half-breadboard':
+        case 'single-sided-through-hole':
+        case 'two-layer-through-hole':
+            return subtype;
+        default:
+            throw new Error(`${path}: expected a supported board subtype`);
+    }
+}
+function parseLiteralString(value, path, expected) {
+    const actual = expectString(value, path);
+    if (actual === expected) {
+        return expected;
+    }
+    throw new Error(`${path}: expected ${expected}`);
+}
+function parseBuildDataObjectArray(value, path) {
+    return optionalArray(value, path).map((item, index) => parseBuildDataObject(item, `${path}[${index}]`));
+}
+function parseBuildDataObject(value, path) {
+    const object = expectObject(value, path);
+    const out = {};
+    for (const [key, child] of Object.entries(object)) {
+        out[key] = parseBuildDataValue(child, `${path}.${key}`);
+    }
+    return out;
+}
+function parseBuildDataValue(value, path) {
+    if (isScalar(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => parseBuildDataValue(item, `${path}[${index}]`));
+    }
+    if (isYamlObject(value)) {
+        return parseBuildDataObject(value, path);
+    }
+    throw new Error(`${path}: expected v3 build data value`);
+}
+function parseControlGroups(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -109,8 +533,7 @@ function parseControlGroups(value: YamlValue | undefined): readonly ControlGroup
         };
     });
 }
-
-function parseControlContexts(value: YamlValue | undefined): readonly ControlContext[] | undefined {
+function parseControlContexts(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -126,8 +549,7 @@ function parseControlContexts(value: YamlValue | undefined): readonly ControlCon
         };
     });
 }
-
-function parseDeviceInterface(value: YamlValue | undefined): DeviceInterface | undefined {
+function parseDeviceInterface(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -155,11 +577,7 @@ function parseDeviceInterface(value: YamlValue | undefined): DeviceInterface | u
         }),
     };
 }
-
-function parseDeviceInterfaceControlKind(
-    value: YamlValue | undefined,
-    path: string,
-): DeviceInterfaceControlKind {
+function parseDeviceInterfaceControlKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'knob':
@@ -174,11 +592,7 @@ function parseDeviceInterfaceControlKind(
             throw new Error(`${path}: expected knob, slider, switch, selector, footswitch, led, or jack`);
     }
 }
-
-function parseOptionalDeviceInterfaceBinding(
-    value: YamlValue | undefined,
-    path: string,
-): DeviceInterfaceBinding | undefined {
+function parseOptionalDeviceInterfaceBinding(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -195,11 +609,7 @@ function parseOptionalDeviceInterfaceBinding(
         ...(externalInterfaceId === undefined ? {} : { externalInterfaceId }),
     };
 }
-
-function parseOptionalApplicabilityPredicate(
-    value: YamlValue | undefined,
-    path: string,
-): ControlApplicabilityPredicate | undefined {
+function parseOptionalApplicabilityPredicate(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -211,8 +621,7 @@ function parseOptionalApplicabilityPredicate(
         ...(anyOf === undefined ? {} : { anyOf }),
     };
 }
-
-function parseDevice(value: YamlValue | undefined): CircuitDocumentDevice | undefined {
+function parseDevice(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -231,8 +640,7 @@ function parseDevice(value: YamlValue | undefined): CircuitDocumentDevice | unde
         ...(audioProcessing === undefined ? {} : { audioProcessing }),
     };
 }
-
-function parseCircuitDocumentDeviceKind(value: YamlValue | undefined, path: string): CircuitDocumentDeviceKind {
+function parseCircuitDocumentDeviceKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'audio-pedal':
@@ -244,8 +652,7 @@ function parseCircuitDocumentDeviceKind(value: YamlValue | undefined, path: stri
             throw new Error(`${path}: expected audio-pedal, control-accessory, utility, or unknown`);
     }
 }
-
-function parseControlOutputs(value: YamlValue | undefined): readonly ControlOutput[] | undefined {
+function parseControlOutputs(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -273,11 +680,7 @@ function parseControlOutputs(value: YamlValue | undefined): readonly ControlOutp
         };
     });
 }
-
-function parseOptionalControlOutputSwitchMode(
-    value: YamlValue | undefined,
-    path: string,
-): ControlOutputSwitchMode | undefined {
+function parseOptionalControlOutputSwitchMode(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -290,8 +693,7 @@ function parseOptionalControlOutputSwitchMode(
             throw new Error(`${path}: expected momentary or latching`);
     }
 }
-
-function parseControlInterfaces(value: YamlValue | undefined): readonly ControlInterface[] | undefined {
+function parseControlInterfaces(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -302,10 +704,7 @@ function parseControlInterfaces(value: YamlValue | undefined): readonly ControlI
         const controlRole = parseOptionalString(controlInterface.controlRole, `${path}.controlRole`);
         const interfaceName = parseOptionalString(controlInterface.interface, `${path}.interface`);
         const connector = parseOptionalControlInterfaceConnector(controlInterface.connector, `${path}.connector`);
-        const assignmentHint = parseOptionalControlInterfaceAssignmentHint(
-            controlInterface.assignmentHint,
-            `${path}.assignmentHint`,
-        );
+        const assignmentHint = parseOptionalControlInterfaceAssignmentHint(controlInterface.assignmentHint, `${path}.assignmentHint`);
         const polarity = parseOptionalControlInterfacePolarity(controlInterface.polarity, `${path}.polarity`);
         const binding = parseOptionalControlInterfaceBinding(controlInterface.binding, `${path}.binding`);
         const description = parseOptionalString(controlInterface.description, `${path}.description`);
@@ -324,11 +723,7 @@ function parseControlInterfaces(value: YamlValue | undefined): readonly ControlI
         };
     });
 }
-
-function parseOptionalControlInterfaceBinding(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterface['binding'] | undefined {
+function parseOptionalControlInterfaceBinding(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -344,8 +739,7 @@ function parseOptionalControlInterfaceBinding(
         ...(property === undefined ? {} : { property }),
     };
 }
-
-function parseControlInterfaceRole(value: YamlValue | undefined, path: string): ControlInterfaceRole {
+function parseControlInterfaceRole(value, path) {
     const role = expectString(value, path);
     switch (role) {
         case 'external-control':
@@ -360,11 +754,7 @@ function parseControlInterfaceRole(value: YamlValue | undefined, path: string):
             throw new Error(`${path}: expected external-control, tempo-tap, trigger, reset, sampler-trigger, expression, or unknown`);
     }
 }
-
-function parseOptionalControlInterfaceConnector(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterfaceConnector | undefined {
+function parseOptionalControlInterfaceConnector(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -381,11 +771,7 @@ function parseOptionalControlInterfaceConnector(
             throw new Error(`${path}: expected a supported connector kind`);
     }
 }
-
-function parseOptionalControlInterfaceAssignmentHint(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterfaceAssignmentHint | undefined {
+function parseOptionalControlInterfaceAssignmentHint(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -400,11 +786,7 @@ function parseOptionalControlInterfaceAssignmentHint(
             throw new Error(`${path}: expected momentary, latching, momentary-or-latching, or continuous`);
     }
 }
-
-function parseOptionalControlInterfacePolarity(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterfacePolarity | undefined {
+function parseOptionalControlInterfacePolarity(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -419,13 +801,12 @@ function parseOptionalControlInterfacePolarity(
             throw new Error(`${path}: expected normally-open, normally-closed, expression, or unknown`);
     }
 }
-
-function parseYamlSubset(source: string): YamlValue {
+function parseYamlSubset(source) {
     const lines = tokenize(source);
     if (lines.length === 0) {
         throw new Error('interchange YAML is empty');
     }
-    const cursor: Cursor = { index: 0 };
+    const cursor = { index: 0 };
     const first = lines[0];
     if (first === undefined) {
         throw new Error('interchange YAML is empty');
@@ -437,9 +818,8 @@ function parseYamlSubset(source: string): YamlValue {
     }
     return value;
 }
-
-function tokenize(source: string): readonly YamlLine[] {
-    const lines: YamlLine[] = [];
+function tokenize(source) {
+    const lines = [];
     const rawLines = source.replace(/^/, '').split(/\r?\n/);
     rawLines.forEach((rawLine, index) => {
         if (rawLine.trim().length === 0) {
@@ -457,8 +837,7 @@ function tokenize(source: string): readonly YamlLine[] {
     });
     return lines;
 }
-
-function parseBlock(lines: readonly YamlLine[], cursor: Cursor, indent: number): YamlValue {
+function parseBlock(lines, cursor, indent) {
     const line = lines[cursor.index];
     if (line === undefined) {
         return {};
@@ -471,9 +850,8 @@ function parseBlock(lines: readonly YamlLine[], cursor: Cursor, indent: number):
     }
     return parseObject(lines, cursor, indent);
 }
-
-function parseObject(lines: readonly YamlLine[], cursor: Cursor, indent: number): YamlObject {
-    const out: YamlObject = {};
+function parseObject(lines, cursor, indent) {
+    const out = {};
     while (cursor.index < lines.length) {
         const line = lines[cursor.index];
         if (line === undefined || line.indent < indent) {
@@ -485,7 +863,6 @@ function parseObject(lines: readonly YamlLine[], cursor: Cursor, indent: number)
         if (line.text === '-' || line.text.startsWith('- ')) {
             break;
         }
-
         const pair = parsePair(line.text, line.lineNumber);
         cursor.index += 1;
         out[pair.key] = pair.rest.length > 0
@@ -494,9 +871,8 @@ function parseObject(lines: readonly YamlLine[], cursor: Cursor, indent: number)
     }
     return out;
 }
-
-function parseArray(lines: readonly YamlLine[], cursor: Cursor, indent: number): readonly YamlValue[] {
-    const out: YamlValue[] = [];
+function parseArray(lines, cursor, indent) {
+    const out = [];
     while (cursor.index < lines.length) {
         const line = lines[cursor.index];
         if (line === undefined || line.indent < indent) {
@@ -508,33 +884,26 @@ function parseArray(lines: readonly YamlLine[], cursor: Cursor, indent: number):
         if (line.text !== '-' && !line.text.startsWith('- ')) {
             break;
         }
-
         const rest = line.text === '-' ? '' : line.text.slice(2);
         cursor.index += 1;
         if (rest.length === 0) {
             out.push(parseNestedValue(lines, cursor, indent, line.lineNumber));
-        } else if (looksLikePair(rest)) {
+        }
+        else if (looksLikePair(rest)) {
             out.push(parseObjectItem(rest, lines, cursor, indent + 2, line.lineNumber));
-        } else {
+        }
+        else {
             out.push(parseInlineValue(rest, line.lineNumber));
         }
     }
     return out;
 }
-
-function parseObjectItem(
-    firstPairText: string,
-    lines: readonly YamlLine[],
-    cursor: Cursor,
-    indent: number,
-    lineNumber: number,
-): YamlObject {
-    const out: YamlObject = {};
+function parseObjectItem(firstPairText, lines, cursor, indent, lineNumber) {
+    const out = {};
     const firstPair = parsePair(firstPairText, lineNumber);
     out[firstPair.key] = firstPair.rest.length > 0
         ? parseInlineValue(firstPair.rest, lineNumber)
         : parseNestedValue(lines, cursor, indent, lineNumber);
-
     while (cursor.index < lines.length) {
         const line = lines[cursor.index];
         if (line === undefined || line.indent < indent) {
@@ -546,23 +915,15 @@ function parseObjectItem(
         if (line.text === '-' || line.text.startsWith('- ')) {
             break;
         }
-
         const pair = parsePair(line.text, line.lineNumber);
         cursor.index += 1;
         out[pair.key] = pair.rest.length > 0
             ? parseInlineValue(pair.rest, line.lineNumber)
             : parseNestedValue(lines, cursor, indent, line.lineNumber);
     }
-
     return out;
 }
-
-function parseNestedValue(
-    lines: readonly YamlLine[],
-    cursor: Cursor,
-    parentIndent: number,
-    lineNumber: number,
-): YamlValue {
+function parseNestedValue(lines, cursor, parentIndent, lineNumber) {
     const next = lines[cursor.index];
     if (next === undefined || next.indent <= parentIndent) {
         return {};
@@ -572,8 +933,7 @@ function parseNestedValue(
     }
     return parseBlock(lines, cursor, next.indent);
 }
-
-function parsePair(text: string, lineNumber: number): ParsedPair {
+function parsePair(text, lineNumber) {
     const colonIndex = findPairColon(text);
     if (colonIndex <= 0) {
         throw new Error(`line ${lineNumber}: expected key/value pair`);
@@ -585,20 +945,17 @@ function parsePair(text: string, lineNumber: number): ParsedPair {
         rest: restText.startsWith(' ') ? restText.slice(1) : restText,
     };
 }
-
-function looksLikePair(text: string): boolean {
+function looksLikePair(text) {
     return findPairColon(text) > 0;
 }
-
-function findPairColon(text: string): number {
+function findPairColon(text) {
     if (text.startsWith('"')) {
         const end = findJsonStringEnd(text);
         return end >= 0 && text[end + 1] === ':' ? end + 1 : -1;
     }
     return text.indexOf(':');
 }
-
-function findJsonStringEnd(text: string): number {
+function findJsonStringEnd(text) {
     let escaped = false;
     for (let index = 1; index < text.length; index += 1) {
         const char = text[index];
@@ -616,8 +973,7 @@ function findJsonStringEnd(text: string): number {
     }
     return -1;
 }
-
-function parseKey(text: string, lineNumber: number): string {
+function parseKey(text, lineNumber) {
     if (!text.startsWith('"')) {
         return text;
     }
@@ -626,13 +982,13 @@ function parseKey(text: string, lineNumber: number): string {
         if (typeof parsed === 'string') {
             return parsed;
         }
-    } catch {
+    }
+    catch {
         // Fall through to the consistent parser error below.
     }
     throw new Error(`line ${lineNumber}: invalid quoted key`);
 }
-
-function parseInlineValue(text: string, lineNumber: number): YamlValue {
+function parseInlineValue(text, lineNumber) {
     if (text === '[]') {
         return [];
     }
@@ -654,7 +1010,8 @@ function parseInlineValue(text: string, lineNumber: number): YamlValue {
             if (typeof parsed === 'string') {
                 return parsed;
             }
-        } catch {
+        }
+        catch {
             // Fall through to the consistent parser error below.
         }
         throw new Error(`line ${lineNumber}: invalid quoted scalar`);
@@ -664,8 +1021,7 @@ function parseInlineValue(text: string, lineNumber: number): YamlValue {
     }
     return text;
 }
-
-function parseMetadata(value: YamlValue | undefined): CircuitDocument['metadata'] {
+function parseMetadata(value) {
     const metadata = optionalObject(value, 'metadata');
     return {
         name: scalarText(metadata.name),
@@ -673,53 +1029,51 @@ function parseMetadata(value: YamlValue | undefined): CircuitDocument['metadata'
         partNumber: scalarText(metadata.partNumber),
     };
 }
-
-function parseSource(value: YamlValue | undefined): DocumentSource {
+function parseSource(value) {
     return parseStringRecord(value, 'source');
 }
-
-function parsePanel(value: YamlValue | undefined): PanelPlacementMetadata | undefined {
+function parsePanel(value, allowV3PhysicalFields) {
     if (value === undefined) {
         return undefined;
     }
     const panel = expectObject(value, 'panel');
-
     if (panel.faces !== undefined) {
         return {
-            faces: optionalArray(panel.faces, 'panel.faces').map((item, index) => parsePanelFace(item, index)),
+            faces: optionalArray(panel.faces, 'panel.faces').map((item, index) => parsePanelFace(item, index, allowV3PhysicalFields)),
         };
     }
-
     if (panel.layout === undefined) {
         return undefined;
     }
-
     const layout = parsePanelLayout(panel.layout, 'panel.layout');
     const elementsValue = panel.controls ?? panel.elements;
     const elementsPath = panel.controls === undefined ? 'panel.elements' : 'panel.controls';
     return {
         faces: [{
-            id: 'top',
-            layout,
-            elements: parsePanelElements(elementsValue, layout, elementsPath),
-        }],
+                id: 'top',
+                layout,
+                elements: parsePanelElements(elementsValue, layout, elementsPath, allowV3PhysicalFields),
+            }],
     };
 }
-
-function parsePanelFace(value: YamlValue, index: number): PanelPlacementMetadata['faces'][number] {
+function parsePanelFace(value, index, allowV3PhysicalFields) {
     const path = `panel.faces[${index}]`;
     const face = expectObject(value, path);
     const label = parseOptionalString(face.label, `${path}.label`);
     const layout = parsePanelLayout(face.layout, `${path}.layout`);
+    if (!allowV3PhysicalFields && face.geometry !== undefined) {
+        throw new Error(`${path}.geometry: requires schema ${INTERCHANGE_SCHEMA_V3}`);
+    }
+    const geometry = allowV3PhysicalFields ? parseOptionalPanelFaceGeometry(face.geometry, `${path}.geometry`) : undefined;
     return {
         id: expectString(face.id, `${path}.id`),
         ...(label === undefined ? {} : { label }),
         layout,
-        elements: parsePanelElements(face.elements, layout, `${path}.elements`),
+        ...(geometry === undefined ? {} : { geometry }),
+        elements: parsePanelElements(face.elements, layout, `${path}.elements`, allowV3PhysicalFields),
     };
 }
-
-function parsePanelLayout(value: YamlValue | undefined, path: string): PanelGridLayout {
+function parsePanelLayout(value, path) {
     const layout = expectObject(value, path);
     const rowOrder = parseOptionalPanelRowOrder(layout.rowOrder, `${path}.rowOrder`);
     const columnOrder = parseOptionalPanelColumnOrder(layout.columnOrder, `${path}.columnOrder`);
@@ -732,33 +1086,77 @@ function parsePanelLayout(value: YamlValue | undefined, path: string): PanelGrid
         ...(columnOrder === undefined ? {} : { columnOrder }),
     };
 }
-
-function parsePanelElements(
-    value: YamlValue | undefined,
-    layout: PanelGridLayout,
-    path: string,
-): PanelPlacementMetadata['faces'][number]['elements'] {
+function parsePanelElements(value, layout, path, allowV3PhysicalFields) {
     return optionalArray(value, path).map((item, index) => {
         const elementPath = `${path}[${index}]`;
         const element = expectObject(item, elementPath);
         const label = parseOptionalString(element.label, `${elementPath}.label`);
         const interfaceControlId = parseOptionalString(element.interfaceControlId, `${elementPath}.interfaceControlId`);
+        if (!allowV3PhysicalFields && element.id !== undefined) {
+            throw new Error(`${elementPath}.id: requires schema ${INTERCHANGE_SCHEMA_V3}`);
+        }
+        if (!allowV3PhysicalFields && element.physical !== undefined) {
+            throw new Error(`${elementPath}.physical: requires schema ${INTERCHANGE_SCHEMA_V3}`);
+        }
+        const id = allowV3PhysicalFields ? parseOptionalString(element.id, `${elementPath}.id`) : undefined;
+        const physical = allowV3PhysicalFields
+            ? parseOptionalPanelElementPhysical(element.physical, `${elementPath}.physical`)
+            : undefined;
         return {
+            ...(id === undefined ? {} : { id }),
             bind: parsePanelElementBinding(element, elementPath),
-            kind: parsePanelControlKind(
-                element.kind ?? element.controlKind,
-                element.kind === undefined && element.controlKind !== undefined
-                    ? `${elementPath}.controlKind`
-                    : `${elementPath}.kind`,
-            ),
+            kind: parsePanelControlKind(element.kind ?? element.controlKind, element.kind === undefined && element.controlKind !== undefined
+                ? `${elementPath}.controlKind`
+                : `${elementPath}.kind`),
             grid: parsePanelGridPosition(element.grid, `${elementPath}.grid`, layout),
             ...(label === undefined ? {} : { label }),
             ...(interfaceControlId === undefined ? {} : { interfaceControlId }),
+            ...(physical === undefined ? {} : { physical }),
         };
     });
 }
-
-function parsePanelElementBinding(element: YamlObject, path: string): PanelElementBinding {
+function parseOptionalPanelFaceGeometry(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const geometry = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(geometry, path),
+        ...(geometry.units === undefined ? {} : { units: expectString(geometry.units, `${path}.units`) }),
+        ...(geometry.surface === undefined ? {} : { surface: expectString(geometry.surface, `${path}.surface`) }),
+        ...(geometry.usableRectMm === undefined
+            ? {}
+            : { usableRectMm: parseMillimeterRect(geometry.usableRectMm, `${path}.usableRectMm`) }),
+    };
+}
+function parseOptionalPanelElementPhysical(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const physical = expectObject(value, path);
+    return {
+        ...parseBuildDataObject(physical, path),
+        ...(physical.units === undefined ? {} : { units: expectString(physical.units, `${path}.units`) }),
+        ...(physical.centerMm === undefined ? {} : { centerMm: parsePoint(physical.centerMm, `${path}.centerMm`) }),
+        ...(physical.drillDiameterMm === undefined
+            ? {}
+            : { drillDiameterMm: expectNumber(physical.drillDiameterMm, `${path}.drillDiameterMm`) }),
+        ...(physical.partProfileId === undefined
+            ? {}
+            : { partProfileId: expectString(physical.partProfileId, `${path}.partProfileId`) }),
+        ...(physical.locked === undefined ? {} : { locked: expectBoolean(physical.locked, `${path}.locked`) }),
+    };
+}
+function parseMillimeterRect(value, path) {
+    const rect = expectObject(value, path);
+    return {
+        x: expectNumber(rect.x, `${path}.x`),
+        y: expectNumber(rect.y, `${path}.y`),
+        width: expectNumber(rect.width, `${path}.width`),
+        height: expectNumber(rect.height, `${path}.height`),
+    };
+}
+function parsePanelElementBinding(element, path) {
     if (element.bind !== undefined) {
         const bind = expectObject(element.bind, `${path}.bind`);
         const controlId = parseOptionalString(bind.controlId, `${path}.bind.controlId`);
@@ -771,17 +1169,11 @@ function parsePanelElementBinding(element: YamlObject, path: string): PanelEleme
             ...(property === undefined ? {} : { property }),
         };
     }
-
     return {
         componentId: expectString(element.componentId, `${path}.componentId`),
     };
 }
-
-function parsePanelGridPosition(
-    value: YamlValue | undefined,
-    path: string,
-    layout: PanelGridLayout,
-): PanelGridPosition {
+function parsePanelGridPosition(value, path, layout) {
     const grid = expectObject(value, path);
     const rowSpan = parseOptionalPositiveInteger(grid.rowSpan, `${path}.rowSpan`);
     const columnSpan = parseOptionalPositiveInteger(grid.columnSpan, `${path}.columnSpan`);
@@ -796,15 +1188,7 @@ function parsePanelGridPosition(
         ...(columnSpan === undefined ? {} : { columnSpan }),
     };
 }
-
-function validateGridAxis(
-    value: number,
-    span: number,
-    size: number,
-    indexing: PanelGridIndexing,
-    path: string,
-    axisName: 'row' | 'column',
-): void {
+function validateGridAxis(value, span, size, indexing, path, axisName) {
     const min = indexing === 'one-based' ? 1 : 0;
     const occupiedEnd = indexing === 'one-based' ? value + span - 1 : value + span;
     if (value < min || occupiedEnd > size) {
@@ -812,24 +1196,21 @@ function validateGridAxis(
         throw new Error(`${path}: expected ${indexing} ${axisName} coordinate within ${min}..${maxLabel}`);
     }
 }
-
-function parsePanelLayoutKind(value: YamlValue | undefined, path: string): 'stompbox-grid' {
+function parsePanelLayoutKind(value, path) {
     const kind = expectString(value, path);
     if (kind === 'stompbox-grid') {
         return kind;
     }
     throw new Error(`${path}: expected stompbox-grid`);
 }
-
-function parsePanelGridIndexing(value: YamlValue | undefined, path: string): PanelGridIndexing {
+function parsePanelGridIndexing(value, path) {
     const indexing = expectString(value, path);
     if (indexing === 'one-based' || indexing === 'zero-based') {
         return indexing;
     }
     throw new Error(`${path}: expected one-based or zero-based`);
 }
-
-function parseOptionalPanelRowOrder(value: YamlValue | undefined, path: string): PanelRowOrder | undefined {
+function parseOptionalPanelRowOrder(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -839,8 +1220,7 @@ function parseOptionalPanelRowOrder(value: YamlValue | undefined, path: string):
     }
     throw new Error(`${path}: expected top-to-bottom or bottom-to-top`);
 }
-
-function parseOptionalPanelColumnOrder(value: YamlValue | undefined, path: string): PanelColumnOrder | undefined {
+function parseOptionalPanelColumnOrder(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -850,22 +1230,22 @@ function parseOptionalPanelColumnOrder(value: YamlValue | undefined, path: strin
     }
     throw new Error(`${path}: expected left-to-right or right-to-left`);
 }
-
-function parsePanelControlKind(value: YamlValue | undefined, path: string): PanelControlKind {
+function parsePanelControlKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'knob':
         case 'slider':
         case 'switch':
+        case 'selector':
+        case 'footswitch':
         case 'led':
         case 'jack':
             return kind;
         default:
-            throw new Error(`${path}: expected knob, slider, switch, led, or jack`);
+            throw new Error(`${path}: expected knob, slider, switch, selector, footswitch, led, or jack`);
     }
 }
-
-function parseComponents(value: YamlValue | undefined): readonly Component[] {
+function parseComponents(value) {
     return optionalArray(value, 'components').map((item, index) => {
         const path = `components[${index}]`;
         const component = expectObject(item, path);
@@ -882,8 +1262,7 @@ function parseComponents(value: YamlValue | undefined): readonly Component[] {
         };
     });
 }
-
-function parseTerminals(value: YamlValue | undefined, path: string): readonly Terminal[] {
+function parseTerminals(value, path) {
     return optionalArray(value, path).map((item, index) => {
         const terminalPath = `${path}[${index}]`;
         const terminal = expectObject(item, terminalPath);
@@ -893,17 +1272,15 @@ function parseTerminals(value: YamlValue | undefined, path: string): readonly Te
         };
     });
 }
-
-function parseProperties(value: YamlValue | undefined, path: string): Readonly<Record<string, PropertyValue>> {
+function parseProperties(value, path) {
     const properties = optionalObject(value, path);
-    const out: Record<string, PropertyValue> = {};
+    const out = {};
     for (const [key, child] of Object.entries(properties)) {
         out[key] = parsePropertyValue(child, `${path}.${key}`);
     }
     return out;
 }
-
-function parsePropertyValue(value: YamlValue, path: string): PropertyValue {
+function parsePropertyValue(value, path) {
     if (isParsedQuantityValue(value)) {
         return {
             raw: expectString(value.raw, `${path}.raw`),
@@ -915,7 +1292,7 @@ function parsePropertyValue(value: YamlValue, path: string): PropertyValue {
         return value.map((item, index) => parsePropertyValue(item, `${path}[${index}]`));
     }
     if (isYamlObject(value)) {
-        const out: Record<string, PropertyValue> = {};
+        const out = {};
         for (const [key, child] of Object.entries(value)) {
             out[key] = parsePropertyValue(child, `${path}.${key}`);
         }
@@ -926,12 +1303,10 @@ function parsePropertyValue(value: YamlValue, path: string): PropertyValue {
     }
     throw new Error(`${path}: expected scalar property value or parsed quantity`);
 }
-
-function isParsedQuantityValue(value: YamlValue): value is ParsedQuantity {
+function isParsedQuantityValue(value) {
     return isParsedQuantity(value);
 }
-
-function parseWires(value: YamlValue | undefined): readonly Wire[] {
+function parseWires(value) {
     return optionalArray(value, 'wires').map((item, index) => {
         const path = `wires[${index}]`;
         const wire = expectObject(item, path);
@@ -947,12 +1322,11 @@ function parseWires(value: YamlValue | undefined): readonly Wire[] {
         };
     });
 }
-
-function parseWarnings(value: YamlValue | undefined): readonly Warning[] {
+function parseWarnings(value) {
     return optionalArray(value, 'diagnostics').map((item, index) => {
         const path = `diagnostics[${index}]`;
         const warning = expectObject(item, path);
-        const out: Warning = {
+        const out = {
             code: expectString(warning.code, `${path}.code`),
             message: expectString(warning.message, `${path}.message`),
             ...(warning.componentId === undefined
@@ -965,44 +1339,38 @@ function parseWarnings(value: YamlValue | undefined): readonly Warning[] {
         return out;
     });
 }
-
-function parseStringArray(value: YamlValue | undefined, path: string): readonly string[] {
+function parseStringArray(value, path) {
     return optionalArray(value, path).map((item, index) => scalarText(item, `${path}[${index}]`));
 }
-
-function parseStringRecord(value: YamlValue | undefined, path: string): Readonly<Record<string, string>> {
+function parseStringRecord(value, path) {
     const record = optionalObject(value, path);
-    const out: Record<string, string> = {};
+    const out = {};
     for (const [key, child] of Object.entries(record)) {
         out[key] = scalarText(child, `${path}.${key}`);
     }
     return out;
 }
-
-function parsePoint(value: YamlValue | undefined, path: string): Point {
+function parsePoint(value, path) {
     const point = expectObject(value, path);
     return {
         x: expectNumber(point.x, `${path}.x`),
         y: expectNumber(point.y, `${path}.y`),
     };
 }
-
-function parseRotation(value: YamlValue | undefined, path: string): Rotation {
+function parseRotation(value, path) {
     const rotation = expectNumber(value, path);
     if (rotation === 0 || rotation === 1 || rotation === 2 || rotation === 3) {
         return rotation;
     }
     throw new Error(`${path}: expected rotation 0, 1, 2, or 3`);
 }
-
-function parseNullableString(value: YamlValue | undefined, path: string): string | null {
+function parseNullableString(value, path) {
     if (value === null || value === undefined) {
         return null;
     }
     return expectString(value, path);
 }
-
-function parseComponentKind(value: YamlValue | undefined, path: string): ComponentKind {
+function parseComponentKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'resistor':
@@ -1045,108 +1413,93 @@ function parseComponentKind(value: YamlValue | undefined, path: string): Compone
             throw new Error(`${path}: unsupported component kind "${kind}"`);
     }
 }
-
-function optionalObject(value: YamlValue | undefined, path: string): YamlObject {
+function optionalObject(value, path) {
     if (value === undefined) {
         return {};
     }
     return expectObject(value, path);
 }
-
-function optionalArray(value: YamlValue | undefined, path: string): readonly YamlValue[] {
+function optionalArray(value, path) {
     if (value === undefined) {
         return [];
     }
     return expectArray(value, path);
 }
-
-function expectObject(value: YamlValue | undefined, path: string): YamlObject {
+function expectObject(value, path) {
     if (isYamlObject(value)) {
         return value;
     }
     throw new Error(`${path}: expected object`);
 }
-
-function expectArray(value: YamlValue | undefined, path: string): readonly YamlValue[] {
+function expectArray(value, path) {
     if (Array.isArray(value)) {
         return value;
     }
     throw new Error(`${path}: expected array`);
 }
-
-function expectString(value: YamlValue | undefined, path: string): string {
+function expectString(value, path) {
     if (typeof value === 'string') {
         return value;
     }
     throw new Error(`${path}: expected string`);
 }
-
-function expectNumber(value: YamlValue | undefined, path: string): number {
+function expectNumber(value, path) {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
     }
     throw new Error(`${path}: expected number`);
 }
-
-function expectPositiveInteger(value: YamlValue | undefined, path: string): number {
+function expectPositiveInteger(value, path) {
     const number = expectNumber(value, path);
     if (Number.isInteger(number) && number > 0) {
         return number;
     }
     throw new Error(`${path}: expected positive integer`);
 }
-
-function expectNonNegativeInteger(value: YamlValue | undefined, path: string): number {
+function expectNonNegativeInteger(value, path) {
     const number = expectNumber(value, path);
     if (Number.isInteger(number) && number >= 0) {
         return number;
     }
     throw new Error(`${path}: expected non-negative integer`);
 }
-
-function parseOptionalPositiveInteger(value: YamlValue | undefined, path: string): number | undefined {
+function parseOptionalPositiveInteger(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectPositiveInteger(value, path);
 }
-
-function parseOptionalNumber(value: YamlValue | undefined, path: string): number | undefined {
+function parseOptionalNumber(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectNumber(value, path);
 }
-
-function parseOptionalString(value: YamlValue | undefined, path: string): string | undefined {
+function parseOptionalString(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectString(value, path);
 }
-
-function parseOptionalStringArray(value: YamlValue | undefined, path: string): readonly string[] | undefined {
+function parseOptionalStringArray(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectArray(value, path).map((item, index) => expectString(item, `${path}[${index}]`));
 }
-
-function parseOptionalBoolean(value: YamlValue | undefined, path: string): boolean | undefined {
+function parseOptionalBoolean(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectBoolean(value, path);
 }
-
-function expectBoolean(value: YamlValue | undefined, path: string): boolean {
+function expectBoolean(value, path) {
     if (typeof value === 'boolean') {
         return value;
     }
     throw new Error(`${path}: expected boolean`);
 }
-
-function scalarText(value: YamlValue | undefined, path = 'value'): string {
+function scalarText(value, path = 'value') {
     if (value === undefined || value === null) {
         return '';
     }
@@ -1155,11 +1508,10 @@ function scalarText(value: YamlValue | undefined, path = 'value'): string {
     }
     throw new Error(`${path}: expected scalar`);
 }
-
-function isScalar(value: YamlValue): value is YamlScalar {
+function isScalar(value) {
     return value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
 }
-
-function isYamlObject(value: YamlValue | undefined): value is YamlObject {
+function isYamlObject(value) {
     return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+//# sourceMappingURL=parser.js.map