@vessel-dsp/core 0.6.3 → 0.6.5

package/dist/formats/interchange/parser.js

@@ -1,19 +1,19 @@
-import { isParsedQuantity } from '../../model/properties.js';
-const INTERCHANGE_SCHEMA_V2 = 'circuit-interchange/v2';
-const INTERCHANGE_SCHEMA_V3 = 'circuit-interchange/v3';
+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',
+    "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');
+    const root = expectObject(value, "root");
+    const schema = expectString(root.schema, "schema");
     if (schema !== INTERCHANGE_SCHEMA_V2 && schema !== INTERCHANGE_SCHEMA_V3) {
         throw new Error(`unsupported interchange schema: ${schema}`);
     }
@@ -33,7 +33,9 @@ export function parseInterchangeYaml(source) {
     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 offBoardWiring = isV3
+        ? parseOffBoardWiring(root.offBoardWiring)
+        : undefined;
     const boards = isV3 ? parseBoards(root.boards) : undefined;
     return {
         metadata: parseMetadata(root.metadata),
@@ -54,9 +56,9 @@ export function parseInterchangeYaml(source) {
         ...(controlOutputs === undefined ? {} : { controlOutputs }),
         components: parseComponents(root.components),
         wires: parseWires(root.wires),
-        directives: parseStringArray(root.directives, 'directives'),
+        directives: parseStringArray(root.directives, "directives"),
         warnings: parseWarnings(root.diagnostics),
-        rawAttributes: parseStringRecord(root.rawAttributes, 'rawAttributes'),
+        rawAttributes: parseStringRecord(root.rawAttributes, "rawAttributes"),
     };
 }
 function rejectV3OnlyTopLevelFields(root) {
@@ -70,49 +72,64 @@ function parseMechanical(value) {
     if (value === undefined) {
         return undefined;
     }
-    const mechanical = expectObject(value, 'mechanical');
+    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') }),
+        ...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');
+    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') }),
+        ...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') }),
+            : {
+                completeness: parseBuildCompleteness(build.completeness, "build.completeness"),
+            }),
         ...(build.selectedBoardId === undefined
             ? {}
-            : { selectedBoardId: expectString(build.selectedBoardId, 'build.selectedBoardId') }),
+            : {
+                selectedBoardId: expectString(build.selectedBoardId, "build.selectedBoardId"),
+            }),
         ...(build.selectedOffBoardWiringHarnessIds === undefined
             ? {}
             : {
-                selectedOffBoardWiringHarnessIds: parseOptionalStringArray(build.selectedOffBoardWiringHarnessIds, 'build.selectedOffBoardWiringHarnessIds') ?? [],
+                selectedOffBoardWiringHarnessIds: parseOptionalStringArray(build.selectedOffBoardWiringHarnessIds, "build.selectedOffBoardWiringHarnessIds") ?? [],
             }),
         ...(build.alternateBoardIds === undefined
             ? {}
-            : { alternateBoardIds: parseOptionalStringArray(build.alternateBoardIds, 'build.alternateBoardIds') ?? [] }),
-        ...(build.bomScope === undefined ? {} : { bomScope: expectString(build.bomScope, 'build.bomScope') }),
+            : {
+                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') {
+    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') {
+    if (completeness === "complete-selected-build" ||
+        completeness === "partial-offboard-wiring") {
         return completeness;
     }
     throw new Error(`${path}: expected complete-selected-build or partial-offboard-wiring`);
@@ -121,11 +138,11 @@ function parseBom(value) {
     if (value === undefined) {
         return undefined;
     }
-    const bom = expectObject(value, 'bom');
+    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),
+        ...parseBuildDataObject(bom, "bom"),
+        schema: parseLiteralString(bom.schema, "bom.schema", "build-bom/v1"),
+        items: optionalArray(bom.items, "bom.items").map(parseBomItem),
     };
 }
 function parseBomItem(value, index) {
@@ -136,33 +153,53 @@ function parseBomItem(value, index) {
         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.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`) }),
+            : {
+                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':
+        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.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`) }),
+                    : {
+                        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`);
@@ -172,15 +209,19 @@ function parsePartProfiles(value) {
     if (value === undefined) {
         return undefined;
     }
-    const catalog = expectObject(value, 'partProfiles');
+    const catalog = expectObject(value, "partProfiles");
     return {
-        ...parseBuildDataObject(catalog, 'partProfiles'),
-        schema: parseLiteralString(catalog.schema, 'partProfiles.schema', 'part-profile-catalog/v1'),
+        ...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)),
+            : {
+                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) {
@@ -189,20 +230,28 @@ function parsePartProfile(value, index) {
     return {
         ...parseBuildDataObject(profile, path),
         id: expectString(profile.id, `${path}.id`),
-        ...(profile.kind === undefined ? {} : { kind: expectString(profile.kind, `${path}.kind`) }),
+        ...(profile.kind === undefined
+            ? {}
+            : { kind: expectString(profile.kind, `${path}.kind`) }),
     };
 }
 function parseFootprints(value) {
     if (value === undefined) {
         return undefined;
     }
-    const catalog = expectObject(value, 'footprints');
+    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)),
+        ...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) {
@@ -213,7 +262,9 @@ function parseFootprint(value, index) {
         id: expectString(footprint.id, `${path}.id`),
         ...(footprint.boardApplicability === undefined
             ? {}
-            : { boardApplicability: parseBoardApplicability(footprint.boardApplicability, `${path}.boardApplicability`) }),
+            : {
+                boardApplicability: parseBoardApplicability(footprint.boardApplicability, `${path}.boardApplicability`),
+            }),
     };
 }
 function parseBoardApplicability(value, path) {
@@ -224,27 +275,34 @@ function parseBoardApplicability(value, path) {
         kind: parseBoardKind(applicability.kind, `${path}.kind`),
         ...(applicability.subtype === undefined
             ? {}
-            : { subtype: parseBoardSubtype(applicability.subtype, `${path}.subtype`) }),
+            : {
+                subtype: parseBoardSubtype(applicability.subtype, `${path}.subtype`),
+            }),
     };
 }
 function parseOffBoardWiring(value) {
     if (value === undefined) {
         return undefined;
     }
-    const plan = expectObject(value, 'offBoardWiring');
+    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') }),
+        ...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),
+            : {
+                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') {
+    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`);
@@ -257,15 +315,19 @@ function parseOffBoardWiringHarness(value, index) {
         id: expectString(harness.id, `${path}.id`),
         ...(harness.status === undefined
             ? {}
-            : { status: parseOffBoardWiringHarnessStatus(harness.status, `${path}.status`) }),
-        ...(harness.notes === undefined ? {} : { notes: expectString(harness.notes, `${path}.notes`) }),
+            : {
+                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') {
+    if (status === "complete" || status === "partial" || status === "candidate") {
         return status;
     }
     throw new Error(`${path}: expected complete, partial, or candidate`);
@@ -274,29 +336,41 @@ 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':
+        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`) }),
+                    : {
+                        componentId: expectString(endpoint.componentId, `${path}.componentId`),
+                    }),
                 ...(endpoint.terminalName === undefined
                     ? {}
-                    : { terminalName: expectString(endpoint.terminalName, `${path}.terminalName`) }),
+                    : {
+                        terminalName: expectString(endpoint.terminalName, `${path}.terminalName`),
+                    }),
                 ...(endpoint.panelElementId === undefined
                     ? {}
-                    : { panelElementId: expectString(endpoint.panelElementId, `${path}.panelElementId`) }),
-                ...(endpoint.boardId === undefined ? {} : { boardId: expectString(endpoint.boardId, `${path}.boardId`) }),
+                    : {
+                        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`) }),
+                    : {
+                        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`);
@@ -311,15 +385,19 @@ function parseOffBoardWiringConnection(value, path) {
         toEndpointId: expectString(connection.toEndpointId, `${path}.toEndpointId`),
         ...(connection.signalRef === undefined
             ? {}
-            : { signalRef: parseBuildDataObject(connection.signalRef, `${path}.signalRef`) }),
-        ...(connection.wire === undefined ? {} : { wire: parseBuildDataObject(connection.wire, `${path}.wire`) }),
+            : {
+                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);
+    return optionalArray(value, "boards").map(parseBoard);
 }
 function parseBoard(value, index) {
     const path = `boards[${index}]`;
@@ -330,21 +408,37 @@ function parseBoard(value, index) {
     return {
         ...parseBuildDataObject(board, path),
         id: expectString(board.id, `${path}.id`),
-        schema: parseLiteralString(board.schema, `${path}.schema`, 'circuit-board/v1'),
+        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`) }),
+        ...(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`) }),
+        ...(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`) }),
+        ...(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) {
@@ -355,8 +449,8 @@ function parseBoardSourceCircuit(value, path) {
     }
     return {
         ...parseBuildDataObject(sourceCircuit, path),
-        schema: parseLiteralString(sourceCircuit.schema, `${path}.schema`, 'canonical-circuit-facts-hash/v1'),
-        hashAlgorithm: parseLiteralString(sourceCircuit.hashAlgorithm, `${path}.hashAlgorithm`, 'sha256'),
+        schema: parseLiteralString(sourceCircuit.schema, `${path}.schema`, "canonical-circuit-facts-hash/v1"),
+        hashAlgorithm: parseLiteralString(sourceCircuit.hashAlgorithm, `${path}.hashAlgorithm`, "sha256"),
         hash,
     };
 }
@@ -365,11 +459,17 @@ function parseBoardEdgeTerminal(value, path) {
     return {
         ...parseBuildDataObject(terminal, path),
         id: expectString(terminal.id, `${path}.id`),
-        ...(terminal.role === undefined ? {} : { role: expectString(terminal.role, `${path}.role`) }),
+        ...(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`) }),
+            : {
+                terminalRef: parseComponentTerminalRef(terminal.terminalRef, `${path}.terminalRef`),
+            }),
+        ...(terminal.hole === undefined
+            ? {}
+            : { hole: parseBoardHole(terminal.hole, `${path}.hole`) }),
     };
 }
 function parseBoardFootprintPlacement(value, path) {
@@ -378,9 +478,17 @@ function parseBoardFootprintPlacement(value, path) {
         ...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`) }),
+        ...(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}]`)),
     };
 }
@@ -389,16 +497,26 @@ function parseBoardPlacedPad(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`) }),
+        ...(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`) }),
+        ...(netlist.source === undefined
+            ? {}
+            : { source: expectString(netlist.source, `${path}.source`) }),
         nets: optionalArray(netlist.nets, `${path}.nets`).map((net, netIndex) => parseBoardNet(net, `${path}.nets[${netIndex}]`)),
     };
 }
@@ -407,7 +525,9 @@ function parseBoardNet(value, path) {
     return {
         ...parseBuildDataObject(net, path),
         id: expectString(net.id, `${path}.id`),
-        ...(net.name === undefined ? {} : { name: expectString(net.name, `${path}.name`) }),
+        ...(net.name === undefined
+            ? {}
+            : { name: expectString(net.name, `${path}.name`) }),
         members: optionalArray(net.members, `${path}.members`).map((member, memberIndex) => parseBoardNetMember(member, `${path}.members[${memberIndex}]`)),
     };
 }
@@ -417,8 +537,12 @@ function parseBoardNetMember(value, path) {
         ...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`) }),
+        ...(member.padId === undefined
+            ? {}
+            : { padId: expectString(member.padId, `${path}.padId`) }),
+        ...(member.terminalId === undefined
+            ? {}
+            : { terminalId: expectString(member.terminalId, `${path}.terminalId`) }),
     };
 }
 function parseBoardRoute(value, path) {
@@ -426,15 +550,29 @@ function parseBoardRoute(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.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`) }),
+            : {
+                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) {
@@ -455,7 +593,7 @@ function parseBoardHole(value, path) {
 }
 function parseBoardFamily(value, path) {
     const family = expectString(value, path);
-    if (family === 'prototype-board' || family === 'fabricated-board') {
+    if (family === "prototype-board" || family === "fabricated-board") {
         return family;
     }
     throw new Error(`${path}: expected prototype-board or fabricated-board`);
@@ -463,10 +601,10 @@ function parseBoardFamily(value, path) {
 function parseBoardKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
-        case 'stripboard':
-        case 'perfboard':
-        case 'breadboard-pattern':
-        case 'pcb':
+        case "stripboard":
+        case "perfboard":
+        case "breadboard-pattern":
+        case "pcb":
             return kind;
         default:
             throw new Error(`${path}: expected stripboard, perfboard, breadboard-pattern, or pcb`);
@@ -475,11 +613,11 @@ function parseBoardKind(value, path) {
 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':
+        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`);
@@ -519,10 +657,11 @@ function parseControlGroups(value) {
     if (value === undefined) {
         return undefined;
     }
-    return optionalArray(value, 'controlGroups').map((item, index) => {
+    return optionalArray(value, "controlGroups").map((item, index) => {
         const path = `controlGroups[${index}]`;
         const group = expectObject(item, path);
         const contextIds = parseOptionalStringArray(group.contextIds, `${path}.contextIds`);
+        const members = parseControlGroupMembers(group.members, `${path}.members`);
         const description = parseOptionalString(group.description, `${path}.description`);
         return {
             id: expectString(group.id, `${path}.id`),
@@ -530,6 +669,25 @@ function parseControlGroups(value) {
             role: expectString(group.role, `${path}.role`),
             ...(contextIds === undefined ? {} : { contextIds }),
             ...(description === undefined ? {} : { description }),
+            ...(members === undefined ? {} : { members }),
+        };
+    });
+}
+function parseControlGroupMembers(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return optionalArray(value, path).map((item, index) => {
+        const memberPath = `${path}[${index}]`;
+        const member = expectObject(item, memberPath);
+        const order = parseOptionalNumber(member.order, `${memberPath}.order`);
+        const appliesWhen = parseOptionalApplicabilityPredicate(member.appliesWhen, `${memberPath}.appliesWhen`);
+        const description = parseOptionalString(member.description, `${memberPath}.description`);
+        return {
+            controlId: expectString(member.controlId, `${memberPath}.controlId`),
+            ...(order === undefined ? {} : { order }),
+            ...(appliesWhen === undefined ? {} : { appliesWhen }),
+            ...(description === undefined ? {} : { description }),
         };
     });
 }
@@ -537,7 +695,7 @@ function parseControlContexts(value) {
     if (value === undefined) {
         return undefined;
     }
-    return optionalArray(value, 'controlContexts').map((item, index) => {
+    return optionalArray(value, "controlContexts").map((item, index) => {
         const path = `controlContexts[${index}]`;
         const context = expectObject(item, path);
         const description = parseOptionalString(context.description, `${path}.description`);
@@ -553,9 +711,9 @@ function parseDeviceInterface(value) {
     if (value === undefined) {
         return undefined;
     }
-    const deviceInterface = expectObject(value, 'deviceInterface');
+    const deviceInterface = expectObject(value, "deviceInterface");
     return {
-        controls: optionalArray(deviceInterface.controls, 'deviceInterface.controls').map((item, index) => {
+        controls: optionalArray(deviceInterface.controls, "deviceInterface.controls").map((item, index) => {
             const path = `deviceInterface.controls[${index}]`;
             const control = expectObject(item, path);
             const groupId = parseOptionalString(control.groupId, `${path}.groupId`);
@@ -580,13 +738,13 @@ function parseDeviceInterface(value) {
 function parseDeviceInterfaceControlKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
-        case 'knob':
-        case 'slider':
-        case 'switch':
-        case 'selector':
-        case 'footswitch':
-        case 'led':
-        case 'jack':
+        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, selector, footswitch, led, or jack`);
@@ -625,16 +783,16 @@ function parseDevice(value) {
     if (value === undefined) {
         return undefined;
     }
-    const device = expectObject(value, 'device');
-    const id = parseOptionalString(device.id, 'device.id');
-    const version = parseOptionalPositiveInteger(device.version, 'device.version');
-    const family = parseOptionalString(device.family, 'device.family');
-    const model = parseOptionalString(device.model, 'device.model');
-    const audioProcessing = parseOptionalBoolean(device.audioProcessing, 'device.audioProcessing');
+    const device = expectObject(value, "device");
+    const id = parseOptionalString(device.id, "device.id");
+    const version = parseOptionalPositiveInteger(device.version, "device.version");
+    const family = parseOptionalString(device.family, "device.family");
+    const model = parseOptionalString(device.model, "device.model");
+    const audioProcessing = parseOptionalBoolean(device.audioProcessing, "device.audioProcessing");
     return {
         ...(id === undefined ? {} : { id }),
         ...(version === undefined ? {} : { version }),
-        kind: parseCircuitDocumentDeviceKind(device.kind, 'device.kind'),
+        kind: parseCircuitDocumentDeviceKind(device.kind, "device.kind"),
         ...(family === undefined ? {} : { family }),
         ...(model === undefined ? {} : { model }),
         ...(audioProcessing === undefined ? {} : { audioProcessing }),
@@ -643,10 +801,10 @@ function parseDevice(value) {
 function parseCircuitDocumentDeviceKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
-        case 'audio-pedal':
-        case 'control-accessory':
-        case 'utility':
-        case 'unknown':
+        case "audio-pedal":
+        case "control-accessory":
+        case "utility":
+        case "unknown":
             return kind;
         default:
             throw new Error(`${path}: expected audio-pedal, control-accessory, utility, or unknown`);
@@ -656,7 +814,7 @@ function parseControlOutputs(value) {
     if (value === undefined) {
         return undefined;
     }
-    return optionalArray(value, 'controlOutputs').map((item, index) => {
+    return optionalArray(value, "controlOutputs").map((item, index) => {
         const path = `controlOutputs[${index}]`;
         const controlOutput = expectObject(item, path);
         const connector = parseOptionalControlInterfaceConnector(controlOutput.connector, `${path}.connector`);
@@ -686,8 +844,8 @@ function parseOptionalControlOutputSwitchMode(value, path) {
     }
     const switchMode = expectString(value, path);
     switch (switchMode) {
-        case 'momentary':
-        case 'latching':
+        case "momentary":
+        case "latching":
             return switchMode;
         default:
             throw new Error(`${path}: expected momentary or latching`);
@@ -697,7 +855,7 @@ function parseControlInterfaces(value) {
     if (value === undefined) {
         return undefined;
     }
-    return optionalArray(value, 'controlInterfaces').map((item, index) => {
+    return optionalArray(value, "controlInterfaces").map((item, index) => {
         const path = `controlInterfaces[${index}]`;
         const controlInterface = expectObject(item, path);
         const componentId = parseOptionalString(controlInterface.componentId, `${path}.componentId`);
@@ -742,13 +900,13 @@ function parseOptionalControlInterfaceBinding(value, path) {
 function parseControlInterfaceRole(value, path) {
     const role = expectString(value, path);
     switch (role) {
-        case 'external-control':
-        case 'tempo-tap':
-        case 'trigger':
-        case 'reset':
-        case 'sampler-trigger':
-        case 'expression':
-        case 'unknown':
+        case "external-control":
+        case "tempo-tap":
+        case "trigger":
+        case "reset":
+        case "sampler-trigger":
+        case "expression":
+        case "unknown":
             return role;
         default:
             throw new Error(`${path}: expected external-control, tempo-tap, trigger, reset, sampler-trigger, expression, or unknown`);
@@ -760,12 +918,12 @@ function parseOptionalControlInterfaceConnector(value, path) {
     }
     const connector = expectString(value, path);
     switch (connector) {
-        case '1/4-inch-mono-ts':
-        case '1/4-inch-trs':
-        case '3.5mm-mono-ts':
-        case '3.5mm-trs':
-        case 'proprietary':
-        case 'unknown':
+        case "1/4-inch-mono-ts":
+        case "1/4-inch-trs":
+        case "3.5mm-mono-ts":
+        case "3.5mm-trs":
+        case "proprietary":
+        case "unknown":
             return connector;
         default:
             throw new Error(`${path}: expected a supported connector kind`);
@@ -777,10 +935,10 @@ function parseOptionalControlInterfaceAssignmentHint(value, path) {
     }
     const hint = expectString(value, path);
     switch (hint) {
-        case 'momentary':
-        case 'latching':
-        case 'momentary-or-latching':
-        case 'continuous':
+        case "momentary":
+        case "latching":
+        case "momentary-or-latching":
+        case "continuous":
             return hint;
         default:
             throw new Error(`${path}: expected momentary, latching, momentary-or-latching, or continuous`);
@@ -792,10 +950,10 @@ function parseOptionalControlInterfacePolarity(value, path) {
     }
     const polarity = expectString(value, path);
     switch (polarity) {
-        case 'normally-open':
-        case 'normally-closed':
-        case 'expression':
-        case 'unknown':
+        case "normally-open":
+        case "normally-closed":
+        case "expression":
+        case "unknown":
             return polarity;
         default:
             throw new Error(`${path}: expected normally-open, normally-closed, expression, or unknown`);
@@ -804,12 +962,12 @@ function parseOptionalControlInterfacePolarity(value, path) {
 function parseYamlSubset(source) {
     const lines = tokenize(source);
     if (lines.length === 0) {
-        throw new Error('interchange YAML is empty');
+        throw new Error("interchange YAML is empty");
     }
     const cursor = { index: 0 };
     const first = lines[0];
     if (first === undefined) {
-        throw new Error('interchange YAML is empty');
+        throw new Error("interchange YAML is empty");
     }
     const value = parseBlock(lines, cursor, first.indent);
     if (cursor.index < lines.length) {
@@ -820,13 +978,13 @@ function parseYamlSubset(source) {
 }
 function tokenize(source) {
     const lines = [];
-    const rawLines = source.replace(/^/, '').split(/\r?\n/);
+    const rawLines = source.replace(/^/, "").split(/\r?\n/);
     rawLines.forEach((rawLine, index) => {
         if (rawLine.trim().length === 0) {
             return;
         }
-        const indentText = rawLine.match(/^\s*/)?.[0] ?? '';
-        if (indentText.includes('\t')) {
+        const indentText = rawLine.match(/^\s*/)?.[0] ?? "";
+        if (indentText.includes("\t")) {
             throw new Error(`line ${index + 1}: tabs are not supported in interchange YAML`);
         }
         lines.push({
@@ -845,7 +1003,7 @@ function parseBlock(lines, cursor, indent) {
     if (line.indent !== indent) {
         throw new Error(`line ${line.lineNumber}: expected indentation ${indent}, got ${line.indent}`);
     }
-    if (line.text === '-' || line.text.startsWith('- ')) {
+    if (line.text === "-" || line.text.startsWith("- ")) {
         return parseArray(lines, cursor, indent);
     }
     return parseObject(lines, cursor, indent);
@@ -860,14 +1018,15 @@ function parseObject(lines, cursor, indent) {
         if (line.indent > indent) {
             throw new Error(`line ${line.lineNumber}: unexpected indentation ${line.indent}`);
         }
-        if (line.text === '-' || line.text.startsWith('- ')) {
+        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);
+        out[pair.key] =
+            pair.rest.length > 0
+                ? parseInlineValue(pair.rest, line.lineNumber)
+                : parseNestedValue(lines, cursor, indent, line.lineNumber);
     }
     return out;
 }
@@ -881,10 +1040,10 @@ function parseArray(lines, cursor, indent) {
         if (line.indent > indent) {
             throw new Error(`line ${line.lineNumber}: unexpected indentation ${line.indent}`);
         }
-        if (line.text !== '-' && !line.text.startsWith('- ')) {
+        if (line.text !== "-" && !line.text.startsWith("- ")) {
             break;
         }
-        const rest = line.text === '-' ? '' : line.text.slice(2);
+        const rest = line.text === "-" ? "" : line.text.slice(2);
         cursor.index += 1;
         if (rest.length === 0) {
             out.push(parseNestedValue(lines, cursor, indent, line.lineNumber));
@@ -901,9 +1060,10 @@ function parseArray(lines, cursor, indent) {
 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);
+    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) {
@@ -912,14 +1072,15 @@ function parseObjectItem(firstPairText, lines, cursor, indent, lineNumber) {
         if (line.indent > indent) {
             throw new Error(`line ${line.lineNumber}: unexpected indentation ${line.indent}`);
         }
-        if (line.text === '-' || line.text.startsWith('- ')) {
+        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);
+        out[pair.key] =
+            pair.rest.length > 0
+                ? parseInlineValue(pair.rest, line.lineNumber)
+                : parseNestedValue(lines, cursor, indent, line.lineNumber);
     }
     return out;
 }
@@ -942,7 +1103,7 @@ function parsePair(text, lineNumber) {
     const restText = text.slice(colonIndex + 1);
     return {
         key: parseKey(keyText, lineNumber),
-        rest: restText.startsWith(' ') ? restText.slice(1) : restText,
+        rest: restText.startsWith(" ") ? restText.slice(1) : restText,
     };
 }
 function looksLikePair(text) {
@@ -951,9 +1112,9 @@ function looksLikePair(text) {
 function findPairColon(text) {
     if (text.startsWith('"')) {
         const end = findJsonStringEnd(text);
-        return end >= 0 && text[end + 1] === ':' ? end + 1 : -1;
+        return end >= 0 && text[end + 1] === ":" ? end + 1 : -1;
     }
-    return text.indexOf(':');
+    return text.indexOf(":");
 }
 function findJsonStringEnd(text) {
     let escaped = false;
@@ -963,7 +1124,7 @@ function findJsonStringEnd(text) {
             escaped = false;
             continue;
         }
-        if (char === '\\') {
+        if (char === "\\") {
             escaped = true;
             continue;
         }
@@ -979,7 +1140,7 @@ function parseKey(text, lineNumber) {
     }
     try {
         const parsed = JSON.parse(text);
-        if (typeof parsed === 'string') {
+        if (typeof parsed === "string") {
             return parsed;
         }
     }
@@ -989,25 +1150,25 @@ function parseKey(text, lineNumber) {
     throw new Error(`line ${lineNumber}: invalid quoted key`);
 }
 function parseInlineValue(text, lineNumber) {
-    if (text === '[]') {
+    if (text === "[]") {
         return [];
     }
-    if (text === '{}') {
+    if (text === "{}") {
         return {};
     }
-    if (text === 'null') {
+    if (text === "null") {
         return null;
     }
-    if (text === 'true') {
+    if (text === "true") {
         return true;
     }
-    if (text === 'false') {
+    if (text === "false") {
         return false;
     }
     if (text.startsWith('"')) {
         try {
             const parsed = JSON.parse(text);
-            if (typeof parsed === 'string') {
+            if (typeof parsed === "string") {
                 return parsed;
             }
         }
@@ -1022,7 +1183,7 @@ function parseInlineValue(text, lineNumber) {
     return text;
 }
 function parseMetadata(value) {
-    const metadata = optionalObject(value, 'metadata');
+    const metadata = optionalObject(value, "metadata");
     return {
         name: scalarText(metadata.name),
         description: scalarText(metadata.description),
@@ -1030,30 +1191,32 @@ function parseMetadata(value) {
     };
 }
 function parseSource(value) {
-    return parseStringRecord(value, 'source');
+    return parseStringRecord(value, "source");
 }
 function parsePanel(value, allowV3PhysicalFields) {
     if (value === undefined) {
         return undefined;
     }
-    const panel = expectObject(value, 'panel');
+    const panel = expectObject(value, "panel");
     if (panel.faces !== undefined) {
         return {
-            faces: optionalArray(panel.faces, 'panel.faces').map((item, index) => parsePanelFace(item, index, allowV3PhysicalFields)),
+            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 layout = parsePanelLayout(panel.layout, "panel.layout");
     const elementsValue = panel.controls ?? panel.elements;
-    const elementsPath = panel.controls === undefined ? 'panel.elements' : 'panel.controls';
+    const elementsPath = panel.controls === undefined ? "panel.elements" : "panel.controls";
     return {
-        faces: [{
-                id: 'top',
+        faces: [
+            {
+                id: "top",
                 layout,
                 elements: parsePanelElements(elementsValue, layout, elementsPath, allowV3PhysicalFields),
-            }],
+            },
+        ],
     };
 }
 function parsePanelFace(value, index, allowV3PhysicalFields) {
@@ -1064,7 +1227,9 @@ function parsePanelFace(value, index, allowV3PhysicalFields) {
     if (!allowV3PhysicalFields && face.geometry !== undefined) {
         throw new Error(`${path}.geometry: requires schema ${INTERCHANGE_SCHEMA_V3}`);
     }
-    const geometry = allowV3PhysicalFields ? parseOptionalPanelFaceGeometry(face.geometry, `${path}.geometry`) : undefined;
+    const geometry = allowV3PhysicalFields
+        ? parseOptionalPanelFaceGeometry(face.geometry, `${path}.geometry`)
+        : undefined;
     return {
         id: expectString(face.id, `${path}.id`),
         ...(label === undefined ? {} : { label }),
@@ -1098,7 +1263,9 @@ function parsePanelElements(value, layout, path, allowV3PhysicalFields) {
         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 id = allowV3PhysicalFields
+            ? parseOptionalString(element.id, `${elementPath}.id`)
+            : undefined;
         const physical = allowV3PhysicalFields
             ? parseOptionalPanelElementPhysical(element.physical, `${elementPath}.physical`)
             : undefined;
@@ -1122,11 +1289,17 @@ function parseOptionalPanelFaceGeometry(value, path) {
     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.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`) }),
+            : {
+                usableRectMm: parseMillimeterRect(geometry.usableRectMm, `${path}.usableRectMm`),
+            }),
     };
 }
 function parseOptionalPanelElementPhysical(value, path) {
@@ -1136,15 +1309,31 @@ function parseOptionalPanelElementPhysical(value, path) {
     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.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`) }),
+            : {
+                drillDiameterMm: expectNumber(physical.drillDiameterMm, `${path}.drillDiameterMm`),
+            }),
         ...(physical.partProfileId === undefined
             ? {}
-            : { partProfileId: expectString(physical.partProfileId, `${path}.partProfileId`) }),
-        ...(physical.locked === undefined ? {} : { locked: expectBoolean(physical.locked, `${path}.locked`) }),
+            : {
+                partProfileId: expectString(physical.partProfileId, `${path}.partProfileId`),
+            }),
+        ...(physical.locked === undefined
+            ? {}
+            : { locked: expectBoolean(physical.locked, `${path}.locked`) }),
+        ...(physical.mountId === undefined
+            ? {}
+            : { mountId: expectString(physical.mountId, `${path}.mountId`) }),
+        ...(physical.surface === undefined
+            ? {}
+            : { surface: expectString(physical.surface, `${path}.surface`) }),
     };
 }
 function parseMillimeterRect(value, path) {
@@ -1179,8 +1368,8 @@ function parsePanelGridPosition(value, path, layout) {
     const columnSpan = parseOptionalPositiveInteger(grid.columnSpan, `${path}.columnSpan`);
     const row = expectNonNegativeInteger(grid.row, `${path}.row`);
     const column = expectNonNegativeInteger(grid.column, `${path}.column`);
-    validateGridAxis(row, rowSpan ?? 1, layout.rows, layout.indexing, `${path}.row`, 'row');
-    validateGridAxis(column, columnSpan ?? 1, layout.columns, layout.indexing, `${path}.column`, 'column');
+    validateGridAxis(row, rowSpan ?? 1, layout.rows, layout.indexing, `${path}.row`, "row");
+    validateGridAxis(column, columnSpan ?? 1, layout.columns, layout.indexing, `${path}.column`, "column");
     return {
         row,
         column,
@@ -1189,23 +1378,23 @@ function parsePanelGridPosition(value, path, layout) {
     };
 }
 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;
+    const min = indexing === "one-based" ? 1 : 0;
+    const occupiedEnd = indexing === "one-based" ? value + span - 1 : value + span;
     if (value < min || occupiedEnd > size) {
-        const maxLabel = indexing === 'one-based' ? String(size) : String(size - 1);
+        const maxLabel = indexing === "one-based" ? String(size) : String(size - 1);
         throw new Error(`${path}: expected ${indexing} ${axisName} coordinate within ${min}..${maxLabel}`);
     }
 }
 function parsePanelLayoutKind(value, path) {
     const kind = expectString(value, path);
-    if (kind === 'stompbox-grid') {
+    if (kind === "stompbox-grid") {
         return kind;
     }
     throw new Error(`${path}: expected stompbox-grid`);
 }
 function parsePanelGridIndexing(value, path) {
     const indexing = expectString(value, path);
-    if (indexing === 'one-based' || indexing === 'zero-based') {
+    if (indexing === "one-based" || indexing === "zero-based") {
         return indexing;
     }
     throw new Error(`${path}: expected one-based or zero-based`);
@@ -1215,7 +1404,7 @@ function parseOptionalPanelRowOrder(value, path) {
         return undefined;
     }
     const order = expectString(value, path);
-    if (order === 'top-to-bottom' || order === 'bottom-to-top') {
+    if (order === "top-to-bottom" || order === "bottom-to-top") {
         return order;
     }
     throw new Error(`${path}: expected top-to-bottom or bottom-to-top`);
@@ -1225,7 +1414,7 @@ function parseOptionalPanelColumnOrder(value, path) {
         return undefined;
     }
     const order = expectString(value, path);
-    if (order === 'left-to-right' || order === 'right-to-left') {
+    if (order === "left-to-right" || order === "right-to-left") {
         return order;
     }
     throw new Error(`${path}: expected left-to-right or right-to-left`);
@@ -1233,20 +1422,20 @@ function parseOptionalPanelColumnOrder(value, path) {
 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':
+        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, selector, footswitch, led, or jack`);
     }
 }
 function parseComponents(value) {
-    return optionalArray(value, 'components').map((item, index) => {
+    return optionalArray(value, "components").map((item, index) => {
         const path = `components[${index}]`;
         const component = expectObject(item, path);
         return {
@@ -1307,7 +1496,7 @@ function isParsedQuantityValue(value) {
     return isParsedQuantity(value);
 }
 function parseWires(value) {
-    return optionalArray(value, 'wires').map((item, index) => {
+    return optionalArray(value, "wires").map((item, index) => {
         const path = `wires[${index}]`;
         const wire = expectObject(item, path);
         const points = expectArray(wire.points, `${path}.points`);
@@ -1323,7 +1512,7 @@ function parseWires(value) {
     });
 }
 function parseWarnings(value) {
-    return optionalArray(value, 'diagnostics').map((item, index) => {
+    return optionalArray(value, "diagnostics").map((item, index) => {
         const path = `diagnostics[${index}]`;
         const warning = expectObject(item, path);
         const out = {
@@ -1331,7 +1520,9 @@ function parseWarnings(value) {
             message: expectString(warning.message, `${path}.message`),
             ...(warning.componentId === undefined
                 ? {}
-                : { componentId: expectString(warning.componentId, `${path}.componentId`) }),
+                : {
+                    componentId: expectString(warning.componentId, `${path}.componentId`),
+                }),
             ...(warning.wireId === undefined
                 ? {}
                 : { wireId: expectString(warning.wireId, `${path}.wireId`) }),
@@ -1373,41 +1564,41 @@ function parseNullableString(value, path) {
 function parseComponentKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
-        case 'resistor':
-        case 'capacitor':
-        case 'inductor':
-        case 'diode':
-        case 'led':
-        case 'bjt':
-        case 'jfet':
-        case 'mosfet':
-        case 'opamp':
-        case 'ota':
-        case 'triode':
-        case 'pentode':
-        case 'tube-diode':
-        case 'transformer':
-        case 'potentiometer':
-        case 'variable-resistor':
-        case 'switch':
-        case 'optocoupler':
-        case 'voltage-source':
-        case 'current-source':
-        case 'battery':
-        case 'ground':
-        case 'rail':
-        case 'jack':
-        case 'bbd':
-        case 'delay-ic':
-        case 'power-amp':
-        case 'regulator':
-        case 'analog-switch':
-        case 'flipflop':
-        case 'ic':
-        case 'label':
-        case 'named-wire':
-        case 'port':
-        case 'unsupported':
+        case "resistor":
+        case "capacitor":
+        case "inductor":
+        case "diode":
+        case "led":
+        case "bjt":
+        case "jfet":
+        case "mosfet":
+        case "opamp":
+        case "ota":
+        case "triode":
+        case "pentode":
+        case "tube-diode":
+        case "transformer":
+        case "potentiometer":
+        case "variable-resistor":
+        case "switch":
+        case "optocoupler":
+        case "voltage-source":
+        case "current-source":
+        case "battery":
+        case "ground":
+        case "rail":
+        case "jack":
+        case "bbd":
+        case "delay-ic":
+        case "power-amp":
+        case "regulator":
+        case "analog-switch":
+        case "flipflop":
+        case "ic":
+        case "label":
+        case "named-wire":
+        case "port":
+        case "unsupported":
             return kind;
         default:
             throw new Error(`${path}: unsupported component kind "${kind}"`);
@@ -1438,13 +1629,13 @@ function expectArray(value, path) {
     throw new Error(`${path}: expected array`);
 }
 function expectString(value, path) {
-    if (typeof value === 'string') {
+    if (typeof value === "string") {
         return value;
     }
     throw new Error(`${path}: expected string`);
 }
 function expectNumber(value, path) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
+    if (typeof value === "number" && Number.isFinite(value)) {
         return value;
     }
     throw new Error(`${path}: expected number`);
@@ -1494,14 +1685,14 @@ function parseOptionalBoolean(value, path) {
     return expectBoolean(value, path);
 }
 function expectBoolean(value, path) {
-    if (typeof value === 'boolean') {
+    if (typeof value === "boolean") {
         return value;
     }
     throw new Error(`${path}: expected boolean`);
 }
-function scalarText(value, path = 'value') {
+function scalarText(value, path = "value") {
     if (value === undefined || value === null) {
-        return '';
+        return "";
     }
     if (isScalar(value)) {
         return String(value);
@@ -1509,9 +1700,15 @@ function scalarText(value, path = 'value') {
     throw new Error(`${path}: expected scalar`);
 }
 function isScalar(value) {
-    return value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+    return (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
 }
 function isYamlObject(value) {
-    return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value);
+    return (value !== undefined &&
+        value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value));
 }
 //# sourceMappingURL=parser.js.map