@willwade/aac-processors 0.0.21 → 0.0.23

package/dist/utilities/analytics/metrics/core.js

@@ -221,44 +221,26 @@ class MetricsCalculator {
      * Count scan items for visual scanning effort
      * When block scanning is enabled, count unique scan blocks instead of individual buttons
      */
-    countScanItems(board, currentRowIndex, currentColIndex, priorScanBlocks, blockScanEnabled) {
-        if (!blockScanEnabled) {
-            // Linear scanning: count all buttons before current position
-            let count = 0;
-            for (let r = 0; r <= currentRowIndex; r++) {
-                const row = board.grid[r];
-                if (!row)
-                    continue;
-                for (let c = 0; c < row.length; c++) {
-                    if (r === currentRowIndex && c === currentColIndex)
-                        return count;
-                    const btn = row[c];
-                    if (btn && (btn.label || btn.id).length > 0) {
-                        count++;
-                    }
-                }
-            }
-            return count;
-        }
+    countScanBlocks(board, currentRowIndex, currentColIndex, priorScanBlocks) {
         // Block scanning: count unique scan blocks before current position
-        const seenBlocks = new Set();
+        // Reuse the priorScanBlocks set from the parent scope
         for (let r = 0; r <= currentRowIndex; r++) {
             const row = board.grid[r];
             if (!row)
                 continue;
             for (let c = 0; c < row.length; c++) {
                 if (r === currentRowIndex && c === currentColIndex)
-                    return seenBlocks.size;
+                    return priorScanBlocks.size;
                 const btn = row[c];
                 if (btn && (btn.label || btn.id).length > 0) {
                     const block = btn.scanBlock ||
                         (btn.scanBlocks && btn.scanBlocks.length > 0 ? btn.scanBlocks[0] : null);
                     if (block !== null)
-                        seenBlocks.add(block);
+                        priorScanBlocks.add(block);
                 }
             }
         }
-        return seenBlocks.size;
+        return priorScanBlocks.size;
     }
     /**
      * Analyze starting from a specific board
@@ -317,216 +299,213 @@ class MetricsCalculator {
             const scanningConfig = options.scanningConfig || board.scanningConfig;
             const blockScanEnabled = scanningConfig?.blockScanEnabled || false;
             // Process each button
-            const priorScanBlocks = new Set();
             const btnHeight = 1.0 / rows;
             const btnWidth = 1.0 / cols;
-            // Iterate over all buttons on the page to handle overlapping cells (common in some gridsets like Super Core 50)
-            // Sort buttons by position to ensure consistent prior_buttons/scanning calculation
-            const sortedButtons = [...board.buttons]
-                .filter((b) => (b.label || '').length > 0)
-                .sort((a, b) => {
-                if ((a.y ?? 0) !== (b.y ?? 0))
-                    return (a.y ?? 0) - (b.y ?? 0);
-                return (a.x ?? 0) - (b.x ?? 0);
-            });
-            sortedButtons.forEach((btn) => {
-                const rowIndex = btn.y ?? 0;
-                const colIndex = btn.x ?? 0;
-                const x = btnWidth / 2 + btnWidth * colIndex;
-                const y = btnHeight / 2 + btnHeight * rowIndex;
-                // Calculate prior items for visual scan effort
-                // If block scanning enabled, count unique scan blocks instead of individual buttons
-                const priorItems = this.countScanItems(board, rowIndex, colIndex, priorScanBlocks, blockScanEnabled);
-                // Calculate button-level effort
-                let buttonEffort = boardEffort;
-                // Debug for specific button (disabled for production)
-                const debugSpecificButton = btn.label === '$938c2cc0dc';
-                if (debugSpecificButton) {
-                    console.log(`\n🔍 DEBUG Button ${btn.label} at [${rowIndex},${colIndex}] on ${board.id}:`);
-                    console.log(`   Entry point: (${entryX.toFixed(4)}, ${entryY.toFixed(4)})`);
-                    console.log(`   Current level: ${level}`);
-                    console.log(`   Starting effort: ${buttonEffort.toFixed(6)}`);
-                }
-                // Apply semantic_id discounts
-                if (btn.semantic_id && boardPcts[btn.semantic_id]) {
-                    const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.semantic_id];
-                    const old = buttonEffort;
-                    buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
-                    if (debugSpecificButton)
-                        console.log(`   Semantic board discount: ${old.toFixed(6)} -> ${buttonEffort.toFixed(6)} (pct=${boardPcts[btn.semantic_id].toFixed(4)})`);
-                }
-                else if (btn.semantic_id && boardPcts[`upstream-${btn.semantic_id}`]) {
-                    const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_PRIOR_DISCOUNT /
-                        boardPcts[`upstream-${btn.semantic_id}`];
-                    const old = buttonEffort;
-                    buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
-                    if (debugSpecificButton)
-                        console.log(`   Semantic upstream discount: ${old.toFixed(6)} -> ${buttonEffort.toFixed(6)} (pct=${boardPcts[`upstream-${btn.semantic_id}`].toFixed(4)})`);
-                }
-                // Apply clone_id discounts
-                if (btn.clone_id && boardPcts[btn.clone_id]) {
-                    const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.clone_id];
-                    buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
-                }
-                else if (btn.clone_id && boardPcts[`upstream-${btn.clone_id}`]) {
-                    const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_PRIOR_DISCOUNT /
-                        boardPcts[`upstream-${btn.clone_id}`];
-                    buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
-                }
-                // Calculate button effort based on access method (Touch vs Scanning)
-                const isScanning = !!scanningConfig || !!board.scanType;
-                if (isScanning) {
-                    const { steps, selections, loopSteps } = this.calculateScanSteps(board, btn, rowIndex, colIndex, scanningConfig);
-                    // Determine effective costs based on selection method
-                    let currentStepCost = options.scanStepCost ?? effort_1.EFFORT_CONSTANTS.SCAN_STEP_COST;
-                    const currentSelectionCost = options.scanSelectionCost ?? effort_1.EFFORT_CONSTANTS.SCAN_SELECTION_COST;
-                    // Step Scan 2 Switch: Every step is a physical selection with Switch 1
-                    if (scanningConfig?.selectionMethod === aac_1.ScanningSelectionMethod.StepScan2Switch) {
-                        // The cost of moving is now a selection cost
-                        currentStepCost = currentSelectionCost;
-                    }
-                    else if (scanningConfig?.selectionMethod === aac_1.ScanningSelectionMethod.StepScan1Switch) {
-                        // Single switch step scan: every step is a physical selection
-                        currentStepCost = currentSelectionCost;
-                    }
-                    let sEffort = (0, effort_1.scanningEffort)(steps, selections, currentStepCost, currentSelectionCost);
-                    // Factor in error correction if enabled
-                    if (scanningConfig?.errorCorrectionEnabled) {
-                        const errorRate = scanningConfig.errorRate ?? effort_1.EFFORT_CONSTANTS.DEFAULT_SCAN_ERROR_RATE;
-                        // A "miss" results in needing to wait for a loop (or part of one)
-                        // We model this as errorRate * (loopSteps * stepCost)
-                        const retryPenalty = loopSteps * currentStepCost;
-                        sEffort += errorRate * retryPenalty;
+            // Track scan blocks for block scanning
+            const priorScanBlocks = new Set();
+            // Iterate over grid positions directly (not just buttons)
+            // This matches Ruby's nested loop: rows.times do |row_idx|; columns.times do |col_idx|
+            for (let rowIndex = 0; rowIndex < rows; rowIndex++) {
+                for (let colIndex = 0; colIndex < cols; colIndex++) {
+                    const btn = board.grid[rowIndex]?.[colIndex];
+                    if (!btn)
+                        continue; // Skip empty cells
+                    const x = btnWidth / 2 + btnWidth * colIndex;
+                    const y = btnHeight / 2 + btnHeight * rowIndex;
+                    // Calculate prior grid positions (not just buttons)
+                    // This matches Ruby's prior_buttons which increments for each grid position
+                    const priorGridPositions = rowIndex * cols + colIndex;
+                    // For block scanning, count unique scan blocks instead
+                    const priorItems = blockScanEnabled
+                        ? this.countScanBlocks(board, rowIndex, colIndex, priorScanBlocks)
+                        : priorGridPositions;
+                    // Calculate button-level effort
+                    let buttonEffort = boardEffort;
+                    // Debug for specific button (disabled for production)
+                    const debugSpecificButton = btn.label === '$938c2cc0dc';
+                    if (debugSpecificButton) {
+                        console.log(`\n🔍 DEBUG Button ${btn.label} at [${rowIndex},${colIndex}] on ${board.id}:`);
+                        console.log(`   Entry point: (${entryX.toFixed(4)}, ${entryY.toFixed(4)})`);
+                        console.log(`   Current level: ${level}`);
+                        console.log(`   Prior positions: ${priorItems}`);
+                        console.log(`   Starting effort: ${buttonEffort.toFixed(6)}`);
                     }
-                    // Apply discounts to scanning effort (similar to touch)
+                    // Apply semantic_id discounts
                     if (btn.semantic_id && boardPcts[btn.semantic_id]) {
                         const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.semantic_id];
-                        sEffort = Math.min(sEffort, sEffort * discount);
+                        const old = buttonEffort;
+                        buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
+                        if (debugSpecificButton)
+                            console.log(`   Semantic board discount: ${old.toFixed(6)} -> ${buttonEffort.toFixed(6)} (pct=${boardPcts[btn.semantic_id].toFixed(4)})`);
                     }
-                    else if (btn.clone_id && boardPcts[btn.clone_id]) {
+                    else if (btn.semantic_id && boardPcts[`upstream-${btn.semantic_id}`]) {
+                        const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_PRIOR_DISCOUNT /
+                            boardPcts[`upstream-${btn.semantic_id}`];
+                        const old = buttonEffort;
+                        buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
+                        if (debugSpecificButton)
+                            console.log(`   Semantic upstream discount: ${old.toFixed(6)} -> ${buttonEffort.toFixed(6)} (pct=${boardPcts[`upstream-${btn.semantic_id}`].toFixed(4)})`);
+                    }
+                    // Apply clone_id discounts
+                    if (btn.clone_id && boardPcts[btn.clone_id]) {
                         const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.clone_id];
-                        sEffort = Math.min(sEffort, sEffort * discount);
+                        buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
                     }
-                    buttonEffort += sEffort;
-                }
-                else {
-                    // Add distance effort (Touch only)
-                    let distance = (0, effort_1.distanceEffort)(x, y, entryX, entryY);
-                    // Apply distance discounts
-                    if (btn.semantic_id) {
-                        if (boardPcts[btn.semantic_id]) {
-                            const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.semantic_id];
-                            distance = Math.min(distance, distance * discount);
-                        }
-                        else if (boardPcts[`upstream-${btn.semantic_id}`]) {
-                            const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_PRIOR_DISCOUNT /
-                                boardPcts[`upstream-${btn.semantic_id}`];
-                            distance = Math.min(distance, distance * discount);
+                    else if (btn.clone_id && boardPcts[`upstream-${btn.clone_id}`]) {
+                        const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_PRIOR_DISCOUNT /
+                            boardPcts[`upstream-${btn.clone_id}`];
+                        buttonEffort = Math.min(buttonEffort, buttonEffort * discount);
+                    }
+                    // Calculate button effort based on access method (Touch vs Scanning)
+                    const isScanning = !!scanningConfig || !!board.scanType;
+                    if (isScanning) {
+                        const { steps, selections, loopSteps } = this.calculateScanSteps(board, btn, rowIndex, colIndex, scanningConfig);
+                        // Determine effective costs based on selection method
+                        let currentStepCost = options.scanStepCost ?? effort_1.EFFORT_CONSTANTS.SCAN_STEP_COST;
+                        const currentSelectionCost = options.scanSelectionCost ?? effort_1.EFFORT_CONSTANTS.SCAN_SELECTION_COST;
+                        // Step Scan 2 Switch: Every step is a physical selection with Switch 1
+                        if (scanningConfig?.selectionMethod === aac_1.ScanningSelectionMethod.StepScan2Switch) {
+                            // The cost of moving is now a selection cost
+                            currentStepCost = currentSelectionCost;
                         }
-                        else if (level > 0 && setPcts[btn.semantic_id]) {
-                            const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_OTHER_DISCOUNT /
-                                setPcts[btn.semantic_id];
-                            distance = Math.min(distance, distance * discount);
+                        else if (scanningConfig?.selectionMethod === aac_1.ScanningSelectionMethod.StepScan1Switch) {
+                            // Single switch step scan: every step is a physical selection
+                            currentStepCost = currentSelectionCost;
                         }
-                    }
-                    if (btn.clone_id) {
-                        if (boardPcts[btn.clone_id]) {
-                            const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.clone_id];
-                            distance = Math.min(distance, distance * discount);
+                        let sEffort = (0, effort_1.scanningEffort)(steps, selections, currentStepCost, currentSelectionCost);
+                        // Factor in error correction if enabled
+                        if (scanningConfig?.errorCorrectionEnabled) {
+                            const errorRate = scanningConfig.errorRate ?? effort_1.EFFORT_CONSTANTS.DEFAULT_SCAN_ERROR_RATE;
+                            // A "miss" results in needing to wait for a loop (or part of one)
+                            // We model this as errorRate * (loopSteps * stepCost)
+                            const retryPenalty = loopSteps * currentStepCost;
+                            sEffort += errorRate * retryPenalty;
                         }
-                        else if (boardPcts[`upstream-${btn.clone_id}`]) {
-                            const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_PRIOR_DISCOUNT /
-                                boardPcts[`upstream-${btn.clone_id}`];
-                            distance = Math.min(distance, distance * discount);
+                        // Apply discounts to scanning effort (similar to touch)
+                        if (btn.semantic_id && boardPcts[btn.semantic_id]) {
+                            const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.semantic_id];
+                            sEffort = Math.min(sEffort, sEffort * discount);
                         }
-                        else if (level > 0 && setPcts[btn.clone_id]) {
-                            const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_OTHER_DISCOUNT / setPcts[btn.clone_id];
-                            distance = Math.min(distance, distance * discount);
+                        else if (btn.clone_id && boardPcts[btn.clone_id]) {
+                            const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.clone_id];
+                            sEffort = Math.min(sEffort, sEffort * discount);
                         }
-                    }
-                    buttonEffort += distance;
-                    // Add visual scan or local scan effort
-                    if (distance > effort_1.EFFORT_CONSTANTS.DISTANCE_THRESHOLD_TO_SKIP_VISUAL_SCAN ||
-                        (entryX === 1.0 && entryY === 1.0)) {
-                        buttonEffort += (0, effort_1.visualScanEffort)(priorItems);
+                        buttonEffort += sEffort;
                     }
                     else {
-                        buttonEffort += (0, effort_1.localScanEffort)(distance);
-                    }
-                }
-                // Add cumulative prior effort
-                buttonEffort += priorEffort;
-                // Track scan blocks for block scanning, otherwise track individual buttons
-                if (blockScanEnabled) {
-                    const scanBlockId = btn.scanBlock ?? btn.scanBlocks?.[0];
-                    if (scanBlockId !== undefined && scanBlockId !== null) {
-                        priorScanBlocks.add(scanBlockId);
-                    }
-                }
-                // Handle navigation buttons
-                if (btn.targetPageId) {
-                    const nextBoard = tree.getPage(btn.targetPageId);
-                    if (nextBoard) {
-                        // Only add to toVisit if this board hasn't been visited yet at any level
-                        // The visitedBoardIds map stores the *lowest* level a board was visited.
-                        // If it's already in the map, it means we've processed it or scheduled it at a lower level.
-                        if (visitedBoardIds.get(nextBoard.id) === undefined) {
-                            const changeEffort = effort_1.EFFORT_CONSTANTS.BOARD_CHANGE_PROCESSING_EFFORT;
-                            const tempHomeId = btn.semanticAction?.platformData?.grid3?.parameters?.temporary_home === 'prior'
-                                ? board.id
-                                : btn.semanticAction?.platformData?.grid3?.parameters?.temporary_home === true
-                                    ? btn.targetPageId
-                                    : temporaryHomeId;
-                            toVisit.push({
-                                board: nextBoard,
-                                level: level + 1,
-                                priorEffort: buttonEffort + changeEffort,
-                                temporaryHomeId: tempHomeId,
-                                entryX: x,
-                                entryY: y,
-                                entryCloneId: btn.clone_id,
-                                entrySemanticId: btn.semantic_id,
-                            });
+                        // Add distance effort (Touch only)
+                        let distance = (0, effort_1.distanceEffort)(x, y, entryX, entryY);
+                        // Apply distance discounts
+                        if (btn.semantic_id) {
+                            if (boardPcts[btn.semantic_id]) {
+                                const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.semantic_id];
+                                distance = Math.min(distance, distance * discount);
+                            }
+                            else if (boardPcts[`upstream-${btn.semantic_id}`]) {
+                                const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_PRIOR_DISCOUNT /
+                                    boardPcts[`upstream-${btn.semantic_id}`];
+                                distance = Math.min(distance, distance * discount);
+                            }
+                            else if (level > 0 && setPcts[btn.semantic_id]) {
+                                const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_SEMANTIC_FROM_OTHER_DISCOUNT /
+                                    setPcts[btn.semantic_id];
+                                distance = Math.min(distance, distance * discount);
+                            }
+                        }
+                        if (btn.clone_id) {
+                            if (boardPcts[btn.clone_id]) {
+                                const discount = effort_1.EFFORT_CONSTANTS.SAME_LOCATION_AS_PRIOR_DISCOUNT / boardPcts[btn.clone_id];
+                                distance = Math.min(distance, distance * discount);
+                            }
+                            else if (boardPcts[`upstream-${btn.clone_id}`]) {
+                                const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_PRIOR_DISCOUNT /
+                                    boardPcts[`upstream-${btn.clone_id}`];
+                                distance = Math.min(distance, distance * discount);
+                            }
+                            else if (level > 0 && setPcts[btn.clone_id]) {
+                                const discount = effort_1.EFFORT_CONSTANTS.RECOGNIZABLE_CLONE_FROM_OTHER_DISCOUNT / setPcts[btn.clone_id];
+                                distance = Math.min(distance, distance * discount);
+                            }
+                        }
+                        buttonEffort += distance;
+                        // Add visual scan or local scan effort
+                        if (distance > effort_1.EFFORT_CONSTANTS.DISTANCE_THRESHOLD_TO_SKIP_VISUAL_SCAN ||
+                            (entryX === 1.0 && entryY === 1.0)) {
+                            buttonEffort += (0, effort_1.visualScanEffort)(priorItems);
+                        }
+                        else {
+                            buttonEffort += (0, effort_1.localScanEffort)(distance);
                         }
                     }
-                }
-                // Track word if it speaks or adds to sentence
-                const intent = String(btn.semanticAction?.intent || '');
-                const isSpeak = btn.semanticAction?.category === treeStructure_1.AACSemanticCategory.COMMUNICATION ||
-                    intent === 'SPEAK_TEXT' ||
-                    intent === 'SPEAK_IMMEDIATE' ||
-                    intent === 'INSERT_TEXT' ||
-                    btn.semanticAction?.fallback?.type === 'SPEAK';
-                const addToSentence = btn.semanticAction?.platformData?.grid3?.parameters?.add_to_sentence ||
-                    btn.semanticAction?.fallback?.add_to_sentence;
-                if (isSpeak || addToSentence) {
-                    let finalEffort = buttonEffort;
-                    // Apply Board Change Processing Effort Discount (matching Ruby lines 347-350)
-                    const changeEffort = effort_1.EFFORT_CONSTANTS.BOARD_CHANGE_PROCESSING_EFFORT;
-                    if (btn.clone_id && boardPcts[btn.clone_id]) {
-                        const discount = Math.min(changeEffort, (changeEffort * 0.3) / boardPcts[btn.clone_id]);
-                        finalEffort -= discount;
+                    // Add cumulative prior effort
+                    buttonEffort += priorEffort;
+                    // Track scan blocks for block scanning, otherwise track individual buttons
+                    if (blockScanEnabled) {
+                        const scanBlockId = btn.scanBlock ?? btn.scanBlocks?.[0];
+                        if (scanBlockId !== undefined && scanBlockId !== null) {
+                            priorScanBlocks.add(scanBlockId);
+                        }
                     }
-                    else if (btn.semantic_id && boardPcts[btn.semantic_id]) {
-                        const discount = Math.min(changeEffort, (changeEffort * 0.5) / boardPcts[btn.semantic_id]);
-                        finalEffort -= discount;
+                    // Handle navigation buttons
+                    if (btn.targetPageId) {
+                        const nextBoard = tree.getPage(btn.targetPageId);
+                        if (nextBoard) {
+                            // Only add to toVisit if this board hasn't been visited yet at any level
+                            // The visitedBoardIds map stores the *lowest* level a board was visited.
+                            // If it's already in the map, it means we've processed it or scheduled it at a lower level.
+                            if (visitedBoardIds.get(nextBoard.id) === undefined) {
+                                const changeEffort = effort_1.EFFORT_CONSTANTS.BOARD_CHANGE_PROCESSING_EFFORT;
+                                const tempHomeId = btn.semanticAction?.platformData?.grid3?.parameters?.temporary_home === 'prior'
+                                    ? board.id
+                                    : btn.semanticAction?.platformData?.grid3?.parameters?.temporary_home === true
+                                        ? btn.targetPageId
+                                        : temporaryHomeId;
+                                toVisit.push({
+                                    board: nextBoard,
+                                    level: level + 1,
+                                    priorEffort: buttonEffort + changeEffort,
+                                    temporaryHomeId: tempHomeId,
+                                    entryX: x,
+                                    entryY: y,
+                                    entryCloneId: btn.clone_id,
+                                    entrySemanticId: btn.semantic_id,
+                                });
+                            }
+                        }
                     }
-                    const existing = knownButtons.get(btn.label);
-                    const knownBtn = {
-                        id: btn.id,
-                        label: btn.label,
-                        level,
-                        effort: finalEffort,
-                        count: (existing?.count || 0) + 1,
-                        semantic_id: btn.semantic_id,
-                        clone_id: btn.clone_id,
-                        temporary_home_id: temporaryHomeId || undefined,
-                    };
-                    if (!existing || finalEffort < existing.effort) {
-                        knownButtons.set(btn.label, knownBtn);
+                    // Track word if it speaks or adds to sentence
+                    const isSpeak = btn.semanticAction?.category === treeStructure_1.AACSemanticCategory.COMMUNICATION && !btn.targetPageId; // Must not be a navigation button
+                    const addToSentence = btn.semanticAction?.platformData?.grid3?.parameters?.add_to_sentence ||
+                        btn.semanticAction?.fallback?.add_to_sentence;
+                    if (isSpeak || addToSentence) {
+                        let finalEffort = buttonEffort;
+                        // Apply Board Change Processing Effort Discount (matching Ruby lines 347-350)
+                        const changeEffort = effort_1.EFFORT_CONSTANTS.BOARD_CHANGE_PROCESSING_EFFORT;
+                        if (btn.clone_id && boardPcts[btn.clone_id]) {
+                            const discount = Math.min(changeEffort, (changeEffort * 0.3) / boardPcts[btn.clone_id]);
+                            finalEffort -= discount;
+                        }
+                        else if (btn.semantic_id && boardPcts[btn.semantic_id]) {
+                            const discount = Math.min(changeEffort, (changeEffort * 0.5) / boardPcts[btn.semantic_id]);
+                            finalEffort -= discount;
+                        }
+                        const existing = knownButtons.get(btn.label);
+                        const knownBtn = {
+                            id: btn.id,
+                            label: btn.label,
+                            level,
+                            effort: finalEffort,
+                            count: (existing?.count || 0) + 1,
+                            semantic_id: btn.semantic_id,
+                            clone_id: btn.clone_id,
+                            temporary_home_id: temporaryHomeId || undefined,
+                        };
+                        if (!existing || finalEffort < existing.effort) {
+                            knownButtons.set(btn.label, knownBtn);
+                        }
                     }
                 }
-            });
+            }
         }
         // Convert to array and group by level
         const buttons = Array.from(knownButtons.values());

package/dist/validation/applePanelsValidator.d.ts

@@ -0,0 +1,10 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Apple Panels (.plist or .ascconfig directory)
+ */
+export declare class ApplePanelsValidator extends BaseValidator {
+    static validateFile(filePath: string): Promise<ValidationResult>;
+    static identifyFormat(content: any, filename: string): Promise<boolean>;
+    validate(content: Buffer | Uint8Array, filename: string, filesize: number): Promise<ValidationResult>;
+}

package/dist/validation/applePanelsValidator.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplePanelsValidator = void 0;
+/* eslint-disable @typescript-eslint/require-await */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plist_1 = __importDefault(require("plist"));
+const baseValidator_1 = require("./baseValidator");
+/**
+ * Validator for Apple Panels (.plist or .ascconfig directory)
+ */
+class ApplePanelsValidator extends baseValidator_1.BaseValidator {
+    static async validateFile(filePath) {
+        const validator = new ApplePanelsValidator();
+        let content;
+        const filename = path.basename(filePath);
+        let size = 0;
+        const stats = fs.existsSync(filePath) ? fs.statSync(filePath) : null;
+        if (stats?.isDirectory() && filename.toLowerCase().endsWith('.ascconfig')) {
+            const panelPath = path.join(filePath, 'Contents', 'Resources', 'PanelDefinitions.plist');
+            if (!fs.existsSync(panelPath)) {
+                return validator.validate(Buffer.alloc(0), filename, 0);
+            }
+            content = fs.readFileSync(panelPath);
+            size = fs.statSync(panelPath).size;
+        }
+        else {
+            content = fs.readFileSync(filePath);
+            size = stats?.size || content.byteLength;
+        }
+        return validator.validate(content, filename, size);
+    }
+    static async identifyFormat(content, filename) {
+        const name = filename.toLowerCase();
+        if (name.endsWith('.plist') || name.endsWith('.ascconfig')) {
+            return true;
+        }
+        try {
+            const str = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content);
+            const parsed = plist_1.default.parse(str);
+            return Boolean(parsed.panels || parsed.Panels);
+        }
+        catch {
+            return false;
+        }
+    }
+    async validate(content, filename, filesize) {
+        this.reset();
+        await this.add_check('filename', 'file extension', async () => {
+            if (!filename.toLowerCase().match(/\.(plist|ascconfig)$/)) {
+                this.warn('filename should end with .plist or .ascconfig');
+            }
+        });
+        let parsed = null;
+        await this.add_check('plist_parse', 'valid plist/XML', async () => {
+            try {
+                const str = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content);
+                parsed = plist_1.default.parse(str);
+            }
+            catch (e) {
+                this.err(`Failed to parse plist: ${e.message}`, true);
+            }
+        });
+        if (!parsed) {
+            return this.buildResult(filename, filesize, 'applepanels');
+        }
+        let panels = [];
+        await this.add_check('panels', 'panels present', async () => {
+            if (Array.isArray(parsed?.panels)) {
+                panels = parsed?.panels;
+            }
+            else if (parsed?.Panels && typeof parsed.Panels === 'object') {
+                panels = Object.values(parsed.Panels);
+            }
+            else {
+                this.err('missing panels/PanelDefinitions content', true);
+            }
+        });
+        panels.slice(0, 5).forEach((panel, idx) => {
+            const prefix = `panel[${idx}]`;
+            this.add_check_sync(`${prefix}_id`, `${prefix} id`, () => {
+                if (!panel?.ID && !panel?.id) {
+                    this.err('panel missing ID');
+                }
+            });
+            this.add_check_sync(`${prefix}_buttons`, `${prefix} buttons`, () => {
+                const buttons = Array.isArray(panel?.PanelObjects)
+                    ? panel.PanelObjects.filter((obj) => obj?.PanelObjectType === 'Button')
+                    : [];
+                if (buttons.length === 0) {
+                    this.warn('panel has no buttons');
+                }
+            });
+        });
+        return this.buildResult(filename, filesize, 'applepanels');
+    }
+}
+exports.ApplePanelsValidator = ApplePanelsValidator;

package/dist/validation/astericsValidator.d.ts

@@ -0,0 +1,16 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Asterics Grid (.grd) JSON files
+ */
+export declare class AstericsGridValidator extends BaseValidator {
+    /**
+     * Validate from disk
+     */
+    static validateFile(filePath: string): Promise<ValidationResult>;
+    /**
+     * Identify whether the content appears to be an Asterics .grd file
+     */
+    static identifyFormat(content: any, filename: string): Promise<boolean>;
+    validate(content: Buffer | Uint8Array, filename: string, filesize: number): Promise<ValidationResult>;
+}