@vessel-dsp/core 0.5.0 → 0.6.1

package/{src/model/validation.ts → dist/model/validation.js}

@@ -1,90 +1,17 @@
-import { propertyQuantityValue, propertyStringValue } from './properties';
-import { extractPanel } from '../panel/extract';
-import type {
-    CircuitDocument,
-    Component,
-    ComponentKind,
-    DeviceInterfaceBinding,
-    DeviceInterfaceControl,
-    PanelControlKind,
-    PanelElementPlacement,
-    PanelFace,
-    ParsedQuantity,
-    PropertyValue,
-} from './types';
-
-export type ValidationSeverity = 'error' | 'warning';
-
-export type ValidationCode =
-    | 'value-required'
-    | 'model-required'
-    | 'value-unparseable'
-    | 'value-out-of-range'
-    | 'unit-mismatch'
-    | 'unsupported-component'
-    | 'invalid-jack-role'
-    | 'invalid-jack-interface'
-    | 'invalid-jack-audio-role'
-    | 'descriptor-control-empty'
-    | 'descriptor-mode-label-mismatch'
-    | 'duplicate-device-interface-control-id'
-    | 'invalid-device-interface-token'
-    | 'control-group-context-unresolved'
-    | 'device-interface-group-unresolved'
-    | 'device-interface-context-unresolved'
-    | 'device-interface-binding-unresolved'
-    | 'device-interface-duplicate-role'
-    | 'panel-interface-control-unresolved'
-    | 'panel-binding-unresolved'
-    | 'panel-control-unresolved'
-    | 'panel-kind-mismatch'
-    | 'panel-cell-collision'
-    | 'duplicate-id'
-    | 'degenerate-wire';
-
-export type ValidationIssue = Readonly<{
-    code: ValidationCode;
-    severity: ValidationSeverity;
-    message: string;
-    componentId?: string;
-    property?: string;
-    wireId?: string;
-}>;
-
-export type QuantityRule = Readonly<{
-    kind: 'quantity';
-    name: string;
-    required: boolean;
-    aliases?: readonly string[];
-    unit?: string;
-    min?: number;
-    max?: number;
-}>;
-
-export type StringRule = Readonly<{
-    kind: 'string';
-    name: string;
-    required: boolean;
-    aliases?: readonly string[];
-}>;
-
-export type PropertyRule = QuantityRule | StringRule;
-
-const MODEL_ALIASES = ['Model', 'Type', 'partNumber', 'PartNumber'] as const;
-
+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: ReadonlySet<string> = 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: Partial<Record<ComponentKind, readonly string[]>> = {
+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'],
 };
-
 const RUNTIME_DESCRIPTOR_CONTROL_PROPERTIES = [
     'TimeControl',
     'FeedbackControl',
@@ -101,23 +28,16 @@ const RUNTIME_DESCRIPTOR_CONTROL_PROPERTIES = [
     'DirectOutJack',
     'DirectOutputControl',
     'DirectOutControl',
-] as const;
-
-type ResolvedPanelElement = Readonly<{
-    id: string;
-    componentId: string;
-    kind: PanelControlKind;
-}>;
-
-const KIND_RULES: Partial<Record<ComponentKind, readonly PropertyRule[]>> = {
+];
+const KIND_RULES = {
     resistor: [{
-        kind: 'quantity', name: 'R', required: true, unit: 'Ω',
-        min: 1e-9, max: 1e9, aliases: ['Resistance', 'resistance', 'r'],
-    }],
+            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'],
-    }],
+            kind: 'quantity', name: 'R', required: true, unit: 'Ω',
+            min: 1e-9, max: 1e9, aliases: ['Resistance', 'resistance', 'r'],
+        }],
     potentiometer: [
         {
             kind: 'quantity', name: 'R', required: true, unit: 'Ω',
@@ -126,29 +46,29 @@ const KIND_RULES: Partial<Record<ComponentKind, readonly PropertyRule[]>> = {
         { 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'],
-    }],
+            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'],
-    }],
+            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'],
-    }],
+            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'],
-    }],
+            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'],
-    }],
+            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'],
-    }],
+            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] }],
@@ -169,27 +89,19 @@ const KIND_RULES: Partial<Record<ComponentKind, readonly PropertyRule[]>> = {
     flipflop: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
     ic: [{ kind: 'string', name: 'model', required: true, aliases: [...MODEL_ALIASES] }],
 };
-
-export function getRulesForKind(kind: ComponentKind): readonly PropertyRule[] {
+export function getRulesForKind(kind) {
     return KIND_RULES[kind] ?? [];
 }
-
-export function validateComponent(
-    component: Component,
-    rules: readonly PropertyRule[] = getRulesForKind(component.kind),
-): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-
+export function validateComponent(component, rules = getRulesForKind(component.kind)) {
+    const issues = [];
     for (const rule of rules) {
         const value = findProperty(component, rule);
-
         if (value === undefined) {
             if (rule.required && !isRequirementWaived(component, rule)) {
                 issues.push(missingPropertyIssue(component, rule));
             }
             continue;
         }
-
         if (rule.kind === 'string') {
             if (typeof value !== 'string' || value.trim().length === 0) {
                 if (rule.required && !isRequirementWaived(component, rule)) {
@@ -198,7 +110,6 @@ export function validateComponent(
             }
             continue;
         }
-
         const quantity = coerceQuantity(value);
         if (quantity === null) {
             if (typeof value === 'string' && isRawQuantityExpression(value)) {
@@ -213,7 +124,6 @@ export function validateComponent(
             });
             continue;
         }
-
         if (rule.unit !== undefined && rule.unit.length > 0 && quantity.unit.length > 0 && quantity.unit !== rule.unit) {
             issues.push({
                 code: 'unit-mismatch',
@@ -223,7 +133,6 @@ export function validateComponent(
                 property: rule.name,
             });
         }
-
         if (rule.min !== undefined && quantity.value < rule.min) {
             issues.push({
                 code: 'value-out-of-range',
@@ -243,14 +152,11 @@ export function validateComponent(
             });
         }
     }
-
     return issues;
 }
-
-export function validateDocument(doc: CircuitDocument): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-    const seen = new Set<string>();
-
+export function validateDocument(doc) {
+    const issues = [];
+    const seen = new Set();
     for (const component of doc.components) {
         if (seen.has(component.id)) {
             issues.push({
@@ -261,7 +167,6 @@ export function validateDocument(doc: CircuitDocument): readonly ValidationIssue
             });
         }
         seen.add(component.id);
-
         if (component.kind === 'unsupported') {
             issues.push({
                 code: 'unsupported-component',
@@ -271,16 +176,13 @@ export function validateDocument(doc: CircuitDocument): readonly ValidationIssue
             });
             continue;
         }
-
         for (const issue of validateComponent(component)) {
             issues.push(issue);
         }
-
         for (const issue of validateSemanticMetadata(component)) {
             issues.push(issue);
         }
     }
-
     for (const wire of doc.wires) {
         const [a, b] = wire.endpoints;
         if (a.x === b.x && a.y === b.y) {
@@ -292,27 +194,24 @@ export function validateDocument(doc: CircuitDocument): readonly ValidationIssue
             });
         }
     }
-
     for (const issue of validateDeviceInterface(doc, seen)) {
         issues.push(issue);
     }
-
     for (const issue of validatePanel(doc, seen, new Set(doc.deviceInterface?.controls.map((control) => control.id) ?? []))) {
         issues.push(issue);
     }
-
+    for (const issue of validateV3BuildMetadata(doc, seen)) {
+        issues.push(issue);
+    }
     return issues;
 }
-
-export function hasErrors(issues: readonly ValidationIssue[]): boolean {
+export function hasErrors(issues) {
     return issues.some((issue) => issue.severity === 'error');
 }
-
-function isRequirementWaived(component: Component, rule: PropertyRule): boolean {
+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') {
         return false;
@@ -327,8 +226,7 @@ function isRequirementWaived(component: Component, rule: PropertyRule): boolean
     const inline = INLINE_MODEL_PARAMETERS[component.kind] ?? [];
     return inline.some((name) => component.properties[name] !== undefined);
 }
-
-function isInterfaceOnlyComponent(component: Component): boolean {
+function isInterfaceOnlyComponent(component) {
     const interfaceOnly = component.properties.InterfaceOnly;
     if (interfaceOnly === true) {
         return true;
@@ -339,25 +237,19 @@ function isInterfaceOnlyComponent(component: Component): boolean {
     const support = component.properties.Support;
     return typeof support === 'string' && normalizeToken(support) === 'view-only';
 }
-
-function validateSemanticMetadata(component: Component): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-
+function validateSemanticMetadata(component) {
+    const issues = [];
     if (component.kind === 'jack') {
         issues.push(...validateJackSemanticMetadata(component));
     }
-
     if (component.kind === 'ic' && component.properties.RuntimeDescriptor === 'true') {
         issues.push(...validateRuntimeDescriptorMetadata(component));
     }
-
     return issues;
 }
-
-function validateJackSemanticMetadata(component: Component): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-
-    for (const property of ['Role', 'ControlRole'] as const) {
+function validateJackSemanticMetadata(component) {
+    const issues = [];
+    for (const property of ['Role', 'ControlRole']) {
         const value = propertyString(component, property);
         if (value !== null && value.trim().length > 0 && !isRecognizedJackRole(value)) {
             issues.push({
@@ -369,7 +261,6 @@ function validateJackSemanticMetadata(component: Component): readonly Validation
             });
         }
     }
-
     const interfaceName = propertyString(component, 'Interface');
     if (interfaceName !== null && interfaceName.trim().length > 0 && !isRecognizedJackInterface(interfaceName)) {
         issues.push({
@@ -380,7 +271,6 @@ function validateJackSemanticMetadata(component: Component): readonly Validation
             property: 'Interface',
         });
     }
-
     const audioRole = propertyString(component, 'AudioRole');
     if (audioRole !== null && !isValidJackAudioRole(audioRole)) {
         issues.push({
@@ -391,13 +281,10 @@ function validateJackSemanticMetadata(component: Component): readonly Validation
             property: 'AudioRole',
         });
     }
-
     return issues;
 }
-
-function validateRuntimeDescriptorMetadata(component: Component): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-
+function validateRuntimeDescriptorMetadata(component) {
+    const issues = [];
     for (const property of RUNTIME_DESCRIPTOR_CONTROL_PROPERTIES) {
         const value = propertyString(component, property);
         if (value !== null && value.trim().length === 0) {
@@ -410,7 +297,6 @@ function validateRuntimeDescriptorMetadata(component: Component): readonly Valid
             });
         }
     }
-
     const labels = parseStringList(propertyStringAny(component, ['ModeLabels', 'ModeOptions']));
     const stepCount = parsePositiveInteger(propertyStringAny(component, ['ModeStepCount', 'ModeSteps', 'ModeCount']));
     if (labels.length > 0 && stepCount !== undefined && labels.length !== stepCount) {
@@ -422,11 +308,9 @@ function validateRuntimeDescriptorMetadata(component: Component): readonly Valid
             property: 'ModeLabels',
         });
     }
-
     return issues;
 }
-
-function shortSourceType(sourceTypeName: string | null): string | null {
+function shortSourceType(sourceTypeName) {
     if (sourceTypeName === null) {
         return null;
     }
@@ -437,8 +321,7 @@ function shortSourceType(sourceTypeName: string | null): string | null {
     const lastDot = head.lastIndexOf('.');
     return lastDot >= 0 ? head.slice(lastDot + 1) : head;
 }
-
-function findProperty(component: Component, rule: PropertyRule): PropertyValue | undefined {
+function findProperty(component, rule) {
     const candidates = [rule.name, ...(rule.aliases ?? [])];
     for (const name of candidates) {
         const value = component.properties[name];
@@ -448,12 +331,10 @@ function findProperty(component: Component, rule: PropertyRule): PropertyValue |
     }
     return undefined;
 }
-
-function propertyString(component: Component, name: string): string | null {
+function propertyString(component, name) {
     return propertyStringValue(component.properties[name]);
 }
-
-function propertyStringAny(component: Component, names: readonly string[]): string | null {
+function propertyStringAny(component, names) {
     for (const name of names) {
         const value = propertyString(component, name);
         if (value !== null) {
@@ -462,12 +343,10 @@ function propertyStringAny(component: Component, names: readonly string[]): stri
     }
     return null;
 }
-
-function coerceQuantity(value: PropertyValue): ParsedQuantity | null {
+function coerceQuantity(value) {
     return propertyQuantityValue(value);
 }
-
-function isRawQuantityExpression(value: string): boolean {
+function isRawQuantityExpression(value) {
     const trimmed = value.trim();
     if (trimmed.length === 0) {
         return false;
@@ -478,8 +357,7 @@ function isRawQuantityExpression(value: string): boolean {
     return /^(AC|DC)\b/i.test(trimmed) ||
         /^(SINE|PULSE|PWL|EXP|SFFM|AM|WAVEFILE)\s*\(/i.test(trimmed);
 }
-
-function isRecognizedJackRole(value: string): boolean {
+function isRecognizedJackRole(value) {
     const normalized = normalizeToken(value);
     return [
         'input',
@@ -511,8 +389,7 @@ function isRecognizedJackRole(value: string): boolean {
         'reset',
     ].includes(normalized);
 }
-
-function isRecognizedJackInterface(value: string): boolean {
+function isRecognizedJackInterface(value) {
     const normalized = normalizeToken(value);
     return isRecognizedJackRole(value) ||
         [
@@ -520,15 +397,17 @@ function isRecognizedJackInterface(value: string): boolean {
             'audio-port',
             'control',
             'control-port',
+            'power',
+            'power-port',
+            'dc-power',
+            'dc-power-input',
             'tap-tempo-input',
         ].includes(normalized);
 }
-
-function isValidJackAudioRole(value: string): boolean {
+function isValidJackAudioRole(value) {
     return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
 }
-
-function parseStringList(value: string | null): readonly string[] {
+function parseStringList(value) {
     if (value === null) {
         return [];
     }
@@ -537,8 +416,7 @@ function parseStringList(value: string | null): readonly string[] {
         .map((part) => part.trim())
         .filter((part) => part.length > 0);
 }
-
-function parsePositiveInteger(value: string | null): number | undefined {
+function parsePositiveInteger(value) {
     if (value === null) {
         return undefined;
     }
@@ -549,23 +427,17 @@ function parsePositiveInteger(value: string | null): number | undefined {
     const count = Number(trimmed);
     return Number.isInteger(count) && count > 0 ? count : undefined;
 }
-
-function normalizeToken(value: string): string {
+function normalizeToken(value) {
     return value.trim().toLowerCase().replace(/[\s_]+/g, '-');
 }
-
-function validateDeviceInterface(
-    doc: CircuitDocument,
-    componentIds: ReadonlySet<string>,
-): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
+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 semanticControlIds = new Set<string>();
+    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'));
         for (const contextId of group.contextIds ?? []) {
@@ -580,11 +452,9 @@ function validateDeviceInterface(
             }
         }
     }
-
     for (const context of doc.controlContexts ?? []) {
         issues.push(...validateOpenToken(context.role, context.id, 'role'));
     }
-
     for (const control of doc.deviceInterface?.controls ?? []) {
         if (semanticControlIds.has(control.id)) {
             issues.push({
@@ -595,9 +465,7 @@ function validateDeviceInterface(
             });
         }
         semanticControlIds.add(control.id);
-
         issues.push(...validateOpenToken(control.role, control.id, 'role'));
-
         if (control.groupId !== undefined && !groupIds.has(control.groupId)) {
             issues.push({
                 code: 'device-interface-group-unresolved',
@@ -607,85 +475,54 @@ function validateDeviceInterface(
                 property: 'groupId',
             });
         }
-
         issues.push(...validateApplicability(control, contextIds));
-
         if (control.binding !== undefined) {
-            issues.push(...validateDeviceInterfaceBinding(
-                control,
-                control.binding,
-                componentIds,
-                externalInterfaceIds,
-                componentsById,
-                resolvedPanelElements,
-            ));
+            issues.push(...validateDeviceInterfaceBinding(control, control.binding, componentIds, externalInterfaceIds, componentsById, resolvedPanelElements));
         }
     }
-
     issues.push(...validateDuplicateDeviceInterfaceRoles(doc.deviceInterface?.controls ?? []));
-
     return issues;
 }
-
-function validateOpenToken(value: string, componentId: string, property: string): readonly ValidationIssue[] {
+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',
-        message: `${componentId}: ${property} "${value}" must be a lower-kebab token`,
-        componentId,
-        property,
-    }];
-}
-
-function validateApplicability(
-    control: DeviceInterfaceControl,
-    contextIds: ReadonlySet<string>,
-): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
+            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
+    if (control.appliesWhen.allOf !== undefined
         && control.appliesWhen.allOf.length === 0
-        && control.appliesWhen.anyOf === undefined
-    ) {
+        && control.appliesWhen.anyOf === undefined) {
         issues.push(emptyApplicabilityIssue(control.id, 'appliesWhen.allOf'));
     }
-    if (
-        control.appliesWhen.anyOf !== undefined
+    if (control.appliesWhen.anyOf !== undefined
         && control.appliesWhen.anyOf.length === 0
-        && control.appliesWhen.allOf === undefined
-    ) {
+        && control.appliesWhen.allOf === undefined) {
         issues.push(emptyApplicabilityIssue(control.id, 'appliesWhen.anyOf'));
     }
-
     return issues;
 }
-
-function validateContextList(
-    controlId: string,
-    property: string,
-    values: readonly string[] | undefined,
-    contextIds: ReadonlySet<string>,
-): readonly ValidationIssue[] {
+function validateContextList(controlId, property, values, contextIds) {
     if (values === undefined) {
         return [];
     }
-
-    const issues: ValidationIssue[] = [];
-    const seen = new Set<string>();
+    const issues = [];
+    const seen = new Set();
     if (values.length === 0) {
         issues.push(emptyApplicabilityIssue(controlId, property));
     }
-
     for (const contextId of values) {
         if (seen.has(contextId)) {
             issues.push({
@@ -697,7 +534,6 @@ function validateContextList(
             });
         }
         seen.add(contextId);
-
         if (!contextIds.has(contextId)) {
             issues.push({
                 code: 'device-interface-context-unresolved',
@@ -708,11 +544,9 @@ function validateContextList(
             });
         }
     }
-
     return issues;
 }
-
-function emptyApplicabilityIssue(controlId: string, property: string): ValidationIssue {
+function emptyApplicabilityIssue(controlId, property) {
     return {
         code: 'device-interface-context-unresolved',
         severity: 'warning',
@@ -721,16 +555,8 @@ function emptyApplicabilityIssue(controlId: string, property: string): Validatio
         property,
     };
 }
-
-function validateDeviceInterfaceBinding(
-    control: DeviceInterfaceControl,
-    binding: DeviceInterfaceBinding,
-    componentIds: ReadonlySet<string>,
-    externalInterfaceIds: ReadonlySet<string>,
-    componentsById: ReadonlyMap<string, Component>,
-    resolvedPanelElements: readonly ResolvedPanelElement[],
-): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
+function validateDeviceInterfaceBinding(control, binding, componentIds, externalInterfaceIds, componentsById, resolvedPanelElements) {
+    const issues = [];
     if (binding.externalInterfaceId !== undefined && !externalInterfaceIds.has(binding.externalInterfaceId)) {
         issues.push({
             code: 'device-interface-binding-unresolved',
@@ -740,7 +566,6 @@ function validateDeviceInterfaceBinding(
             property: 'binding.externalInterfaceId',
         });
     }
-
     if (!componentIds.has(binding.componentId)) {
         issues.push({
             code: 'device-interface-binding-unresolved',
@@ -751,13 +576,8 @@ function validateDeviceInterfaceBinding(
         });
         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',
@@ -766,7 +586,6 @@ function validateDeviceInterfaceBinding(
             property: 'binding.controlId',
         });
     }
-
     const component = componentsById.get(binding.componentId);
     if (binding.property !== undefined && component?.properties[binding.property] === undefined) {
         issues.push({
@@ -777,15 +596,11 @@ function validateDeviceInterfaceBinding(
             property: 'binding.property',
         });
     }
-
     return issues;
 }
-
-function validateDuplicateDeviceInterfaceRoles(
-    controls: readonly DeviceInterfaceControl[],
-): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-    const seen = new Map<string, DeviceInterfaceControl>();
+function validateDuplicateDeviceInterfaceRoles(controls) {
+    const issues = [];
+    const seen = new Map();
     for (const control of controls) {
         const key = `${control.groupId ?? ''}:${control.role}`;
         const existing = seen.get(key);
@@ -804,8 +619,7 @@ function validateDuplicateDeviceInterfaceRoles(
     }
     return issues;
 }
-
-function deviceInterfaceBindingSignature(binding: DeviceInterfaceBinding | undefined): string {
+function deviceInterfaceBindingSignature(binding) {
     if (binding === undefined) {
         return '';
     }
@@ -817,19 +631,12 @@ function deviceInterfaceBindingSignature(binding: DeviceInterfaceBinding | undef
         binding.externalInterfaceId ?? '',
     ].join(':');
 }
-
-function validatePanel(
-    doc: CircuitDocument,
-    componentIds: ReadonlySet<string>,
-    semanticControlIds: ReadonlySet<string>,
-): readonly ValidationIssue[] {
+function validatePanel(doc, componentIds, semanticControlIds) {
     if (doc.panel === undefined) {
         return [];
     }
-
-    const issues: ValidationIssue[] = [];
+    const issues = [];
     const resolvedElements = resolvePanelElements(doc);
-
     for (const face of doc.panel.faces) {
         for (const element of face.elements) {
             const componentId = element.bind.componentId;
@@ -851,7 +658,6 @@ function validatePanel(
                 });
                 continue;
             }
-
             const resolved = resolvePanelElement(resolvedElements, element);
             if (element.bind.controlId !== undefined && resolved === undefined) {
                 issues.push({
@@ -863,8 +669,7 @@ function validatePanel(
                 });
                 continue;
             }
-
-            if (resolved !== undefined && resolved.kind !== element.kind) {
+            if (resolved !== undefined && !panelKindsCompatible(element.kind, resolved.kind)) {
                 issues.push({
                     code: 'panel-kind-mismatch',
                     severity: 'warning',
@@ -873,19 +678,21 @@ function validatePanel(
                 });
             }
         }
-
         for (const issue of validatePanelCellCollisions(face)) {
             issues.push(issue);
         }
     }
-
     return issues;
 }
-
-function resolvePanelElements(doc: CircuitDocument): readonly ResolvedPanelElement[] {
+function panelKindsCompatible(declared, resolved) {
+    if (declared === resolved) {
+        return true;
+    }
+    return resolved === 'switch' && (declared === 'selector' || declared === 'footswitch');
+}
+function resolvePanelElements(doc) {
     const panel = extractPanel(doc);
-    const resolved: ResolvedPanelElement[] = [];
-
+    const resolved = [];
     for (const knob of panel.knobs) {
         resolved.push({
             id: knob.id,
@@ -921,34 +728,21 @@ function resolvePanelElements(doc: CircuitDocument): readonly ResolvedPanelEleme
             kind: 'jack',
         });
     }
-
     return resolved;
 }
-
-function resolvePanelElement(
-    resolvedElements: readonly ResolvedPanelElement[],
-    element: PanelElementPlacement,
-): ResolvedPanelElement | undefined {
+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: string): string {
+function componentIdFromPanelElementId(id) {
     const separator = id.indexOf(':');
     return separator <= 0 ? id : id.slice(0, separator);
 }
-
-function validatePanelCellCollisions(face: PanelFace): readonly ValidationIssue[] {
-    const issues: ValidationIssue[] = [];
-    const occupied = new Map<string, PanelElementPlacement>();
-
+function validatePanelCellCollisions(face) {
+    const issues = [];
+    const occupied = new Map();
     for (const element of face.elements) {
         const rowSpan = element.grid.rowSpan ?? 1;
         const columnSpan = element.grid.columnSpan ?? 1;
@@ -970,11 +764,313 @@ function validatePanelCellCollisions(face: PanelFace): readonly ValidationIssue[
             }
         }
     }
-
     return issues;
 }
-
-function missingPropertyIssue(component: Component, rule: PropertyRule): ValidationIssue {
+function validateV3BuildMetadata(doc, componentIds) {
+    if (!hasV3BuildMetadata(doc)) {
+        return [];
+    }
+    const issues = [];
+    const boards = doc.boards ?? [];
+    const boardsById = new Map(boards.map((board) => [board.id, board]));
+    const componentsById = new Map(doc.components.map((component) => [component.id, component]));
+    const panelElementIds = collectPanelElementIds(doc);
+    const controlIds = new Set(doc.deviceInterface?.controls.map((control) => control.id) ?? []);
+    const boardNetsByBoardId = new Map(boards.map((board) => [
+        board.id,
+        new Set(board.netlist?.nets.map((net) => net.id) ?? []),
+    ]));
+    const boardTerminalsByBoardId = new Map(boards.map((board) => [
+        board.id,
+        new Set(board.edgeTerminals.map((terminal) => terminal.id)),
+    ]));
+    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'));
+    }
+    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'));
+        }
+    }
+    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'));
+    }
+    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'));
+        }
+    }
+    for (const item of doc.bom?.items ?? []) {
+        for (const ref of item.refs) {
+            const issue = validateBomRef(ref, componentIds, controlIds, panelElementIds, boardsById, item.id);
+            if (issue !== undefined) {
+                issues.push(issue);
+            }
+        }
+    }
+    for (const board of boards) {
+        issues.push(...validateBoardRealization(board, componentsById, boardNetsByBoardId));
+    }
+    if (doc.offBoardWiring !== undefined) {
+        issues.push(...validateOffBoardWiring(doc, componentsById, panelElementIds, boardTerminalsByBoardId, boardNetsByBoardId));
+    }
+    if (doc.build?.completeness === 'complete-selected-build' && selectedBoardId !== undefined) {
+        const selectedBoard = boardsById.get(selectedBoardId);
+        if (selectedBoard !== undefined) {
+            issues.push(...validateCompleteSelectedBoardRoutes(selectedBoard));
+        }
+    }
+    return issues;
+}
+function hasV3BuildMetadata(doc) {
+    return doc.mechanical !== undefined ||
+        doc.build !== undefined ||
+        doc.bom !== undefined ||
+        doc.partProfiles !== undefined ||
+        doc.footprints !== undefined ||
+        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;
+}
+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 === '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');
+    }
+    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');
+    }
+    return undefined;
+}
+function validateBoardRealization(board, componentsById, boardNetsByBoardId) {
+    const issues = [];
+    if (board.sourceCircuit !== undefined && !isDigestShapedSourceHash(board.sourceCircuit.hash)) {
+        issues.push({
+            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',
+        });
+    }
+    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));
+        }
+    }
+    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));
+            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));
+            }
+        }
+    }
+    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));
+            }
+        }
+    }
+    for (const route of board.routes) {
+        if (route.zones !== undefined || route.drills !== undefined) {
+            issues.push({
+                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));
+        }
+    }
+    return issues;
+}
+function validateOffBoardWiring(doc, componentsById, panelElementIds, boardTerminalsByBoardId, boardNetsByBoardId) {
+    const issues = [];
+    const endpointIds = new Set();
+    for (const harness of doc.offBoardWiring?.harnesses ?? []) {
+        const localEndpointIds = new Set();
+        for (const endpoint of harness.endpoints) {
+            endpointIds.add(endpoint.id);
+            localEndpointIds.add(endpoint.id);
+            const issue = validateOffBoardEndpoint(endpoint, componentsById, panelElementIds, boardTerminalsByBoardId);
+            if (issue !== undefined) {
+                issues.push(issue);
+            }
+        }
+        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));
+            }
+            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));
+            }
+            if (connection.signalRef !== undefined) {
+                const issue = validateOffBoardSignalRef(connection.signalRef, componentsById, boardNetsByBoardId, harness.id);
+                if (issue !== undefined) {
+                    issues.push(issue);
+                }
+            }
+        }
+    }
+    for (const harnessId of doc.build?.selectedOffBoardWiringHarnessIds ?? []) {
+        const harness = doc.offBoardWiring?.harnesses.find((candidate) => candidate.id === harnessId);
+        if (harness === undefined) {
+            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));
+            }
+        }
+    }
+    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');
+        }
+        return undefined;
+    }
+    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');
+        }
+        if (endpoint.panelElementId !== undefined &&
+            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 undefined;
+}
+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 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 undefined;
+}
+function validateCompleteSelectedBoardRoutes(board) {
+    const issues = [];
+    const routedNetIds = new Set(board.routes
+        .filter((route) => isRouteForBoardNet(route, board.id))
+        .map((route) => dataString(route.netRef, 'netId'))
+        .filter((netId) => netId !== undefined));
+    for (const net of board.netlist?.nets ?? []) {
+        if (isSingleTerminalEdgeNet(net)) {
+            continue;
+        }
+        if (!routedNetIds.has(net.id)) {
+            issues.push({
+                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,
+            });
+        }
+    }
+    return issues;
+}
+function isSingleTerminalEdgeNet(net) {
+    return net.members.length <= 1;
+}
+function isRouteForBoardNet(route, boardId) {
+    if (!isBoardNetlistRef(route.netRef)) {
+        return false;
+    }
+    return route.netRef.boardId === undefined || route.netRef.boardId === boardId;
+}
+function isBoardNetlistRef(value) {
+    return dataString(value, 'source') === 'board-netlist' && dataString(value, 'netId') !== undefined;
+}
+function boardNetRefExists(ref, fallbackBoardId, boardNetsByBoardId) {
+    const boardId = ref.boardId ?? fallbackBoardId;
+    if (boardId === undefined) {
+        return Array.from(boardNetsByBoardId.values()).some((netIds) => netIds.has(ref.netId));
+    }
+    return boardNetsByBoardId.get(boardId)?.has(ref.netId) === true;
+}
+function collectPanelElementIds(doc) {
+    const ids = new Set();
+    for (const face of doc.panel?.faces ?? []) {
+        for (const element of face.elements) {
+            if (element.id !== undefined) {
+                ids.add(element.id);
+            }
+            ids.add(element.bind.componentId);
+            if (element.bind.controlId !== undefined) {
+                ids.add(element.bind.controlId);
+            }
+        }
+    }
+    return ids;
+}
+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;
+}
+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;
+}
+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);
+}
+function unresolvedIssue(code, severity, message, componentId, property) {
+    return {
+        code,
+        severity,
+        message,
+        componentId,
+        property,
+    };
+}
+function missingPropertyIssue(component, rule) {
     return {
         code: rule.kind === 'string' ? 'model-required' : 'value-required',
         severity: 'error',
@@ -983,3 +1079,4 @@ function missingPropertyIssue(component: Component, rule: PropertyRule): Validat
         property: rule.name,
     };
 }
+//# sourceMappingURL=validation.js.map