@volter/browser-wali 0.1.166 → 0.1.168

package/dist/snapshot-filesystem.js

@@ -8,12 +8,35 @@ import { encodeBase64, decodeBase64 } from "@volter/browser-runtime/browser-base
  */
 class NodeMap extends Map {
     names = new Map();
+    paths = new Map();
+    pathsFor(node) { return this.paths.get(node) ?? new Set(); }
     static rooted() {
         const nodes = new NodeMap();
         nodes.set("/", rootNode());
         return nodes;
     }
     set(path, node) {
+        const previous = super.get(path);
+        if (previous && previous !== node && previous.ino === node.ino) {
+            // A write replaces the content version, not the inode's names. Every
+            // alias observes the new version without a scan of the whole tree.
+            replaceNode(previous, node);
+            node = previous;
+        }
+        else if (previous !== node) {
+            if (previous) {
+                const aliases = this.paths.get(previous);
+                aliases.delete(path);
+                if (!aliases.size)
+                    this.paths.delete(previous);
+            }
+            let aliases = this.paths.get(node);
+            if (!aliases) {
+                aliases = new Set();
+                this.paths.set(node, aliases);
+            }
+            aliases.add(path);
+        }
         if (!this.has(path) && path !== "/") {
             const directory = parent(path);
             let names = this.names.get(directory);
@@ -26,8 +49,13 @@ class NodeMap extends Map {
         return super.set(path, node);
     }
     delete(path) {
+        const node = super.get(path);
         if (!super.delete(path))
             return false;
+        const aliases = this.paths.get(node);
+        aliases.delete(path);
+        if (!aliases.size)
+            this.paths.delete(node);
         const directory = parent(path);
         const names = this.names.get(directory);
         names?.delete(path.slice(directory === "/" ? 1 : directory.length + 1));
@@ -38,6 +66,7 @@ class NodeMap extends Map {
     clear() {
         super.clear();
         this.names.clear();
+        this.paths.clear();
     }
     /** The names directly under a directory. */
     namesIn(directory) {
@@ -62,6 +91,10 @@ class NodeMap extends Map {
 /** Small transferable filesystem used inside WALI process workers. */
 export class SnapshotWaliFileSystem {
     nodes = NodeMap.rooted();
+    // WasmFS's OpenFileState holds a File independently of the directory.
+    // Adapted from The Emscripten Authors' file_table.cpp/file.h (MIT/NCSA);
+    // our owner keeps the inode and its names once across all process tables.
+    opened = new Map();
     /**
      * 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
@@ -140,6 +173,7 @@ export class SnapshotWaliFileSystem {
                         node.atimeMs = node.mtimeMs = entry.mtimeMs;
                 }
             }
+            filesystem.restoreHardLinks(snapshot);
             filesystem.mutated = false;
         });
         return filesystem;
@@ -316,7 +350,7 @@ export class SnapshotWaliFileSystem {
         const node = this.node(normalized);
         if (!node)
             return undefined;
-        const details = { mode: node.mode, mtimeMs: node.mtimeMs };
+        const details = { mode: node.mode, mtimeMs: node.mtimeMs, inode: node.ino };
         if (node.type === "directory")
             return { path: normalized, type: "directory", ...details };
         // Raw for the live channel to the page (ADR-0046): a copy, whose buffer the post transfers.
@@ -358,6 +392,11 @@ export class SnapshotWaliFileSystem {
                         this.mkdirSync(normalized, { recursive: true });
                     }
                     else if (entry.content !== undefined) {
+                        const kept = previous.get(normalized);
+                        if (kept?.type === "file") {
+                            this.mkdirSync(parent(normalized), { recursive: true });
+                            this.nodes.set(normalized, kept);
+                        }
                         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.
@@ -387,8 +426,30 @@ export class SnapshotWaliFileSystem {
                     this.markMutation(normalized);
                 }
             }
+            this.restoreHardLinks(snapshot);
+            for (const node of new Set(previous.values()))
+                this.releaseUnlinkedNode(node);
         });
     }
+    restoreHardLinks(snapshot) {
+        const inodes = new Map();
+        for (const entry of snapshot.files) {
+            if (entry.type !== "file" || !Number.isSafeInteger(entry.inode) || entry.inode < 2)
+                continue;
+            const path = normalize(entry.path);
+            const node = this.node(path);
+            if (node?.type !== "file")
+                continue;
+            const inode = entry.inode;
+            const existing = inodes.get(inode);
+            if (existing)
+                this.nodes.set(path, existing);
+            // Snapshot inode numbers describe alias groups, not this owner's
+            // allocator. Keep local identities unique, including directories.
+            else
+                inodes.set(inode, node);
+        }
+    }
     /**
      * 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.
@@ -407,7 +468,7 @@ export class SnapshotWaliFileSystem {
                 ? { 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 }).concat(this.untouchedStoreEntries()) };
+                    : { path, type: "file", content: encodeBase64(node.content ?? new Uint8Array()), mode: node.mode, mtimeMs: node.mtimeMs, inode: node.ino }).concat(this.untouchedStoreEntries()) };
     }
     /** The store's entries this tree has not made nodes of, as sized entries: their bytes are the store's. */
     untouchedStoreEntries() {
@@ -445,11 +506,11 @@ export class SnapshotWaliFileSystem {
         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 }
+                    ? { path, type: "file", content: encodeBase64(node.content ?? new Uint8Array()), mode: node.mode, mtimeMs: node.mtimeMs, inode: node.ino }
                     : 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 };
+        return { path, type: "file", size: node.content?.byteLength ?? node.size ?? 0, mode: node.mode, mtimeMs: node.mtimeMs, inode: node.ino };
     }
     existsSync(path) { return this.node(normalize(path)) !== undefined; }
     statSync(path) {
@@ -457,6 +518,9 @@ export class SnapshotWaliFileSystem {
         const node = this.node(normalized);
         if (!node)
             throw new Error(`ENOENT: no such file or directory, stat '${normalized}'`);
+        return this.statNode(node);
+    }
+    statNode(node) {
         const size = node.content?.byteLength ?? node.size ?? 0;
         return {
             isFile: () => node.type === "file",
@@ -466,7 +530,7 @@ export class SnapshotWaliFileSystem {
             mtimeMs: node.mtimeMs,
             atimeMs: node.atimeMs,
             ctimeMs: node.mtimeMs,
-            nlink: 1,
+            nlink: node.type === "file" ? this.nodes.pathsFor(node).size : 1,
             uid: 1000,
             gid: 1000,
             dev: 1,
@@ -477,6 +541,60 @@ export class SnapshotWaliFileSystem {
         };
     }
     lstatSync(path) { return this.statSync(path); }
+    openFileSync(path) {
+        const normalized = normalize(path), 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, open '${normalized}'`);
+        return this.retainNode(node);
+    }
+    retainNode(node) {
+        this.opened.set(node, (this.opened.get(node) ?? 0) + 1);
+        let closed = false;
+        const check = () => { if (closed)
+            throw new Error("EBADF: closed inode handle"); };
+        return {
+            stat: () => { check(); return this.statNode(node); },
+            read: (offset, length) => {
+                check();
+                return node.range && node.content === undefined ? node.range(offset, length)
+                    : this.bytesOf(node).subarray(offset, offset + length);
+            },
+            write: (offset, data) => {
+                check();
+                this.mutate(() => { replaceNode(node, this.writeNode(node, offset, data)); this.markNodeMutation(node); });
+            },
+            truncate: (length) => {
+                check();
+                this.mutate(() => { replaceNode(node, this.truncateNode(node, length)); this.markNodeMutation(node); });
+            },
+            chmod: (mode) => { check(); this.mutate(() => { node.mode = mode & 0o7777; this.markNodeMutation(node); }); },
+            retain: () => { check(); return this.retainNode(node); },
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                const left = this.opened.get(node) - 1;
+                if (left)
+                    this.opened.set(node, left);
+                else {
+                    this.opened.delete(node);
+                    this.releaseUnlinkedNode(node);
+                }
+            },
+        };
+    }
+    releaseUnlinkedNode(node) {
+        if (!this.opened.has(node) && !this.nodes.pathsFor(node).size && node.dirty && node.content) {
+            this.release(node.content);
+            delete node.content;
+        }
+    }
+    markNodeMutation(node) {
+        for (const path of this.nodes.pathsFor(node))
+            this.markMutation(path);
+    }
     async readFile(path) { return this.readFileSync(path); }
     readFileSync(path) {
         const normalized = normalize(path);
@@ -555,42 +673,45 @@ export class SnapshotWaliFileSystem {
             const existing = removed ? this.nodes.get(normalized) : 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) {
-                // In place only in bytes this tree owns: a loaded file's may be a view of a shared layer.
-                content = existing?.dirty ? current : current.slice();
-            }
-            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 {
-                const spare = this.takeSpare(end);
-                content = new Uint8Array(spare ?? new ArrayBuffer(Math.max(end, current.byteLength * 2, 4096)), 0, end);
-                content.set(current);
-                // A spare buffer holds what its last file did; a new one is zero.
-                if (spare)
-                    content.fill(0, current.byteLength, offset);
-                if (existing?.dirty)
-                    this.release(current);
-            }
-            content.set(data, offset);
-            this.nodes.set(normalized, {
-                type: "file",
-                content,
-                dirty: true,
-                mode: existing?.type === "file" ? existing.mode : 0o644,
-                atimeMs: realtimeMilliseconds(),
-                mtimeMs: realtimeMilliseconds(),
-                ino: existing?.type === "file" ? existing.ino : this.nextInode++,
-            });
+            this.nodes.set(normalized, this.writeNode(existing, offset, data));
             this.markMutation(normalized);
         });
     }
+    writeNode(existing, offset, data) {
+        const current = existing ? this.bytesOf(existing) : new Uint8Array();
+        const end = offset + data.byteLength;
+        let content;
+        if (end <= current.byteLength) {
+            // In place only in bytes this tree owns: a loaded file's may be a view of a shared layer.
+            content = existing?.dirty ? current : current.slice();
+        }
+        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 {
+            const spare = this.takeSpare(end);
+            content = new Uint8Array(spare ?? new ArrayBuffer(Math.max(end, current.byteLength * 2, 4096)), 0, end);
+            content.set(current);
+            // A spare buffer holds what its last file did; a new one is zero.
+            if (spare)
+                content.fill(0, current.byteLength, offset);
+            if (existing?.dirty)
+                this.release(current);
+        }
+        content.set(data, offset);
+        return {
+            type: "file",
+            content,
+            dirty: true,
+            mode: existing?.type === "file" ? existing.mode : 0o644,
+            atimeMs: realtimeMilliseconds(),
+            mtimeMs: realtimeMilliseconds(),
+            ino: existing?.type === "file" ? existing.ino : this.nextInode++,
+        };
+    }
     /**
      * A file cut or extended to `length`, in place where its bytes are this
      * tree's own: a rewrite (`O_TRUNC`, then writes) keeps the buffer the file
@@ -608,39 +729,42 @@ export class SnapshotWaliFileSystem {
                 throw new Error(`ENOENT: no such file, truncate '${normalized}'`);
             if (existing.type !== "file")
                 throw new Error(`EISDIR: illegal operation on a directory, truncate '${normalized}'`);
-            let content;
-            if (length === 0 && existing.content === undefined) {
-                // Emptied before it was ever read: the store's bytes are not needed at all.
-                content = new Uint8Array();
+            this.nodes.set(normalized, this.truncateNode(existing, length));
+            this.markMutation(normalized);
+        });
+    }
+    truncateNode(existing, length) {
+        let content;
+        if (length === 0 && existing.content === undefined) {
+            // Emptied before it was ever read: the store's bytes are not needed at all.
+            content = new Uint8Array();
+        }
+        else {
+            const current = this.bytesOf(existing);
+            const capacity = current.buffer.byteLength - current.byteOffset;
+            if (existing.dirty && length <= capacity && (capacity <= SPARE_MINIMUM || length * 4 >= capacity)) {
+                content = new Uint8Array(current.buffer, current.byteOffset, length);
+                content.fill(0, current.byteLength);
             }
             else {
-                const current = this.bytesOf(existing);
-                const capacity = current.buffer.byteLength - current.byteOffset;
-                if (existing.dirty && length <= capacity && (capacity <= SPARE_MINIMUM || length * 4 >= capacity)) {
-                    content = new Uint8Array(current.buffer, current.byteOffset, length);
-                    content.fill(0, current.byteLength);
-                }
-                else {
-                    // Cut far below what the buffer holds: the file stops holding it, and
-                    // it goes where the next file to grow may take it back (a rewrite's
-                    // own writes, usually), within the spares' bound.
-                    content = new Uint8Array(length);
-                    content.set(current.subarray(0, length));
-                    if (existing.dirty)
-                        this.release(current);
-                }
+                // Cut far below what the buffer holds: the file stops holding it, and
+                // it goes where the next file to grow may take it back (a rewrite's
+                // own writes, usually), within the spares' bound.
+                content = new Uint8Array(length);
+                content.set(current.subarray(0, length));
+                if (existing.dirty)
+                    this.release(current);
             }
-            this.nodes.set(normalized, {
-                type: "file",
-                content,
-                dirty: true,
-                mode: existing.mode,
-                atimeMs: realtimeMilliseconds(),
-                mtimeMs: realtimeMilliseconds(),
-                ino: existing.ino,
-            });
-            this.markMutation(normalized);
-        });
+        }
+        return {
+            type: "file",
+            content,
+            dirty: true,
+            mode: existing.mode,
+            atimeMs: realtimeMilliseconds(),
+            mtimeMs: realtimeMilliseconds(),
+            ino: existing.ino,
+        };
     }
     /**
      * Buffers of files this tree owned and dropped (replaced by a rename,
@@ -757,11 +881,32 @@ export class SnapshotWaliFileSystem {
                 throw new Error(`ENOENT: no such file, unlink '${normalized}'`);
             if (node.type !== "file")
                 throw new Error(`EISDIR: illegal operation on a directory, unlink '${normalized}'`);
-            if (node.dirty && node.content)
-                this.release(node.content);
             this.nodes.delete(normalized);
+            this.releaseUnlinkedNode(node);
             this.hide(normalized);
             this.markMutation(normalized);
+            for (const alias of this.nodes.pathsFor(node))
+                this.markMutation(alias);
+        });
+    }
+    linkSync(source, destination) {
+        this.mutate(() => {
+            const from = normalize(source), to = normalize(destination);
+            const node = this.node(from);
+            if (!node)
+                throw new Error(`ENOENT: no such file, link '${from}'`);
+            if (node.type === "directory")
+                throw new Error(`EPERM: cannot hard-link directory '${from}'`);
+            if (this.node(to))
+                throw new Error(`EEXIST: destination exists, link '${to}'`);
+            const directory = this.node(parent(to));
+            if (!directory)
+                throw new Error(`ENOENT: no such directory, link '${to}'`);
+            if (directory.type !== "directory")
+                throw new Error(`ENOTDIR: not a directory, link '${to}'`);
+            this.unhide(to);
+            this.nodes.set(to, node);
+            this.markMutation(to);
         });
     }
     rmdirSync(path) {
@@ -788,6 +933,8 @@ export class SnapshotWaliFileSystem {
             const node = this.node(source);
             if (!node)
                 throw new Error(`ENOENT: no such file or directory, rename '${source}'`);
+            if (this.node(destination) === node)
+                return; // Two names of one inode: Linux rename is a no-op.
             this.mkdirSync(parent(destination), { recursive: true });
             // What the store holds under the source moves too: it is made nodes here first.
             if (this.lower && !this.isHidden(source)) {
@@ -811,9 +958,9 @@ export class SnapshotWaliFileSystem {
                 }
                 const target = `${destination}${path.slice(source.length)}`;
                 const replaced = this.nodes.get(target);
-                if (replaced?.type === "file" && replaced.dirty && replaced.content && replaced !== value)
-                    this.release(replaced.content);
                 this.nodes.set(target, value);
+                if (replaced && replaced !== value)
+                    this.releaseUnlinkedNode(replaced);
                 this.markMutation(path);
                 this.markMutation(target);
             }
@@ -860,6 +1007,9 @@ export class SnapshotWaliFileSystem {
             this.markMutation(normalized);
         });
     }
+    utimesMsSync(path, atimeMs, mtimeMs) {
+        this.utimesSync(path, atimeMs, mtimeMs);
+    }
     mutate(operation) {
         this.mutationDepth += 1;
         try {
@@ -875,7 +1025,12 @@ export class SnapshotWaliFileSystem {
     }
     markMutation(path) {
         this.mutated = true;
-        this.changedPaths?.add(normalize(path));
+        const normalized = normalize(path);
+        this.changedPaths?.add(normalized);
+        const node = this.nodes.get(normalized);
+        if (node)
+            for (const alias of this.nodes.pathsFor(node))
+                this.changedPaths?.add(alias);
     }
 }
 /** A store's file this large is read by range until the program writes it (ADR-0048); a smaller one is read whole, once. */
@@ -889,6 +1044,19 @@ const RANGE_UNCACHED_MINIMUM = 1 << 20;
 const SPARE_MINIMUM = 64 * 1024;
 const SPARE_COUNT = 2;
 const SPARE_TOTAL = 32 * 1024 * 1024;
+/** Replace an inode's content version without invalidating open descriptions. */
+function replaceNode(target, source) {
+    if (target === source)
+        return;
+    delete target.content;
+    delete target.load;
+    delete target.range;
+    delete target.size;
+    delete target.dirty;
+    delete target.fromStore;
+    delete target.link;
+    Object.assign(target, source);
+}
 function rootNode() {
     const now = realtimeMilliseconds();
     return { type: "directory", mode: 0o755, atimeMs: now, mtimeMs: now, ino: 1 };