@willwade/aac-processors 0.0.13 → 0.0.15

package/dist/processors/gridset/symbolAlignment.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Symbol Alignment for Translation
+ *
+ * Utilities to preserve symbol positions during text translation.
+ * When translating AAC gridset messages that contain symbols attached
+ * to specific words, we need to maintain the symbol-to-word associations
+ * across languages.
+ *
+ * Example:
+ *   English: "I want apple juice" with apple symbol on "apple"
+ *   Spanish: "Yo quiero jugo de manzana" with apple symbol on "manzana"
+ */
+/**
+ * Represents a symbol anchored to a specific word in the text
+ */
+export interface SymbolAnchor {
+    symbolRef: string;
+    wordIndex: number;
+    originalWord: string;
+    startPos: number;
+    endPos: number;
+}
+/**
+ * Parsed message with symbol anchors
+ */
+export interface ParsedMessage {
+    text: string;
+    words: string[];
+    symbols: SymbolAnchor[];
+}
+/**
+ * Translation result with preserved symbols
+ */
+export interface TranslatedMessage {
+    text: string;
+    alignment: {
+        originalWord: string;
+        translatedWord: string;
+        originalIndex: number;
+        translatedIndex: number;
+    }[];
+}
+/**
+ * Parse a message to extract text and symbol anchors.
+ *
+ * This handles various formats:
+ * 1. Plain text with no symbols
+ * 2. Rich text with embedded symbol markers (future enhancement)
+ * 3. Text where symbols are tracked separately (via richText.symbols)
+ *
+ * For now, this assumes symbols are tracked separately in the richText structure.
+ * The text itself is plain, and we need to tokenize it to find word positions.
+ *
+ * @param message - The message text (may contain words or be plain)
+ * @param richTextSymbols - Optional symbols from richText.symbols array
+ * @returns Parsed message with word positions and symbol anchors
+ */
+export declare function parseMessageWithSymbols(message: string, richTextSymbols?: Array<{
+    text: string;
+    image?: string;
+}>): ParsedMessage;
+/**
+ * Align words from original text to translated text.
+ *
+ * This is a simple alignment strategy that works for many cases:
+ * 1. Exact word matching (for cognates, names, numbers)
+ * 2. Position-based alignment (assumes similar word order)
+ *
+ * For more accurate alignment, you could integrate with:
+ * - Translation APIs that return alignment (e.g., Google Translate's word alignment)
+ * - Statistical machine translation alignment tools
+ * - Bilingual dictionaries
+ *
+ * @param originalWords - Words from the original text
+ * @param translatedWords - Words from the translated text
+ * @returns Alignment mapping between original and translated word indices
+ */
+export declare function alignWords(originalWords: string[], translatedWords: string[]): TranslatedMessage['alignment'];
+/**
+ * Reattach symbols to translated text based on word alignment.
+ *
+ * @param translatedText - The translated plain text
+ * @param originalParsed - The original parsed message with symbols
+ * @param alignment - Word alignment between original and translation
+ * @returns Translated text with symbols embedded (as rich text structure)
+ */
+export declare function reattachSymbols(translatedText: string, originalParsed: ParsedMessage, alignment: TranslatedMessage['alignment']): {
+    text: string;
+    richTextSymbols: Array<{
+        text: string;
+        image?: string;
+    }>;
+};
+/**
+ * Complete pipeline: translate a message while preserving symbol positions.
+ *
+ * @param originalMessage - The original message text
+ * @param translatedText - The translated text (from translation API)
+ * @param richTextSymbols - Original symbols from richText.symbols
+ * @returns Object with translated text and aligned symbols
+ */
+export declare function translateWithSymbols(originalMessage: string, translatedText: string, richTextSymbols?: Array<{
+    text: string;
+    image?: string;
+}>): {
+    text: string;
+    richTextSymbols: Array<{
+        text: string;
+        image?: string;
+    }>;
+};
+/**
+ * Extract symbols from a button for use during translation.
+ *
+ * This helper extracts symbols from either:
+ * - button.semanticAction.richText.symbols
+ * - button.image (if it's a symbol library reference)
+ *
+ * @param button - The AAC button
+ * @returns Array of symbol attachments
+ */
+export declare function extractSymbolsFromButton(button: any): Array<{
+    text: string;
+    image?: string;
+}> | undefined;

package/dist/processors/gridset/symbolAlignment.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Symbol Alignment for Translation
+ *
+ * Utilities to preserve symbol positions during text translation.
+ * When translating AAC gridset messages that contain symbols attached
+ * to specific words, we need to maintain the symbol-to-word associations
+ * across languages.
+ *
+ * Example:
+ *   English: "I want apple juice" with apple symbol on "apple"
+ *   Spanish: "Yo quiero jugo de manzana" with apple symbol on "manzana"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMessageWithSymbols = parseMessageWithSymbols;
+exports.alignWords = alignWords;
+exports.reattachSymbols = reattachSymbols;
+exports.translateWithSymbols = translateWithSymbols;
+exports.extractSymbolsFromButton = extractSymbolsFromButton;
+/**
+ * Parse a message to extract text and symbol anchors.
+ *
+ * This handles various formats:
+ * 1. Plain text with no symbols
+ * 2. Rich text with embedded symbol markers (future enhancement)
+ * 3. Text where symbols are tracked separately (via richText.symbols)
+ *
+ * For now, this assumes symbols are tracked separately in the richText structure.
+ * The text itself is plain, and we need to tokenize it to find word positions.
+ *
+ * @param message - The message text (may contain words or be plain)
+ * @param richTextSymbols - Optional symbols from richText.symbols array
+ * @returns Parsed message with word positions and symbol anchors
+ */
+function parseMessageWithSymbols(message, richTextSymbols) {
+    // Normalize whitespace for consistent tokenization
+    const normalizedMessage = message.trim().replace(/\s+/g, ' ');
+    // Tokenize into words, preserving punctuation
+    const words = [];
+    const wordPositions = [];
+    // Split by whitespace but track positions
+    let currentPos = 0;
+    const parts = normalizedMessage.split(/(\s+)/); // Keep delimiters
+    for (const part of parts) {
+        if (part.trim().length > 0) {
+            // This is a word
+            const startPos = currentPos;
+            const endPos = currentPos + part.length;
+            words.push(part);
+            wordPositions.push({ start: startPos, end: endPos, word: part });
+            currentPos = endPos;
+        }
+        else {
+            // This is whitespace
+            currentPos += part.length;
+        }
+    }
+    // Extract symbol anchors from richText.symbols if provided
+    const symbols = [];
+    if (richTextSymbols && richTextSymbols.length > 0) {
+        for (const sym of richTextSymbols) {
+            // Find which word this symbol is attached to
+            const wordIndex = words.findIndex((w) => w === sym.text);
+            if (wordIndex !== -1) {
+                const pos = wordPositions[wordIndex];
+                symbols.push({
+                    symbolRef: sym.image || '',
+                    wordIndex,
+                    originalWord: sym.text,
+                    startPos: pos.start,
+                    endPos: pos.end,
+                });
+            }
+            else {
+                // Fuzzy match - find closest word (handles case differences, punctuation)
+                const normalizedSymText = sym.text.toLowerCase().replace(/[^\w]/g, '');
+                const fuzzyIndex = words.findIndex((w) => w.toLowerCase().replace(/[^\w]/g, '') === normalizedSymText);
+                if (fuzzyIndex !== -1) {
+                    const pos = wordPositions[fuzzyIndex];
+                    symbols.push({
+                        symbolRef: sym.image || '',
+                        wordIndex: fuzzyIndex,
+                        originalWord: words[fuzzyIndex],
+                        startPos: pos.start,
+                        endPos: pos.end,
+                    });
+                }
+            }
+        }
+    }
+    return {
+        text: normalizedMessage,
+        words,
+        symbols,
+    };
+}
+/**
+ * Align words from original text to translated text.
+ *
+ * This is a simple alignment strategy that works for many cases:
+ * 1. Exact word matching (for cognates, names, numbers)
+ * 2. Position-based alignment (assumes similar word order)
+ *
+ * For more accurate alignment, you could integrate with:
+ * - Translation APIs that return alignment (e.g., Google Translate's word alignment)
+ * - Statistical machine translation alignment tools
+ * - Bilingual dictionaries
+ *
+ * @param originalWords - Words from the original text
+ * @param translatedWords - Words from the translated text
+ * @returns Alignment mapping between original and translated word indices
+ */
+function alignWords(originalWords, translatedWords) {
+    const alignment = [];
+    // Strategy 1: Try to match identical words (numbers, names, cognates)
+    const matchedTranslatedIndices = new Set();
+    for (let origIdx = 0; origIdx < originalWords.length; origIdx++) {
+        const origWord = originalWords[origIdx];
+        const normalizedOrig = origWord.toLowerCase().replace(/[^\w]/g, '');
+        // Try to find this word in the translation
+        for (let transIdx = 0; transIdx < translatedWords.length; transIdx++) {
+            if (matchedTranslatedIndices.has(transIdx))
+                continue;
+            const transWord = translatedWords[transIdx];
+            const normalizedTrans = transWord.toLowerCase().replace(/[^\w]/g, '');
+            // Exact match (case-insensitive, ignoring punctuation)
+            if (normalizedOrig === normalizedTrans && normalizedOrig.length > 0) {
+                alignment.push({
+                    originalWord: origWord,
+                    translatedWord: transWord,
+                    originalIndex: origIdx,
+                    translatedIndex: transIdx,
+                });
+                matchedTranslatedIndices.add(transIdx);
+                break;
+            }
+        }
+    }
+    // Strategy 2: For unmatched words, use positional alignment
+    // This is a simple fallback that assumes similar word order
+    for (let origIdx = 0; origIdx < originalWords.length; origIdx++) {
+        if (alignment.find((a) => a.originalIndex === origIdx))
+            continue; // Already matched
+        // Find the closest unmatched position in translation
+        let bestTransIdx = -1;
+        let minDistance = Infinity;
+        for (let transIdx = 0; transIdx < translatedWords.length; transIdx++) {
+            if (matchedTranslatedIndices.has(transIdx))
+                continue;
+            // Calculate relative position
+            const relativeOrigPos = origIdx / originalWords.length;
+            const relativeTransPos = transIdx / translatedWords.length;
+            const distance = Math.abs(relativeOrigPos - relativeTransPos);
+            if (distance < minDistance) {
+                minDistance = distance;
+                bestTransIdx = transIdx;
+            }
+        }
+        if (bestTransIdx !== -1) {
+            alignment.push({
+                originalWord: originalWords[origIdx],
+                translatedWord: translatedWords[bestTransIdx],
+                originalIndex: origIdx,
+                translatedIndex: bestTransIdx,
+            });
+            matchedTranslatedIndices.add(bestTransIdx);
+        }
+    }
+    return alignment;
+}
+/**
+ * Reattach symbols to translated text based on word alignment.
+ *
+ * @param translatedText - The translated plain text
+ * @param originalParsed - The original parsed message with symbols
+ * @param alignment - Word alignment between original and translation
+ * @returns Translated text with symbols embedded (as rich text structure)
+ */
+function reattachSymbols(translatedText, originalParsed, alignment) {
+    // Tokenize the translated text
+    const translatedWords = translatedText
+        .trim()
+        .replace(/\s+/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 0);
+    // Create the rich text symbols array
+    const richTextSymbols = [];
+    for (const symbol of originalParsed.symbols) {
+        // Find the alignment for this word
+        const wordAlignment = alignment.find((a) => a.originalIndex === symbol.wordIndex);
+        if (wordAlignment && wordAlignment.translatedIndex < translatedWords.length) {
+            const translatedWord = translatedWords[wordAlignment.translatedIndex];
+            // Attach the symbol to the translated word
+            richTextSymbols.push({
+                text: translatedWord,
+                image: symbol.symbolRef,
+            });
+        }
+        else {
+            // Fallback: keep symbol on original word if no alignment found
+            richTextSymbols.push({
+                text: symbol.originalWord,
+                image: symbol.symbolRef,
+            });
+        }
+    }
+    return {
+        text: translatedText,
+        richTextSymbols,
+    };
+}
+/**
+ * Complete pipeline: translate a message while preserving symbol positions.
+ *
+ * @param originalMessage - The original message text
+ * @param translatedText - The translated text (from translation API)
+ * @param richTextSymbols - Original symbols from richText.symbols
+ * @returns Object with translated text and aligned symbols
+ */
+function translateWithSymbols(originalMessage, translatedText, richTextSymbols) {
+    // Step 1: Parse original message
+    const parsedOriginal = parseMessageWithSymbols(originalMessage, richTextSymbols);
+    // If no symbols, return as-is
+    if (parsedOriginal.symbols.length === 0) {
+        return {
+            text: translatedText,
+            richTextSymbols: [],
+        };
+    }
+    // Step 2: Tokenize translated text
+    const translatedWords = translatedText
+        .trim()
+        .replace(/\s+/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 0);
+    // Step 3: Align words
+    const alignment = alignWords(parsedOriginal.words, translatedWords);
+    // Step 4: Reattach symbols
+    const result = reattachSymbols(translatedText, parsedOriginal, alignment);
+    return result;
+}
+/**
+ * Extract symbols from a button for use during translation.
+ *
+ * This helper extracts symbols from either:
+ * - button.semanticAction.richText.symbols
+ * - button.image (if it's a symbol library reference)
+ *
+ * @param button - The AAC button
+ * @returns Array of symbol attachments
+ */
+function extractSymbolsFromButton(button) {
+    // First check richText structure
+    if (button.semanticAction?.richText?.symbols) {
+        return button.semanticAction.richText.symbols;
+    }
+    // Check if button has a symbol library reference as image
+    if (button.symbolLibrary && button.symbolPath) {
+        // Create a symbol attachment for the label/message
+        const text = button.label || button.message || '';
+        if (text) {
+            return [
+                {
+                    text,
+                    image: `[${button.symbolLibrary}]${button.symbolPath}`,
+                },
+            ];
+        }
+    }
+    // Check if image field contains a symbol reference
+    if (button.image && button.image.startsWith('[')) {
+        const text = button.label || button.message || '';
+        if (text) {
+            return [
+                {
+                    text,
+                    image: button.image,
+                },
+            ];
+        }
+    }
+    return undefined;
+}

package/dist/processors/gridsetProcessor.d.ts

@@ -1,5 +1,6 @@
 import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString, SourceString } from '../core/baseProcessor';
 import { AACTree } from '../core/treeStructure';
+import { type ButtonForTranslation, type LLMLTranslationResult } from '../utilities/translation/translationProcessor';
 import { ValidationResult } from '../validation/validationTypes';
 declare class GridsetProcessor extends BaseProcessor {
     constructor(options?: ProcessorOptions);
@@ -18,6 +19,31 @@ declare class GridsetProcessor extends BaseProcessor {
     extractTexts(filePathOrBuffer: string | Buffer): string[];
     loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;
     processTexts(filePathOrBuffer: string | Buffer, translations: Map<string, string>, outputPath: string): Buffer;
+    /**
+     * Extract symbol information from a gridset for LLM-based translation.
+     * Returns a structured format showing which buttons have symbols and their context.
+     *
+     * This method uses shared translation utilities that work across all AAC formats.
+     *
+     * @param filePathOrBuffer - Path to gridset file or buffer
+     * @returns Array of symbol information for LLM processing
+     */
+    extractSymbolsForLLM(filePathOrBuffer: string | Buffer): ButtonForTranslation[];
+    /**
+     * Apply LLM translations with symbol information.
+     * The LLM should provide translations with symbol attachments in the correct positions.
+     *
+     * This method uses shared translation utilities that work across all AAC formats.
+     *
+     * @param filePathOrBuffer - Path to gridset file or buffer
+     * @param llmTranslations - Array of LLM translations with symbol info
+     * @param outputPath - Where to save the translated gridset
+     * @param options - Translation options (e.g., allowPartial for testing)
+     * @returns Buffer of the translated gridset
+     */
+    processLLMTranslations(filePathOrBuffer: string | Buffer, llmTranslations: LLMLTranslationResult[], outputPath: string, options?: {
+        allowPartial?: boolean;
+    }): Buffer;
     saveFromTree(tree: AACTree, outputPath: string): void;
     private calculateColumnDefinitions;
     private calculateRowDefinitions;

package/dist/processors/gridsetProcessor.js

@@ -10,6 +10,7 @@ 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");
+const translationProcessor_1 = require("../utilities/translation/translationProcessor");
 const password_1 = require("./gridset/password");
 const crypto_1 = __importDefault(require("crypto"));
 const zlib_1 = __importDefault(require("zlib"));
@@ -19,7 +20,8 @@ const pluginTypes_1 = require("./gridset/pluginTypes");
 const commands_1 = require("./gridset/commands");
 const symbols_1 = require("./gridset/symbols");
 const resolver_2 = require("./gridset/resolver");
-const idGenerator_1 = require("../optional/analytics/utils/idGenerator");
+const idGenerator_1 = require("../utilities/analytics/utils/idGenerator");
+const symbolAlignment_1 = require("./gridset/symbolAlignment");
 class GridsetProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -1084,17 +1086,51 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                 if (tPage)
                     page.name = tPage;
             }
-            // Translate button labels and messages
+            // Translate button labels and messages, preserving symbol positions
             page.buttons.forEach((button) => {
+                // Translate label
                 if (button.label && translations.has(button.label)) {
                     const tLabel = translations.get(button.label);
                     if (tLabel)
                         button.label = tLabel;
                 }
+                // Translate message with symbol preservation
                 if (button.message && translations.has(button.message)) {
-                    const tMsg = translations.get(button.message);
-                    if (tMsg)
-                        button.message = tMsg;
+                    const originalMessage = button.message;
+                    const translatedText = translations.get(originalMessage);
+                    if (translatedText) {
+                        // Extract symbols from the button (from richText or image fields)
+                        const symbols = (0, symbolAlignment_1.extractSymbolsFromButton)(button);
+                        if (symbols && symbols.length > 0) {
+                            // Use symbol-aware translation to preserve symbol positions
+                            const result = (0, symbolAlignment_1.translateWithSymbols)(originalMessage, translatedText, symbols);
+                            // Update the message
+                            button.message = result.text;
+                            // Update the rich text structure if it exists
+                            if (button.semanticAction?.richText) {
+                                button.semanticAction.richText.text = result.text;
+                                button.semanticAction.richText.symbols = result.richTextSymbols;
+                            }
+                            else if (result.richTextSymbols.length > 0) {
+                                // Create rich text structure if it doesn't exist but we have symbols
+                                if (!button.semanticAction) {
+                                    button.semanticAction = {
+                                        category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                                        intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                                        text: result.text,
+                                    };
+                                }
+                                button.semanticAction.richText = {
+                                    text: result.text,
+                                    symbols: result.richTextSymbols,
+                                };
+                            }
+                        }
+                        else {
+                            // No symbols to preserve, simple translation
+                            button.message = translatedText;
+                        }
+                    }
                 }
             });
         });
@@ -1102,6 +1138,86 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
         this.saveFromTree(tree, outputPath);
         return fs_1.default.readFileSync(outputPath);
     }
+    /**
+     * Extract symbol information from a gridset for LLM-based translation.
+     * Returns a structured format showing which buttons have symbols and their context.
+     *
+     * This method uses shared translation utilities that work across all AAC formats.
+     *
+     * @param filePathOrBuffer - Path to gridset file or buffer
+     * @returns Array of symbol information for LLM processing
+     */
+    extractSymbolsForLLM(filePathOrBuffer) {
+        const tree = this.loadIntoTree(filePathOrBuffer);
+        // Collect all buttons from all pages
+        const allButtons = [];
+        Object.values(tree.pages).forEach((page) => {
+            page.buttons.forEach((button) => {
+                // Add page context to each button
+                button.pageId = page.id;
+                button.pageName = page.name || page.id;
+                allButtons.push(button);
+            });
+        });
+        // Use shared utility to extract buttons with translation context
+        return (0, translationProcessor_1.extractAllButtonsForTranslation)(allButtons, (button) => ({
+            pageId: button.pageId,
+            pageName: button.pageName,
+        }));
+    }
+    /**
+     * Apply LLM translations with symbol information.
+     * The LLM should provide translations with symbol attachments in the correct positions.
+     *
+     * This method uses shared translation utilities that work across all AAC formats.
+     *
+     * @param filePathOrBuffer - Path to gridset file or buffer
+     * @param llmTranslations - Array of LLM translations with symbol info
+     * @param outputPath - Where to save the translated gridset
+     * @param options - Translation options (e.g., allowPartial for testing)
+     * @returns Buffer of the translated gridset
+     */
+    processLLMTranslations(filePathOrBuffer, llmTranslations, outputPath, options) {
+        const tree = this.loadIntoTree(filePathOrBuffer);
+        // Validate translations using shared utility
+        const buttonIds = Object.values(tree.pages).flatMap((page) => page.buttons.map((b) => b.id));
+        (0, translationProcessor_1.validateTranslationResults)(llmTranslations, buttonIds, options);
+        // Create a map for quick lookup
+        const translationMap = new Map(llmTranslations.map((t) => [t.buttonId, t]));
+        // Apply translations
+        Object.values(tree.pages).forEach((page) => {
+            page.buttons.forEach((button) => {
+                const translation = translationMap.get(button.id);
+                if (!translation)
+                    return;
+                // Apply label translation
+                if (translation.translatedLabel) {
+                    button.label = translation.translatedLabel;
+                }
+                // Apply message translation
+                if (translation.translatedMessage) {
+                    button.message = translation.translatedMessage;
+                    // Update rich text if symbols provided
+                    if (translation.symbols && translation.symbols.length > 0) {
+                        if (!button.semanticAction) {
+                            button.semanticAction = {
+                                category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                                intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                                text: translation.translatedMessage,
+                            };
+                        }
+                        button.semanticAction.richText = {
+                            text: translation.translatedMessage,
+                            symbols: translation.symbols,
+                        };
+                    }
+                }
+            });
+        });
+        // Save and return
+        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) {

package/dist/processors/index.d.ts

@@ -1,3 +1,11 @@
+/**
+ * AAC Processor Classes
+ *
+ * All processor classes for different AAC file formats.
+ * For platform-specific utilities (Gridset, Snap, etc.), use the namespace imports:
+ * - import { Gridset } from 'aac-processors/gridset';
+ * - import { Snap } from 'aac-processors/snap';
+ */
 export { ApplePanelsProcessor } from './applePanelsProcessor';
 export { DotProcessor } from './dotProcessor';
 export { ExcelProcessor } from './excelProcessor';
@@ -8,21 +16,3 @@ export { SnapProcessor } from './snapProcessor';
 export { TouchChatProcessor } from './touchchatProcessor';
 export { AstericsGridProcessor } from './astericsGridProcessor';
 export { ObfsetProcessor } from './obfsetProcessor';
-export { getPageTokenImageMap, getAllowedImageEntries, openImage, generateGrid3Guid, createSettingsXml, createFileMapXml, getCommonDocumentsPath, findGrid3UserPaths, findGrid3HistoryDatabases, findGrid3Users, findGrid3Vocabularies, findGrid3UserHistory, isGrid3Installed, readGrid3History, readGrid3HistoryForUser, readAllGrid3History, type Grid3UserPath, type Grid3VocabularyPath, type Grid3HistoryEntry, } from './gridset/helpers';
-export { getPageTokenImageMap as getGridsetPageTokenImageMap, getAllowedImageEntries as getGridsetAllowedImageEntries, openImage as openGridsetImage, generateGrid3Guid as generateGridsetGuid, createSettingsXml as createGridsetSettingsXml, createFileMapXml as createGridsetFileMapXml, getCommonDocumentsPath as getGridsetCommonDocumentsPath, findGrid3UserPaths as findGridsetUserPaths, findGrid3HistoryDatabases as findGridsetHistoryDatabases, findGrid3Users as findGridsetUsers, findGrid3Vocabularies as findGridsetVocabularies, findGrid3UserHistory as findGridsetUserHistory, isGrid3Installed as isGridsetInstalled, readGrid3History as readGridsetHistory, readGrid3HistoryForUser as readGridsetHistoryForUser, readAllGrid3History as readAllGridsetHistory, } from './gridset/helpers';
-export { resolveGrid3CellImage } from './gridset/resolver';
-export { createWordlist, extractWordlists, updateWordlist, wordlistToXml, type WordList, type WordListItem, } from './gridset/wordlistHelpers';
-export { resolveGridsetPassword, resolveGridsetPasswordFromEnv } from './gridset/password';
-export { getNamedColor, rgbaToHex, channelToHex, clampColorChannel, clampAlpha, toHexColor, darkenColor, normalizeColor, ensureAlphaChannel, } from './gridset/colorUtils';
-export { DEFAULT_GRID3_STYLES, CATEGORY_STYLES, createDefaultStylesXml, createCategoryStyle, CellBackgroundShape, SHAPE_NAMES, } from './gridset/styleHelpers';
-export { ensureAlphaChannel as ensureAlphaChannelFromStyles } from './gridset/styleHelpers';
-export { detectPluginCellType, type Grid3PluginMetadata, Grid3CellType, WORKSPACE_TYPES, LIVECELL_TYPES, AUTOCONTENT_TYPES, getCellTypeDisplayName, isWorkspaceCell, isLiveCell, isAutoContentCell, isRegularCell, } from './gridset/pluginTypes';
-export { detectCommand, getCommandDefinition, getCommandsByPlugin, getCommandsByCategory, getAllCommandIds, getAllPluginIds, extractCommandParameters, GRID3_COMMANDS, type Grid3CommandDefinition, type CommandParameter, type ExtractedParameters, Grid3CommandCategory, } from './gridset/commands';
-export * from './gridset/index';
-export { parseSymbolReference, isSymbolReference, resolveSymbolReference, getAvailableSymbolLibraries, getSymbolLibraryInfo, extractSymbolReferences, analyzeSymbolUsage, createSymbolReference, getSymbolLibraryName, getSymbolPath, isKnownSymbolLibrary, getSymbolLibraryDisplayName, getDefaultGrid3Path, getSymbolLibrariesDir, getSymbolSearchIndexesDir, symbolReferenceToFilename, SYMBOL_LIBRARIES, } from './gridset/symbols';
-export { isSymbolLibraryReference, parseImageSymbolReference } from './gridset/resolver';
-export { getSymbolsDir, getSymbolSearchDir } from './gridset/symbols';
-export { extractButtonImage, extractSymbolLibraryImage, convertToAstericsImage, analyzeSymbolExtraction, suggestExtractionStrategy, exportSymbolReferencesToCsv, createSymbolManifest, } from './gridset/symbolExtractor';
-export { parsePixFile, loadSearchIndexes, searchSymbols, searchSymbolsWithReferences, getSymbolFilename, getSymbolDisplayName, getAllSearchTerms, getSearchSuggestions, countLibrarySymbols, getSymbolSearchStats, } from './gridset/symbolSearch';
-export { getPageTokenImageMap as getSnapPageTokenImageMap, getAllowedImageEntries as getSnapAllowedImageEntries, openImage as openSnapImage, findSnapPackages, findSnapPackagePath, findSnapUsers, findSnapUserVocabularies, findSnapUserHistory, isSnapInstalled, readSnapUsage, readSnapUsageForUser, type SnapPackagePath, type SnapUserInfo, type SnapUsageEntry, } from './snap/helpers';
-export { getPageTokenImageMap as getTouchChatPageTokenImageMap, getAllowedImageEntries as getTouchChatAllowedImageEntries, openImage as openTouchChatImage, } from './touchchat/helpers';