@willwade/aac-processors 0.0.3

package/dist/processors/gridsetProcessor.js

@@ -0,0 +1,1339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridsetProcessor = void 0;
+const baseProcessor_1 = require("../core/baseProcessor");
+const treeStructure_1 = require("../core/treeStructure");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const fs_1 = __importDefault(require("fs"));
+const fast_xml_parser_1 = require("fast-xml-parser");
+const resolver_1 = require("./gridset/resolver");
+class GridsetProcessor extends baseProcessor_1.BaseProcessor {
+    constructor(options) {
+        super(options);
+    }
+    // Helper function to ensure color has alpha channel (Grid3 format)
+    ensureAlphaChannel(color) {
+        if (!color)
+            return '#FFFFFFFF';
+        // If already 8 digits (with alpha), return as is
+        if (color.match(/^#[0-9A-Fa-f]{8}$/))
+            return color;
+        // If 6 digits (no alpha), add FF for fully opaque
+        if (color.match(/^#[0-9A-Fa-f]{6}$/))
+            return color + 'FF';
+        // If 3 digits (shorthand), expand to 8
+        if (color.match(/^#[0-9A-Fa-f]{3}$/)) {
+            const r = color[1];
+            const g = color[2];
+            const b = color[3];
+            return `#${r}${r}${g}${g}${b}${b}FF`;
+        }
+        // Invalid or unknown format, return white
+        return '#FFFFFFFF';
+    }
+    // Helper function to generate Grid3 commands from semantic actions
+    generateCommandsFromSemanticAction(button, tree) {
+        const semanticAction = button.semanticAction;
+        if (!semanticAction) {
+            // Default to insert text action with structured XML format
+            // Use two <s> elements: one for the word, one for the space (CDATA preserves whitespace)
+            let text = button.message || button.label || '';
+            // Remove trailing space from message if present (we'll add it as separate segment)
+            if (text.endsWith(' ')) {
+                text = text.slice(0, -1);
+            }
+            return {
+                Command: {
+                    '@_ID': 'Action.InsertText',
+                    Parameter: {
+                        '@_Key': 'text',
+                        p: {
+                            s: [
+                                {
+                                    r: text,
+                                },
+                                {
+                                    r: { '__cdata': ' ' },
+                                },
+                            ],
+                        },
+                    },
+                },
+            };
+        }
+        // Use platform-specific Grid3 data if available
+        if (semanticAction.platformData?.grid3) {
+            const grid3Data = semanticAction.platformData.grid3;
+            const params = Object.entries(grid3Data.parameters || {}).map(([key, value]) => ({
+                '@_Key': key,
+                '#text': String(value),
+            }));
+            return {
+                Command: {
+                    '@_ID': grid3Data.commandId,
+                    ...(params.length > 0 ? { Parameter: params } : {}),
+                },
+            };
+        }
+        // Convert semantic actions to Grid3 commands
+        const intentStr = String(semanticAction.intent);
+        switch (intentStr) {
+            case 'NAVIGATE_TO': {
+                // For Grid3, we need to use the grid name, not the ID
+                let targetGridName = semanticAction.targetId || '';
+                if (tree && semanticAction.targetId) {
+                    const targetPage = tree.getPage(semanticAction.targetId);
+                    if (targetPage) {
+                        targetGridName = targetPage.name || targetPage.id;
+                    }
+                }
+                return {
+                    Command: {
+                        '@_ID': 'Jump.To',
+                        Parameter: {
+                            '@_Key': 'grid',
+                            '#text': targetGridName,
+                        },
+                    },
+                };
+            }
+            case 'GO_BACK':
+                return {
+                    Command: {
+                        '@_ID': 'Jump.Back',
+                    },
+                };
+            case 'GO_HOME':
+                return {
+                    Command: {
+                        '@_ID': 'Jump.Home',
+                    },
+                };
+            case 'DELETE_WORD':
+                return {
+                    Command: {
+                        '@_ID': 'Action.DeleteWord',
+                    },
+                };
+            case 'DELETE_CHARACTER':
+                return {
+                    Command: {
+                        '@_ID': 'Action.DeleteLetter',
+                    },
+                };
+            case 'CLEAR_TEXT':
+                return {
+                    Command: {
+                        '@_ID': 'Action.Clear',
+                    },
+                };
+            case 'SPEAK_TEXT':
+            case 'SPEAK_IMMEDIATE':
+                // For communication buttons, insert text into message bar (sentence building)
+                // Grid3 requires explicit trailing space for automatic word spacing
+                // Use two <s> elements: one for the word, one for the space (CDATA preserves whitespace)
+                // Users can speak the complete sentence with a dedicated Speak button
+                {
+                    let text = semanticAction.text || button.message || button.label || '';
+                    // Remove trailing space from message if present (we'll add it as separate segment)
+                    if (text.endsWith(' ')) {
+                        text = text.slice(0, -1);
+                    }
+                    return {
+                        Command: {
+                            '@_ID': 'Action.InsertText',
+                            Parameter: {
+                                '@_Key': 'text',
+                                p: {
+                                    s: [
+                                        {
+                                            r: text,
+                                        },
+                                        {
+                                            r: { '__cdata': ' ' },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    };
+                }
+            case 'INSERT_TEXT':
+                // Add trailing space for word buttons to enable sentence building
+                // Use two <s> elements: one for the word, one for the space (CDATA preserves whitespace)
+                {
+                    let text = semanticAction.text || button.message || button.label || '';
+                    // Remove trailing space from message if present (we'll add it as separate segment)
+                    if (text.endsWith(' ')) {
+                        text = text.slice(0, -1);
+                    }
+                    return {
+                        Command: {
+                            '@_ID': 'Action.InsertText',
+                            Parameter: {
+                                '@_Key': 'text',
+                                p: {
+                                    s: [
+                                        {
+                                            r: text,
+                                        },
+                                        {
+                                            r: { '__cdata': ' ' },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    };
+                }
+            default:
+                // Fallback to insert text with structured XML format
+                // Use two <s> elements: one for the word, one for the space (CDATA preserves whitespace)
+                {
+                    let text = semanticAction.text || button.message || button.label || '';
+                    // Remove trailing space from message if present (we'll add it as separate segment)
+                    if (text.endsWith(' ')) {
+                        text = text.slice(0, -1);
+                    }
+                    return {
+                        Command: {
+                            '@_ID': 'Action.InsertText',
+                            Parameter: {
+                                '@_Key': 'text',
+                                p: {
+                                    s: [
+                                        {
+                                            r: text,
+                                        },
+                                        {
+                                            r: { '__cdata': ' ' },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    };
+                }
+        }
+    }
+    // Helper function to convert Grid 3 style to AACStyle
+    convertGrid3StyleToAACStyle(grid3Style) {
+        if (!grid3Style)
+            return {};
+        return {
+            backgroundColor: grid3Style.BackColour || grid3Style.TileColour,
+            borderColor: grid3Style.BorderColour,
+            fontColor: grid3Style.FontColour,
+            fontFamily: grid3Style.FontName,
+            fontSize: grid3Style.FontSize ? parseInt(String(grid3Style.FontSize)) : undefined,
+        };
+    }
+    // Helper function to get style by ID or return default
+    getStyleById(styles, styleId) {
+        if (!styleId || !styles.has(styleId)) {
+            return {};
+        }
+        return this.convertGrid3StyleToAACStyle(styles.get(styleId));
+    }
+    // Helper to safely extract text from XML parser values
+    textOf(val) {
+        if (!val)
+            return undefined;
+        if (typeof val === 'string')
+            return val;
+        if (typeof val === 'object' && '#text' in val)
+            return String(val['#text']);
+        return undefined;
+    }
+    extractTexts(filePathOrBuffer) {
+        const buffer = Buffer.isBuffer(filePathOrBuffer)
+            ? filePathOrBuffer
+            : fs_1.default.readFileSync(filePathOrBuffer);
+        const tree = this.loadIntoTree(buffer);
+        const texts = [];
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            if (page.name)
+                texts.push(page.name);
+            page.buttons.forEach((btn) => {
+                if (btn.label)
+                    texts.push(btn.label);
+                if (btn.message && btn.message !== btn.label)
+                    texts.push(btn.message);
+            });
+        }
+        return texts;
+    }
+    loadIntoTree(filePathOrBuffer) {
+        const tree = new treeStructure_1.AACTree();
+        let zip;
+        try {
+            zip = new adm_zip_1.default(filePathOrBuffer);
+        }
+        catch (error) {
+            throw new Error(`Invalid ZIP file format: ${error.message}`);
+        }
+        const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false });
+        // Parse FileMap.xml if present to index dynamic files per grid
+        const fileMapIndex = new Map();
+        try {
+            const fmEntry = zip.getEntries().find((e) => e.entryName.endsWith('FileMap.xml'));
+            if (fmEntry) {
+                const fmXml = fmEntry.getData().toString('utf8');
+                const fmData = parser.parse(fmXml);
+                const entries = fmData?.FileMap?.Entries?.Entry || fmData?.fileMap?.entries?.entry;
+                if (entries) {
+                    const arr = Array.isArray(entries) ? entries : [entries];
+                    for (const ent of arr) {
+                        const staticFile = (ent['@_StaticFile'] ||
+                            ent.StaticFile ||
+                            ent.staticFile ||
+                            '').replace(/\\/g, '/');
+                        if (!staticFile)
+                            continue;
+                        const df = ent.DynamicFiles || ent.dynamicFiles;
+                        const candidates = df?.File || df?.file || df?.Files || df?.files;
+                        const list = Array.isArray(candidates) ? candidates : candidates ? [candidates] : [];
+                        const files = [];
+                        for (const v of list) {
+                            if (!v)
+                                continue;
+                            if (typeof v === 'string')
+                                files.push(v.replace(/\\/g, '/'));
+                            else if (typeof v === 'object' && '#text' in v)
+                                files.push(String(v['#text']).replace(/\\/g, '/'));
+                        }
+                        fileMapIndex.set(staticFile, files);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            /* ignore: optional FileMap.xml may be missing or malformed */
+        }
+        // First, load styles from Settings0/Styles/styles.xml (Grid3 format)
+        const styles = new Map();
+        const styleEntry = zip
+            .getEntries()
+            .find((entry) => entry.entryName.endsWith('styles.xml') || entry.entryName.endsWith('style.xml'));
+        if (styleEntry) {
+            try {
+                const styleXmlContent = styleEntry.getData().toString('utf8');
+                const styleData = parser.parse(styleXmlContent);
+                // Parse styles and store them in the map
+                // Grid3 uses StyleData.Styles.Style with Key attribute
+                if (styleData.StyleData?.Styles?.Style) {
+                    const styleArray = Array.isArray(styleData.StyleData.Styles.Style)
+                        ? styleData.StyleData.Styles.Style
+                        : [styleData.StyleData.Styles.Style];
+                    styleArray.forEach((style) => {
+                        if (style['@_Key']) {
+                            styles.set(String(style['@_Key']), style);
+                        }
+                    });
+                }
+                // Also handle legacy format with @_ID
+                else if (styleData.Styles?.Style) {
+                    const styleArray = Array.isArray(styleData.Styles.Style)
+                        ? styleData.Styles.Style
+                        : [styleData.Styles.Style];
+                    styleArray.forEach((style) => {
+                        if (style['@_ID']) {
+                            styles.set(String(style['@_ID']), style);
+                        }
+                    });
+                }
+            }
+            catch (e) {
+                console.warn('Failed to parse styles.xml:', e);
+            }
+        }
+        // Debug: log all entry names
+        // console.log('Gridset zip entries:', zip.getEntries().map(e => e.entryName));
+        // First pass: collect all grid names and IDs for navigation resolution
+        const gridNameToIdMap = new Map();
+        const gridIdToNameMap = new Map();
+        zip.getEntries().forEach((entry) => {
+            if (entry.entryName.startsWith('Grids/') && entry.entryName.endsWith('grid.xml')) {
+                try {
+                    const xmlContent = entry.getData().toString('utf8');
+                    const data = parser.parse(xmlContent);
+                    const grid = data.Grid || data.grid;
+                    if (!grid)
+                        return;
+                    const gridId = this.textOf(grid.GridGuid || grid.gridGuid || grid.id);
+                    let gridName = this.textOf(grid.Name) || this.textOf(grid.name) || this.textOf(grid['@_Name']);
+                    if (!gridName) {
+                        const match = entry.entryName.match(/^Grids\/([^/]+)\//);
+                        if (match)
+                            gridName = match[1];
+                    }
+                    if (gridId && gridName) {
+                        gridNameToIdMap.set(gridName, gridId);
+                        gridIdToNameMap.set(gridId, gridName);
+                    }
+                }
+                catch (e) {
+                    // Skip errors in first pass
+                }
+            }
+        });
+        // Second pass: process each grid file in the gridset
+        zip.getEntries().forEach((entry) => {
+            // Only process files named grid.xml under Grids/ (any subdir)
+            if (entry.entryName.startsWith('Grids/') && entry.entryName.endsWith('grid.xml')) {
+                let xmlContent;
+                try {
+                    xmlContent = entry.getData().toString('utf8');
+                }
+                catch (e) {
+                    // Skip unreadable files
+                    return;
+                }
+                let data;
+                try {
+                    data = parser.parse(xmlContent);
+                }
+                catch (error) {
+                    // Skip malformed XML but log the specific error
+                    console.warn(`Malformed XML in ${entry.entryName}: ${error.message}`);
+                    return;
+                }
+                // Grid3 XML: <Grid> root
+                const grid = data.Grid || data.grid;
+                if (!grid) {
+                    return;
+                }
+                // Defensive: GridGuid and Name required
+                const gridId = this.textOf(grid.GridGuid || grid.gridGuid || grid.id);
+                let gridName = this.textOf(grid.Name) || this.textOf(grid.name) || this.textOf(grid['@_Name']);
+                if (!gridName) {
+                    // Fallback: get folder name from entry path
+                    const match = entry.entryName.match(/^Grids\/([^/]+)\//);
+                    if (match)
+                        gridName = match[1];
+                }
+                if (!gridId || !gridName) {
+                    return;
+                }
+                const page = new treeStructure_1.AACPage({
+                    id: String(gridId),
+                    name: String(gridName),
+                    grid: [],
+                    buttons: [],
+                    parentId: null,
+                    style: {
+                        backgroundColor: grid.BackgroundColour || grid.backgroundColour,
+                    },
+                });
+                // Calculate grid dimensions from ColumnDefinitions and RowDefinitions
+                const columnDefs = grid.ColumnDefinitions?.ColumnDefinition || [];
+                const rowDefs = grid.RowDefinitions?.RowDefinition || [];
+                const maxCols = Array.isArray(columnDefs) ? columnDefs.length : columnDefs ? 1 : 5;
+                const maxRows = Array.isArray(rowDefs) ? rowDefs.length : rowDefs ? 1 : 4;
+                // Process buttons: <Cells><Cell>
+                const cells = grid.Cells?.Cell || grid.cells?.cell;
+                if (cells) {
+                    // Cells may be array or single object
+                    const cellArr = Array.isArray(cells) ? cells : [cells];
+                    // Create a 2D grid to track button positions
+                    const gridLayout = [];
+                    for (let r = 0; r < maxRows; r++) {
+                        gridLayout[r] = new Array(maxCols).fill(null);
+                    }
+                    cellArr.forEach((cell, idx) => {
+                        if (!cell || !cell.Content)
+                            return;
+                        // Extract position information from cell attributes
+                        // Grid3 uses 1-based coordinates, convert to 0-based for internal use
+                        const cellX = Math.max(0, parseInt(String(cell['@_X'] || '1'), 10) - 1);
+                        const cellY = Math.max(0, parseInt(String(cell['@_Y'] || '1'), 10) - 1);
+                        const colSpan = parseInt(String(cell['@_ColumnSpan'] || '1'), 10);
+                        const rowSpan = parseInt(String(cell['@_RowSpan'] || '1'), 10);
+                        // Extract label from CaptionAndImage/Caption
+                        const content = cell.Content;
+                        const captionAndImage = content.CaptionAndImage || content.captionAndImage;
+                        let label = captionAndImage?.Caption || captionAndImage?.caption || '';
+                        // If no caption, try other sources or create a placeholder
+                        if (!label) {
+                            // For cells without captions (like AutoContent cells), create a meaningful label
+                            if (content.ContentType === 'AutoContent') {
+                                label = `AutoContent_${idx}`;
+                            }
+                            else {
+                                return; // Skip cells without labels
+                            }
+                        }
+                        const message = label; // Use caption as message
+                        // Parse all command types from Grid3 and create semantic actions
+                        let semanticAction;
+                        let legacyAction = null;
+                        // infer action type implicitly from commands; no explicit enum needed
+                        let navigationTarget;
+                        const commands = content.Commands?.Command || content.commands?.command;
+                        // Resolve image for this cell using FileMap and coordinate heuristics
+                        const imageCandidate = captionAndImage?.Image ||
+                            captionAndImage?.image ||
+                            captionAndImage?.ImageName ||
+                            captionAndImage?.imageName ||
+                            captionAndImage?.Symbol ||
+                            captionAndImage?.symbol;
+                        const declaredImageName = imageCandidate ? this.textOf(imageCandidate) : undefined;
+                        const gridEntryPath = entry.entryName.replace(/\\/g, '/');
+                        const baseDir = gridEntryPath.replace(/\/grid\.xml$/, '/');
+                        const dynamicFiles = fileMapIndex.get(gridEntryPath) || [];
+                        const resolvedImageEntry = (0, resolver_1.resolveGrid3CellImage)(zip, {
+                            baseDir,
+                            imageName: declaredImageName,
+                            x: cellX + 1,
+                            y: cellY + 1,
+                            dynamicFiles,
+                        }) || undefined;
+                        if (commands) {
+                            const commandArr = Array.isArray(commands) ? commands : [commands];
+                            for (const command of commandArr) {
+                                const commandId = command['@_ID'] || command.ID || command.id;
+                                const parameters = command.Parameter || command.parameter;
+                                const paramArr = parameters
+                                    ? Array.isArray(parameters)
+                                        ? parameters
+                                        : [parameters]
+                                    : [];
+                                // Helper to extract text from Grid3's structured format <p><s><r>text</r></s></p>
+                                const extractStructuredText = (param) => {
+                                    // Try to extract from nested p.s structure
+                                    if (param.p) {
+                                        const p = param.p;
+                                        // Handle p.s array or single s element
+                                        const sElements = Array.isArray(p.s) ? p.s : p.s ? [p.s] : [];
+                                        // Extract all r values and concatenate
+                                        const parts = [];
+                                        for (const s of sElements) {
+                                            if (s && s.r !== undefined) {
+                                                parts.push(String(s.r));
+                                            }
+                                        }
+                                        if (parts.length > 0) {
+                                            return parts.join('');
+                                        }
+                                    }
+                                    return undefined;
+                                };
+                                // Helper to get parameter value
+                                const getParam = (key) => {
+                                    if (!parameters)
+                                        return undefined;
+                                    for (const param of paramArr) {
+                                        if (param['@_Key'] === key || param.Key === key || param.key === key) {
+                                            // First try simple #text value
+                                            const simpleValue = param['#text'] ?? param.text ?? param.value;
+                                            if (typeof simpleValue === 'string') {
+                                                return simpleValue;
+                                            }
+                                            // Try to extract from structured format (Grid3's <p><s><r> format)
+                                            const structuredValue = extractStructuredText(param);
+                                            if (structuredValue !== undefined) {
+                                                return structuredValue;
+                                            }
+                                            // Fallback to string conversion
+                                            if (typeof param === 'string') {
+                                                return param;
+                                            }
+                                        }
+                                    }
+                                    return undefined;
+                                };
+                                switch (commandId) {
+                                    case 'Jump.To': {
+                                        const gridTarget = getParam('grid');
+                                        if (gridTarget) {
+                                            // Resolve grid name to grid ID for navigation
+                                            const targetGridId = gridNameToIdMap.get(gridTarget) || gridTarget;
+                                            navigationTarget = targetGridId;
+                                            // navigate action
+                                            semanticAction = {
+                                                category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                                                intent: treeStructure_1.AACSemanticIntent.NAVIGATE_TO,
+                                                targetId: targetGridId,
+                                                platformData: {
+                                                    grid3: {
+                                                        commandId,
+                                                        parameters: { grid: gridTarget },
+                                                    },
+                                                },
+                                                fallback: {
+                                                    type: 'NAVIGATE',
+                                                    targetPageId: targetGridId,
+                                                },
+                                            };
+                                            legacyAction = {
+                                                type: 'NAVIGATE',
+                                                targetPageId: targetGridId,
+                                            };
+                                        }
+                                        break;
+                                    }
+                                    case 'Jump.Back':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                                            intent: treeStructure_1.AACSemanticIntent.GO_BACK,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {},
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Go back',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'GO_BACK',
+                                        };
+                                        break;
+                                    case 'Jump.Home':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                                            intent: treeStructure_1.AACSemanticIntent.GO_HOME,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {},
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Go home',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'GO_HOME',
+                                        };
+                                        break;
+                                    case 'Action.Speak': {
+                                        // speak
+                                        const speakUnit = getParam('unit');
+                                        const moveCaret = getParam('movecaret');
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                                            intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {
+                                                        unit: speakUnit,
+                                                        movecaret: moveCaret,
+                                                    },
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'SPEAK',
+                                                message: 'Speak text',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'SPEAK',
+                                            unit: speakUnit,
+                                            moveCaret: moveCaret ? parseInt(String(moveCaret)) : undefined,
+                                        };
+                                        break;
+                                    }
+                                    case 'Action.InsertText': {
+                                        // speak
+                                        const insertText = getParam('text');
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                                            intent: treeStructure_1.AACSemanticIntent.INSERT_TEXT,
+                                            text: insertText,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: { text: insertText },
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'SPEAK',
+                                                message: insertText,
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'INSERT_TEXT',
+                                            text: insertText,
+                                        };
+                                        break;
+                                    }
+                                    case 'Action.DeleteWord':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.TEXT_EDITING,
+                                            intent: treeStructure_1.AACSemanticIntent.DELETE_WORD,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {},
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Delete word',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'DELETE_WORD',
+                                        };
+                                        break;
+                                    case 'Action.DeleteLetter':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.TEXT_EDITING,
+                                            intent: treeStructure_1.AACSemanticIntent.DELETE_CHARACTER,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {},
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Delete character',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'DELETE_CHARACTER',
+                                        };
+                                        break;
+                                    case 'Action.Clear':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.TEXT_EDITING,
+                                            intent: treeStructure_1.AACSemanticIntent.CLEAR_TEXT,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {},
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Clear text',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'CLEAR_TEXT',
+                                        };
+                                        break;
+                                    case 'Action.Letter': {
+                                        // action
+                                        const letter = getParam('letter');
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.TEXT_EDITING,
+                                            intent: treeStructure_1.AACSemanticIntent.INSERT_TEXT,
+                                            text: letter,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: { letter },
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: letter,
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'INSERT_LETTER',
+                                            letter,
+                                        };
+                                        break;
+                                    }
+                                    case 'Settings.RestAll':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.CUSTOM,
+                                            intent: treeStructure_1.AACSemanticIntent.PLATFORM_SPECIFIC,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {
+                                                        indicatorenabled: getParam('indicatorenabled'),
+                                                        action: getParam('action'),
+                                                    },
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Settings action',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'SETTINGS',
+                                            indicatorEnabled: getParam('indicatorenabled') === '1',
+                                            settingsAction: getParam('action'),
+                                        };
+                                        break;
+                                    case 'AutoContent.Activate':
+                                        // action
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.CUSTOM,
+                                            intent: treeStructure_1.AACSemanticIntent.PLATFORM_SPECIFIC,
+                                            platformData: {
+                                                grid3: {
+                                                    commandId,
+                                                    parameters: {
+                                                        autocontenttype: getParam('autocontenttype'),
+                                                    },
+                                                },
+                                            },
+                                            fallback: {
+                                                type: 'ACTION',
+                                                message: 'Auto content',
+                                            },
+                                        };
+                                        legacyAction = {
+                                            type: 'AUTO_CONTENT',
+                                            autoContentType: getParam('autocontenttype'),
+                                        };
+                                        break;
+                                    default:
+                                        // Unknown command - preserve as generic action
+                                        if (commandId) {
+                                            // action
+                                            const allParams = Object.fromEntries(paramArr.map((p) => [p.Key || p.key, p['#text']]));
+                                            semanticAction = {
+                                                category: treeStructure_1.AACSemanticCategory.CUSTOM,
+                                                intent: treeStructure_1.AACSemanticIntent.PLATFORM_SPECIFIC,
+                                                platformData: {
+                                                    grid3: {
+                                                        commandId,
+                                                        parameters: allParams,
+                                                    },
+                                                },
+                                                fallback: {
+                                                    type: 'ACTION',
+                                                    message: 'Unknown command',
+                                                },
+                                            };
+                                            legacyAction = {
+                                                type: 'SPEAK',
+                                                parameters: { commandId, ...allParams },
+                                            };
+                                        }
+                                        break;
+                                }
+                                // Use first recognized command
+                                if (semanticAction || legacyAction)
+                                    break;
+                            }
+                        }
+                        // Create default semantic action if none was created from commands
+                        if (!semanticAction) {
+                            semanticAction = {
+                                category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                                intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                                text: String(message),
+                                fallback: {
+                                    type: 'SPEAK',
+                                    message: String(message),
+                                },
+                            };
+                        }
+                        // Get style information from cell attributes and Content.Style
+                        let cellStyleId = cell['@_StyleID'] || cell['@_styleid'];
+                        // Grid3 format: check Content.Style.BasedOnStyle
+                        if (!cellStyleId && content.Style?.BasedOnStyle) {
+                            cellStyleId = content.Style.BasedOnStyle;
+                        }
+                        const cellStyle = this.getStyleById(styles, cellStyleId ? String(cellStyleId) : undefined);
+                        // Also check for inline style overrides
+                        const inlineStyle = {};
+                        if (cell['@_BackColour'])
+                            inlineStyle.backgroundColor = cell['@_BackColour'];
+                        if (cell['@_FontColour'])
+                            inlineStyle.fontColor = cell['@_FontColour'];
+                        if (cell['@_BorderColour'])
+                            inlineStyle.borderColor = cell['@_BorderColour'];
+                        // Grid3 inline styles from Content.Style
+                        if (content.Style) {
+                            if (content.Style.BackColour)
+                                inlineStyle.backgroundColor = content.Style.BackColour;
+                            if (content.Style.FontColour)
+                                inlineStyle.fontColor = content.Style.FontColour;
+                            if (content.Style.BorderColour)
+                                inlineStyle.borderColor = content.Style.BorderColour;
+                            if (content.Style.FontName)
+                                inlineStyle.fontFamily = content.Style.FontName;
+                            if (content.Style.FontSize)
+                                inlineStyle.fontSize = parseInt(String(content.Style.FontSize));
+                        }
+                        const button = new treeStructure_1.AACButton({
+                            id: `${gridId}_btn_${idx}`,
+                            label: String(label),
+                            message: String(message),
+                            targetPageId: navigationTarget ? String(navigationTarget) : undefined,
+                            semanticAction: semanticAction,
+                            image: declaredImageName,
+                            resolvedImageEntry: resolvedImageEntry,
+                            x: cellX,
+                            y: cellY,
+                            columnSpan: colSpan,
+                            rowSpan: rowSpan,
+                            style: {
+                                ...cellStyle,
+                                ...inlineStyle, // Inline styles override referenced styles
+                            },
+                        });
+                        // Add button to page
+                        page.addButton(button);
+                        // Place button in grid layout (handle colspan/rowspan)
+                        for (let r = cellY; r < cellY + rowSpan && r < maxRows; r++) {
+                            for (let c = cellX; c < cellX + colSpan && c < maxCols; c++) {
+                                if (gridLayout[r] && gridLayout[r][c] === null) {
+                                    gridLayout[r][c] = button;
+                                }
+                            }
+                        }
+                    });
+                    // Set the page's grid layout
+                    page.grid = gridLayout;
+                }
+                tree.addPage(page);
+            }
+        });
+        // After all pages are loaded, set parentId for navigation targets
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            page.buttons.forEach((btn) => {
+                if (btn.semanticAction?.intent === treeStructure_1.AACSemanticIntent.NAVIGATE_TO && btn.targetPageId) {
+                    const targetPage = tree.getPage(btn.targetPageId);
+                    if (targetPage) {
+                        targetPage.parentId = page.id;
+                    }
+                }
+            });
+        }
+        // Read settings.xml to get the StartGrid (home page)
+        try {
+            const settingsEntry = zip.getEntries().find((e) => e.entryName.endsWith('settings.xml'));
+            if (settingsEntry) {
+                const settingsXml = settingsEntry.getData().toString('utf8');
+                const settingsData = parser.parse(settingsXml);
+                const startGridName = settingsData?.GridSetSettings?.StartGrid ||
+                    settingsData?.gridSetSettings?.startGrid ||
+                    settingsData?.GridsetSettings?.StartGrid;
+                if (startGridName && typeof startGridName === 'string') {
+                    // Resolve the grid name to grid ID
+                    const homeGridId = gridNameToIdMap.get(startGridName);
+                    if (homeGridId) {
+                        tree.rootId = homeGridId;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // If settings.xml parsing fails, tree.rootId will default to first page
+        }
+        return tree;
+    }
+    processTexts(filePathOrBuffer, translations, outputPath) {
+        // Load the tree, apply translations, and save to new file
+        const buffer = Buffer.isBuffer(filePathOrBuffer)
+            ? filePathOrBuffer
+            : fs_1.default.readFileSync(filePathOrBuffer);
+        const tree = this.loadIntoTree(buffer);
+        // Apply translations to all text content
+        Object.values(tree.pages).forEach((page) => {
+            // Translate page names
+            if (page.name && translations.has(page.name)) {
+                const tPage = translations.get(page.name);
+                if (tPage)
+                    page.name = tPage;
+            }
+            // Translate button labels and messages
+            page.buttons.forEach((button) => {
+                if (button.label && translations.has(button.label)) {
+                    const tLabel = translations.get(button.label);
+                    if (tLabel)
+                        button.label = tLabel;
+                }
+                if (button.message && translations.has(button.message)) {
+                    const tMsg = translations.get(button.message);
+                    if (tMsg)
+                        button.message = tMsg;
+                }
+            });
+        });
+        // Save the translated tree and return its content
+        this.saveFromTree(tree, outputPath);
+        return fs_1.default.readFileSync(outputPath);
+    }
+    saveFromTree(tree, outputPath) {
+        const zip = new adm_zip_1.default();
+        if (Object.keys(tree.pages).length === 0) {
+            // Create empty zip for empty tree
+            zip.writeZip(outputPath);
+            return;
+        }
+        // Collect all unique styles from pages and buttons
+        const uniqueStyles = new Map();
+        let styleIdCounter = 1;
+        // Track images that need to be written to the ZIP
+        // Maps button ID to image data for buttons with images
+        const buttonImages = new Map();
+        // Helper function to add style and return its ID
+        const addStyle = (style) => {
+            if (!style || typeof style !== 'object')
+                return '';
+            const obj = style;
+            if (Object.keys(obj).length === 0)
+                return '';
+            const styleKey = JSON.stringify(obj);
+            const existing = uniqueStyles.get(styleKey);
+            if (existing)
+                return existing.id;
+            const styleId = `Style${styleIdCounter++}`;
+            uniqueStyles.set(styleKey, { id: styleId, style: obj });
+            return styleId;
+        };
+        // Collect styles from all pages and buttons
+        Object.values(tree.pages).forEach((page) => {
+            if (page.style)
+                addStyle(page.style);
+            page.buttons.forEach((button) => {
+                if (button.style)
+                    addStyle(button.style);
+            });
+        });
+        // Get the home/start grid from tree.rootId, fallback to first page
+        const pages = Object.values(tree.pages);
+        let startGrid = '';
+        if (tree.rootId) {
+            const homePage = tree.getPage(tree.rootId);
+            if (homePage) {
+                startGrid = homePage.name || homePage.id;
+            }
+        }
+        // Fallback to first page if no rootId or page not found
+        if (!startGrid && pages.length > 0) {
+            startGrid = pages[0].name || pages[0].id;
+        }
+        // Create Settings0/settings.xml with proper Grid3 structure
+        const settingsData = {
+            '?xml': { '@_version': '1.0', '@_encoding': 'UTF-8' },
+            GridSetSettings: {
+                '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+                StartGrid: startGrid,
+                // Add other common Grid3 settings
+                ScanEnabled: 'false',
+                ScanTimeoutMs: '2000',
+                HoverEnabled: 'false',
+                HoverTimeoutMs: '1000',
+                MouseclickEnabled: 'true',
+                Language: 'en-US',
+            },
+        };
+        const settingsBuilder = new fast_xml_parser_1.XMLBuilder({
+            ignoreAttributes: false,
+            format: true,
+            indentBy: '  ',
+            suppressEmptyNode: true,
+        });
+        const settingsXmlContent = settingsBuilder.build(settingsData);
+        zip.addFile('Settings0/settings.xml', Buffer.from(settingsXmlContent, 'utf8'));
+        // Create Settings0/Styles/style.xml if there are styles
+        if (uniqueStyles.size > 0) {
+            const stylesArray = Array.from(uniqueStyles.values()).map(({ id, style }) => {
+                const styleObj = {
+                    '@_Key': id,
+                    // When TileColour is present, BackColour is the surround (outer area)
+                    // For "None" surround, just use BackColour for the fill (no TileColour)
+                    BackColour: this.ensureAlphaChannel(style.backgroundColor),
+                    BorderColour: this.ensureAlphaChannel(style.borderColor) || '#000000FF',
+                    FontColour: this.ensureAlphaChannel(style.fontColor) || '#000000FF',
+                    FontName: style.fontFamily || 'Arial',
+                    FontSize: style.fontSize?.toString() || '16',
+                };
+                // Don't add TileColour - just use BackColour as the fill color
+                return styleObj;
+            });
+            const styleData = {
+                '?xml': { '@_version': '1.0', '@_encoding': 'UTF-8' },
+                StyleData: {
+                    '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+                    Styles: {
+                        Style: stylesArray,
+                    },
+                },
+            };
+            const styleBuilder = new fast_xml_parser_1.XMLBuilder({
+                ignoreAttributes: false,
+                format: true,
+                indentBy: '  ',
+            });
+            const styleXmlContent = styleBuilder.build(styleData);
+            zip.addFile('Settings0/Styles/styles.xml', Buffer.from(styleXmlContent, 'utf8'));
+        }
+        // Collect grid file paths for FileMap.xml
+        const gridFilePaths = [];
+        // Create a grid for each page
+        Object.values(tree.pages).forEach((page, index) => {
+            const gridData = {
+                Grid: {
+                    '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+                    GridGuid: page.id,
+                    // Calculate grid dimensions based on actual layout
+                    ColumnDefinitions: this.calculateColumnDefinitions(page),
+                    RowDefinitions: this.calculateRowDefinitions(page),
+                    AutoContentCommands: '',
+                    Cells: page.buttons.length > 0
+                        ? {
+                            Cell: [
+                                // Add workspace/message bar cell at the top of ALL pages
+                                // Grid3 uses 0-based coordinates; omit X and Y to use defaults (0, 0)
+                                {
+                                    '@_ColumnSpan': 4,
+                                    Content: {
+                                        ContentType: 'Workspace',
+                                        ContentSubType: 'Chat',
+                                        Style: {
+                                            BasedOnStyle: 'Workspace',
+                                        },
+                                    },
+                                },
+                                // Regular button cells
+                                ...this.filterPageButtons(page.buttons).map((button, btnIndex) => {
+                                    const buttonStyleId = button.style ? addStyle(button.style) : '';
+                                    // Find button position in grid layout
+                                    const position = this.findButtonPosition(page, button, btnIndex);
+                                    // Shift all buttons down by 1 row to make room for workspace
+                                    const yOffset = 1;
+                                    // Build CaptionAndImage object
+                                    const captionAndImage = {
+                                        Caption: button.label || '',
+                                    };
+                                    // Add image reference if button has an image
+                                    // Grid3 uses coordinate-based naming: {x}-{y}-0-text-0.{ext}
+                                    if (button.image) {
+                                        // Try to determine file extension from image name or default to PNG
+                                        let imageExt = 'png';
+                                        if (button.image.match(/\.(png|jpg|jpeg|gif|svg)$/i)) {
+                                            imageExt = button.image.match(/\.(png|jpg|jpeg|gif|svg)$/i)[1].toLowerCase();
+                                        }
+                                        // Grid3 dynamically constructs image filenames by prepending cell coordinates
+                                        // The XML should only contain the suffix: -0-text-0.{ext}
+                                        // Grid3 automatically adds the X-Y prefix based on the Cell's position
+                                        captionAndImage.Image = `-0-text-0.${imageExt}`;
+                                        // Extract image data from button parameters if available
+                                        // (AstericsGridProcessor stores it there during loadIntoTree)
+                                        let imageData = Buffer.alloc(0);
+                                        if (button.parameters && button.parameters.imageData && Buffer.isBuffer(button.parameters.imageData)) {
+                                            imageData = button.parameters.imageData;
+                                        }
+                                        // Store image data for later writing to ZIP
+                                        buttonImages.set(button.id, {
+                                            imageData: imageData,
+                                            ext: imageExt,
+                                            pageName: page.name || page.id,
+                                            x: position.x,
+                                            y: position.y + yOffset,
+                                        });
+                                    }
+                                    const cellData = {
+                                        '@_X': position.x, // Grid3 uses 0-based X coordinates (defaults to 0 when omitted)
+                                        '@_Y': position.y + yOffset, // Grid3 uses 0-based Y coordinates with workspace offset
+                                        '@_ColumnSpan': position.columnSpan,
+                                        '@_RowSpan': position.rowSpan,
+                                        Content: {
+                                            Commands: this.generateCommandsFromSemanticAction(button, tree),
+                                            CaptionAndImage: captionAndImage,
+                                        },
+                                    };
+                                    // Add style reference and inline color overrides if available
+                                    // Some Grid3 versions need inline colors in addition to style references
+                                    if (buttonStyleId || button.style) {
+                                        const styleObj = {};
+                                        // Add style reference if we have one
+                                        if (buttonStyleId) {
+                                            styleObj.BasedOnStyle = buttonStyleId;
+                                        }
+                                        // Add inline color overrides for better Grid3 compatibility
+                                        if (button.style?.backgroundColor) {
+                                            // Use BackColour for fill (no TileColour means no surround, just the fill)
+                                            styleObj.BackColour = this.ensureAlphaChannel(button.style.backgroundColor);
+                                        }
+                                        if (button.style?.borderColor) {
+                                            styleObj.BorderColour = this.ensureAlphaChannel(button.style.borderColor);
+                                        }
+                                        if (button.style?.fontColor) {
+                                            styleObj.FontColour = this.ensureAlphaChannel(button.style.fontColor);
+                                        }
+                                        if (button.style?.fontFamily) {
+                                            styleObj.FontName = button.style.fontFamily;
+                                        }
+                                        if (button.style?.fontSize) {
+                                            styleObj.FontSize = button.style.fontSize;
+                                        }
+                                        cellData.Content.Style = styleObj;
+                                    }
+                                    return cellData;
+                                }),
+                            ]
+                        }
+                        : { Cell: [] },
+                },
+            };
+            // Convert to XML
+            const builder = new fast_xml_parser_1.XMLBuilder({
+                ignoreAttributes: false,
+                format: true,
+                indentBy: '  ',
+                suppressEmptyNode: true,
+                cdataPropName: '__cdata',
+            });
+            const xmlContent = builder.build(gridData);
+            // Add to zip in Grids folder with proper Grid3 naming
+            const gridPath = `Grids\\${page.name || page.id}\\grid.xml`;
+            gridFilePaths.push(gridPath);
+            zip.addFile(gridPath, Buffer.from(xmlContent, 'utf8'));
+        });
+        // Write image files to ZIP
+        buttonImages.forEach((imgData, buttonId) => {
+            if (imgData.imageData && imgData.imageData.length > 0) {
+                // Create image path in the grid's directory
+                const imagePath = `Grids\\${imgData.pageName}\\${imgData.x}-${imgData.y}-0-text-0.${imgData.ext}`;
+                zip.addFile(imagePath, imgData.imageData);
+            }
+        });
+        // Create FileMap.xml to map all grid files with their dynamic image files
+        const fileMapData = {
+            '?xml': { '@_version': '1.0', '@_encoding': 'UTF-8' },
+            FileMap: {
+                '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+                Entries: {
+                    Entry: gridFilePaths.map((gridPath) => {
+                        // Find all image files for this grid
+                        const gridName = gridPath.match(/Grids\\([^\\]+)\\grid\.xml$/)?.[1] || '';
+                        const imageFiles = [];
+                        // Collect image filenames for buttons on this page
+                        // IMPORTANT: FileMap.xml requires full paths like "Grids\PageName\1-5-0-text-0.png"
+                        buttonImages.forEach((imgData, buttonId) => {
+                            if (imgData.pageName === gridName && imgData.imageData.length > 0) {
+                                const imagePath = `Grids\\${gridName}\\${imgData.x}-${imgData.y}-0-text-0.${imgData.ext}`;
+                                imageFiles.push(imagePath);
+                            }
+                        });
+                        return {
+                            '@_StaticFile': gridPath,
+                            DynamicFiles: imageFiles.length > 0 ? {
+                                File: imageFiles
+                            } : {},
+                        };
+                    }),
+                },
+            },
+        };
+        const fileMapBuilder = new fast_xml_parser_1.XMLBuilder({
+            ignoreAttributes: false,
+            format: true,
+            indentBy: '  ',
+        });
+        const fileMapXmlContent = fileMapBuilder.build(fileMapData);
+        zip.addFile('FileMap.xml', Buffer.from(fileMapXmlContent, 'utf8'));
+        // Write the zip file
+        zip.writeZip(outputPath);
+    }
+    // Helper method to calculate column definitions based on page layout
+    calculateColumnDefinitions(page) {
+        let maxCols = 4; // Default minimum
+        if (page.grid && page.grid.length > 0) {
+            maxCols = Math.max(maxCols, page.grid[0]?.length || 0);
+        }
+        else {
+            // Fallback: estimate from button count
+            maxCols = Math.max(4, Math.ceil(Math.sqrt(page.buttons.length)));
+        }
+        return {
+            ColumnDefinition: Array(maxCols).fill({}),
+        };
+    }
+    // Helper method to calculate row definitions based on page layout
+    calculateRowDefinitions(page) {
+        let maxRows = 4; // Default minimum
+        if (page.grid && page.grid.length > 0) {
+            maxRows = Math.max(maxRows, page.grid.length);
+        }
+        else {
+            // Fallback: estimate from button count
+            const estimatedCols = Math.ceil(Math.sqrt(page.buttons.length));
+            maxRows = Math.max(4, Math.ceil(page.buttons.length / estimatedCols));
+        }
+        return {
+            RowDefinition: Array(maxRows).fill({}),
+        };
+    }
+    // Helper method to find button position with span information
+    findButtonPosition(page, button, fallbackIndex) {
+        if (page.grid && page.grid.length > 0) {
+            // Search for button in grid layout and calculate span
+            for (let y = 0; y < page.grid.length; y++) {
+                for (let x = 0; x < page.grid[y].length; x++) {
+                    const current = page.grid[y][x];
+                    if (current && current.id === button.id) {
+                        // Calculate span by checking how far the same button extends
+                        let columnSpan = 1;
+                        let rowSpan = 1;
+                        // Check column span (rightward)
+                        while (x + columnSpan < page.grid[y].length) {
+                            const right = page.grid[y][x + columnSpan];
+                            if (right && right.id === button.id) {
+                                columnSpan++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        // Check row span (downward)
+                        while (y + rowSpan < page.grid.length) {
+                            const below = page.grid[y + rowSpan][x];
+                            if (below && below.id === button.id) {
+                                rowSpan++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        return { x, y, columnSpan, rowSpan };
+                    }
+                }
+            }
+        }
+        // Fallback positioning
+        const gridCols = page.grid?.[0]?.length || Math.ceil(Math.sqrt(page.buttons.length));
+        return {
+            x: fallbackIndex % gridCols,
+            y: Math.floor(fallbackIndex / gridCols),
+            columnSpan: 1,
+            rowSpan: 1,
+        };
+    }
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    extractStringsWithMetadata(filePath) {
+        return this.extractStringsWithMetadataGeneric(filePath);
+    }
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    generateTranslatedDownload(filePath, translatedStrings, sourceStrings) {
+        return this.generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings);
+    }
+}
+exports.GridsetProcessor = GridsetProcessor;