@willwade/aac-processors 0.1.20 → 0.2.0

package/dist/browser/processors/gridset/symbolSearch.js

@@ -0,0 +1,248 @@
+/**
+ * Grid 3 Symbol Search Implementation
+ *
+ * The .pix files are simple text mappings:
+ * searchTerm=symbolFilename=searchTerm
+ *
+ * Example:
+ * above bw=above bw.png=above bw
+ * active family=active family.png=active family
+ */
+import { defaultFileAdapter } from '../../utils/io';
+/**
+ * Parse a .pix file into search index
+ * @param pixFilePath - Path to .pix file
+ * @returns Search index
+ */
+export async function parsePixFile(pixFilePath, fileAdapter = defaultFileAdapter) {
+    const { readTextFromInput, basename } = fileAdapter;
+    const content = await readTextFromInput(pixFilePath);
+    const library = basename(pixFilePath, '.pix');
+    const searchTerms = new Map();
+    const filenames = new Map();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('encoding=')) {
+            continue;
+        }
+        // Format: searchTerm=symbolFilename=searchTerm
+        const parts = trimmed.split('=');
+        if (parts.length >= 3) {
+            const searchTerm = parts[0];
+            const symbolFilename = parts[1];
+            const displayName = parts[2];
+            searchTerms.set(searchTerm.toLowerCase(), symbolFilename);
+            filenames.set(symbolFilename, displayName || searchTerm);
+        }
+    }
+    return { library, searchTerms, filenames };
+}
+/**
+ * Load search indexes for all available libraries
+ * @param options - Search options
+ * @returns Map of library name to search index
+ */
+export async function loadSearchIndexes(options = {}, fileAdapter = defaultFileAdapter) {
+    const { listDir, pathExists, join, basename } = fileAdapter;
+    const { grid3Path, locale = 'en-GB', libraries: specifiedLibs } = options;
+    if (!grid3Path) {
+        throw new Error('grid3Path is required for symbol search');
+    }
+    const searchIndexesDir = join(grid3Path, 'Locale', locale, 'symbolsearch');
+    if (!(await pathExists(searchIndexesDir))) {
+        throw new Error(`Symbol search directory not found: ${searchIndexesDir}`);
+    }
+    const indexes = new Map();
+    const files = await listDir(searchIndexesDir);
+    for (const file of files) {
+        if (!file.endsWith('.pix')) {
+            continue;
+        }
+        const libraryName = basename(file, '.pix');
+        // Filter libraries if specified
+        if (specifiedLibs && specifiedLibs.length > 0) {
+            if (!specifiedLibs.some((lib) => lib.toLowerCase() === libraryName.toLowerCase())) {
+                continue;
+            }
+        }
+        try {
+            const pixFilePath = join(searchIndexesDir, file);
+            const index = await parsePixFile(pixFilePath);
+            indexes.set(libraryName, index);
+        }
+        catch (error) {
+            console.warn(`Failed to load index for ${libraryName}:`, error);
+        }
+    }
+    return indexes;
+}
+/**
+ * Search for symbols by term
+ * @param searchTerm - Term to search for
+ * @param options - Search options
+ * @returns Array of search results
+ */
+export async function searchSymbols(searchTerm, options = {}) {
+    const indexes = await loadSearchIndexes(options);
+    const results = [];
+    const lowerSearchTerm = searchTerm.toLowerCase().trim();
+    const limit = options.limit || 100;
+    for (const [libraryName, index] of indexes.entries()) {
+        // Exact match first
+        if (index.searchTerms.has(lowerSearchTerm)) {
+            const symbolFilename = index.searchTerms.get(lowerSearchTerm);
+            if (symbolFilename) {
+                results.push({
+                    searchTerm: lowerSearchTerm,
+                    symbolFilename,
+                    displayName: index.filenames.get(symbolFilename) || lowerSearchTerm,
+                    library: libraryName,
+                    exactMatch: true,
+                });
+            }
+        }
+        // Fuzzy match if enabled
+        if (options.fuzzyMatch !== false) {
+            for (const [term, symbolFilename] of index.searchTerms.entries()) {
+                if (term.includes(lowerSearchTerm) || lowerSearchTerm.includes(term)) {
+                    // Skip if already added as exact match
+                    if (results.some((r) => r.library === libraryName && r.symbolFilename === symbolFilename)) {
+                        continue;
+                    }
+                    results.push({
+                        searchTerm: lowerSearchTerm,
+                        symbolFilename,
+                        displayName: index.filenames.get(symbolFilename) || term,
+                        library: libraryName,
+                        exactMatch: false,
+                    });
+                }
+            }
+        }
+    }
+    // Sort by exact match first, then by library
+    results.sort((a, b) => {
+        if (a.exactMatch !== b.exactMatch) {
+            return a.exactMatch ? -1 : 1;
+        }
+        return a.library.localeCompare(b.library);
+    });
+    return results.slice(0, limit);
+}
+/**
+ * Get symbol filename for a specific search term
+ * @param searchTerm - Search term to look up
+ * @param library - Library name
+ * @param options - Search options
+ * @returns Symbol filename or undefined
+ */
+export async function getSymbolFilename(searchTerm, library, options = {}) {
+    const indexes = await loadSearchIndexes({
+        ...options,
+        libraries: [library],
+    });
+    const index = indexes.get(library.toLowerCase());
+    if (!index) {
+        return undefined;
+    }
+    return index.searchTerms.get(searchTerm.toLowerCase());
+}
+/**
+ * Get display name for a symbol filename
+ * @param symbolFilename - Symbol filename (e.g., "above bw.png")
+ * @param library - Library name
+ * @param options - Search options
+ * @returns Display name or undefined
+ */
+export async function getSymbolDisplayName(symbolFilename, library, options = {}) {
+    const indexes = await loadSearchIndexes({
+        ...options,
+        libraries: [library],
+    });
+    const index = indexes.get(library.toLowerCase());
+    if (!index) {
+        return undefined;
+    }
+    return index.filenames.get(symbolFilename);
+}
+/**
+ * Get all search terms for a library
+ * @param library - Library name
+ * @param options - Search options
+ * @returns Array of search terms
+ */
+export async function getAllSearchTerms(library, options = {}) {
+    const indexes = await loadSearchIndexes({
+        ...options,
+        libraries: [library],
+    });
+    const index = indexes.get(library.toLowerCase());
+    if (!index) {
+        return [];
+    }
+    return Array.from(index.searchTerms.keys());
+}
+/**
+ * Search suggestions (autocomplete)
+ * @param partialTerm - Partial search term
+ * @param options - Search options
+ * @returns Array of suggested terms
+ */
+export async function getSearchSuggestions(partialTerm, options = {}) {
+    const indexes = await loadSearchIndexes(options);
+    const suggestions = new Set();
+    const lowerPartial = partialTerm.toLowerCase().trim();
+    for (const index of indexes.values()) {
+        for (const term of index.searchTerms.keys()) {
+            if (term.startsWith(lowerPartial)) {
+                suggestions.add(term);
+            }
+        }
+    }
+    return Array.from(suggestions).sort().slice(0, 20);
+}
+/**
+ * Search for symbols and return results with library references
+ * @param searchTerm - Term to search for
+ * @param options - Search options
+ * @returns Array of full symbol references
+ */
+export async function searchSymbolsWithReferences(searchTerm, options = {}) {
+    const results = await searchSymbols(searchTerm, options);
+    return results.map((r) => `[${r.library}]${r.symbolFilename}`);
+}
+/**
+ * Count symbols in each library
+ * @param options - Search options
+ * @returns Map of library name to symbol count
+ */
+export async function countLibrarySymbols(options = {}) {
+    const indexes = await loadSearchIndexes(options);
+    const counts = new Map();
+    for (const [libraryName, index] of indexes.entries()) {
+        counts.set(libraryName, index.searchTerms.size);
+    }
+    return counts;
+}
+/**
+ * Get symbol search statistics
+ * @param options - Search options
+ * @returns Statistics about available symbols
+ */
+export async function getSymbolSearchStats(options = {}) {
+    const indexes = await loadSearchIndexes(options);
+    const stats = {
+        totalLibraries: indexes.size,
+        totalSymbols: 0,
+        libraries: {},
+    };
+    for (const [libraryName, index] of indexes.entries()) {
+        stats.totalSymbols += index.searchTerms.size;
+        stats.libraries[libraryName] = {
+            symbolCount: index.searchTerms.size,
+            exampleTerms: Array.from(index.searchTerms.keys()).slice(0, 10),
+        };
+    }
+    return stats;
+}

package/dist/browser/processors/gridset/symbols.js

@@ -12,7 +12,8 @@
  *
  * This module provides symbol resolution and metadata extraction.
  */
-import { getFs, getNodeRequire, getPath } from '../../utils/io';
+import { defaultFileAdapter } from '../../utils/io';
+import { getZipAdapter } from '../../utils/zip';
 /**
  * Default Grid 3 installation paths by platform
  */
@@ -55,38 +56,6 @@ export const SYMBOL_LIBRARIES = {
  * Default locale to use
  */
 export const DEFAULT_LOCALE = 'en-GB';
-function getNodeFs() {
-    try {
-        return getFs();
-    }
-    catch {
-        throw new Error('Symbol library access is not available in this environment.');
-    }
-}
-function getNodePath() {
-    try {
-        return getPath();
-    }
-    catch {
-        throw new Error('Path utilities are not available in this environment.');
-    }
-}
-let cachedAdmZip = null;
-function getAdmZip() {
-    if (cachedAdmZip)
-        return cachedAdmZip;
-    try {
-        const nodeRequire = getNodeRequire();
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const module = nodeRequire('adm-zip');
-        const resolved = module.default || module;
-        cachedAdmZip = resolved;
-        return resolved;
-    }
-    catch {
-        throw new Error('Symbol library access requires AdmZip in this environment.');
-    }
-}
 /**
  * Parse a symbol reference string
  * @param reference - Symbol reference like "[widgit]/food/apple.png"
@@ -124,12 +93,12 @@ export function isSymbolReference(reference) {
  * Get the default Grid 3 installation path for the current platform
  * @returns Default Grid 3 path or empty string if not found
  */
-export function getDefaultGrid3Path() {
+export async function getDefaultGrid3Path(fileAdapter) {
+    const { pathExists } = fileAdapter ?? defaultFileAdapter;
     const platform = (typeof process !== 'undefined' && process.platform ? process.platform : 'unknown');
     const defaultPath = DEFAULT_GRID3_PATHS[platform] || '';
     try {
-        const fs = getNodeFs();
-        if (defaultPath && fs.existsSync(defaultPath)) {
+        if (defaultPath && (await pathExists(defaultPath))) {
             return defaultPath;
         }
         // Try to find Grid 3 in common locations
@@ -141,7 +110,7 @@ export function getDefaultGrid3Path() {
             '/opt/smartbox/grid3',
         ];
         for (const testPath of commonPaths) {
-            if (fs.existsSync(testPath)) {
+            if (await pathExists(testPath)) {
                 return testPath;
             }
         }
@@ -157,9 +126,9 @@ export function getDefaultGrid3Path() {
  * @param grid3Path - Grid 3 installation path
  * @returns Path to Symbol Libraries directory (e.g., "C:\...\Grid 3\Resources\Symbols")
  */
-export function getSymbolLibrariesDir(grid3Path) {
-    const path = getNodePath();
-    return path.join(grid3Path, SYMBOLS_SUBDIR);
+export function getSymbolLibrariesDir(grid3Path, fileAdapter = defaultFileAdapter) {
+    const { join } = fileAdapter;
+    return join(grid3Path, SYMBOLS_SUBDIR);
 }
 /**
  * Get the symbol search indexes directory path for a given locale
@@ -168,38 +137,37 @@ export function getSymbolLibrariesDir(grid3Path) {
  * @param locale - Locale code (e.g., 'en-GB')
  * @returns Path to symbol search indexes directory (e.g., "C:\...\Grid 3\Locale\en-GB\symbolsearch")
  */
-export function getSymbolSearchIndexesDir(grid3Path, locale = DEFAULT_LOCALE) {
-    const path = getNodePath();
-    return path.join(grid3Path, SYMBOLSEARCH_SUBDIR, locale, 'symbolsearch');
+export function getSymbolSearchIndexesDir(grid3Path, locale = DEFAULT_LOCALE, fileAdapter = defaultFileAdapter) {
+    const { join } = fileAdapter;
+    return 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
  */
-export function getAvailableSymbolLibraries(options = {}) {
-    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+export async function getAvailableSymbolLibraries(options = {}, fileAdapter) {
+    const { pathExists, getFileSize, listDir, join, basename } = fileAdapter ?? defaultFileAdapter;
+    const grid3Path = options.grid3Path || options.symbolDir || (await getDefaultGrid3Path());
     if (!grid3Path) {
         return [];
     }
-    const symbolsDir = getSymbolLibrariesDir(grid3Path);
-    const fs = getNodeFs();
-    if (!fs.existsSync(symbolsDir)) {
+    const symbolsDir = getSymbolLibrariesDir(grid3Path, fileAdapter);
+    if (!(await pathExists(symbolsDir))) {
         return [];
     }
     const libraries = [];
-    const files = fs.readdirSync(symbolsDir);
+    const files = await listDir(symbolsDir);
     for (const file of files) {
         if (file.endsWith('.symbols')) {
-            const path = getNodePath();
-            const fullPath = path.join(symbolsDir, file);
-            const stats = fs.statSync(fullPath);
-            const libraryName = path.basename(file, '.symbols');
+            const fullPath = join(symbolsDir, file);
+            const size = await getFileSize(fullPath);
+            const libraryName = basename(file, '.symbols');
             libraries.push({
                 name: libraryName,
                 pixFile: fullPath, // Reuse this field for the .symbols file path
                 exists: true,
-                size: stats.size,
+                size,
                 locale: 'global', // .symbols files are not locale-specific
             });
         }
@@ -212,12 +180,13 @@ export function getAvailableSymbolLibraries(options = {}) {
  * @param options - Resolution options
  * @returns Symbol library info or undefined if not found
  */
-export function getSymbolLibraryInfo(libraryName, options = {}) {
-    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+export async function getSymbolLibraryInfo(libraryName, options = {}, fileAdapter) {
+    const { pathExists, getFileSize, join } = fileAdapter ?? defaultFileAdapter;
+    const grid3Path = options.grid3Path || options.symbolDir || (await getDefaultGrid3Path());
     if (!grid3Path) {
         return undefined;
     }
-    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    const symbolsDir = getSymbolLibrariesDir(grid3Path, fileAdapter);
     const normalizedLibName = libraryName.toLowerCase();
     // Try different case variations
     const variations = [
@@ -226,16 +195,14 @@ export function getSymbolLibraryInfo(libraryName, options = {}) {
         libraryName + '.symbols',
     ];
     for (const file of variations) {
-        const path = getNodePath();
-        const fullPath = path.join(symbolsDir, file);
-        const fs = getNodeFs();
-        if (fs.existsSync(fullPath)) {
-            const stats = fs.statSync(fullPath);
+        const fullPath = join(symbolsDir, file);
+        if (await pathExists(fullPath)) {
+            const size = await getFileSize(fullPath);
             return {
                 name: libraryName,
                 pixFile: fullPath,
                 exists: true,
-                size: stats.size,
+                size,
                 locale: 'global',
             };
         }
@@ -248,7 +215,7 @@ export function getSymbolLibraryInfo(libraryName, options = {}) {
  * @param options - Resolution options
  * @returns Resolution result with image data if found
  */
-export function resolveSymbolReference(reference, options = {}) {
+export async function resolveSymbolReference(reference, options = {}, fileAdapter = defaultFileAdapter, zipAdapter) {
     const parsed = parseSymbolReference(reference);
     if (!parsed.isValid) {
         return {
@@ -257,7 +224,7 @@ export function resolveSymbolReference(reference, options = {}) {
             error: 'Invalid symbol reference format',
         };
     }
-    const grid3Path = options.grid3Path || getDefaultGrid3Path();
+    const grid3Path = options.grid3Path || (await getDefaultGrid3Path());
     if (!grid3Path) {
         return {
             reference: parsed,
@@ -265,7 +232,7 @@ export function resolveSymbolReference(reference, options = {}) {
             error: 'Grid 3 installation not found. Please specify grid3Path.',
         };
     }
-    const libraryInfo = getSymbolLibraryInfo(parsed.library, { grid3Path });
+    const libraryInfo = await getSymbolLibraryInfo(parsed.library, { grid3Path });
     if (!libraryInfo || !libraryInfo.exists) {
         return {
             reference: parsed,
@@ -275,16 +242,16 @@ export function resolveSymbolReference(reference, options = {}) {
     }
     try {
         // .symbols files are ZIP archives
-        const AdmZip = getAdmZip();
-        const zip = new AdmZip(libraryInfo.pixFile);
+        const zipFile = libraryInfo.pixFile;
+        const zip = zipAdapter ? await zipAdapter(zipFile) : await getZipAdapter(zipFile, fileAdapter);
         // 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);
+        const entry = await zip.readFile(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);
+            const altEntry = await zip.readFile(altPath);
             if (!altEntry) {
                 return {
                     reference: parsed,
@@ -295,7 +262,7 @@ export function resolveSymbolReference(reference, options = {}) {
                 };
             }
             // Found with alternate path
-            const data = altEntry.getData();
+            const data = Buffer.from(altEntry);
             return {
                 reference: parsed,
                 found: true,
@@ -305,7 +272,7 @@ export function resolveSymbolReference(reference, options = {}) {
             };
         }
         // Found the symbol!
-        const data = entry.getData();
+        const data = Buffer.from(entry);
         return {
             reference: parsed,
             found: true,

package/dist/browser/processors/gridsetProcessor.js

@@ -13,8 +13,7 @@ import { parseSymbolReference } from './gridset/symbols';
 import { isSymbolLibraryReference } from './gridset/resolver';
 import { generateCloneId } from '../utilities/analytics/utils/idGenerator';
 import { translateWithSymbols, extractSymbolsFromButton } from './gridset/symbolAlignment';
-import { readBinaryFromInput, decodeText, writeBinaryToPath, getNodeRequire, isNodeRuntime, } from '../utils/io';
-import { openZipFromInput } from '../utils/zip';
+import { decodeText } from '../utils/io';
 class GridsetProcessor extends BaseProcessor {
     constructor(options) {
         super(options);
@@ -395,19 +394,18 @@ class GridsetProcessor extends BaseProcessor {
         return texts;
     }
     async loadIntoTree(filePathOrBuffer) {
+        const { readBinaryFromInput } = this.options.fileAdapter;
         const tree = new AACTree();
         let zipResult;
         try {
-            const zipInput = readBinaryFromInput(filePathOrBuffer);
-            zipResult = this.options.zipAdapter
-                ? await this.options.zipAdapter(zipInput)
-                : await openZipFromInput(zipInput);
+            const zipInput = await readBinaryFromInput(filePathOrBuffer);
+            zipResult = await this.options.zipAdapter(zipInput);
         }
         catch (error) {
             throw new Error(`Invalid ZIP file format: ${error.message}`);
         }
         const password = this.getGridsetPassword(filePathOrBuffer);
-        const entries = getZipEntriesFromAdapter(zipResult.zip, password);
+        const entries = getZipEntriesFromAdapter(zipResult, password);
         const options = {
             ignoreAttributes: false,
             ignoreDeclaration: true,
@@ -1683,6 +1681,7 @@ class GridsetProcessor extends BaseProcessor {
         return tree;
     }
     async processTexts(filePathOrBuffer, translations, outputPath) {
+        const { readBinaryFromInput } = this.options.fileAdapter;
         // Load the tree, apply translations, and save to new file
         const tree = await this.loadIntoTree(filePathOrBuffer);
         // Apply translations to all text content
@@ -1743,7 +1742,7 @@ class GridsetProcessor extends BaseProcessor {
         });
         // Save the translated tree and return its content
         await this.saveFromTree(tree, outputPath);
-        return readBinaryFromInput(outputPath);
+        return await readBinaryFromInput(outputPath);
     }
     /**
      * Extract symbol information from a gridset for LLM-based translation.
@@ -1752,7 +1751,7 @@ class GridsetProcessor extends BaseProcessor {
      * 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
+     * @returns Promise resolving to symbol information for LLM processing
      */
     async extractSymbolsForLLM(filePathOrBuffer) {
         const tree = await this.loadIntoTree(filePathOrBuffer);
@@ -1782,9 +1781,10 @@ class GridsetProcessor extends BaseProcessor {
      * @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
+     * @returns Promise resolving to a buffer of the translated gridset
      */
     async processLLMTranslations(filePathOrBuffer, llmTranslations, outputPath, options) {
+        const { readBinaryFromInput } = this.options.fileAdapter;
         const tree = await this.loadIntoTree(filePathOrBuffer);
         // Validate translations using shared utility
         const buttonIds = Object.values(tree.pages).flatMap((page) => page.buttons.map((b) => b.id));
@@ -1823,40 +1823,16 @@ class GridsetProcessor extends BaseProcessor {
         });
         // Save and return
         await this.saveFromTree(tree, outputPath);
-        return readBinaryFromInput(outputPath);
+        return await readBinaryFromInput(outputPath);
     }
     async saveFromTree(tree, outputPath) {
-        const useNodeZip = isNodeRuntime();
-        let addText;
-        let addBinary;
-        let finalizeZip;
-        if (useNodeZip) {
-            const AdmZip = getNodeRequire()('adm-zip');
-            const zip = new AdmZip();
-            addText = (entryPath, content) => {
-                zip.addFile(entryPath, Buffer.from(content, 'utf8'));
-            };
-            addBinary = (entryPath, content) => {
-                zip.addFile(entryPath, Buffer.from(content));
-            };
-            finalizeZip = () => Promise.resolve(zip.toBuffer());
-        }
-        else {
-            const module = await import('jszip');
-            const JSZip = module.default || module;
-            const zip = new JSZip();
-            addText = (entryPath, content) => {
-                zip.file(entryPath, content, { binary: false });
-            };
-            addBinary = (entryPath, content) => {
-                zip.file(entryPath, content);
-            };
-            finalizeZip = async () => zip.generateAsync({ type: 'uint8array' });
-        }
+        const files = [];
+        const { writeBinaryToPath } = this.options.fileAdapter;
+        const zip = await this.options.zipAdapter();
         if (Object.keys(tree.pages).length === 0) {
             // Create empty zip for empty tree
-            const zipBuffer = await finalizeZip();
-            writeBinaryToPath(outputPath, zipBuffer);
+            const zipBuffer = await zip.writeFiles([]);
+            await writeBinaryToPath(outputPath, zipBuffer);
             return;
         }
         // Collect all unique styles from pages and buttons
@@ -1928,7 +1904,10 @@ class GridsetProcessor extends BaseProcessor {
             suppressEmptyNode: true,
         });
         const settingsXmlContent = settingsBuilder.build(settingsData);
-        addText('Settings0/settings.xml', settingsXmlContent);
+        files.push({
+            name: 'Settings0/settings.xml',
+            data: settingsXmlContent,
+        });
         // Create Settings0/Styles/style.xml if there are styles
         if (uniqueStyles.size > 0) {
             const stylesArray = Array.from(uniqueStyles.values()).map(({ id, style }) => {
@@ -1961,7 +1940,10 @@ class GridsetProcessor extends BaseProcessor {
                 indentBy: '  ',
             });
             const styleXmlContent = styleBuilder.build(styleData);
-            addText('Settings0/Styles/styles.xml', styleXmlContent);
+            files.push({
+                name: 'Settings0/Styles/styles.xml',
+                data: styleXmlContent,
+            });
         }
         // Collect grid file paths for FileMap.xml
         const gridFilePaths = [];
@@ -2102,14 +2084,20 @@ class GridsetProcessor extends BaseProcessor {
             // Add to zip in Grids folder with proper Grid3 naming
             const gridPath = `Grids/${page.name || page.id}/grid.xml`;
             gridFilePaths.push(gridPath);
-            addText(gridPath, xmlContent);
+            files.push({
+                name: gridPath,
+                data: xmlContent,
+            });
         });
         // Write image files to ZIP
         buttonImages.forEach((imgData) => {
             if (imgData.imageData && imgData.imageData.length > 0) {
                 // Create image path in the grid's directory
                 const imagePath = `Grids/${imgData.pageName}/${imgData.x}-${imgData.y}-0-text-0.${imgData.ext}`;
-                addBinary(imagePath, imgData.imageData);
+                files.push({
+                    name: imagePath,
+                    data: imgData.imageData,
+                });
             }
         });
         // Create FileMap.xml to map all grid files with their dynamic image files
@@ -2148,10 +2136,13 @@ class GridsetProcessor extends BaseProcessor {
             indentBy: '  ',
         });
         const fileMapXmlContent = fileMapBuilder.build(fileMapData);
-        addText('FileMap.xml', fileMapXmlContent);
+        files.push({
+            name: 'FileMap.xml',
+            data: fileMapXmlContent,
+        });
         // Write the zip file
-        const zipBuffer = await finalizeZip();
-        writeBinaryToPath(outputPath, zipBuffer);
+        const zipBuffer = await zip.writeFiles(files);
+        await writeBinaryToPath(outputPath, zipBuffer);
     }
     // Helper method to calculate column definitions based on page layout
     calculateColumnDefinitions(page) {
@@ -2248,7 +2239,7 @@ class GridsetProcessor extends BaseProcessor {
      * @returns Promise with validation result
      */
     async validate(filePath) {
-        return GridsetValidator.validateFile(filePath);
+        return GridsetValidator.validateFile(filePath, this.options.fileAdapter);
     }
 }
 export { GridsetProcessor };