@willwade/aac-processors 0.1.20 → 0.2.0

package/dist/browser/processors/snapProcessor.js

@@ -2,9 +2,8 @@ import { BaseProcessor, } from '../core/baseProcessor';
 import { AACTree, AACPage, AACButton, AACSemanticCategory, AACSemanticIntent, } from '../core/treeStructure';
 import { generateCloneId } from '../utilities/analytics/utils/idGenerator';
 import { SnapValidator } from '../validation/snapValidator';
-import { getFs, getNodeRequire, getPath, isNodeRuntime, getOs } from '../utils/io';
+import { getNodeRequire, isNodeRuntime } from '../utils/io';
 import { openSqliteDatabase, requireBetterSqlite3 } from '../utils/sqlite';
-import { openZipFromInput } from '../utils/zip';
 /**
  * Convert a Buffer or Uint8Array to base64 string (browser and Node compatible)
  * Node.js Buffers support toString('base64'), but Uint8Arrays in browser do not.
@@ -36,15 +35,15 @@ function mapSnapVisibility(visible) {
     return visible === 0 ? 'Hidden' : 'Visible';
 }
 class SnapProcessor extends BaseProcessor {
-    constructor(symbolResolver = null, options = {}) {
+    constructor(symbolResolver = null, options) {
         super(options);
         this.symbolResolver = null;
         this.loadAudio = false;
         this.pageLayoutPreference = 'scanning'; // Default to scanning for metrics
         this.symbolResolver = symbolResolver;
-        this.loadAudio = options.loadAudio !== undefined ? options.loadAudio : true;
+        this.loadAudio = options?.loadAudio !== undefined ? options.loadAudio : true;
         this.pageLayoutPreference =
-            options.pageLayoutPreference !== undefined ? options.pageLayoutPreference : 'scanning'; // Default to scanning
+            options?.pageLayoutPreference !== undefined ? options.pageLayoutPreference : 'scanning'; // Default to scanning
     }
     async extractTexts(filePathOrBuffer) {
         const tree = await this.loadIntoTree(filePathOrBuffer);
@@ -65,7 +64,7 @@ class SnapProcessor extends BaseProcessor {
         return texts;
     }
     async loadIntoTree(filePathOrBuffer) {
-        await Promise.resolve();
+        const { writeBinaryToPath, removePath, mkTempDir, basename, join } = this.options.fileAdapter;
         const tree = new AACTree();
         let dbResult = null;
         let cleanupTempZip = null;
@@ -73,32 +72,32 @@ class SnapProcessor extends BaseProcessor {
             // Handle .sub.zip files (Snap pageset backups containing .sps files)
             let inputFile = filePathOrBuffer;
             if (typeof filePathOrBuffer === 'string') {
-                const fileName = getPath().basename(filePathOrBuffer).toLowerCase();
+                const fileName = basename(filePathOrBuffer).toLowerCase();
                 if (fileName.endsWith('.sub.zip') || filePathOrBuffer.endsWith('.sub')) {
-                    const fs = getFs();
-                    const path = getPath();
-                    const os = getOs();
                     // Extract .sub.zip to find the embedded .sps file
-                    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'snap-sub-'));
-                    const { zip } = await openZipFromInput(filePathOrBuffer);
+                    const tempDir = await mkTempDir('snap-sub-');
+                    const zip = await this.options.zipAdapter(filePathOrBuffer);
                     // Find the .sps file in the archive
                     const files = zip.listFiles();
                     const spsFile = files.find((f) => f.endsWith('.sps'));
                     if (!spsFile) {
-                        fs.rmSync(tempDir, { recursive: true, force: true });
+                        await removePath(tempDir, { recursive: true, force: true });
                         throw new Error('No .sps file found in .sub.zip archive');
                     }
                     // Extract the .sps file
                     const spsData = await zip.readFile(spsFile);
-                    const extractedSpsPath = path.join(tempDir, path.basename(spsFile));
-                    fs.writeFileSync(extractedSpsPath, Buffer.from(spsData));
+                    const extractedSpsPath = join(tempDir, basename(spsFile));
+                    await writeBinaryToPath(extractedSpsPath, Buffer.from(spsData));
                     inputFile = extractedSpsPath;
-                    cleanupTempZip = () => {
-                        fs.rmSync(tempDir, { recursive: true, force: true });
+                    cleanupTempZip = async () => {
+                        await removePath(tempDir, { recursive: true, force: true });
                     };
                 }
             }
-            dbResult = await openSqliteDatabase(inputFile, { readonly: true });
+            dbResult = await openSqliteDatabase(inputFile, {
+                readonly: true,
+                fileAdapter: this.options.fileAdapter,
+            });
             const db = dbResult.db;
             const getTableColumns = (tableName) => {
                 try {
@@ -683,7 +682,7 @@ class SnapProcessor extends BaseProcessor {
         }
         finally {
             if (dbResult?.cleanup) {
-                dbResult.cleanup();
+                await dbResult.cleanup();
             }
             else if (dbResult?.db) {
                 dbResult.db.close();
@@ -691,7 +690,7 @@ class SnapProcessor extends BaseProcessor {
             // Clean up temporary extracted .sps file from .sub.zip
             if (cleanupTempZip) {
                 try {
-                    cleanupTempZip();
+                    await cleanupTempZip();
                 }
                 catch (e) {
                     console.warn('[SnapProcessor] Failed to clean up temporary .sps file:', e);
@@ -700,21 +699,21 @@ class SnapProcessor extends BaseProcessor {
         }
     }
     async processTexts(filePathOrBuffer, translations, outputPath) {
+        const { pathExists, mkDir, writeBinaryToPath, readBinaryFromInput, removePath, dirname } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('processTexts is only supported in Node.js environments for Snap files.');
         }
-        const fs = getFs();
-        const path = getPath();
         if (typeof filePathOrBuffer === 'string') {
             const inputPath = filePathOrBuffer;
-            const outputDir = path.dirname(outputPath);
-            if (!fs.existsSync(outputDir)) {
-                fs.mkdirSync(outputDir, { recursive: true });
+            const outputDir = dirname(outputPath);
+            const dirExists = await pathExists(outputDir);
+            if (!dirExists) {
+                await mkDir(outputDir, { recursive: true });
             }
-            if (fs.existsSync(outputPath)) {
-                fs.unlinkSync(outputPath);
+            if (await pathExists(outputPath)) {
+                await removePath(outputPath);
             }
-            fs.copyFileSync(inputPath, outputPath);
+            await writeBinaryToPath(outputPath, await readBinaryFromInput(inputPath));
             const Database = requireBetterSqlite3();
             const db = new Database(outputPath, { readonly: false });
             try {
@@ -776,7 +775,7 @@ class SnapProcessor extends BaseProcessor {
             finally {
                 db.close();
             }
-            return fs.readFileSync(outputPath);
+            return await readBinaryFromInput(outputPath);
         }
         // Fallback for buffer inputs: rebuild from tree (may drop Snap assets)
         const tree = await this.loadIntoTree(filePathOrBuffer);
@@ -803,21 +802,20 @@ class SnapProcessor extends BaseProcessor {
             });
         });
         await this.saveFromTree(tree, outputPath);
-        return fs.readFileSync(outputPath);
+        return await readBinaryFromInput(outputPath);
     }
     async saveFromTree(tree, outputPath) {
+        const { pathExists, mkDir, removePath, dirname } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('saveFromTree is only supported in Node.js environments for Snap files.');
         }
-        await Promise.resolve();
-        const fs = getFs();
-        const path = getPath();
-        const outputDir = path.dirname(outputPath);
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
+        const outputDir = dirname(outputPath);
+        const dirExists = await pathExists(outputDir);
+        if (!dirExists) {
+            await mkDir(outputDir, { recursive: true });
         }
-        if (fs.existsSync(outputPath)) {
-            fs.unlinkSync(outputPath);
+        if (await pathExists(outputPath)) {
+            await removePath(outputPath);
         }
         // Create a new SQLite database for Snap format
         const Database = requireBetterSqlite3();
@@ -1052,7 +1050,6 @@ class SnapProcessor extends BaseProcessor {
      * Add audio recording to a button in the database
      */
     async addAudioToButton(dbPath, buttonId, audioData, metadata) {
-        await Promise.resolve();
         if (!isNodeRuntime()) {
             throw new Error('addAudioToButton is only supported in Node.js environments.');
         }
@@ -1090,7 +1087,7 @@ class SnapProcessor extends BaseProcessor {
             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;
+            return Promise.resolve(audioId);
         }
         finally {
             db.close();
@@ -1100,12 +1097,12 @@ class SnapProcessor extends BaseProcessor {
      * Create a copy of the pageset with audio recordings added
      */
     async createAudioEnhancedPageset(sourceDbPath, targetDbPath, audioMappings) {
+        const { writeBinaryToPath, readBinaryFromInput } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('createAudioEnhancedPageset is only supported in Node.js environments.');
         }
-        const fs = getFs();
         // Copy the source database to target
-        fs.copyFileSync(sourceDbPath, targetDbPath);
+        await writeBinaryToPath(targetDbPath, await readBinaryFromInput(sourceDbPath));
         // Add audio recordings to the copy
         for (const [buttonId, audioInfo] of audioMappings.entries()) {
             await this.addAudioToButton(targetDbPath, buttonId, audioInfo.audioData, audioInfo.metadata);
@@ -1167,23 +1164,22 @@ class SnapProcessor extends BaseProcessor {
      * @returns Promise with validation result
      */
     async validate(filePath) {
-        return SnapValidator.validateFile(filePath);
+        return SnapValidator.validateFile(filePath, this.options.fileAdapter);
     }
     /**
      * Get available PageLayouts for a Snap file
      * Useful for UI components that want to let users select layout size
      * @param filePath - Path to the Snap file
-     * @returns Array of available PageLayouts with their dimensions
+     * @returns Promise resolving to available PageLayouts with their dimensions
      */
-    getAvailablePageLayouts(filePath) {
+    async getAvailablePageLayouts(filePath) {
+        const { writeBinaryToPath, removePath, pathExists, join } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('getAvailablePageLayouts is only supported in Node.js environments.');
         }
-        const fs = getFs();
-        const path = getPath();
-        const dbPath = typeof filePath === 'string' ? filePath : path.join(process.cwd(), 'temp.spb');
+        const dbPath = typeof filePath === 'string' ? filePath : join(process.cwd(), 'temp.spb');
         if (Buffer.isBuffer(filePath)) {
-            fs.writeFileSync(dbPath, filePath);
+            await writeBinaryToPath(dbPath, filePath);
         }
         let db = null;
         try {
@@ -1234,9 +1230,10 @@ class SnapProcessor extends BaseProcessor {
                 db.close();
             }
             // Clean up temporary file if created from buffer
-            if (Buffer.isBuffer(filePath) && fs.existsSync(dbPath)) {
+            const exists = await pathExists(dbPath);
+            if (Buffer.isBuffer(filePath) && exists) {
                 try {
-                    fs.unlinkSync(dbPath);
+                    await removePath(dbPath);
                 }
                 catch (e) {
                     console.warn('Failed to clean up temporary file:', e);

package/dist/browser/processors/touchchatProcessor.js

@@ -3,10 +3,10 @@ import { AACTree, AACPage, AACButton, AACSemanticCategory, AACSemanticIntent, }
 import { generateCloneId } from '../utilities/analytics/utils/idGenerator';
 import { detectCasing, isNumericOrEmpty } from '../core/stringCasing';
 import { TouchChatValidator } from '../validation/touchChatValidator';
-import { getFs, getNodeRequire, getOs, getPath, isNodeRuntime, readBinaryFromInput, } from '../utils/io';
+import { isNodeRuntime } from '../utils/io';
 import { extractAllButtonsForTranslation, validateTranslationResults, } from '../utilities/translation/translationProcessor';
 import { openSqliteDatabase, requireBetterSqlite3, } from '../utils/sqlite';
-import { openZipFromInput } from '../utils/zip';
+import { getZipEntriesFromAdapter } from './gridset';
 const toNumberOrUndefined = (value) => typeof value === 'number' ? value : undefined;
 const toStringOrUndefined = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
 const toBooleanOrUndefined = (value) => typeof value === 'number' ? value !== 0 : undefined;
@@ -55,7 +55,7 @@ class TouchChatProcessor extends BaseProcessor {
         return texts;
     }
     async loadIntoTree(filePathOrBuffer) {
-        await Promise.resolve();
+        const { readBinaryFromInput } = this.options.fileAdapter;
         // Unzip .ce file, extract the .c4v SQLite DB, and parse pages/buttons
         let db = null;
         let cleanup;
@@ -63,16 +63,17 @@ class TouchChatProcessor extends BaseProcessor {
             // Store source file path or buffer
             this.sourceFile = filePathOrBuffer;
             // Step 1: Unzip
-            const zipInput = readBinaryFromInput(filePathOrBuffer);
-            const { zip } = this.options.zipAdapter
-                ? await this.options.zipAdapter(zipInput)
-                : await openZipFromInput(zipInput);
+            const zipInput = await readBinaryFromInput(filePathOrBuffer);
+            const zip = await this.options.zipAdapter(zipInput);
             const vocabEntry = zip.listFiles().find((name) => name.endsWith('.c4v'));
             if (!vocabEntry) {
                 throw new Error('No .c4v vocab DB found in TouchChat export');
             }
             const dbBuffer = await zip.readFile(vocabEntry);
-            const dbResult = await openSqliteDatabase(dbBuffer, { readonly: true });
+            const dbResult = await openSqliteDatabase(dbBuffer, {
+                readonly: true,
+                fileAdapter: this.options.fileAdapter,
+            });
             db = dbResult.db;
             cleanup = dbResult.cleanup;
             // Step 3: Create tree and load pages
@@ -467,7 +468,7 @@ class TouchChatProcessor extends BaseProcessor {
         finally {
             // Clean up
             if (cleanup) {
-                cleanup();
+                await cleanup();
             }
             else if (db) {
                 db.close();
@@ -475,6 +476,7 @@ class TouchChatProcessor extends BaseProcessor {
         }
     }
     async processTexts(filePathOrBuffer, translations, outputPath) {
+        const { pathExists, mkDir, removePath, mkTempDir, writeBinaryToPath, readBinaryFromInput, dirname, join, } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('processTexts is only supported in Node.js environments for TouchChat files.');
         }
@@ -487,28 +489,25 @@ class TouchChatProcessor extends BaseProcessor {
          * within the embedded SQLite database, ensuring assets and metadata remain intact.
          */
         if (typeof filePathOrBuffer === 'string') {
-            const fs = getFs();
-            const path = getPath();
-            const os = getOs();
-            const AdmZip = getNodeRequire()('adm-zip');
             const inputPath = filePathOrBuffer;
-            const outputDir = path.dirname(outputPath);
-            if (!fs.existsSync(outputDir)) {
-                fs.mkdirSync(outputDir, { recursive: true });
+            const outputDir = dirname(outputPath);
+            const dirExists = await pathExists(outputDir);
+            if (!dirExists) {
+                await mkDir(outputDir, { recursive: true });
             }
-            if (fs.existsSync(outputPath)) {
-                fs.unlinkSync(outputPath);
+            if (await pathExists(outputPath)) {
+                await removePath(outputPath);
             }
-            const zip = new AdmZip(inputPath);
-            const entries = zip.getEntries();
+            const zip = await this.options.zipAdapter(inputPath);
+            const entries = getZipEntriesFromAdapter(zip);
             const vocabEntry = entries.find((entry) => entry.entryName.endsWith('.c4v'));
             if (!vocabEntry) {
                 throw new Error('No .c4v vocab DB found in TouchChat export');
             }
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'touchchat-translate-'));
-            const dbPath = path.join(tempDir, 'vocab.c4v');
+            const tempDir = await mkTempDir('touchchat-translate-');
+            const dbPath = join(tempDir, 'vocab.c4v');
             try {
-                fs.writeFileSync(dbPath, vocabEntry.getData());
+                await writeBinaryToPath(dbPath, await vocabEntry.getData());
                 const Database = requireBetterSqlite3();
                 const db = new Database(dbPath, { readonly: false });
                 try {
@@ -561,26 +560,34 @@ class TouchChatProcessor extends BaseProcessor {
                 finally {
                     db.close();
                 }
-                const outputZip = new AdmZip();
-                entries.forEach((entry) => {
+                const outputZip = await this.options.zipAdapter();
+                const files = [];
+                for (const entry of entries) {
                     if (entry.entryName === vocabEntry.entryName) {
-                        return;
+                        continue;
                     }
-                    const data = entry.isDirectory ? Buffer.alloc(0) : entry.getData();
-                    outputZip.addFile(entry.entryName, data, entry.comment || '');
+                    const data = await entry.getData();
+                    files.push({
+                        name: entry.entryName,
+                        data,
+                    });
+                }
+                files.push({
+                    name: vocabEntry.entryName,
+                    data: await readBinaryFromInput(dbPath),
                 });
-                outputZip.addFile(vocabEntry.entryName, fs.readFileSync(dbPath));
-                outputZip.writeZip(outputPath);
+                const zipData = await outputZip.writeFiles(files);
+                await writeBinaryToPath(outputPath, zipData);
             }
             finally {
                 try {
-                    fs.rmSync(tempDir, { recursive: true, force: true });
+                    await removePath(tempDir, { recursive: true, force: true });
                 }
                 catch {
                     // Best-effort cleanup
                 }
             }
-            return fs.readFileSync(outputPath);
+            return await readBinaryFromInput(outputPath);
         }
         // Fallback for buffer inputs: rebuild from tree (may drop TouchChat metadata)
         const tree = await this.loadIntoTree(filePathOrBuffer);
@@ -607,20 +614,16 @@ class TouchChatProcessor extends BaseProcessor {
             });
         });
         await this.saveFromTree(tree, outputPath);
-        const fs = getFs();
-        return fs.readFileSync(outputPath);
+        return await readBinaryFromInput(outputPath);
     }
     async saveFromTree(tree, outputPath) {
-        await Promise.resolve();
+        const { writeBinaryToPath, mkTempDir, readBinaryFromInput, pathExists, removePath, join } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('saveFromTree is only supported in Node.js environments for TouchChat files.');
         }
-        const fs = getFs();
-        const path = getPath();
-        const os = getOs();
         // Create a TouchChat database that matches the expected schema for loading
-        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'touchchat-export-'));
-        const dbPath = path.join(tmpDir, 'vocab.c4v');
+        const tmpDir = await mkTempDir('touchchat-export-');
+        const dbPath = join(tmpDir, 'vocab.c4v');
         try {
             const Database = requireBetterSqlite3();
             const db = new Database(dbPath);
@@ -913,15 +916,20 @@ class TouchChatProcessor extends BaseProcessor {
             }
             db.close();
             // Create zip file with the database
-            const AdmZip = getNodeRequire()('adm-zip');
-            const zip = new AdmZip();
-            zip.addLocalFile(dbPath, '', 'vocab.c4v');
-            zip.writeZip(outputPath);
+            const zip = await this.options.zipAdapter();
+            const data = await readBinaryFromInput(dbPath);
+            const zipData = await zip.writeFiles([
+                {
+                    name: 'vocab.c4v',
+                    data,
+                },
+            ]);
+            await writeBinaryToPath(outputPath, zipData);
         }
         finally {
             // Clean up
-            if (fs.existsSync(tmpDir)) {
-                fs.rmSync(tmpDir, { recursive: true, force: true });
+            if (await pathExists(tmpDir)) {
+                await removePath(tmpDir, { recursive: true, force: true });
             }
         }
     }
@@ -1004,7 +1012,7 @@ class TouchChatProcessor extends BaseProcessor {
             const outputPath = filePath.replace(/\.ce$/, '_translated.ce');
             // Use existing processTexts method
             await this.processTexts(filePath, translations, outputPath);
-            return Promise.resolve(outputPath);
+            return outputPath;
         }
         catch (error) {
             return Promise.reject(new Error(`Failed to generate translated download: ${error instanceof Error ? error.message : 'Unknown error'}`));
@@ -1016,7 +1024,7 @@ class TouchChatProcessor extends BaseProcessor {
      * @returns Promise with validation result
      */
     async validate(filePath) {
-        return TouchChatValidator.validateFile(filePath);
+        return await TouchChatValidator.validateFile(filePath, this.options.fileAdapter);
     }
     /**
      * Extract symbol information from a TouchChat file for LLM-based translation.
@@ -1025,7 +1033,7 @@ class TouchChatProcessor extends BaseProcessor {
      * This method uses shared translation utilities that work across all AAC formats.
      *
      * @param filePathOrBuffer - Path to TouchChat .ce 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);
@@ -1055,9 +1063,10 @@ class TouchChatProcessor extends BaseProcessor {
      * @param llmTranslations - Array of LLM translations with symbol info
      * @param outputPath - Where to save the translated TouchChat file
      * @param options - Translation options (e.g., allowPartial for testing)
-     * @returns Buffer of the translated TouchChat file
+     * @returns Promise resolving to a buffer of the translated TouchChat file
      */
     async processLLMTranslations(filePathOrBuffer, llmTranslations, outputPath, options) {
+        const { readBinaryFromInput } = this.options.fileAdapter;
         if (!isNodeRuntime()) {
             throw new Error('processLLMTranslations is only supported in Node.js environments for TouchChat files.');
         }
@@ -1099,8 +1108,7 @@ class TouchChatProcessor extends BaseProcessor {
         });
         // Save and return
         await this.saveFromTree(tree, outputPath);
-        const fs = getFs();
-        return fs.readFileSync(outputPath);
+        return await readBinaryFromInput(outputPath);
     }
 }
 export { TouchChatProcessor };

package/dist/browser/utilities/analytics/history.js

@@ -60,8 +60,9 @@ export function exportHistoryToBaton(entries, options) {
 /**
  * Read Grid 3 phrase history from a history.sqlite database and tag entries with their source.
  */
-export function readGrid3History(historyDbPath) {
-    return readGrid3HistoryImpl(historyDbPath).map((e) => ({
+export async function readGrid3History(historyDbPath) {
+    const history = await readGrid3HistoryImpl(historyDbPath);
+    return history.map((e) => ({
         ...e,
         source: 'Grid',
     }));
@@ -69,8 +70,9 @@ export function readGrid3History(historyDbPath) {
 /**
  * Read Grid 3 history for a specific user/language combination.
  */
-export function readGrid3HistoryForUser(userName, langCode) {
-    return readGrid3HistoryForUserImpl(userName, langCode).map((e) => ({
+export async function readGrid3HistoryForUser(userName, langCode) {
+    const history = await readGrid3HistoryForUserImpl(userName, langCode);
+    return history.map((e) => ({
         ...e,
         source: 'Grid',
     }));
@@ -78,39 +80,43 @@ export function readGrid3HistoryForUser(userName, langCode) {
 /**
  * Read every available Grid 3 history database on the machine.
  */
-export function readAllGrid3History() {
-    return readAllGrid3HistoryImpl().map((e) => ({ ...e, source: 'Grid' }));
+export async function readAllGrid3History() {
+    const history = await readAllGrid3HistoryImpl();
+    return history.map((e) => ({ ...e, source: 'Grid' }));
 }
 /**
  * Read Snap button usage from a pageset database and tag entries with source.
  */
-export function readSnapUsage(pagesetPath) {
-    return readSnapUsageImpl(pagesetPath).map((e) => ({ ...e, source: 'Snap' }));
+export async function readSnapUsage(pagesetPath) {
+    const usage = await readSnapUsageImpl(pagesetPath);
+    return usage.map((e) => ({ ...e, source: 'Snap' }));
 }
 /**
  * Read Snap usage for a specific user across all discovered pagesets.
  */
-export function readSnapUsageForUser(userId, packageNamePattern = 'TobiiDynavox') {
-    return readSnapUsageForUserImpl(userId, packageNamePattern).map((e) => ({
+export async function readSnapUsageForUser(userId, packageNamePattern = 'TobiiDynavox') {
+    const usage = await readSnapUsageForUserImpl(userId, packageNamePattern);
+    return usage.map((e) => ({
         ...e,
         source: 'Snap',
     }));
 }
-export function listSnapUsers() {
-    return findSnapUsers();
+export async function listSnapUsers() {
+    return await findSnapUsers();
 }
 /**
  * List Grid 3 users on the current machine.
  */
-export function listGrid3Users() {
-    return findGrid3Users();
+export async function listGrid3Users() {
+    return await findGrid3Users();
 }
 /**
  * Convenience helper to gather all available history across Grid 3 and Snap.
  * Returns an empty array if no history files are present.
  */
-export function collectUnifiedHistory() {
-    const gridHistory = readAllGrid3History();
-    const snapHistory = findSnapUsers().flatMap((u) => readSnapUsageForUser(u.userId));
-    return [...gridHistory, ...snapHistory];
+export async function collectUnifiedHistory() {
+    const gridHistory = await readAllGrid3History();
+    const users = await findSnapUsers();
+    const snapHistory = await Promise.all(users.map(async (u) => await readSnapUsageForUser(u.userId)));
+    return [...gridHistory, ...snapHistory.flat()];
 }

package/dist/browser/utilities/analytics/metrics/comparison.js

@@ -23,7 +23,7 @@ export class ComparisonAnalyzer {
     /**
      * Compare two board sets
      */
-    compare(targetResult, compareResult, options) {
+    async compare(targetResult, compareResult, options) {
         // Create base result from target
         const baseResult = { ...targetResult };
         // Create word maps with normalized keys
@@ -77,7 +77,7 @@ export class ComparisonAnalyzer {
             };
         });
         // Calculate CARE components
-        const careComponents = this.calculateCareComponents(targetResult, compareResult, overlappingWords, options);
+        const careComponents = await this.calculateCareComponents(targetResult, compareResult, overlappingWords, options);
         // Analyze high/low effort words
         const highEffortWords = [];
         const lowEffortWords = [];
@@ -110,7 +110,7 @@ export class ComparisonAnalyzer {
         // Sentence analysis
         let sentences = [];
         if (options?.includeSentences) {
-            const testSentences = this.referenceLoader.loadSentences();
+            const testSentences = await this.referenceLoader.loadSentences();
             const targetSentences = this.sentenceAnalyzer.analyzeSentences(targetResult, testSentences);
             const compareSentences = this.sentenceAnalyzer.analyzeSentences(compareResult, testSentences);
             sentences = targetSentences.map((ts, idx) => ({
@@ -123,7 +123,7 @@ export class ComparisonAnalyzer {
             }));
         }
         // Core vocabulary analysis
-        const coreLists = this.referenceLoader.loadCoreLists();
+        const coreLists = await this.referenceLoader.loadCoreLists();
         const cores = {};
         coreLists.forEach((list) => {
             let targetTotal = 0;
@@ -171,8 +171,8 @@ export class ComparisonAnalyzer {
             }
         });
         // Fringe vocabulary analysis
-        const fringeWords = this.analyzeFringe(targetWords, compareWords);
-        const commonFringeWords = this.analyzeCommonFringe(targetWords, compareWords);
+        const fringeWords = await this.analyzeFringe(targetWords, compareWords);
+        const commonFringeWords = await this.analyzeCommonFringe(targetWords, compareWords);
         return {
             ...baseResult,
             buttons: enrichedButtons,
@@ -214,9 +214,9 @@ export class ComparisonAnalyzer {
     /**
      * Calculate CARE component scores
      */
-    calculateCareComponents(targetResult, compareResult, _overlappingWords, options) {
+    async calculateCareComponents(targetResult, compareResult, _overlappingWords, options) {
         // Load common words with baseline efforts (matching Ruby line 527-534)
-        const commonWordsData = this.referenceLoader.loadCommonWords();
+        const commonWordsData = await this.referenceLoader.loadCommonWords();
         const commonWords = new Map();
         commonWordsData.words.forEach((word) => {
             commonWords.set(word.toLowerCase(), commonWordsData.efforts[word] || 0);
@@ -268,10 +268,10 @@ export class ComparisonAnalyzer {
             }
         });
         // Load reference data
-        const coreLists = this.referenceLoader.loadCoreLists();
-        const fringe = this.referenceLoader.loadFringe();
-        const commonFringe = this.referenceLoader.loadCommonFringe();
-        const sentences = this.referenceLoader.loadSentences();
+        const coreLists = await this.referenceLoader.loadCoreLists();
+        const fringe = await this.referenceLoader.loadFringe();
+        const commonFringe = await this.referenceLoader.loadCommonFringe();
+        const sentences = await this.referenceLoader.loadSentences();
         // Calculate core coverage and effort (matching Ruby lines 609-647)
         let coreCount = 0;
         let compCoreCount = 0;
@@ -423,8 +423,8 @@ export class ComparisonAnalyzer {
     /**
      * Analyze fringe vocabulary
      */
-    analyzeFringe(targetWords, compareWords) {
-        const fringe = this.referenceLoader.loadFringe();
+    async analyzeFringe(targetWords, compareWords) {
+        const fringe = await this.referenceLoader.loadFringe();
         const result = [];
         fringe.forEach((word) => {
             const key = this.normalize(word);
@@ -444,8 +444,8 @@ export class ComparisonAnalyzer {
     /**
      * Analyze common fringe vocabulary
      */
-    analyzeCommonFringe(targetWords, compareWords) {
-        const fringe = this.referenceLoader.loadFringe();
+    async analyzeCommonFringe(targetWords, compareWords) {
+        const fringe = await this.referenceLoader.loadFringe();
         const result = [];
         fringe.forEach((word) => {
             const key = this.normalize(word);