@vessel-dsp/core 0.6.3 → 0.6.5

package/dist/model/validation.js

@@ -1,93 +1,279 @@
-import { propertyQuantityValue, propertyStringValue } from './properties.js';
-import { extractPanel } from '../panel/extract.js';
-const MODEL_ALIASES = ['Model', 'Type', 'partNumber', 'PartNumber'];
+import { propertyQuantityValue, propertyStringValue } from "./properties.js";
+import { extractPanel } from "../panel/extract.js";
+const MODEL_ALIASES = ["Model", "Type", "partNumber", "PartNumber"];
 // Short source-type names (last dotted segment) that represent an "ideal" component variant —
 // no model name is required because the component is a mathematical abstraction.
-const IDEAL_SOURCE_TYPES = new Set(['IdealOpAmp']);
+const IDEAL_SOURCE_TYPES = new Set(["IdealOpAmp"]);
 // Per-kind property names that, if present, satisfy the "needs a model" requirement.
 // LiveSPICE stores tube Koren parameters and opamp small-signal parameters inline; when those
 // are present, the parameters ARE the model definition and no separate model name is needed.
 const INLINE_MODEL_PARAMETERS = {
-    opamp: ['Rin', 'Rout', 'Aol', 'GBP', 'SupplyVoltage'],
-    triode: ['Mu', 'K', 'Kp', 'Kvb', 'Ex', 'Kg'],
-    pentode: ['Mu', 'K', 'Kp', 'Kvb', 'Ex', 'Kg', 'Kg1', 'Kg2'],
+    opamp: ["Rin", "Rout", "Aol", "GBP", "SupplyVoltage"],
+    triode: ["Mu", "K", "Kp", "Kvb", "Ex", "Kg"],
+    pentode: ["Mu", "K", "Kp", "Kvb", "Ex", "Kg", "Kg1", "Kg2"],
 };
 const RUNTIME_DESCRIPTOR_CONTROL_PROPERTIES = [
-    'TimeControl',
-    'FeedbackControl',
-    'MixControl',
-    'LevelControl',
-    'ToneControl',
-    'ModRateControl',
-    'ModDepthControl',
-    'ModeControl',
-    'TempoTapControl',
-    'TapTempoControl',
-    'TempoControl',
-    'DirectOutputJack',
-    'DirectOutJack',
-    'DirectOutputControl',
-    'DirectOutControl',
+    "TimeControl",
+    "FeedbackControl",
+    "MixControl",
+    "LevelControl",
+    "ToneControl",
+    "ModRateControl",
+    "ModDepthControl",
+    "ModeControl",
+    "TempoTapControl",
+    "TapTempoControl",
+    "TempoControl",
+    "DirectOutputJack",
+    "DirectOutJack",
+    "DirectOutputControl",
+    "DirectOutControl",
 ];
 const KIND_RULES = {
-    resistor: [{
-            kind: 'quantity', name: 'R', required: true, unit: 'Ω',
-            min: 1e-9, max: 1e9, aliases: ['Resistance', 'resistance', 'r'],
-        }],
-    'variable-resistor': [{
-            kind: 'quantity', name: 'R', required: true, unit: 'Ω',
-            min: 1e-9, max: 1e9, aliases: ['Resistance', 'resistance', 'r'],
-        }],
+    resistor: [
+        {
+            kind: "quantity",
+            name: "R",
+            required: true,
+            unit: "Ω",
+            min: 1e-9,
+            max: 1e9,
+            aliases: ["Resistance", "resistance", "r"],
+        },
+    ],
+    "variable-resistor": [
+        {
+            kind: "quantity",
+            name: "R",
+            required: true,
+            unit: "Ω",
+            min: 1e-9,
+            max: 1e9,
+            aliases: ["Resistance", "resistance", "r"],
+        },
+    ],
     potentiometer: [
         {
-            kind: 'quantity', name: 'R', required: true, unit: 'Ω',
-            min: 1e-9, max: 1e9, aliases: ['Resistance', 'totalResistance'],
+            kind: "quantity",
+            name: "R",
+            required: true,
+            unit: "Ω",
+            min: 1e-9,
+            max: 1e9,
+            aliases: ["Resistance", "totalResistance"],
+        },
+        { kind: "string", name: "taper", required: false, aliases: ["Taper"] },
+    ],
+    capacitor: [
+        {
+            kind: "quantity",
+            name: "C",
+            required: true,
+            unit: "F",
+            min: 1e-15,
+            max: 1,
+            aliases: ["Capacitance", "capacitance", "c"],
+        },
+    ],
+    inductor: [
+        {
+            kind: "quantity",
+            name: "L",
+            required: true,
+            unit: "H",
+            min: 1e-12,
+            max: 100,
+            aliases: ["Inductance", "inductance", "l"],
+        },
+    ],
+    "voltage-source": [
+        {
+            kind: "quantity",
+            name: "V",
+            required: true,
+            unit: "V",
+            aliases: ["Voltage", "voltage", "v"],
+        },
+    ],
+    "current-source": [
+        {
+            kind: "quantity",
+            name: "I",
+            required: true,
+            unit: "A",
+            aliases: ["Current", "current", "i"],
+        },
+    ],
+    battery: [
+        {
+            kind: "quantity",
+            name: "V",
+            required: true,
+            unit: "V",
+            aliases: ["Voltage", "voltage", "v"],
+        },
+    ],
+    rail: [
+        {
+            kind: "quantity",
+            name: "V",
+            required: true,
+            unit: "V",
+            aliases: ["Voltage", "voltage", "v"],
+        },
+    ],
+    diode: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    led: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    bjt: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    jfet: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    mosfet: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    opamp: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    triode: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    pentode: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    "tube-diode": [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    optocoupler: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    transformer: [
+        {
+            kind: "string",
+            name: "model",
+            required: false,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    ota: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    bbd: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    "delay-ic": [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    "power-amp": [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    regulator: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    "analog-switch": [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    flipflop: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
+        },
+    ],
+    ic: [
+        {
+            kind: "string",
+            name: "model",
+            required: true,
+            aliases: [...MODEL_ALIASES],
         },
-        { kind: 'string', name: 'taper', required: false, aliases: ['Taper'] },
     ],
-    capacitor: [{
-            kind: 'quantity', name: 'C', required: true, unit: 'F',
-            min: 1e-15, max: 1, aliases: ['Capacitance', 'capacitance', 'c'],
-        }],
-    inductor: [{
-            kind: 'quantity', name: 'L', required: true, unit: 'H',
-            min: 1e-12, max: 100, aliases: ['Inductance', 'inductance', 'l'],
-        }],
-    'voltage-source': [{
-            kind: 'quantity', name: 'V', required: true, unit: 'V',
-            aliases: ['Voltage', 'voltage', 'v'],
-        }],
-    'current-source': [{
-            kind: 'quantity', name: 'I', required: true, unit: 'A',
-            aliases: ['Current', 'current', 'i'],
-        }],
-    battery: [{
-            kind: 'quantity', name: 'V', required: true, unit: 'V',
-            aliases: ['Voltage', 'voltage', 'v'],
-        }],
-    rail: [{
-            kind: 'quantity', name: 'V', required: true, unit: 'V',
-            aliases: ['Voltage', 'voltage', 'v'],
-        }],
-    diode: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    led: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    bjt: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    jfet: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    mosfet: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    opamp: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    triode: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    pentode: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    'tube-diode': [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    optocoupler: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    transformer: [{ kind: 'string', name: 'model', required: false, aliases: [...MODEL_ALIASES] }],
-    ota: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    bbd: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    'delay-ic': [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    'power-amp': [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    regulator: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    'analog-switch': [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    flipflop: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
-    ic: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
 };
 export function getRulesForKind(kind) {
     return KIND_RULES[kind] ?? [];
@@ -102,8 +288,8 @@ export function validateComponent(component, rules = getRulesForKind(component.k
             }
             continue;
         }
-        if (rule.kind === 'string') {
-            if (typeof value !== 'string' || value.trim().length === 0) {
+        if (rule.kind === "string") {
+            if (typeof value !== "string" || value.trim().length === 0) {
                 if (rule.required && !isRequirementWaived(component, rule)) {
                     issues.push(missingPropertyIssue(component, rule));
                 }
@@ -112,22 +298,25 @@ export function validateComponent(component, rules = getRulesForKind(component.k
         }
         const quantity = coerceQuantity(value);
         if (quantity === null) {
-            if (typeof value === 'string' && isRawQuantityExpression(value)) {
+            if (typeof value === "string" && isRawQuantityExpression(value)) {
                 continue;
             }
             issues.push({
-                code: 'value-unparseable',
-                severity: 'error',
+                code: "value-unparseable",
+                severity: "error",
                 message: `${component.id}: property "${rule.name}" could not be parsed as a quantity`,
                 componentId: component.id,
                 property: rule.name,
             });
             continue;
         }
-        if (rule.unit !== undefined && rule.unit.length > 0 && quantity.unit.length > 0 && quantity.unit !== rule.unit) {
+        if (rule.unit !== undefined &&
+            rule.unit.length > 0 &&
+            quantity.unit.length > 0 &&
+            quantity.unit !== rule.unit) {
             issues.push({
-                code: 'unit-mismatch',
-                severity: 'warning',
+                code: "unit-mismatch",
+                severity: "warning",
                 message: `${component.id}: property "${rule.name}" has unit "${quantity.unit}" but expected "${rule.unit}"`,
                 componentId: component.id,
                 property: rule.name,
@@ -135,8 +324,8 @@ export function validateComponent(component, rules = getRulesForKind(component.k
         }
         if (rule.min !== undefined && quantity.value < rule.min) {
             issues.push({
-                code: 'value-out-of-range',
-                severity: 'error',
+                code: "value-out-of-range",
+                severity: "error",
                 message: `${component.id}: property "${rule.name}" value ${quantity.value} is below minimum ${rule.min}`,
                 componentId: component.id,
                 property: rule.name,
@@ -144,8 +333,8 @@ export function validateComponent(component, rules = getRulesForKind(component.k
         }
         if (rule.max !== undefined && quantity.value > rule.max) {
             issues.push({
-                code: 'value-out-of-range',
-                severity: 'error',
+                code: "value-out-of-range",
+                severity: "error",
                 message: `${component.id}: property "${rule.name}" value ${quantity.value} is above maximum ${rule.max}`,
                 componentId: component.id,
                 property: rule.name,
@@ -160,18 +349,18 @@ export function validateDocument(doc) {
     for (const component of doc.components) {
         if (seen.has(component.id)) {
             issues.push({
-                code: 'duplicate-id',
-                severity: 'error',
+                code: "duplicate-id",
+                severity: "error",
                 message: `Duplicate component id "${component.id}"`,
                 componentId: component.id,
             });
         }
         seen.add(component.id);
-        if (component.kind === 'unsupported') {
+        if (component.kind === "unsupported") {
             issues.push({
-                code: 'unsupported-component',
-                severity: 'warning',
-                message: `${component.id}: unsupported source type ${component.sourceTypeName ?? 'unknown'}`,
+                code: "unsupported-component",
+                severity: "warning",
+                message: `${component.id}: unsupported source type ${component.sourceTypeName ?? "unknown"}`,
                 componentId: component.id,
             });
             continue;
@@ -187,8 +376,8 @@ export function validateDocument(doc) {
         const [a, b] = wire.endpoints;
         if (a.x === b.x && a.y === b.y) {
             issues.push({
-                code: 'degenerate-wire',
-                severity: 'warning',
+                code: "degenerate-wire",
+                severity: "warning",
                 message: `Wire "${wire.id}" has identical endpoints`,
                 wireId: wire.id,
             });
@@ -200,23 +389,27 @@ export function validateDocument(doc) {
     for (const issue of validatePanel(doc, seen, new Set(doc.deviceInterface?.controls.map((control) => control.id) ?? []))) {
         issues.push(issue);
     }
+    for (const issue of validateMountGroups(doc)) {
+        issues.push(issue);
+    }
     for (const issue of validateV3BuildMetadata(doc, seen)) {
         issues.push(issue);
     }
     return issues;
 }
 export function hasErrors(issues) {
-    return issues.some((issue) => issue.severity === 'error');
+    return issues.some((issue) => issue.severity === "error");
 }
 function isRequirementWaived(component, rule) {
     if (isInterfaceOnlyComponent(component)) {
         return true;
     }
     // Only the "model" string requirement has a waiver path today.
-    if (rule.kind !== 'string' || rule.name !== 'model') {
+    if (rule.kind !== "string" || rule.name !== "model") {
         return false;
     }
-    if (component.kind === 'ic' && component.properties.RuntimeDescriptor === 'true') {
+    if (component.kind === "ic" &&
+        component.properties.RuntimeDescriptor === "true") {
         return true;
     }
     const shortType = shortSourceType(component.sourceTypeName);
@@ -231,54 +424,60 @@ function isInterfaceOnlyComponent(component) {
     if (interfaceOnly === true) {
         return true;
     }
-    if (typeof interfaceOnly === 'string' && normalizeToken(interfaceOnly) === 'true') {
+    if (typeof interfaceOnly === "string" &&
+        normalizeToken(interfaceOnly) === "true") {
         return true;
     }
     const support = component.properties.Support;
-    return typeof support === 'string' && normalizeToken(support) === 'view-only';
+    return typeof support === "string" && normalizeToken(support) === "view-only";
 }
 function validateSemanticMetadata(component) {
     const issues = [];
-    if (component.kind === 'jack') {
+    if (component.kind === "jack") {
         issues.push(...validateJackSemanticMetadata(component));
     }
-    if (component.kind === 'ic' && component.properties.RuntimeDescriptor === 'true') {
+    if (component.kind === "ic" &&
+        component.properties.RuntimeDescriptor === "true") {
         issues.push(...validateRuntimeDescriptorMetadata(component));
     }
     return issues;
 }
 function validateJackSemanticMetadata(component) {
     const issues = [];
-    for (const property of ['Role', 'ControlRole']) {
+    for (const property of ["Role", "ControlRole"]) {
         const value = propertyString(component, property);
-        if (value !== null && value.trim().length > 0 && !isRecognizedJackRole(value)) {
+        if (value !== null &&
+            value.trim().length > 0 &&
+            !isRecognizedJackRole(value)) {
             issues.push({
-                code: 'invalid-jack-role',
-                severity: 'warning',
+                code: "invalid-jack-role",
+                severity: "warning",
                 message: `${component.id}: jack ${property} "${value}" is not a recognized panel role`,
                 componentId: component.id,
                 property,
             });
         }
     }
-    const interfaceName = propertyString(component, 'Interface');
-    if (interfaceName !== null && interfaceName.trim().length > 0 && !isRecognizedJackInterface(interfaceName)) {
+    const interfaceName = propertyString(component, "Interface");
+    if (interfaceName !== null &&
+        interfaceName.trim().length > 0 &&
+        !isRecognizedJackInterface(interfaceName)) {
         issues.push({
-            code: 'invalid-jack-interface',
-            severity: 'warning',
+            code: "invalid-jack-interface",
+            severity: "warning",
             message: `${component.id}: jack Interface "${interfaceName}" is not a recognized panel interface`,
             componentId: component.id,
-            property: 'Interface',
+            property: "Interface",
         });
     }
-    const audioRole = propertyString(component, 'AudioRole');
+    const audioRole = propertyString(component, "AudioRole");
     if (audioRole !== null && !isValidJackAudioRole(audioRole)) {
         issues.push({
-            code: 'invalid-jack-audio-role',
-            severity: 'warning',
+            code: "invalid-jack-audio-role",
+            severity: "warning",
             message: `${component.id}: jack AudioRole "${audioRole}" must be a lower-kebab source subtype slug`,
             componentId: component.id,
-            property: 'AudioRole',
+            property: "AudioRole",
         });
     }
     return issues;
@@ -289,23 +488,25 @@ function validateRuntimeDescriptorMetadata(component) {
         const value = propertyString(component, property);
         if (value !== null && value.trim().length === 0) {
             issues.push({
-                code: 'descriptor-control-empty',
-                severity: 'warning',
+                code: "descriptor-control-empty",
+                severity: "warning",
                 message: `${component.id}: runtime descriptor property "${property}" must not be empty`,
                 componentId: component.id,
                 property,
             });
         }
     }
-    const labels = parseStringList(propertyStringAny(component, ['ModeLabels', 'ModeOptions']));
-    const stepCount = parsePositiveInteger(propertyStringAny(component, ['ModeStepCount', 'ModeSteps', 'ModeCount']));
-    if (labels.length > 0 && stepCount !== undefined && labels.length !== stepCount) {
+    const labels = parseStringList(propertyStringAny(component, ["ModeLabels", "ModeOptions"]));
+    const stepCount = parsePositiveInteger(propertyStringAny(component, ["ModeStepCount", "ModeSteps", "ModeCount"]));
+    if (labels.length > 0 &&
+        stepCount !== undefined &&
+        labels.length !== stepCount) {
         issues.push({
-            code: 'descriptor-mode-label-mismatch',
-            severity: 'warning',
+            code: "descriptor-mode-label-mismatch",
+            severity: "warning",
             message: `${component.id}: ModeLabels has ${labels.length} labels but ModeStepCount is ${stepCount}`,
             componentId: component.id,
-            property: 'ModeLabels',
+            property: "ModeLabels",
         });
     }
     return issues;
@@ -314,11 +515,11 @@ function shortSourceType(sourceTypeName) {
     if (sourceTypeName === null) {
         return null;
     }
-    const head = sourceTypeName.split(',')[0]?.trim() ?? '';
+    const head = sourceTypeName.split(",")[0]?.trim() ?? "";
     if (head.length === 0) {
         return null;
     }
-    const lastDot = head.lastIndexOf('.');
+    const lastDot = head.lastIndexOf(".");
     return lastDot >= 0 ? head.slice(lastDot + 1) : head;
 }
 function findProperty(component, rule) {
@@ -351,58 +552,58 @@ function isRawQuantityExpression(value) {
     if (trimmed.length === 0) {
         return false;
     }
-    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
         return true;
     }
-    return /^(AC|DC)\b/i.test(trimmed) ||
-        /^(SINE|PULSE|PWL|EXP|SFFM|AM|WAVEFILE)\s*\(/i.test(trimmed);
+    return (/^(AC|DC)\b/i.test(trimmed) ||
+        /^(SINE|PULSE|PWL|EXP|SFFM|AM|WAVEFILE)\s*\(/i.test(trimmed));
 }
 function isRecognizedJackRole(value) {
     const normalized = normalizeToken(value);
     return [
-        'input',
-        'audio-input',
-        'in',
-        'direct-output',
-        'direct-out',
-        'dry-output',
-        'dry-out',
-        'output',
-        'audio-output',
-        'out',
-        'send',
-        'return',
-        'expression',
-        'exp',
-        'expression-pedal',
-        'tempo-tap',
-        'tap-tempo',
-        'tempo-in',
-        'tap',
-        'tempo',
-        'external-control',
-        'external-control-input',
-        'control-input',
-        'remote',
-        'footswitch',
-        'trigger',
-        'reset',
+        "input",
+        "audio-input",
+        "in",
+        "direct-output",
+        "direct-out",
+        "dry-output",
+        "dry-out",
+        "output",
+        "audio-output",
+        "out",
+        "send",
+        "return",
+        "expression",
+        "exp",
+        "expression-pedal",
+        "tempo-tap",
+        "tap-tempo",
+        "tempo-in",
+        "tap",
+        "tempo",
+        "external-control",
+        "external-control-input",
+        "control-input",
+        "remote",
+        "footswitch",
+        "trigger",
+        "reset",
     ].includes(normalized);
 }
 function isRecognizedJackInterface(value) {
     const normalized = normalizeToken(value);
-    return isRecognizedJackRole(value) ||
+    return (isRecognizedJackRole(value) ||
         [
-            'audio',
-            'audio-port',
-            'control',
-            'control-port',
-            'power',
-            'power-port',
-            'dc-power',
-            'dc-power-input',
-            'tap-tempo-input',
-        ].includes(normalized);
+            "audio",
+            "audio-port",
+            "control",
+            "control-port",
+            "power",
+            "power-port",
+            "dc-power",
+            "dc-power-input",
+            "tap-tempo-input",
+        ].includes(normalized));
 }
 function isValidJackAudioRole(value) {
     return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
@@ -428,51 +629,56 @@ function parsePositiveInteger(value) {
     return Number.isInteger(count) && count > 0 ? count : undefined;
 }
 function normalizeToken(value) {
-    return value.trim().toLowerCase().replace(/[\s_]+/g, '-');
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s_]+/g, "-");
 }
 function validateDeviceInterface(doc, componentIds) {
     const issues = [];
     const groupIds = new Set(doc.controlGroups?.map((group) => group.id) ?? []);
     const contextIds = new Set(doc.controlContexts?.map((context) => context.id) ?? []);
+    const declaredControlIds = new Set(doc.deviceInterface?.controls.map((control) => control.id) ?? []);
     const semanticControlIds = new Set();
     const externalInterfaceIds = new Set(doc.controlInterfaces?.map((controlInterface) => controlInterface.id) ?? []);
     const componentsById = new Map(doc.components.map((component) => [component.id, component]));
     const resolvedPanelElements = resolvePanelElements(doc);
     for (const group of doc.controlGroups ?? []) {
-        issues.push(...validateOpenToken(group.role, group.id, 'role'));
+        issues.push(...validateOpenToken(group.role, group.id, "role"));
         for (const contextId of group.contextIds ?? []) {
             if (!contextIds.has(contextId)) {
                 issues.push({
-                    code: 'control-group-context-unresolved',
-                    severity: 'warning',
+                    code: "control-group-context-unresolved",
+                    severity: "warning",
                     message: `Control group "${group.id}" references missing context "${contextId}"`,
                     componentId: group.id,
-                    property: 'contextIds',
+                    property: "contextIds",
                 });
             }
         }
+        issues.push(...validateControlGroupMembers(group, declaredControlIds, contextIds));
     }
     for (const context of doc.controlContexts ?? []) {
-        issues.push(...validateOpenToken(context.role, context.id, 'role'));
+        issues.push(...validateOpenToken(context.role, context.id, "role"));
     }
     for (const control of doc.deviceInterface?.controls ?? []) {
         if (semanticControlIds.has(control.id)) {
             issues.push({
-                code: 'duplicate-device-interface-control-id',
-                severity: 'error',
+                code: "duplicate-device-interface-control-id",
+                severity: "error",
                 message: `Duplicate device interface control id "${control.id}"`,
                 componentId: control.id,
             });
         }
         semanticControlIds.add(control.id);
-        issues.push(...validateOpenToken(control.role, control.id, 'role'));
+        issues.push(...validateOpenToken(control.role, control.id, "role"));
         if (control.groupId !== undefined && !groupIds.has(control.groupId)) {
             issues.push({
-                code: 'device-interface-group-unresolved',
-                severity: 'warning',
+                code: "device-interface-group-unresolved",
+                severity: "warning",
                 message: `Device interface control "${control.id}" references missing group "${control.groupId}"`,
                 componentId: control.id,
-                property: 'groupId',
+                property: "groupId",
             });
         }
         issues.push(...validateApplicability(control, contextIds));
@@ -480,37 +686,129 @@ function validateDeviceInterface(doc, componentIds) {
             issues.push(...validateDeviceInterfaceBinding(control, control.binding, componentIds, externalInterfaceIds, componentsById, resolvedPanelElements));
         }
     }
-    issues.push(...validateDuplicateDeviceInterfaceRoles(doc.deviceInterface?.controls ?? []));
+    issues.push(...validateDuplicateDeviceInterfaceRoles(doc.deviceInterface?.controls ?? [], doc.controlGroups ?? []));
+    return issues;
+}
+function validateControlGroupMembers(group, controlIds, contextIds) {
+    const issues = [];
+    const orderOwners = new Map();
+    for (const member of group.members ?? []) {
+        if (!controlIds.has(member.controlId)) {
+            issues.push({
+                code: "control-group-member-unresolved",
+                severity: "warning",
+                message: `Control group "${group.id}" references missing member control "${member.controlId}"`,
+                componentId: group.id,
+                property: "members.controlId",
+            });
+        }
+        if (member.order !== undefined) {
+            const existingControlId = orderOwners.get(member.order);
+            if (existingControlId !== undefined) {
+                issues.push({
+                    code: "control-group-member-order-duplicate",
+                    severity: "warning",
+                    message: `Control group "${group.id}" assigns order ${member.order} to both "${existingControlId}" and "${member.controlId}"`,
+                    componentId: group.id,
+                    property: "members.order",
+                });
+            }
+            orderOwners.set(member.order, member.controlId);
+        }
+        issues.push(...validateControlGroupMemberApplicability(group.id, member, contextIds));
+    }
+    return issues;
+}
+function validateControlGroupMemberApplicability(groupId, member, contextIds) {
+    const issues = [];
+    if (member.appliesWhen === undefined) {
+        return issues;
+    }
+    issues.push(...validateGroupMemberContextList(groupId, member, "members.appliesWhen.allOf", member.appliesWhen.allOf, contextIds));
+    issues.push(...validateGroupMemberContextList(groupId, member, "members.appliesWhen.anyOf", member.appliesWhen.anyOf, contextIds));
+    if (member.appliesWhen.allOf !== undefined &&
+        member.appliesWhen.allOf.length === 0 &&
+        member.appliesWhen.anyOf === undefined) {
+        issues.push(emptyGroupMemberApplicabilityIssue(groupId, member.controlId, "members.appliesWhen.allOf"));
+    }
+    if (member.appliesWhen.anyOf !== undefined &&
+        member.appliesWhen.anyOf.length === 0 &&
+        member.appliesWhen.allOf === undefined) {
+        issues.push(emptyGroupMemberApplicabilityIssue(groupId, member.controlId, "members.appliesWhen.anyOf"));
+    }
+    return issues;
+}
+function validateGroupMemberContextList(groupId, member, property, values, contextIds) {
+    if (values === undefined) {
+        return [];
+    }
+    const issues = [];
+    const seen = new Set();
+    if (values.length === 0) {
+        issues.push(emptyGroupMemberApplicabilityIssue(groupId, member.controlId, property));
+    }
+    for (const contextId of values) {
+        if (seen.has(contextId)) {
+            issues.push({
+                code: "control-group-member-context-unresolved",
+                severity: "warning",
+                message: `Control group "${groupId}" member "${member.controlId}" repeats context "${contextId}" in ${property}`,
+                componentId: groupId,
+                property,
+            });
+        }
+        seen.add(contextId);
+        if (!contextIds.has(contextId)) {
+            issues.push({
+                code: "control-group-member-context-unresolved",
+                severity: "warning",
+                message: `Control group "${groupId}" member "${member.controlId}" references missing context "${contextId}"`,
+                componentId: groupId,
+                property,
+            });
+        }
+    }
     return issues;
 }
+function emptyGroupMemberApplicabilityIssue(groupId, controlId, property) {
+    return {
+        code: "control-group-member-context-unresolved",
+        severity: "warning",
+        message: `Control group "${groupId}" member "${controlId}" has empty ${property}; omit the predicate instead`,
+        componentId: groupId,
+        property,
+    };
+}
 function validateOpenToken(value, componentId, property) {
     if (/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value)) {
         return [];
     }
-    return [{
-            code: 'invalid-device-interface-token',
-            severity: 'warning',
+    return [
+        {
+            code: "invalid-device-interface-token",
+            severity: "warning",
             message: `${componentId}: ${property} "${value}" must be a lower-kebab token`,
             componentId,
             property,
-        }];
+        },
+    ];
 }
 function validateApplicability(control, contextIds) {
     const issues = [];
     if (control.appliesWhen === undefined) {
         return issues;
     }
-    issues.push(...validateContextList(control.id, 'appliesWhen.allOf', control.appliesWhen.allOf, contextIds));
-    issues.push(...validateContextList(control.id, 'appliesWhen.anyOf', control.appliesWhen.anyOf, contextIds));
-    if (control.appliesWhen.allOf !== undefined
-        && control.appliesWhen.allOf.length === 0
-        && control.appliesWhen.anyOf === undefined) {
-        issues.push(emptyApplicabilityIssue(control.id, 'appliesWhen.allOf'));
+    issues.push(...validateContextList(control.id, "appliesWhen.allOf", control.appliesWhen.allOf, contextIds));
+    issues.push(...validateContextList(control.id, "appliesWhen.anyOf", control.appliesWhen.anyOf, contextIds));
+    if (control.appliesWhen.allOf !== undefined &&
+        control.appliesWhen.allOf.length === 0 &&
+        control.appliesWhen.anyOf === undefined) {
+        issues.push(emptyApplicabilityIssue(control.id, "appliesWhen.allOf"));
     }
-    if (control.appliesWhen.anyOf !== undefined
-        && control.appliesWhen.anyOf.length === 0
-        && control.appliesWhen.allOf === undefined) {
-        issues.push(emptyApplicabilityIssue(control.id, 'appliesWhen.anyOf'));
+    if (control.appliesWhen.anyOf !== undefined &&
+        control.appliesWhen.anyOf.length === 0 &&
+        control.appliesWhen.allOf === undefined) {
+        issues.push(emptyApplicabilityIssue(control.id, "appliesWhen.anyOf"));
     }
     return issues;
 }
@@ -526,8 +824,8 @@ function validateContextList(controlId, property, values, contextIds) {
     for (const contextId of values) {
         if (seen.has(contextId)) {
             issues.push({
-                code: 'device-interface-context-unresolved',
-                severity: 'warning',
+                code: "device-interface-context-unresolved",
+                severity: "warning",
                 message: `Device interface control "${controlId}" repeats context "${contextId}" in ${property}`,
                 componentId: controlId,
                 property,
@@ -536,8 +834,8 @@ function validateContextList(controlId, property, values, contextIds) {
         seen.add(contextId);
         if (!contextIds.has(contextId)) {
             issues.push({
-                code: 'device-interface-context-unresolved',
-                severity: 'warning',
+                code: "device-interface-context-unresolved",
+                severity: "warning",
                 message: `Device interface control "${controlId}" references missing context "${contextId}"`,
                 componentId: controlId,
                 property,
@@ -548,8 +846,8 @@ function validateContextList(controlId, property, values, contextIds) {
 }
 function emptyApplicabilityIssue(controlId, property) {
     return {
-        code: 'device-interface-context-unresolved',
-        severity: 'warning',
+        code: "device-interface-context-unresolved",
+        severity: "warning",
         message: `Device interface control "${controlId}" has empty ${property}; omit the predicate instead`,
         componentId: controlId,
         property,
@@ -557,79 +855,204 @@ function emptyApplicabilityIssue(controlId, property) {
 }
 function validateDeviceInterfaceBinding(control, binding, componentIds, externalInterfaceIds, componentsById, resolvedPanelElements) {
     const issues = [];
-    if (binding.externalInterfaceId !== undefined && !externalInterfaceIds.has(binding.externalInterfaceId)) {
+    if (binding.externalInterfaceId !== undefined &&
+        !externalInterfaceIds.has(binding.externalInterfaceId)) {
         issues.push({
-            code: 'device-interface-binding-unresolved',
-            severity: 'warning',
+            code: "device-interface-binding-unresolved",
+            severity: "warning",
             message: `Device interface control "${control.id}" references missing external interface "${binding.externalInterfaceId}"`,
             componentId: control.id,
-            property: 'binding.externalInterfaceId',
+            property: "binding.externalInterfaceId",
         });
     }
     if (!componentIds.has(binding.componentId)) {
         issues.push({
-            code: 'device-interface-binding-unresolved',
-            severity: 'warning',
+            code: "device-interface-binding-unresolved",
+            severity: "warning",
             message: `Device interface control "${control.id}" references missing component "${binding.componentId}"`,
             componentId: control.id,
-            property: 'binding.componentId',
+            property: "binding.componentId",
         });
         return issues;
     }
-    if (binding.controlId !== undefined
-        && !resolvedPanelElements.some((resolved) => resolved.componentId === binding.componentId && resolved.id === binding.controlId)) {
+    if (binding.controlId !== undefined &&
+        !resolvedPanelElements.some((resolved) => resolved.componentId === binding.componentId &&
+            resolved.id === binding.controlId)) {
         issues.push({
-            code: 'device-interface-binding-unresolved',
-            severity: 'warning',
+            code: "device-interface-binding-unresolved",
+            severity: "warning",
             message: `Device interface control "${control.id}" references missing control "${binding.controlId}"`,
             componentId: control.id,
-            property: 'binding.controlId',
+            property: "binding.controlId",
         });
     }
     const component = componentsById.get(binding.componentId);
-    if (binding.property !== undefined && component?.properties[binding.property] === undefined) {
+    if (binding.property !== undefined &&
+        component?.properties[binding.property] === undefined) {
         issues.push({
-            code: 'device-interface-binding-unresolved',
-            severity: 'warning',
+            code: "device-interface-binding-unresolved",
+            severity: "warning",
             message: `Device interface control "${control.id}" references missing property "${binding.property}"`,
             componentId: control.id,
-            property: 'binding.property',
+            property: "binding.property",
         });
     }
     return issues;
 }
-function validateDuplicateDeviceInterfaceRoles(controls) {
+function validateDuplicateDeviceInterfaceRoles(controls, groups) {
     const issues = [];
+    const layoutsByControlId = deviceInterfaceRoleLayoutsByControlId(groups);
     const seen = new Map();
     for (const control of controls) {
-        const key = `${control.groupId ?? ''}:${control.role}`;
-        const existing = seen.get(key);
-        if (existing !== undefined && existing.order === undefined && control.order === undefined) {
-            if (deviceInterfaceBindingSignature(existing.binding) === deviceInterfaceBindingSignature(control.binding)) {
-                issues.push({
-                    code: 'device-interface-duplicate-role',
-                    severity: 'warning',
-                    message: `Device interface controls "${existing.id}" and "${control.id}" share role "${control.role}" without order or distinct binding`,
-                    componentId: control.id,
-                    property: 'role',
-                });
+        const layouts = layoutsByControlId.get(control.id) ?? [
+            { groupId: control.groupId ?? "", order: control.order },
+        ];
+        for (const layout of layouts) {
+            const key = `${layout.groupId}:${control.role}`;
+            const existing = seen.get(key);
+            if (existing !== undefined &&
+                existing.order === undefined &&
+                layout.order === undefined) {
+                if (deviceInterfaceBindingSignature(existing.control.binding) ===
+                    deviceInterfaceBindingSignature(control.binding)) {
+                    issues.push({
+                        code: "device-interface-duplicate-role",
+                        severity: "warning",
+                        message: `Device interface controls "${existing.control.id}" and "${control.id}" share role "${control.role}" without order or distinct binding`,
+                        componentId: control.id,
+                        property: "role",
+                    });
+                }
             }
+            seen.set(key, {
+                control,
+                ...(layout.order === undefined ? {} : { order: layout.order }),
+            });
         }
-        seen.set(key, control);
     }
     return issues;
 }
+function deviceInterfaceRoleLayoutsByControlId(groups) {
+    const layoutsByControlId = new Map();
+    for (const group of groups) {
+        for (const member of group.members ?? []) {
+            const layouts = layoutsByControlId.get(member.controlId) ?? [];
+            layouts.push({
+                groupId: group.id,
+                ...(member.order === undefined ? {} : { order: member.order }),
+            });
+            layoutsByControlId.set(member.controlId, layouts);
+        }
+    }
+    return layoutsByControlId;
+}
 function deviceInterfaceBindingSignature(binding) {
     if (binding === undefined) {
-        return '';
+        return "";
     }
     return [
         binding.componentId,
-        binding.controlId ?? '',
-        binding.controlName ?? '',
-        binding.property ?? '',
-        binding.externalInterfaceId ?? '',
-    ].join(':');
+        binding.controlId ?? "",
+        binding.controlName ?? "",
+        binding.property ?? "",
+        binding.externalInterfaceId ?? "",
+    ].join(":");
+}
+/**
+ * Structural (catalog-free) validation of multi-surface part mounts, where
+ * several placement elements share one physical part in one hole (e.g. a
+ * concentric pot). Catches orphan bindings and inconsistent mount groups.
+ * Surface-existence and completeness against the part catalog are validated
+ * downstream in the stompbox build layer, which owns the part profiles.
+ */
+function validateMountGroups(doc) {
+    if (doc.panel === undefined) {
+        return [];
+    }
+    const issues = [];
+    const groups = new Map();
+    for (const face of doc.panel.faces) {
+        for (const element of face.elements) {
+            const physical = element.physical;
+            if (physical === undefined) {
+                continue;
+            }
+            const componentId = element.bind.componentId;
+            if (physical.mountId === undefined) {
+                if (physical.surface !== undefined) {
+                    issues.push({
+                        code: "panel-mount-orphan",
+                        severity: "warning",
+                        message: `Panel element for "${componentId}" sets physical.surface "${physical.surface}" without a mountId`,
+                        componentId,
+                    });
+                }
+                continue;
+            }
+            if (physical.surface === undefined) {
+                issues.push({
+                    code: "panel-mount-orphan",
+                    severity: "warning",
+                    message: `Panel element for "${componentId}" joins mount "${physical.mountId}" without a surface`,
+                    componentId,
+                });
+            }
+            if (physical.partProfileId === undefined) {
+                issues.push({
+                    code: "panel-mount-orphan",
+                    severity: "warning",
+                    message: `Panel element for "${componentId}" joins mount "${physical.mountId}" without a partProfileId`,
+                    componentId,
+                });
+            }
+            const members = groups.get(physical.mountId) ?? [];
+            members.push({ componentId, physical });
+            groups.set(physical.mountId, members);
+        }
+    }
+    for (const [mountId, members] of groups) {
+        const anchorId = members[0]?.componentId;
+        const surfaces = new Set();
+        const partIds = new Set();
+        const centers = new Set();
+        for (const member of members) {
+            const { surface, partProfileId, centerMm } = member.physical;
+            if (surface !== undefined) {
+                if (surfaces.has(surface)) {
+                    issues.push({
+                        code: "panel-mount-inconsistent",
+                        severity: "warning",
+                        message: `Mount "${mountId}" has duplicate surface "${surface}"`,
+                        componentId: member.componentId,
+                    });
+                }
+                surfaces.add(surface);
+            }
+            if (partProfileId !== undefined) {
+                partIds.add(partProfileId);
+            }
+            if (centerMm !== undefined) {
+                centers.add(`${centerMm.x},${centerMm.y}`);
+            }
+        }
+        if (partIds.size > 1) {
+            issues.push({
+                code: "panel-mount-inconsistent",
+                severity: "warning",
+                message: `Mount "${mountId}" mixes part profiles: ${[...partIds].join(", ")}`,
+                ...(anchorId === undefined ? {} : { componentId: anchorId }),
+            });
+        }
+        if (centers.size > 1) {
+            issues.push({
+                code: "panel-mount-inconsistent",
+                severity: "warning",
+                message: `Mount "${mountId}" members are not at one shared centerMm`,
+                ...(anchorId === undefined ? {} : { componentId: anchorId }),
+            });
+        }
+    }
+    return issues;
 }
 function validatePanel(doc, componentIds, semanticControlIds) {
     if (doc.panel === undefined) {
@@ -640,19 +1063,20 @@ function validatePanel(doc, componentIds, semanticControlIds) {
     for (const face of doc.panel.faces) {
         for (const element of face.elements) {
             const componentId = element.bind.componentId;
-            if (element.interfaceControlId !== undefined && !semanticControlIds.has(element.interfaceControlId)) {
+            if (element.interfaceControlId !== undefined &&
+                !semanticControlIds.has(element.interfaceControlId)) {
                 issues.push({
-                    code: 'panel-interface-control-unresolved',
-                    severity: 'warning',
+                    code: "panel-interface-control-unresolved",
+                    severity: "warning",
                     message: `Panel element on face "${face.id}" references missing interface control "${element.interfaceControlId}"`,
                     componentId: element.interfaceControlId,
-                    property: 'interfaceControlId',
+                    property: "interfaceControlId",
                 });
             }
             if (!componentIds.has(componentId)) {
                 issues.push({
-                    code: 'panel-binding-unresolved',
-                    severity: 'warning',
+                    code: "panel-binding-unresolved",
+                    severity: "warning",
                     message: `Panel element on face "${face.id}" references missing component "${componentId}"`,
                     componentId,
                 });
@@ -661,18 +1085,19 @@ function validatePanel(doc, componentIds, semanticControlIds) {
             const resolved = resolvePanelElement(resolvedElements, element);
             if (element.bind.controlId !== undefined && resolved === undefined) {
                 issues.push({
-                    code: 'panel-control-unresolved',
-                    severity: 'warning',
+                    code: "panel-control-unresolved",
+                    severity: "warning",
                     message: `Panel element on face "${face.id}" references missing control "${element.bind.controlId}" on component "${componentId}"`,
                     componentId,
                     property: element.bind.controlId,
                 });
                 continue;
             }
-            if (resolved !== undefined && !panelKindsCompatible(element.kind, resolved.kind)) {
+            if (resolved !== undefined &&
+                !panelKindsCompatible(element.kind, resolved.kind)) {
                 issues.push({
-                    code: 'panel-kind-mismatch',
-                    severity: 'warning',
+                    code: "panel-kind-mismatch",
+                    severity: "warning",
                     message: `Panel element on face "${face.id}" binds component "${componentId}" as ${element.kind} but resolved kind is ${resolved.kind}`,
                     componentId,
                 });
@@ -688,7 +1113,8 @@ function panelKindsCompatible(declared, resolved) {
     if (declared === resolved) {
         return true;
     }
-    return resolved === 'switch' && (declared === 'selector' || declared === 'footswitch');
+    return (resolved === "switch" &&
+        (declared === "selector" || declared === "footswitch"));
 }
 function resolvePanelElements(doc) {
     const panel = extractPanel(doc);
@@ -697,47 +1123,51 @@ function resolvePanelElements(doc) {
         resolved.push({
             id: knob.id,
             componentId: componentIdFromPanelElementId(knob.id),
-            kind: knob.id.endsWith(':mode') && knob.controlMode === 'stepped' ? 'switch' : 'knob',
+            kind: knob.id.endsWith(":mode") && knob.controlMode === "stepped"
+                ? "switch"
+                : "knob",
         });
     }
     for (const slider of panel.sliders ?? []) {
         resolved.push({
             id: slider.id,
             componentId: componentIdFromPanelElementId(slider.id),
-            kind: 'slider',
+            kind: "slider",
         });
     }
     for (const switchControl of panel.switches) {
         resolved.push({
             id: switchControl.id,
             componentId: componentIdFromPanelElementId(switchControl.id),
-            kind: 'switch',
+            kind: "switch",
         });
     }
     for (const led of panel.leds) {
         resolved.push({
             id: led.id,
             componentId: componentIdFromPanelElementId(led.id),
-            kind: 'led',
+            kind: "led",
         });
     }
     for (const jack of panel.jacks) {
         resolved.push({
             id: jack.id,
             componentId: jack.sourceComponentId ?? componentIdFromPanelElementId(jack.id),
-            kind: 'jack',
+            kind: "jack",
         });
     }
     return resolved;
 }
 function resolvePanelElement(resolvedElements, element) {
     if (element.bind.controlId !== undefined) {
-        return resolvedElements.find((resolved) => resolved.componentId === element.bind.componentId && resolved.id === element.bind.controlId);
+        return resolvedElements.find((resolved) => resolved.componentId === element.bind.componentId &&
+            resolved.id === element.bind.controlId);
     }
-    return resolvedElements.find((resolved) => resolved.componentId === element.bind.componentId && resolved.id === element.bind.componentId);
+    return resolvedElements.find((resolved) => resolved.componentId === element.bind.componentId &&
+        resolved.id === element.bind.componentId);
 }
 function componentIdFromPanelElementId(id) {
-    const separator = id.indexOf(':');
+    const separator = id.indexOf(":");
     return separator <= 0 ? id : id.slice(0, separator);
 }
 function validatePanelCellCollisions(face) {
@@ -753,8 +1183,8 @@ function validatePanelCellCollisions(face) {
                 const key = `${row}:${column}`;
                 if (occupied.has(key)) {
                     issues.push({
-                        code: 'panel-cell-collision',
-                        severity: 'warning',
+                        code: "panel-cell-collision",
+                        severity: "warning",
                         message: `Panel face "${face.id}" has overlapping elements at row ${row}, column ${column}`,
                         componentId: element.bind.componentId,
                     });
@@ -786,21 +1216,21 @@ function validateV3BuildMetadata(doc, componentIds) {
     ]));
     const selectedBoardId = doc.build?.selectedBoardId;
     if (selectedBoardId !== undefined && !boardsById.has(selectedBoardId)) {
-        issues.push(unresolvedIssue('build-board-unresolved', 'error', `Build selectedBoardId references missing board "${selectedBoardId}"`, selectedBoardId, 'selectedBoardId'));
+        issues.push(unresolvedIssue("build-board-unresolved", "error", `Build selectedBoardId references missing board "${selectedBoardId}"`, selectedBoardId, "selectedBoardId"));
     }
     for (const boardId of doc.build?.alternateBoardIds ?? []) {
         if (!boardsById.has(boardId)) {
-            issues.push(unresolvedIssue('build-board-unresolved', 'warning', `Build alternateBoardIds references missing board "${boardId}"`, boardId, 'alternateBoardIds'));
+            issues.push(unresolvedIssue("build-board-unresolved", "warning", `Build alternateBoardIds references missing board "${boardId}"`, boardId, "alternateBoardIds"));
         }
     }
-    const preferredBoardId = dataString(doc.mechanical?.internalBoard, 'preferredBoardId');
+    const preferredBoardId = dataString(doc.mechanical?.internalBoard, "preferredBoardId");
     if (preferredBoardId !== undefined && !boardsById.has(preferredBoardId)) {
-        issues.push(unresolvedIssue('build-board-unresolved', 'warning', `Mechanical internalBoard.preferredBoardId references missing board "${preferredBoardId}"`, preferredBoardId, 'mechanical.internalBoard.preferredBoardId'));
+        issues.push(unresolvedIssue("build-board-unresolved", "warning", `Mechanical internalBoard.preferredBoardId references missing board "${preferredBoardId}"`, preferredBoardId, "mechanical.internalBoard.preferredBoardId"));
     }
     const harnessesById = new Map(doc.offBoardWiring?.harnesses.map((harness) => [harness.id, harness]) ?? []);
     for (const harnessId of doc.build?.selectedOffBoardWiringHarnessIds ?? []) {
         if (!harnessesById.has(harnessId)) {
-            issues.push(unresolvedIssue('build-harness-unresolved', 'error', `Build selectedOffBoardWiringHarnessIds references missing harness "${harnessId}"`, harnessId, 'selectedOffBoardWiringHarnessIds'));
+            issues.push(unresolvedIssue("build-harness-unresolved", "error", `Build selectedOffBoardWiringHarnessIds references missing harness "${harnessId}"`, harnessId, "selectedOffBoardWiringHarnessIds"));
         }
     }
     for (const item of doc.bom?.items ?? []) {
@@ -817,7 +1247,8 @@ function validateV3BuildMetadata(doc, componentIds) {
     if (doc.offBoardWiring !== undefined) {
         issues.push(...validateOffBoardWiring(doc, componentsById, panelElementIds, boardTerminalsByBoardId, boardNetsByBoardId));
     }
-    if (doc.build?.completeness === 'complete-selected-build' && selectedBoardId !== undefined) {
+    if (doc.build?.completeness === "complete-selected-build" &&
+        selectedBoardId !== undefined) {
         const selectedBoard = boardsById.get(selectedBoardId);
         if (selectedBoard !== undefined) {
             issues.push(...validateCompleteSelectedBoardRoutes(selectedBoard));
@@ -826,7 +1257,7 @@ function validateV3BuildMetadata(doc, componentIds) {
     return issues;
 }
 function hasV3BuildMetadata(doc) {
-    return doc.mechanical !== undefined ||
+    return (doc.mechanical !== undefined ||
         doc.build !== undefined ||
         doc.bom !== undefined ||
         doc.partProfiles !== undefined ||
@@ -834,71 +1265,78 @@ function hasV3BuildMetadata(doc) {
         doc.offBoardWiring !== undefined ||
         doc.boards !== undefined ||
         doc.panel?.faces.some((face) => face.geometry !== undefined ||
-            face.elements.some((element) => element.id !== undefined || element.physical !== undefined)) === true;
+            face.elements.some((element) => element.id !== undefined || element.physical !== undefined)) === true);
 }
 function validateBomRef(ref, componentIds, controlIds, panelElementIds, boardsById, itemId) {
-    if (ref.kind === 'component' && (ref.componentId === undefined || !componentIds.has(ref.componentId))) {
-        return unresolvedIssue('bom-ref-unresolved', 'warning', `BOM item "${itemId}" references missing component "${ref.componentId ?? ''}"`, itemId, 'refs.componentId');
+    if (ref.kind === "component" &&
+        (ref.componentId === undefined || !componentIds.has(ref.componentId))) {
+        return unresolvedIssue("bom-ref-unresolved", "warning", `BOM item "${itemId}" references missing component "${ref.componentId ?? ""}"`, itemId, "refs.componentId");
     }
-    if (ref.kind === 'device-interface-control' &&
+    if (ref.kind === "device-interface-control" &&
         (ref.controlId === undefined || !controlIds.has(ref.controlId))) {
-        return unresolvedIssue('bom-ref-unresolved', 'warning', `BOM item "${itemId}" references missing device interface control "${ref.controlId ?? ''}"`, itemId, 'refs.controlId');
+        return unresolvedIssue("bom-ref-unresolved", "warning", `BOM item "${itemId}" references missing device interface control "${ref.controlId ?? ""}"`, itemId, "refs.controlId");
     }
-    if (ref.kind === 'panel-element' && (ref.panelElementId === undefined || !panelElementIds.has(ref.panelElementId))) {
-        return unresolvedIssue('bom-ref-unresolved', 'warning', `BOM item "${itemId}" references missing panel element "${ref.panelElementId ?? ''}"`, itemId, 'refs.panelElementId');
+    if (ref.kind === "panel-element" &&
+        (ref.panelElementId === undefined ||
+            !panelElementIds.has(ref.panelElementId))) {
+        return unresolvedIssue("bom-ref-unresolved", "warning", `BOM item "${itemId}" references missing panel element "${ref.panelElementId ?? ""}"`, itemId, "refs.panelElementId");
     }
-    if (ref.kind === 'board' && (ref.boardId === undefined || !boardsById.has(ref.boardId))) {
-        return unresolvedIssue('bom-ref-unresolved', 'warning', `BOM item "${itemId}" references missing board "${ref.boardId ?? ''}"`, itemId, 'refs.boardId');
+    if (ref.kind === "board" &&
+        (ref.boardId === undefined || !boardsById.has(ref.boardId))) {
+        return unresolvedIssue("bom-ref-unresolved", "warning", `BOM item "${itemId}" references missing board "${ref.boardId ?? ""}"`, itemId, "refs.boardId");
     }
     return undefined;
 }
 function validateBoardRealization(board, componentsById, boardNetsByBoardId) {
     const issues = [];
-    if (board.sourceCircuit !== undefined && !isDigestShapedSourceHash(board.sourceCircuit.hash)) {
+    if (board.sourceCircuit !== undefined &&
+        !isDigestShapedSourceHash(board.sourceCircuit.hash)) {
         issues.push({
-            code: 'board-source-hash-invalid',
-            severity: 'error',
+            code: "board-source-hash-invalid",
+            severity: "error",
             message: `Board "${board.id}" sourceCircuit.hash must be sha256:<64 hex chars>`,
             componentId: board.id,
-            property: 'sourceCircuit.hash',
+            property: "sourceCircuit.hash",
         });
     }
     for (const terminal of board.edgeTerminals) {
-        if (terminal.terminalRef !== undefined && !componentTerminalExists(componentsById, terminal.terminalRef)) {
-            issues.push(unresolvedIssue('board-terminal-unresolved', 'warning', `Board "${board.id}" edge terminal "${terminal.id}" references missing component terminal`, board.id, terminal.id));
+        if (terminal.terminalRef !== undefined &&
+            !componentTerminalExists(componentsById, terminal.terminalRef)) {
+            issues.push(unresolvedIssue("board-terminal-unresolved", "warning", `Board "${board.id}" edge terminal "${terminal.id}" references missing component terminal`, board.id, terminal.id));
         }
     }
     for (const placement of board.footprintPlacements) {
         if (!componentsById.has(placement.componentId)) {
-            issues.push(unresolvedIssue('board-terminal-unresolved', 'warning', `Board "${board.id}" places missing component "${placement.componentId}"`, board.id, placement.componentId));
+            issues.push(unresolvedIssue("board-terminal-unresolved", "warning", `Board "${board.id}" places missing component "${placement.componentId}"`, board.id, placement.componentId));
             continue;
         }
         for (const pad of placement.pads) {
             if (pad.terminalName !== undefined &&
                 !componentHasTerminal(componentsById, placement.componentId, pad.terminalName)) {
-                issues.push(unresolvedIssue('board-terminal-unresolved', 'warning', `Board "${board.id}" pad "${pad.padId}" references missing terminal "${pad.terminalName}"`, board.id, pad.padId));
+                issues.push(unresolvedIssue("board-terminal-unresolved", "warning", `Board "${board.id}" pad "${pad.padId}" references missing terminal "${pad.terminalName}"`, board.id, pad.padId));
             }
         }
     }
     for (const net of board.netlist?.nets ?? []) {
         for (const member of net.members) {
             if (!componentTerminalExists(componentsById, member)) {
-                issues.push(unresolvedIssue('board-terminal-unresolved', 'warning', `Board "${board.id}" net "${net.id}" references missing component terminal`, board.id, net.id));
+                issues.push(unresolvedIssue("board-terminal-unresolved", "warning", `Board "${board.id}" net "${net.id}" references missing component terminal`, board.id, net.id));
             }
         }
     }
     for (const route of board.routes) {
         if (route.zones !== undefined || route.drills !== undefined) {
             issues.push({
-                code: 'board-route-feature-invalid',
-                severity: 'error',
+                code: "board-route-feature-invalid",
+                severity: "error",
                 message: `Board "${board.id}" route "${route.id}" contains board-level zones or drills`,
                 componentId: board.id,
                 property: route.id,
             });
         }
-        if (isBoardNetlistRef(route.netRef) && !boardNetRefExists(route.netRef, board.id, boardNetsByBoardId)) {
-            issues.push(unresolvedIssue('offboard-signal-unresolved', 'warning', `Board "${board.id}" route "${route.id}" references missing board net "${route.netRef.netId}"`, board.id, route.id));
+        if (isBoardNetlistRef(route.netRef) &&
+            !boardNetRefExists(route.netRef, board.id, boardNetsByBoardId)) {
+            issues.push(unresolvedIssue("offboard-signal-unresolved", "warning", `Board "${board.id}" route "${route.id}" references missing board net "${route.netRef.netId}"`, board.id, route.id));
         }
     }
     return issues;
@@ -918,10 +1356,10 @@ function validateOffBoardWiring(doc, componentsById, panelElementIds, boardTermi
         }
         for (const connection of harness.connections) {
             if (!localEndpointIds.has(connection.fromEndpointId)) {
-                issues.push(unresolvedIssue('offboard-endpoint-unresolved', 'error', `Harness "${harness.id}" connection "${connection.id}" references missing endpoint "${connection.fromEndpointId}"`, harness.id, connection.id));
+                issues.push(unresolvedIssue("offboard-endpoint-unresolved", "error", `Harness "${harness.id}" connection "${connection.id}" references missing endpoint "${connection.fromEndpointId}"`, harness.id, connection.id));
             }
             if (!localEndpointIds.has(connection.toEndpointId)) {
-                issues.push(unresolvedIssue('offboard-endpoint-unresolved', 'error', `Harness "${harness.id}" connection "${connection.id}" references missing endpoint "${connection.toEndpointId}"`, harness.id, connection.id));
+                issues.push(unresolvedIssue("offboard-endpoint-unresolved", "error", `Harness "${harness.id}" connection "${connection.id}" references missing endpoint "${connection.toEndpointId}"`, harness.id, connection.id));
             }
             if (connection.signalRef !== undefined) {
                 const issue = validateOffBoardSignalRef(connection.signalRef, componentsById, boardNetsByBoardId, harness.id);
@@ -937,33 +1375,38 @@ function validateOffBoardWiring(doc, componentsById, panelElementIds, boardTermi
             continue;
         }
         for (const connection of harness.connections) {
-            if (!endpointIds.has(connection.fromEndpointId) || !endpointIds.has(connection.toEndpointId)) {
-                issues.push(unresolvedIssue('offboard-endpoint-unresolved', 'error', `Selected harness "${harnessId}" contains an unresolved connection endpoint`, harnessId, connection.id));
+            if (!endpointIds.has(connection.fromEndpointId) ||
+                !endpointIds.has(connection.toEndpointId)) {
+                issues.push(unresolvedIssue("offboard-endpoint-unresolved", "error", `Selected harness "${harnessId}" contains an unresolved connection endpoint`, harnessId, connection.id));
             }
         }
     }
     return issues;
 }
 function validateOffBoardEndpoint(endpoint, componentsById, panelElementIds, boardTerminalsByBoardId) {
-    if (endpoint.kind === 'board-terminal') {
-        const terminalIds = endpoint.boardId === undefined ? undefined : boardTerminalsByBoardId.get(endpoint.boardId);
-        if (terminalIds === undefined || endpoint.terminalId === undefined || !terminalIds.has(endpoint.terminalId)) {
-            return unresolvedIssue('offboard-endpoint-unresolved', 'error', `Off-board endpoint "${endpoint.id}" references missing board terminal`, endpoint.id, 'terminalId');
+    if (endpoint.kind === "board-terminal") {
+        const terminalIds = endpoint.boardId === undefined
+            ? undefined
+            : boardTerminalsByBoardId.get(endpoint.boardId);
+        if (terminalIds === undefined ||
+            endpoint.terminalId === undefined ||
+            !terminalIds.has(endpoint.terminalId)) {
+            return unresolvedIssue("offboard-endpoint-unresolved", "error", `Off-board endpoint "${endpoint.id}" references missing board terminal`, endpoint.id, "terminalId");
         }
         return undefined;
     }
-    if (endpoint.kind === 'panel-component-terminal' ||
-        endpoint.kind === 'power-terminal' ||
-        endpoint.kind === 'footswitch-terminal') {
+    if (endpoint.kind === "panel-component-terminal" ||
+        endpoint.kind === "power-terminal" ||
+        endpoint.kind === "footswitch-terminal") {
         if (endpoint.componentId === undefined ||
             endpoint.terminalName === undefined ||
             !componentHasTerminal(componentsById, endpoint.componentId, endpoint.terminalName)) {
-            return unresolvedIssue('offboard-endpoint-unresolved', 'error', `Off-board endpoint "${endpoint.id}" references missing component terminal`, endpoint.id, 'componentId');
+            return unresolvedIssue("offboard-endpoint-unresolved", "error", `Off-board endpoint "${endpoint.id}" references missing component terminal`, endpoint.id, "componentId");
         }
         if (endpoint.panelElementId !== undefined &&
-            endpoint.kind !== 'power-terminal' &&
+            endpoint.kind !== "power-terminal" &&
             !panelElementIds.has(endpoint.panelElementId)) {
-            return unresolvedIssue('offboard-endpoint-unresolved', 'warning', `Off-board endpoint "${endpoint.id}" references missing panel element "${endpoint.panelElementId}"`, endpoint.id, 'panelElementId');
+            return unresolvedIssue("offboard-endpoint-unresolved", "warning", `Off-board endpoint "${endpoint.id}" references missing panel element "${endpoint.panelElementId}"`, endpoint.id, "panelElementId");
         }
     }
     return undefined;
@@ -971,16 +1414,18 @@ function validateOffBoardEndpoint(endpoint, componentsById, panelElementIds, boa
 function validateOffBoardSignalRef(signalRef, componentsById, boardNetsByBoardId, harnessId) {
     if (isBoardNetlistRef(signalRef)) {
         if (!boardNetRefExists(signalRef, signalRef.boardId, boardNetsByBoardId)) {
-            return unresolvedIssue('offboard-signal-unresolved', 'error', `Harness "${harnessId}" references missing board net "${signalRef.netId}"`, harnessId, 'signalRef');
+            return unresolvedIssue("offboard-signal-unresolved", "error", `Harness "${harnessId}" references missing board net "${signalRef.netId}"`, harnessId, "signalRef");
         }
         return undefined;
     }
-    const member = dataObject(signalRef, 'member');
-    const componentId = dataString(member, 'componentId');
-    const terminalName = dataString(member, 'terminalName');
-    if (dataString(signalRef, 'source') === 'canonical-circuit' && componentId !== undefined && terminalName !== undefined) {
+    const member = dataObject(signalRef, "member");
+    const componentId = dataString(member, "componentId");
+    const terminalName = dataString(member, "terminalName");
+    if (dataString(signalRef, "source") === "canonical-circuit" &&
+        componentId !== undefined &&
+        terminalName !== undefined) {
         if (!componentHasTerminal(componentsById, componentId, terminalName)) {
-            return unresolvedIssue('offboard-signal-unresolved', 'error', `Harness "${harnessId}" references missing canonical component terminal`, harnessId, 'signalRef');
+            return unresolvedIssue("offboard-signal-unresolved", "error", `Harness "${harnessId}" references missing canonical component terminal`, harnessId, "signalRef");
         }
     }
     return undefined;
@@ -989,7 +1434,7 @@ function validateCompleteSelectedBoardRoutes(board) {
     const issues = [];
     const routedNetIds = new Set(board.routes
         .filter((route) => isRouteForBoardNet(route, board.id))
-        .map((route) => dataString(route.netRef, 'netId'))
+        .map((route) => dataString(route.netRef, "netId"))
         .filter((netId) => netId !== undefined));
     for (const net of board.netlist?.nets ?? []) {
         if (isSingleTerminalEdgeNet(net)) {
@@ -997,8 +1442,8 @@ function validateCompleteSelectedBoardRoutes(board) {
         }
         if (!routedNetIds.has(net.id)) {
             issues.push({
-                code: 'board-net-unrouted',
-                severity: 'error',
+                code: "board-net-unrouted",
+                severity: "error",
                 message: `Selected board "${board.id}" net "${net.id}" has multiple members but no route`,
                 componentId: board.id,
                 property: net.id,
@@ -1017,7 +1462,8 @@ function isRouteForBoardNet(route, boardId) {
     return route.netRef.boardId === undefined || route.netRef.boardId === boardId;
 }
 function isBoardNetlistRef(value) {
-    return dataString(value, 'source') === 'board-netlist' && dataString(value, 'netId') !== undefined;
+    return (dataString(value, "source") === "board-netlist" &&
+        dataString(value, "netId") !== undefined);
 }
 function boardNetRefExists(ref, fallbackBoardId, boardNetsByBoardId) {
     const boardId = ref.boardId ?? fallbackBoardId;
@@ -1045,21 +1491,23 @@ function componentTerminalExists(componentsById, ref) {
     return componentHasTerminal(componentsById, ref.componentId, ref.terminalName);
 }
 function componentHasTerminal(componentsById, componentId, terminalName) {
-    return componentsById.get(componentId)?.terminals.some((terminal) => terminal.name === terminalName) === true;
+    return (componentsById
+        .get(componentId)
+        ?.terminals.some((terminal) => terminal.name === terminalName) === true);
 }
 function isDigestShapedSourceHash(hash) {
     return /^sha256:[0-9a-f]{64}$/i.test(hash);
 }
 function dataString(object, key) {
     const value = object?.[key];
-    return typeof value === 'string' ? value : undefined;
+    return typeof value === "string" ? value : undefined;
 }
 function dataObject(object, key) {
     const value = object?.[key];
     return isBuildDataObject(value) ? value : undefined;
 }
 function isBuildDataObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function unresolvedIssue(code, severity, message, componentId, property) {
     return {
@@ -1072,8 +1520,8 @@ function unresolvedIssue(code, severity, message, componentId, property) {
 }
 function missingPropertyIssue(component, rule) {
     return {
-        code: rule.kind === 'string' ? 'model-required' : 'value-required',
-        severity: 'error',
+        code: rule.kind === "string" ? "model-required" : "value-required",
+        severity: "error",
         message: `${component.id} (${component.kind}): missing required property "${rule.name}"`,
         componentId: component.id,
         property: rule.name,