@willwade/aac-processors 0.0.3

package/dist/processors/snapProcessor.d.ts

@@ -0,0 +1,44 @@
+import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString, SourceString } from '../core/baseProcessor';
+import { AACTree } from '../core/treeStructure';
+declare class SnapProcessor extends BaseProcessor {
+    private symbolResolver;
+    private loadAudio;
+    constructor(symbolResolver?: unknown | null, options?: ProcessorOptions & {
+        loadAudio?: boolean;
+    });
+    extractTexts(filePathOrBuffer: string | Buffer): string[];
+    loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;
+    processTexts(filePathOrBuffer: string | Buffer, translations: Map<string, string>, outputPath: string): Buffer;
+    saveFromTree(tree: AACTree, outputPath: string): void;
+    /**
+     * Add audio recording to a button in the database
+     */
+    addAudioToButton(dbPath: string, buttonId: number, audioData: Buffer, metadata?: string): number;
+    /**
+     * Create a copy of the pageset with audio recordings added
+     */
+    createAudioEnhancedPageset(sourceDbPath: string, targetDbPath: string, audioMappings: Map<number, {
+        audioData: Buffer;
+        metadata?: string;
+    }>): void;
+    /**
+     * Extract buttons from a specific page that need audio recordings
+     */
+    extractButtonsForAudio(dbPath: string, pageUniqueId: string): Array<{
+        id: number;
+        label: string;
+        message: string;
+        hasAudio: boolean;
+    }>;
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    extractStringsWithMetadata(filePath: string): Promise<ExtractStringsResult>;
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    generateTranslatedDownload(filePath: string, translatedStrings: TranslatedString[], sourceStrings: SourceString[]): Promise<string>;
+}
+export { SnapProcessor };

package/dist/processors/snapProcessor.js

@@ -0,0 +1,586 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+class SnapProcessor extends baseProcessor_1.BaseProcessor {
+    constructor(symbolResolver = null, options = {}) {
+        super(options);
+        this.symbolResolver = null;
+        this.loadAudio = false;
+        this.symbolResolver = symbolResolver;
+        this.loadAudio = options.loadAudio !== undefined ? options.loadAudio : true;
+    }
+    extractTexts(filePathOrBuffer) {
+        const tree = this.loadIntoTree(filePathOrBuffer);
+        const texts = [];
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            // Include page names
+            if (page.name)
+                texts.push(page.name);
+            // Include button texts
+            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();
+        const filePath = typeof filePathOrBuffer === 'string'
+            ? filePathOrBuffer
+            : path_1.default.join(process.cwd(), 'temp.spb');
+        if (Buffer.isBuffer(filePathOrBuffer)) {
+            fs_1.default.writeFileSync(filePath, filePathOrBuffer);
+        }
+        let db = null;
+        try {
+            db = new better_sqlite3_1.default(filePath, { readonly: true });
+            const getTableColumns = (tableName) => {
+                try {
+                    const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+                    return new Set(rows.map((row) => row.name));
+                }
+                catch {
+                    return new Set();
+                }
+            };
+            // Load pages first, using UniqueId as canonical id
+            const pages = db.prepare('SELECT * FROM Page').all();
+            // Map from numeric Id -> UniqueId for later lookup
+            const idToUniqueId = {};
+            pages.forEach((pageRow) => {
+                const uniqueId = String(pageRow.UniqueId || pageRow.Id);
+                idToUniqueId[String(pageRow.Id)] = uniqueId;
+                const page = new treeStructure_1.AACPage({
+                    id: uniqueId,
+                    name: pageRow.Title || pageRow.Name,
+                    grid: [],
+                    buttons: [],
+                    parentId: null, // ParentId will be set via navigation buttons below
+                    style: {
+                        backgroundColor: pageRow.BackgroundColor
+                            ? `#${pageRow.BackgroundColor.toString(16)}`
+                            : undefined,
+                    },
+                });
+                tree.addPage(page);
+            });
+            // 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();
+                try {
+                    const buttonColumns = getTableColumns('Button');
+                    const selectFields = [
+                        'b.Id',
+                        'b.Label',
+                        'b.Message',
+                        buttonColumns.has('LibrarySymbolId') ? 'b.LibrarySymbolId' : 'NULL AS LibrarySymbolId',
+                        buttonColumns.has('PageSetImageId') ? 'b.PageSetImageId' : 'NULL AS PageSetImageId',
+                        buttonColumns.has('BorderColor') ? 'b.BorderColor' : 'NULL AS BorderColor',
+                        buttonColumns.has('BorderThickness') ? 'b.BorderThickness' : 'NULL AS BorderThickness',
+                        buttonColumns.has('FontSize') ? 'b.FontSize' : 'NULL AS FontSize',
+                        buttonColumns.has('FontFamily') ? 'b.FontFamily' : 'NULL AS FontFamily',
+                        buttonColumns.has('FontStyle') ? 'b.FontStyle' : 'NULL AS FontStyle',
+                        buttonColumns.has('LabelColor') ? 'b.LabelColor' : 'NULL AS LabelColor',
+                        buttonColumns.has('BackgroundColor') ? 'b.BackgroundColor' : 'NULL AS BackgroundColor',
+                        buttonColumns.has('NavigatePageId') ? 'b.NavigatePageId' : 'NULL AS NavigatePageId',
+                    ];
+                    if (this.loadAudio) {
+                        selectFields.push(buttonColumns.has('MessageRecordingId')
+                            ? 'b.MessageRecordingId'
+                            : 'NULL AS MessageRecordingId');
+                        selectFields.push(buttonColumns.has('UseMessageRecording')
+                            ? 'b.UseMessageRecording'
+                            : 'NULL AS UseMessageRecording');
+                        selectFields.push(buttonColumns.has('SerializedMessageSoundMetadata')
+                            ? 'b.SerializedMessageSoundMetadata'
+                            : 'NULL AS SerializedMessageSoundMetadata');
+                    }
+                    selectFields.push('ep.GridPosition', '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 = ?
+          `;
+                    buttons = db.prepare(buttonQuery).all(pageRow.Id);
+                }
+                catch (err) {
+                    const errorMessage = err instanceof Error ? err.message : String(err);
+                    const errorCode = err && typeof err === 'object' && 'code' in err ? err.code : undefined;
+                    if (errorCode === 'SQLITE_CORRUPT' ||
+                        errorCode === 'SQLITE_NOTADB' ||
+                        /malformed/i.test(errorMessage)) {
+                        throw new Error(`Snap database is corrupted or incomplete: ${errorMessage}`);
+                    }
+                    console.warn(`Failed to load buttons for page ${pageRow.Id}: ${errorMessage}`);
+                    // Skip this page instead of loading all buttons
+                    buttons = [];
+                }
+                const uniqueId = String(pageRow.UniqueId || pageRow.Id);
+                const page = tree.getPage(uniqueId);
+                if (!page) {
+                    continue;
+                }
+                // Initialize page grid if not exists (assume max 10x10 grid)
+                if (!pageGrids.has(uniqueId)) {
+                    const grid = [];
+                    for (let r = 0; r < 10; r++) {
+                        grid[r] = new Array(10).fill(null);
+                    }
+                    pageGrids.set(uniqueId, grid);
+                }
+                const pageGrid = pageGrids.get(uniqueId);
+                if (!pageGrid)
+                    continue;
+                buttons.forEach((btnRow) => {
+                    // Determine navigation target UniqueId, if possible
+                    let targetPageUniqueId = undefined;
+                    if (btnRow.NavigatePageId && idToUniqueId[String(btnRow.NavigatePageId)]) {
+                        targetPageUniqueId = idToUniqueId[String(btnRow.NavigatePageId)];
+                    }
+                    else if (btnRow.PageUniqueId) {
+                        targetPageUniqueId = String(btnRow.PageUniqueId);
+                    }
+                    // Determine parent page association for this button
+                    const parentPageId = btnRow.ButtonPageId ? String(btnRow.ButtonPageId) : undefined;
+                    const parentUniqueId = parentPageId && idToUniqueId[parentPageId] ? idToUniqueId[parentPageId] : uniqueId;
+                    // Load audio recording if requested and available
+                    let audioRecording;
+                    if (this.loadAudio && btnRow.MessageRecordingId && btnRow.MessageRecordingId > 0) {
+                        try {
+                            const recordingData = db
+                                .prepare(`
+                SELECT Id, Identifier, Data FROM PageSetData WHERE Id = ?
+              `)
+                                .get(btnRow.MessageRecordingId);
+                            if (recordingData) {
+                                audioRecording = {
+                                    id: recordingData.Id,
+                                    data: recordingData.Data,
+                                    identifier: recordingData.Identifier,
+                                    metadata: btnRow.SerializedMessageSoundMetadata || undefined,
+                                };
+                            }
+                        }
+                        catch (e) {
+                            console.warn(`[SnapProcessor] Failed to load audio for button ${btnRow.Id}:`, e);
+                        }
+                    }
+                    // Create semantic action for Snap button
+                    let semanticAction;
+                    let legacyAction = null;
+                    if (targetPageUniqueId) {
+                        semanticAction = {
+                            category: treeStructure_1.AACSemanticCategory.NAVIGATION,
+                            intent: treeStructure_1.AACSemanticIntent.NAVIGATE_TO,
+                            targetId: targetPageUniqueId,
+                            platformData: {
+                                snap: {
+                                    navigatePageId: btnRow.NavigatePageId,
+                                    elementReferenceId: btnRow.Id,
+                                },
+                            },
+                            fallback: {
+                                type: 'NAVIGATE',
+                                targetPageId: targetPageUniqueId,
+                            },
+                        };
+                        legacyAction = {
+                            type: 'NAVIGATE',
+                            targetPageId: targetPageUniqueId,
+                        };
+                    }
+                    else {
+                        semanticAction = {
+                            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                            intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                            text: btnRow.Message || btnRow.Label || '',
+                            platformData: {
+                                snap: {
+                                    elementReferenceId: btnRow.Id,
+                                },
+                            },
+                            fallback: {
+                                type: 'SPEAK',
+                                message: btnRow.Message || btnRow.Label || '',
+                            },
+                        };
+                    }
+                    const button = new treeStructure_1.AACButton({
+                        id: String(btnRow.Id),
+                        label: btnRow.Label || '',
+                        message: btnRow.Message || btnRow.Label || '',
+                        targetPageId: targetPageUniqueId,
+                        semanticAction: semanticAction,
+                        audioRecording: audioRecording,
+                        style: {
+                            backgroundColor: btnRow.BackgroundColor
+                                ? `#${btnRow.BackgroundColor.toString(16)}`
+                                : undefined,
+                            borderColor: btnRow.BorderColor ? `#${btnRow.BorderColor.toString(16)}` : undefined,
+                            borderWidth: btnRow.BorderThickness,
+                            fontColor: btnRow.LabelColor ? `#${btnRow.LabelColor.toString(16)}` : undefined,
+                            fontSize: btnRow.FontSize,
+                            fontFamily: btnRow.FontFamily,
+                            fontStyle: btnRow.FontStyle?.toString(),
+                        },
+                    });
+                    // Add to the intended parent page
+                    const parentPage = tree.getPage(parentUniqueId);
+                    if (parentPage) {
+                        parentPage.addButton(button);
+                        // Add button to grid layout if position data is available
+                        const gridPositionStr = String(btnRow.GridPosition || '');
+                        if (gridPositionStr && gridPositionStr.includes(',')) {
+                            // Parse comma-separated coordinates "x,y"
+                            const [xStr, yStr] = gridPositionStr.split(',');
+                            const gridX = parseInt(xStr, 10);
+                            const gridY = parseInt(yStr, 10);
+                            // Place button in grid if within bounds and coordinates are valid
+                            if (!isNaN(gridX) &&
+                                !isNaN(gridY) &&
+                                gridX >= 0 &&
+                                gridY >= 0 &&
+                                gridY < 10 &&
+                                gridX < 10 &&
+                                pageGrid[gridY] &&
+                                pageGrid[gridY][gridX] === null) {
+                                pageGrid[gridY][gridX] = button;
+                            }
+                        }
+                    }
+                    // If this is a navigation button, update the target page's parentId
+                    if (targetPageUniqueId) {
+                        const targetPage = tree.getPage(targetPageUniqueId);
+                        if (targetPage) {
+                            targetPage.parentId = parentUniqueId;
+                        }
+                    }
+                });
+                // Set grid layout for the current page
+                const currentPage = tree.getPage(uniqueId);
+                if (currentPage && pageGrid) {
+                    currentPage.grid = pageGrid;
+                }
+            }
+            return tree;
+        }
+        catch (error) {
+            // Provide more specific error messages
+            if (error.code === 'SQLITE_NOTADB') {
+                throw new Error(`Invalid SQLite database file: ${typeof filePathOrBuffer === 'string' ? filePathOrBuffer : 'buffer'}`);
+            }
+            else if (error.code === 'ENOENT') {
+                throw new Error(`File not found: ${filePathOrBuffer}`);
+            }
+            else if (error.code === 'EACCES') {
+                throw new Error(`Permission denied accessing file: ${filePathOrBuffer}`);
+            }
+            else {
+                throw new Error(`Failed to load Snap file: ${error.message}`);
+            }
+        }
+        finally {
+            // Ensure database is closed
+            if (db) {
+                db.close();
+            }
+            // Clean up temporary file if created from buffer
+            if (Buffer.isBuffer(filePathOrBuffer) && fs_1.default.existsSync(filePath)) {
+                try {
+                    fs_1.default.unlinkSync(filePath);
+                }
+                catch (e) {
+                    console.warn('Failed to clean up temporary file:', e);
+                }
+            }
+        }
+    }
+    processTexts(filePathOrBuffer, translations, outputPath) {
+        // Load the tree, apply translations, and save to new file
+        const tree = this.loadIntoTree(filePathOrBuffer);
+        // Apply translations to all text content
+        Object.values(tree.pages).forEach((page) => {
+            // Translate page names
+            if (page.name && translations.has(page.name)) {
+                page.name = translations.get(page.name);
+            }
+            // Translate button labels and messages
+            page.buttons.forEach((button) => {
+                if (button.label && translations.has(button.label)) {
+                    button.label = translations.get(button.label);
+                }
+                if (button.message && translations.has(button.message)) {
+                    button.message = translations.get(button.message);
+                }
+            });
+        });
+        // Save the translated tree and return its content
+        this.saveFromTree(tree, outputPath);
+        return fs_1.default.readFileSync(outputPath);
+    }
+    saveFromTree(tree, outputPath) {
+        const outputDir = path_1.default.dirname(outputPath);
+        if (!fs_1.default.existsSync(outputDir)) {
+            fs_1.default.mkdirSync(outputDir, { recursive: true });
+        }
+        if (fs_1.default.existsSync(outputPath)) {
+            fs_1.default.unlinkSync(outputPath);
+        }
+        // Create a new SQLite database for Snap format
+        const db = new better_sqlite3_1.default(outputPath, { readonly: false });
+        try {
+            // Create basic Snap database schema (simplified)
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS Page (
+          Id INTEGER PRIMARY KEY,
+          UniqueId TEXT UNIQUE,
+          Title TEXT,
+          Name TEXT,
+          BackgroundColor INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS Button (
+          Id INTEGER PRIMARY KEY,
+          Label TEXT,
+          Message TEXT,
+          NavigatePageId INTEGER,
+          ElementReferenceId INTEGER,
+          LibrarySymbolId INTEGER,
+          PageSetImageId INTEGER,
+          MessageRecordingId INTEGER,
+          SerializedMessageSoundMetadata TEXT,
+          UseMessageRecording INTEGER,
+          LabelColor INTEGER,
+          BackgroundColor INTEGER,
+          BorderColor INTEGER,
+          BorderThickness REAL,
+          FontSize REAL,
+          FontFamily TEXT,
+          FontStyle INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS ElementReference (
+          Id INTEGER PRIMARY KEY,
+          PageId INTEGER,
+          FOREIGN KEY (PageId) REFERENCES Page (Id)
+        );
+
+        CREATE TABLE IF NOT EXISTS ElementPlacement (
+          Id INTEGER PRIMARY KEY,
+          ElementReferenceId INTEGER,
+          GridPosition TEXT,
+          FOREIGN KEY (ElementReferenceId) REFERENCES ElementReference (Id)
+        );
+
+        CREATE TABLE IF NOT EXISTS PageSetData (
+          Id INTEGER PRIMARY KEY,
+          Identifier TEXT UNIQUE,
+          Data BLOB,
+          RefCount INTEGER DEFAULT 1
+        );
+      `);
+            // Insert pages
+            let pageIdCounter = 1;
+            let buttonIdCounter = 1;
+            let elementRefIdCounter = 1;
+            let placementIdCounter = 1;
+            let pageSetDataIdCounter = 1;
+            const pageIdMap = new Map();
+            const pageSetDataIdentifierMap = new Map();
+            const insertPageSetData = db.prepare('INSERT INTO PageSetData (Id, Identifier, Data, RefCount) VALUES (?, ?, ?, ?)');
+            const incrementRefCount = db.prepare('UPDATE PageSetData SET RefCount = RefCount + 1 WHERE Id = ?');
+            // First pass: create all pages
+            Object.values(tree.pages).forEach((page) => {
+                const numericPageId = pageIdCounter++;
+                pageIdMap.set(page.id, numericPageId);
+                const insertPage = db.prepare('INSERT INTO Page (Id, UniqueId, Title, Name, BackgroundColor) VALUES (?, ?, ?, ?, ?)');
+                insertPage.run(numericPageId, page.id, page.name || '', page.name || '', page.style?.backgroundColor
+                    ? parseInt(page.style.backgroundColor.replace('#', ''), 16)
+                    : null);
+            });
+            // Second pass: create buttons with proper page references
+            Object.values(tree.pages).forEach((page) => {
+                const numericPageId = pageIdMap.get(page.id);
+                page.buttons.forEach((button, index) => {
+                    // Find button position in grid layout
+                    let gridPosition = `${index % 4},${Math.floor(index / 4)}`; // Default fallback
+                    if (page.grid && page.grid.length > 0) {
+                        // Search for button in grid layout
+                        for (let y = 0; y < page.grid.length; y++) {
+                            for (let x = 0; x < page.grid[y].length; x++) {
+                                const gridButton = page.grid[y][x];
+                                if (gridButton && gridButton.id === button.id) {
+                                    // Convert grid coordinates to comma-separated format
+                                    gridPosition = `${x},${y}`;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    const elementRefId = elementRefIdCounter++;
+                    // Insert ElementReference
+                    const insertElementRef = db.prepare('INSERT INTO ElementReference (Id, PageId) VALUES (?, ?)');
+                    insertElementRef.run(elementRefId, numericPageId);
+                    // Insert Button - handle semantic actions
+                    let navigatePageId = null;
+                    // Use semantic action if available
+                    if (button.semanticAction?.intent === treeStructure_1.AACSemanticIntent.NAVIGATE_TO) {
+                        const targetId = button.semanticAction.targetId || button.targetPageId;
+                        navigatePageId = targetId ? pageIdMap.get(targetId) || null : null;
+                    }
+                    const insertButton = db.prepare('INSERT INTO Button (Id, Label, Message, NavigatePageId, ElementReferenceId, LibrarySymbolId, PageSetImageId, MessageRecordingId, SerializedMessageSoundMetadata, UseMessageRecording, LabelColor, BackgroundColor, BorderColor, BorderThickness, FontSize, FontFamily, FontStyle) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+                    const audio = button.audioRecording;
+                    let messageRecordingId = null;
+                    let serializedMetadata = null;
+                    let useMessageRecording = 0;
+                    if (audio && Buffer.isBuffer(audio.data) && audio.data.length > 0) {
+                        const identifier = audio.identifier && audio.identifier.trim().length > 0
+                            ? audio.identifier.trim()
+                            : `audio_${buttonIdCounter}`;
+                        let audioId = pageSetDataIdentifierMap.get(identifier);
+                        if (!audioId) {
+                            audioId = pageSetDataIdCounter++;
+                            insertPageSetData.run(audioId, identifier, audio.data, 1);
+                            pageSetDataIdentifierMap.set(identifier, audioId);
+                        }
+                        else {
+                            incrementRefCount.run(audioId);
+                        }
+                        messageRecordingId = audioId;
+                        serializedMetadata = audio.metadata || null;
+                        useMessageRecording = 1;
+                    }
+                    insertButton.run(buttonIdCounter++, button.label || '', button.message || button.label || '', navigatePageId, elementRefId, null, null, messageRecordingId, serializedMetadata, useMessageRecording, button.style?.fontColor ? parseInt(button.style.fontColor.replace('#', ''), 16) : null, button.style?.backgroundColor
+                        ? parseInt(button.style.backgroundColor.replace('#', ''), 16)
+                        : null, button.style?.borderColor
+                        ? parseInt(button.style.borderColor.replace('#', ''), 16)
+                        : null, button.style?.borderWidth, button.style?.fontSize, button.style?.fontFamily, button.style?.fontStyle ? parseInt(button.style.fontStyle) : null);
+                    // Insert ElementPlacement
+                    const insertPlacement = db.prepare('INSERT INTO ElementPlacement (Id, ElementReferenceId, GridPosition) VALUES (?, ?, ?)');
+                    insertPlacement.run(placementIdCounter++, elementRefId, gridPosition);
+                });
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Add audio recording to a button in the database
+     */
+    addAudioToButton(dbPath, buttonId, audioData, metadata) {
+        const db = new better_sqlite3_1.default(dbPath, { fileMustExist: true });
+        try {
+            // Ensure PageSetData table exists
+            db.exec(`
+            CREATE TABLE IF NOT EXISTS PageSetData (
+                Id INTEGER PRIMARY KEY,
+                Identifier TEXT UNIQUE,
+                Data BLOB
+            );
+        `);
+            // Generate SHA1 hash for the identifier
+            const sha1Hash = crypto_1.default.createHash('sha1').update(audioData).digest('hex');
+            const identifier = `SND:${sha1Hash}`;
+            // Check if audio with this identifier already exists
+            let audioId;
+            const existingAudio = db
+                .prepare('SELECT Id FROM PageSetData WHERE Identifier = ?')
+                .get(identifier);
+            if (existingAudio) {
+                audioId = existingAudio.Id;
+            }
+            else {
+                // Insert new audio data
+                const result = db
+                    .prepare('INSERT INTO PageSetData (Identifier, Data) VALUES (?, ?)')
+                    .run(identifier, audioData);
+                audioId = Number(result.lastInsertRowid);
+            }
+            // Update button to reference the audio
+            const updateButton = db.prepare('UPDATE Button SET MessageRecordingId = ?, UseMessageRecording = 1, SerializedMessageSoundMetadata = ? WHERE Id = ?');
+            const metadataJson = metadata ? JSON.stringify({ FileName: metadata }) : null;
+            updateButton.run(audioId, metadataJson, buttonId);
+            return audioId;
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Create a copy of the pageset with audio recordings added
+     */
+    createAudioEnhancedPageset(sourceDbPath, targetDbPath, audioMappings) {
+        // Copy the source database to target
+        fs_1.default.copyFileSync(sourceDbPath, targetDbPath);
+        // Add audio recordings to the copy
+        audioMappings.forEach((audioInfo, buttonId) => {
+            this.addAudioToButton(targetDbPath, buttonId, audioInfo.audioData, audioInfo.metadata);
+        });
+    }
+    /**
+     * Extract buttons from a specific page that need audio recordings
+     */
+    extractButtonsForAudio(dbPath, pageUniqueId) {
+        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        try {
+            // Find the page by UniqueId
+            const page = db.prepare('SELECT * FROM Page WHERE UniqueId = ?').get(pageUniqueId);
+            if (!page) {
+                throw new Error(`Page with UniqueId ${pageUniqueId} not found`);
+            }
+            // Get buttons for this page
+            const buttons = db
+                .prepare(`
+        SELECT
+          b.Id, b.Label, b.Message, b.MessageRecordingId, b.UseMessageRecording
+        FROM Button b
+        JOIN ElementReference er ON b.ElementReferenceId = er.Id
+        WHERE er.PageId = ?
+      `)
+                .all(page.Id);
+            return buttons.map((btn) => ({
+                id: btn.Id,
+                label: btn.Label || '',
+                message: btn.Message || btn.Label || '',
+                hasAudio: !!(btn.MessageRecordingId && btn.MessageRecordingId > 0),
+            }));
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    async extractStringsWithMetadata(filePath) {
+        return this.extractStringsWithMetadataGeneric(filePath);
+    }
+    /**
+     * Generate translated download for aac-tools-platform compatibility
+     * Uses the generic implementation from BaseProcessor
+     */
+    async generateTranslatedDownload(filePath, translatedStrings, sourceStrings) {
+        return this.generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings);
+    }
+}
+exports.SnapProcessor = SnapProcessor;

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

@@ -0,0 +1,4 @@
+import { AACTree } from '../../core/treeStructure';
+export declare function getPageTokenImageMap(tree: AACTree, pageId: string): Map<string, string>;
+export declare function getAllowedImageEntries(_tree: AACTree): Set<string>;
+export declare function openImage(_ceFile: string | Buffer, _entryPath: string): Buffer | null;

package/dist/processors/touchchat/helpers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageTokenImageMap = getPageTokenImageMap;
+exports.getAllowedImageEntries = getAllowedImageEntries;
+exports.openImage = openImage;
+// Minimal TouchChat helpers (stubs) to align with processors/<engine>/helpers pattern
+// NOTE: TouchChat buttons currently do not populate resolvedImageEntry; these helpers
+// therefore return empty collections until image resolution is implemented.
+function getPageTokenImageMap(tree, pageId) {
+    const map = new Map();
+    const page = tree.getPage(pageId);
+    if (!page)
+        return map;
+    for (const btn of page.buttons) {
+        if (btn.resolvedImageEntry)
+            map.set(btn.id, String(btn.resolvedImageEntry));
+    }
+    return map;
+}
+function getAllowedImageEntries(_tree) {
+    // No known image entry paths for TouchChat yet
+    return new Set();
+}
+function openImage(_ceFile, _entryPath) {
+    // Not implemented for TouchChat yet
+    return null;
+}