typescript-virtual-container 1.4.6 → 1.4.8

package/dist/VirtualFileSystem/index.js

@@ -1,8 +1,10 @@
+/** biome-ignore-all lint/style/useNamingConvention: NW ? */
 import { EventEmitter } from "node:events";
 import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { gunzipSync, gzipSync } from "node:zlib";
 import { decodeVfs, encodeVfs, isBinarySnapshot } from "./binaryPack";
+import { appendJournalEntry, JournalOp, readJournal, truncateJournal } from "./journal";
 import { getNode, getParentDirectory, normalizePath } from "./path";
 // ── VirtualFileSystem ─────────────────────────────────────────────────────────
 /**
@@ -32,6 +34,18 @@ class VirtualFileSystem extends EventEmitter {
     root;
     mode;
     snapshotFile;
+    /** Path to the WAL journal file (null in memory mode). */
+    journalFile;
+    /** Eviction threshold in bytes (0 = disabled). Files above this are purged after flush. */
+    evictionThreshold;
+    /** Max writes between forced flushes (0 = disabled). */
+    flushAfterNWrites;
+    /** Pending write counter since last checkpoint. */
+    _writesSinceFlush = 0;
+    /** NodeJS timer handle for periodic auto-flush (null = disabled or stopped). */
+    _flushTimer = null;
+    /** True if the VFS has unflushed changes. */
+    _dirty = false;
     /** Active host-directory mounts: vPath → { hostPath, readOnly } */
     mounts = new Map();
     /** True when running in a browser environment (no host FS access). */
@@ -44,26 +58,44 @@ class VirtualFileSystem extends EventEmitter {
                 throw new Error('VirtualFileSystem: "snapshotPath" is required when mode is "fs".');
             }
             this.snapshotFile = path.resolve(options.snapshotPath, "vfs-snapshot.vfsb");
+            this.journalFile = path.resolve(options.snapshotPath, "vfs-journal.bin");
+            this.evictionThreshold = options.evictionThresholdBytes ?? 64 * 1024; // 64 KB default
+            this.flushAfterNWrites = options.flushAfterNWrites ?? 500;
+            const intervalMs = options.flushIntervalMs ?? 30_000;
+            if (intervalMs > 0) {
+                this._flushTimer = setInterval(() => {
+                    if (this._dirty)
+                        void this._autoFlush();
+                }, intervalMs);
+                // Don't block process exit on this timer
+                if (typeof this._flushTimer === "object" && this._flushTimer !== null && "unref" in this._flushTimer) {
+                    this._flushTimer.unref();
+                }
+            }
         }
         else {
             this.snapshotFile = null;
+            this.journalFile = null;
+            this.evictionThreshold = 0; // disabled in memory mode
+            this.flushAfterNWrites = 0;
         }
         this.root = this.makeDir("", 0o755);
     }
     // ── Internal helpers ──────────────────────────────────────────────────────
     makeDir(name, mode) {
-        const now = new Date();
+        const now = Date.now();
         return {
             type: "directory",
             name,
             mode,
             createdAt: now,
             updatedAt: now,
-            children: new Map(),
+            children: Object.create(null),
+            _childCount: 0,
         };
     }
     makeFile(name, content, mode, compressed) {
-        const now = new Date();
+        const now = Date.now();
         return {
             type: "file",
             name,
@@ -74,6 +106,30 @@ class VirtualFileSystem extends EventEmitter {
             updatedAt: now,
         };
     }
+    makeStub(name, content, mode) {
+        const now = Date.now();
+        return { type: "stub", name, stubContent: content, mode, createdAt: now, updatedAt: now };
+    }
+    /**
+     * Write a lazy stub — stores content as a plain string with no Buffer allocation.
+     * Use for static rootfs files that may never be read. On first `writeFile()`,
+     * the stub is promoted to a real `InternalFileNode`.
+     * Parent directories are created when missing.
+     */
+    writeStub(targetPath, content, mode = 0o644) {
+        const normalized = normalizePath(targetPath);
+        const { parent, name } = getParentDirectory(this.root, normalized, true, (p) => this.mkdirRecursive(p, 0o755));
+        const existing = parent.children[name];
+        if (existing?.type === "directory") {
+            throw new Error(`Cannot write stub '${normalized}': path is a directory.`);
+        }
+        // Don't overwrite a real file or an already-promoted node
+        if (existing?.type === "file")
+            return;
+        if (!existing)
+            parent._childCount++;
+        parent.children[name] = this.makeStub(name, content, mode);
+    }
     mkdirRecursive(targetPath, mode) {
         const normalized = normalizePath(targetPath);
         if (normalized === "/")
@@ -83,11 +139,13 @@ class VirtualFileSystem extends EventEmitter {
         let builtPath = "";
         for (const part of parts) {
             builtPath += `/${part}`;
-            let child = current.children.get(part);
+            let child = current.children[part];
             if (!child) {
                 child = this.makeDir(part, mode);
-                current.children.set(part, child);
+                current.children[part] = child;
+                current._childCount++;
                 this.emit("dir:create", { path: builtPath, mode });
+                this._journal({ op: JournalOp.MKDIR, path: builtPath, mode });
             }
             else if (child.type !== "directory") {
                 throw new Error(`Cannot create directory '${builtPath}': path is a file.`);
@@ -106,8 +164,15 @@ class VirtualFileSystem extends EventEmitter {
     async restoreMirror() {
         if (this.mode !== "fs" || !this.snapshotFile)
             return;
-        if (!fsSync.existsSync(this.snapshotFile))
+        if (!fsSync.existsSync(this.snapshotFile)) {
+            // No snapshot yet — but replay journal if it exists (crash after writes, before first flush)
+            if (this.journalFile) {
+                const entries = readJournal(this.journalFile);
+                if (entries.length > 0)
+                    this._replayJournal(entries);
+            }
             return;
+        }
         try {
             const raw = fsSync.readFileSync(this.snapshotFile);
             if (isBinarySnapshot(raw)) {
@@ -121,6 +186,12 @@ class VirtualFileSystem extends EventEmitter {
                 console.info("[VirtualFileSystem] Migrating legacy JSON snapshot to binary format.");
             }
             this.emit("snapshot:restore", { path: this.snapshotFile });
+            // Replay WAL journal on top of the loaded snapshot
+            if (this.journalFile) {
+                const entries = readJournal(this.journalFile);
+                if (entries.length > 0)
+                    this._replayJournal(entries);
+            }
         }
         catch (err) {
             // Corrupt or unreadable snapshot — start fresh and warn
@@ -143,7 +214,14 @@ class VirtualFileSystem extends EventEmitter {
         fsSync.mkdirSync(dir, { recursive: true });
         const binary = encodeVfs(this.root);
         fsSync.writeFileSync(this.snapshotFile, binary);
+        // Checkpoint complete — truncate the journal (entries are now in the snapshot)
+        if (this.journalFile)
+            truncateJournal(this.journalFile);
+        this._dirty = false;
+        this._writesSinceFlush = 0;
         this.emit("mirror:flush", { path: this.snapshotFile });
+        // Evict large files from RAM now that the snapshot is on disk
+        this.evictLargeFiles();
     }
     /** Returns the current persistence mode. */
     getMode() {
@@ -155,6 +233,183 @@ class VirtualFileSystem extends EventEmitter {
     }
     // ── Public filesystem API ─────────────────────────────────────────────────
     /** Creates a directory (and any missing parents). */
+    // ── Auto-flush scheduler ──────────────────────────────────────────────────
+    /** Internal: flush triggered by timer or write-count threshold. */
+    async _autoFlush() {
+        if (!this._dirty)
+            return;
+        await this.flushMirror();
+    }
+    /** Mark VFS as having unflushed writes and trigger threshold flush if needed. */
+    _markDirty() {
+        this._dirty = true;
+        if (this.flushAfterNWrites > 0) {
+            this._writesSinceFlush++;
+            if (this._writesSinceFlush >= this.flushAfterNWrites) {
+                this._writesSinceFlush = 0;
+                void this._autoFlush();
+            }
+        }
+    }
+    /**
+     * Stop the automatic flush timer and perform a final checkpoint.
+     * Call this when shutting down to ensure all data is persisted.
+     *
+     * @example
+     * ```ts
+     * process.on("SIGINT", async () => {
+     *   await shell.vfs.stopAutoFlush();
+     *   process.exit(0);
+     * });
+     * ```
+     */
+    async stopAutoFlush() {
+        if (this._flushTimer !== null) {
+            clearInterval(this._flushTimer);
+            this._flushTimer = null;
+        }
+        if (this._dirty)
+            await this.flushMirror();
+    }
+    /**
+     * Replace the entire root tree — used internally by `bootstrapLinuxRootfs`
+     * to hot-swap the static rootfs snapshot without going through importSnapshot
+     * (which would re-journal every node in fs mode).
+     * @internal
+     */
+    importRootTree(root) {
+        const prev = this._replayMode;
+        this._replayMode = true;
+        try {
+            this.root = root;
+        }
+        finally {
+            this._replayMode = prev;
+        }
+    }
+    /** Serialise current tree to VFSB binary. Used for the static rootfs cache. */
+    encodeBinary() {
+        return encodeVfs(this.root);
+    }
+    /**
+     * Release the in-memory VFS tree, freeing all InternalNode objects for GC.
+     * The tree MUST be restored via `importRootTree()` before any VFS operation.
+     * Called by IdleManager when freezing an idle shell.
+     * @internal
+     */
+    releaseTree() {
+        // Replace root with a minimal stub — keeps the object alive but frees all children
+        this.root = this.makeDir("", 0o755);
+    }
+    /** Set to true during journal replay to suppress re-journaling. */
+    _replayMode = false;
+    /** Append a journal entry if in fs mode and not replaying. */
+    _journal(entry) {
+        if (this.journalFile && !this._replayMode) {
+            appendJournalEntry(this.journalFile, entry);
+            this._markDirty();
+        }
+    }
+    /** Replay a list of journal entries onto the in-memory tree. */
+    _replayJournal(entries) {
+        this._replayMode = true;
+        try {
+            for (const e of entries) {
+                try {
+                    if (e.op === JournalOp.WRITE) {
+                        this.writeFile(e.path, e.content ?? Buffer.alloc(0), { mode: e.mode });
+                    }
+                    else if (e.op === JournalOp.MKDIR) {
+                        this.mkdir(e.path, e.mode);
+                    }
+                    else if (e.op === JournalOp.REMOVE) {
+                        if (this.exists(e.path))
+                            this.remove(e.path, { recursive: true });
+                    }
+                    else if (e.op === JournalOp.CHMOD) {
+                        if (this.exists(e.path))
+                            this.chmod(e.path, e.mode ?? 0o644);
+                    }
+                    else if (e.op === JournalOp.MOVE) {
+                        if (this.exists(e.path) && e.dest)
+                            this.move(e.path, e.dest);
+                    }
+                    else if (e.op === JournalOp.SYMLINK) {
+                        if (e.dest)
+                            this.symlink(e.dest, e.path);
+                    }
+                }
+                catch { /* ignore individual replay errors — best-effort */ }
+            }
+        }
+        finally {
+            this._replayMode = false;
+        }
+    }
+    // ── RAM eviction ──────────────────────────────────────────────────────────
+    /**
+     * Walk the in-memory tree and evict file contents that exceed
+     * `evictionThreshold`. Called automatically after `flushMirror()`.
+     * Safe to call at any time — evicted files are reloaded on demand.
+     */
+    evictLargeFiles() {
+        if (!this.snapshotFile || this.evictionThreshold === 0)
+            return;
+        if (!fsSync.existsSync(this.snapshotFile))
+            return;
+        this._evictDir(this.root);
+    }
+    _evictDir(dir) {
+        for (const node of Object.values(dir.children)) {
+            if (node.type === "directory") {
+                this._evictDir(node);
+            }
+            else if (node.type === "file" && !node.evicted) {
+                const rawSize = node.compressed
+                    ? (node.size ?? node.content.length * 2) // estimate uncompressed
+                    : node.content.length;
+                if (rawSize > this.evictionThreshold) {
+                    node.size = rawSize;
+                    node.content = Buffer.alloc(0); // free heap
+                    node.evicted = true;
+                }
+            }
+            // stubs: nothing to evict — content is already a plain string, not a Buffer
+        }
+    }
+    /**
+     * Reload a single evicted file node's content from the current snapshot.
+     * No-op if the node is not evicted.
+     */
+    _reloadEvicted(node, normalizedPath) {
+        if (!node.evicted || !this.snapshotFile)
+            return;
+        if (!fsSync.existsSync(this.snapshotFile))
+            return;
+        try {
+            // Load and parse the snapshot to find this specific node
+            const raw = fsSync.readFileSync(this.snapshotFile);
+            const tmpRoot = decodeVfs(raw);
+            const parts = normalizedPath.split("/").filter(Boolean);
+            let cur = tmpRoot;
+            for (const part of parts) {
+                if (cur.type !== "directory")
+                    return;
+                const next = cur.children[part];
+                if (!next)
+                    return;
+                cur = next;
+            }
+            if (cur.type === "file") {
+                node.content = cur.content;
+                node.compressed = cur.compressed;
+                node.evicted = undefined;
+            }
+        }
+        catch {
+            // Snapshot unreadable — leave evicted; caller will get empty content
+        }
+    }
     // ── Mount API ─────────────────────────────────────────────────────────────
     /**
      * Mount a host directory into the VFS at `vPath`.
@@ -262,7 +517,7 @@ class VirtualFileSystem extends EventEmitter {
         }
         const normalized = normalizePath(targetPath);
         const { parent, name } = getParentDirectory(this.root, normalized, true, (p) => this.mkdirRecursive(p, 0o755));
-        const existing = parent.children.get(name);
+        const existing = parent.children[name];
         if (existing?.type === "directory") {
             throw new Error(`Cannot write file '${normalized}': path is a directory.`);
         }
@@ -272,17 +527,22 @@ class VirtualFileSystem extends EventEmitter {
         const shouldCompress = options.compress ?? false;
         const storedContent = shouldCompress ? gzipSync(rawContent) : rawContent;
         const mode = options.mode ?? 0o644;
-        if (existing) {
+        if (existing && existing.type === "file") {
+            // Update real file in place
             const f = existing;
             f.content = storedContent;
             f.compressed = shouldCompress;
             f.mode = mode;
-            f.updatedAt = new Date();
+            f.updatedAt = Date.now();
         }
         else {
-            parent.children.set(name, this.makeFile(name, storedContent, mode, shouldCompress));
+            // Create new real file — also promotes stubs (no _childCount change for stubs)
+            if (!existing)
+                parent._childCount++;
+            parent.children[name] = this.makeFile(name, storedContent, mode, shouldCompress);
         }
         this.emit("file:write", { path: normalized, size: storedContent.length });
+        this._journal({ op: JournalOp.WRITE, path: normalized, content: rawContent, mode });
     }
     /**
      * Reads file content as a UTF-8 string.
@@ -297,10 +557,16 @@ class VirtualFileSystem extends EventEmitter {
         }
         const normalized = normalizePath(targetPath);
         const node = getNode(this.root, normalized);
+        if (node.type === "stub") {
+            this.emit("file:read", { path: normalized, size: node.stubContent.length });
+            return node.stubContent;
+        }
         if (node.type !== "file") {
             throw new Error(`Cannot read '${targetPath}': not a file.`);
         }
         const f = node;
+        if (f.evicted)
+            this._reloadEvicted(f, normalized);
         const raw = f.compressed ? gunzipSync(f.content) : f.content;
         this.emit("file:read", { path: normalized, size: raw.length });
         return raw.toString("utf8");
@@ -315,10 +581,17 @@ class VirtualFileSystem extends EventEmitter {
         }
         const normalized = normalizePath(targetPath);
         const node = getNode(this.root, normalized);
+        if (node.type === "stub") {
+            const buf = Buffer.from(node.stubContent, "utf8");
+            this.emit("file:read", { path: normalized, size: buf.length });
+            return buf;
+        }
         if (node.type !== "file") {
             throw new Error(`Cannot read '${targetPath}': not a file.`);
         }
         const f = node;
+        if (f.evicted)
+            this._reloadEvicted(f, normalized);
         const raw = f.compressed ? gunzipSync(f.content) : f.content;
         this.emit("file:read", { path: normalized, size: raw.length });
         return raw;
@@ -338,7 +611,9 @@ class VirtualFileSystem extends EventEmitter {
     }
     /** Updates mode bits on a node. */
     chmod(targetPath, mode) {
-        getNode(this.root, normalizePath(targetPath)).mode = mode;
+        const normalized = normalizePath(targetPath);
+        getNode(this.root, normalized).mode = mode;
+        this._journal({ op: JournalOp.CHMOD, path: normalized, mode });
     }
     /** Returns metadata for a file or directory. */
     stat(targetPath) {
@@ -374,6 +649,19 @@ class VirtualFileSystem extends EventEmitter {
         const normalized = normalizePath(targetPath);
         const node = getNode(this.root, normalized);
         const name = normalized === "/" ? "" : path.posix.basename(normalized);
+        if (node.type === "stub") {
+            const s = node;
+            return {
+                type: "file",
+                name,
+                path: normalized,
+                mode: s.mode,
+                createdAt: new Date(s.createdAt),
+                updatedAt: new Date(s.updatedAt),
+                compressed: false,
+                size: s.stubContent.length,
+            };
+        }
         if (node.type === "file") {
             const f = node;
             return {
@@ -381,10 +669,10 @@ class VirtualFileSystem extends EventEmitter {
                 name,
                 path: normalized,
                 mode: f.mode,
-                createdAt: f.createdAt,
-                updatedAt: f.updatedAt,
+                createdAt: new Date(f.createdAt),
+                updatedAt: new Date(f.updatedAt),
                 compressed: f.compressed,
-                size: f.content.length,
+                size: f.evicted ? (f.size ?? 0) : f.content.length,
             };
         }
         const d = node;
@@ -393,9 +681,9 @@ class VirtualFileSystem extends EventEmitter {
             name,
             path: normalized,
             mode: d.mode,
-            createdAt: d.createdAt,
-            updatedAt: d.updatedAt,
-            childrenCount: d.children.size,
+            createdAt: new Date(d.createdAt),
+            updatedAt: new Date(d.updatedAt),
+            childrenCount: d._childCount,
         };
     }
     /** Lists direct children names of a directory (sorted). */
@@ -416,7 +704,7 @@ class VirtualFileSystem extends EventEmitter {
         if (node.type !== "directory") {
             throw new Error(`Cannot list '${dirPath}': not a directory.`);
         }
-        return Array.from(node.children.keys()).sort();
+        return Object.keys(node.children).sort();
     }
     /** Renders ASCII tree view of a directory hierarchy. */
     tree(dirPath = "/") {
@@ -430,10 +718,10 @@ class VirtualFileSystem extends EventEmitter {
     }
     renderTreeLines(dir, label) {
         const lines = [label];
-        const entries = Array.from(dir.children.keys()).sort();
+        const entries = Object.keys(dir.children).sort();
         for (let i = 0; i < entries.length; i++) {
             const name = entries[i];
-            const child = dir.children.get(name);
+            const child = dir.children[name];
             const isLast = i === entries.length - 1;
             const connector = isLast ? "└── " : "├── ";
             const nextPrefix = isLast ? "    " : "│   ";
@@ -455,8 +743,10 @@ class VirtualFileSystem extends EventEmitter {
     computeUsage(node) {
         if (node.type === "file")
             return node.content.length;
+        if (node.type === "stub")
+            return node.stubContent.length;
         let total = 0;
-        for (const child of node.children.values()) {
+        for (const child of Object.values(node.children)) {
             total += this.computeUsage(child);
         }
         return total;
@@ -470,7 +760,7 @@ class VirtualFileSystem extends EventEmitter {
         if (!f.compressed) {
             f.content = gzipSync(f.content);
             f.compressed = true;
-            f.updatedAt = new Date();
+            f.updatedAt = Date.now();
         }
     }
     /** Decompresses a gzip-compressed file in place. */
@@ -482,7 +772,7 @@ class VirtualFileSystem extends EventEmitter {
         if (f.compressed) {
             f.content = gunzipSync(f.content);
             f.compressed = false;
-            f.updatedAt = new Date();
+            f.updatedAt = Date.now();
         }
     }
     /**
@@ -501,10 +791,13 @@ class VirtualFileSystem extends EventEmitter {
             content: Buffer.from(normalizedTarget, "utf8"),
             mode: 0o120777,
             compressed: false,
-            createdAt: new Date(),
-            updatedAt: new Date(),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
         };
-        parent.children.set(name, symNode);
+        parent.children[name] = symNode;
+        parent._childCount++;
+        // Journal before emit
+        this._journal({ op: JournalOp.SYMLINK, path: normalizedLink, dest: normalizedTarget });
         this.emit("symlink:create", {
             link: normalizedLink,
             target: normalizedTarget,
@@ -567,13 +860,15 @@ class VirtualFileSystem extends EventEmitter {
         const node = getNode(this.root, normalized);
         if (node.type === "directory") {
             const dir = node;
-            if (!options.recursive && dir.children.size > 0) {
+            if (!options.recursive && dir._childCount > 0) {
                 throw new Error(`Directory '${normalized}' is not empty. Use recursive option.`);
             }
         }
         const { parent, name } = getParentDirectory(this.root, normalized, false, () => { });
-        parent.children.delete(name);
+        delete parent.children[name];
+        parent._childCount--;
         this.emit("node:remove", { path: normalized });
+        this._journal({ op: JournalOp.REMOVE, path: normalized });
     }
     /** Moves or renames a node. */
     move(fromPath, toPath) {
@@ -589,9 +884,12 @@ class VirtualFileSystem extends EventEmitter {
         this.mkdirRecursive(path.posix.dirname(toNormalized), 0o755);
         const { parent: destParent, name: destName } = getParentDirectory(this.root, toNormalized, false, () => { });
         const { parent: srcParent, name: srcName } = getParentDirectory(this.root, fromNormalized, false, () => { });
-        srcParent.children.delete(srcName);
+        delete srcParent.children[srcName];
+        srcParent._childCount--;
         node.name = destName;
-        destParent.children.set(destName, node);
+        destParent.children[destName] = node;
+        destParent._childCount++;
+        this._journal({ op: JournalOp.MOVE, path: fromNormalized, dest: toNormalized });
     }
     // ── Snapshot serialisation ─────────────────────────────────────────────────
     /**
@@ -605,17 +903,32 @@ class VirtualFileSystem extends EventEmitter {
     }
     serializeDir(dir) {
         const children = [];
-        for (const child of dir.children.values()) {
-            children.push(child.type === "file"
-                ? this.serializeFile(child)
-                : this.serializeDir(child));
+        for (const child of Object.values(dir.children)) {
+            if (child.type === "stub") {
+                // Serialize stub as a regular file node
+                children.push({
+                    type: "file",
+                    name: child.name,
+                    mode: child.mode,
+                    createdAt: new Date(child.createdAt).toISOString(),
+                    updatedAt: new Date(child.updatedAt).toISOString(),
+                    compressed: false,
+                    contentBase64: Buffer.from(child.stubContent, "utf8").toString("base64"),
+                });
+            }
+            else if (child.type === "file") {
+                children.push(this.serializeFile(child));
+            }
+            else {
+                children.push(this.serializeDir(child));
+            }
         }
         return {
             type: "directory",
             name: dir.name,
             mode: dir.mode,
-            createdAt: dir.createdAt.toISOString(),
-            updatedAt: dir.updatedAt.toISOString(),
+            createdAt: new Date(dir.createdAt).toISOString(),
+            updatedAt: new Date(dir.updatedAt).toISOString(),
             children,
         };
     }
@@ -624,8 +937,8 @@ class VirtualFileSystem extends EventEmitter {
             type: "file",
             name: file.name,
             mode: file.mode,
-            createdAt: file.createdAt.toISOString(),
-            updatedAt: file.updatedAt.toISOString(),
+            createdAt: new Date(file.createdAt).toISOString(),
+            updatedAt: new Date(file.updatedAt).toISOString(),
             compressed: file.compressed,
             contentBase64: file.content.toString("base64"),
         };
@@ -661,27 +974,29 @@ class VirtualFileSystem extends EventEmitter {
             type: "directory",
             name,
             mode: snap.mode,
-            createdAt: new Date(snap.createdAt),
-            updatedAt: new Date(snap.updatedAt),
-            children: new Map(),
+            createdAt: Date.parse(snap.createdAt),
+            updatedAt: Date.parse(snap.updatedAt),
+            children: Object.create(null),
+            _childCount: 0,
         };
         for (const child of snap.children) {
             if (child.type === "file") {
                 const f = child;
-                dir.children.set(f.name, {
+                dir.children[f.name] = {
                     type: "file",
                     name: f.name,
                     mode: f.mode,
-                    createdAt: new Date(f.createdAt),
-                    updatedAt: new Date(f.updatedAt),
+                    createdAt: Date.parse(f.createdAt),
+                    updatedAt: Date.parse(f.updatedAt),
                     compressed: f.compressed,
                     content: Buffer.from(f.contentBase64, "base64"),
-                });
+                };
             }
             else {
                 const sub = this.deserializeDir(child, child.name);
-                dir.children.set(child.name, sub);
+                dir.children[child.name] = sub;
             }
+            dir._childCount++;
         }
         return dir;
     }