@willwade/aac-processors 0.1.20 → 0.2.0

package/dist/utilities/analytics/reference/index.d.ts

@@ -5,17 +5,18 @@
  * for AAC metrics analysis.
  */
 import { CoreList, CommonWordsData, SynonymsData } from '../metrics/types';
+import { FileAdapter } from '../../../utils/io';
 export interface ReferenceDataProvider {
-    loadCoreLists(): CoreList[];
-    loadCommonWords(): CommonWordsData;
-    loadSynonyms(): SynonymsData;
-    loadSentences(): string[][];
-    loadFringe(): string[];
-    loadBaseWords(): {
+    loadCoreLists(): Promise<CoreList[]>;
+    loadCommonWords(): Promise<CommonWordsData>;
+    loadSynonyms(): Promise<SynonymsData>;
+    loadSentences(): Promise<string[][]>;
+    loadFringe(): Promise<string[]>;
+    loadBaseWords(): Promise<{
         [word: string]: boolean;
-    };
-    loadCommonFringe(): string[];
-    loadAll(): {
+    }>;
+    loadCommonFringe(): Promise<string[]>;
+    loadAll(): Promise<{
         coreLists: CoreList[];
         commonWords: CommonWordsData;
         synonyms: SynonymsData;
@@ -24,48 +25,49 @@ export interface ReferenceDataProvider {
         baseWords: {
             [word: string]: boolean;
         };
-    };
+    }>;
 }
 export declare class ReferenceLoader {
     private dataDir;
     private locale;
-    constructor(dataDir?: string, locale?: string);
+    private fileAdapter;
+    constructor(dataDir?: string, locale?: string, fileAdapter?: FileAdapter);
     /**
      * Load core vocabulary lists
      */
-    loadCoreLists(): CoreList[];
+    loadCoreLists(): Promise<CoreList[]>;
     /**
      * Load common words with baseline effort scores
      */
-    loadCommonWords(): CommonWordsData;
+    loadCommonWords(): Promise<CommonWordsData>;
     /**
      * Load synonym mappings
      */
-    loadSynonyms(): SynonymsData;
+    loadSynonyms(): Promise<SynonymsData>;
     /**
      * Load test sentences
      */
-    loadSentences(): string[][];
+    loadSentences(): Promise<string[][]>;
     /**
      * Load fringe vocabulary
      */
-    loadFringe(): string[];
+    loadFringe(): Promise<string[]>;
     /**
      * Load base words hash map
      */
-    loadBaseWords(): {
+    loadBaseWords(): Promise<{
         [word: string]: boolean;
-    };
+    }>;
     /**
      * Load common fringe vocabulary
      * Common words that are NOT in core vocabulary lists
      * (matching Ruby loader.rb:413-420)
      */
-    loadCommonFringe(): string[];
+    loadCommonFringe(): Promise<string[]>;
     /**
      * Get all reference data at once
      */
-    loadAll(): {
+    loadAll(): Promise<{
         coreLists: CoreList[];
         commonWords: CommonWordsData;
         synonyms: SynonymsData;
@@ -74,13 +76,13 @@ export declare class ReferenceLoader {
         baseWords: {
             [word: string]: boolean;
         };
-    };
+    }>;
 }
 /**
  * Get the default reference data path
  */
-export declare function getReferenceDataPath(): string;
+export declare function getReferenceDataPath(fileAdapter?: FileAdapter): string;
 /**
  * Check if reference data files exist
  */
-export declare function hasReferenceData(): boolean;
+export declare function hasReferenceData(fileAdapter?: FileAdapter): Promise<boolean>;

package/dist/utilities/analytics/reference/index.js

@@ -11,55 +11,61 @@ exports.getReferenceDataPath = getReferenceDataPath;
 exports.hasReferenceData = hasReferenceData;
 const io_1 = require("../../../utils/io");
 class ReferenceLoader {
-    constructor(dataDir, locale = 'en') {
+    constructor(dataDir, locale = 'en', fileAdapter = io_1.defaultFileAdapter) {
         this.locale = locale;
+        this.fileAdapter = fileAdapter;
         if (dataDir) {
             this.dataDir = dataDir;
         }
         else {
             // Resolve the data directory relative to this file's location
             // Use __dirname which works correctly after compilation
-            this.dataDir = (0, io_1.getPath)().join(__dirname, 'data');
+            this.dataDir = this.fileAdapter.join(__dirname, 'data');
         }
     }
     /**
      * Load core vocabulary lists
      */
-    loadCoreLists() {
-        const filePath = (0, io_1.getPath)().join(this.dataDir, `core_lists.${this.locale}.json`);
-        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+    async loadCoreLists() {
+        const { readTextFromInput } = this.fileAdapter;
+        const filePath = this.fileAdapter.join(this.dataDir, `core_lists.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load common words with baseline effort scores
      */
-    loadCommonWords() {
-        const filePath = (0, io_1.getPath)().join(this.dataDir, `common_words.${this.locale}.json`);
-        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+    async loadCommonWords() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `common_words.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load synonym mappings
      */
-    loadSynonyms() {
-        const filePath = (0, io_1.getPath)().join(this.dataDir, `synonyms.${this.locale}.json`);
-        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+    async loadSynonyms() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `synonyms.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load test sentences
      */
-    loadSentences() {
-        const filePath = (0, io_1.getPath)().join(this.dataDir, `sentences.${this.locale}.json`);
-        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+    async loadSentences() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `sentences.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load fringe vocabulary
      */
-    loadFringe() {
-        const filePath = (0, io_1.getPath)().join(this.dataDir, `fringe.${this.locale}.json`);
-        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+    async loadFringe() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `fringe.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         const data = JSON.parse(String(content));
         // Flatten nested category words if needed
         if (Array.isArray(data) && data.length > 0 && data[0].categories) {
@@ -76,9 +82,10 @@ class ReferenceLoader {
     /**
      * Load base words hash map
      */
-    loadBaseWords() {
-        const filePath = (0, io_1.getPath)().join(this.dataDir, `base_words.${this.locale}.json`);
-        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+    async loadBaseWords() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `base_words.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
@@ -86,10 +93,10 @@ class ReferenceLoader {
      * Common words that are NOT in core vocabulary lists
      * (matching Ruby loader.rb:413-420)
      */
-    loadCommonFringe() {
-        const commonWordsData = this.loadCommonWords();
+    async loadCommonFringe() {
+        const commonWordsData = await this.loadCommonWords();
         const commonWords = new Set(commonWordsData.words.map((w) => w.toLowerCase()));
-        const coreLists = this.loadCoreLists();
+        const coreLists = await this.loadCoreLists();
         const coreWords = new Set();
         coreLists.forEach((list) => {
             list.words.forEach((word) => coreWords.add(word.toLowerCase()));
@@ -101,14 +108,14 @@ class ReferenceLoader {
     /**
      * Get all reference data at once
      */
-    loadAll() {
+    async loadAll() {
         return {
-            coreLists: this.loadCoreLists(),
-            commonWords: this.loadCommonWords(),
-            synonyms: this.loadSynonyms(),
-            sentences: this.loadSentences(),
-            fringe: this.loadFringe(),
-            baseWords: this.loadBaseWords(),
+            coreLists: await this.loadCoreLists(),
+            commonWords: await this.loadCommonWords(),
+            synonyms: await this.loadSynonyms(),
+            sentences: await this.loadSentences(),
+            fringe: await this.loadFringe(),
+            baseWords: await this.loadBaseWords(),
         };
     }
 }
@@ -116,13 +123,14 @@ exports.ReferenceLoader = ReferenceLoader;
 /**
  * Get the default reference data path
  */
-function getReferenceDataPath() {
-    return String((0, io_1.getPath)().join(__dirname, 'data'));
+function getReferenceDataPath(fileAdapter = io_1.defaultFileAdapter) {
+    return String(fileAdapter.join(__dirname, 'data'));
 }
 /**
  * Check if reference data files exist
  */
-function hasReferenceData() {
+async function hasReferenceData(fileAdapter = io_1.defaultFileAdapter) {
+    const { pathExists, join } = fileAdapter;
     const dataPath = getReferenceDataPath();
     const requiredFiles = [
         'core_lists.en.json',
@@ -131,5 +139,6 @@ function hasReferenceData() {
         'synonyms.en.json',
         'fringe.en.json',
     ];
-    return requiredFiles.every((file) => (0, io_1.getFs)().existsSync((0, io_1.getPath)().join(dataPath, file)));
+    const existingPaths = await Promise.all(requiredFiles.map(async (file) => await pathExists(join(dataPath, file))));
+    return existingPaths.every((exists) => exists);
 }

package/dist/utilities/symbolTools.d.ts

@@ -1,28 +1,30 @@
+import { FileAdapter } from '../utils/io';
 export declare abstract class SymbolExtractor {
     abstract getSymbolReferences(filePath: string): string[];
 }
 export declare abstract class SymbolResolver {
     protected symbolPath: string;
     protected dbPath: string;
-    constructor(symbolPath: string, dbPath: string);
-    abstract resolveSymbol(symbolRef: string): string | null;
+    protected fileAdapter: FileAdapter;
+    constructor(symbolPath: string, dbPath: string, fileAdapter?: FileAdapter);
+    abstract resolveSymbol(symbolRef: string): Promise<string | null>;
 }
 export declare class SnapSymbolExtractor extends SymbolExtractor {
     getSymbolReferences(filePath: string): string[];
 }
 export declare class SnapSymbolResolver extends SymbolResolver {
-    resolveSymbol(symbolRef: string): string | null;
+    resolveSymbol(symbolRef: string): Promise<string | null>;
 }
 export declare class Grid3SymbolExtractor extends SymbolExtractor {
     getSymbolReferences(filePath: string): string[];
 }
 export declare class Grid3SymbolResolver extends SymbolResolver {
-    resolveSymbol(symbolRef: string): string | null;
+    resolveSymbol(symbolRef: string): Promise<string | null>;
 }
 export declare class TouchChatSymbolExtractor extends SymbolExtractor {
     getSymbolReferences(_filePath: string): string[];
 }
 export declare class TouchChatSymbolResolver extends SymbolResolver {
-    resolveSymbol(symbolRef: string): string | null;
+    resolveSymbol(symbolRef: string): Promise<string | null>;
 }
-export declare function resolveSymbol(label: string, symbolDir: string): string | null;
+export declare function resolveSymbol(label: string, symbolDir: string, fileAdapter?: FileAdapter): Promise<string | null>;

package/dist/utilities/symbolTools.js

@@ -1,21 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TouchChatSymbolResolver = exports.TouchChatSymbolExtractor = exports.Grid3SymbolResolver = exports.Grid3SymbolExtractor = exports.SnapSymbolResolver = exports.SnapSymbolExtractor = exports.SymbolResolver = exports.SymbolExtractor = void 0;
 exports.resolveSymbol = resolveSymbol;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
 const symbols_1 = require("../processors/gridset/symbols");
+const io_1 = require("../utils/io");
 // --- Base Classes ---
 class SymbolExtractor {
 }
 exports.SymbolExtractor = SymbolExtractor;
 class SymbolResolver {
-    constructor(symbolPath, dbPath) {
+    constructor(symbolPath, dbPath, fileAdapter = io_1.defaultFileAdapter) {
         this.symbolPath = symbolPath;
         this.dbPath = dbPath;
+        this.fileAdapter = fileAdapter;
     }
 }
 exports.SymbolResolver = SymbolResolver;
@@ -42,7 +39,8 @@ class SnapSymbolExtractor extends SymbolExtractor {
 }
 exports.SnapSymbolExtractor = SnapSymbolExtractor;
 class SnapSymbolResolver extends SymbolResolver {
-    resolveSymbol(symbolRef) {
+    async resolveSymbol(symbolRef) {
+        const { join, writeBinaryToPath } = this.fileAdapter;
         if (!Database)
             throw new Error('better-sqlite3 not installed');
         const db = new Database(this.dbPath, { readonly: true });
@@ -51,8 +49,8 @@ class SnapSymbolResolver extends SymbolResolver {
         db.close();
         if (!row)
             return null;
-        const outPath = path_1.default.join(this.symbolPath, `${symbolRef}.png`);
-        fs_1.default.writeFileSync(outPath, row.ImageData);
+        const outPath = join(this.symbolPath, `${symbolRef}.png`);
+        await writeBinaryToPath(outPath, row.ImageData);
         return outPath;
     }
 }
@@ -88,10 +86,12 @@ class Grid3SymbolExtractor extends SymbolExtractor {
 }
 exports.Grid3SymbolExtractor = Grid3SymbolExtractor;
 class Grid3SymbolResolver extends SymbolResolver {
-    resolveSymbol(symbolRef) {
+    async resolveSymbol(symbolRef) {
+        const { join, pathExists } = this.fileAdapter;
         // Implementation depends on Grid 3 symbol storage format
-        const symbolPath = path_1.default.join(this.symbolPath, symbolRef);
-        return fs_1.default.existsSync(symbolPath) ? symbolPath : null;
+        const symbolPath = join(this.symbolPath, symbolRef);
+        const exists = await pathExists(symbolPath);
+        return exists ? symbolPath : null;
     }
 }
 exports.Grid3SymbolResolver = Grid3SymbolResolver;
@@ -104,20 +104,23 @@ class TouchChatSymbolExtractor extends SymbolExtractor {
 }
 exports.TouchChatSymbolExtractor = TouchChatSymbolExtractor;
 class TouchChatSymbolResolver extends SymbolResolver {
-    resolveSymbol(symbolRef) {
+    async resolveSymbol(symbolRef) {
+        const { join, pathExists } = this.fileAdapter;
         // Implementation depends on TouchChat symbol storage format
-        const symbolPath = path_1.default.join(this.symbolPath, symbolRef);
-        return fs_1.default.existsSync(symbolPath) ? symbolPath : null;
+        const symbolPath = join(this.symbolPath, symbolRef);
+        const exists = await pathExists(symbolPath);
+        return exists ? symbolPath : null;
     }
 }
 exports.TouchChatSymbolResolver = TouchChatSymbolResolver;
 // --- Simple fallback function for PCS-style lookup ---
-function resolveSymbol(label, symbolDir) {
+async function resolveSymbol(label, symbolDir, fileAdapter = io_1.defaultFileAdapter) {
+    const { join, pathExists } = fileAdapter;
     const cleanLabel = label.toLowerCase().replace(/[^a-z0-9]/g, '');
     const exts = ['.png', '.jpg', '.svg'];
     for (const ext of exts) {
-        const symbolPath = path_1.default.join(symbolDir, cleanLabel + ext);
-        if (fs_1.default.existsSync(symbolPath)) {
+        const symbolPath = join(symbolDir, cleanLabel + ext);
+        if (await pathExists(symbolPath)) {
             return symbolPath;
         }
     }

package/dist/utils/io.d.ts

@@ -1,9 +1,28 @@
 export type ProcessorInput = string | Buffer | ArrayBuffer | Uint8Array;
 export type BinaryOutput = Buffer | Uint8Array;
+export interface FileAdapter {
+    readBinaryFromInput: (input: ProcessorInput) => Promise<Uint8Array>;
+    readTextFromInput: (input: ProcessorInput, encoding?: BufferEncoding) => Promise<string>;
+    writeBinaryToPath: (outputPath: string, data: BinaryOutput) => Promise<void>;
+    writeTextToPath: (outputPath: string, text: string) => Promise<void>;
+    pathExists: (path: string) => Promise<boolean>;
+    isDirectory: (path: string) => Promise<boolean>;
+    getFileSize: (path: string) => Promise<number>;
+    mkDir: (path: string, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    listDir: (path: string) => Promise<string[]>;
+    removePath: (path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }) => Promise<void>;
+    mkTempDir: (prefix: string) => Promise<string>;
+    join: (...pathParts: string[]) => string;
+    dirname: (path: string) => string;
+    basename: (path: string, suffix?: string) => string;
+}
 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;
@@ -12,8 +31,7 @@ export declare function toArrayBuffer(input: Uint8Array | ArrayBuffer | Buffer):
 export declare function decodeText(input: Uint8Array): string;
 export declare function encodeBase64(input: Uint8Array): string;
 export declare function encodeText(text: string): BinaryOutput;
-export declare function readBinaryFromInput(input: ProcessorInput): Uint8Array;
-export declare function readTextFromInput(input: ProcessorInput, encoding?: BufferEncoding): string;
-export declare function writeBinaryToPath(outputPath: string, data: BinaryOutput): void;
-export declare function writeTextToPath(outputPath: string, text: string): void;
+export declare function extname(path: string): string;
+export declare function joinWin32(...pathParts: string[]): string;
+export declare const defaultFileAdapter: FileAdapter;
 export {};

package/dist/utils/io.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileAdapter = void 0;
 exports.getNodeRequire = getNodeRequire;
-exports.getFs = getFs;
-exports.getPath = getPath;
 exports.getOs = getOs;
 exports.isNodeRuntime = isNodeRuntime;
 exports.getBasename = getBasename;
@@ -11,10 +10,8 @@ exports.toArrayBuffer = toArrayBuffer;
 exports.decodeText = decodeText;
 exports.encodeBase64 = encodeBase64;
 exports.encodeText = encodeText;
-exports.readBinaryFromInput = readBinaryFromInput;
-exports.readTextFromInput = readTextFromInput;
-exports.writeBinaryToPath = writeBinaryToPath;
-exports.writeTextToPath = writeTextToPath;
+exports.extname = extname;
+exports.joinWin32 = joinWin32;
 let cachedFs = null;
 let cachedPath = null;
 let cachedOs = null;
@@ -41,7 +38,7 @@ function getFs() {
     if (!cachedFs) {
         try {
             const nodeRequire = getNodeRequire();
-            const fsModule = 'fs';
+            const fsModule = 'node:fs';
             cachedFs = nodeRequire(fsModule);
         }
         catch {
@@ -131,37 +128,94 @@ function encodeText(text) {
     }
     return new TextEncoder().encode(text);
 }
-function readBinaryFromInput(input) {
+// extname algorithm from node:path
+const splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/; //eslint-disable-line
+const splitTailRe = /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/; //eslint-disable-line
+function extname(path) {
+    const tail = splitDeviceRe.exec(path)?.at(3) ?? '';
+    return splitTailRe.exec(tail)?.at(3) ?? '';
+}
+async function readBinaryFromInput(input) {
     if (typeof input === 'string') {
-        const fs = getFs();
-        return fs.readFileSync(input);
+        return Promise.resolve(getFs().readFileSync(input));
     }
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
-        return input;
+        return Promise.resolve(input);
     }
     if (input instanceof ArrayBuffer) {
-        return new Uint8Array(input);
+        return Promise.resolve(new Uint8Array(input));
     }
-    return input;
+    return Promise.resolve(input);
 }
-function readTextFromInput(input, encoding = 'utf8') {
+async function readTextFromInput(input, encoding = 'utf8') {
     if (typeof input === 'string') {
-        const fs = getFs();
-        return fs.readFileSync(input, encoding);
+        return Promise.resolve(getFs().readFileSync(input, encoding));
     }
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
-        return input.toString(encoding);
+        return Promise.resolve(input.toString(encoding));
     }
     if (input instanceof ArrayBuffer) {
-        return decodeText(new Uint8Array(input));
+        return Promise.resolve(decodeText(new Uint8Array(input)));
     }
-    return decodeText(input);
+    return Promise.resolve(decodeText(input));
+}
+async function writeBinaryToPath(outputPath, data) {
+    getFs().writeFileSync(outputPath, data);
+    await Promise.resolve();
+}
+async function writeTextToPath(outputPath, text) {
+    getFs().writeFileSync(outputPath, text, 'utf8');
+    await Promise.resolve();
+}
+async function pathExists(path) {
+    return Promise.resolve(getFs().existsSync(path));
+}
+async function isDirectory(path) {
+    return Promise.resolve(getFs().statSync(path).isDirectory());
+}
+async function getFileSize(path) {
+    return Promise.resolve(getFs().statSync(path).size);
+}
+async function mkDir(path, options) {
+    getFs().mkdirSync(path, options);
+    await Promise.resolve();
+}
+async function listDir(path) {
+    return Promise.resolve(getFs().readdirSync(path));
+}
+async function removePath(path, options) {
+    getFs().rmSync(path, options);
+    await Promise.resolve();
+}
+async function mkTempDir(prefix) {
+    const path = join(getOs().tmpdir(), prefix);
+    return Promise.resolve(getFs().mkdtempSync(path));
+}
+function join(...pathParts) {
+    return getPath().join(...pathParts);
+}
+function joinWin32(...pathParts) {
+    return getPath().win32.join(...pathParts);
 }
-function writeBinaryToPath(outputPath, data) {
-    const fs = getFs();
-    fs.writeFileSync(outputPath, data);
+function dirname(path) {
+    return getPath().dirname(path);
 }
-function writeTextToPath(outputPath, text) {
-    const fs = getFs();
-    fs.writeFileSync(outputPath, text, 'utf8');
+function basename(path, suffix) {
+    return getPath().basename(path, suffix);
 }
+exports.defaultFileAdapter = {
+    readBinaryFromInput,
+    readTextFromInput,
+    writeBinaryToPath,
+    writeTextToPath,
+    pathExists,
+    isDirectory,
+    getFileSize,
+    mkDir,
+    listDir,
+    removePath,
+    mkTempDir,
+    join,
+    dirname,
+    basename,
+};

package/dist/utils/sqlite.d.ts

@@ -1,4 +1,5 @@
 import type { SqlJsConfig } from 'sql.js';
+import { FileAdapter } from './io';
 export interface SqliteStatementAdapter {
     all(...params: unknown[]): any[];
     get(...params: unknown[]): any;
@@ -11,10 +12,11 @@ export interface SqliteDatabaseAdapter {
 }
 export interface SqliteOpenOptions {
     readonly?: boolean;
+    fileAdapter?: FileAdapter;
 }
 export interface SqliteOpenResult {
     db: SqliteDatabaseAdapter;
-    cleanup?: () => void;
+    cleanup?: () => Promise<void>;
 }
 export declare function configureSqlJs(config: SqlJsConfig): void;
 export declare function requireBetterSqlite3(): typeof import('better-sqlite3');

package/dist/utils/sqlite.js

@@ -98,6 +98,7 @@ function requireBetterSqlite3() {
     return getBetterSqlite3();
 }
 async function openSqliteDatabase(input, options = {}) {
+    const { readBinaryFromInput, mkTempDir, writeBinaryToPath, removePath, join } = options.fileAdapter ?? io_1.defaultFileAdapter;
     if (typeof input === 'string') {
         if (!(0, io_1.isNodeRuntime)()) {
             throw new Error('SQLite file paths are not supported in browser environments.');
@@ -106,27 +107,24 @@ async function openSqliteDatabase(input, options = {}) {
         const db = new Database(input, { readonly: options.readonly ?? true });
         return { db };
     }
-    const data = (0, io_1.readBinaryFromInput)(input);
+    const data = await readBinaryFromInput(input);
     if (!(0, io_1.isNodeRuntime)()) {
         const SQL = await getSqlJs();
         const db = new SQL.Database(data);
         return { db: createSqlJsAdapter(db) };
     }
-    const fs = (0, io_1.getFs)();
-    const path = (0, io_1.getPath)();
-    const os = (0, io_1.getOs)();
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aac-sqlite-'));
-    const dbPath = path.join(tempDir, 'input.sqlite');
-    fs.writeFileSync(dbPath, data);
+    const tempDir = await mkTempDir('aac-sqlite-');
+    const dbPath = join(tempDir, 'input.sqlite');
+    await writeBinaryToPath(dbPath, data);
     const Database = getBetterSqlite3();
     const db = new Database(dbPath, { readonly: options.readonly ?? true });
-    const cleanup = () => {
+    const cleanup = async () => {
         try {
             db.close();
         }
         finally {
             try {
-                fs.rmSync(tempDir, { recursive: true, force: true });
+                await removePath(tempDir, { recursive: true, force: true });
             }
             catch (error) {
                 console.warn('Failed to clean up temporary SQLite files:', error);

package/dist/utils/zip.d.ts

@@ -1,7 +1,11 @@
+import { ProcessorInput, FileAdapter } from './io';
 export interface ZipAdapter {
     listFiles(): string[];
     readFile(name: string): Promise<Uint8Array>;
+    writeFiles(files: ZipFile[]): Promise<Uint8Array>;
 }
-export declare function openZipFromInput(input: string | Uint8Array | ArrayBuffer | Buffer): Promise<{
-    zip: ZipAdapter;
-}>;
+export interface ZipFile {
+    name: string;
+    data: string | Uint8Array;
+}
+export declare function getZipAdapter(input?: ProcessorInput, fileAdapter?: FileAdapter): Promise<ZipAdapter>;