@fgv/ts-web-extras 5.1.0-0 → 5.1.0-1

package/src/test/unit/fileSystemAccessTreeAccessors.test.ts

@@ -21,6 +21,7 @@
  */
 
 import '@fgv/ts-utils-jest';
+import { fail, type Result, Logging } from '@fgv/ts-utils';
 import { FileSystemAccessTreeAccessors } from '../../packlets/file-tree';
 import { FileApiTreeAccessors } from '../../packlets/file-tree';
 import { FileTree } from '@fgv/ts-json-base';
@@ -166,7 +167,7 @@ describe('FileSystemAccessTreeAccessors', () => {
 
     test('fails gracefully when queryPermission throws', async () => {
       const fileHandle = {
-        kind: 'file' as const,
+        kind: 'file',
         name: 'collection.yaml',
         async getFile(): Promise<File> {
           return createMockFileHandle('collection.yaml', {
@@ -466,267 +467,419 @@ describe('FileSystemAccessTreeAccessors', () => {
         accessors.saveFileContents('/test.txt', 'modified').orThrow();
 
         // Verify file is marked dirty but not synced
-        expect(accessors.isDirty()).toBe(true);
         expect(accessors.getDirtyPaths()).toContain('/test.txt');
 
         // In-memory content should be modified
         expect(accessors.getFileContents('/test.txt')).toSucceedWith('modified');
       });
-    });
-  });
 
-  describe('fileIsMutable', () => {
-    test('returns persistent detail when write permission granted', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'test.txt': { content: 'test', type: 'text/plain' }
+      test('logs when save auto-sync returns a failure Result', async () => {
+        const logger = {
+          detail: jest.fn(),
+          info: jest.fn(),
+          warn: jest.fn(),
+          error: jest.fn()
+        } as unknown as Logging.LogReporter<unknown>;
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'original', type: 'text/plain' }
+        });
+
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+            mutable: true,
+            autoSync: true,
+            logger
+          })
+        ).orThrow();
+
+        (
+          accessors as unknown as {
+            _syncFile: (_path: string) => Promise<Result<void>>;
+          }
+        )._syncFile = async () => fail<void>('simulated save sync failure');
+
+        accessors.saveFileContents('/test.txt', 'modified').orThrow();
+        await new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('simulated save sync failure'));
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
-      ).orThrow();
+      test('logs when delete auto-sync throws unexpectedly', async () => {
+        const logger = {
+          detail: jest.fn(),
+          info: jest.fn(),
+          warn: jest.fn(),
+          error: jest.fn()
+        } as unknown as Logging.LogReporter<unknown>;
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'original', type: 'text/plain' }
+        });
 
-      const result = accessors.fileIsMutable('/test.txt');
-      expect(result).toSucceedWithDetail(true, 'persistent');
-    });
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+            mutable: true,
+            autoSync: true,
+            logger
+          })
+        ).orThrow();
 
-    test('returns transient detail when write permission not granted', async () => {
-      const dirHandle = createMockDirectoryHandle(
-        '/',
-        { 'test.txt': { content: 'test', type: 'text/plain' } },
-        { hasWritePermission: false }
-      );
+        (
+          accessors as unknown as {
+            _deleteFileFromDisk: (_path: string) => Promise<Result<void>>;
+          }
+        )._deleteFileFromDisk = async () => {
+          throw new Error('simulated delete throw');
+        };
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
-          mutable: true,
-          requireWritePermission: false
-        })
-      ).orThrow();
+        accessors.deleteFile('/test.txt').orThrow();
+        await new Promise<void>((resolve) => setTimeout(resolve, 0));
 
-      const result = accessors.fileIsMutable('/test.txt');
-      expect(result).toSucceedWithDetail(true, 'transient');
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('simulated delete throw'));
+      });
     });
 
-    test('returns not-mutable when mutability disabled', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'test.txt': { content: 'test', type: 'text/plain' }
+    describe('fileIsMutable', () => {
+      test('returns persistent detail when write permission granted', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'test', type: 'text/plain' }
+        });
+
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
+
+        const result = accessors.fileIsMutable('/test.txt');
+        expect(result).toSucceedWithDetail(true, 'persistent');
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: false })
-      ).orThrow();
+      test('returns transient detail when write permission not granted', async () => {
+        const dirHandle = createMockDirectoryHandle(
+          '/',
+          { 'test.txt': { content: 'test', type: 'text/plain' } },
+          { hasWritePermission: false }
+        );
 
-      const result = accessors.fileIsMutable('/test.txt');
-      expect(result).toFailWithDetail(/mutability is disabled/i, 'not-mutable');
-    });
-  });
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+            mutable: true,
+            requireWritePermission: false
+          })
+        ).orThrow();
 
-  describe('integration with FileApiTreeAccessors', () => {
-    test('createPersistent creates FileTree with persistent accessors', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'test.txt': { content: 'test content', type: 'text/plain' }
+        const result = accessors.fileIsMutable('/test.txt');
+        expect(result).toSucceedWithDetail(true, 'transient');
       });
 
-      const result = await FileApiTreeAccessors.createPersistent(dirHandle, { mutable: true });
-      expect(result).toSucceed();
+      test('returns not-mutable when mutability disabled', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'test', type: 'text/plain' }
+        });
 
-      const tree = result.orThrow();
-      expect(tree).toBeInstanceOf(FileTree.FileTree);
-      expect(FileTree.isPersistentAccessors(tree.hal)).toBe(true);
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: false })
+        ).orThrow();
 
-      const file = tree.getFile('/test.txt').orThrow();
-      expect(file.getIsMutable()).toSucceedWithDetail(true, 'persistent');
+        const result = accessors.fileIsMutable('/test.txt');
+        expect(result).toFailWithDetail(/mutability is disabled/i, 'not-mutable');
+      });
     });
 
-    test('createPersistent with autoSync option', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'test.txt': { content: 'original', type: 'text/plain' }
-      });
+    describe('integration with FileApiTreeAccessors', () => {
+      test('createPersistent creates FileTree with persistent accessors', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'test content', type: 'text/plain' }
+        });
 
-      const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
-        mutable: true,
-        autoSync: true
-      });
+        const result = await FileApiTreeAccessors.createPersistent(dirHandle, { mutable: true });
+        expect(result).toSucceed();
 
-      expect(result).toSucceedAndSatisfy((tree) => {
+        const tree = result.orThrow();
         expect(tree).toBeInstanceOf(FileTree.FileTree);
+        expect(FileTree.isPersistentAccessors(tree.hal)).toBe(true);
+
+        const file = tree.getFile('/test.txt').orThrow();
+        expect(FileTree.isMutableFileItem(file)).toBe(true);
+        if (FileTree.isMutableFileItem(file)) {
+          expect(file.getIsMutable()).toSucceedWithDetail(true, 'persistent');
+        }
       });
 
-      const tree = result.orThrow();
-      const file = tree.getFile('/test.txt').orThrow();
-      file.setRawContents('modified').orThrow();
+      test('createPersistent with autoSync option', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'original', type: 'text/plain' }
+        });
 
-      // Give auto-sync time to complete
-      await new Promise((resolve) => setTimeout(resolve, 10));
+        const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
+          mutable: true,
+          autoSync: true
+        });
 
-      // Verify file was written
-      const fileHandle = await dirHandle.getFileHandle('test.txt');
-      const diskFile = await fileHandle.getFile();
-      const content = await diskFile.text();
-      expect(content).toBe('modified');
-    });
+        expect(result).toSucceedAndSatisfy((tree) => {
+          expect(tree).toBeInstanceOf(FileTree.FileTree);
+        });
 
-    test('createPersistent fails with appropriate error', async () => {
-      const dirHandle = createMockDirectoryHandle(
-        '/',
-        { 'test.txt': { content: 'test', type: 'text/plain' } },
-        { hasWritePermission: false }
-      );
+        const tree = result.orThrow();
+        const file = tree.getFile('/test.txt').orThrow();
+        expect(FileTree.isMutableFileItem(file)).toBe(true);
+        if (FileTree.isMutableFileItem(file)) {
+          file.setRawContents('modified').orThrow();
+        }
 
-      const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
-        requireWritePermission: true
+        // Give auto-sync time to complete
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
+        // Verify file was written
+        const fileHandle = await dirHandle.getFileHandle('test.txt');
+        const diskFile = await fileHandle.getFile();
+        const content = await diskFile.text();
+        expect(content).toBe('modified');
       });
-      expect(result).toFailWith(/write permission required/i);
-    });
-  });
 
-  describe('error handling', () => {
-    test('handles permission query errors gracefully', async () => {
-      const dirHandle = createMockDirectoryHandle(
-        '/',
-        { 'test.txt': { content: 'test', type: 'text/plain' } },
-        { permissionError: true }
-      );
+      test('createPersistent fails with appropriate error', async () => {
+        const dirHandle = createMockDirectoryHandle(
+          '/',
+          { 'test.txt': { content: 'test', type: 'text/plain' } },
+          { hasWritePermission: false }
+        );
 
-      const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
-        requireWritePermission: false
+        const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
+          requireWritePermission: true
+        });
+        expect(result).toFailWith(/write permission required/i);
       });
-      // Should succeed but without write permission due to error
-      expect(result).toSucceed();
     });
 
-    test('handles permission status "prompt" by requesting permission', async () => {
-      const dirHandle = createMockDirectoryHandle(
-        '/',
-        { 'test.txt': { content: 'test', type: 'text/plain' } },
-        { permissionStatus: 'prompt', requestGranted: true }
-      );
+    describe('error handling', () => {
+      test('handles permission query errors gracefully', async () => {
+        const dirHandle = createMockDirectoryHandle(
+          '/',
+          { 'test.txt': { content: 'test', type: 'text/plain' } },
+          { permissionError: true }
+        );
 
-      const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
-        requireWritePermission: true
+        const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+          requireWritePermission: false
+        });
+        // Should succeed but without write permission due to error
+        expect(result).toSucceed();
       });
-      expect(result).toSucceedAndSatisfy((accessors) => {
-        expect(accessors).toBeInstanceOf(FileSystemAccessTreeAccessors);
+
+      test('handles permission status "prompt" by requesting permission', async () => {
+        const dirHandle = createMockDirectoryHandle(
+          '/',
+          { 'test.txt': { content: 'test', type: 'text/plain' } },
+          { permissionStatus: 'prompt', requestGranted: true }
+        );
+
+        const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+          requireWritePermission: true
+        });
+        expect(result).toSucceedAndSatisfy((accessors) => {
+          expect(accessors).toBeInstanceOf(FileSystemAccessTreeAccessors);
+        });
       });
-    });
 
-    test('handles sync failures with aggregated errors', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'file1.txt': { content: 'content1', type: 'text/plain' },
-        'file2.txt': { content: 'content2', type: 'text/plain' }
+      test('handles sync failures with aggregated errors', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'file1.txt': { content: 'content1', type: 'text/plain' },
+          'file2.txt': { content: 'content2', type: 'text/plain' }
+        });
+
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
+
+        // Modify files
+        accessors.saveFileContents('/file1.txt', 'modified1').orThrow();
+        accessors.saveFileContents('/file2.txt', 'modified2').orThrow();
+
+        // Replace the file handles with ones that fail to write
+        const handles = (accessors as any)._handles as Map<string, any>;
+        for (const [, handle] of handles) {
+          handle.createWritable = jest.fn().mockRejectedValue(new Error('Write permission denied'));
+        }
+
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toFailWith(/Failed to sync 2 file\(s\)/i);
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
-      ).orThrow();
+      test('handles getFileContents failure during sync', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'original', type: 'text/plain' }
+        });
 
-      // Modify files
-      accessors.saveFileContents('/file1.txt', 'modified1').orThrow();
-      accessors.saveFileContents('/file2.txt', 'modified2').orThrow();
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
 
-      // Replace the file handles with ones that fail to write
-      const handles = (accessors as any)._handles as Map<string, any>;
-      for (const [, handle] of handles) {
-        handle.createWritable = jest.fn().mockRejectedValue(new Error('Write permission denied'));
-      }
+        // Add a new file
+        accessors.saveFileContents('/newfile.txt', 'new content').orThrow();
 
-      const syncResult = await accessors.syncToDisk();
-      expect(syncResult).toFailWith(/Failed to sync 2 file\(s\)/i);
-    });
+        // Override getFileContents to fail
+        const originalGetFileContents = accessors.getFileContents.bind(accessors);
+        accessors.getFileContents = jest.fn((path: string) => {
+          if (path === '/newfile.txt') {
+            return { isSuccess: () => false, isFailure: () => true, message: 'File read error' } as any;
+          }
+          return originalGetFileContents(path);
+        });
 
-    test('handles getFileContents failure during sync', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'test.txt': { content: 'original', type: 'text/plain' }
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toFailWith(/File read error/i);
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
-      ).orThrow();
+      test('handles file write failure during sync', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'test.txt': { content: 'original', type: 'text/plain' }
+        });
 
-      // Add a new file
-      accessors.saveFileContents('/newfile.txt', 'new content').orThrow();
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
 
-      // Override getFileContents to fail
-      const originalGetFileContents = accessors.getFileContents.bind(accessors);
-      accessors.getFileContents = jest.fn((path: string) => {
-        if (path === '/newfile.txt') {
-          return { isSuccess: () => false, isFailure: () => true, message: 'File read error' } as any;
-        }
-        return originalGetFileContents(path);
+        accessors.saveFileContents('/test.txt', 'modified').orThrow();
+
+        // Replace the handle with one that fails to write
+        const handles = (accessors as any)._handles as Map<string, any>;
+        const handle = handles.get('/test.txt');
+        handle.createWritable = jest.fn().mockRejectedValue(new Error('Disk full'));
+
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toFailWith(/Failed to write file.*Disk full/i);
       });
 
-      const syncResult = await accessors.syncToDisk();
-      expect(syncResult).toFailWith(/File read error/i);
-    });
+      test('handles invalid file path with no filename', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'existing.txt': { content: 'existing', type: 'text/plain' }
+        });
 
-    test('handles file write failure during sync', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'test.txt': { content: 'original', type: 'text/plain' }
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
+
+        // Override resolveAbsolutePath to return an empty path to trigger the error
+        const originalResolveAbsolutePath = (accessors as any).resolveAbsolutePath.bind(accessors);
+        (accessors as any).resolveAbsolutePath = jest.fn((path: string) => {
+          if (path === '/badpath') {
+            return ''; // This will result in no parts after split
+          }
+          return originalResolveAbsolutePath(path);
+        });
+
+        // Create a new file with the bad path - don't throw if it fails
+        const saveResult = accessors.saveFileContents('/badpath', 'content');
+        if (saveResult.isFailure()) {
+          // saveFileContents itself might reject the path
+          expect(saveResult).toFailWith(/invalid file path/i);
+        } else {
+          // If save succeeded, sync should fail
+          const syncResult = await accessors.syncToDisk();
+          expect(syncResult).toFailWith(/Invalid file path/i);
+        }
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
-      ).orThrow();
+      test('handles file creation failure in _createAndWriteFile', async () => {
+        const dirHandle = createMockDirectoryHandle('/', {
+          'existing.txt': { content: 'existing', type: 'text/plain' }
+        });
 
-      accessors.saveFileContents('/test.txt', 'modified').orThrow();
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
 
-      // Replace the handle with one that fails to write
-      const handles = (accessors as any)._handles as Map<string, any>;
-      const handle = handles.get('/test.txt');
-      handle.createWritable = jest.fn().mockRejectedValue(new Error('Disk full'));
+        // Add a new file that will need to be created
+        accessors.saveFileContents('/newdir/newfile.txt', 'new content').orThrow();
 
-      const syncResult = await accessors.syncToDisk();
-      expect(syncResult).toFailWith(/Failed to write file.*Disk full/i);
-    });
+        // Mock getDirectoryHandle to fail
+        const rootDir = (accessors as any)._rootDir;
+        rootDir.getDirectoryHandle = jest.fn().mockRejectedValue(new Error('Permission denied'));
 
-    test('handles invalid file path with no filename', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'existing.txt': { content: 'existing', type: 'text/plain' }
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toFailWith(/Failed to create file.*Permission denied/i);
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
-      ).orThrow();
+      test('successfully deletes a root-level file from disk via syncToDisk pending deletions', async () => {
+        // Covers lines 329-333: the pending deletions loop in syncToDisk
+        const dirHandle = createMockDirectoryHandle('/', {
+          'toDelete.txt': { content: 'will be deleted', type: 'text/plain' },
+          'keep.txt': { content: 'stays', type: 'text/plain' }
+        });
 
-      // Override resolveAbsolutePath to return an empty path to trigger the error
-      const originalResolveAbsolutePath = (accessors as any).resolveAbsolutePath.bind(accessors);
-      (accessors as any).resolveAbsolutePath = jest.fn((path: string) => {
-        if (path === '/badpath') {
-          return ''; // This will result in no parts after split
-        }
-        return originalResolveAbsolutePath(path);
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
+
+        // Delete the file from in-memory tree
+        accessors.deleteFile('/toDelete.txt').orThrow();
+        expect(accessors.isDirty()).toBe(true);
+        expect(accessors.getDirtyPaths()).toContain('/toDelete.txt');
+
+        // syncToDisk should process the pending deletion
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toSucceed();
+        expect(accessors.isDirty()).toBe(false);
       });
 
-      // Create a new file with the bad path - don't throw if it fails
-      const saveResult = accessors.saveFileContents('/badpath', 'content');
-      if (saveResult.isFailure()) {
-        // saveFileContents itself might reject the path
-        expect(saveResult).toFailWith(/invalid file path/i);
-      } else {
-        // If save succeeded, sync should fail
+      test('successfully deletes a nested file from disk via syncToDisk (navigates parent dirs)', async () => {
+        // Covers lines 468-469: getDirectoryHandle navigation loop in _deleteFileFromDisk
+        const dirHandle = createMockDirectoryHandle('/', {
+          'src/utils/helper.txt': { content: 'to be deleted', type: 'text/plain' },
+          'src/index.txt': { content: 'stays', type: 'text/plain' }
+        });
+
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
+
+        // Delete the nested file
+        accessors.deleteFile('/src/utils/helper.txt').orThrow();
+        expect(accessors.isDirty()).toBe(true);
+
         const syncResult = await accessors.syncToDisk();
-        expect(syncResult).toFailWith(/Invalid file path/i);
-      }
-    });
+        expect(syncResult).toSucceed();
+        expect(accessors.isDirty()).toBe(false);
+      });
 
-    test('handles file creation failure in _createAndWriteFile', async () => {
-      const dirHandle = createMockDirectoryHandle('/', {
-        'existing.txt': { content: 'existing', type: 'text/plain' }
+      test('aggregates deletion errors when _deleteFileFromDisk fails during syncToDisk', async () => {
+        // Covers lines 330-332: the error aggregation when _deleteFileFromDisk returns failure
+        const dirHandle = createMockDirectoryHandle('/', {
+          'toDelete.txt': { content: 'content', type: 'text/plain' }
+        });
+
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
+
+        accessors.deleteFile('/toDelete.txt').orThrow();
+
+        // Make removeEntry fail to trigger the error path in _deleteFileFromDisk
+        const rootDir = (accessors as any)._rootDir;
+        rootDir.removeEntry = jest.fn().mockRejectedValue(new Error('Cannot delete: file locked'));
+
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toFailWith(/Failed to sync 1 file/i);
+        expect(syncResult).toFailWith(/delete.*toDelete\.txt/i);
       });
 
-      const accessors = (
-        await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
-      ).orThrow();
+      test('catch block in _deleteFileFromDisk when removeEntry throws', async () => {
+        // Covers lines 473-476: the catch block in _deleteFileFromDisk
+        const dirHandle = createMockDirectoryHandle('/', {
+          'target.txt': { content: 'content', type: 'text/plain' }
+        });
+
+        const accessors = (
+          await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })
+        ).orThrow();
 
-      // Add a new file that will need to be created
-      accessors.saveFileContents('/newdir/newfile.txt', 'new content').orThrow();
+        accessors.deleteFile('/target.txt').orThrow();
 
-      // Mock getDirectoryHandle to fail
-      const rootDir = (accessors as any)._rootDir;
-      rootDir.getDirectoryHandle = jest.fn().mockRejectedValue(new Error('Permission denied'));
+        // Directly make _rootDir.removeEntry throw a non-Error value to test the catch branch
+        const rootDir = (accessors as any)._rootDir;
+        rootDir.removeEntry = jest.fn().mockRejectedValue('non-error string');
 
-      const syncResult = await accessors.syncToDisk();
-      expect(syncResult).toFailWith(/Failed to create file.*Permission denied/i);
+        const syncResult = await accessors.syncToDisk();
+        expect(syncResult).toFailWith(/Failed to delete file.*non-error string/i);
+      });
     });
   });
 });