@willwade/aac-processors 0.1.5 → 0.1.6

package/dist/processors/obfProcessor.js

@@ -29,31 +29,7 @@ const treeStructure_1 = require("../core/treeStructure");
 const idGenerator_1 = require("../utilities/analytics/utils/idGenerator");
 const translationProcessor_1 = require("../utilities/translation/translationProcessor");
 const io_1 = require("../utils/io");
-let JSZipModuleObf;
-async function getJSZipObf() {
-    if (!JSZipModuleObf) {
-        try {
-            // Try ES module import first (browser/Vite)
-            const module = await Promise.resolve().then(() => __importStar(require('jszip')));
-            JSZipModuleObf = module.default || module;
-        }
-        catch (error) {
-            // Fall back to CommonJS require (Node.js)
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const module = require('jszip');
-                JSZipModuleObf = module.default || module;
-            }
-            catch (err2) {
-                throw new Error('Zip handling requires JSZip in this environment.');
-            }
-        }
-    }
-    if (!JSZipModuleObf) {
-        throw new Error('Zip handling requires JSZip in this environment.');
-    }
-    return JSZipModuleObf;
-}
+const zip_1 = require("../utils/zip");
 const OBF_FORMAT_VERSION = 'open-board-0.1';
 /**
  * Map OBF hidden value to AAC standard visibility
@@ -91,10 +67,12 @@ class ObfProcessor extends baseProcessor_1.BaseProcessor {
         ].filter(Boolean);
         for (const imagePath of possiblePaths) {
             try {
-                const file = this.zipFile.file(imagePath);
-                if (file) {
-                    const buffer = await file.async('nodebuffer');
-                    return buffer;
+                const buffer = await this.zipFile.readFile(imagePath);
+                if (buffer) {
+                    if (typeof Buffer !== 'undefined') {
+                        return Buffer.from(buffer);
+                    }
+                    return null;
                 }
             }
             catch (err) {
@@ -128,9 +106,8 @@ class ObfProcessor extends baseProcessor_1.BaseProcessor {
         ].filter(Boolean);
         for (const imagePath of possiblePaths) {
             try {
-                const file = this.zipFile.file(imagePath);
-                if (file) {
-                    const buffer = await file.async('uint8array');
+                const buffer = await this.zipFile.readFile(imagePath);
+                if (buffer) {
                     const contentType = imageData.content_type ||
                         this.getMimeTypeFromFilename(imagePath);
                     const dataUrl = `data:${contentType};base64,${(0, io_1.encodeBase64)(buffer)}`;
@@ -433,36 +410,28 @@ class ObfProcessor extends baseProcessor_1.BaseProcessor {
         if (!isLikelyZip(filePathOrBuffer)) {
             throw new Error('Invalid OBF content: not JSON and not ZIP');
         }
-        const JSZip = await getJSZipObf();
-        let zip;
         try {
-            const zipInput = (0, io_1.readBinaryFromInput)(filePathOrBuffer);
-            zip = await JSZip.loadAsync(zipInput);
+            const zipResult = await (0, zip_1.openZipFromInput)(filePathOrBuffer);
+            this.zipFile = zipResult.zip;
         }
         catch (err) {
-            console.error('[OBF] Error loading ZIP with JSZip:', err);
+            console.error('[OBF] Error loading ZIP:', err);
             throw err;
         }
         // Store the ZIP file reference for image extraction
-        this.zipFile = zip;
         this.imageCache.clear(); // Clear cache for new file
         console.log('[OBF] Detected zip archive, extracting .obf files');
         // Collect all .obf entries
-        const obfEntries = [];
-        zip.forEach((relativePath, file) => {
-            if (file.dir)
-                return;
-            if (relativePath.toLowerCase().endsWith('.obf')) {
-                obfEntries.push({ name: relativePath, file });
-            }
-        });
+        const obfEntries = this.zipFile
+            .listFiles()
+            .filter((name) => name.toLowerCase().endsWith('.obf'));
         // Process each .obf entry
-        for (const entry of obfEntries) {
+        for (const entryName of obfEntries) {
             try {
-                const content = await entry.file.async('string');
-                const boardData = tryParseObfJson(content);
+                const content = await this.zipFile.readFile(entryName);
+                const boardData = tryParseObfJson((0, io_1.decodeText)(content));
                 if (boardData) {
-                    const page = await this.processBoard(boardData, entry.name);
+                    const page = await this.processBoard(boardData, entryName);
                     tree.addPage(page);
                     // Set metadata if not already set (use first board as reference)
                     if (!tree.metadata.format) {
@@ -479,11 +448,11 @@ class ObfProcessor extends baseProcessor_1.BaseProcessor {
                     }
                 }
                 else {
-                    console.warn('[OBF] Skipped entry (not valid OBF JSON):', entry.name);
+                    console.warn('[OBF] Skipped entry (not valid OBF JSON):', entryName);
                 }
             }
             catch (err) {
-                console.warn('[OBF] Error processing entry:', entry.name, err);
+                console.warn('[OBF] Error processing entry:', entryName, err);
             }
         }
         return tree;
@@ -609,16 +578,31 @@ class ObfProcessor extends baseProcessor_1.BaseProcessor {
         }
         else {
             // Save as OBZ (zip with multiple OBF files)
-            const JSZip = await getJSZipObf();
-            const zip = new JSZip();
-            Object.values(tree.pages).forEach((page) => {
-                const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata);
-                const obfContent = JSON.stringify(obfBoard, null, 2);
-                zip.file(`${page.id}.obf`, obfContent);
-            });
-            const zipBuffer = await zip.generateAsync({ type: 'uint8array' });
-            const { writeBinaryToPath } = await Promise.resolve().then(() => __importStar(require('../utils/io')));
-            writeBinaryToPath(outputPath, zipBuffer);
+            if ((0, io_1.isNodeRuntime)()) {
+                const AdmZip = (0, io_1.getNodeRequire)()('adm-zip');
+                const zip = new AdmZip();
+                Object.values(tree.pages).forEach((page) => {
+                    const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata);
+                    const obfContent = JSON.stringify(obfBoard, null, 2);
+                    zip.addFile(`${page.id}.obf`, Buffer.from(obfContent, 'utf8'));
+                });
+                const zipBuffer = zip.toBuffer();
+                const { writeBinaryToPath } = await Promise.resolve().then(() => __importStar(require('../utils/io')));
+                writeBinaryToPath(outputPath, zipBuffer);
+            }
+            else {
+                const module = await Promise.resolve().then(() => __importStar(require('jszip')));
+                const JSZip = module.default || module;
+                const zip = new JSZip();
+                Object.values(tree.pages).forEach((page) => {
+                    const obfBoard = this.createObfBoardFromPage(page, 'Board', tree.metadata);
+                    const obfContent = JSON.stringify(obfBoard, null, 2);
+                    zip.file(`${page.id}.obf`, obfContent);
+                });
+                const zipBuffer = await zip.generateAsync({ type: 'uint8array' });
+                const { writeBinaryToPath } = await Promise.resolve().then(() => __importStar(require('../utils/io')));
+                writeBinaryToPath(outputPath, zipBuffer);
+            }
         }
     }
     /**

package/dist/processors/snapProcessor.js

@@ -1,18 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapProcessor = void 0;
 const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
 const idGenerator_1 = require("../utilities/analytics/utils/idGenerator");
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const crypto_1 = __importDefault(require("crypto"));
-const os_1 = __importDefault(require("os"));
 const snapValidator_1 = require("../validation/snapValidator");
+const io_1 = require("../utils/io");
+const sqlite_1 = require("../utils/sqlite");
 /**
  * Map Snap Visible value to AAC standard visibility
  * Snap: 0 = hidden, 1 (or non-zero) = visible
@@ -56,22 +50,10 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
     async loadIntoTree(filePathOrBuffer) {
         await Promise.resolve();
         const tree = new treeStructure_1.AACTree();
-        let tempDir = null;
-        const filePath = typeof filePathOrBuffer !== 'string'
-            ? (() => {
-                tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'snap-'));
-                return path_1.default.join(tempDir, 'input.spb');
-            })()
-            : filePathOrBuffer;
-        if (typeof filePathOrBuffer !== 'string') {
-            const buffer = Buffer.isBuffer(filePathOrBuffer)
-                ? filePathOrBuffer
-                : Buffer.from(filePathOrBuffer);
-            fs_1.default.writeFileSync(filePath, buffer);
-        }
-        let db = null;
+        let dbResult = null;
         try {
-            db = new better_sqlite3_1.default(filePath, { readonly: true });
+            dbResult = await (0, sqlite_1.openSqliteDatabase)(filePathOrBuffer, { readonly: true });
+            const db = dbResult.db;
             const getTableColumns = (tableName) => {
                 try {
                     const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
@@ -338,10 +320,12 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
              ${hasCommandSequence ? 'LEFT JOIN CommandSequence cs ON b.Id = cs.ButtonId' : ''}
              WHERE er.PageId = ? ${selectedPageLayoutId ? 'AND ep.PageLayoutId = ?' : ''}
            `;
-                    const queryParams = selectedPageLayoutId
-                        ? [pageRow.Id, selectedPageLayoutId]
-                        : [pageRow.Id];
-                    buttons = db.prepare(buttonQuery).all(...queryParams);
+                    if (selectedPageLayoutId) {
+                        buttons = db.prepare(buttonQuery).all(pageRow.Id, selectedPageLayoutId);
+                    }
+                    else {
+                        buttons = db.prepare(buttonQuery).all(pageRow.Id);
+                    }
                 }
                 catch (err) {
                     const errorMessage = err instanceof Error ? err.message : String(err);
@@ -606,22 +590,18 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
             }
         }
         finally {
-            // Ensure database is closed
-            if (db) {
-                db.close();
+            if (dbResult?.cleanup) {
+                dbResult.cleanup();
             }
-            // Clean up temporary file if created from buffer
-            if (tempDir && fs_1.default.existsSync(tempDir)) {
-                try {
-                    fs_1.default.rmSync(tempDir, { recursive: true, force: true });
-                }
-                catch (e) {
-                    console.warn('Failed to clean up temporary files:', e);
-                }
+            else if (dbResult?.db) {
+                dbResult.db.close();
             }
         }
     }
     async processTexts(filePathOrBuffer, translations, outputPath) {
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('processTexts is only supported in Node.js environments for Snap files.');
+        }
         // Load the tree, apply translations, and save to new file
         const tree = await this.loadIntoTree(filePathOrBuffer);
         // Apply translations to all text content
@@ -651,19 +631,26 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
         });
         // Save the translated tree and return its content
         await this.saveFromTree(tree, outputPath);
-        return fs_1.default.readFileSync(outputPath);
+        const fs = (0, io_1.getFs)();
+        return fs.readFileSync(outputPath);
     }
     async saveFromTree(tree, outputPath) {
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('saveFromTree is only supported in Node.js environments for Snap files.');
+        }
         await Promise.resolve();
-        const outputDir = path_1.default.dirname(outputPath);
-        if (!fs_1.default.existsSync(outputDir)) {
-            fs_1.default.mkdirSync(outputDir, { recursive: true });
+        const fs = (0, io_1.getFs)();
+        const path = (0, io_1.getPath)();
+        const outputDir = path.dirname(outputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
         }
-        if (fs_1.default.existsSync(outputPath)) {
-            fs_1.default.unlinkSync(outputPath);
+        if (fs.existsSync(outputPath)) {
+            fs.unlinkSync(outputPath);
         }
         // Create a new SQLite database for Snap format
-        const db = new better_sqlite3_1.default(outputPath, { readonly: false });
+        const Database = (0, sqlite_1.requireBetterSqlite3)();
+        const db = new Database(outputPath, { readonly: false });
         try {
             // Create basic Snap database schema (simplified)
             db.exec(`
@@ -852,7 +839,12 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
      */
     async addAudioToButton(dbPath, buttonId, audioData, metadata) {
         await Promise.resolve();
-        const db = new better_sqlite3_1.default(dbPath, { fileMustExist: true });
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('addAudioToButton is only supported in Node.js environments.');
+        }
+        const Database = (0, sqlite_1.requireBetterSqlite3)();
+        const crypto = (0, io_1.getNodeRequire)()('crypto');
+        const db = new Database(dbPath, { fileMustExist: true });
         try {
             // Ensure PageSetData table exists
             db.exec(`
@@ -863,7 +855,7 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
             );
         `);
             // Generate SHA1 hash for the identifier
-            const sha1Hash = crypto_1.default.createHash('sha1').update(audioData).digest('hex');
+            const sha1Hash = crypto.createHash('sha1').update(audioData).digest('hex');
             const identifier = `SND:${sha1Hash}`;
             // Check if audio with this identifier already exists
             let audioId;
@@ -894,8 +886,12 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
      * Create a copy of the pageset with audio recordings added
      */
     async createAudioEnhancedPageset(sourceDbPath, targetDbPath, audioMappings) {
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('createAudioEnhancedPageset is only supported in Node.js environments.');
+        }
+        const fs = (0, io_1.getFs)();
         // Copy the source database to target
-        fs_1.default.copyFileSync(sourceDbPath, targetDbPath);
+        fs.copyFileSync(sourceDbPath, targetDbPath);
         // Add audio recordings to the copy
         for (const [buttonId, audioInfo] of audioMappings.entries()) {
             await this.addAudioToButton(targetDbPath, buttonId, audioInfo.audioData, audioInfo.metadata);
@@ -905,7 +901,11 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
      * Extract buttons from a specific page that need audio recordings
      */
     extractButtonsForAudio(dbPath, pageUniqueId) {
-        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('extractButtonsForAudio is only supported in Node.js environments.');
+        }
+        const Database = (0, sqlite_1.requireBetterSqlite3)();
+        const db = new Database(dbPath, { readonly: true });
         try {
             // Find the page by UniqueId
             const page = db.prepare('SELECT * FROM Page WHERE UniqueId = ?').get(pageUniqueId);
@@ -962,13 +962,19 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
      * @returns Array of available PageLayouts with their dimensions
      */
     getAvailablePageLayouts(filePath) {
-        const dbPath = typeof filePath === 'string' ? filePath : path_1.default.join(process.cwd(), 'temp.spb');
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('getAvailablePageLayouts is only supported in Node.js environments.');
+        }
+        const fs = (0, io_1.getFs)();
+        const path = (0, io_1.getPath)();
+        const dbPath = typeof filePath === 'string' ? filePath : path.join(process.cwd(), 'temp.spb');
         if (Buffer.isBuffer(filePath)) {
-            fs_1.default.writeFileSync(dbPath, filePath);
+            fs.writeFileSync(dbPath, filePath);
         }
         let db = null;
         try {
-            db = new better_sqlite3_1.default(dbPath, { readonly: true });
+            const Database = (0, sqlite_1.requireBetterSqlite3)();
+            db = new Database(dbPath, { readonly: true });
             // Get unique PageLayouts based on PageLayoutSetting (dimensions)
             const pageLayouts = db
                 .prepare(`
@@ -1014,9 +1020,9 @@ class SnapProcessor extends baseProcessor_1.BaseProcessor {
                 db.close();
             }
             // Clean up temporary file if created from buffer
-            if (Buffer.isBuffer(filePath) && fs_1.default.existsSync(dbPath)) {
+            if (Buffer.isBuffer(filePath) && fs.existsSync(dbPath)) {
                 try {
-                    fs_1.default.unlinkSync(dbPath);
+                    fs.unlinkSync(dbPath);
                 }
                 catch (e) {
                     console.warn('Failed to clean up temporary file:', e);

package/dist/processors/touchchatProcessor.js

@@ -1,21 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TouchChatProcessor = void 0;
 const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
 const idGenerator_1 = require("../utilities/analytics/utils/idGenerator");
 const stringCasing_1 = require("../core/stringCasing");
-const adm_zip_1 = __importDefault(require("adm-zip"));
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
 const touchChatValidator_1 = require("../validation/touchChatValidator");
 const io_1 = require("../utils/io");
 const translationProcessor_1 = require("../utilities/translation/translationProcessor");
+const sqlite_1 = require("../utils/sqlite");
+const zip_1 = require("../utils/zip");
 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;
@@ -66,25 +60,22 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
     async loadIntoTree(filePathOrBuffer) {
         await Promise.resolve();
         // Unzip .ce file, extract the .c4v SQLite DB, and parse pages/buttons
-        let tmpDir = null;
         let db = null;
+        let cleanup;
         try {
             // Store source file path or buffer
             this.sourceFile = filePathOrBuffer;
             // Step 1: Unzip
-            tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'touchchat-'));
             const zipInput = (0, io_1.readBinaryFromInput)(filePathOrBuffer);
-            const zipBuffer = Buffer.isBuffer(zipInput) ? zipInput : Buffer.from(zipInput);
-            const zip = new adm_zip_1.default(zipBuffer);
-            zip.extractAllTo(tmpDir, true);
-            // Step 2: Find and open SQLite DB
-            const files = fs_1.default.readdirSync(tmpDir);
-            const vocabFile = files.find((f) => f.endsWith('.c4v'));
-            if (!vocabFile) {
+            const { zip } = await (0, zip_1.openZipFromInput)(zipInput);
+            const vocabEntry = zip.listFiles().find((name) => name.endsWith('.c4v'));
+            if (!vocabEntry) {
                 throw new Error('No .c4v vocab DB found in TouchChat export');
             }
-            const dbPath = path_1.default.join(tmpDir, vocabFile);
-            db = new better_sqlite3_1.default(dbPath, { readonly: true });
+            const dbBuffer = await zip.readFile(vocabEntry);
+            const dbResult = await (0, sqlite_1.openSqliteDatabase)(dbBuffer, { readonly: true });
+            db = dbResult.db;
+            cleanup = dbResult.cleanup;
             // Step 3: Create tree and load pages
             const tree = new treeStructure_1.AACTree();
             // Set root ID to the first page ID (will be updated if we find a better root)
@@ -476,20 +467,18 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
         }
         finally {
             // Clean up
-            if (db) {
-                db.close();
+            if (cleanup) {
+                cleanup();
             }
-            if (tmpDir && fs_1.default.existsSync(tmpDir)) {
-                try {
-                    fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
-                }
-                catch (e) {
-                    console.warn('Failed to clean up temp directory:', e);
-                }
+            else if (db) {
+                db.close();
             }
         }
     }
     async processTexts(filePathOrBuffer, translations, outputPath) {
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('processTexts is only supported in Node.js environments for TouchChat files.');
+        }
         // Load the tree, apply translations, and save to new file
         const tree = await this.loadIntoTree(filePathOrBuffer);
         // Apply translations to all text content
@@ -519,15 +508,23 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
         });
         // Save the translated tree and return its content
         await this.saveFromTree(tree, outputPath);
-        return fs_1.default.readFileSync(outputPath);
+        const fs = (0, io_1.getFs)();
+        return fs.readFileSync(outputPath);
     }
     async saveFromTree(tree, outputPath) {
         await Promise.resolve();
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('saveFromTree is only supported in Node.js environments for TouchChat files.');
+        }
+        const fs = (0, io_1.getFs)();
+        const path = (0, io_1.getPath)();
+        const os = (0, io_1.getOs)();
         // Create a TouchChat database that matches the expected schema for loading
-        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'touchchat-export-'));
-        const dbPath = path_1.default.join(tmpDir, 'vocab.c4v');
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'touchchat-export-'));
+        const dbPath = path.join(tmpDir, 'vocab.c4v');
         try {
-            const db = new better_sqlite3_1.default(dbPath);
+            const Database = (0, sqlite_1.requireBetterSqlite3)();
+            const db = new Database(dbPath);
             // Create schema that matches what loadIntoTree expects
             db.exec(`
         CREATE TABLE IF NOT EXISTS resources (
@@ -817,14 +814,15 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
             }
             db.close();
             // Create zip file with the database
-            const zip = new adm_zip_1.default();
+            const AdmZip = (0, io_1.getNodeRequire)()('adm-zip');
+            const zip = new AdmZip();
             zip.addLocalFile(dbPath, '', 'vocab.c4v');
             zip.writeZip(outputPath);
         }
         finally {
             // Clean up
-            if (fs_1.default.existsSync(tmpDir)) {
-                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            if (fs.existsSync(tmpDir)) {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
             }
         }
     }
@@ -961,6 +959,9 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
      * @returns Buffer of the translated TouchChat file
      */
     async processLLMTranslations(filePathOrBuffer, llmTranslations, outputPath, options) {
+        if (!(0, io_1.isNodeRuntime)()) {
+            throw new Error('processLLMTranslations is only supported in Node.js environments for TouchChat files.');
+        }
         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));
@@ -999,7 +1000,8 @@ class TouchChatProcessor extends baseProcessor_1.BaseProcessor {
         });
         // Save and return
         await this.saveFromTree(tree, outputPath);
-        return fs_1.default.readFileSync(outputPath);
+        const fs = (0, io_1.getFs)();
+        return fs.readFileSync(outputPath);
     }
 }
 exports.TouchChatProcessor = TouchChatProcessor;

package/dist/utils/io.d.ts

@@ -4,6 +4,8 @@ type NodeRequire = (id: string) => any;
 export declare function getNodeRequire(): NodeRequire;
 export declare function getFs(): typeof import('fs');
 export declare function getPath(): typeof import('path');
+export declare function getOs(): typeof import('os');
+export declare function isNodeRuntime(): boolean;
 export declare function getBasename(filePath: string): string;
 export declare function decodeText(input: Uint8Array): string;
 export declare function encodeBase64(input: Uint8Array): string;

package/dist/utils/io.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNodeRequire = getNodeRequire;
 exports.getFs = getFs;
 exports.getPath = getPath;
+exports.getOs = getOs;
+exports.isNodeRuntime = isNodeRuntime;
 exports.getBasename = getBasename;
 exports.decodeText = decodeText;
 exports.encodeBase64 = encodeBase64;
@@ -13,6 +15,7 @@ exports.writeBinaryToPath = writeBinaryToPath;
 exports.writeTextToPath = writeTextToPath;
 let cachedFs = null;
 let cachedPath = null;
+let cachedOs = null;
 let cachedRequire = undefined;
 function getNodeRequire() {
     if (cachedRequire === undefined) {
@@ -64,6 +67,25 @@ function getPath() {
     }
     return cachedPath;
 }
+function getOs() {
+    if (!cachedOs) {
+        try {
+            const nodeRequire = getNodeRequire();
+            const osModule = 'os';
+            cachedOs = nodeRequire(osModule);
+        }
+        catch {
+            throw new Error('OS utilities are not available in this environment.');
+        }
+    }
+    if (!cachedOs) {
+        throw new Error('OS utilities are not available in this environment.');
+    }
+    return cachedOs;
+}
+function isNodeRuntime() {
+    return typeof process !== 'undefined' && !!process.versions?.node;
+}
 function getBasename(filePath) {
     const parts = filePath.split(/[/\\]/);
     return parts[parts.length - 1] || filePath;

package/dist/utils/sqlite.d.ts

@@ -0,0 +1,21 @@
+import type { SqlJsConfig } from 'sql.js';
+export interface SqliteStatementAdapter {
+    all(...params: unknown[]): any[];
+    get(...params: unknown[]): any;
+    run(...params: unknown[]): any;
+}
+export interface SqliteDatabaseAdapter {
+    prepare(sql: string): SqliteStatementAdapter;
+    exec(sql: string): void;
+    close(): void;
+}
+export interface SqliteOpenOptions {
+    readonly?: boolean;
+}
+export interface SqliteOpenResult {
+    db: SqliteDatabaseAdapter;
+    cleanup?: () => void;
+}
+export declare function configureSqlJs(config: SqlJsConfig): void;
+export declare function requireBetterSqlite3(): typeof import('better-sqlite3');
+export declare function openSqliteDatabase(input: string | Uint8Array | ArrayBuffer | Buffer, options?: SqliteOpenOptions): Promise<SqliteOpenResult>;