@ttsc/wasm 0.19.3 → 0.20.0

package/dist/go.mod

@@ -8,6 +8,7 @@ go 1.26
 // public proxy cannot resolve the in-tree shim modules.
 replace (
 	github.com/microsoft/typescript-go/shim/ast => ./shim-vendor/shim/ast
+	github.com/microsoft/typescript-go/shim/astnav => ./shim-vendor/shim/astnav
 	github.com/microsoft/typescript-go/shim/bundled => ./shim-vendor/shim/bundled
 	github.com/microsoft/typescript-go/shim/checker => ./shim-vendor/shim/checker
 	github.com/microsoft/typescript-go/shim/compiler => ./shim-vendor/shim/compiler
@@ -26,6 +27,7 @@ replace (
 
 require (
 	github.com/microsoft/typescript-go/shim/ast v0.0.0
+	github.com/microsoft/typescript-go/shim/astnav v0.0.0
 	github.com/microsoft/typescript-go/shim/compiler v0.0.0
 	github.com/microsoft/typescript-go/shim/scanner v0.0.0
 	github.com/samchon/ttsc/packages/ttsc v0.0.0

package/go.mod

@@ -8,6 +8,7 @@ go 1.26
 // public proxy cannot resolve the in-tree shim modules.
 replace (
 	github.com/microsoft/typescript-go/shim/ast => ./shim-vendor/shim/ast
+	github.com/microsoft/typescript-go/shim/astnav => ./shim-vendor/shim/astnav
 	github.com/microsoft/typescript-go/shim/bundled => ./shim-vendor/shim/bundled
 	github.com/microsoft/typescript-go/shim/checker => ./shim-vendor/shim/checker
 	github.com/microsoft/typescript-go/shim/compiler => ./shim-vendor/shim/compiler
@@ -26,6 +27,7 @@ replace (
 
 require (
 	github.com/microsoft/typescript-go/shim/ast v0.0.0
+	github.com/microsoft/typescript-go/shim/astnav v0.0.0
 	github.com/microsoft/typescript-go/shim/compiler v0.0.0
 	github.com/microsoft/typescript-go/shim/scanner v0.0.0
 	github.com/samchon/ttsc/packages/ttsc v0.0.0

package/host/fountain.go

@@ -28,6 +28,7 @@ import (
   "syscall/js"
 
   "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/microsoft/typescript-go/shim/astnav"
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
@@ -291,28 +292,31 @@ func jsGetDiagnostics(this js.Value, args []js.Value) any {
 }
 
 // jsGetNodeAtPosition({handle, path, position}) → Promise<ITtscResult>.
-// `position` is a byte offset into the source text (the same coordinate the
-// AST uses internally). JS callers that have a UTF-16 line/character pair
-// should resolve it to a byte offset before calling (the @ttsc/playground
-// helper does this).
+// Returns the token touching the byte offset, including punctuation.
+// Whitespace and comments return `{node: null}`. JS callers with a UTF-16
+// line/character pair must resolve it to a byte offset first.
 func jsGetNodeAtPosition(this js.Value, args []js.Value) any {
   return withSnapshotPosition(args, func(_ *snapshotEntry, file *ast.SourceFile, pos int) any {
-    node := ast.GetNodeAtPosition(file, pos, false)
+    node := tokenAtPosition(file, pos)
     return fountainOK(GetNodeAtPositionResult{Node: nodeInfoOf(node)})
   })
 }
 
 // jsGetTypeAtPosition({handle, path, position}) → Promise<ITtscResult>.
-// Resolves the node at position via GetNodeAtPosition and asks the Program's
-// pinned single checker for its type. Returns `{type: null}` when there is no
-// node at that position or no checker is available.
+// Resolves the touching token, then asks the Program's pinned single checker
+// for the enclosing semantic AST node. Returns `{type: null}` when no token
+// has type semantics, including whitespace, comments, and punctuation.
 func jsGetTypeAtPosition(this js.Value, args []js.Value) any {
   return withSnapshotPosition(args, func(entry *snapshotEntry, file *ast.SourceFile, pos int) any {
-    node := ast.GetNodeAtPosition(file, pos, false)
-    if node == nil || entry.prog.Checker == nil {
+    node := tokenAtPosition(file, pos)
+    if !hasTypeAtLocation(node) || entry.prog.Checker == nil {
+      return fountainOK(GetTypeAtPositionResult{Type: nil})
+    }
+    semanticNode := ast.GetNodeAtPosition(file, pos, false)
+    if semanticNode == nil {
       return fountainOK(GetTypeAtPositionResult{Type: nil})
     }
-    t := entry.prog.Checker.GetTypeAtLocation(node)
+    t := entry.prog.Checker.GetTypeAtLocation(semanticNode)
     if t == nil {
       return fountainOK(GetTypeAtPositionResult{Type: nil})
     }
@@ -326,11 +330,11 @@ func jsGetTypeAtPosition(this js.Value, args []js.Value) any {
 }
 
 // jsGetSymbolAtPosition({handle, path, position}) → Promise<ITtscResult>.
-// Returns `{symbol: null}` when the node at position has no associated
-// symbol (e.g. punctuation, whitespace).
+// Returns `{symbol: null}` when the touching token has no associated symbol,
+// including punctuation, whitespace, and comments.
 func jsGetSymbolAtPosition(this js.Value, args []js.Value) any {
   return withSnapshotPosition(args, func(entry *snapshotEntry, file *ast.SourceFile, pos int) any {
-    node := ast.GetNodeAtPosition(file, pos, false)
+    node := tokenAtPosition(file, pos)
     if node == nil || entry.prog.Checker == nil {
       return fountainOK(GetSymbolAtPositionResult{Symbol: nil})
     }
@@ -374,9 +378,9 @@ func withSnapshot(args []js.Value, fn func(*snapshotEntry, js.Value) any) any {
 
 // withSnapshotPosition is the shared envelope for the 3 position-bound
 // fountain verbs. Same read-lock lifecycle as withSnapshot, plus parses
-// {path, position} and bounds-checks position against the file length so an
-// out-of-range offset reaches `ast.GetNodeAtPosition` only as a clean
-// error response instead of an internal panic.
+// {path, position} and bounds-checks position against the file length. A
+// position must address an existing byte, so the offset at end-of-file is
+// rejected before it can reach AST navigation.
 func withSnapshotPosition(args []js.Value, fn func(*snapshotEntry, *ast.SourceFile, int) any) any {
   return withSnapshot(args, func(entry *snapshotEntry, opts js.Value) any {
     path := stringProp(opts, "path")
@@ -395,13 +399,38 @@ func withSnapshotPosition(args []js.Value, fn func(*snapshotEntry, *ast.SourceFi
     if file == nil {
       return errorResponse(2, fmt.Sprintf("host: file %q not found in snapshot", path))
     }
-    if pos > len(file.Text()) {
-      return errorResponse(2, fmt.Sprintf("host: \"position\" %d exceeds file length %d", pos, len(file.Text())))
+    if pos >= len(file.Text()) {
+      return errorResponse(2, fmt.Sprintf("host: \"position\" %d is outside file length %d", pos, len(file.Text())))
     }
     return fn(entry, file, pos)
   })
 }
 
+// tokenAtPosition resolves the exact token at pos. GetTouchingToken returns a
+// containing AST node when a gap has no token, so preserve the fountain
+// contract by filtering that fallback out explicitly.
+func tokenAtPosition(file *ast.SourceFile, pos int) *ast.Node {
+  node := astnav.GetTouchingToken(file, pos)
+  if node == nil || !ast.IsTokenKind(node.Kind) {
+    return nil
+  }
+  return node
+}
+
+// hasTypeAtLocation mirrors the public checker entrypoint's semantic cases.
+// It deliberately excludes punctuation tokens, whose checker fallback is the
+// error type even though a cursor query has no meaningful type answer.
+func hasTypeAtLocation(node *ast.Node) bool {
+  return node != nil && (ast.IsPartOfTypeNode(node) ||
+    ast.IsExpressionNode(node) ||
+    ast.IsTypeDeclaration(node) ||
+    ast.IsTypeDeclarationName(node) ||
+    ast.IsBindingElement(node) ||
+    ast.IsDeclaration(node) ||
+    ast.IsDeclarationNameOrImportPropertyName(node) ||
+    ast.IsBindingPattern(node))
+}
+
 // resolveSnapshotFile finds a SourceFile by path, accepting either an
 // absolute path or a path relative to the snapshot's cwd.
 func resolveSnapshotFile(entry *snapshotEntry, path string) *ast.SourceFile {

package/lib/src/createMemFS.d.ts

@@ -7,5 +7,11 @@ import type { IMemFSHost } from "./structures/IMemFSHost";
  * `globalThis.fs` before loading `wasm_exec.js`) and convenience helpers
  * (`writeFile`, `readFile`, `mkdirp`, …) for seeding source files and reading
  * compiler output without touching the real filesystem.
+ *
+ * Every successful mutation leaves a valid tree: `/` stays a directory, each
+ * proper ancestor of a node exists and is a directory, and a file has no
+ * descendants. An operation that cannot satisfy that throws (`writeFile`,
+ * `mkdirp`) or reports a POSIX error through its callback, having changed no
+ * node, byte, or descriptor.
  */
 export declare function createMemFS(): IMemFSHost;

package/lib/src/createMemFS.js

@@ -55,6 +55,12 @@ function normalize(p) {
  * `globalThis.fs` before loading `wasm_exec.js`) and convenience helpers
  * (`writeFile`, `readFile`, `mkdirp`, …) for seeding source files and reading
  * compiler output without touching the real filesystem.
+ *
+ * Every successful mutation leaves a valid tree: `/` stays a directory, each
+ * proper ancestor of a node exists and is a directory, and a file has no
+ * descendants. An operation that cannot satisfy that throws (`writeFile`,
+ * `mkdirp`) or reports a POSIX error through its callback, having changed no
+ * node, byte, or descriptor.
  */
 function createMemFS() {
     const nodes = new Map();
@@ -64,8 +70,22 @@ function createMemFS() {
     const fdTable = new Map();
     let nextFd = 100;
     // Reserve 1/2 for stdout/stderr writeSync routing.
-    fdTable.set(1, { path: "/dev/stdout", position: 0, isStdout: true });
-    fdTable.set(2, { path: "/dev/stderr", position: 0, isStderr: true });
+    fdTable.set(1, {
+        path: "/dev/stdout",
+        position: 0,
+        readable: false,
+        writable: true,
+        append: true,
+        isStdout: true,
+    });
+    fdTable.set(2, {
+        path: "/dev/stderr",
+        position: 0,
+        readable: false,
+        writable: true,
+        append: true,
+        isStderr: true,
+    });
     const pipes = new Map();
     /**
      * Drain buffered pipe data into `buffer[offset..offset+length]`. Returns
@@ -99,21 +119,60 @@ function createMemFS() {
             reader.callback(null, n);
         }
     }
-    /** Silently create any missing ancestor directories for path `p`. */
-    function ensureParentDirs(p) {
-        const segments = normalize(p).split("/").filter(Boolean);
-        segments.pop();
+    /** Root-to-leaf path of every segment of `norm` (`/a/b` → `["/a", "/a/b"]`). */
+    function pathChain(norm) {
+        const chain = [];
         let cursor = "";
-        for (const seg of segments) {
+        for (const seg of norm.split("/").filter(Boolean)) {
             cursor += "/" + seg;
-            if (!nodes.has(cursor)) {
-                nodes.set(cursor, {
-                    kind: "dir",
-                    data: new Uint8Array(),
-                    mtimeMs: Date.now(),
-                });
-            }
+            chain.push(cursor);
         }
+        return chain;
+    }
+    /**
+     * Validate that every path in root-to-leaf `chain` is or can become a
+     * directory, and report the ones that do not exist yet.
+     *
+     * A segment that exists as a file makes everything below it impossible: a
+     * file has no descendants, so creating one there would leave a node map that
+     * is not a tree. Validation is deliberately separate from creation so every
+     * caller can reject before touching anything, and so a rejected operation
+     * never leaves half a directory chain behind.
+     */
+    function missingDirs(chain, syscall) {
+        const missing = [];
+        for (const path of chain) {
+            const existing = nodes.get(path);
+            if (!existing)
+                missing.push(path);
+            else if (existing.kind !== "dir")
+                throw new MemFSError_1.MemFSError("ENOTDIR", syscall, path);
+        }
+        return missing;
+    }
+    /** Materialize the directories `missingDirs` reported. */
+    function createDirs(paths) {
+        for (const path of paths)
+            nodes.set(path, {
+                kind: "dir",
+                data: new Uint8Array(),
+                mtimeMs: Date.now(),
+            });
+    }
+    /**
+     * Validate that normalized path `norm` may hold a regular file, returning the
+     * node already there when one exists.
+     *
+     * A directory is never silently replaced by a file — including the root,
+     * which is a directory node like any other. POSIX answers `EISDIR`, and
+     * overwriting the node here would strand every descendant in the map behind a
+     * path `readdir` can no longer walk.
+     */
+    function assertFileTarget(norm, syscall) {
+        const existing = nodes.get(norm);
+        if (existing && existing.kind !== "file")
+            throw new MemFSError_1.MemFSError("EISDIR", syscall, norm);
+        return existing;
     }
     /** Absolute parent directory of a normalized path (`/` for a top-level path). */
     function parentDir(norm) {
@@ -138,6 +197,42 @@ function createMemFS() {
         next.set(data.subarray(0, Math.min(length, data.byteLength)));
         return next;
     }
+    /**
+     * Write `view` through descriptor `entry` and return the bytes stored.
+     *
+     * Three offsets are possible and only one of them is right per call: an
+     * `O_APPEND` descriptor always writes at end-of-file, an explicit `position`
+     * writes exactly there without disturbing the cursor (POSIX `pwrite`), and
+     * `position: null` writes at the cursor and advances it. A write that starts
+     * past end-of-file zero-fills the gap rather than silently relocating.
+     *
+     * A zero-byte write changes nothing at all, so a cursor sitting past
+     * end-of-file cannot extend the file by writing nothing into it.
+     */
+    function writeThroughDescriptor(entry, view, position, syscall) {
+        if (!entry.writable)
+            throw new MemFSError_1.MemFSError("EBADF", syscall, entry.path);
+        const node = entry.node;
+        if (!node)
+            throw new MemFSError_1.MemFSError("ENOENT", syscall, entry.path);
+        if (node.kind !== "file")
+            throw new MemFSError_1.MemFSError("EISDIR", syscall, entry.path);
+        const start = entry.append
+            ? node.data.byteLength
+            : (position ?? entry.position);
+        if (!Number.isInteger(start) || start < 0)
+            throw new MemFSError_1.MemFSError("EINVAL", syscall, entry.path);
+        if (view.byteLength === 0)
+            return 0;
+        const end = start + view.byteLength;
+        if (end > node.data.byteLength)
+            node.data = resizeFileData(node.data, end);
+        node.data.set(view, start);
+        node.mtimeMs = Date.now();
+        if (position === null || entry.append)
+            entry.position = end;
+        return view.byteLength;
+    }
     /**
      * Move the entire subtree rooted at `src` to `dest`, overwriting any existing
      * `dest` node. Every descendant key is re-parented so no old-prefix node is
@@ -170,28 +265,26 @@ function createMemFS() {
         }
     }
     function mkdirp(p) {
-        const segments = normalize(p).split("/").filter(Boolean);
-        let cursor = "";
-        for (const seg of segments) {
-            cursor += "/" + seg;
-            const existing = nodes.get(cursor);
-            if (!existing) {
-                nodes.set(cursor, {
-                    kind: "dir",
-                    data: new Uint8Array(),
-                    mtimeMs: Date.now(),
-                });
-            }
-            else if (existing.kind !== "dir") {
-                throw new MemFSError_1.MemFSError("ENOTDIR", "mkdir", cursor);
-            }
-        }
+        // Validate the whole chain before creating any of it: a rejected mkdirp
+        // must not leave the prefix it had already walked past behind.
+        createDirs(missingDirs(pathChain(normalize(p)), "mkdir"));
     }
     function writeFile(p, data) {
         const norm = normalize(p);
-        ensureParentDirs(norm);
+        // Resolve left to right the way POSIX does: an impossible ancestor is
+        // reported before the target, and both are checked before any mutation.
+        const missing = missingDirs(pathChain(norm).slice(0, -1), "open");
+        const existing = assertFileTarget(norm, "open");
         const bytes = typeof data === "string" ? encoder.encode(data) : new Uint8Array(data);
-        nodes.set(norm, { kind: "file", data: bytes, mtimeMs: Date.now() });
+        createDirs(missing);
+        // Overwriting keeps the same node so descriptors already pointing at this
+        // file observe the replacement instead of a detached predecessor.
+        if (existing) {
+            existing.data = bytes;
+            existing.mtimeMs = Date.now();
+        }
+        else
+            nodes.set(norm, { kind: "file", data: bytes, mtimeMs: Date.now() });
     }
     function readFile(p) {
         const node = nodes.get(normalize(p));
@@ -286,36 +379,20 @@ function createMemFS() {
                     console.error("[wasm]", line);
                 return buf.length;
             }
-            // Open-file fds (>= 100): append to the underlying file. Browser-hosted
-            // tools use this path for ordinary virtual files and explicit outputs.
+            // Open-file fds (>= 100): write at the descriptor cursor, the way Node's
+            // own `writeSync` without a position does. Browser-hosted tools use this
+            // path for ordinary virtual files and explicit outputs.
+            //
+            // An unknown or already-closed fd throws instead of being diverted into
+            // the captured stderr: reporting the byte count of a write nobody
+            // performed made the caller continue on a false success and quietly
+            // contaminated a diagnostic channel consumers read.
             const entry = fdTable.get(fd);
-            if (entry) {
-                const node = nodes.get(entry.path);
-                if (node && node.kind === "file") {
-                    // subarray(0) is a zero-copy view over the full incoming buffer; the
-                    // bytes are copied into `next` before writeSync returns.
-                    const incoming = buf.subarray(0);
-                    const existing = node.data;
-                    const next = new Uint8Array(existing.byteLength + incoming.byteLength);
-                    next.set(existing, 0);
-                    next.set(incoming, existing.byteLength);
-                    node.data = next;
-                    node.mtimeMs = Date.now();
-                    entry.position = next.byteLength;
-                    return incoming.byteLength;
-                }
-            }
-            // Unknown fd. Fall back to the stderr buffer so the bytes aren't lost
-            // entirely (and surface as a console.error so the regression is
-            // visible to whoever's looking).
-            stderr.buffer += decoder.decode(buf);
-            // eslint-disable-next-line no-console
-            console.error("[wasm] writeSync to unknown fd " +
-                fd +
-                " (" +
-                buf.byteLength +
-                " bytes); routed to stderr buffer");
-            return buf.length;
+            if (!entry)
+                throw new MemFSError_1.MemFSError("EBADF", "write");
+            // subarray(0) is a zero-copy view over the full incoming buffer; the
+            // bytes are copied into the node before writeSync returns.
+            return writeThroughDescriptor(entry, buf.subarray(0), null, "write");
         },
         write(fd, buf, offset, length, position, callback) {
             try {
@@ -337,44 +414,88 @@ function createMemFS() {
                     callback(null, length);
                     return;
                 }
-                if (position !== null && position !== 0) {
-                    callback(new MemFSError_1.MemFSError("ESPIPE", "write"), 0);
+                const view = buf.subarray(offset, offset + length);
+                // The stdout/stderr capture buffers are streams, not files: they have
+                // no seekable offset, so an explicit position is meaningless on them.
+                if (fd === 1 || fd === 2) {
+                    if (position !== null && position !== 0)
+                        throw new MemFSError_1.MemFSError("ESPIPE", "write");
+                    callback(null, this.writeSync(fd, view));
                     return;
                 }
-                const view = buf.subarray(offset, offset + length);
-                const written = this.writeSync(fd, view);
-                callback(null, written);
+                const entry = fdTable.get(fd);
+                if (!entry)
+                    throw new MemFSError_1.MemFSError("EBADF", "write");
+                callback(null, writeThroughDescriptor(entry, view, position, "write"));
             }
             catch (err) {
                 callback(err, 0);
             }
         },
+        // Every rejection happens before the first mutation and before a
+        // descriptor is minted, so a refused open leaves neither a half-created
+        // node nor a leaked fd behind.
         open(p, flags, _mode, callback) {
-            const norm = normalize(p);
-            const node = nodes.get(norm);
-            const creating = (flags & (this.constants.O_CREAT ?? 0)) !== 0;
-            if (!node) {
-                if (!creating) {
-                    callback(new MemFSError_1.MemFSError("ENOENT", "open", norm), -1);
-                    return;
+            try {
+                const norm = normalize(p);
+                const creating = (flags & (this.constants.O_CREAT ?? 0)) !== 0;
+                const exclusive = (flags & (this.constants.O_EXCL ?? 0)) !== 0;
+                const truncating = (flags & (this.constants.O_TRUNC ?? 0)) !== 0;
+                const appending = (flags & (this.constants.O_APPEND ?? 0)) !== 0;
+                const directoryOnly = (flags & (this.constants.O_DIRECTORY ?? 0)) !== 0;
+                // The access mode is the low bits of `flags`: absent both means
+                // read-only, and `O_RDWR` alongside `O_WRONLY` still grants both.
+                const writeOnly = (flags & (this.constants.O_WRONLY ?? 0)) !== 0;
+                const readWrite = (flags & (this.constants.O_RDWR ?? 0)) !== 0;
+                const writable = writeOnly || readWrite;
+                const readable = !writeOnly || readWrite;
+                let node = nodes.get(norm);
+                if (!node) {
+                    if (!creating)
+                        throw new MemFSError_1.MemFSError("ENOENT", "open", norm);
+                    // `open` can only ever create a regular file, so a caller demanding a
+                    // directory cannot be satisfied by creating one.
+                    if (directoryOnly)
+                        throw new MemFSError_1.MemFSError("ENOTDIR", "open", norm);
+                    // Creating the missing ancestor chain is the documented job of
+                    // `writeFile` and `mkdirp`; the low-level `open` never promised it.
+                    const missing = missingDirs(pathChain(norm).slice(0, -1), "open");
+                    if (missing.length > 0)
+                        throw new MemFSError_1.MemFSError("ENOENT", "open", missing[0]);
+                    node = { kind: "file", data: new Uint8Array(), mtimeMs: Date.now() };
+                    nodes.set(norm, node);
                 }
-                ensureParentDirs(norm);
-                nodes.set(norm, {
-                    kind: "file",
-                    data: new Uint8Array(),
-                    mtimeMs: Date.now(),
+                else {
+                    if (creating && exclusive)
+                        throw new MemFSError_1.MemFSError("EEXIST", "open", norm);
+                    if (node.kind === "dir") {
+                        // A directory opens read-only — Go stats the fd and lists the path
+                        // that way. Writing to it or truncating it would turn it into a
+                        // file and orphan every descendant.
+                        if (writable || truncating)
+                            throw new MemFSError_1.MemFSError("EISDIR", "open", norm);
+                    }
+                    else if (directoryOnly)
+                        throw new MemFSError_1.MemFSError("ENOTDIR", "open", norm);
+                }
+                if (truncating) {
+                    node.data = new Uint8Array();
+                    node.mtimeMs = Date.now();
+                }
+                const fd = nextFd++;
+                fdTable.set(fd, {
+                    path: norm,
+                    node,
+                    position: 0,
+                    readable,
+                    writable,
+                    append: appending,
                 });
+                callback(null, fd);
             }
-            const fd = nextFd++;
-            fdTable.set(fd, { path: norm, position: 0 });
-            if ((flags & (this.constants.O_TRUNC ?? 0)) !== 0) {
-                nodes.set(norm, {
-                    kind: "file",
-                    data: new Uint8Array(),
-                    mtimeMs: Date.now(),
-                });
+            catch (err) {
+                callback(err, -1);
             }
-            callback(null, fd);
         },
         close(fd, callback) {
             const pipeState = pipes.get(fd);
@@ -421,17 +542,30 @@ function createMemFS() {
                 callback(new MemFSError_1.MemFSError("EBADF", "read"), 0);
                 return;
             }
-            const node = nodes.get(entry.path);
+            // A write-only descriptor is not a readable one. POSIX answers EBADF for
+            // an operation the descriptor's access mode never granted.
+            if (!entry.readable) {
+                callback(new MemFSError_1.MemFSError("EBADF", "read", entry.path), 0);
+                return;
+            }
+            const node = entry.node;
             if (!node || node.kind !== "file") {
                 callback(new MemFSError_1.MemFSError("ENOENT", "read", entry.path), 0);
                 return;
             }
             const start = position ?? entry.position;
+            if (!Number.isInteger(start) || start < 0) {
+                callback(new MemFSError_1.MemFSError("EINVAL", "read", entry.path), 0);
+                return;
+            }
             const end = Math.min(start + length, node.data.byteLength);
             const slice = node.data.subarray(start, end);
             buffer.set(slice, offset);
+            // The cursor advances by the bytes actually read. Assigning `end` would
+            // rewind a cursor already past end-of-file (after `ftruncate`, say) back
+            // onto live bytes and make the next sequential write overwrite them.
             if (position === null)
-                entry.position = end;
+                entry.position = start + slice.byteLength;
             callback(null, slice.byteLength);
         },
         readdir(p, callback) {
@@ -444,7 +578,19 @@ function createMemFS() {
         },
         mkdir(p, _perm, callback) {
             try {
-                mkdirp(p);
+                const norm = normalize(p);
+                if (nodes.has(norm))
+                    throw new MemFSError_1.MemFSError("EEXIST", "mkdir", norm);
+                const parent = nodes.get(parentDir(norm));
+                if (!parent)
+                    throw new MemFSError_1.MemFSError("ENOENT", "mkdir", parentDir(norm));
+                if (parent.kind !== "dir")
+                    throw new MemFSError_1.MemFSError("ENOTDIR", "mkdir", parentDir(norm));
+                nodes.set(norm, {
+                    kind: "dir",
+                    data: new Uint8Array(),
+                    mtimeMs: Date.now(),
+                });
                 callback(null);
             }
             catch (err) {
@@ -463,9 +609,9 @@ function createMemFS() {
             this.stat(p, callback);
         },
         fstat(fd, callback) {
-            // fstat against a pipe end returns a synthetic file-stat. Go's
-            // os.Pipe-backed File uses fstat at construction time to populate
-            // Stat_t; without this it errors and falls back to invalid fds.
+            // fstat against a pipe end returns a synthetic file-stat so a direct
+            // JavaScript caller that wraps the fd in a file-like abstraction can
+            // populate its stat fields. A pipe end has no node in the tree.
             if (pipes.has(fd)) {
                 callback(null, makeStats({
                     kind: "file",
@@ -480,7 +626,9 @@ function createMemFS() {
                 return;
             }
             try {
-                callback(null, statSync(entry.path));
+                if (!entry.node)
+                    throw new MemFSError_1.MemFSError("ENOENT", "fstat", entry.path);
+                callback(null, makeStats(entry.node));
             }
             catch (err) {
                 callback(err, undefined);
@@ -644,7 +792,11 @@ function createMemFS() {
                 callback(new MemFSError_1.MemFSError("EINVAL", "ftruncate"));
                 return;
             }
-            const node = nodes.get(entry.path);
+            if (!entry.writable) {
+                callback(new MemFSError_1.MemFSError("EBADF", "ftruncate", entry.path));
+                return;
+            }
+            const node = entry.node;
             if (!node || node.kind !== "file") {
                 callback(new MemFSError_1.MemFSError("EINVAL", "ftruncate", entry.path));
                 return;