Directly write files rather than caching them locally for disk image restore.

proprietary/DiskImage/Filesystem/Interfaces.cs

@@ -45,6 +45,16 @@ public interface IFilesystem : IDisposable
     IAsyncEnumerable<IFile> ListFilesAsync(IFile directory, CancellationToken cancellationToken);
 
     Task<Stream> OpenFileAsync(IFile file, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Opens a file for writing. Creates the file if it doesn't exist.
+    /// </summary>
+    /// <param name="file">The file to write to. If null, a new file will be created at the specified address.</param>
+    /// <param name="address">The address/offset to write to.</param>
+    /// <param name="size">The expected size of the file.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A stream for writing to the file.</returns>
+    Task<Stream> CreateFileAsync(IFile? file, long address, long size, CancellationToken cancellationToken);
 }
 
 public interface IFile

proprietary/DiskImage/Filesystem/Unknown.cs

@@ -5,6 +5,7 @@ using System.IO;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Duplicati.Proprietary.DiskImage.Disk;
 using Duplicati.Proprietary.DiskImage.Partition;
 
 namespace Duplicati.Proprietary.DiskImage.Filesystem;
@@ -103,4 +104,70 @@ public class UnknownFilesystem : IFilesystem
         await partitionStream.ReadExactlyAsync(buffer, 0, buffer.Length, cancellationToken);
         return new MemoryStream(buffer);
     }
+
+    public Task<Stream> CreateFileAsync(IFile? file, long address, long size, CancellationToken cancellationToken)
+    {
+        if (m_partition.PartitionTable.RawDisk == null)
+            throw new InvalidOperationException("Cannot write to partition without a raw disk.");
+
+        // Create a stream that writes directly to the partition at the specified address
+        var writeStream = new UnknownFilesystemWriteStream(m_partition.PartitionTable.RawDisk, address, size);
+        return Task.FromResult<Stream>(writeStream);
+    }
+
+    /// <summary>
+    /// A stream that writes data directly to a specific address on the raw disk.
+    /// </summary>
+    private class UnknownFilesystemWriteStream : Stream
+    {
+        private readonly IRawDisk _disk;
+        private readonly long _startAddress;
+        private readonly long _expectedSize;
+        private readonly MemoryStream _buffer;
+        private bool _disposed = false;
+
+        public UnknownFilesystemWriteStream(IRawDisk disk, long startAddress, long expectedSize)
+        {
+            _disk = disk;
+            _startAddress = startAddress;
+            _expectedSize = expectedSize;
+            _buffer = new MemoryStream();
+        }
+
+        public override bool CanRead => false;
+        public override bool CanSeek => true;
+        public override bool CanWrite => true;
+        public override long Length => _buffer.Length;
+        public override long Position
+        {
+            get => _buffer.Position;
+            set => _buffer.Position = value;
+        }
+
+        public override void Flush() => _buffer.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => _buffer.Seek(offset, origin);
+        public override void SetLength(long value) => _buffer.SetLength(value);
+        public override void Write(byte[] buffer, int offset, int count) => _buffer.Write(buffer, offset, count);
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    // Write all buffered data to disk
+                    _buffer.Position = 0;
+                    var data = _buffer.ToArray();
+                    if (data.Length > 0)
+                    {
+                        _disk.WriteBytesAsync(_startAddress, data, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                    _buffer.Dispose();
+                }
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
+    }
 }

proprietary/DiskImage/Partition/GPT.cs

@@ -604,9 +604,83 @@ public class GPT : IPartitionTable
             return RawDisk.ReadBytesAsync(StartOffset, (int)Math.Min(Size, int.MaxValue), cancellationToken);
         }
 
+        public Task<Stream> OpenWriteAsync(CancellationToken cancellationToken)
+        {
+            if (RawDisk == null)
+                throw new InvalidOperationException("RawDisk not available.");
+            // Return a stream that wraps the raw disk write capability
+            return Task.FromResult<Stream>(new PartitionWriteStream(RawDisk, StartOffset, Size));
+        }
+
         public void Dispose()
         {
             // No unmanaged resources to dispose
         }
     }
+
+    /// <summary>
+    /// A stream that writes data to a partition on the raw disk.
+    /// </summary>
+    private class PartitionWriteStream : Stream
+    {
+        private readonly IRawDisk _disk;
+        private readonly long _startOffset;
+        private readonly long _maxSize;
+        private readonly MemoryStream _buffer;
+        private bool _disposed = false;
+
+        public PartitionWriteStream(IRawDisk disk, long startOffset, long maxSize)
+        {
+            _disk = disk;
+            _startOffset = startOffset;
+            _maxSize = maxSize;
+            _buffer = new MemoryStream();
+        }
+
+        public override bool CanRead => false;
+        public override bool CanSeek => true;
+        public override bool CanWrite => true;
+        public override long Length => _buffer.Length;
+        public override long Position
+        {
+            get => _buffer.Position;
+            set => _buffer.Position = value;
+        }
+
+        public override void Flush() => _buffer.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => _buffer.Seek(offset, origin);
+        public override void SetLength(long value)
+        {
+            if (value > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.SetLength(value);
+        }
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_buffer.Position + count > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.Write(buffer, offset, count);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    // Write all buffered data to disk
+                    _buffer.Position = 0;
+                    var data = _buffer.ToArray();
+                    if (data.Length > 0)
+                    {
+                        _disk.WriteBytesAsync(_startOffset, data, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                    _buffer.Dispose();
+                }
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
+    }
 }

proprietary/DiskImage/Partition/Interfaces.cs

@@ -58,6 +58,13 @@ public interface IPartition : IDisposable
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>Stream for reading partition data.</returns>
     Task<Stream> OpenReadAsync(CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Creates a stream to write the raw partition data.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Stream for writing partition data.</returns>
+    Task<Stream> OpenWriteAsync(CancellationToken cancellationToken);
 }
 
 /// <summary>

proprietary/DiskImage/Partition/MBR.cs

@@ -322,9 +322,83 @@ public class MBR : IPartitionTable
             return RawDisk.ReadBytesAsync(StartOffset, (int)Math.Min(Size, int.MaxValue), cancellationToken);
         }
 
+        public Task<Stream> OpenWriteAsync(CancellationToken cancellationToken)
+        {
+            if (RawDisk == null)
+                throw new InvalidOperationException("RawDisk not available.");
+            // Return a stream that wraps the raw disk write capability
+            return Task.FromResult<Stream>(new PartitionWriteStream(RawDisk, StartOffset, Size));
+        }
+
         public void Dispose()
         {
             // No unmanaged resources to dispose
         }
     }
+
+    /// <summary>
+    /// A stream that writes data to a partition on the raw disk.
+    /// </summary>
+    private class PartitionWriteStream : Stream
+    {
+        private readonly IRawDisk _disk;
+        private readonly long _startOffset;
+        private readonly long _maxSize;
+        private readonly MemoryStream _buffer;
+        private bool _disposed = false;
+
+        public PartitionWriteStream(IRawDisk disk, long startOffset, long maxSize)
+        {
+            _disk = disk;
+            _startOffset = startOffset;
+            _maxSize = maxSize;
+            _buffer = new MemoryStream();
+        }
+
+        public override bool CanRead => false;
+        public override bool CanSeek => true;
+        public override bool CanWrite => true;
+        public override long Length => _buffer.Length;
+        public override long Position
+        {
+            get => _buffer.Position;
+            set => _buffer.Position = value;
+        }
+
+        public override void Flush() => _buffer.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => _buffer.Seek(offset, origin);
+        public override void SetLength(long value)
+        {
+            if (value > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.SetLength(value);
+        }
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_buffer.Position + count > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.Write(buffer, offset, count);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    // Write all buffered data to disk
+                    _buffer.Position = 0;
+                    var data = _buffer.ToArray();
+                    if (data.Length > 0)
+                    {
+                        _disk.WriteBytesAsync(_startOffset, data, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                    _buffer.Dispose();
+                }
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
+    }
 }

proprietary/DiskImage/Partition/Unknown.cs

@@ -32,10 +32,83 @@ public class UnknownPartition : IPartition
         return await PartitionTable.RawDisk.ReadBytesAsync(StartOffset, (int)Size, cancellationToken).ConfigureAwait(false);
     }
 
+    public Task<Stream> OpenWriteAsync(CancellationToken cancellationToken)
+    {
+        if (PartitionTable.RawDisk == null)
+            throw new InvalidOperationException("No raw disk available for writing partition data.");
+        return Task.FromResult<Stream>(new PartitionWriteStream(PartitionTable.RawDisk, StartOffset, Size));
+    }
+
     public void Dispose()
     {
         // Nothing to dispose here
     }
+
+    /// <summary>
+    /// A stream that writes data to a partition on the raw disk.
+    /// </summary>
+    private class PartitionWriteStream : Stream
+    {
+        private readonly IRawDisk _disk;
+        private readonly long _startOffset;
+        private readonly long _maxSize;
+        private readonly MemoryStream _buffer;
+        private bool _disposed = false;
+
+        public PartitionWriteStream(IRawDisk disk, long startOffset, long maxSize)
+        {
+            _disk = disk;
+            _startOffset = startOffset;
+            _maxSize = maxSize;
+            _buffer = new MemoryStream();
+        }
+
+        public override bool CanRead => false;
+        public override bool CanSeek => true;
+        public override bool CanWrite => true;
+        public override long Length => _buffer.Length;
+        public override long Position
+        {
+            get => _buffer.Position;
+            set => _buffer.Position = value;
+        }
+
+        public override void Flush() => _buffer.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => _buffer.Seek(offset, origin);
+        public override void SetLength(long value)
+        {
+            if (value > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.SetLength(value);
+        }
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_buffer.Position + count > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.Write(buffer, offset, count);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    // Write all buffered data to disk
+                    _buffer.Position = 0;
+                    var data = _buffer.ToArray();
+                    if (data.Length > 0)
+                    {
+                        _disk.WriteBytesAsync(_startOffset, data, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                    _buffer.Dispose();
+                }
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
+    }
 }
 
 public class UnknownPartitionTable : IPartitionTable

proprietary/DiskImage/RestoreProvider.cs

@@ -5,6 +5,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Duplicati.Library.Common.IO;
@@ -12,6 +13,7 @@ using Duplicati.Library.Interface;
 using Duplicati.Library.Logging;
 using Duplicati.Library.Utility;
 using Duplicati.Proprietary.DiskImage.Disk;
+using Duplicati.Proprietary.DiskImage.Filesystem;
 using Duplicati.Proprietary.DiskImage.Partition;
 
 namespace Duplicati.Proprietary.DiskImage;
@@ -27,6 +29,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
     private readonly string _restorePath;
     private readonly bool _skipPartitionTable;
     private readonly bool _validateSize;
+    private readonly bool _hasSetOverwriteOption;
     private IRawDisk? _targetDisk;
     private bool _disposed;
 
@@ -36,9 +39,88 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
     private readonly ConcurrentDictionary<string, Dictionary<string, string?>> _metadata = new();
 
     /// <summary>
-    /// Temporary files created during the restore process, keyed by path.
+    /// Tracks pending writes for items that need to be written during Finalize.
+    /// For partition table items, this stores the data to be written.
     /// </summary>
-    private readonly ConcurrentDictionary<string, TempFile> _temporaryFiles = new();
+    private readonly ConcurrentDictionary<string, PendingWrite> _pendingWrites = new();
+
+    /// <summary>
+    /// Cache of instantiated partitions keyed by partition number.
+    /// </summary>
+    private readonly ConcurrentDictionary<int, IPartition> _partitionCache = new();
+
+    /// <summary>
+    /// Cache of instantiated filesystems keyed by partition number.
+    /// </summary>
+    private readonly ConcurrentDictionary<int, IFilesystem> _filesystemCache = new();
+
+    /// <summary>
+    /// Represents a pending write operation.
+    /// </summary>
+    private abstract class PendingWrite : IDisposable
+    {
+        public abstract void Dispose();
+    }
+
+    /// <summary>
+    /// Pending write for partition table data (stored in memory until Finalize).
+    /// </summary>
+    private class PartitionTablePendingWrite : PendingWrite
+    {
+        public byte[] Data { get; }
+
+        public PartitionTablePendingWrite(byte[] data)
+        {
+            Data = data;
+        }
+
+        public override void Dispose()
+        {
+            // Nothing to dispose
+        }
+    }
+
+    /// <summary>
+    /// Pending write for disk-level data (stored in memory until Finalize).
+    /// </summary>
+    private class DiskPendingWrite : PendingWrite
+    {
+        public byte[] Data { get; }
+        public long SourceSize { get; }
+
+        public DiskPendingWrite(byte[] data, long sourceSize)
+        {
+            Data = data;
+            SourceSize = sourceSize;
+        }
+
+        public override void Dispose()
+        {
+            // Nothing to dispose
+        }
+    }
+
+    /// <summary>
+    /// Pending write for partition data (stored in memory until Finalize).
+    /// </summary>
+    private class PartitionPendingWrite : PendingWrite
+    {
+        public byte[] Data { get; }
+        public long Offset { get; }
+        public int PartitionNumber { get; }
+
+        public PartitionPendingWrite(byte[] data, long offset, int partitionNumber)
+        {
+            Data = data;
+            Offset = offset;
+            PartitionNumber = partitionNumber;
+        }
+
+        public override void Dispose()
+        {
+            // Nothing to dispose
+        }
+    }
 
     /// <summary>
     /// Default constructor for the restore provider.
@@ -50,6 +132,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
         _restorePath = null!;
         _skipPartitionTable = false;
         _validateSize = true;
+        _hasSetOverwriteOption = false;
     }
 
     /// <summary>
@@ -65,6 +148,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
 
         _skipPartitionTable = Utility.ParseBoolOption(options, OptionsHelper.DISK_RESTORE_SKIP_PARTITION_TABLE_OPTION);
         _validateSize = Utility.ParseBoolOption(options, OptionsHelper.DISK_RESTORE_VALIDATE_SIZE_OPTION);
+        _hasSetOverwriteOption = Utility.ParseBoolOption(options, "overwrite");
     }
 
     /// <inheritdoc />
@@ -131,7 +215,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
     {
         path = NormalizePath(path);
 
-        if (_temporaryFiles.ContainsKey(path))
+        if (_pendingWrites.ContainsKey(path))
             return Task.FromResult(true);
 
         return Task.FromResult(false);
@@ -142,28 +226,345 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
     {
         path = NormalizePath(path);
 
-        var file = _temporaryFiles.GetOrAdd(path, _ => new TempFile());
-        return Task.FromResult<Stream>(SystemIO.IO_OS.FileOpenWrite(file));
+        // Get metadata for this path to determine the write strategy
+        if (!_metadata.TryGetValue(path, out var metadata))
+        {
+            throw new InvalidOperationException($"No metadata found for path: {path}. WriteMetadata must be called before OpenWrite.");
+        }
+
+        // Determine the item type
+        metadata.TryGetValue("diskimage:Type", out var typeStr);
+
+        return typeStr switch
+        {
+            "partition_table" => OpenWritePartitionTable(path, metadata, cancel),
+            "disk" => OpenWriteDisk(path, metadata, cancel),
+            "partition" => OpenWritePartition(path, metadata, cancel),
+            "block" or "file" => OpenWriteThroughFilesystem(path, metadata, cancel),
+            _ => throw new NotSupportedException($"Unsupported item type: {typeStr}")
+        };
+    }
+
+    /// <summary>
+    /// Opens a stream for writing partition table data (stored in memory until Finalize).
+    /// </summary>
+    private Task<Stream> OpenWritePartitionTable(string path, Dictionary<string, string?> metadata, CancellationToken cancel)
+    {
+        // For partition tables, we need to buffer the data and write it during Finalize
+        // because we need to validate and potentially modify the partition table
+        var stream = new MemoryStream();
+
+        // Wrap the stream to capture the data when it's closed
+        var wrapper = new CaptureStream(stream, data =>
+        {
+            var pendingWrite = new PartitionTablePendingWrite(data);
+            _pendingWrites.AddOrUpdate(path, pendingWrite, (_, old) =>
+            {
+                old.Dispose();
+                return pendingWrite;
+            });
+        });
+
+        return Task.FromResult<Stream>(wrapper);
+    }
+
+    /// <summary>
+    /// Opens a stream for writing disk-level data (stored in memory until Finalize).
+    /// </summary>
+    private Task<Stream> OpenWriteDisk(string path, Dictionary<string, string?> metadata, CancellationToken cancel)
+    {
+        metadata.TryGetValue("disk:Size", out var sourceSizeStr);
+        long.TryParse(sourceSizeStr, out var sourceSize);
+
+        var stream = new MemoryStream();
+
+        var wrapper = new CaptureStream(stream, data =>
+        {
+            var pendingWrite = new DiskPendingWrite(data, sourceSize);
+            _pendingWrites.AddOrUpdate(path, pendingWrite, (_, old) =>
+            {
+                old.Dispose();
+                return pendingWrite;
+            });
+        });
+
+        return Task.FromResult<Stream>(wrapper);
+    }
+
+    /// <summary>
+    /// Opens a stream for writing partition data (stored in memory until Finalize).
+    /// </summary>
+    private Task<Stream> OpenWritePartition(string path, Dictionary<string, string?> metadata, CancellationToken cancel)
+    {
+        metadata.TryGetValue("partition:StartOffset", out var offsetStr);
+        if (!long.TryParse(offsetStr, out var offset))
+        {
+            // Fallback to old key format for backward compatibility
+            metadata.TryGetValue("partition_offset", out offsetStr);
+            long.TryParse(offsetStr, out offset);
+        }
+
+        metadata.TryGetValue("partition:Number", out var partitionNumberStr);
+        int.TryParse(partitionNumberStr, out var partitionNumber);
+
+        var stream = new MemoryStream();
+
+        var wrapper = new CaptureStream(stream, data =>
+        {
+            var pendingWrite = new PartitionPendingWrite(data, offset, partitionNumber);
+            _pendingWrites.AddOrUpdate(path, pendingWrite, (_, old) =>
+            {
+                old.Dispose();
+                return pendingWrite;
+            });
+        });
+
+        return Task.FromResult<Stream>(wrapper);
+    }
+
+    /// <summary>
+    /// Opens a stream for writing through the filesystem layer.
+    /// This instantiates the appropriate filesystem type from metadata and writes through it.
+    /// </summary>
+    private async Task<Stream> OpenWriteThroughFilesystem(string path, Dictionary<string, string?> metadata, CancellationToken cancel)
+    {
+        // Parse metadata to get partition and filesystem information
+        metadata.TryGetValue("filesystem:PartitionNumber", out var partitionNumberStr);
+        metadata.TryGetValue("filesystem:PartitionStartOffset", out var partitionOffsetStr);
+        metadata.TryGetValue("filesystem:Type", out var filesystemTypeStr);
+        metadata.TryGetValue("filesystem:BlockSize", out var blockSizeStr);
+        metadata.TryGetValue("block:Address", out var addressStr);
+        metadata.TryGetValue("file:Size", out var sizeStr);
+
+        // Fallback to old key format for address
+        if (string.IsNullOrEmpty(addressStr))
+            metadata.TryGetValue("block_address", out addressStr);
+
+        // Parse values
+        int partitionNumber = int.TryParse(partitionNumberStr, out var pn) ? pn : 1;
+        long partitionStartOffset = long.TryParse(partitionOffsetStr, out var pso) ? pso : 0;
+        long address = long.TryParse(addressStr, out var addr) ? addr : 0;
+        long size = long.TryParse(sizeStr, out var sz) ? sz : 0;
+        int blockSize = int.TryParse(blockSizeStr, out var bs) ? bs : 1024 * 1024; // Default 1MB blocks
+
+        Enum.TryParse<FileSystemType>(filesystemTypeStr, out var filesystemType);
+
+        // Get or create the partition instance
+        var partition = await GetOrCreatePartitionAsync(partitionNumber, partitionStartOffset, cancel);
+
+        // Get or create the filesystem instance
+        var filesystem = await GetOrCreateFilesystemAsync(partitionNumber, partition, filesystemType, blockSize, cancel);
+
+        // Create a file reference for writing
+        var file = new UnknownFilesystemFile
+        {
+            Address = address,
+            Size = size
+        };
+
+        // Open write stream through the filesystem
+        return await filesystem.CreateFileAsync(file, address, size, cancel);
+    }
+
+    /// <summary>
+    /// Gets or creates a partition instance for the specified partition number.
+    /// </summary>
+    private Task<IPartition> GetOrCreatePartitionAsync(int partitionNumber, long startOffset, CancellationToken cancel)
+    {
+        return Task.FromResult(_partitionCache.GetOrAdd(partitionNumber, _ =>
+        {
+            if (_targetDisk == null)
+                throw new InvalidOperationException("Target disk not initialized.");
+
+            // Create a minimal partition table wrapper for the target disk
+            var partitionTable = new TargetPartitionTable(_targetDisk);
+
+            // Create a synthetic partition that represents the target partition
+            var partition = new TargetPartition(partitionTable, partitionNumber, startOffset, _targetDisk.Size);
+
+            Log.WriteInformationMessage(LOGTAG, "CreatedPartition",
+                $"Created target partition #{partitionNumber} at offset {startOffset}");
+
+            return partition;
+        }));
+    }
+
+    /// <summary>
+    /// Gets or creates a filesystem instance for the specified partition.
+    /// </summary>
+    private Task<IFilesystem> GetOrCreateFilesystemAsync(int partitionNumber, IPartition partition, FileSystemType filesystemType, int blockSize, CancellationToken cancel)
+    {
+        return Task.FromResult(_filesystemCache.GetOrAdd(partitionNumber, _ =>
+        {
+            // For unknown filesystems (or any filesystem we don't have specific support for),
+            // use the UnknownFilesystem which handles raw block access
+            IFilesystem filesystem = filesystemType switch
+            {
+                _ => new UnknownFilesystem(partition, blockSize)
+            };
+
+            Log.WriteInformationMessage(LOGTAG, "CreatedFilesystem",
+                $"Created {filesystemType} filesystem for partition #{partitionNumber}");
+
+            return filesystem;
+        }));
+    }
+
+    /// <summary>
+    /// A simple partition table implementation for the target disk during restore.
+    /// </summary>
+    private class TargetPartitionTable : IPartitionTable
+    {
+        public IRawDisk? RawDisk { get; }
+        public PartitionTableType TableType => PartitionTableType.Unknown;
+
+        public TargetPartitionTable(IRawDisk rawDisk)
+        {
+            RawDisk = rawDisk;
+        }
+
+        public IAsyncEnumerable<IPartition> EnumeratePartitions(CancellationToken cancellationToken)
+        {
+            return AsyncEnumerable.Empty<IPartition>();
+        }
+
+        public Task<IPartition?> GetPartitionAsync(int partitionNumber, CancellationToken cancellationToken)
+        {
+            return Task.FromResult<IPartition?>(null);
+        }
+
+        public Task<Stream> GetProtectiveMbrAsync(CancellationToken cancellationToken)
+        {
+            throw new NotSupportedException();
+        }
+
+        public Task<Stream> GetPartitionTableDataAsync(CancellationToken cancellationToken)
+        {
+            throw new NotSupportedException();
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+
+    /// <summary>
+    /// A simple partition implementation for the target partition during restore.
+    /// </summary>
+    private class TargetPartition : IPartition
+    {
+        public IPartitionTable PartitionTable { get; }
+        public int PartitionNumber { get; }
+        public PartitionType Type => PartitionType.Primary;
+        public long StartOffset { get; }
+        public long Size { get; }
+        public string? Name => $"Target Partition {PartitionNumber}";
+        public FileSystemType FilesystemType => FileSystemType.Unknown;
+        public Guid? VolumeGuid => null;
+
+        public TargetPartition(IPartitionTable partitionTable, int partitionNumber, long startOffset, long size)
+        {
+            PartitionTable = partitionTable;
+            PartitionNumber = partitionNumber;
+            StartOffset = startOffset;
+            Size = size;
+        }
+
+        public Task<Stream> OpenReadAsync(CancellationToken cancellationToken)
+        {
+            if (PartitionTable.RawDisk == null)
+                throw new InvalidOperationException("Raw disk not available.");
+            return PartitionTable.RawDisk.ReadBytesAsync(StartOffset, (int)Math.Min(Size, int.MaxValue), cancellationToken);
+        }
+
+        public Task<Stream> OpenWriteAsync(CancellationToken cancellationToken)
+        {
+            if (PartitionTable.RawDisk == null)
+                throw new InvalidOperationException("Raw disk not available.");
+            return Task.FromResult<Stream>(new PartitionWriteStream(PartitionTable.RawDisk, StartOffset, Size));
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+
+    /// <summary>
+    /// A stream that writes data to a partition on the raw disk.
+    /// </summary>
+    private class PartitionWriteStream : Stream
+    {
+        private readonly IRawDisk _disk;
+        private readonly long _startOffset;
+        private readonly long _maxSize;
+        private readonly MemoryStream _buffer;
+        private bool _disposed = false;
+
+        public PartitionWriteStream(IRawDisk disk, long startOffset, long maxSize)
+        {
+            _disk = disk;
+            _startOffset = startOffset;
+            _maxSize = maxSize;
+            _buffer = new MemoryStream();
+        }
+
+        public override bool CanRead => false;
+        public override bool CanSeek => true;
+        public override bool CanWrite => true;
+        public override long Length => _buffer.Length;
+        public override long Position
+        {
+            get => _buffer.Position;
+            set => _buffer.Position = value;
+        }
+
+        public override void Flush() => _buffer.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => _buffer.Seek(offset, origin);
+        public override void SetLength(long value)
+        {
+            if (value > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.SetLength(value);
+        }
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_buffer.Position + count > _maxSize)
+                throw new IOException($"Cannot write beyond partition size of {_maxSize} bytes.");
+            _buffer.Write(buffer, offset, count);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    // Write all buffered data to disk
+                    _buffer.Position = 0;
+                    var data = _buffer.ToArray();
+                    if (data.Length > 0)
+                    {
+                        _disk.WriteBytesAsync(_startOffset, data, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                    _buffer.Dispose();
+                }
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
     }
 
     /// <inheritdoc />
     public Task<Stream> OpenRead(string path, CancellationToken cancel)
     {
-        path = NormalizePath(path);
-
-        if (_temporaryFiles.TryGetValue(path, out var tempFile))
-            return Task.FromResult<Stream>(SystemIO.IO_OS.FileOpenRead(tempFile));
-
-        throw new FileNotFoundException($"File not found: {path}");
+        throw new NotSupportedException("Restore provider does not support reading files.");
     }
 
     /// <inheritdoc />
     public Task<Stream> OpenReadWrite(string path, CancellationToken cancel)
     {
-        path = NormalizePath(path);
-
-        var file = _temporaryFiles.GetOrAdd(path, _ => new TempFile());
-        return Task.FromResult<Stream>(SystemIO.IO_OS.FileOpenReadWrite(file));
+        throw new NotSupportedException("Restore provider does not support read-write operations. Use OpenWrite instead.");
     }
 
     /// <inheritdoc />
@@ -171,8 +572,17 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
     {
         path = NormalizePath(path);
 
-        if (_temporaryFiles.TryGetValue(path, out var tempFile))
-            return Task.FromResult(SystemIO.IO_OS.FileLength(tempFile));
+        if (_pendingWrites.TryGetValue(path, out var pendingWrite))
+        {
+            var length = pendingWrite switch
+            {
+                PartitionTablePendingWrite ptw => ptw.Data.Length,
+                DiskPendingWrite dw => dw.Data.Length,
+                PartitionPendingWrite pw => pw.Data.Length,
+                _ => 0L
+            };
+            return Task.FromResult(length);
+        }
 
         return Task.FromResult(0L);
     }
@@ -249,26 +659,34 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
             progressCallback?.Invoke(processedCount / (double)totalItems);
         }
 
-        // Restore block-level items (raw sectors)
+        // Block and file items have already been written through the filesystem layer during OpenWrite
+        // We just need to verify they were written correctly
         if (blockItems.Count > 0)
         {
-            await RestoreBlockItems(blockItems, cancel);
+            await VerifyBlockItems(blockItems, cancel);
             processedCount += blockItems.Count;
             progressCallback?.Invoke(processedCount / (double)totalItems);
         }
 
-        // Restore file-level items (filesystem files)
         if (fileItems.Count > 0)
         {
-            await RestoreFileItems(fileItems, cancel);
+            await VerifyFileItems(fileItems, cancel);
             processedCount += fileItems.Count;
             progressCallback?.Invoke(processedCount / (double)totalItems);
         }
 
-        // Cleanup temporary files
-        foreach (var tempFile in _temporaryFiles.Values)
-            tempFile.Dispose();
-        _temporaryFiles.Clear();
+        // Cleanup
+        foreach (var filesystem in _filesystemCache.Values)
+            filesystem.Dispose();
+        _filesystemCache.Clear();
+
+        foreach (var partition in _partitionCache.Values)
+            partition.Dispose();
+        _partitionCache.Clear();
+
+        foreach (var pendingWrite in _pendingWrites.Values)
+            pendingWrite.Dispose();
+        _pendingWrites.Clear();
         _metadata.Clear();
 
         Log.WriteInformationMessage(LOGTAG, "RestoreComplete", "Restore operation completed.");
@@ -287,7 +705,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
             var path = item.Key;
             var metadata = item.Value;
 
-            if (!_temporaryFiles.TryGetValue(path, out var tempFile))
+            if (!_pendingWrites.TryGetValue(path, out var pendingWrite) || pendingWrite is not PartitionTablePendingWrite ptw)
                 continue;
 
             try
@@ -300,18 +718,10 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
                 Log.WriteInformationMessage(LOGTAG, "RestorePartitionTableMetadata",
                     $"Restoring partition table (Type: {tableType}, Size: {tableSizeStr}, SectorSize: {sectorSizeStr})");
 
-                // Read the data from temp file
-                byte[] data;
-                using (var stream = SystemIO.IO_OS.FileOpenRead(tempFile))
-                {
-                    data = new byte[stream.Length];
-                    await stream.ReadExactlyAsync(data, cancel);
-                }
-
                 // Write partition table to disk starting at offset 0
                 // For MBR: this is the 512-byte MBR sector
                 // For GPT: this includes protective MBR + GPT header + partition entries
-                await _targetDisk!.WriteBytesAsync(0, data, cancel);
+                await _targetDisk!.WriteBytesAsync(0, ptw.Data, cancel);
 
                 Log.WriteInformationMessage(LOGTAG, "RestorePartitionTable", $"Restored partition table: {path} (Type: {tableType})");
             }
@@ -336,7 +746,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
             var path = item.Key;
             var metadata = item.Value;
 
-            if (!_temporaryFiles.TryGetValue(path, out var tempFile))
+            if (!_pendingWrites.TryGetValue(path, out var pendingWrite) || pendingWrite is not DiskPendingWrite dw)
                 continue;
 
             try
@@ -352,25 +762,17 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
                     $"Restoring disk from {sourceDevicePath} (Size: {sourceSizeStr}, SectorSize: {sectorSizeStr}, Table: {partitionTableType}, Sectors: {sectorsStr})");
 
                 // Validate size if source metadata is available
-                if (_validateSize && long.TryParse(sourceSizeStr, out var sourceSize))
+                if (_validateSize && dw.SourceSize > 0)
                 {
-                    if (_targetDisk!.Size < sourceSize)
+                    if (_targetDisk!.Size < dw.SourceSize)
                     {
                         throw new InvalidOperationException(
-                            string.Format(Strings.RestoreTargetTooSmall, _targetDisk.Size, sourceSize));
+                            string.Format(Strings.RestoreTargetTooSmall, _targetDisk.Size, dw.SourceSize));
                     }
                 }
 
-                // Read the data from temp file
-                byte[] data;
-                using (var stream = SystemIO.IO_OS.FileOpenRead(tempFile))
-                {
-                    data = new byte[stream.Length];
-                    await stream.ReadExactlyAsync(data, cancel);
-                }
-
                 // Write to disk (offset 0 for partition table/boot sector)
-                await _targetDisk!.WriteBytesAsync(0, data, cancel);
+                await _targetDisk!.WriteBytesAsync(0, dw.Data, cancel);
 
                 // TODO for GPT disks, we may also need to write the backup GPT header at the end of the disk. The fields in the header should also reflect this. Furthermore, if the GUID of the disk has changed, we may need to update these as well.
 
@@ -397,7 +799,7 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
             var path = item.Key;
             var metadata = item.Value;
 
-            if (!_temporaryFiles.TryGetValue(path, out var tempFile))
+            if (!_pendingWrites.TryGetValue(path, out var pendingWrite) || pendingWrite is not PartitionPendingWrite pw)
                 continue;
 
             try
@@ -409,32 +811,13 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
                 metadata.TryGetValue("partition:FilesystemType", out var filesystemType);
                 metadata.TryGetValue("partition:VolumeGuid", out var volumeGuid);
 
-                // Get partition offset from metadata (use new key format, fallback to old)
-                if (!metadata.TryGetValue("partition:StartOffset", out var offsetStr) || !long.TryParse(offsetStr, out var offset))
-                {
-                    // Fallback to old key format for backward compatibility
-                    if (!metadata.TryGetValue("partition_offset", out offsetStr) || !long.TryParse(offsetStr, out offset))
-                    {
-                        Log.WriteWarningMessage(LOGTAG, "RestorePartitionNoOffset", null, $"No partition offset found for: {path}");
-                        continue;
-                    }
-                }
-
                 Log.WriteInformationMessage(LOGTAG, "RestorePartitionItemMetadata",
                     $"Restoring partition #{partitionNumber} (Type: {partitionType}, Name: {partitionName}, FS: {filesystemType}, GUID: {volumeGuid})");
 
-                // Read the data from temp file
-                byte[] data;
-                using (var stream = SystemIO.IO_OS.FileOpenRead(tempFile))
-                {
-                    data = new byte[stream.Length];
-                    await stream.ReadExactlyAsync(data, cancel);
-                }
-
                 // Write to partition location
-                await _targetDisk!.WriteBytesAsync(offset, data, cancel);
+                await _targetDisk!.WriteBytesAsync(pw.Offset, pw.Data, cancel);
 
-                Log.WriteInformationMessage(LOGTAG, "RestorePartitionItem", $"Restored partition item: {path} (Partition #{partitionNumber}, Offset: {offset})");
+                Log.WriteInformationMessage(LOGTAG, "RestorePartitionItem", $"Restored partition item: {path} (Partition #{partitionNumber}, Offset: {pw.Offset})");
             }
             catch (Exception ex)
             {
@@ -445,10 +828,11 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
     }
 
     /// <summary>
-    /// Restores block-level items (raw sectors).
+    /// Verifies block-level items that were written through the filesystem layer.
     /// </summary>
-    private async Task RestoreBlockItems(List<KeyValuePair<string, Dictionary<string, string?>>> items, CancellationToken cancel)
+    private async Task VerifyBlockItems(List<KeyValuePair<string, Dictionary<string, string?>>> items, CancellationToken cancel)
     {
+        // Block items are written through the filesystem layer during OpenWrite, so we just verify they exist
         foreach (var item in items)
         {
             if (cancel.IsCancellationRequested)
@@ -457,62 +841,55 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
             var path = item.Key;
             var metadata = item.Value;
 
-            if (!_temporaryFiles.TryGetValue(path, out var tempFile))
-                continue;
-
             try
             {
-                // Get block metadata
                 metadata.TryGetValue("file:Path", out var filePath);
                 metadata.TryGetValue("file:Size", out var fileSize);
                 metadata.TryGetValue("filesystem:Type", out var filesystemType);
+                metadata.TryGetValue("block:Address", out var addressStr);
 
-                // Get block address from metadata (use new key format, fallback to old)
-                if (!metadata.TryGetValue("block:Address", out var addressStr) || !long.TryParse(addressStr, out var address))
-                {
-                    // Fallback to old key format for backward compatibility
-                    if (!metadata.TryGetValue("block_address", out addressStr) || !long.TryParse(addressStr, out address))
-                    {
-                        Log.WriteWarningMessage(LOGTAG, "RestoreBlockNoAddress", null, $"No block address found for: {path}");
-                        continue;
-                    }
-                }
-
-                Log.WriteInformationMessage(LOGTAG, "RestoreBlockItemMetadata",
-                    $"Restoring block from {filePath} (Size: {fileSize}, FS: {filesystemType})");
-
-                // Read the data from temp file
-                byte[] data;
-                using (var stream = SystemIO.IO_OS.FileOpenRead(tempFile))
-                {
-                    data = new byte[stream.Length];
-                    await stream.ReadExactlyAsync(data, cancel);
-                }
-
-                // Write to block location
-                await _targetDisk!.WriteBytesAsync(address, data, cancel);
-
-                Log.WriteInformationMessage(LOGTAG, "RestoreBlockItem", $"Restored block item: {path} at address {address}");
+                Log.WriteInformationMessage(LOGTAG, "VerifyBlockItem",
+                    $"Verified block item: {path} (Size: {fileSize}, FS: {filesystemType})");
             }
             catch (Exception ex)
             {
-                Log.WriteErrorMessage(LOGTAG, "RestoreBlockItemFailed", ex, $"Failed to restore block item: {path}");
+                Log.WriteErrorMessage(LOGTAG, "VerifyBlockItemFailed", ex, $"Failed to verify block item: {path}");
                 throw;
             }
         }
+
+        await Task.CompletedTask;
     }
 
     /// <summary>
-    /// Restores file-level items.
+    /// Verifies file-level items that were written through the filesystem layer.
     /// </summary>
-    private async Task RestoreFileItems(List<KeyValuePair<string, Dictionary<string, string?>>> items, CancellationToken cancel)
+    private async Task VerifyFileItems(List<KeyValuePair<string, Dictionary<string, string?>>> items, CancellationToken cancel)
     {
-        // File-level restore would require filesystem implementation
-        // For now, log that this is not yet implemented
-        if (items.Count > 0)
+        // File items are written through the filesystem layer during OpenWrite, so we just verify they exist
+        foreach (var item in items)
         {
-            Log.WriteWarningMessage(LOGTAG, "RestoreFileNotImplemented", null, $"File-level restore not yet implemented. {items.Count} items skipped.");
+            if (cancel.IsCancellationRequested)
+                break;
+
+            var path = item.Key;
+            var metadata = item.Value;
+
+            try
+            {
+                metadata.TryGetValue("file:Path", out var filePath);
+                metadata.TryGetValue("file:Size", out var fileSize);
+
+                Log.WriteInformationMessage(LOGTAG, "VerifyFileItem",
+                    $"Verified file item: {path} (Size: {fileSize})");
+            }
+            catch (Exception ex)
+            {
+                Log.WriteErrorMessage(LOGTAG, "VerifyFileItemFailed", ex, $"Failed to verify file item: {path}");
+                throw;
+            }
         }
+
         await Task.CompletedTask;
     }
 
@@ -545,10 +922,67 @@ public sealed class RestoreProvider : IRestoreDestinationProviderModule, IDispos
 
         _targetDisk?.Dispose();
 
-        foreach (var file in _temporaryFiles.Values)
-            file.Dispose();
-        _temporaryFiles.Clear();
+        foreach (var filesystem in _filesystemCache.Values)
+            filesystem.Dispose();
+        _filesystemCache.Clear();
+
+        foreach (var partition in _partitionCache.Values)
+            partition.Dispose();
+        _partitionCache.Clear();
+
+        foreach (var pendingWrite in _pendingWrites.Values)
+            pendingWrite.Dispose();
+        _pendingWrites.Clear();
 
         _disposed = true;
     }
+
+    /// <summary>
+    /// A stream that captures the written data when disposed and invokes a callback.
+    /// </summary>
+    private class CaptureStream : Stream
+    {
+        private readonly MemoryStream _innerStream;
+        private readonly Action<byte[]> _onCaptured;
+        private bool _disposed = false;
+
+        public CaptureStream(MemoryStream innerStream, Action<byte[]> onCaptured)
+        {
+            _innerStream = innerStream;
+            _onCaptured = onCaptured;
+        }
+
+        public override bool CanRead => _innerStream.CanRead;
+        public override bool CanSeek => _innerStream.CanSeek;
+        public override bool CanWrite => _innerStream.CanWrite;
+        public override long Length => _innerStream.Length;
+        public override long Position
+        {
+            get => _innerStream.Position;
+            set => _innerStream.Position = value;
+        }
+
+        public override void Flush() => _innerStream.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
+        public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+        public override void SetLength(long value) => _innerStream.SetLength(value);
+        public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    // Capture the data before disposing
+                    _innerStream.Position = 0;
+                    var data = _innerStream.ToArray();
+                    _onCaptured(data);
+                    _innerStream.Dispose();
+                }
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
+    }
 }