Method aggregateElements

src/tools/position-tool/index.ts:62–157

* Deterministic in-process aggregation. * NOTE: Map-based inputs are not JSON-friendly for future agent calls; we can add a JSON form later.

(
        positions: Record<string, ElementAbsolutePosition>,
        elementToComponentMap: Map<string, { id: string; name: string; path: string }>,
        positionThreshold: number
    )

     * NOTE: Map-based inputs are not JSON-friendly for future agent calls; we can add a JSON form later.
     */
    aggregateElements(
        positions: Record<string, ElementAbsolutePosition>,
        elementToComponentMap: Map<string, { id: string; name: string; path: string }>,
        positionThreshold: number
    ): AggregateElementsResult {
        const componentMap = new Map<string, ComponentData>();
        const skippedElements: SkippedElement[] = [];

        for (const [elementId, position] of Object.entries(positions)) {
            if (!position.figmaPosition) {
                skippedElements.push({
                    elementId,
                    reason: 'no_figma_position',
                    details: 'Element exists in render but has no corresponding Figma position data',
                });
                continue;
            }

            const component = elementToComponentMap.get(elementId);
            if (!component) {
                skippedElements.push({
                    elementId,
                    reason: 'missing_component_mapping',
                    details: 'Element has no component mapping in structure tree',
                });
                continue;
            }

            if (!componentMap.has(component.id)) {
                componentMap.set(component.id, {
                    componentId: component.id,
                    componentName: component.name,
                    componentPath: component.path,
                    elementIds: [],
                    positions: [],
                    targets: [],
                    errors: [],
                });
            }

            const compData = componentMap.get(component.id)!;
            compData.elementIds.push(elementId);
            compData.positions.push(toRect(position.boundingBox));
            compData.targets.push(toRect(position.figmaPosition));
            compData.errors.push({
                x: Math.abs(position.metrics?.xDelta ?? 0),
                y: Math.abs(position.metrics?.yDelta ?? 0),
            });
        }

        this.logSkippedElementsSummary(skippedElements);

        const misalignedComponents: ComponentMisalignment[] = [];

        for (const compData of componentMap.values()) {
            if (compData.positions.length === 0 || compData.targets.length === 0) {
                for (const elemId of compData.elementIds) {
                    skippedElements.push({