esp32tool 1.0.0

package/src/wasm/littlefs/index.d.ts

@@ -0,0 +1,83 @@
+import type { FileSource, BinarySource } from "../shared/types";
+
+/**
+ * Maximum filename length (ESP-IDF default: 64)
+ */
+export declare const LFS_NAME_MAX: number;
+
+/**
+ * LittleFS disk version 2.0 (0x00020000)
+ * Use this for maximum compatibility with older implementations.
+ */
+export declare const DISK_VERSION_2_0: number;
+
+/**
+ * LittleFS disk version 2.1 (0x00020001)
+ * Latest version with additional features.
+ */
+export declare const DISK_VERSION_2_1: number;
+
+/**
+ * Format disk version as human-readable string (e.g., "2.0", "2.1")
+ */
+export declare function formatDiskVersion(version: number): string;
+
+export interface LittleFSEntry {
+    path: string;
+    size: number;
+    type: "file" | "dir";
+}
+
+export interface LittleFSOptions {
+    blockSize?: number;
+    blockCount?: number;
+    lookaheadSize?: number;
+    /**
+     * Optional override for the wasm asset location. Useful when bundlers move files.
+     */
+    wasmURL?: string | URL;
+    /**
+     * Formats the filesystem immediately after initialization.
+     */
+    formatOnInit?: boolean;
+    /**
+     * Disk version to use when formatting new filesystems.
+     * Use DISK_VERSION_2_0 for compatibility with older ESP implementations.
+     * Use DISK_VERSION_2_1 for latest features.
+     * 
+     * IMPORTANT: Setting this prevents automatic migration of older filesystems.
+     */
+    diskVersion?: number;
+}
+
+export interface LittleFS {
+    format(): void;
+    list(path?: string): LittleFSEntry[];
+    addFile(path: string, data: FileSource): void;
+    writeFile(path: string, data: FileSource): void;
+    deleteFile(path: string): void;
+    delete(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    mkdir(path: string): void;
+    rename(oldPath: string, newPath: string): void;
+    toImage(): Uint8Array;
+    readFile(path: string): Uint8Array;
+    /**
+     * Get the disk version of the mounted filesystem.
+     * @returns Version as 32-bit number (e.g., 0x00020000 for v2.0)
+     */
+    getDiskVersion(): number;
+    /**
+     * Get filesystem usage statistics.
+     */
+    getUsage(): { capacityBytes: number; usedBytes: number; freeBytes: number };
+}
+
+export declare class LittleFSError extends Error {
+    readonly code: number;
+    constructor(message: string, code: number);
+}
+
+export declare function createLittleFS(options?: LittleFSOptions): Promise<LittleFS>;
+export declare function createLittleFSFromImage(image: BinarySource, options?: LittleFSOptions): Promise<LittleFS>;

package/src/wasm/littlefs/index.js

@@ -0,0 +1,529 @@
+/**
+ * LittleFS WebAssembly Bindings for ESPConnect
+ * 
+ * Provides TypeScript-first API for LittleFS with disk version control.
+ * Supports DISK_VERSION_2_0 to prevent automatic migration of older filesystems.
+ * 
+ * ESP-IDF Compatible Configuration:
+ * - LFS_NAME_MAX=64 (filename length)
+ * - LFS_ATTR_MAX=4 (metadata for timestamps)
+ * - LFS_MULTIVERSION enabled
+ */
+
+// Import Emscripten-generated module loader (converted to ES module)
+import createLittleFSModule from './littlefs.js';
+
+const DEFAULT_BLOCK_SIZE = 4096;
+const DEFAULT_BLOCK_COUNT = 256;
+const DEFAULT_LOOKAHEAD_SIZE = 32;
+const LFS_ERR_NOSPC = -28;
+
+/**
+ * Maximum filename length (ESP-IDF default)
+ */
+export const LFS_NAME_MAX = 64;
+
+/**
+ * LittleFS disk version 2.0 (0x00020000)
+ * Use this for maximum compatibility with older implementations.
+ */
+export const DISK_VERSION_2_0 = 0x00020000;
+
+/**
+ * LittleFS disk version 2.1 (0x00020001)
+ * Latest version with additional features.
+ */
+export const DISK_VERSION_2_1 = 0x00020001;
+
+/**
+ * Format disk version as human-readable string (e.g., "2.0", "2.1")
+ */
+export function formatDiskVersion(version) {
+    const major = (version >> 16) & 0xffff;
+    const minor = version & 0xffff;
+    return `${major}.${minor}`;
+}
+
+export class LittleFSError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "LittleFSError";
+    }
+}
+
+function createModuleConfig(wasmURL) {
+    const wasmURLStr = wasmURL instanceof URL ? wasmURL.href : wasmURL;
+    
+    return {
+        locateFile: (path) => {
+            if (path.endsWith('.wasm')) {
+                console.info("[littlefs-wasm] locateFile:", path, "->", wasmURLStr);
+                return wasmURLStr;
+            }
+            return path;
+        }
+    };
+}
+
+/**
+ * Create a new LittleFS instance
+ * @param {LittleFSOptions} options 
+ * @returns {Promise<LittleFS>}
+ */
+export async function createLittleFS(options = {}) {
+    console.info("[littlefs-wasm] createLittleFS() starting", options);
+    
+    const blockSize = options.blockSize ?? DEFAULT_BLOCK_SIZE;
+    const blockCount = options.blockCount ?? DEFAULT_BLOCK_COUNT;
+    const lookaheadSize = options.lookaheadSize ?? DEFAULT_LOOKAHEAD_SIZE;
+    const diskVersion = options.diskVersion ?? DISK_VERSION_2_0;
+
+    // Configure module with custom locateFile for WASM
+    // Always set locateFile to ensure correct WASM path resolution
+    const wasmURL = options.wasmURL ?? new URL('./littlefs.wasm', import.meta.url).href;
+    const moduleConfig = createModuleConfig(wasmURL);
+
+    // Initialize Emscripten module
+    const Module = await createLittleFSModule(moduleConfig);
+    console.info("[littlefs-wasm] Emscripten module loaded");
+    try {
+        // Set disk version before init to ensure new filesystems use the specified version
+        // and to prevent automatic migration from older versions
+        if (Module._lfs_wasm_set_disk_version) {
+            Module._lfs_wasm_set_disk_version(diskVersion);
+            console.info("[littlefs-wasm] Disk version set to:", formatDiskVersion(diskVersion));
+        }
+
+        // Initialize LittleFS
+        const initResult = Module._lfs_wasm_init(blockSize, blockCount, lookaheadSize);
+        if (initResult !== 0) {
+            throw new LittleFSError(`Failed to initialize LittleFS: ${initResult}`, initResult);
+        }
+
+        // Format if requested
+        if (options.formatOnInit) {
+            const formatResult = Module._lfs_wasm_format();
+            if (formatResult !== 0) {
+                throw new LittleFSError(`Failed to format LittleFS: ${formatResult}`, formatResult);
+            }
+        }
+
+        // Mount (with optional auto-format on failure)
+        const mountResult = Module._lfs_wasm_mount();
+        if (mountResult !== 0) {
+            if (options.autoFormatOnMountFailure !== true) {
+                throw new LittleFSError(`Failed to mount LittleFS: ${mountResult}`, mountResult);
+            }
+            console.warn("[littlefs-wasm] Mount failed, attempting format and remount...");
+            const formatResult = Module._lfs_wasm_format();
+            if (formatResult !== 0) {
+                throw new LittleFSError(`Failed to format LittleFS: ${formatResult}`, formatResult);
+            }
+            const retryMount = Module._lfs_wasm_mount();
+            if (retryMount !== 0) {
+                throw new LittleFSError(`Failed to mount LittleFS: ${retryMount}`, retryMount);
+            }
+        }
+    } catch (error) {
+        // Clean up Module resources before rethrowing
+        if (Module._lfs_wasm_cleanup) {
+            try {
+                Module._lfs_wasm_cleanup();
+            } catch (cleanupError) {
+                console.error("[littlefs-wasm] Cleanup during error handling failed:", cleanupError);
+            }
+        }
+        throw error;
+    }
+
+    console.info("[littlefs-wasm] LittleFS mounted successfully");
+    return createClient(Module, blockSize, blockCount);
+}
+
+/**
+ * Create a LittleFS instance from an existing image
+ * @param {Uint8Array|ArrayBuffer} image 
+ * @param {LittleFSOptions} options 
+ * @returns {Promise<LittleFS>}
+ */
+export async function createLittleFSFromImage(image, options = {}) {
+    console.info("[littlefs-wasm] createLittleFSFromImage() starting");
+
+    const imageData = image instanceof ArrayBuffer ? new Uint8Array(image) : image;
+    const blockSize = options.blockSize ?? DEFAULT_BLOCK_SIZE;
+    const blockCount = options.blockCount ?? Math.ceil(imageData.length / blockSize);
+    const lookaheadSize = options.lookaheadSize ?? DEFAULT_LOOKAHEAD_SIZE;
+
+    // Configure module with custom locateFile for WASM
+    // Always set locateFile to ensure correct WASM path resolution
+    const wasmURL = options.wasmURL ?? new URL('./littlefs.wasm', import.meta.url).href;
+    const moduleConfig = createModuleConfig(wasmURL);
+
+    // Initialize Emscripten module
+    const Module = await createLittleFSModule(moduleConfig);
+    console.info("[littlefs-wasm] Emscripten module loaded");
+
+    // When loading from image, don't set disk version (preserve existing)
+    // This is important to not trigger migration
+
+    try {
+        // Allocate memory for image
+        const imagePtr = Module._malloc(imageData.length);
+        if (!imagePtr) {
+            throw new LittleFSError("Failed to allocate memory for image", -1);
+        }
+
+        try {
+            // Copy image to WASM memory (access HEAPU8 after malloc to ensure current buffer)
+            Module.HEAPU8.set(imageData, imagePtr);
+
+            // Initialize from image
+            const initResult = Module._lfs_wasm_init_from_image(
+                imagePtr, 
+                imageData.length, 
+                blockSize, 
+                blockCount, 
+                lookaheadSize
+            );
+            
+            if (initResult !== 0) {
+                throw new LittleFSError(`Failed to initialize LittleFS from image: ${initResult}`, initResult);
+            }
+        } finally {
+            Module._free(imagePtr);
+        }
+
+        // Mount
+        const mountResult = Module._lfs_wasm_mount();
+        if (mountResult !== 0) {
+            throw new LittleFSError(`Failed to mount LittleFS: ${mountResult}`, mountResult);
+        }
+    } catch (error) {
+        // Clean up Module resources before rethrowing
+        if (Module._lfs_wasm_cleanup) {
+            try {
+                Module._lfs_wasm_cleanup();
+            } catch (cleanupError) {
+                console.error("[littlefs-wasm] Cleanup during error handling failed:", cleanupError);
+            }
+        }
+        throw error;
+    }
+
+    // Get disk version after mounting
+    const version = Module._lfs_wasm_get_disk_version ? Module._lfs_wasm_get_disk_version() : 0;
+    console.info("[littlefs-wasm] LittleFS mounted from image, disk version:", formatDiskVersion(version));
+
+    return createClient(Module, blockSize, blockCount);
+}
+
+/**
+ * Create the client API wrapper
+ */
+function createClient(Module, blockSize, blockCount) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+
+    function allocString(str) {
+        const bytes = encoder.encode(str + '\0');
+        const ptr = Module._malloc(bytes.length);
+        if (!ptr) throw new LittleFSError("Failed to allocate string", -1);
+        // Get HEAPU8 AFTER malloc to avoid stale reference if memory grows
+        Module.HEAPU8.set(bytes, ptr);
+        return ptr;
+    }
+
+    function readString(ptr, maxLength = 4096) {
+        if (!ptr) return "";
+        let end = ptr;
+        const limit = ptr + maxLength;
+        while (end < limit && Module.HEAPU8[end] !== 0) end++;
+        if (end >= limit) {
+            console.warn("[littlefs-wasm] String read truncated at maxLength");
+        }
+        return decoder.decode(Module.HEAPU8.subarray(ptr, end));
+    }
+
+    const client = {
+        format() {
+            const result = Module._lfs_wasm_format();
+            if (result !== 0) {
+                throw new LittleFSError(`Format failed: ${result}`, result);
+            }
+            // Remount after format
+            const mountResult = Module._lfs_wasm_mount();
+            if (mountResult !== 0) {
+                throw new LittleFSError(`Mount after format failed: ${mountResult}`, mountResult);
+            }
+        },
+
+        list(path = "/") {
+            const entries = [];
+            const pathPtr = allocString(path);
+            let dirHandle = -1;
+            
+            try {
+                // dir_open returns handle >= 0 on success, negative on error
+                dirHandle = Module._lfs_wasm_dir_open(pathPtr);
+                if (dirHandle < 0) {
+                    throw new LittleFSError(`Failed to open directory: ${dirHandle}`, dirHandle);
+                }
+
+                const nameBuffer = Module._malloc(LFS_NAME_MAX + 1);
+                const typePtr = Module._malloc(4);
+                const sizePtr = Module._malloc(4);
+
+                try {
+                    while (true) {
+                        // dir_read takes handle as first parameter
+                        const readResult = Module._lfs_wasm_dir_read(dirHandle, nameBuffer, LFS_NAME_MAX, typePtr, sizePtr);
+                        if (readResult === 0) break; // No more entries
+                        if (readResult < 0) {
+                            throw new LittleFSError(`Failed to read directory: ${readResult}`, readResult);
+                        }
+
+                        const name = readString(nameBuffer);
+                        // . and .. are already filtered in C code, but double-check
+                        if (name === "." || name === "..") continue;
+
+                        const type = Module.HEAP32[typePtr >> 2];
+                        const size = Module.HEAPU32[sizePtr >> 2];
+
+                        const entryPath = path === "/" ? `/${name}` : `${path}/${name}`;
+                        // type: 1 = file (LFS_TYPE_REG), 2 = directory (LFS_TYPE_DIR)
+                        const isDir = type === 2;
+                        entries.push({
+                            path: entryPath,
+                            name,
+                            size: isDir ? 0 : size,  // Files have size, directories don't
+                            type: isDir ? "dir" : "file"
+                        });
+                    }
+                } finally {
+                    Module._free(nameBuffer);
+                    Module._free(typePtr);
+                    Module._free(sizePtr);
+                }
+
+                // dir_close takes handle as parameter
+                Module._lfs_wasm_dir_close(dirHandle);
+                dirHandle = -1; // Mark as closed
+            } finally {
+                Module._free(pathPtr);
+                // Close handle if still open (in case of exception)
+                if (dirHandle >= 0) {
+                    Module._lfs_wasm_dir_close(dirHandle);
+                }
+            }
+
+            return entries;
+        },
+
+        readFile(path) {
+            const pathPtr = allocString(path);
+            try {
+                // Get file size first
+                const size = Module._lfs_wasm_file_size(pathPtr);
+                if (size < 0) {
+                    throw new LittleFSError(`Failed to get file size: ${size}`, size);
+                }
+
+                const dataPtr = Module._malloc(size);
+                if (!dataPtr && size > 0) {
+                    throw new LittleFSError("Failed to allocate read buffer", -1);
+                }
+
+                try {
+                    const readResult = Module._lfs_wasm_read_file(pathPtr, dataPtr, size);
+                    if (readResult < 0) {
+                        throw new LittleFSError(`Failed to read file: ${readResult}`, readResult);
+                    }
+                    return new Uint8Array(Module.HEAPU8.buffer, dataPtr, readResult).slice();
+                } finally {
+                    Module._free(dataPtr);
+                }
+            } finally {
+                Module._free(pathPtr);
+            }
+        },
+
+        writeFile(path, data) {
+            const pathPtr = allocString(path);
+            const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+            const dataPtr = Module._malloc(bytes.length);
+            
+            if (!dataPtr && bytes.length > 0) {
+                Module._free(pathPtr);
+                throw new LittleFSError("Failed to allocate write buffer", -1);
+            }
+
+            try {
+                // Access HEAPU8 after malloc to ensure we have current buffer
+                Module.HEAPU8.set(bytes, dataPtr);
+                const result = Module._lfs_wasm_write_file(pathPtr, dataPtr, bytes.length);
+                if (result < 0) {
+                    if (result === LFS_ERR_NOSPC) {
+                        throw new LittleFSError("No space left on device", result);
+                    }
+                    throw new LittleFSError(`Failed to write file: ${result}`, result);
+                }
+            } finally {
+                Module._free(pathPtr);
+                Module._free(dataPtr);
+            }
+        },
+
+        addFile(path, data) {
+            return this.writeFile(path, data);
+        },
+
+        deleteFile(path) {
+            const pathPtr = allocString(path);
+            try {
+                const result = Module._lfs_wasm_remove(pathPtr);
+                if (result !== 0) {
+                    throw new LittleFSError(`Failed to delete: ${result}`, result);
+                }
+            } finally {
+                Module._free(pathPtr);
+            }
+        },
+
+        delete(path, options = {}) {
+            if (options.recursive) {
+                // List contents and delete recursively
+                try {
+                    const entries = this.list(path);
+                    for (const entry of entries) {
+                        if (entry.type === "dir") {
+                            this.delete(entry.path, { recursive: true });
+                        } else {
+                            this.deleteFile(entry.path);
+                        }
+                    }
+                } catch (e) {
+                    // Directory might be empty or not exist, log other errors
+                    if (e.code !== -2) { // -2 is ENOENT
+                        console.warn("[littlefs-wasm] Error during recursive delete:", e);
+                    }
+                }
+            }
+            this.deleteFile(path);
+        },
+
+        mkdir(path) {
+            const pathPtr = allocString(path);
+            try {
+                const result = Module._lfs_wasm_mkdir(pathPtr);
+                // Ignore "already exists" error
+                if (result !== 0 && result !== -17) {
+                    throw new LittleFSError(`Failed to create directory: ${result}`, result);
+                }
+            } finally {
+                Module._free(pathPtr);
+            }
+        },
+
+        rename(oldPath, newPath) {
+            const oldPtr = allocString(oldPath);
+            const newPtr = allocString(newPath);
+            try {
+                const result = Module._lfs_wasm_rename(oldPtr, newPtr);
+                if (result !== 0) {
+                    throw new LittleFSError(`Failed to rename: ${result}`, result);
+                }
+            } finally {
+                Module._free(oldPtr);
+                Module._free(newPtr);
+            }
+        },
+
+        toImage() {
+            const size = Module._lfs_wasm_get_image_size();
+            if (size <= 0) {
+                throw new LittleFSError(`Invalid image size: ${size}`, size);
+            }
+
+            const ptr = Module._lfs_wasm_get_image();
+            if (!ptr) {
+                throw new LittleFSError("Failed to get image pointer", -1);
+            }
+
+            // Note: ptr points to internal ram_storage buffer, not allocated memory
+            // slice() already copies the data, so we must NOT free this pointer
+            return new Uint8Array(Module.HEAPU8.buffer, ptr, size).slice();
+        },
+
+        getDiskVersion() {
+            if (Module._lfs_wasm_get_fs_info) {
+                const versionPtr = Module._malloc(4);
+                try {
+                    const result = Module._lfs_wasm_get_fs_info(versionPtr);
+                    if (result === 0) {
+                        return Module.HEAPU32[versionPtr >> 2];
+                    }
+                } finally {
+                    Module._free(versionPtr);
+                }
+            }
+            console.warn("[littlefs-wasm] getDiskVersion not available or filesystem not mounted");
+            return 0;
+        },
+
+        setDiskVersion(version) {
+            if (Module._lfs_wasm_set_disk_version) {
+                Module._lfs_wasm_set_disk_version(version);
+            } else {
+                console.warn("[littlefs-wasm] setDiskVersion not available");
+            }
+        },
+
+        getUsage() {
+            const blockUsedPtr = Module._malloc(4);
+            const blockTotalPtr = Module._malloc(4);
+            
+            try {
+                const result = Module._lfs_wasm_fs_stat(blockUsedPtr, blockTotalPtr);
+                if (result !== 0) {
+                    // Fallback estimation
+                    return {
+                        capacityBytes: blockSize * blockCount,
+                        usedBytes: 0,
+                        freeBytes: blockSize * blockCount
+                    };
+                }
+
+                const blocksUsed = Module.HEAPU32[blockUsedPtr >> 2];
+                const blocksTotal = Module.HEAPU32[blockTotalPtr >> 2];
+
+                const capacityBytes = blocksTotal * blockSize;
+                const usedBytes = blocksUsed * blockSize;
+
+                return {
+                    capacityBytes,
+                    usedBytes,
+                    freeBytes: Math.max(0, capacityBytes - usedBytes)
+                };
+            } finally {
+                Module._free(blockUsedPtr);
+                Module._free(blockTotalPtr);
+            }
+        },
+
+        canFit(path, size) {
+            const usage = this.getUsage();
+            return usage.freeBytes >= size;
+        },
+
+        cleanup() {
+            Module._lfs_wasm_unmount();
+            Module._lfs_wasm_cleanup();
+        }
+    };
+
+    return client;
+}
+
+// Default export for CommonJS compatibility
+export default { createLittleFS, createLittleFSFromImage, DISK_VERSION_2_0, DISK_VERSION_2_1, LFS_NAME_MAX, formatDiskVersion };

package/src/wasm/littlefs/littlefs.js

@@ -0,0 +1,2 @@
+export default (()=>{var _scriptName=globalThis.document?.currentScript?.src;return async function(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;var readyPromiseResolve,readyPromiseReject;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["i"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("littlefs.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0};var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which]}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()))},timeout_ms);timers[which]={id,timeout_ms};return 0};var getHeapMax=()=>67108864;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var printCharBuffers=[null,[],[]];var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer));buffer.length=0}else{buffer.push(curr)}};var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}var _lfs_wasm_set_disk_version,_lfs_wasm_get_disk_version,_lfs_wasm_init,_free,_malloc,_lfs_wasm_init_from_image,_lfs_wasm_get_fs_info,_lfs_wasm_mount,_lfs_wasm_unmount,_lfs_wasm_format,_lfs_wasm_mkdir,_lfs_wasm_remove,_lfs_wasm_rename,_lfs_wasm_stat,_lfs_wasm_dir_open,_lfs_wasm_dir_read,_lfs_wasm_dir_close,_lfs_wasm_write_file,_lfs_wasm_read_file,_lfs_wasm_file_size,_lfs_wasm_get_image,_lfs_wasm_get_image_size,_lfs_wasm_fs_stat,_lfs_wasm_cleanup,__emscripten_timeout,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_lfs_wasm_set_disk_version=Module["_lfs_wasm_set_disk_version"]=wasmExports["j"];_lfs_wasm_get_disk_version=Module["_lfs_wasm_get_disk_version"]=wasmExports["k"];_lfs_wasm_init=Module["_lfs_wasm_init"]=wasmExports["l"];_free=Module["_free"]=wasmExports["m"];_malloc=Module["_malloc"]=wasmExports["n"];_lfs_wasm_init_from_image=Module["_lfs_wasm_init_from_image"]=wasmExports["o"];_lfs_wasm_get_fs_info=Module["_lfs_wasm_get_fs_info"]=wasmExports["p"];_lfs_wasm_mount=Module["_lfs_wasm_mount"]=wasmExports["q"];_lfs_wasm_unmount=Module["_lfs_wasm_unmount"]=wasmExports["r"];_lfs_wasm_format=Module["_lfs_wasm_format"]=wasmExports["s"];_lfs_wasm_mkdir=Module["_lfs_wasm_mkdir"]=wasmExports["t"];_lfs_wasm_remove=Module["_lfs_wasm_remove"]=wasmExports["u"];_lfs_wasm_rename=Module["_lfs_wasm_rename"]=wasmExports["v"];_lfs_wasm_stat=Module["_lfs_wasm_stat"]=wasmExports["w"];_lfs_wasm_dir_open=Module["_lfs_wasm_dir_open"]=wasmExports["x"];_lfs_wasm_dir_read=Module["_lfs_wasm_dir_read"]=wasmExports["y"];_lfs_wasm_dir_close=Module["_lfs_wasm_dir_close"]=wasmExports["z"];_lfs_wasm_write_file=Module["_lfs_wasm_write_file"]=wasmExports["A"];_lfs_wasm_read_file=Module["_lfs_wasm_read_file"]=wasmExports["B"];_lfs_wasm_file_size=Module["_lfs_wasm_file_size"]=wasmExports["C"];_lfs_wasm_get_image=Module["_lfs_wasm_get_image"]=wasmExports["D"];_lfs_wasm_get_image_size=Module["_lfs_wasm_get_image_size"]=wasmExports["E"];_lfs_wasm_fs_stat=Module["_lfs_wasm_fs_stat"]=wasmExports["F"];_lfs_wasm_cleanup=Module["_lfs_wasm_cleanup"]=wasmExports["G"];__emscripten_timeout=wasmExports["H"];memory=wasmMemory=wasmExports["h"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={a:___assert_fail,d:__abort_js,c:__emscripten_runtime_keepalive_clear,e:__setitimer_js,f:_emscripten_resize_heap,g:_fd_write,b:_proc_exit};function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
+;return moduleRtn}})();if(typeof exports==="object"&&typeof module==="object"){module.exports=createLittleFS;module.exports.default=createLittleFS}else if(typeof define==="function"&&define["amd"])define([],()=>createLittleFS);

package/src/wasm/shared/types.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared types for filesystem implementations
+ */
+
+/**
+ * File source can be a string, Uint8Array, or ArrayBuffer
+ */
+export type FileSource = string | Uint8Array | ArrayBuffer;
+
+/**
+ * Binary source for filesystem images (Uint8Array or ArrayBuffer)
+ */
+export type BinarySource = Uint8Array | ArrayBuffer;