Function validateInputMappings

backend/src/dsl/validator.ts:256–324

* Validate input mappings between nodes

(
  graph: WorkflowGraphDto,
  compiledDefinition: WorkflowDefinition,
  actionPorts: Map<string, ActionPortSnapshot>,
  errors: ValidationError[],
  _warnings: ValidationError[],
)

 * Validate input mappings between nodes
 */
function validateInputMappings(
  graph: WorkflowGraphDto,
  compiledDefinition: WorkflowDefinition,
  actionPorts: Map<string, ActionPortSnapshot>,
  errors: ValidationError[],
  _warnings: ValidationError[],
) {
  const nodes = new Map(graph.nodes.map((n) => [n.id, n]));

  for (const action of compiledDefinition.actions) {
    const componentInputs = actionPorts.get(action.ref)?.inputs ?? [];

    // Check if all required inputs have mappings or static values
    for (const input of componentInputs) {
      const hasStaticValue = Object.hasOwn(action.inputOverrides ?? {}, input.id);
      const hasMapping = Object.hasOwn(action.inputMappings ?? {}, input.id);

      if (input.required && !hasStaticValue && !hasMapping) {
        errors.push({
          node: action.ref,
          field: 'inputMappings',
          message: `Required input '${input.label}' (${input.id}) has no mapping or static value`,
          severity: 'error',
          suggestion:
            'Either provide a static value in node configuration or connect an edge to this input',
        });
      }
    }

    // Validate edge mappings point to valid nodes
    for (const [_targetHandle, mapping] of Object.entries(action.inputMappings ?? {})) {
      const sourceNode = nodes.get(mapping.sourceRef);
      if (!sourceNode) {
        errors.push({
          node: action.ref,
          field: 'inputMappings',
          message: `Edge references unknown source node: ${mapping.sourceRef}`,
          severity: 'error',
          suggestion: 'Check that the source node exists and the edge is properly connected',
        });
      }
    }

    // Check raw edges for multiple inputs to the same port
    const edgesToThisNode = graph.edges.filter((e) => e.target === action.ref);
    const portsSeen = new Map<string, number>();
    for (const edge of edgesToThisNode) {
      const targetHandle = edge.targetHandle ?? edge.sourceHandle;
      if (!targetHandle) continue;

      portsSeen.set(targetHandle, (portsSeen.get(targetHandle) ?? 0) + 1);
    }

    for (const [portId, count] of portsSeen.entries()) {
      if (count > 1 && portId !== 'tools') {
        const inputMetadata = actionPorts.get(action.ref)?.inputs.find((i) => i.id === portId);
        const portLabel = inputMetadata?.label || portId;