@willwade/aac-processors 0.0.10 → 0.0.12

package/dist/processors/gridset/symbols.js

@@ -0,0 +1,468 @@
+"use strict";
+/**
+ * Grid 3 Symbol Library Resolution
+ *
+ * Grid 3 uses symbol libraries stored as .pix files in the installation directory.
+ * Symbol references in Grid files use the format: [library]/path/to/symbol.png
+ *
+ * Examples:
+ * - [widgit]/food/apple.png
+ * - [tawasl]/above bw.png
+ * - [ssnaps]963.jpg
+ * - [grid3x]/folder/document.png
+ *
+ * This module provides symbol resolution and metadata extraction.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOCALE = exports.SYMBOL_LIBRARIES = void 0;
+exports.parseSymbolReference = parseSymbolReference;
+exports.isSymbolReference = isSymbolReference;
+exports.getDefaultGrid3Path = getDefaultGrid3Path;
+exports.getSymbolLibrariesDir = getSymbolLibrariesDir;
+exports.getSymbolSearchIndexesDir = getSymbolSearchIndexesDir;
+exports.getAvailableSymbolLibraries = getAvailableSymbolLibraries;
+exports.getSymbolLibraryInfo = getSymbolLibraryInfo;
+exports.resolveSymbolReference = resolveSymbolReference;
+exports.extractSymbolReferences = extractSymbolReferences;
+exports.createSymbolReference = createSymbolReference;
+exports.getSymbolLibraryName = getSymbolLibraryName;
+exports.getSymbolPath = getSymbolPath;
+exports.isKnownSymbolLibrary = isKnownSymbolLibrary;
+exports.getSymbolLibraryDisplayName = getSymbolLibraryDisplayName;
+exports.analyzeSymbolUsage = analyzeSymbolUsage;
+exports.symbolReferenceToFilename = symbolReferenceToFilename;
+exports.getSymbolsDir = getSymbolsDir;
+exports.getSymbolSearchDir = getSymbolSearchDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+/**
+ * Default Grid 3 installation paths by platform
+ */
+const DEFAULT_GRID3_PATHS = {
+    win32: 'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+    darwin: '/Applications/Grid 3.app/Contents/Resources',
+    linux: '/opt/smartbox/grid3',
+};
+/**
+ * Path to Symbols directory within Grid 3 installation
+ * Contains .symbols ZIP archives with actual images
+ */
+const SYMBOLS_SUBDIR = 'Resources\\Symbols';
+/**
+ * Path to symbol search indexes within Grid 3 installation
+ * Contains .pix index files for searching
+ */
+const SYMBOLSEARCH_SUBDIR = 'Locale';
+/**
+ * Known symbol libraries in Grid 3
+ */
+exports.SYMBOL_LIBRARIES = {
+    WIDGIT: 'widgit',
+    TAWASL: 'tawasl',
+    SSNAPS: 'ssnaps',
+    GRID3X: 'grid3x',
+    GRID2X: 'grid2x',
+    BLISSX: 'blissx',
+    EYEGAZ: 'eyegaz',
+    INTERL: 'interl',
+    METACM: 'metacm',
+    MJPCS: 'mjpcs#',
+    PCSHC: 'pcshc#',
+    PCSTL: 'pcstl#',
+    SESENS: 'sesens',
+    SSTIX: 'sstix#',
+    SYMOJI: 'symoji',
+};
+/**
+ * Default locale to use
+ */
+exports.DEFAULT_LOCALE = 'en-GB';
+/**
+ * Parse a symbol reference string
+ * @param reference - Symbol reference like "[widgit]/food/apple.png"
+ * @returns Parsed symbol reference
+ */
+function parseSymbolReference(reference) {
+    const trimmed = reference.trim();
+    // Match pattern: [library]/path or [library]path
+    const match = trimmed.match(/^\[([^\]]+)\](.+)$/);
+    if (!match) {
+        return {
+            library: '',
+            path: trimmed,
+            fullReference: trimmed,
+            isValid: false,
+        };
+    }
+    const [, library, symbolPath] = match;
+    return {
+        library: library.toLowerCase(),
+        path: symbolPath.replace(/^\\+/, '').trim(), // Remove leading slashes
+        fullReference: trimmed,
+        isValid: true,
+    };
+}
+/**
+ * Check if a string is a symbol library reference
+ * @param reference - String to check
+ * @returns True if it's a symbol reference like [widgit]/...
+ */
+function isSymbolReference(reference) {
+    return reference.trim().startsWith('[');
+}
+/**
+ * Get the default Grid 3 installation path for the current platform
+ * @returns Default Grid 3 path or empty string if not found
+ */
+function getDefaultGrid3Path() {
+    const platform = process.platform;
+    const defaultPath = DEFAULT_GRID3_PATHS[platform] || '';
+    if (defaultPath && fs.existsSync(defaultPath)) {
+        return defaultPath;
+    }
+    // Try to find Grid 3 in common locations
+    const commonPaths = [
+        'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+        'C:\\Program Files\\Smartbox\\Grid 3',
+        'C:\\Program Files\\Smartbox\\Grid 3',
+        '/Applications/Grid 3.app',
+        '/opt/smartbox/grid3',
+    ];
+    for (const testPath of commonPaths) {
+        if (fs.existsSync(testPath)) {
+            return testPath;
+        }
+    }
+    return '';
+}
+/**
+ * Get the Symbol Libraries directory path
+ * Contains .symbols ZIP archives with actual image files
+ * @param grid3Path - Grid 3 installation path
+ * @returns Path to Symbol Libraries directory (e.g., "C:\...\Grid 3\Resources\Symbols")
+ */
+function getSymbolLibrariesDir(grid3Path) {
+    return path.join(grid3Path, SYMBOLS_SUBDIR);
+}
+/**
+ * Get the symbol search indexes directory path for a given locale
+ * Contains .pix index files for searching symbols
+ * @param grid3Path - Grid 3 installation path
+ * @param locale - Locale code (e.g., 'en-GB')
+ * @returns Path to symbol search indexes directory (e.g., "C:\...\Grid 3\Locale\en-GB\symbolsearch")
+ */
+function getSymbolSearchIndexesDir(grid3Path, locale = exports.DEFAULT_LOCALE) {
+    return path.join(grid3Path, SYMBOLSEARCH_SUBDIR, locale, 'symbolsearch');
+}
+/**
+ * Get all available symbol libraries in the Grid 3 installation
+ * @param options - Resolution options
+ * @returns Array of symbol library information
+ */
+function getAvailableSymbolLibraries(options = {}) {
+    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return [];
+    }
+    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    if (!fs.existsSync(symbolsDir)) {
+        return [];
+    }
+    const libraries = [];
+    const files = fs.readdirSync(symbolsDir);
+    for (const file of files) {
+        if (file.endsWith('.symbols')) {
+            const fullPath = path.join(symbolsDir, file);
+            const stats = fs.statSync(fullPath);
+            const libraryName = path.basename(file, '.symbols');
+            libraries.push({
+                name: libraryName,
+                pixFile: fullPath, // Reuse this field for the .symbols file path
+                exists: true,
+                size: stats.size,
+                locale: 'global', // .symbols files are not locale-specific
+            });
+        }
+    }
+    return libraries.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Check if a symbol library exists
+ * @param libraryName - Name of the library (e.g., 'widgit', 'tawasl')
+ * @param options - Resolution options
+ * @returns Symbol library info or undefined if not found
+ */
+function getSymbolLibraryInfo(libraryName, options = {}) {
+    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return undefined;
+    }
+    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    const normalizedLibName = libraryName.toLowerCase();
+    // Try different case variations
+    const variations = [
+        normalizedLibName + '.symbols',
+        normalizedLibName.toUpperCase() + '.symbols',
+        libraryName + '.symbols',
+    ];
+    for (const file of variations) {
+        const fullPath = path.join(symbolsDir, file);
+        if (fs.existsSync(fullPath)) {
+            const stats = fs.statSync(fullPath);
+            return {
+                name: libraryName,
+                pixFile: fullPath,
+                exists: true,
+                size: stats.size,
+                locale: 'global',
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve a symbol reference to extract the actual image data
+ * @param reference - Symbol reference like "[tawasl]/above bw.png"
+ * @param options - Resolution options
+ * @returns Resolution result with image data if found
+ */
+function resolveSymbolReference(reference, options = {}) {
+    const parsed = parseSymbolReference(reference);
+    if (!parsed.isValid) {
+        return {
+            reference: parsed,
+            found: false,
+            error: 'Invalid symbol reference format',
+        };
+    }
+    const grid3Path = options.grid3Path || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return {
+            reference: parsed,
+            found: false,
+            error: 'Grid 3 installation not found. Please specify grid3Path.',
+        };
+    }
+    const libraryInfo = getSymbolLibraryInfo(parsed.library, { grid3Path });
+    if (!libraryInfo || !libraryInfo.exists) {
+        return {
+            reference: parsed,
+            found: false,
+            error: `Symbol library '${parsed.library}' not found at ${libraryInfo?.pixFile || 'unknown'}`,
+        };
+    }
+    try {
+        // .symbols files are ZIP archives
+        const zip = new adm_zip_1.default(libraryInfo.pixFile);
+        // The path in the symbol reference becomes the path within the symbols/ folder
+        // e.g., [tawasl]/above bw.png becomes symbols/above bw.png
+        const symbolPath = `symbols/${parsed.path}`;
+        const entry = zip.getEntry(symbolPath);
+        if (!entry) {
+            // Try without the symbols/ prefix (in case reference already includes it)
+            const altPath = parsed.path.startsWith('symbols/') ? parsed.path : `symbols/${parsed.path}`;
+            const altEntry = zip.getEntry(altPath);
+            if (!altEntry) {
+                return {
+                    reference: parsed,
+                    found: false,
+                    error: `Symbol '${parsed.path}' not found in library '${parsed.library}'`,
+                    path: libraryInfo.pixFile,
+                    libraryInfo,
+                };
+            }
+            // Found with alternate path
+            const data = altEntry.getData();
+            return {
+                reference: parsed,
+                found: true,
+                path: libraryInfo.pixFile,
+                data,
+                libraryInfo,
+            };
+        }
+        // Found the symbol!
+        const data = entry.getData();
+        return {
+            reference: parsed,
+            found: true,
+            path: libraryInfo.pixFile,
+            data,
+            libraryInfo,
+        };
+    }
+    catch (error) {
+        return {
+            reference: parsed,
+            found: false,
+            error: `Failed to extract symbol: ${error.message}`,
+            path: libraryInfo.pixFile,
+            libraryInfo,
+        };
+    }
+}
+/**
+ * Get all symbol references from a gridset
+ * This scans button images for symbol references
+ * @param tree - AAC tree from loaded gridset
+ * @returns Array of unique symbol references
+ */
+function extractSymbolReferences(tree) {
+    const references = new Set();
+    for (const pageId in tree.pages) {
+        const page = tree.pages[pageId];
+        if (page.buttons) {
+            for (const button of page.buttons) {
+                if (button.image && isSymbolReference(String(button.image))) {
+                    references.add(String(button.image));
+                }
+                // Check for symbol library metadata
+                if (button.symbolLibrary) {
+                    const ref = `[${button.symbolLibrary}]${button.symbolPath || ''}`;
+                    references.add(ref);
+                }
+            }
+        }
+    }
+    return Array.from(references).sort();
+}
+/**
+ * Create a symbol reference from library and path
+ * @param library - Library name
+ * @param symbolPath - Path within the library
+ * @returns Formatted symbol reference
+ */
+function createSymbolReference(library, symbolPath) {
+    const normalizedLib = library.toLowerCase().replace(/\[|\]/g, '');
+    const normalizedPath = symbolPath.replace(/^\\+/, '');
+    return `[${normalizedLib}]${normalizedPath}`;
+}
+/**
+ * Get the library name from a symbol reference
+ * @param reference - Symbol reference
+ * @returns Library name or empty string
+ */
+function getSymbolLibraryName(reference) {
+    const parsed = parseSymbolReference(reference);
+    return parsed.library;
+}
+/**
+ * Get the symbol path from a symbol reference
+ * @param reference - Symbol reference
+ * @returns Symbol path or empty string
+ */
+function getSymbolPath(reference) {
+    const parsed = parseSymbolReference(reference);
+    return parsed.path;
+}
+/**
+ * Check if a symbol library is one of the known Grid 3 libraries
+ * @param libraryName - Library name to check
+ * @returns True if it's a known library
+ */
+function isKnownSymbolLibrary(libraryName) {
+    const normalized = libraryName.toLowerCase().replace(/\[|\]/g, '');
+    return Object.values(exports.SYMBOL_LIBRARIES).includes(normalized);
+}
+/**
+ * Get display name for a symbol library
+ * @param libraryName - Library name
+ * @returns Human-readable display name
+ */
+function getSymbolLibraryDisplayName(libraryName) {
+    const normalized = libraryName.toLowerCase().replace(/\[|\]/g, '');
+    const displayNames = {
+        widgit: 'Widgit Symbols',
+        tawasl: 'Tawasol (Arabic)',
+        ssnaps: 'Smartbox Symbol Snapshots',
+        grid3x: 'Grid 3 Extended',
+        grid2x: 'Grid 2 Extended',
+        blissx: 'Blissymbols',
+        eyegaz: 'Eye Gaze Symbols',
+        interl: 'International Symbols',
+        metacm: 'MetaComm',
+        mjpcs: 'Mayer-Johnson PCS',
+        pcshc: 'PCS High Contrast',
+        pcstl: 'PCS Thin Line',
+        sesens: 'Sensory Software',
+        sstix: 'Smartbox TIX',
+        symoji: 'Symbol Emoji',
+    };
+    return displayNames[normalized] || normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function analyzeSymbolUsage(tree) {
+    const references = extractSymbolReferences(tree);
+    const byLibrary = {};
+    const libraries = new Set();
+    for (const ref of references) {
+        const lib = getSymbolLibraryName(ref);
+        byLibrary[lib] = (byLibrary[lib] || 0) + 1;
+        if (lib) {
+            libraries.add(lib);
+        }
+    }
+    return {
+        totalSymbols: references.length,
+        byLibrary,
+        uniqueReferences: references,
+        librariesUsed: Array.from(libraries).sort(),
+    };
+}
+/**
+ * Convert symbol reference to filename for embedded images
+ * Grid 3 sometimes embeds symbols with special naming
+ * @param reference - Symbol reference
+ * @param cellX - Cell X coordinate
+ * @param cellY - Cell Y coordinate
+ * @returns Generated filename
+ */
+function symbolReferenceToFilename(reference, cellX, cellY) {
+    const parsed = parseSymbolReference(reference);
+    const ext = path.extname(parsed.path) || '.png';
+    // Grid 3 format: {x}-{y}-0-text-0.{ext}
+    return `${cellX}-${cellY}-0-text-0${ext}`;
+}
+// ============================================================================
+// BACKWARD COMPATIBILITY ALIASES
+// ============================================================================
+/**
+ * @deprecated Use getSymbolLibrariesDir() instead - more descriptive name
+ * Get the Symbols directory path (where .symbols ZIP archives are)
+ */
+function getSymbolsDir(grid3Path) {
+    return getSymbolLibrariesDir(grid3Path);
+}
+/**
+ * @deprecated Use getSymbolSearchIndexesDir() instead - more descriptive name
+ * Get the symbol search directory for a given locale (where .pix index files are)
+ */
+function getSymbolSearchDir(grid3Path, locale = exports.DEFAULT_LOCALE) {
+    return getSymbolSearchIndexesDir(grid3Path, locale);
+}

package/dist/processors/gridsetProcessor.js

@@ -14,6 +14,12 @@ const password_1 = require("./gridset/password");
 const crypto_1 = __importDefault(require("crypto"));
 const zlib_1 = __importDefault(require("zlib"));
 const gridsetValidator_1 = require("../validation/gridsetValidator");
+// New imports for enhanced Grid 3 support
+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");
 class GridsetProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -254,6 +260,9 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
             fontColor: grid3Style.FontColour,
             fontFamily: grid3Style.FontName,
             fontSize: grid3Style.FontSize ? parseInt(String(grid3Style.FontSize)) : undefined,
+            backgroundShape: grid3Style.BackgroundShape !== undefined
+                ? parseInt(String(grid3Style.BackgroundShape))
+                : undefined,
         };
     }
     // Helper function to get style by ID or return default
@@ -496,11 +505,14 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             }
                         }
                         const message = label; // Use caption as message
+                        // Detect plugin cell type (Workspace, LiveCell, AutoContent)
+                        const pluginMetadata = (0, pluginTypes_1.detectPluginCellType)(content);
                         // 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;
+                        let detectedCommands = []; // Store detected command metadata
                         const commands = content.Commands?.Command || content.commands?.command;
                         // Resolve image for this cell using FileMap and coordinate heuristics
                         const imageCandidate = captionAndImage?.Image ||
@@ -520,8 +532,14 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             y: cellY + 1,
                             dynamicFiles,
                         }, entries) || undefined;
+                        // Check if image is a symbol library reference
+                        let symbolLibraryRef = null;
+                        if (declaredImageName && (0, resolver_2.isSymbolLibraryReference)(declaredImageName)) {
+                            symbolLibraryRef = (0, symbols_1.parseSymbolReference)(declaredImageName);
+                        }
                         if (commands) {
                             const commandArr = Array.isArray(commands) ? commands : [commands];
+                            detectedCommands = commandArr.map((cmd) => (0, commands_1.detectCommand)(cmd));
                             for (const command of commandArr) {
                                 const commandId = command['@_ID'] || command.ID || command.id;
                                 const parameters = command.Parameter || command.parameter;
@@ -905,16 +923,34 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             message: String(message),
                             targetPageId: navigationTarget ? String(navigationTarget) : undefined,
                             semanticAction: semanticAction,
+                            semantic_id: cell.semantic_id || cell.SemanticId || undefined, // Extract semantic_id if present
                             image: declaredImageName,
                             resolvedImageEntry: resolvedImageEntry,
                             x: cellX,
                             y: cellY,
                             columnSpan: colSpan,
                             rowSpan: rowSpan,
+                            contentType: pluginMetadata.cellType === pluginTypes_1.Grid3CellType.Regular
+                                ? 'Normal'
+                                : pluginMetadata.cellType === pluginTypes_1.Grid3CellType.Workspace
+                                    ? 'Workspace'
+                                    : pluginMetadata.cellType === pluginTypes_1.Grid3CellType.LiveCell
+                                        ? 'LiveCell'
+                                        : 'AutoContent',
+                            contentSubType: pluginMetadata.subType ||
+                                pluginMetadata.liveCellType ||
+                                pluginMetadata.autoContentType,
+                            symbolLibrary: symbolLibraryRef?.library || undefined,
+                            symbolPath: symbolLibraryRef?.path || undefined,
                             style: {
                                 ...cellStyle,
                                 ...inlineStyle, // Inline styles override referenced styles
                             },
+                            parameters: {
+                                pluginMetadata: pluginMetadata, // Store full plugin metadata for future use
+                                grid3Commands: detectedCommands, // Store detected command metadata
+                                symbolLibraryRef: symbolLibraryRef, // Store full symbol reference
+                            },
                         });
                         // Add button to page
                         page.addButton(button);
@@ -929,6 +965,29 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                     });
                     // Set the page's grid layout
                     page.grid = gridLayout;
+                    // Generate clone_id for each button in the grid
+                    const semanticIds = [];
+                    const cloneIds = [];
+                    gridLayout.forEach((row, rowIndex) => {
+                        row.forEach((btn, colIndex) => {
+                            if (btn) {
+                                // Generate clone_id based on position and label
+                                btn.clone_id = (0, idGenerator_1.generateCloneId)(maxRows, maxCols, rowIndex, colIndex, btn.label);
+                                cloneIds.push(btn.clone_id);
+                                // Track semantic_id if present
+                                if (btn.semantic_id) {
+                                    semanticIds.push(btn.semantic_id);
+                                }
+                            }
+                        });
+                    });
+                    // Track IDs on the page
+                    if (semanticIds.length > 0) {
+                        page.semantic_ids = semanticIds;
+                    }
+                    if (cloneIds.length > 0) {
+                        page.clone_ids = cloneIds;
+                    }
                 }
                 tree.addPage(page);
             }

package/dist/processors/index.d.ts

@@ -7,13 +7,22 @@ export { OpmlProcessor } from './opmlProcessor';
 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, } from './gridset/styleHelpers';
+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';