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
PR-URL: #65752
Fixes: #65751
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: trivikr

lib/internal/vfs/providers/ziparchive.js

@@ -29,6 +29,7 @@ const {
 const {
   createEBADF,
   createEEXIST,
+  createEINVAL,
   createEISDIR,
   createENOENT,
   createENOTDIR,
@@ -78,17 +79,41 @@ function isWritableFlag(flags) {
 }
 
 /**
- * The `options.method` value that reproduces `method` (a `zipEntry.method`
- * raw compression method number) on `add()`/`addSync()`, so `rename()`
- * doesn't silently recompress an entry with a different method than the one
- * it already had (e.g. turning a zstd-compressed entry into a stored one).
- * @param {number} method
- * @returns {'store' | 'zstd' | 'deflate'}
+ * Builds the options needed to preserve an entry's metadata and compression
+ * method when adding it under a new name. Converts the raw ZIP compression
+ * method number to the corresponding `add()`/`addSync()` option.
+ * @param {ZipEntry} entry
+ * @returns {{ mode: number | undefined, modified: Date,
+ *   method: 'store' | 'zstd' | 'deflate' }}
  */
-function methodOption(method) {
-  if (method === 0) return 'store';
-  if (method === 93) return 'zstd';
-  return 'deflate';
+function renameOptions(entry) {
+  return {
+    mode: entry.mode || undefined,
+    modified: entry.modified,
+    method: entry.method === 0 ? 'store' : entry.method === 93 ? 'zstd' : 'deflate',
+  };
+}
+
+/**
+ * Finds the entries belonging to an implicit directory and maps their names
+ * from the old directory prefix to the new one.
+ * @param {ZipBuffer | ZipFile} source
+ * @param {string} oldName
+ * @param {string} newName
+ * @returns {Array<{ oldName: string, newName: string }>}
+ */
+function getDirectoryRenames(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;
 }
 
 /**
@@ -537,32 +562,56 @@ 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);
-    // A file cannot take a directory's name; the archive would otherwise
-    // hold both under it.
-    if (this.#isDirectory(newName)) throw createEISDIR('rename', newPath);
-    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);
+    let entries;
+    if (entry === null) {
+      entries = getDirectoryRenames(this.#source, oldName, newName);
+      if (entries.length === 0) throw createENOENT('rename', oldPath);
+      if (StringPrototypeStartsWith(newName, `${oldName}/`)) {
+        throw createEINVAL('rename', oldPath);
+      }
+    } else {
+      if (this.#isDirectory(newName)) throw createEISDIR('rename', newPath);
+      entries = [{ oldName, newName, entry }];
+    }
+    if (oldName === newName) return;
+
+    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);
-    if (this.#isDirectory(newName)) throw createEISDIR('rename', newPath);
-    const content = entry.contentSync();
-    this.#source.addSync(newName, content, {
-      mode: entry.mode || undefined,
-      modified: entry.modified,
-      method: methodOption(entry.method),
-    });
-    this.#deleteEntrySync(oldName);
+    let entries;
+    if (entry === null) {
+      entries = getDirectoryRenames(this.#source, oldName, newName);
+      if (entries.length === 0) throw createENOENT('rename', oldPath);
+      if (StringPrototypeStartsWith(newName, `${oldName}/`)) {
+        throw createEINVAL('rename', oldPath);
+      }
+    } else {
+      if (this.#isDirectory(newName)) throw createEISDIR('rename', newPath);
+      entries = [{ oldName, newName, entry }];
+    }
+    if (oldName === newName) return;
+
+    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,37 @@ 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');
+  }
+
+  // Renaming an explicit directory also renames its children.
+  {
+    const archive = await buildArchive([
+      await zlib.ZipEntry.create('async-dir/', Buffer.alloc(0)),
+      await zlib.ZipEntry.create('async-dir/child.txt', Buffer.from('async')),
+      await zlib.ZipEntry.create('sync-dir/', Buffer.alloc(0)),
+      await zlib.ZipEntry.create('sync-dir/child.txt', Buffer.from('sync')),
+    ]);
+    const zip = new zlib.ZipBuffer(archive);
+    const archiveVfs = vfs.create(new vfs.ZipProvider(zip));
+
+    await archiveVfs.promises.rename('/async-dir', '/renamed-async-dir');
+    assert.strictEqual(zip.has('async-dir/'), false);
+    assert.strictEqual(zip.has('async-dir/child.txt'), false);
+    assert.strictEqual(zip.has('renamed-async-dir/'), true);
+    assert.strictEqual(
+      await archiveVfs.promises.readFile('/renamed-async-dir/child.txt', 'utf8'),
+      'async',
+    );
+
+    archiveVfs.renameSync('/sync-dir', '/renamed-sync-dir');
+    assert.strictEqual(zip.has('sync-dir/'), false);
+    assert.strictEqual(zip.has('sync-dir/child.txt'), false);
+    assert.strictEqual(zip.has('renamed-sync-dir/'), true);
+    assert.strictEqual(archiveVfs.readFileSync('/renamed-sync-dir/child.txt', 'utf8'), 'sync');
   }
 
   // --- ZipFile-backed, read-only: writes rejected with EROFS ----------------
@@ -220,6 +251,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 -----------