vfs: support renaming implicit ZIP directories

Treat archive entry prefixes as directories when renaming with
ZipProvider. Move all descendant entries to the new prefix for both
asynchronous and synchronous operations.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: codex:gpt-5.6-sol

Author: trivikr

lib/internal/vfs/providers/ziparchive.js

@@ -23,6 +23,7 @@ const { VirtualProvider } = require('internal/vfs/provider');
 const { VirtualFileHandle } = require('internal/vfs/file_handle');
 const {
   createEEXIST,
+  createEINVAL,
   createEISDIR,
   createENOENT,
   createENOTDIR,
@@ -102,6 +103,28 @@ function methodOption(method) {
   return 'deflate';
 }
 
+function renameOptions(entry) {
+  return {
+    mode: entry.mode || undefined,
+    modified: entry.modified,
+    method: methodOption(entry.method),
+  };
+}
+
+function directoryRenames(source, oldName, newName) {
+  const entries = [];
+  const prefix = `${oldName}/`;
+  for (const name of source.keys()) {
+    if (StringPrototypeStartsWith(name, prefix)) {
+      ArrayPrototypePush(entries, {
+        oldName: name,
+        newName: newName + StringPrototypeSlice(name, oldName.length),
+      });
+    }
+  }
+  return entries;
+}
+
 /**
  * A file handle over one ZIP entry. ZIP members can't be edited in place
  * (they're a single compressed blob), so writes accumulate in memory and are
@@ -530,28 +553,48 @@ class ZipProvider extends VirtualProvider {
     const oldName = normalize(oldPath);
     const newName = normalize(newPath);
     const entry = await this.#getEntry(oldName);
-    if (entry === null) throw createENOENT('rename', oldPath);
-    const content = await entry.content();
-    await this.#source.add(newName, content, {
-      mode: entry.mode || undefined,
-      modified: entry.modified,
-      method: methodOption(entry.method),
-    });
-    await this.#source.delete(oldName);
+    const entries = entry === null ?
+      directoryRenames(this.#source, oldName, newName) :
+      [{ oldName, newName, entry }];
+    if (entries.length === 0) throw createENOENT('rename', oldPath);
+    if (oldName === newName) return;
+    if (entry === null && StringPrototypeStartsWith(newName, `${oldName}/`)) {
+      throw createEINVAL('rename', oldPath);
+    }
+
+    for (let i = 0; i < entries.length; i++) {
+      const item = entries[i];
+      item.entry ??= await this.#getEntry(item.oldName);
+      await this.#source.add(
+        item.newName, await item.entry.content(), renameOptions(item.entry));
+    }
+    for (let i = 0; i < entries.length; i++) {
+      await this.#source.delete(entries[i].oldName);
+    }
   }
   renameSync(oldPath, newPath) {
     if (this.readonly) throw createEROFS('rename', oldPath);
     const oldName = normalize(oldPath);
     const newName = normalize(newPath);
     const entry = this.#getEntrySync(oldName);
-    if (entry === null) throw createENOENT('rename', oldPath);
-    const content = entry.contentSync();
-    this.#source.addSync(newName, content, {
-      mode: entry.mode || undefined,
-      modified: entry.modified,
-      method: methodOption(entry.method),
-    });
-    this.#deleteEntrySync(oldName);
+    const entries = entry === null ?
+      directoryRenames(this.#source, oldName, newName) :
+      [{ oldName, newName, entry }];
+    if (entries.length === 0) throw createENOENT('rename', oldPath);
+    if (oldName === newName) return;
+    if (entry === null && StringPrototypeStartsWith(newName, `${oldName}/`)) {
+      throw createEINVAL('rename', oldPath);
+    }
+
+    for (let i = 0; i < entries.length; i++) {
+      const item = entries[i];
+      item.entry ??= this.#getEntrySync(item.oldName);
+      this.#source.addSync(
+        item.newName, item.entry.contentSync(), renameOptions(item.entry));
+    }
+    for (let i = 0; i < entries.length; i++) {
+      this.#deleteEntrySync(entries[i].oldName);
+    }
   }
 
   /**

test/parallel/test-vfs-zip-provider.js

@@ -119,6 +119,10 @@ async function buildArchive(entries, comment) {
     await assert.rejects(archiveVfs.promises.open('/does-not-exist.txt', 'r'), { code: 'ENOENT' });
     await assert.rejects(archiveVfs.promises.open('/a.txt', 'wx'), { code: 'EEXIST' });
     await assert.rejects(archiveVfs.promises.open('/dir', 'r'), { code: 'EISDIR' });
+
+    await archiveVfs.promises.rename('/dir', '/renamed-dir');
+    await assert.rejects(archiveVfs.promises.stat('/dir'), { code: 'ENOENT' });
+    assert.strictEqual(await archiveVfs.promises.readFile('/renamed-dir/b.txt', 'utf8'), 'nested');
   }
 
   // --- ZipFile-backed, read-only: writes rejected with EROFS ----------------
@@ -220,6 +224,10 @@ async function buildArchive(entries, comment) {
     assert.throws(() => archiveVfs.openSync('/does-not-exist.txt', 'r'), { code: 'ENOENT' });
     assert.throws(() => archiveVfs.openSync('/a.txt', 'wx'), { code: 'EEXIST' });
     assert.throws(() => archiveVfs.openSync('/dir', 'r'), { code: 'EISDIR' });
+
+    archiveVfs.renameSync('/dir', '/renamed-dir');
+    assert.throws(() => archiveVfs.statSync('/dir'), { code: 'ENOENT' });
+    assert.strictEqual(archiveVfs.readFileSync('/renamed-dir/b.txt', 'utf8'), 'nested');
   }
 
   // --- ZipFile-backed via openSync: sync-only round trip on disk -----------