@volter/browser-wali 0.1.5 → 0.1.6

package/dist/snapshot-filesystem.js

@@ -1,55 +1,409 @@
+import { PROJECT_ROOTS } from "@volter/browser-runtime/browser-pack-store.js";
+import { encodeBase64, decodeBase64 } from "@volter/browser-runtime/browser-base64.js";
+/**
+ * The tree's nodes by path, with each directory's names beside them, so a
+ * listing is a lookup. It was a scan of every path: 7 ms a listing in a tree
+ * of 100,000 entries, which `git status` pays per directory (2026-09-24).
+ */
+class NodeMap extends Map {
+    names = new Map();
+    static rooted() {
+        const nodes = new NodeMap();
+        nodes.set("/", rootNode());
+        return nodes;
+    }
+    set(path, node) {
+        if (!this.has(path) && path !== "/") {
+            const directory = parent(path);
+            let names = this.names.get(directory);
+            if (!names) {
+                names = new Set();
+                this.names.set(directory, names);
+            }
+            names.add(path.slice(directory === "/" ? 1 : directory.length + 1));
+        }
+        return super.set(path, node);
+    }
+    delete(path) {
+        if (!super.delete(path))
+            return false;
+        const directory = parent(path);
+        const names = this.names.get(directory);
+        names?.delete(path.slice(directory === "/" ? 1 : directory.length + 1));
+        if (names?.size === 0)
+            this.names.delete(directory);
+        return true;
+    }
+    clear() {
+        super.clear();
+        this.names.clear();
+    }
+    /** The names directly under a directory. */
+    namesIn(directory) {
+        return [...(this.names.get(directory) ?? [])];
+    }
+    /** A path and everything under it, parents first, found through the names rather than a scan. */
+    subtree(path) {
+        const found = [];
+        const pending = [path];
+        while (pending.length > 0) {
+            const current = pending.shift();
+            const node = this.get(current);
+            if (!node)
+                continue;
+            found.push([current, node]);
+            for (const name of this.names.get(current) ?? [])
+                pending.push(current === "/" ? `/${name}` : `${current}/${name}`);
+        }
+        return found;
+    }
+}
 /** Small transferable filesystem used inside WALI process workers. */
 export class SnapshotWaliFileSystem {
-    nodes = new Map([["/", rootNode()]]);
+    nodes = NodeMap.rooted();
+    /**
+     * The project's store, when the tree is over one (ADR-0042): its index
+     * answers every path this tree has not itself touched, and a path is made a
+     * node when first asked for. Building every node up front was 272 ms of each
+     * process's start in a tree of 100,000 entries, and a process that can fork
+     * paid it twice, once more in its filesystem worker (2026-09-24).
+     */
+    lower;
+    /** The store's paths this tree removed or moved away; everything under one is gone too. */
+    hidden = new Set();
     nextInode = 2;
     mutationDepth = 0;
     mutated = false;
     mutationHandler;
+    /**
+     * The paths mutated since the last {@link takeChangedPaths}, tracked only
+     * while a mutation handler is installed -- i.e. only for the coordinator's
+     * page-facing delta channel, which is the one caller that drains it. Nobody
+     * else drains, so nobody else accumulates.
+     */
+    changedPaths;
     static fromSnapshot(snapshot) {
         const filesystem = new SnapshotWaliFileSystem();
         filesystem.replaceSnapshot(snapshot);
         return filesystem;
     }
+    /**
+     * The tree as the project's store holds it, each file's bytes read from
+     * the store when the program first opens it; the snapshot the page sent
+     * is metadata, and the entries in it that carry content, a program's
+     * private files, are written over the store's.
+     */
+    static fromStore(store, snapshot) {
+        const filesystem = new SnapshotWaliFileSystem();
+        filesystem.lower = store;
+        filesystem.mutate(() => {
+            // The page's metadata for the store's own paths repeats the store; only
+            // what differs from it is applied, so a tree of any size costs its
+            // differences here, not its size.
+            const differing = snapshot.files.filter((source) => {
+                const entry = source;
+                const normalized = normalize(entry.path);
+                if (normalized === "/")
+                    return false;
+                if (entry.content !== undefined)
+                    return true;
+                const held = store.entries.get(normalized);
+                if (!held)
+                    return true;
+                if ((entry.type === "directory") !== (held.type === "directory"))
+                    return true;
+                return (entry.mode !== undefined && entry.mode !== (held.mode & 0o7777))
+                    || (entry.mtimeMs !== undefined && entry.mtimeMs !== held.mtimeMs);
+            });
+            for (const source of differing.sort((left, right) => depth(left.path) - depth(right.path))) {
+                const entry = source;
+                const normalized = normalize(entry.path);
+                if (entry.type === "directory") {
+                    if (!filesystem.node(normalized))
+                        filesystem.mkdirSync(normalized, { recursive: true });
+                }
+                else if (entry.content !== undefined) {
+                    filesystem.writeFileSync(normalized, decodeBase64(entry.content));
+                }
+                else if (!filesystem.node(normalized)) {
+                    continue;
+                }
+                const node = filesystem.node(normalized);
+                if (node) {
+                    if (entry.mode !== undefined)
+                        node.mode = entry.mode;
+                    if (entry.mtimeMs !== undefined)
+                        node.atimeMs = node.mtimeMs = entry.mtimeMs;
+                }
+            }
+            filesystem.mutated = false;
+        });
+        return filesystem;
+    }
+    /** A path's node: one this tree holds, or the store's entry for it, made a node the first time it is asked for. */
+    node(path) {
+        const held = this.nodes.get(path);
+        if (held || !this.lower || path === "/")
+            return held;
+        if (this.isHidden(path))
+            return undefined;
+        const entry = this.lower.entries.get(path);
+        if (!entry)
+            return undefined;
+        const node = this.lowerNode(path, entry);
+        this.nodes.set(path, node);
+        return node;
+    }
+    lowerNode(path, entry) {
+        const store = this.lower;
+        return entry.type === "directory"
+            ? { type: "directory", fromStore: true, mode: entry.mode & 0o7777, atimeMs: entry.mtimeMs, mtimeMs: entry.mtimeMs, ino: this.nextInode++ }
+            : { type: "file", fromStore: true, load: () => store.read(path), size: entry.length, mode: entry.mode & 0o7777, atimeMs: entry.mtimeMs, mtimeMs: entry.mtimeMs, ino: this.nextInode++ };
+    }
+    /**
+     * The tree for a peer that reads the same store: only what differs from it.
+     * A tree that has removed any of the store's paths answers whole, since a
+     * snapshot names what is there and cannot name what is not.
+     */
+    toStoreOverlaySnapshot() {
+        if (!this.lower || this.hidden.size > 0)
+            return this.toSnapshot();
+        const store = this.lower;
+        const overlay = [...this.nodes.entries()].filter(([path, node]) => {
+            if (path === "/")
+                return false;
+            const held = store.entries.get(path);
+            return !(node.fromStore && !node.dirty && held && node.mode === (held.mode & 0o7777) && node.mtimeMs === held.mtimeMs);
+        });
+        return { files: overlay.map(([path, node]) => node.type === "directory"
+                ? { path, type: "directory", mode: node.mode, mtimeMs: node.mtimeMs }
+                : node.load && !node.dirty
+                    ? this.sized(path, node)
+                    : { path, type: "file", content: encodeBase64(node.content ?? new Uint8Array()), mode: node.mode, mtimeMs: node.mtimeMs }) };
+    }
+    isHidden(path) {
+        if (this.hidden.size === 0)
+            return false;
+        for (let current = path; current !== "/"; current = parent(current)) {
+            if (this.hidden.has(current))
+                return true;
+        }
+        return false;
+    }
+    /** A store path this tree no longer has. */
+    hide(path) {
+        if (this.lower?.entries.has(path))
+            this.hidden.add(path);
+    }
+    /** A path made again where the store's was removed: it is new, and the store's contents under it stay gone. */
+    unhide(path) {
+        if (!this.lower || !this.isHidden(path))
+            return;
+        this.hidden.delete(path);
+        for (const name of this.lower.childrenOf(path))
+            this.hidden.add(path === "/" ? `/${name}` : `${path}/${name}`);
+    }
+    /** Every path of the tree, the store's untouched ones as they are there. */
+    everyNode() {
+        const every = [...this.nodes.entries()];
+        if (!this.lower)
+            return every;
+        for (const [path, entry] of this.lower.entries) {
+            if (path === "/" || this.nodes.has(path) || this.isHidden(path))
+                continue;
+            every.push([path, this.lowerNode(path, entry)]);
+        }
+        return every;
+    }
     setMutationHandler(handler) {
         this.mutationHandler = handler;
+        this.changedPaths = handler ? new Set() : undefined;
+    }
+    /**
+     * THE PATHS THIS TREE HAS MUTATED, and then it forgets them.
+     *
+     * This is what the page-facing delta channel publishes, and it exists
+     * because the alternative -- diff two whole-tree snapshots -- is quadratic
+     * in a session's own history. `dirty` (above) stops a flush re-encoding
+     * files the PAGE wrote, but nothing cleared it for files the GUEST wrote,
+     * so every file Blender had ever written was re-base64-encoded on every
+     * later flush. MEASURED 2026-09-19 against Blender's real 1,751-file,
+     * 76 MB staged tree: `toWrittenSnapshot()` costs 0.2 ms on a fresh session
+     * and 1,447 ms forty-one calls in, and the channel calls it three times per
+     * host round trip. That single curve is the whole "WALI is ~100x slower
+     * than Emscripten" floor, and its growth with session age is why a floor
+     * measured on one model looked like a property of the model.
+     *
+     * Clearing `dirty` on publish would NOT have been safe: an entry the page
+     * already holds is compared by SIZE, so a same-length rewrite of the export
+     * arena would have silently dropped out of the patch. Naming the paths
+     * avoids the comparison altogether -- and it is the same shape the HOST
+     * side of this channel already uses (`worker-program.ts`'s
+     * `scheduleFilesystemImport`: "THE CHANGED PATHS, ONE AT A TIME, never the
+     * whole tree"), which had been fixed on that side only.
+     */
+    takeChangedPaths() {
+        const paths = this.changedPaths ?? new Set();
+        this.changedPaths = this.changedPaths ? new Set() : undefined;
+        return paths;
     }
+    /** These paths are not news: file coherence carried them to the page already. */
+    dropChangedPaths(paths) {
+        if (!this.changedPaths)
+            return;
+        for (const path of paths)
+            this.changedPaths.delete(normalize(path));
+    }
+    /**
+     * One path as the page must record it: bytes for a file, the bare node for
+     * a directory, and undefined when the path is gone (the caller's removal).
+     * Always content-carrying, never sized -- the caller named this path
+     * because it changed, so a size would be exactly the wrong answer.
+     */
+    writtenEntry(path) {
+        const normalized = normalize(path);
+        const node = this.node(normalized);
+        if (!node)
+            return undefined;
+        const details = { mode: node.mode, mtimeMs: node.mtimeMs };
+        if (node.type === "directory")
+            return { path: normalized, type: "directory", ...details };
+        return {
+            path: normalized,
+            type: "file",
+            content: encodeBase64(this.bytesOf(node)),
+            ...details,
+        };
+    }
+    /**
+     * The tree as a snapshot describes it. An entry with content is written;
+     * an entry without keeps the bytes this tree already holds for that path,
+     * which is what a snapshot from another realm over the same store says.
+     */
     replaceSnapshot(snapshot) {
         this.mutate(() => {
-            this.nodes.clear();
-            this.nodes.set("/", rootNode());
-            this.nextInode = 2;
-            this.markMutation();
+            // A whole tree replaces everything, the store's layer with it: what the
+            // snapshot does not name is gone.
+            const previous = new Map(this.everyNode());
+            this.lower = undefined;
+            this.hidden.clear();
+            this.nodes = NodeMap.rooted();
+            // THE WHOLE TREE CHANGED, so every path on either side is a changed
+            // path: the ones that survive are republished, the ones that do not
+            // become removals. Costly and correct, and reached only by a child
+            // process's restore -- never by the directory channel's own round trip.
+            for (const path of previous.keys())
+                this.markMutation(path);
+            this.markMutation("/");
             const entries = snapshot.files.slice().sort((left, right) => depth(left.path) - depth(right.path));
             for (const source of entries) {
                 const entry = source;
-                if (entry.path !== "/") {
-                    if (entry.type === "directory")
-                        this.mkdirSync(entry.path, { recursive: true });
-                    else
-                        this.writeFileSync(entry.path, decodeBase64(entry.content ?? ""));
+                const normalized = normalize(entry.path);
+                if (normalized !== "/") {
+                    if (entry.type === "directory") {
+                        this.mkdirSync(normalized, { recursive: true });
+                    }
+                    else if (entry.content !== undefined) {
+                        this.writeFileSync(normalized, decodeBase64(entry.content));
+                        // RESTORED, NOT WRITTEN. These bytes came FROM the page; sending
+                        // them back is the whole cost `dirty` exists to avoid.
+                        const restored = this.nodes.get(normalized);
+                        if (restored)
+                            restored.dirty = false;
+                    }
+                    else {
+                        const kept = previous.get(normalized);
+                        this.mkdirSync(parent(normalized), { recursive: true });
+                        // An entry with no bytes names a file this worker held before
+                        // (kept as it is) or one whose bytes are in no realm it reads: a
+                        // tree the page left out of this image on purpose. The second is
+                        // absent here, its directories present. It was an empty, dirty
+                        // file once, and the exit patch wrote that emptiness back over
+                        // the page's bytes (measured 2026-09-21: a 512 KiB file became 0).
+                        if (kept?.type === "file")
+                            this.nodes.set(normalized, kept);
+                    }
                 }
-                const node = this.nodes.get(normalize(entry.path));
+                const node = this.node(normalized);
                 if (node) {
                     if (entry.mode !== undefined)
                         node.mode = entry.mode;
                     if (entry.mtimeMs !== undefined)
                         node.atimeMs = node.mtimeMs = entry.mtimeMs;
+                    this.markMutation(normalized);
                 }
             }
         });
     }
+    /**
+     * The tree for a peer that holds NOTHING: every file's bytes, except the
+     * ones still in the store, which such a peer reads from the store itself.
+     *
+     * This is the TRANSFER form, and it has two consumers that both materialize
+     * a tree from it and would otherwise get empty files: the coordinator
+     * worker a threaded program's filesystem is handed to (`runtime.ts` ->
+     * `WaliFilesystemCoordinator.create`) and `FilesystemOperation.Snapshot`.
+     * MEASURED 2026-09-19 by shipping the other behaviour here for one commit:
+     * Blender booted to "Failed to import encodings module" because
+     * `python313.zip` reached the coordinator as a size. For a peer that
+     * already holds the unwritten rest, ask {@link toWrittenSnapshot}.
+     */
     toSnapshot() {
         return { files: [...this.nodes.entries()].map(([path, node]) => node.type === "directory"
                 ? { path, type: "directory", mode: node.mode, mtimeMs: node.mtimeMs }
-                : { path, type: "file", content: encodeBase64(node.content ?? new Uint8Array()), mode: node.mode, mtimeMs: node.mtimeMs }) };
+                : node.load && !node.dirty
+                    ? this.sized(path, node)
+                    : { path, type: "file", content: encodeBase64(node.content ?? new Uint8Array()), mode: node.mode, mtimeMs: node.mtimeMs }).concat(this.untouchedStoreEntries()) };
+    }
+    /** The store's entries this tree has not made nodes of, as sized entries: their bytes are the store's. */
+    untouchedStoreEntries() {
+        const untouched = [];
+        if (!this.lower)
+            return untouched;
+        for (const [path, entry] of this.lower.entries) {
+            if (path === "/" || this.nodes.has(path) || this.isHidden(path))
+                continue;
+            untouched.push(entry.type === "directory"
+                ? { path, type: "directory", mode: entry.mode & 0o7777, mtimeMs: entry.mtimeMs }
+                : { path, type: "file", size: entry.length, mode: entry.mode & 0o7777, mtimeMs: entry.mtimeMs });
+        }
+        return untouched;
+    }
+    /**
+     * The tree for a peer that ALREADY HOLDS what this filesystem has not
+     * written: bytes for files written here, a size for everything else.
+     *
+     * WHY, measured 2026-09-19 with Blender's 78 MB runtime tree (2,285 files)
+     * in the guest: `toSnapshot()` costs 1739 ms and allocates 96.2 MB of
+     * base64 string, and the page-facing delta channel calls it on a 100 ms
+     * debounce after every guest mutation plus twice more inside every host
+     * import -- so one round trip of a long-lived program spent seconds
+     * re-encoding files nobody had written, and the editor's Blender session
+     * wedged on it. Against the same tree this answers in 0 ms and allocates
+     * nothing.
+     *
+     * Safe for that channel and only for it: the page sent those bytes, and
+     * `createProcessFilesystemPatch` compares a sized entry against a
+     * content-carrying one by SIZE, so an untouched file falls out of the patch
+     * exactly as it did when it carried its own base64.
+     */
+    toWrittenSnapshot() {
+        return { files: [...this.nodes.entries()].map(([path, node]) => node.type === "directory"
+                ? { path, type: "directory", mode: node.mode, mtimeMs: node.mtimeMs }
+                : node.dirty
+                    ? { path, type: "file", content: encodeBase64(node.content ?? new Uint8Array()), mode: node.mode, mtimeMs: node.mtimeMs }
+                    : this.sized(path, node)).concat(this.untouchedStoreEntries()) };
+    }
+    sized(path, node) {
+        return { path, type: "file", size: node.content?.byteLength ?? node.size ?? 0, mode: node.mode, mtimeMs: node.mtimeMs };
     }
-    existsSync(path) { return this.nodes.has(normalize(path)); }
+    existsSync(path) { return this.node(normalize(path)) !== undefined; }
     statSync(path) {
         const normalized = normalize(path);
-        const node = this.nodes.get(normalized);
+        const node = this.node(normalized);
         if (!node)
             throw new Error(`ENOENT: no such file or directory, stat '${normalized}'`);
-        const size = node.content?.byteLength ?? 0;
+        const size = node.content?.byteLength ?? node.size ?? 0;
         return {
             isFile: () => node.type === "file",
             isDirectory: () => node.type === "directory",
@@ -69,29 +423,93 @@ export class SnapshotWaliFileSystem {
         };
     }
     lstatSync(path) { return this.statSync(path); }
+    async readFile(path) { return this.readFileSync(path); }
     readFileSync(path) {
         const normalized = normalize(path);
-        const node = this.nodes.get(normalized);
+        const node = this.node(normalized);
+        if (!node)
+            throw new Error(`ENOENT: no such file, open '${normalized}'`);
+        if (node.type !== "file")
+            throw new Error(`EISDIR: illegal operation on a directory, read '${normalized}'`);
+        return this.bytesOf(node).slice();
+    }
+    /** The file's bytes, read from the store the first time. */
+    bytesOf(node) {
+        if (node.content === undefined && node.load) {
+            node.content = node.load();
+            node.size = node.content.byteLength;
+        }
+        return node.content ?? new Uint8Array();
+    }
+    readRangeSync(path, offset, length) {
+        const normalized = normalize(path);
+        const node = this.node(normalized);
         if (!node)
             throw new Error(`ENOENT: no such file, open '${normalized}'`);
         if (node.type !== "file")
             throw new Error(`EISDIR: illegal operation on a directory, read '${normalized}'`);
-        return (node.content ?? new Uint8Array()).slice();
+        return this.bytesOf(node).slice(offset, offset + length);
+    }
+    /**
+     * Write in place, growing the backing buffer geometrically. `content` is a
+     * view; its `buffer` may be larger than the file, and every reader of a
+     * node goes through the view (`bytesOf`, `writtenEntry`, `toSnapshot`), so
+     * the spare capacity is never observed. A file that does not exist yet is
+     * created; a gap past the old end is zero.
+     */
+    writeRangeSync(path, offset, data) {
+        this.mutate(() => {
+            const normalized = normalize(path);
+            this.mkdirSync(parent(normalized), { recursive: true });
+            this.unhide(normalized);
+            const existing = this.node(normalized);
+            if (existing?.type === "directory")
+                throw new Error(`EISDIR: illegal operation on a directory, write '${normalized}'`);
+            const current = existing ? this.bytesOf(existing) : new Uint8Array();
+            const end = offset + data.byteLength;
+            let content;
+            if (end <= current.byteLength) {
+                content = current;
+            }
+            else if (end <= current.buffer.byteLength - current.byteOffset && existing?.dirty) {
+                // Room in a buffer this store already grew for the file (a dirty
+                // node's buffer is ours; a loaded or snapshot one may be shared).
+                content = new Uint8Array(current.buffer, current.byteOffset, end);
+                content.fill(0, current.byteLength, offset);
+            }
+            else {
+                content = new Uint8Array(new ArrayBuffer(Math.max(end, current.byteLength * 2, 4096)), 0, end);
+                content.set(current);
+            }
+            content.set(data, offset);
+            this.nodes.set(normalized, {
+                type: "file",
+                content,
+                dirty: true,
+                mode: existing?.type === "file" ? existing.mode : 0o644,
+                atimeMs: Date.now(),
+                mtimeMs: Date.now(),
+                ino: existing?.type === "file" ? existing.ino : this.nextInode++,
+            });
+            this.markMutation(normalized);
+        });
     }
     writeFileSync(path, data) {
         this.mutate(() => {
             const normalized = normalize(path);
             this.mkdirSync(parent(normalized), { recursive: true });
-            const existing = this.nodes.get(normalized);
+            this.unhide(normalized);
+            const existing = this.node(normalized);
             this.nodes.set(normalized, {
                 type: "file",
                 content: typeof data === "string" ? new TextEncoder().encode(data) : data.slice(),
+                dirty: true,
                 mode: existing?.type === "file" ? existing.mode : 0o644,
                 atimeMs: Date.now(),
                 mtimeMs: Date.now(),
                 ino: existing?.type === "file" ? existing.ino : this.nextInode++,
             });
-            this.markMutation();
+            this.markMutation(normalized);
         });
     }
     mkdirSync(path, options) {
@@ -103,47 +521,51 @@ export class SnapshotWaliFileSystem {
             let current = "";
             for (let index = 0; index < segments.length; index += 1) {
                 current += `/${segments[index]}`;
-                const existing = this.nodes.get(current);
+                const existing = this.node(current);
                 if (existing?.type === "file")
                     throw new Error(`ENOTDIR: not a directory, mkdir '${current}'`);
                 if (existing)
                     continue;
                 if (!options?.recursive && index !== segments.length - 1)
                     throw new Error(`ENOENT: no such directory, mkdir '${current}'`);
+                this.unhide(current);
                 const now = Date.now();
                 this.nodes.set(current, { type: "directory", mode: 0o755, atimeMs: now, mtimeMs: now, ino: this.nextInode++ });
-                this.markMutation();
+                this.markMutation(current);
             }
         });
     }
     readdirSync(path) {
         const normalized = normalize(path);
-        const node = this.nodes.get(normalized);
+        const node = this.node(normalized);
         if (!node)
             throw new Error(`ENOENT: no such directory, scandir '${normalized}'`);
         if (node.type !== "directory")
             throw new Error(`ENOTDIR: not a directory, scandir '${normalized}'`);
-        const prefix = normalized === "/" ? "/" : `${normalized}/`;
-        const children = new Set();
-        for (const candidate of this.nodes.keys()) {
-            if (candidate.startsWith(prefix) && candidate !== normalized) {
-                const child = candidate.slice(prefix.length).split("/", 1)[0];
-                if (child)
-                    children.add(child);
+        const names = new Set(this.nodes.namesIn(normalized));
+        if (this.lower && !this.isHidden(normalized)) {
+            // The store's roots are its top: no entry of it names them as children of `/`.
+            const lowerNames = normalized === "/"
+                ? PROJECT_ROOTS.filter((root) => this.lower.entries.has(root)).map((root) => root.slice(1))
+                : this.lower.childrenOf(normalized);
+            for (const name of lowerNames) {
+                if (!this.isHidden(normalized === "/" ? `/${name}` : `${normalized}/${name}`))
+                    names.add(name);
             }
         }
-        return [...children];
+        return [...names];
     }
     unlinkSync(path) {
         this.mutate(() => {
             const normalized = normalize(path);
-            const node = this.nodes.get(normalized);
+            const node = this.node(normalized);
             if (!node)
                 throw new Error(`ENOENT: no such file, unlink '${normalized}'`);
             if (node.type !== "file")
                 throw new Error(`EISDIR: illegal operation on a directory, unlink '${normalized}'`);
             this.nodes.delete(normalized);
-            this.markMutation();
+            this.hide(normalized);
+            this.markMutation(normalized);
         });
     }
     rmdirSync(path) {
@@ -151,7 +573,7 @@ export class SnapshotWaliFileSystem {
             const normalized = normalize(path);
             if (normalized === "/")
                 throw new Error("EPERM: cannot remove root directory");
-            const node = this.nodes.get(normalized);
+            const node = this.node(normalized);
             if (!node)
                 throw new Error(`ENOENT: no such directory, rmdir '${normalized}'`);
             if (node.type !== "directory")
@@ -159,44 +581,59 @@ export class SnapshotWaliFileSystem {
             if (this.readdirSync(normalized).length > 0)
                 throw new Error(`ENOTEMPTY: directory not empty, rmdir '${normalized}'`);
             this.nodes.delete(normalized);
-            this.markMutation();
+            this.hide(normalized);
+            this.markMutation(normalized);
         });
     }
     renameSync(oldPath, newPath) {
         this.mutate(() => {
             const source = normalize(oldPath);
             const destination = normalize(newPath);
-            const node = this.nodes.get(source);
+            const node = this.node(source);
             if (!node)
                 throw new Error(`ENOENT: no such file or directory, rename '${source}'`);
             this.mkdirSync(parent(destination), { recursive: true });
-            const moved = [...this.nodes.entries()].filter(([path]) => path === source || path.startsWith(`${source}/`));
+            // What the store holds under the source moves too: it is made nodes here first.
+            if (this.lower && !this.isHidden(source)) {
+                for (const [path] of this.lower.descendants(source))
+                    this.node(path);
+            }
+            const moved = this.nodes.subtree(source);
             for (const [path] of moved)
                 this.nodes.delete(path);
-            for (const [path, value] of moved)
+            this.hide(source);
+            this.unhide(destination);
+            for (const [path, value] of moved) {
+                // A file moved is a file the page must write at its new path: its bytes come along.
+                if (value.type === "file") {
+                    this.bytesOf(value);
+                    value.dirty = true;
+                }
                 this.nodes.set(`${destination}${path.slice(source.length)}`, value);
-            this.markMutation();
+                this.markMutation(path);
+                this.markMutation(`${destination}${path.slice(source.length)}`);
+            }
         });
     }
     chmodSync(path, mode) {
         this.mutate(() => {
             const normalized = normalize(path);
-            const node = this.nodes.get(normalized);
+            const node = this.node(normalized);
             if (!node)
                 throw new Error(`ENOENT: no such file or directory, chmod '${normalized}'`);
             node.mode = mode & 0o7777;
-            this.markMutation();
+            this.markMutation(normalized);
         });
     }
     utimesSync(path, atimeMs, mtimeMs) {
         this.mutate(() => {
             const normalized = normalize(path);
-            const node = this.nodes.get(normalized);
+            const node = this.node(normalized);
             if (!node)
                 throw new Error(`ENOENT: no such file or directory, utimes '${normalized}'`);
             node.atimeMs = atimeMs;
             node.mtimeMs = mtimeMs;
-            this.markMutation();
+            this.markMutation(normalized);
         });
     }
     mutate(operation) {
@@ -212,8 +649,9 @@ export class SnapshotWaliFileSystem {
             }
         }
     }
-    markMutation() {
+    markMutation(path) {
         this.mutated = true;
+        this.changedPaths?.add(normalize(path));
     }
 }
 function rootNode() {
@@ -234,14 +672,4 @@ function normalize(path) {
 }
 function parent(path) { return path.slice(0, path.lastIndexOf("/")) || "/"; }
 function depth(path) { return path.split("/").length; }
-function decodeBase64(value) {
-    const binary = atob(value);
-    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
-}
-function encodeBase64(value) {
-    let binary = "";
-    for (const byte of value)
-        binary += String.fromCharCode(byte);
-    return btoa(binary);
-}
 //# sourceMappingURL=snapshot-filesystem.js.map