esp32tool 1.1.4 → 1.1.5

package/js/script.js

@@ -2219,8 +2219,48 @@ function refreshLittleFS() {
     littlefsBreadcrumb.textContent = currentLittleFSPath || '/';
     butLittlefsUp.disabled = currentLittleFSPath === '/' || !currentLittleFSPath;
     
-    // List files
-    const entries = currentLittleFS.list(currentLittleFSPath);
+    // List files - the list() function behavior differs between filesystems
+    let entries;
+    
+    if (currentFilesystemType === 'fatfs') {
+      // FatFS returns ALL files recursively from root, so we always list from root and filter
+      const allEntries = currentLittleFS.list('/');
+      const isRoot = currentLittleFSPath === '/';
+      
+      // Filter to show only direct children
+      entries = allEntries.filter(entry => {
+        // Remove /fatfs prefix from entry path for comparison
+        let entryPath = entry.path;
+        if (entryPath.startsWith('/fatfs/')) {
+          entryPath = entryPath.slice(6);
+        } else if (entryPath === '/fatfs') {
+          entryPath = '/';
+        }
+        
+        if (isRoot) {
+          // In root: only show top-level entries
+          const withoutLeadingSlash = entryPath.slice(1);
+          return withoutLeadingSlash && !withoutLeadingSlash.includes('/');
+        } else {
+          // In subdirectory: entry must be direct child of current path
+          const expectedPrefix = currentLittleFSPath + '/';
+          if (!entryPath.startsWith(expectedPrefix)) {
+            return false;
+          }
+          const relativePath = entryPath.slice(expectedPrefix.length);
+          return relativePath && !relativePath.includes('/');
+        }
+      });
+      
+      // Add name attribute for FatFS entries
+      entries = entries.map(entry => ({
+        ...entry,
+        name: entry.path.split('/').pop() || entry.path
+      }));
+    } else {
+      // LittleFS and SPIFFS return only direct children
+      entries = currentLittleFS.list(currentLittleFSPath);
+    }
     
     // Clear table
     littlefsFileList.innerHTML = '';
@@ -2252,7 +2292,8 @@ function refreshLittleFS() {
       icon.className = 'file-icon';
       icon.textContent = entry.type === 'dir' ? '📁' : '📄';
       
-      const name = entry.path.split('/').filter(Boolean).pop() || '/';
+      // Use entry.name instead of parsing the path
+      const name = entry.name || entry.path.split('/').filter(Boolean).pop() || '/';
       const nameText = document.createElement('span');
       nameText.textContent = name;
       
@@ -2313,7 +2354,20 @@ function refreshLittleFS() {
  * Navigate to a directory in LittleFS
  */
 function navigateLittleFS(path) {
-  currentLittleFSPath = path;
+  // Remove /fatfs prefix if present (for FatFS compatibility)
+  let normalizedPath = path;
+  if (normalizedPath.startsWith('/fatfs/')) {
+    normalizedPath = normalizedPath.slice(6); // Remove '/fatfs' keeping the /
+  } else if (normalizedPath === '/fatfs') {
+    normalizedPath = '/';
+  }
+  
+  // Remove trailing slash except for root
+  if (normalizedPath !== '/' && normalizedPath.endsWith('/')) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  
+  currentLittleFSPath = normalizedPath;
   refreshLittleFS();
 }
 
@@ -2323,12 +2377,12 @@ function navigateLittleFS(path) {
 function clickLittlefsUp() {
   if (currentLittleFSPath === '/' || !currentLittleFSPath) return;
   
+  // Split path and remove last segment
   const parts = currentLittleFSPath.split('/').filter(Boolean);
   parts.pop();
-  currentLittleFSPath = '/' + parts.join('/');
-  if (currentLittleFSPath !== '/' && !currentLittleFSPath.endsWith('/')) {
-    currentLittleFSPath += '/';
-  }
+  
+  // Reconstruct path
+  currentLittleFSPath = parts.length ? '/' + parts.join('/') : '/';
   refreshLittleFS();
 }
 
@@ -2433,7 +2487,8 @@ async function clickLittlefsWrite() {
     butLittlefsWrite.disabled = false;
     butLittlefsClose.disabled = false;
     butLittlefsUpload.disabled = !littlefsFileInput.files.length;
-    butLittlefsMkdir.disabled = false;
+    // Re-enable mkdir only if not SPIFFS
+    butLittlefsMkdir.disabled = (currentFilesystemType === 'spiffs');
   }
 }
 
@@ -2522,10 +2577,22 @@ async function clickLittlefsUpload() {
 /**
  * Create new directory
  */
-function clickLittlefsMkdir() {
+async function clickLittlefsMkdir() {
   if (!currentLittleFS) return;
   
-  const dirName = prompt('Enter directory name:');
+  // Check if mkdir is supported (SPIFFS doesn't support directories)
+  if (currentFilesystemType === 'spiffs') {
+    errorMsg('SPIFFS does not support directories. Files are stored in a flat structure.');
+    return;
+  }
+  
+  let dirName;
+  if (isElectron) {
+    dirName = await window.electronAPI.showPrompt('Enter directory name:');
+  } else {
+    dirName = prompt('Enter directory name:');
+  }
+  
   if (!dirName || !dirName.trim()) return;
   
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esp32tool",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Flash & Read ESP devices using WebSerial",
   "main": "electron/main.js",
   "repository": {

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

@@ -1,26 +1,30 @@
-import type { FileSource, BinarySource } from "../shared/types";
+import type { BinarySource, FileSource, FileSystemUsage } from "../shared/types";
+export declare const FAT_MOUNT = "/fatfs";
 export interface FatFSEntry {
     path: string;
     size: number;
-    type: 'file' | 'dir';
+    type: "file" | "dir";
 }
 export interface FatFSOptions {
     blockSize?: number;
     blockCount?: number;
-    wasmURL?: string | URL;
     formatOnInit?: boolean;
+    wasmURL?: string | URL;
 }
 export interface FatFS {
-    format(): void;
-    list(): FatFSEntry[];
+    list(path?: string): FatFSEntry[];
     readFile(path: string): Uint8Array;
+    toImage(): Uint8Array;
+    getUsage(): FileSystemUsage;
+    format(): void;
     writeFile(path: string, data: FileSource): void;
     deleteFile(path: string): void;
-    toImage(): Uint8Array;
+    mkdir(path: string): void;
+    rename(oldPath: string, newPath: string): void;
 }
 export declare class FatFSError extends Error {
     readonly code: number;
     constructor(message: string, code: number);
 }
-export declare function createFatFS(options?: FatFSOptions): Promise<FatFS>;
 export declare function createFatFSFromImage(image: BinarySource, options?: FatFSOptions): Promise<FatFS>;
+export declare function createFatFS(options?: FatFSOptions): Promise<FatFS>;

package/src/wasm/fatfs/index.js

@@ -1,7 +1,9 @@
-const DEFAULT_BLOCK_SIZE = 512;
-const DEFAULT_BLOCK_COUNT = 1024;
+export const FAT_MOUNT = "/fatfs";
 const INITIAL_LIST_BUFFER = 4096;
-const FATFS_ERR_NOT_ENOUGH_CORE = -17;
+const DEFAULT_BLOCK_SIZE = 4096;
+const DEFAULT_BLOCK_COUNT = 128;
+const FATFS_ERR_INVAL = -1;
+const FATFS_ERR_NOSPC = -3;
 export class FatFSError extends Error {
     constructor(message, code) {
         super(message);
@@ -9,61 +11,60 @@ export class FatFSError extends Error {
         this.name = "FatFSError";
     }
 }
-export async function createFatFS(options = {}) {
-    console.info("[fatfs-wasm] createFatFS() starting", options);
-    const wasmURL = options.wasmURL ?? new URL("./fatfs.wasm", import.meta.url);
-    const exports = await instantiateFatFSModule(wasmURL);
-    const blockSize = options.blockSize ?? DEFAULT_BLOCK_SIZE;
-    const blockCount = options.blockCount ?? DEFAULT_BLOCK_COUNT;
-    const initResult = exports.fatfsjs_init(blockSize, blockCount);
-    console.info("[fatfs-wasm] fatfsjs_init returned", initResult);
-    if (initResult < 0) {
-        throw new FatFSError("Failed to initialize FatFS", initResult);
-    }
-    if (options.formatOnInit) {
-        const formatResult = exports.fatfsjs_format();
-        console.info("[fatfs-wasm] fatfsjs_format returned", formatResult);
-        if (formatResult < 0) {
-            throw new FatFSError("Failed to format FatFS volume", formatResult);
-        }
-    }
-    const client = new FatFSClient(exports);
-    console.info("[fatfs-wasm] Filesystem initialized");
-    return client;
-}
 export async function createFatFSFromImage(image, options = {}) {
     console.info("[fatfs-wasm] createFatFSFromImage() starting");
     const wasmURL = options.wasmURL ?? new URL("./fatfs.wasm", import.meta.url);
     const exports = await instantiateFatFSModule(wasmURL);
     const bytes = asBinaryUint8Array(image);
     const blockSize = options.blockSize ?? DEFAULT_BLOCK_SIZE;
-    if (blockSize === 0) {
-        throw new Error("blockSize must be a positive integer");
+    if (blockSize !== DEFAULT_BLOCK_SIZE) {
+        throw new Error(`blockSize must be ${DEFAULT_BLOCK_SIZE}`);
     }
-    const inferredBlocks = bytes.length / blockSize;
-    const blockCount = options.blockCount ?? inferredBlocks;
-    if (blockCount * blockSize !== bytes.length) {
+    if (options.blockCount && options.blockCount * blockSize !== bytes.length) {
         throw new Error("Image size must equal blockSize * blockCount");
     }
-    const ptr = exports.malloc(bytes.length || 1);
-    if (!ptr) {
-        throw new FatFSError("Failed to allocate WebAssembly memory", FATFS_ERR_NOT_ENOUGH_CORE);
+    const heap = new Uint8Array(exports.memory.buffer);
+    const imagePtr = exports.malloc(bytes.length || 1);
+    if (!imagePtr) {
+        throw new FatFSError("Failed to allocate WebAssembly memory", FATFS_ERR_NOSPC);
     }
     try {
-        // Get heap AFTER malloc to avoid stale reference if memory grows
-        const heap = new Uint8Array(exports.memory.buffer);
-        heap.set(bytes, ptr);
-        const initResult = exports.fatfsjs_init_from_image(blockSize, blockCount, ptr, bytes.length);
+        heap.set(bytes, imagePtr);
+        const initResult = exports.fatfsjs_init_from_image(imagePtr, bytes.length);
         if (initResult < 0) {
-            throw new FatFSError("Failed to initialize FatFS from image", initResult);
+            throw new FatFSError("Failed to initialize FAT16 image", initResult);
         }
     }
     finally {
-        exports.free(ptr);
+        exports.free(imagePtr);
     }
-    const client = new FatFSClient(exports);
     console.info("[fatfs-wasm] Filesystem initialized from image");
-    return client;
+    return new FatFSClient(exports);
+}
+export async function createFatFS(options = {}) {
+    console.info("[fatfs-wasm] createFatFS() starting", options);
+    const wasmURL = options.wasmURL ?? new URL("./fatfs.wasm", import.meta.url);
+    const exports = await instantiateFatFSModule(wasmURL);
+    const blockSize = options.blockSize ?? DEFAULT_BLOCK_SIZE;
+    const blockCount = options.blockCount ?? DEFAULT_BLOCK_COUNT;
+    if (blockSize !== DEFAULT_BLOCK_SIZE) {
+        throw new Error(`blockSize must be ${DEFAULT_BLOCK_SIZE}`);
+    }
+    if (!Number.isFinite(blockCount) || blockCount <= 0) {
+        throw new Error("blockCount must be a positive integer");
+    }
+    const initResult = exports.fatfsjs_init(blockSize, blockCount);
+    if (initResult < 0) {
+        throw new FatFSError("Failed to initialize FatFS", initResult);
+    }
+    if (options.formatOnInit) {
+        const formatResult = exports.fatfsjs_format();
+        if (formatResult < 0) {
+            throw new FatFSError("Failed to format filesystem", formatResult);
+        }
+    }
+    console.info("[fatfs-wasm] Filesystem initialized");
+    return new FatFSClient(exports);
 }
 class FatFSClient {
     constructor(exports) {
@@ -73,46 +74,56 @@ class FatFSClient {
         this.exports = exports;
         this.heapU8 = new Uint8Array(this.exports.memory.buffer);
     }
-    format() {
-        const result = this.exports.fatfsjs_format();
-        this.assertOk(result, "format filesystem");
-    }
-    list() {
+    list(path = FAT_MOUNT) {
+        const normalized = normalizeMountPath(path);
+        const basePath = normalized;
+        const pathPtr = this.allocString(normalized);
         let capacity = this.listBufferSize;
-        while (true) {
-            const ptr = this.alloc(capacity);
-            try {
-                const used = this.exports.fatfsjs_list(ptr, capacity);
-                if (used === FATFS_ERR_NOT_ENOUGH_CORE) {
-                    this.listBufferSize = capacity * 2;
-                    capacity = this.listBufferSize;
-                    continue;
+        try {
+            while (true) {
+                const ptr = this.alloc(capacity);
+                try {
+                    const used = this.exports.fatfsjs_list(pathPtr, ptr, capacity);
+                    if (used === FATFS_ERR_NOSPC) {
+                        this.listBufferSize = capacity * 2;
+                        capacity = this.listBufferSize;
+                        continue;
+                    }
+                    this.assertOk(used, "list files");
+                    if (used === 0) {
+                        return [];
+                    }
+                    const payload = this.decoder.decode(this.heapU8.subarray(ptr, ptr + used));
+                    return parseListPayload(payload).map((entry) => ({
+                        ...entry,
+                        path: joinListPath(basePath, entry.path),
+                    }));
                 }
-                this.assertOk(used, "list files");
-                if (used === 0) {
-                    return [];
+                finally {
+                    this.exports.free(ptr);
                 }
-                const payload = this.decoder.decode(this.heapU8.subarray(ptr, ptr + used));
-                return parseListPayload(payload);
-            }
-            finally {
-                this.exports.free(ptr);
             }
         }
+        finally {
+            this.exports.free(pathPtr);
+        }
     }
     readFile(path) {
-        const normalizedPath = normalizePath(path);
-        const pathPtr = this.allocString(normalizedPath);
+        const normalized = normalizeMountPath(path);
+        if (normalized === FAT_MOUNT) {
+            throw new FatFSError("Path must point to a file", FATFS_ERR_INVAL);
+        }
+        const pathPtr = this.allocString(normalized);
         try {
             const size = this.exports.fatfsjs_file_size(pathPtr);
-            this.assertOk(size, `stat file "${normalizedPath}"`);
+            this.assertOk(size, `stat file "${normalized}"`);
             if (size === 0) {
                 return new Uint8Array();
             }
             const dataPtr = this.alloc(size);
             try {
                 const read = this.exports.fatfsjs_read_file(pathPtr, dataPtr, size);
-                this.assertOk(read, `read file "${normalizedPath}"`);
+                this.assertOk(read, `read file "${normalized}"`);
                 return this.heapU8.slice(dataPtr, dataPtr + size);
             }
             finally {
@@ -123,17 +134,50 @@ class FatFSClient {
             this.exports.free(pathPtr);
         }
     }
+    toImage() {
+        const size = this.exports.fatfsjs_storage_size();
+        if (size === 0) {
+            return new Uint8Array();
+        }
+        const ptr = this.alloc(size);
+        try {
+            const copied = this.exports.fatfsjs_export_image(ptr, size);
+            this.assertOk(copied, "export filesystem image");
+            return this.heapU8.slice(ptr, ptr + size);
+        }
+        finally {
+            this.exports.free(ptr);
+        }
+    }
+    getUsage() {
+        const capacityBytes = this.exports.fatfsjs_storage_size();
+        const entries = this.list(FAT_MOUNT);
+        const usedBytes = entries.reduce((acc, entry) => (entry.type === "file" ? acc + entry.size : acc), 0);
+        const freeBytes = capacityBytes > usedBytes ? capacityBytes - usedBytes : 0;
+        return {
+            capacityBytes,
+            usedBytes,
+            freeBytes,
+        };
+    }
+    format() {
+        const result = this.exports.fatfsjs_format();
+        this.assertOk(result, "format filesystem");
+    }
     writeFile(path, data) {
-        const normalizedPath = normalizePath(path);
+        const normalized = normalizeMountPath(path);
+        if (normalized === FAT_MOUNT) {
+            throw new FatFSError("Path must point to a file", FATFS_ERR_INVAL);
+        }
         const payload = asUint8Array(data, this.encoder);
-        const pathPtr = this.allocString(normalizedPath);
-        const dataPtr = this.alloc(payload.length);
+        const pathPtr = this.allocString(normalized);
+        const dataPtr = payload.length ? this.alloc(payload.length) : 0;
         try {
-            if (payload.length > 0 && dataPtr) {
+            if (payload.length > 0) {
                 this.heapU8.set(payload, dataPtr);
             }
-            const result = this.exports.fatfsjs_write_file(pathPtr, payload.length > 0 ? dataPtr : 0, payload.length);
-            this.assertOk(result, `write file "${normalizedPath}"`);
+            const result = this.exports.fatfsjs_write_file(pathPtr, dataPtr, payload.length);
+            this.assertOk(result, `write file "${normalized}"`);
         }
         finally {
             if (dataPtr) {
@@ -143,29 +187,45 @@ class FatFSClient {
         }
     }
     deleteFile(path) {
-        const normalizedPath = normalizePath(path);
-        const pathPtr = this.allocString(normalizedPath);
+        const normalized = normalizeMountPath(path);
+        if (normalized === FAT_MOUNT) {
+            throw new FatFSError("Path must point to a file", FATFS_ERR_INVAL);
+        }
+        const pathPtr = this.allocString(normalized);
         try {
             const result = this.exports.fatfsjs_delete_file(pathPtr);
-            this.assertOk(result, `delete file "${normalizedPath}"`);
+            this.assertOk(result, `delete file "${normalized}"`);
         }
         finally {
             this.exports.free(pathPtr);
         }
     }
-    toImage() {
-        const size = this.exports.fatfsjs_storage_size();
-        if (size === 0) {
-            return new Uint8Array();
+    mkdir(path) {
+        const normalized = normalizeMountPath(path);
+        if (normalized === FAT_MOUNT) {
+            return;
         }
-        const ptr = this.alloc(size);
+        const pathPtr = this.allocString(normalized);
         try {
-            const copied = this.exports.fatfsjs_export_image(ptr, size);
-            this.assertOk(copied, "export filesystem image");
-            return this.heapU8.slice(ptr, ptr + size);
+            const result = this.exports.fatfsjs_mkdir(pathPtr);
+            this.assertOk(result, `mkdir "${normalized}"`);
         }
         finally {
-            this.exports.free(ptr);
+            this.exports.free(pathPtr);
+        }
+    }
+    rename(oldPath, newPath) {
+        const from = normalizeMountPath(oldPath);
+        const to = normalizeMountPath(newPath);
+        const fromPtr = this.allocString(from);
+        const toPtr = this.allocString(to);
+        try {
+            const result = this.exports.fatfsjs_rename(fromPtr, toPtr);
+            this.assertOk(result, `rename "${from}" -> "${to}"`);
+        }
+        finally {
+            this.exports.free(fromPtr);
+            this.exports.free(toPtr);
         }
     }
     refreshHeap() {
@@ -179,7 +239,7 @@ class FatFSClient {
         }
         const ptr = this.exports.malloc(size);
         if (!ptr) {
-            throw new FatFSError("Failed to allocate WebAssembly memory", FATFS_ERR_NOT_ENOUGH_CORE);
+            throw new FatFSError("Failed to allocate WebAssembly memory", FATFS_ERR_NOSPC);
         }
         this.refreshHeap();
         return ptr;
@@ -204,7 +264,7 @@ async function instantiateFatFSModule(input) {
     const imports = createDefaultImports(wasmContext);
     let response = await fetch(source);
     if (!response.ok) {
-        throw new Error(`Unable to fetch FatFS wasm from ${response.url}`);
+        throw new Error(`Unable to fetch FATFS wasm from ${response.url}`);
     }
     console.info("[fatfs-wasm] Fetch complete, status", response.status);
     if ("instantiateStreaming" in WebAssembly && typeof WebAssembly.instantiateStreaming === "function") {
@@ -216,10 +276,10 @@ async function instantiateFatFSModule(input) {
             return streaming.instance.exports;
         }
         catch (error) {
-            console.warn("Unable to instantiate FatFS wasm via streaming, retrying with arrayBuffer()", error);
+            console.warn("Unable to instantiate FATFS wasm via streaming, retrying with arrayBuffer()", error);
             response = await fetch(source);
             if (!response.ok) {
-                throw new Error(`Unable to fetch FatFS wasm from ${response.url}`);
+                throw new Error(`Unable to fetch FATFS wasm from ${response.url}`);
             }
             console.info("[fatfs-wasm] Fallback fetch complete, status", response.status);
         }
@@ -239,26 +299,38 @@ function parseListPayload(payload) {
         .split("\n")
         .filter((line) => line.length > 0)
         .map((line) => {
-        const [rawPath, rawSize] = line.split("\t");
-        const path = rawPath ?? "";
-        const size = Number(rawSize ?? "0") || 0;
-        // Determine type: directories end with '/', files don't
-        const type = path.endsWith('/') ? 'dir' : 'file';
+        const [rawPath, rawSize, rawType] = line.split("\t");
         return {
-            path: path,
-            size: size,
-            type: type
+            path: rawPath ?? "",
+            size: Number(rawSize ?? "0") || 0,
+            type: rawType === "d" ? "dir" : "file",
         };
     });
 }
-function normalizePath(input) {
-    const value = input.trim().replace(/\\/g, "/");
-    const withoutRoot = value.replace(/^\/+/, "");
-    if (!withoutRoot) {
-        throw new Error('Path must point to a file (e.g. "docs/readme.txt")');
-    }
-    const collapsed = withoutRoot.replace(/\/{2,}/g, "/");
-    return collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
+function normalizeMountPath(input) {
+    const raw = (input ?? "").trim();
+    if (!raw || raw === "/") {
+        return FAT_MOUNT;
+    }
+    const normalized = raw.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+    const collapsed = normalized.endsWith("/") && normalized !== "/" ? normalized.slice(0, -1) : normalized;
+    const lower = collapsed.toLowerCase();
+    if (lower.startsWith(FAT_MOUNT)) {
+        const rest = collapsed.slice(FAT_MOUNT.length);
+        return rest ? `${FAT_MOUNT}${rest}` : FAT_MOUNT;
+    }
+    if (collapsed.startsWith("/")) {
+        return `${FAT_MOUNT}${collapsed}`;
+    }
+    return `${FAT_MOUNT}/${collapsed}`;
+}
+function joinListPath(basePath, entryPath) {
+    const base = basePath.replace(/\/+$/, "");
+    if (!entryPath || entryPath === "/") {
+        return base || FAT_MOUNT;
+    }
+    const trimmed = entryPath.replace(/^\/+/, "");
+    return base === FAT_MOUNT ? `${FAT_MOUNT}/${trimmed}` : `${base}/${trimmed}`;
 }
 function asUint8Array(source, encoder) {
     if (typeof source === "string") {
@@ -301,13 +373,13 @@ function createDefaultImports(context) {
     const ok = () => 0;
     return {
         env: {
-            emscripten_notify_memory_growth: noop
+            emscripten_notify_memory_growth: noop,
         },
         wasi_snapshot_preview1: {
             fd_close: ok,
             fd_seek: ok,
-            fd_write: (fd, iov, iovcnt, pnum) => handleFdWrite(context, fd, iov, iovcnt, pnum)
-        }
+            fd_write: (fd, iov, iovcnt, pnum) => handleFdWrite(context, fd, iov, iovcnt, pnum),
+        },
     };
 }
 function handleFdWrite(context, fd, iov, iovcnt, pnum) {
@@ -322,13 +394,11 @@ function handleFdWrite(context, fd, iov, iovcnt, pnum) {
         const ptr = view.getUint32(base, true);
         const len = view.getUint32(base + 4, true);
         total += len;
-        // Suppress fd_write logging in production (fd 1=stdout, 2=stderr)
-        // Uncomment for debugging:
-        // if (fd === 1 || fd === 2) {
-        //     const bytes = new Uint8Array(memory.buffer, ptr, len);
-        //     const text = new TextDecoder().decode(bytes);
-        //     console.info(`[fatfs-wasm::fd_write fd=${fd}] ${text}`);
-        // }
+        if (fd === 1 || fd === 2) {
+            const bytes = new Uint8Array(memory.buffer, ptr, len);
+            const text = new TextDecoder().decode(bytes);
+            console.info(`[fatfs-wasm::fd_write fd=${fd}] ${text}`);
+        }
     }
     view.setUint32(pnum, total, true);
     return 0;