@willwade/aac-processors 0.1.5 → 0.1.7

package/dist/processors/gridsetProcessor.js

@@ -40,31 +40,7 @@ const resolver_2 = require("./gridset/resolver");
 const idGenerator_1 = require("../utilities/analytics/utils/idGenerator");
 const symbolAlignment_1 = require("./gridset/symbolAlignment");
 const io_1 = require("../utils/io");
-let JSZipModule;
-async function getJSZip() {
-    if (!JSZipModule) {
-        try {
-            // Try ES module import first (browser/Vite)
-            const module = await Promise.resolve().then(() => __importStar(require('jszip')));
-            JSZipModule = 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');
-                JSZipModule = module.default || module;
-            }
-            catch (err2) {
-                throw new Error('Zip handling requires JSZip in this environment.');
-            }
-        }
-    }
-    if (!JSZipModule) {
-        throw new Error('Zip handling requires JSZip in this environment.');
-    }
-    return JSZipModule;
-}
+const zip_1 = require("../utils/zip");
 class GridsetProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -437,17 +413,15 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
     }
     async loadIntoTree(filePathOrBuffer) {
         const tree = new treeStructure_1.AACTree();
-        let zip;
+        let zipResult;
         try {
-            const JSZip = await getJSZip();
-            const zipInput = (0, io_1.readBinaryFromInput)(filePathOrBuffer);
-            zip = await JSZip.loadAsync(zipInput);
+            zipResult = await (0, zip_1.openZipFromInput)((0, io_1.readBinaryFromInput)(filePathOrBuffer));
         }
         catch (error) {
             throw new Error(`Invalid ZIP file format: ${error.message}`);
         }
         const password = this.getGridsetPassword(filePathOrBuffer);
-        const entries = (0, password_1.getZipEntriesWithPassword)(zip, password);
+        const entries = (0, password_1.getZipEntriesFromAdapter)(zipResult.zip, password);
         const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false });
         const isEncryptedArchive = typeof filePathOrBuffer === 'string' && filePathOrBuffer.toLowerCase().endsWith('.gridsetx');
         const encryptedContentPassword = this.getGridsetPassword(filePathOrBuffer);
@@ -458,14 +432,11 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
             passwordProtected: !!password,
         };
         const readEntryBuffer = async (entry) => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument
             const raw = await entry.getData();
             if (!isEncryptedArchive) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return raw;
             }
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return
-            return (0, crypto_1.decryptGridsetEntry)(raw, encryptedContentPassword);
+            return (0, crypto_1.decryptGridsetEntry)(Buffer.from(raw), encryptedContentPassword);
         };
         // Parse FileMap.xml if present to index dynamic files per grid
         const fileMapIndex = new Map();
@@ -785,7 +756,7 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                         const gridEntryPath = entry.entryName.replace(/\\/g, '/');
                         const baseDir = gridEntryPath.replace(/\/grid\.xml$/, '/');
                         const dynamicFiles = fileMapIndex.get(gridEntryPath) || [];
-                        const resolvedImageEntry = (0, resolver_1.resolveGrid3CellImage)(zip, {
+                        const resolvedImageEntry = (0, resolver_1.resolveGrid3CellImage)(null, {
                             baseDir,
                             imageName: declaredImageName,
                             x: cellX + 1,
@@ -1636,11 +1607,36 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
         return (0, io_1.readBinaryFromInput)(outputPath);
     }
     async saveFromTree(tree, outputPath) {
-        const JSZip = await getJSZip();
-        const zip = new JSZip();
+        const useNodeZip = (0, io_1.isNodeRuntime)();
+        let addText;
+        let addBinary;
+        let finalizeZip;
+        if (useNodeZip) {
+            const AdmZip = (0, io_1.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 Promise.resolve().then(() => __importStar(require('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' });
+        }
         if (Object.keys(tree.pages).length === 0) {
             // Create empty zip for empty tree
-            const zipBuffer = await zip.generateAsync({ type: 'uint8array' });
+            const zipBuffer = await finalizeZip();
             (0, io_1.writeBinaryToPath)(outputPath, zipBuffer);
             return;
         }
@@ -1713,7 +1709,7 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
             suppressEmptyNode: true,
         });
         const settingsXmlContent = settingsBuilder.build(settingsData);
-        zip.file('Settings0/settings.xml', settingsXmlContent, { binary: false });
+        addText('Settings0/settings.xml', settingsXmlContent);
         // Create Settings0/Styles/style.xml if there are styles
         if (uniqueStyles.size > 0) {
             const stylesArray = Array.from(uniqueStyles.values()).map(({ id, style }) => {
@@ -1746,7 +1742,7 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                 indentBy: '  ',
             });
             const styleXmlContent = styleBuilder.build(styleData);
-            zip.file('Settings0/Styles/styles.xml', styleXmlContent, { binary: false });
+            addText('Settings0/Styles/styles.xml', styleXmlContent);
         }
         // Collect grid file paths for FileMap.xml
         const gridFilePaths = [];
@@ -1887,14 +1883,14 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
             // Add to zip in Grids folder with proper Grid3 naming
             const gridPath = `Grids/${page.name || page.id}/grid.xml`;
             gridFilePaths.push(gridPath);
-            zip.file(gridPath, xmlContent, { binary: false });
+            addText(gridPath, 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}`;
-                zip.file(imagePath, imgData.imageData);
+                addBinary(imagePath, imgData.imageData);
             }
         });
         // Create FileMap.xml to map all grid files with their dynamic image files
@@ -1933,9 +1929,9 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
             indentBy: '  ',
         });
         const fileMapXmlContent = fileMapBuilder.build(fileMapData);
-        zip.file('FileMap.xml', fileMapXmlContent, { binary: false });
+        addText('FileMap.xml', fileMapXmlContent);
         // Write the zip file
-        const zipBuffer = await zip.generateAsync({ type: 'uint8array' });
+        const zipBuffer = await finalizeZip();
         (0, io_1.writeBinaryToPath)(outputPath, zipBuffer);
     }
     // Helper method to calculate column definitions based on page layout

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);