@willwade/aac-processors 0.0.11 → 0.0.13

package/dist/processors/obfsetProcessor.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * OBF Set Processor - Handles JSON-formatted .obfset files
+ * These are pre-extracted board sets in JSON array format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObfsetProcessor = void 0;
+const treeStructure_1 = require("../core/treeStructure");
+const treeStructure_2 = require("../core/treeStructure");
+const fs_1 = __importDefault(require("fs"));
+const baseProcessor_1 = require("../core/baseProcessor");
+class ObfsetProcessor extends baseProcessor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+    }
+    /**
+     * Extract all text content
+     */
+    extractTexts(filePathOrBuffer) {
+        const tree = this.loadIntoTree(filePathOrBuffer);
+        const texts = new Set();
+        Object.values(tree.pages).forEach((page) => {
+            if (page.name)
+                texts.add(page.name);
+            page.buttons.forEach((button) => {
+                if (button.label)
+                    texts.add(button.label);
+            });
+        });
+        return Array.from(texts);
+    }
+    /**
+     * Load an .obfset file (JSON array of boards)
+     */
+    loadIntoTree(filePathOrBuffer) {
+        const tree = new treeStructure_1.AACTree();
+        let content;
+        if (Buffer.isBuffer(filePathOrBuffer)) {
+            content = filePathOrBuffer.toString('utf-8');
+        }
+        else {
+            content = fs_1.default.readFileSync(filePathOrBuffer, 'utf-8');
+        }
+        const boards = JSON.parse(content);
+        // Track board ID mappings
+        const boardMap = new Map();
+        // First pass: create all boards
+        boards.forEach((boardData) => {
+            const rows = boardData.grid?.rows || 4;
+            const cols = boardData.grid?.columns || 6;
+            const name = boardData.name || boardData.id || `Board ${boardData.id}`;
+            const page = new treeStructure_2.AACPage({
+                id: boardData.id,
+                name,
+                grid: { columns: cols, rows: rows },
+                buttons: [],
+            });
+            tree.addPage(page);
+            boardMap.set(boardData.id, page);
+        });
+        // Second pass: process buttons and establish parent relationships
+        boards.forEach((boardData) => {
+            const page = boardMap.get(boardData.id);
+            if (!page)
+                return;
+            const rows = boardData.grid?.rows || 4;
+            const cols = boardData.grid?.columns || 6;
+            // Initialize grid with nulls
+            page.grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => null));
+            // Create button map by ID
+            const buttonMap = new Map();
+            const buttons = boardData.buttons || [];
+            buttons.forEach((btnData) => {
+                buttonMap.set(btnData.id, btnData);
+            });
+            // Process grid order to place buttons in correct positions
+            const gridOrder = boardData.grid?.order || [];
+            const semanticIds = [];
+            const cloneIds = [];
+            gridOrder.forEach((row, rowIndex) => {
+                row.forEach((buttonId, colIndex) => {
+                    const btnData = buttonMap.get(buttonId);
+                    if (btnData) {
+                        // Create semantic action
+                        let semanticAction;
+                        if (btnData.load_board?.id) {
+                            // Navigation button
+                            semanticAction = {
+                                category: treeStructure_2.AACSemanticCategory.NAVIGATION,
+                                intent: treeStructure_2.AACSemanticIntent.NAVIGATE_TO,
+                                targetId: btnData.load_board.id,
+                                fallback: {
+                                    type: 'NAVIGATE',
+                                    targetPageId: btnData.load_board.id,
+                                    add_to_sentence: btnData.load_board.add_to_sentence,
+                                    temporary_home: btnData.load_board.temporary_home,
+                                },
+                                platformData: {
+                                    grid3: {
+                                        commandId: 'GO_TO_BOARD',
+                                        parameters: {
+                                            add_to_sentence: btnData.load_board.add_to_sentence,
+                                            temporary_home: btnData.load_board.temporary_home,
+                                        },
+                                    },
+                                },
+                            };
+                        }
+                        else {
+                            // Speaking button
+                            semanticAction = {
+                                category: treeStructure_2.AACSemanticCategory.COMMUNICATION,
+                                intent: treeStructure_2.AACSemanticIntent.SPEAK_TEXT,
+                                text: btnData.label || '',
+                                fallback: { type: 'SPEAK', message: btnData.label || '' },
+                            };
+                        }
+                        const button = new treeStructure_2.AACButton({
+                            id: btnData.id,
+                            label: btnData.label || '',
+                            message: btnData.label || '',
+                            targetPageId: btnData.load_board?.id,
+                            semanticAction,
+                            semantic_id: btnData.semantic_id,
+                            clone_id: btnData.clone_id,
+                        });
+                        // Add to grid at the correct position
+                        if (rowIndex < rows && colIndex < cols) {
+                            page.grid[rowIndex][colIndex] = button;
+                        }
+                        page.buttons.push(button);
+                        // Track IDs
+                        if (btnData.semantic_id) {
+                            semanticIds.push(String(btnData.semantic_id));
+                        }
+                        if (btnData.clone_id) {
+                            cloneIds.push(String(btnData.clone_id));
+                        }
+                        // Establish parent relationship if this button links to another board
+                        if (btnData.load_board?.id) {
+                            const targetPage = boardMap.get(String(btnData.load_board.id));
+                            if (targetPage) {
+                                targetPage.parentId = page.id;
+                            }
+                        }
+                    }
+                });
+            });
+            // Store IDs on page
+            page.semantic_ids = semanticIds;
+            page.clone_ids = cloneIds;
+        });
+        // Set root board (first board or one with no parent)
+        const rootBoard = Array.from(boardMap.values()).find((p) => !p.parentId);
+        if (rootBoard) {
+            tree.rootId = rootBoard.id;
+        }
+        return tree;
+    }
+    /**
+     * Process texts (not supported for .obfset currently)
+     */
+    processTexts(_filePathOrBuffer, _translations, _outputPath) {
+        throw new Error('processTexts is not supported for .obfset currently');
+    }
+    /**
+     * Save tree structure back to file
+     */
+    saveFromTree(_tree, _outputPath) {
+        throw new Error('saveFromTree is not supported for .obfset currently');
+    }
+    supportsExtension(extension) {
+        return extension === '.obfset';
+    }
+}
+exports.ObfsetProcessor = ObfsetProcessor;

package/dist/processors/snap/helpers.d.ts

@@ -1,4 +1,4 @@
-import { AACTree } from '../../core/treeStructure';
+import { AACTree, AACSemanticCategory, AACSemanticIntent } from '../../core/treeStructure';
 /**
  * Build a map of button IDs to resolved image entries for a specific page.
  * Mirrors the Grid helper for consumers that expect image reference data.
@@ -33,6 +33,10 @@ export interface SnapUsageEntry {
         timestamp: Date;
         modeling?: boolean;
         accessMethod?: number | null;
+        type?: 'button' | 'action' | 'utterance' | 'note' | 'other';
+        buttonId?: string | null;
+        intent?: AACSemanticIntent | string;
+        category?: AACSemanticCategory;
     }>;
     platform?: {
         label?: string;

package/dist/processors/snap/helpers.js

@@ -37,6 +37,7 @@ exports.findSnapUserHistory = findSnapUserHistory;
 exports.isSnapInstalled = isSnapInstalled;
 exports.readSnapUsage = readSnapUsage;
 exports.readSnapUsageForUser = readSnapUsageForUser;
+const treeStructure_1 = require("../../core/treeStructure");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
@@ -271,6 +272,10 @@ function readSnapUsage(pagesetPath) {
             timestamp: (0, dotnetTicks_1.dotNetTicksToDate)(BigInt(row.TickValue ?? 0)),
             modeling: row.Modeling === 1,
             accessMethod: row.AccessMethod ?? null,
+            type: 'button',
+            buttonId: row.ButtonId,
+            intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
         });
         events.set(buttonId, entry);
     }

package/dist/processors/snapProcessor.d.ts

@@ -4,8 +4,10 @@ import { ValidationResult } from '../validation/validationTypes';
 declare class SnapProcessor extends BaseProcessor {
     private symbolResolver;
     private loadAudio;
+    private pageLayoutPreference;
     constructor(symbolResolver?: unknown | null, options?: ProcessorOptions & {
         loadAudio?: boolean;
+        pageLayoutPreference?: 'largest' | 'smallest' | 'scanning' | number;
     });
     extractTexts(filePathOrBuffer: string | Buffer): string[];
     loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;

package/dist/processors/snapProcessor.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapProcessor = void 0;
 const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
-// Removed unused import: FileProcessor
+const idGenerator_1 = require("../optional/analytics/utils/idGenerator");
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -17,8 +17,11 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
         super(options);
         this.symbolResolver = null;
         this.loadAudio = false;
+        this.pageLayoutPreference = 'scanning'; // Default to scanning for metrics
         this.symbolResolver = symbolResolver;
         this.loadAudio = options.loadAudio !== undefined ? options.loadAudio : true;
+        this.pageLayoutPreference =
+            options.pageLayoutPreference !== undefined ? options.pageLayoutPreference : 'scanning'; // Default to scanning
     }
     extractTexts(filePathOrBuffer) {
         const tree = this.loadIntoTree(filePathOrBuffer);
@@ -79,11 +82,127 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                 });
                 tree.addPage(page);
             });
+            const scanGroupsByPageLayout = new Map();
+            try {
+                const scanGroupRows = db
+                    .prepare('SELECT Id, SerializedGridPositions, PageLayoutId FROM ScanGroup ORDER BY Id')
+                    .all();
+                if (scanGroupRows && scanGroupRows.length > 0) {
+                    // Group by PageLayoutId first
+                    const groupsByLayout = new Map();
+                    scanGroupRows.forEach((sg) => {
+                        if (!groupsByLayout.has(sg.PageLayoutId)) {
+                            groupsByLayout.set(sg.PageLayoutId, []);
+                        }
+                        const layoutGroups = groupsByLayout.get(sg.PageLayoutId);
+                        if (layoutGroups) {
+                            layoutGroups.push(sg);
+                        }
+                    });
+                    // For each PageLayout, assign scan block numbers based on order (1-based index)
+                    groupsByLayout.forEach((groups, layoutId) => {
+                        groups.forEach((sg, index) => {
+                            // Parse SerializedGridPositions JSON
+                            let positions = [];
+                            try {
+                                positions = JSON.parse(sg.SerializedGridPositions);
+                            }
+                            catch (e) {
+                                // Invalid JSON, skip this group
+                                return;
+                            }
+                            const scanGroup = {
+                                id: sg.Id,
+                                scanBlock: index + 1, // Scan block is 1-based index
+                                positions: positions,
+                            };
+                            if (!scanGroupsByPageLayout.has(layoutId)) {
+                                scanGroupsByPageLayout.set(layoutId, []);
+                            }
+                            const layoutGroups = scanGroupsByPageLayout.get(layoutId);
+                            if (layoutGroups) {
+                                layoutGroups.push(scanGroup);
+                            }
+                        });
+                    });
+                }
+            }
+            catch (e) {
+                // No ScanGroups table or error loading, continue without scan blocks
+                console.warn('[SnapProcessor] Failed to load ScanGroups:', e);
+            }
             // Load buttons per page, using UniqueId for page id
             for (const pageRow of pages) {
-                let buttons = [];
                 // Create a map to track page grid layouts
                 const pageGrids = new Map();
+                // Select PageLayout for this page based on preference
+                let selectedPageLayoutId = null;
+                try {
+                    const pageLayouts = db
+                        .prepare('SELECT Id, PageLayoutSetting FROM PageLayout WHERE PageId = ?')
+                        .all(pageRow.Id);
+                    if (pageLayouts && pageLayouts.length > 0) {
+                        // Parse PageLayoutSetting: "columns,rows,hasScanGroups,?"
+                        const layoutsWithInfo = pageLayouts.map((pl) => {
+                            const parts = pl.PageLayoutSetting.split(',');
+                            const cols = parseInt(parts[0], 10) || 0;
+                            const rows = parseInt(parts[1], 10) || 0;
+                            const hasScanning = parts[2] === 'True';
+                            const size = cols * rows;
+                            return { id: pl.Id, cols, rows, size, hasScanning };
+                        });
+                        // Select based on preference
+                        if (typeof this.pageLayoutPreference === 'number') {
+                            // Specific PageLayoutId
+                            selectedPageLayoutId = this.pageLayoutPreference;
+                        }
+                        else if (this.pageLayoutPreference === 'largest') {
+                            // Select layout with largest grid size, prefer layouts with ScanGroups
+                            layoutsWithInfo.sort((a, b) => {
+                                const sizeDiff = b.size - a.size;
+                                if (sizeDiff !== 0)
+                                    return sizeDiff;
+                                // Same size, prefer one with ScanGroups
+                                const aHasScanning = scanGroupsByPageLayout.has(a.id);
+                                const bHasScanning = scanGroupsByPageLayout.has(b.id);
+                                return (bHasScanning ? 1 : 0) - (aHasScanning ? 1 : 0);
+                            });
+                            selectedPageLayoutId = layoutsWithInfo[0].id;
+                        }
+                        else if (this.pageLayoutPreference === 'smallest') {
+                            // Select layout with smallest grid size, prefer layouts with ScanGroups
+                            layoutsWithInfo.sort((a, b) => {
+                                const sizeDiff = a.size - b.size;
+                                if (sizeDiff !== 0)
+                                    return sizeDiff;
+                                // Same size, prefer one with ScanGroups
+                                const aHasScanning = scanGroupsByPageLayout.has(a.id);
+                                const bHasScanning = scanGroupsByPageLayout.has(b.id);
+                                return (bHasScanning ? 1 : 0) - (aHasScanning ? 1 : 0);
+                            });
+                            selectedPageLayoutId = layoutsWithInfo[0].id;
+                        }
+                        else if (this.pageLayoutPreference === 'scanning') {
+                            // Select layout with scanning enabled (check against actual ScanGroups)
+                            const scanningLayouts = layoutsWithInfo.filter((l) => scanGroupsByPageLayout.has(l.id));
+                            if (scanningLayouts.length > 0) {
+                                scanningLayouts.sort((a, b) => b.size - a.size);
+                                selectedPageLayoutId = scanningLayouts[0].id;
+                            }
+                            else {
+                                // Fallback to largest
+                                layoutsWithInfo.sort((a, b) => b.size - a.size);
+                                selectedPageLayoutId = layoutsWithInfo[0].id;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    // Error selecting PageLayout, will load all buttons
+                    console.warn(`[SnapProcessor] Failed to select PageLayout for page ${pageRow.Id}:`, e);
+                }
+                // Load buttons
+                let buttons = [];
                 try {
                     const buttonColumns = getTableColumns('Button');
                     const selectFields = [
@@ -112,15 +231,19 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                             ? 'b.SerializedMessageSoundMetadata'
                             : 'NULL AS SerializedMessageSoundMetadata');
                     }
-                    selectFields.push('ep.GridPosition', 'er.PageId as ButtonPageId');
+                    const placementColumns = getTableColumns('ElementPlacement');
+                    selectFields.push(placementColumns.has('GridPosition') ? 'ep.GridPosition' : 'NULL AS GridPosition', placementColumns.has('PageLayoutId') ? 'ep.PageLayoutId' : 'NULL AS PageLayoutId', 'er.PageId as ButtonPageId');
                     const buttonQuery = `
             SELECT ${selectFields.join(', ')}
             FROM Button b
             INNER JOIN ElementReference er ON b.ElementReferenceId = er.Id
             LEFT JOIN ElementPlacement ep ON ep.ElementReferenceId = er.Id
-            WHERE er.PageId = ?
+            WHERE er.PageId = ? ${selectedPageLayoutId ? 'AND ep.PageLayoutId = ?' : ''}
           `;
-                    buttons = db.prepare(buttonQuery).all(pageRow.Id);
+                    const queryParams = selectedPageLayoutId
+                        ? [pageRow.Id, selectedPageLayoutId]
+                        : [pageRow.Id];
+                    buttons = db.prepare(buttonQuery).all(...queryParams);
                 }
                 catch (err) {
                     const errorMessage = err instanceof Error ? err.message : String(err);
@@ -226,6 +349,9 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                         targetPageId: targetPageUniqueId,
                         semanticAction: semanticAction,
                         audioRecording: audioRecording,
+                        semantic_id: btnRow.LibrarySymbolId
+                            ? `snap_symbol_${btnRow.LibrarySymbolId}`
+                            : undefined, // Extract semantic_id from LibrarySymbolId
                         style: {
                             backgroundColor: btnRow.BackgroundColor
                                 ? `#${btnRow.BackgroundColor.toString(16)}`
@@ -249,6 +375,34 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                             const [xStr, yStr] = gridPositionStr.split(',');
                             const gridX = parseInt(xStr, 10);
                             const gridY = parseInt(yStr, 10);
+                            // Set button x,y properties (critical for metrics!)
+                            if (!isNaN(gridX) && !isNaN(gridY)) {
+                                button.x = gridX;
+                                button.y = gridY;
+                                // Determine scan block from ScanGroups (TD Snap "Group Scan")
+                                // IMPORTANT: Only match against ScanGroups from the SAME PageLayout
+                                // A button can exist in multiple layouts with different positions
+                                const buttonPageLayoutId = btnRow.PageLayoutId;
+                                if (buttonPageLayoutId && scanGroupsByPageLayout.has(buttonPageLayoutId)) {
+                                    const scanGroups = scanGroupsByPageLayout.get(buttonPageLayoutId);
+                                    if (scanGroups && scanGroups.length > 0) {
+                                        // Find which ScanGroup contains this button's position
+                                        for (const scanGroup of scanGroups) {
+                                            // Skip if positions array is null or undefined
+                                            if (!scanGroup.positions || !Array.isArray(scanGroup.positions)) {
+                                                continue;
+                                            }
+                                            const foundInGroup = scanGroup.positions.some((pos) => pos.Column === gridX && pos.Row === gridY);
+                                            if (foundInGroup) {
+                                                // Use the scan block number from the ScanGroup
+                                                // ScanGroup scanBlock is already 1-based (index + 1)
+                                                button.scanBlock = scanGroup.scanBlock;
+                                                break; // Found the scan block, stop looking
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                             // Place button in grid if within bounds and coordinates are valid
                             if (!isNaN(gridX) &&
                                 !isNaN(gridY) &&
@@ -258,6 +412,10 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                                 gridX < 10 &&
                                 pageGrid[gridY] &&
                                 pageGrid[gridY][gridX] === null) {
+                                // Generate clone_id for button at this position
+                                const rows = pageGrid.length;
+                                const cols = pageGrid[0] ? pageGrid[0].length : 10;
+                                button.clone_id = (0, idGenerator_1.generateCloneId)(rows, cols, gridY, gridX, button.label);
                                 pageGrid[gridY][gridX] = button;
                             }
                         }
@@ -274,6 +432,27 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                 const currentPage = tree.getPage(uniqueId);
                 if (currentPage && pageGrid) {
                     currentPage.grid = pageGrid;
+                    // Track semantic_ids and clone_ids on the page
+                    const semanticIds = [];
+                    const cloneIds = [];
+                    pageGrid.forEach((row) => {
+                        row.forEach((btn) => {
+                            if (btn) {
+                                if (btn.semantic_id) {
+                                    semanticIds.push(btn.semantic_id);
+                                }
+                                if (btn.clone_id) {
+                                    cloneIds.push(btn.clone_id);
+                                }
+                            }
+                        });
+                    });
+                    if (semanticIds.length > 0) {
+                        currentPage.semantic_ids = semanticIds;
+                    }
+                    if (cloneIds.length > 0) {
+                        currentPage.clone_ids = cloneIds;
+                    }
                 }
             }
             return tree;

package/dist/processors/touchchatProcessor.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TouchChatProcessor = void 0;
 const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
+const idGenerator_1 = require("../optional/analytics/utils/idGenerator");
 const stringCasing_1 = require("../core/stringCasing");
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
@@ -23,6 +24,17 @@ function intToHex(colorInt) {
     // Assuming the color is in ARGB format, we mask out the alpha channel
     return `#${(colorInt & 0x00ffffff).toString(16).padStart(6, '0')}`;
 }
+/**
+ * Map TouchChat visible value to AAC standard visibility
+ * TouchChat: 0 = Hidden, 1 = Visible
+ * Maps to: 'Hidden' | 'Visible' | undefined
+ */
+function mapTouchChatVisibility(visible) {
+    if (visible === null || visible === undefined) {
+        return undefined; // Default to visible
+    }
+    return visible === 0 ? 'Hidden' : 'Visible';
+}
 class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -131,7 +143,7 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
             });
             // Load button boxes and their cells
             const buttonBoxQuery = `
-        SELECT bbc.*, b.*, bb.id as box_id 
+        SELECT bbc.*, b.*, bb.id as box_id
         FROM button_box_cells bbc
         JOIN buttons b ON b.resource_id = bbc.resource_id
         JOIN button_boxes bb ON bb.id = bbc.button_box_id
@@ -165,6 +177,11 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
                         label: cell.label || '',
                         message: cell.message || '',
                         semanticAction: semanticAction,
+                        semantic_id: (cell.symbol_link_id || cell.symbolLinkId) || undefined, // Extract semantic_id from symbol_link_id
+                        visibility: mapTouchChatVisibility(cell.visible || undefined),
+                        // Note: TouchChat does not use scan blocks in the file
+                        // Scanning is a runtime feature (linear/row-column patterns)
+                        // scanBlock defaults to 1 (no grouping)
                         style: {
                             backgroundColor: intToHex(style?.body_color),
                             borderColor: intToHex(style?.border_color),
@@ -181,9 +198,9 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
                     });
                     buttonBoxes.get(cell.box_id)?.push({
                         button,
-                        location: cell.location,
-                        spanX: cell.span_x,
-                        spanY: cell.span_y,
+                        location: cell.location || 0,
+                        spanX: cell.span_x || 1,
+                        spanY: cell.span_y || 1,
                     });
                 });
                 // Map button boxes to pages
@@ -241,6 +258,31 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
                     const page = tree.getPage(pageId);
                     if (page) {
                         page.grid = grid;
+                        // Generate clone_id for each button in the grid
+                        const semanticIds = [];
+                        const cloneIds = [];
+                        grid.forEach((row, rowIndex) => {
+                            row.forEach((btn, colIndex) => {
+                                if (btn) {
+                                    // Generate clone_id based on position and label
+                                    const rows = grid.length;
+                                    const cols = grid[0] ? grid[0].length : 10;
+                                    btn.clone_id = (0, idGenerator_1.generateCloneId)(rows, cols, rowIndex, colIndex, btn.label);
+                                    cloneIds.push(btn.clone_id);
+                                    // Track semantic_id if present
+                                    if (btn.semantic_id) {
+                                        semanticIds.push(btn.semantic_id);
+                                    }
+                                }
+                            });
+                        });
+                        // Track IDs on the page
+                        if (semanticIds.length > 0) {
+                            page.semantic_ids = semanticIds;
+                        }
+                        if (cloneIds.length > 0) {
+                            page.clone_ids = cloneIds;
+                        }
                     }
                 });
             }
@@ -279,6 +321,10 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
                         label: btnRow.label || '',
                         message: btnRow.message || '',
                         semanticAction: semanticAction,
+                        visibility: mapTouchChatVisibility(btnRow.visible),
+                        // Note: TouchChat does not use scan blocks in the file
+                        // Scanning is a runtime feature (linear/row-column patterns)
+                        // scanBlock defaults to 1 (no grouping)
                         style: {
                             backgroundColor: intToHex(style?.body_color),
                             borderColor: intToHex(style?.border_color),