diff --git a/.claude/rules/c-sharp-code-style.md b/.claude/rules/c-sharp-code-style.md
index 72d76e2..3105975 100644
--- a/.claude/rules/c-sharp-code-style.md
+++ b/.claude/rules/c-sharp-code-style.md
@@ -35,6 +35,14 @@ Coding standards and style guidelines / preferences for C# files in this reposit
 
 - Use file-scoped namespaces.
 - Namespace names should follow the pattern: Company.Project.Module (e.g., Contoso.Sales.Reporting).
+- Use `using` aliases to eliminate noise from verbose third-party type names:
+  ```csharp
+  // ✅ alias at the top of the file — use the alias throughout
+  using GraphClient = Microsoft.Graph.GraphServiceClient;
+
+  // ❌ repeated fully-qualified name in every method signature
+  private static Task<...> FooAsync(Microsoft.Graph.GraphServiceClient client, ...) { }
+  ```
 
 ## Folder Structure
 
@@ -89,6 +97,32 @@ This applies to all new code.
 - Every `return` statement after a code block must be preceded by a blank line. `return` after an `if` must NOT be followed by a blank line or `{ return; }`.
 - Name for **meaning**: `customerId` not `id`, `isExpired` not `flag`.
 - Use builders for test setup / test data creation.
+- Prefer a nullable accumulator parameter with `?? []` over an overload pair where one simply calls the other with an empty collection:
+  ```csharp
+  // ❌ overload pair — the first adds nothing
+  private static Task<Result<List<T>, E>> GetPagesAsync(Client c, Page page, CancellationToken ct)
+      => GetPagesAsync(c, page, [], ct);
+  private static Task<Result<List<T>, E>> GetPagesAsync(Client c, Page page, IReadOnlyCollection<T> acc, CancellationToken ct) { ... }
+
+  // ✅ single method with nullable accumulator
+  private static Task<Result<List<T>, E>> GetPagesAsync(Client c, Page page, IReadOnlyCollection<T>? acc, CancellationToken ct)
+  {
+      var items = (acc ?? []).Concat(GetItemsFromPage(page)).ToList();
+      // ...
+  }
+  ```
+- A private method whose entire body is a 1–2 combinator chain that forwards to another private method earns nothing — inline it at the call site:
+  ```csharp
+  // ❌ wrapper adds a layer for no reason
+  private static Task<Result<List<DriveFolder>, GraphError>> GetDriveFoldersAsync(Client c, DriveFound d, RootFound r, CancellationToken ct)
+      => GetFirstPageAsync(c, d, r, ct).BindAsync(page => GetAllPagesAsync(c, d, r, page, ct));
+
+  // ✅ inline at the call site
+  private static Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersForDriveAsync(Client c, DriveFound d, CancellationToken ct)
+      => GetRootAsync(c, d, ct)
+          .BindAsync(root => GetFirstPageAsync(c, d, root, ct)
+              .BindAsync(page => GetAllPagesAsync(c, d, root, page, null, ct)));
+  ```
 
 ## Primitive Obsession
 
diff --git a/.claude/rules/c-sharp-testing.md b/.claude/rules/c-sharp-testing.md
index 33901ca..021a0b8 100644
--- a/.claude/rules/c-sharp-testing.md
+++ b/.claude/rules/c-sharp-testing.md
@@ -36,7 +36,7 @@ collection.ShouldBeEmpty();
 
 ```csharp
 // ✅ test code — pattern matching is fine
-var result = await repository.GetByIdAsync(id, ct);
+var result = await repository.GetByIdAsync(id, cancellationToken);
 result.ShouldBeOfType<Option<AccountEntity>.Some>();
 var some = (Option<AccountEntity>.Some)result;
 some.Value.Profile.Email.ShouldBe("test@example.com");
diff --git a/.claude/rules/onedrive-auth.md b/.claude/rules/onedrive-auth.md
index f0a3015..69808a6 100644
--- a/.claude/rules/onedrive-auth.md
+++ b/.claude/rules/onedrive-auth.md
@@ -158,8 +158,8 @@ string email = result.ClaimsPrincipal?.FindFirst("preferred_username")?.Value
 ## IAuthService contract
 
 ```csharp
-Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(CancellationToken ct = default);
-Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string accountId, CancellationToken ct = default);
-Task SignOutAsync(string accountId, CancellationToken ct = default);
+Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(CancellationToken cancellationToken = default);
+Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string accountId, CancellationToken cancellationToken = default);
+Task SignOutAsync(string accountId, CancellationToken cancellationToken = default);
 Task<IReadOnlyList<string>> GetCachedAccountIdsAsync();
 ```
diff --git a/.claude/rules/onedrive-background.md b/.claude/rules/onedrive-background.md
index c1c278c..0c350f2 100644
--- a/.claude/rules/onedrive-background.md
+++ b/.claude/rules/onedrive-background.md
@@ -13,7 +13,7 @@ scheduler.StopSync();                     // pause without disposing
 scheduler.SetInterval(newInterval);       // change interval mid-run
 
 await scheduler.TriggerNowAsync(ct);     // immediate one-shot sync (all accounts)
-await scheduler.TriggerAccountAsync(accountId, ct);  // sync a single account
+await scheduler.TriggerAccountAsync(accountId, cancellationToken);  // sync a single account
 await scheduler.CancelAccountSyncAsync(accountId);   // cancel in-flight sync for account
 ```
 
@@ -24,7 +24,7 @@ Use `Interlocked.Exchange` to prevent concurrent sync passes:
 ```csharp
 private long _runningFlag;
 
-private async Task RunSyncPassAsync(CancellationToken ct)
+private async Task RunSyncPassAsync(CancellationToken cancellationToken)
 {
     if (Interlocked.Exchange(ref _runningFlag, 1) == 1) return;
     try { /* sync all accounts */ }
@@ -76,15 +76,15 @@ event EventHandler<string>? SyncCompleted;
 void StartSync(TimeSpan? interval = null);
 void StopSync();
 void SetInterval(TimeSpan interval);
-Task TriggerNowAsync(CancellationToken ct = default);
-Task TriggerAccountAsync(string accountId, CancellationToken ct = default);
-Task TriggerAccountAsync(OneDriveAccount account, CancellationToken ct = default);
+Task TriggerNowAsync(CancellationToken cancellationToken = default);
+Task TriggerAccountAsync(string accountId, CancellationToken cancellationToken = default);
+Task TriggerAccountAsync(OneDriveAccount account, CancellationToken cancellationToken = default);
 Task CancelAccountSyncAsync(string accountId);
 ```
 
 ## CancellationToken rules
 
-- **Every** public async method takes `CancellationToken ct = default` as the final parameter.
+- **Every** public async method takes `CancellationToken cancellationToken = default` as the final parameter.
 - Propagate `ct` to every downstream `await` — never pass `CancellationToken.None` unless you are deliberately starting unlinked work (e.g. timer-tick root, post-cancellation cleanup).
 - Catch `OperationCanceledException` at the service boundary only — do not swallow it inside pipeline steps.
 - Use `CancellationTokenSource.CreateLinkedTokenSource(ct)` when you need per-account cancellation composable with an outer token.
diff --git a/.claude/rules/onedrive-di.md b/.claude/rules/onedrive-di.md
index f2c422c..1ecec43 100644
--- a/.claude/rules/onedrive-di.md
+++ b/.claude/rules/onedrive-di.md
@@ -67,10 +67,10 @@ services.AddDbContextFactory<AppDbContext>(options =>
 // Repository usage — one context per async operation
 public class AccountRepository(IDbContextFactory<AppDbContext> dbFactory) : IAccountRepository
 {
-    public async Task<Option<AccountEntity>> GetByIdAsync(AccountId id, CancellationToken ct)
+    public async Task<Option<AccountEntity>> GetByIdAsync(AccountId id, CancellationToken cancellationToken)
     {
         await using var context = await dbFactory.CreateDbContextAsync(ct);
-        var entity = await context.Accounts.FindAsync([id], ct);
+        var entity = await context.Accounts.FindAsync([id], cancellationToken);
         return entity is null ? new None<AccountEntity>() : new Some<AccountEntity>(entity);
     }
 }
diff --git a/.claude/rules/onedrive-graph.md b/.claude/rules/onedrive-graph.md
index 2411e64..62afa7f 100644
--- a/.claude/rules/onedrive-graph.md
+++ b/.claude/rules/onedrive-graph.md
@@ -9,6 +9,14 @@ This repo uses `Microsoft.Graph` (SDK v5+) via a `GraphServiceClient` created pe
 <PackageReference Include="Microsoft.Kiota.Abstractions" />
 ```
 
+## Type alias
+
+Always add a `using` alias at the top of any file that uses `GraphServiceClient` — the fully-qualified name is noisy in method signatures:
+
+```csharp
+using GraphClient = Microsoft.Graph.GraphServiceClient;
+```
+
 ## Creating a Graph client
 
 ```csharp
@@ -19,7 +27,7 @@ public GraphServiceClient CreateClient(string accessToken)
 
 private sealed class StaticAccessTokenProvider(string token) : IAccessTokenProvider
 {
-    public Task<string> GetAuthorizationTokenAsync(Uri uri, ..., CancellationToken ct = default)
+    public Task<string> GetAuthorizationTokenAsync(Uri uri, ..., CancellationToken cancellationToken = default)
         => Task.FromResult(token);
 
     public AllowedHostsValidator AllowedHostsValidator { get; } = new(["graph.microsoft.com"]);
@@ -45,17 +53,39 @@ _cache[accountId] = new DriveContext(new DriveId(drive.Id), root.Id);
 
 ## Getting root folders
 
+Use a single `GetFolderPageAsync` helper with `string? nextLink` — `null` fetches the first page (with `Select` query params); non-null fetches subsequent pages via `.WithUrl` (URL already contains params). This replaces two near-identical methods:
+
 ```csharp
-var response = await client
-    .Drives[driveId].Items[rootId].Children
-    .GetAsync(req => req.QueryParameters.Select = ["id", "name", "folder", "file", "size",
-        "lastModifiedDateTime", "parentReference", "eTag", "cTag",
-        "@microsoft.graph.downloadUrl"], ct);
+private static async Task<Result<DriveItemCollectionResponse, GraphError>> GetFolderPageAsync(GraphClient client, DriveFound driveFound, RootFound rootFound, string? nextLink, CancellationToken cancellationToken)
+{
+    var children = client.Drives[driveFound.Drive.Id].Items[rootFound.DriveItem.Id].Children;
+    var page = nextLink is null
+        ? await children.GetAsync(req => req.QueryParameters.Select = ChildrenSelect, cancellationToken: cancellationToken).ConfigureAwait(false)
+        : await children.WithUrl(nextLink).GetAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+
+    return page is { }
+        ? new Ok<DriveItemCollectionResponse, GraphError>(page)
+        : new Fail<DriveItemCollectionResponse, GraphError>(GraphErrorFactory.Unexpected("Folder page was null."));
+}
+```
+
+Recursive page accumulation uses `IReadOnlyCollection<T>?` with `?? []` — no overload pair needed:
+
+```csharp
+private static Task<Result<List<DriveFolder>, GraphError>> GetFoldersFromPagesAsync(GraphClient client, DriveFound driveFound, RootFound rootFound, DriveItemCollectionResponse page, IReadOnlyCollection<DriveFolder>? foldersSoFar, CancellationToken cancellationToken)
+{
+    var folders = (foldersSoFar ?? []).Concat(GetFoldersFromPage(page)).ToList();
+
+    return page.OdataNextLink is null
+        ? Task.FromResult<Result<List<DriveFolder>, GraphError>>(new Ok<List<DriveFolder>, GraphError>(folders))
+        : GetFolderPageAsync(client, driveFound, rootFound, page.OdataNextLink, cancellationToken)
+            .BindAsync(nextPage => GetFoldersFromPagesAsync(client, driveFound, rootFound, nextPage, folders, cancellationToken));
+}
 ```
 
 - Filter to `item.Folder is not null` to get folders only.
-- **Always** paginate: loop on `OdataNextLink` using `.WithUrl(nextLink).GetAsync(ct)`.
-- Return `DriveFolder(Id, Name, ParentId)` records ordered by name.
+- Pass `null` for `foldersSoFar` on the initial call; recursive calls pass the accumulated list.
+- Return `DriveFolder(Id, Name, ParentId)` records.
 
 ## Getting child folders (lazy folder tree)
 
@@ -66,7 +96,7 @@ var result = await client
     {
         req.QueryParameters.Select = ["id", "name", "folder", "parentReference"];
         req.QueryParameters.Top = 100;
-    }, ct);
+    }, cancellationToken);
 ```
 
 - Same pagination loop as root folders.
@@ -77,7 +107,7 @@ var result = await client
 ```csharp
 var drive = await client
     .Drives[driveId]
-    .GetAsync(req => req.QueryParameters.Select = ["quota"], ct);
+    .GetAsync(req => req.QueryParameters.Select = ["quota"], cancellationToken);
 long total = drive?.Quota?.Total ?? 0L;
 long used  = drive?.Quota?.Used  ?? 0L;
 ```
@@ -88,12 +118,12 @@ Recursively enumerates a folder subtree. Use a `HashSet<string>` of visited IDs
 
 ```csharp
 static async Task EnumerateSubFolderAsync(GraphServiceClient client, DriveId driveId, string parentId,
-    string relativePath, List<DeltaItem> items, HashSet<string> visited, CancellationToken ct)
+    string relativePath, List<DeltaItem> items, HashSet<string> visited, CancellationToken cancellationToken)
 {
     if (!visited.Add(parentId)) return;  // cycle guard
 
     var page = await client.Drives[driveId.Value].Items[parentId].Children
-        .GetAsync(req => req.QueryParameters.Select = _childrenSelect, ct);
+        .GetAsync(req => req.QueryParameters.Select = _childrenSelect, cancellationToken);
 
     while (page?.Value is not null)
     {
@@ -102,11 +132,11 @@ static async Task EnumerateSubFolderAsync(GraphServiceClient client, DriveId dri
             string itemPath = BuildRelativePath(relativePath, item);
             items.Add(MapToDeltaItem(item, itemPath));
             if (item.Folder is not null && item.Id is not null)
-                await EnumerateSubFolderAsync(client, driveId, item.Id, itemPath, items, visited, ct);
+                await EnumerateSubFolderAsync(client, driveId, item.Id, itemPath, items, visited, cancellationToken);
         }
         if (page.OdataNextLink is null) break;
         page = await client.Drives[driveId.Value].Items[parentId].Children
-            .WithUrl(page.OdataNextLink).GetAsync(ct: ct);
+            .WithUrl(page.OdataNextLink).GetAsync(ct: cancellationToken);
     }
 }
 ```
@@ -118,7 +148,7 @@ Returns `Result<List<DeltaItem>, GraphError>`.
 ```csharp
 var item = await client
     .Drives[driveId].Items[$"root:/{remotePath}"]
-    .GetAsync(req => req.QueryParameters.Select = ["id"], ct);
+    .GetAsync(req => req.QueryParameters.Select = ["id"], cancellationToken);
 // Returns null on 404 — catch ApiException with ResponseStatusCode == 404
 ```
 
@@ -128,7 +158,7 @@ Select `@microsoft.graph.downloadUrl` and read from `item.AdditionalData`:
 
 ```csharp
 var item = await client.Drives[driveId].Items[itemId]
-    .GetAsync(req => req.QueryParameters.Select = ["@microsoft.graph.downloadUrl"], ct);
+    .GetAsync(req => req.QueryParameters.Select = ["@microsoft.graph.downloadUrl"], cancellationToken);
 
 if (!item.AdditionalData.TryGetValue("@microsoft.graph.downloadUrl", out var url) || url is null)
     return new Result<string, GraphError>.Error(GraphErrorFactory.NotFound(itemId));
@@ -148,7 +178,7 @@ var session = await client
     .Drives[driveId].Items[parentFolderId]
     .ItemWithPath(remotePath)
     .CreateUploadSession
-    .PostAsync(requestBody, ct);
+    .PostAsync(requestBody, cancellationToken);
 
 // requestBody sets @microsoft.graph.conflictBehavior = "replace"
 // and fileSystemInfo.lastModifiedDateTime from local file's LastWriteTimeUtc
@@ -161,7 +191,7 @@ See `onedrive-sync.md` for the full upload/retry protocol.
 ## Deleting an item
 
 ```csharp
-await client.Drives[driveId].Items[itemId].DeleteAsync(ct: ct);
+await client.Drives[driveId].Items[itemId].DeleteAsync(ct: cancellationToken);
 ```
 
 Returns `Result<Unit, GraphError>`.
@@ -188,15 +218,15 @@ var downloadUrl  = ExtractDownloadUrl(item);              // Option<string>
 ## IGraphService contract
 
 ```csharp
-Task<Result<DriveId, GraphError>>             GetDriveIdAsync(string accountId, string accessToken, CancellationToken ct = default);
-Task<Result<List<DriveFolder>, GraphError>>   GetRootFoldersAsync(string accountId, string accessToken, CancellationToken ct = default);
-Task<Result<List<DriveFolder>, GraphError>>   GetChildFoldersAsync(string accessToken, DriveId driveId, string parentFolderId, CancellationToken ct = default);
-Task<Result<(long Total, long Used), GraphError>> GetQuotaAsync(string accountId, string accessToken, CancellationToken ct = default);
-Task<Result<List<DeltaItem>, GraphError>>   EnumerateFolderAsync(string accessToken, DriveId driveId, string folderId, string remotePath, CancellationToken ct = default);
-Task<Option<string>>                        GetFolderIdByPathAsync(string accessToken, DriveId driveId, string remotePath, CancellationToken ct = default);
-Task<Result<string, GraphError>>            GetDownloadUrlAsync(string accountId, string accessToken, string itemId, CancellationToken ct = default);
-Task<Result<string, GraphError>>            UploadFileAsync(string accountId, string accessToken, string localPath, string remotePath, string parentFolderId, CancellationToken ct = default);
-Task<Result<Unit, GraphError>>              DeleteItemAsync(string accountId, string accessToken, string itemId, CancellationToken ct = default);
+Task<Result<DriveId, GraphError>>             GetDriveIdAsync(string accountId, string accessToken, CancellationToken cancellationToken = default);
+Task<Result<List<DriveFolder>, GraphError>>   GetRootFoldersAsync(string accountId, string accessToken, CancellationToken cancellationToken = default);
+Task<Result<List<DriveFolder>, GraphError>>   GetChildFoldersAsync(string accessToken, DriveId driveId, string parentFolderId, CancellationToken cancellationToken = default);
+Task<Result<(long Total, long Used), GraphError>> GetQuotaAsync(string accountId, string accessToken, CancellationToken cancellationToken = default);
+Task<Result<List<DeltaItem>, GraphError>>   EnumerateFolderAsync(string accessToken, DriveId driveId, string folderId, string remotePath, CancellationToken cancellationToken = default);
+Task<Option<string>>                        GetFolderIdByPathAsync(string accessToken, DriveId driveId, string remotePath, CancellationToken cancellationToken = default);
+Task<Result<string, GraphError>>            GetDownloadUrlAsync(string accountId, string accessToken, string itemId, CancellationToken cancellationToken = default);
+Task<Result<string, GraphError>>            UploadFileAsync(string accountId, string accessToken, string localPath, string remotePath, string parentFolderId, CancellationToken cancellationToken = default);
+Task<Result<Unit, GraphError>>              DeleteItemAsync(string accountId, string accessToken, string itemId, CancellationToken cancellationToken = default);
 void                                      EvictCachedDriveContext(string accountId);
 ```
 
diff --git a/.claude/rules/onedrive-onboarding.md b/.claude/rules/onedrive-onboarding.md
index e3f4aae..24f3163 100644
--- a/.claude/rules/onedrive-onboarding.md
+++ b/.claude/rules/onedrive-onboarding.md
@@ -9,7 +9,7 @@
 /// Persists a new account and its initial sync configuration after the wizard completes.
 /// Returns the finalised <see cref="OneDriveAccount"/> with all defaults applied.
 /// </summary>
-Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingAsync(OneDriveAccount account, CancellationToken ct = default);
+Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingAsync(OneDriveAccount account, CancellationToken cancellationToken = default);
 ```
 
 ## Responsibilities (in order)
@@ -56,7 +56,7 @@ The wizard ViewModel raises `Completed` with the draft `OneDriveAccount`. The ho
 ```csharp
 wizard.Completed += async (_, account) =>
 {
-    await _onboardingService.CompleteOnboardingAsync(account, ct)
+    await _onboardingService.CompleteOnboardingAsync(account, cancellationToken)
         .MatchAsync(
             finalAccount => { /* add to accounts list, navigate away */ },
             error        => { HasError = true; ErrorMessage = error.Message; });
diff --git a/.claude/rules/onedrive-persistence.md b/.claude/rules/onedrive-persistence.md
index 82dd1c3..2769fcd 100644
--- a/.claude/rules/onedrive-persistence.md
+++ b/.claude/rules/onedrive-persistence.md
@@ -190,11 +190,11 @@ IFileClassificationRuleRepository / FileClassificationRuleRepository
 All write methods return `Result<Unit, PersistenceError>`. Catch EF exceptions at the repository:
 
 ```csharp
-public async Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity entity, CancellationToken ct)
+public async Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity entity, CancellationToken cancellationToken)
 {
     try
     {
-        var existing = await context.Accounts.FindAsync([entity.Id], ct);
+        var existing = await context.Accounts.FindAsync([entity.Id], cancellationToken);
         if (existing is null)
             context.Accounts.Add(entity);
         else
diff --git a/.claude/rules/onedrive-sync.md b/.claude/rules/onedrive-sync.md
index 833e0b0..493a9ad 100644
--- a/.claude/rules/onedrive-sync.md
+++ b/.claude/rules/onedrive-sync.md
@@ -90,7 +90,7 @@ After writing the file:
 A discrete `ISyncedItemRegistrar` handles two registration tasks that occur during the build phase (not job execution):
 
 ```csharp
-Task RegisterFolderAsync(AccountId accountId, FolderDeltaItem item, string remotePath, string localPath, Dictionary<string, SyncedItemEntity> syncedItems, CancellationToken ct);
+Task RegisterFolderAsync(AccountId accountId, FolderDeltaItem item, string remotePath, string localPath, Dictionary<string, SyncedItemEntity> syncedItems, CancellationToken cancellationToken);
 ```
 
 - Creates the local directory via `IFileSystem` if it does not exist.
@@ -163,7 +163,7 @@ Set `fileSystemInfo.lastModifiedDateTime` from the local file's `LastWriteTimeUt
 - Returns `Result<Unit, SyncError>`.
 
 ```csharp
-Task<Result<Unit, SyncError>> DownloadAsync(string url, string localPath, DateTimeOffset remoteModified, IProgress<long>? progress = null, CancellationToken ct = default);
+Task<Result<Unit, SyncError>> DownloadAsync(string url, string localPath, DateTimeOffset remoteModified, IProgress<long>? progress = null, CancellationToken cancellationToken = default);
 ```
 
 ## Conflict detection
@@ -188,7 +188,7 @@ public enum ConflictPolicy
 ### Resolution flow
 
 1. `ConflictResolver.Resolve(policy, localModified, remoteModified)` returns `ConflictOutcome`.
-2. `ConflictApplier.ApplyAsync(conflict, outcome, accountId, accessToken, ct)` executes the chosen action via `IGraphService` or local file system.
+2. `ConflictApplier.ApplyAsync(conflict, outcome, accountId, accessToken, cancellationToken)` executes the chosen action via `IGraphService` or local file system.
 3. `syncRepository.ResolveConflictAsync(conflictId, policy)` marks the conflict resolved in the DB.
 4. Unresolved conflicts surface in the UI via `ISyncService.ConflictDetected` event.
 
@@ -216,7 +216,7 @@ record SyncConflict(
 
 ```csharp
 // ISyncPipeline
-Task RunAsync(IEnumerable<SyncJob> jobs, string accessToken, Action<SyncProgressEventArgs> onProgress, Action<JobCompletedEventArgs> onJobCompleted, string accountId, int workerCount, CancellationToken ct = default);
+Task RunAsync(IEnumerable<SyncJob> jobs, string accessToken, Action<SyncProgressEventArgs> onProgress, Action<JobCompletedEventArgs> onJobCompleted, string accountId, int workerCount, CancellationToken cancellationToken = default);
 ```
 
 Never hard-code `workerCount` — always pass `account.SyncConfig.WorkerCount`.
@@ -228,8 +228,8 @@ event EventHandler<SyncProgressEventArgs>? SyncProgressChanged;
 event EventHandler<JobCompletedEventArgs>?  JobCompleted;
 event EventHandler<SyncConflict>?           ConflictDetected;
 
-Task<Result<Unit, SyncError>> SyncAccountAsync(OneDriveAccount account, CancellationToken ct = default);
-Task<Result<Unit, SyncError>> ResolveConflictAsync(SyncConflict conflict, ConflictPolicy policy, CancellationToken ct = default);
+Task<Result<Unit, SyncError>> SyncAccountAsync(OneDriveAccount account, CancellationToken cancellationToken = default);
+Task<Result<Unit, SyncError>> ResolveConflictAsync(SyncConflict conflict, ConflictPolicy policy, CancellationToken cancellationToken = default);
 ```
 
 ## SyncProgressEventArgs
diff --git a/.claude/rules/onedrive-viewmodels.md b/.claude/rules/onedrive-viewmodels.md
index 55c44c1..76c338f 100644
--- a/.claude/rules/onedrive-viewmodels.md
+++ b/.claude/rules/onedrive-viewmodels.md
@@ -193,9 +193,9 @@ public sealed class AddAccountWizardViewModel : ReactiveObject, IDisposable
         var canGoNext = this.WhenAnyValue(x => x.IsSignedIn, x => x.CurrentStep,
             (signedIn, step) => step == WizardStep.SignIn ? signedIn : true);
 
-        OpenBrowser = ReactiveCommand.CreateFromTask(ct => OpenBrowserAsync(authService, ct));
+        OpenBrowser = ReactiveCommand.CreateFromTask(ct => OpenBrowserAsync(authService, cancellationToken));
         Back        = ReactiveCommand.Create(ExecuteBack);
-        Next        = ReactiveCommand.CreateFromTask(ct => ExecuteNextAsync(graphService, ct), canGoNext);
+        Next        = ReactiveCommand.CreateFromTask(ct => ExecuteNextAsync(graphService, cancellationToken), canGoNext);
         Cancel      = ReactiveCommand.CreateFromTask(ExecuteCancelAsync);
     }
 
diff --git a/.gitignore b/.gitignore
index 378a541..98c206c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,6 +20,9 @@ mono_crash.*
 # graphify
 graphify-out/
 
+# JetBrains Rider
+.idea/
+
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
diff --git a/.vscode/settings.json b/.vscode/settings.json
index fc8800f..af4e2d4 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -6,9 +6,19 @@
     },
     "dotnet.defaultSolution": "AStar.Dev.OneDrive.Functional.slnx",
     "cSpell.words": [
+        "appsettings",
+        "astar",
         "Avalonia",
+        "buildtransitive",
+        "centralise",
+        "cloudsync",
+        "contentfiles",
         "googledrive",
+        "Lucide",
+        "MSAL",
         "MVVM",
-        "onedrive"
+        "onedrive",
+        "Serilog",
+        "Testably"
     ]
 }
\ No newline at end of file
diff --git a/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj b/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
index 03230c3..81f2d6e 100644
--- a/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
+++ b/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
@@ -23,25 +23,26 @@
       <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
       <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.Identity.Client" Version="4.67.2" />
-    <PackageReference Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.67.2" />
-    <PackageReference Include="Microsoft.Graph" Version="5.77.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.0" />
-    <PackageReference Include="Serilog" Version="4.2.0" />
-    <PackageReference Include="Serilog.Extensions.Hosting" Version="9.0.0" />
-    <PackageReference Include="Serilog.Extensions.Logging" Version="9.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.0">
+    <PackageReference Include="Microsoft.Identity.Client" Version="4.84.1" />
+    <PackageReference Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.84.1" />
+    <PackageReference Include="Microsoft.Graph" Version="6.1.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.8" />
+    <PackageReference Include="Serilog" Version="4.3.1" />
+    <PackageReference Include="Serilog.Extensions.Hosting" Version="10.0.0" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="10.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Testably.Abstractions" Version="10.2.0" />
   </ItemGroup>
 
   <ItemGroup>
-    <AvaloniaResource Include="Assets/Fonts/**" />
+    <AvaloniaResource Include="Assets/**" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs
index 8b80004..ac57dd2 100644
--- a/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs
@@ -13,6 +13,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Identity.Client;
+using System.IO.Abstractions;
+using Testably.Abstractions;
 using MELogLevel = Microsoft.Extensions.Logging.LogLevel;
 
 namespace AStar.Dev.CloudSyncFunctional;
@@ -37,13 +39,11 @@ public override void OnFrameworkInitializationCompleted()
         ConfigureServices(services, configuration);
         _serviceProvider = services.BuildServiceProvider();
 
-        ApplyDatabaseMigrations(_serviceProvider);
-
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
             var viewModel = _serviceProvider.GetRequiredService<WorkspaceViewModel>();
             desktop.MainWindow = new MainWindow(viewModel);
-            _ = viewModel.LoadPersistedAccountsAsync(CancellationToken.None);
+            _ = InitialiseAsync(_serviceProvider, viewModel);
         }
 
         base.OnFrameworkInitializationCompleted();
@@ -56,7 +56,7 @@ private static void ConfigureServices(IServiceCollection services, IConfiguratio
         var clientId = configuration["MicrosoftIdentity:ClientId"]
             ?? throw new InvalidOperationException("MicrosoftIdentity:ClientId is not configured. Set it in appsettings.json or user secrets.");
 
-        services.AddSingleton<IPublicClientApplication>(_ =>
+        services.AddSingleton(_ =>
             PublicClientApplicationBuilder
                 .Create(clientId)
                 .WithAuthority("https://login.microsoftonline.com/consumers")
@@ -68,7 +68,10 @@ private static void ConfigureServices(IServiceCollection services, IConfiguratio
         services.AddSingleton<IGraphClientFactory, GraphClientFactory>();
         services.AddSingleton<IGraphService, GraphService>();
 
-        var connectionString = $"DataSource={GetDatabasePath()}";
+        var fileSystem = new RealFileSystem();
+        services.AddSingleton<IFileSystem>(fileSystem);
+
+        var connectionString = $"DataSource={GetDatabasePath(fileSystem)}";
         services.AddDbContextFactory<AppDbContext>(options =>
             options.UseSqlite(connectionString), ServiceLifetime.Singleton);
 
@@ -84,19 +87,25 @@ private static void ConfigureServices(IServiceCollection services, IConfiguratio
         services.AddTransient<WorkspaceViewModel>();
     }
 
-    private static void ApplyDatabaseMigrations(IServiceProvider serviceProvider)
+    private static async Task InitialiseAsync(IServiceProvider serviceProvider, WorkspaceViewModel viewModel)
+    {
+        await ApplyDatabaseMigrationsAsync(serviceProvider);
+        await viewModel.LoadPersistedAccountsAsync(CancellationToken.None);
+    }
+
+    private static async Task ApplyDatabaseMigrationsAsync(IServiceProvider serviceProvider)
     {
         var dbContextFactory = serviceProvider.GetRequiredService<IDbContextFactory<AppDbContext>>();
-        using var startupContext = dbContextFactory.CreateDbContext();
-        startupContext.Database.Migrate();
+        await using var context = await dbContextFactory.CreateDbContextAsync();
+        await context.Database.MigrateAsync();
     }
 
-    private static string GetDatabasePath()
+    private static string GetDatabasePath(IFileSystem fileSystem)
     {
         var configDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
-        var appDir = Path.Combine(configDir, "astar-dev-cloudsync");
-        Directory.CreateDirectory(appDir);
+        var appDir = fileSystem.Path.Combine(configDir, "astar-dev-cloudsync");
+        fileSystem.Directory.CreateDirectory(appDir);
 
-        return Path.Combine(appDir, "sync.db");
+        return fileSystem.Path.Combine(appDir, "sync.db");
     }
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Assets/astar.png b/src/AStar.Dev.CloudSyncFunctional/Assets/astar.png
new file mode 100644
index 0000000..74b197e
Binary files /dev/null and b/src/AStar.Dev.CloudSyncFunctional/Assets/astar.png differ
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/AccountId.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/AccountId.cs
new file mode 100644
index 0000000..f90bcfa
--- /dev/null
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/AccountId.cs
@@ -0,0 +1,15 @@
+namespace AStar.Dev.CloudSyncFunctional.Auth;
+
+/// <summary>
+/// Strongly-typed wrapper for an OneDrive account identifier.
+/// </summary>
+/// <param name="Value">The account identifier.</param>
+public sealed record AccountId(string Value)
+{
+    /// <summary>
+    /// Factory method to create an AccountId from a string value. This can be extended in the future to include validation or transformation logic if needed.
+    /// </summary>
+    /// <param name="value">The string value to create the AccountId from.</param>
+    /// <returns>The created AccountId.</returns>
+    public static AccountId Create(string value) => new(value);
+}
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/AccountProfile.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/AccountProfile.cs
index 4d9aba7..306b662 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/AccountProfile.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/AccountProfile.cs
@@ -4,3 +4,14 @@ namespace AStar.Dev.CloudSyncFunctional.Auth;
 /// <param name="DisplayName">The user's display name.</param>
 /// <param name="Email">The user's email address.</param>
 public sealed record AccountProfile(string DisplayName, string Email);
+
+public static class AccountProfileFactory
+{
+    /// <summary>
+    /// Factory method to create an AccountProfile from string values. This can be extended in the future to include validation or transformation logic if needed.
+    /// </summary>
+    /// <param name="displayName">The user's display name.</param>
+    /// <param name="email">The user's email address.</param>
+    /// <returns>An <see cref="AccountProfile"/> with the provided values.</returns>
+    public static AccountProfile Create(string displayName, string email) => new(displayName, email);
+}
\ No newline at end of file
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/AuthError.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/AuthError.cs
index e82aa9e..0a4c41d 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/AuthError.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/AuthError.cs
@@ -35,6 +35,5 @@ public static class AuthErrorFactory
     /// <summary>Creates an <see cref="AuthFailedError"/> with the given message.</summary>
     /// <param name="message">The error message; falls back to a default if null or whitespace.</param>
     /// <returns>An error representing a failed authentication.</returns>
-    public static AuthError Failed(string? message) => new AuthFailedError(
-        string.IsNullOrWhiteSpace(message) ? "Authentication failed: unknown error." : message);
+    public static AuthError Failed(string? message) => new AuthFailedError(string.IsNullOrWhiteSpace(message) ? "Authentication failed: unknown error." : message);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs
index 07c2e20..c2e4c97 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs
@@ -11,7 +11,7 @@ public sealed partial class AuthService(IPublicClientApplication app, ILogger<Au
     private static readonly string[] Scopes = ["Files.ReadWrite", "offline_access", "User.Read"];
 
     /// <inheritdoc />
-    public async Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(CancellationToken ct = default)
+    public async Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(CancellationToken cancellationToken = default)
     {
         try
         {
@@ -19,7 +19,7 @@ public async Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(Cancella
                 .AcquireTokenInteractive(Scopes)
                 .WithPrompt(Prompt.SelectAccount)
                 .WithUseEmbeddedWebView(false)
-                .ExecuteAsync(ct)
+                .ExecuteAsync(cancellationToken)
                 .ConfigureAwait(false);
 
             return new Ok<AuthResult, AuthError>(BuildAuthResult(msalResult));
@@ -45,7 +45,7 @@ public async Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(Cancella
     }
 
     /// <inheritdoc />
-    public async Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string accountId, CancellationToken ct = default)
+    public async Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string accountId, CancellationToken cancellationToken = default)
     {
         try
         {
@@ -54,7 +54,7 @@ public async Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string
             if (account is null)
                 return new Fail<AuthResult, AuthError>(AuthErrorFactory.Failed("Account not found in token cache."));
 
-            var msalResult = await app.AcquireTokenSilent(Scopes, account).ExecuteAsync(ct).ConfigureAwait(false);
+            var msalResult = await app.AcquireTokenSilent(Scopes, account).ExecuteAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<AuthResult, AuthError>(BuildAuthResult(msalResult));
         }
@@ -70,7 +70,7 @@ public async Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string
     }
 
     /// <inheritdoc />
-    public async Task SignOutAsync(string accountId, CancellationToken ct = default)
+    public async Task SignOutAsync(string accountId, CancellationToken cancellationToken = default)
     {
         var accounts = await app.GetAccountsAsync().ConfigureAwait(false);
         var account = accounts.FirstOrDefault(a => a.HomeAccountId?.Identifier == accountId);
@@ -83,7 +83,7 @@ public async Task<IReadOnlyList<string>> GetCachedAccountIdsAsync()
     {
         var accounts = await app.GetAccountsAsync().ConfigureAwait(false);
 
-        return accounts.Select(a => a.HomeAccountId.Identifier).ToList();
+        return [.. accounts.Where(a => a.HomeAccountId is not null).Select(a => a.HomeAccountId!.Identifier)];
     }
 
     private static AuthResult BuildAuthResult(AuthenticationResult result)
@@ -96,7 +96,7 @@ private static AuthResult BuildAuthResult(AuthenticationResult result)
         return AuthResultFactory.Create(
             result.AccessToken,
             result.Account.HomeAccountId.Identifier,
-            new AccountProfile(displayName, email),
+            AccountProfileFactory.Create(displayName, email),
             result.ExpiresOn);
     }
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/DriveId.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/DriveId.cs
new file mode 100644
index 0000000..cd6344e
--- /dev/null
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/DriveId.cs
@@ -0,0 +1,15 @@
+namespace AStar.Dev.CloudSyncFunctional.Auth;
+
+/// <summary>
+/// Strongly-typed wrapper for a Graph drive identifier, which is used to uniquely identify a OneDrive drive or folder across API calls and app sessions.
+/// </summary>
+/// <param name="Value">The drive identifier.</param>
+public sealed record DriveId(string Value)
+{
+    /// <summary>
+    /// Creates a new <see cref="DriveId"/> instance with the specified value.
+    /// </summary>
+    /// <param name="value">The string value to create the DriveId from.</param>
+    /// <returns>The created DriveId.</returns>
+    public static DriveId Create(string value) => new(value);
+}
\ No newline at end of file
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
index aa12414..0f5fd96 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
@@ -6,21 +6,21 @@ namespace AStar.Dev.CloudSyncFunctional.Auth;
 public interface IAuthService
 {
     /// <summary>Opens an interactive browser sign-in and returns the authenticated result.</summary>
-    /// <param name="ct">Token to cancel the operation.</param>
+    /// <param name="cancellationToken">Token to cancel the operation.</param>
     /// <returns>An <see cref="AuthResult"/> on success, or an <see cref="AuthError"/> on failure.</returns>
-    Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(CancellationToken ct = default);
+    Task<Result<AuthResult, AuthError>> SignInInteractiveAsync(CancellationToken cancellationToken = default);
 
     /// <summary>Silently acquires a new access token for an existing cached account.</summary>
     /// <param name="accountId">The MSAL HomeAccountId identifier.</param>
-    /// <param name="ct">Token to cancel the operation.</param>
+    /// <param name="cancellationToken">Token to cancel the operation.</param>
     /// <returns>An <see cref="AuthResult"/> on success, or an <see cref="AuthError"/> on failure.</returns>
-    Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string accountId, CancellationToken ct = default);
+    Task<Result<AuthResult, AuthError>> AcquireTokenSilentAsync(string accountId, CancellationToken cancellationToken = default);
 
     /// <summary>Signs out and removes the account from the token cache.</summary>
     /// <param name="accountId">The MSAL HomeAccountId identifier.</param>
-    /// <param name="ct">Token to cancel the operation.</param>
+    /// <param name="cancellationToken">Token to cancel the operation.</param>
     /// <returns>A task that completes when sign-out is done.</returns>
-    Task SignOutAsync(string accountId, CancellationToken ct = default);
+    Task SignOutAsync(string accountId, CancellationToken cancellationToken = default);
 
     /// <summary>Returns the list of account IDs currently in the token cache.</summary>
     /// <returns>A read-only list of MSAL HomeAccountId identifiers.</returns>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs
index fa26a4c..8cc4393 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs
@@ -7,7 +7,7 @@ public interface ITokenCacheService
 {
     /// <summary>Registers the cache helper with the given MSAL application.</summary>
     /// <param name="app">The MSAL application whose token cache is registered.</param>
-    /// <param name="ct">Token to cancel the operation.</param>
+    /// <param name="cancellationToken">Token to cancel the operation.</param>
     /// <returns>A task that completes when registration is done.</returns>
-    Task RegisterAsync(IPublicClientApplication app, CancellationToken ct = default);
+    Task RegisterAsync(IPublicClientApplication app, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/TokenCacheService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/TokenCacheService.cs
index ecafc16..0346915 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/TokenCacheService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/TokenCacheService.cs
@@ -15,7 +15,7 @@ public sealed partial class TokenCacheService(ILogger<TokenCacheService> logger)
     private static readonly string CacheDir = BuildCacheDir();
 
     /// <inheritdoc />
-    public async Task RegisterAsync(IPublicClientApplication app, CancellationToken ct = default)
+    public async Task RegisterAsync(IPublicClientApplication app, CancellationToken cancellationToken = default)
     {
         try
         {
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml b/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml
index 59b31ff..f26c872 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml
@@ -25,9 +25,9 @@
                            FontSize="12.5"/>
             </StackPanel>
             <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="6" VerticalAlignment="Center">
-                <controls:AppButton x:Name="PauseButton" Kind="Ghost" ButtonSize="Sm" Label="Pause"/>
-                <controls:AppButton x:Name="SettingsButton" Kind="Ghost" ButtonSize="Sm" Label="Settings"/>
-                <controls:AppButton x:Name="MoreButton" Kind="Subtle" ButtonSize="Sm" Label="⋯"/>
+                <controls:AppButton x:Name="PauseButton" Kind="Ghost" ButtonSize="Small" Label="Pause"/>
+                <controls:AppButton x:Name="SettingsButton" Kind="Ghost" ButtonSize="Small" Label="Settings"/>
+                <controls:AppButton x:Name="MoreButton" Kind="Subtle" ButtonSize="Small" Label="⋯"/>
             </StackPanel>
         </Grid>
     </Border>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml.cs
index 95b7fea..dcddbbe 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/AccountHeader.axaml.cs
@@ -10,32 +10,25 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class AccountHeader : UserControl
 {
     /// <summary>Identifies the <see cref="AccountName"/> styled property.</summary>
-    public static readonly StyledProperty<string> AccountNameProperty =
-        AvaloniaProperty.Register<AccountHeader, string>(nameof(AccountName), string.Empty);
+    public static readonly StyledProperty<string> AccountNameProperty = AvaloniaProperty.Register<AccountHeader, string>(nameof(AccountName), string.Empty);
 
     /// <summary>Identifies the <see cref="Email"/> styled property.</summary>
-    public static readonly StyledProperty<string> EmailProperty =
-        AvaloniaProperty.Register<AccountHeader, string>(nameof(Email), string.Empty);
+    public static readonly StyledProperty<string> EmailProperty = AvaloniaProperty.Register<AccountHeader, string>(nameof(Email), string.Empty);
 
     /// <summary>Identifies the <see cref="Kind"/> styled property.</summary>
-    public static readonly StyledProperty<ProviderKind> KindProperty =
-        AvaloniaProperty.Register<AccountHeader, ProviderKind>(nameof(Kind));
+    public static readonly StyledProperty<ProviderKind> KindProperty = AvaloniaProperty.Register<AccountHeader, ProviderKind>(nameof(Kind));
 
     /// <summary>Identifies the <see cref="Status"/> styled property.</summary>
-    public static readonly StyledProperty<SyncStatus> StatusProperty =
-        AvaloniaProperty.Register<AccountHeader, SyncStatus>(nameof(Status));
+    public static readonly StyledProperty<SyncStatus> StatusProperty = AvaloniaProperty.Register<AccountHeader, SyncStatus>(nameof(Status));
 
     /// <summary>Identifies the <see cref="PauseCommand"/> styled property.</summary>
-    public static readonly StyledProperty<ICommand?> PauseCommandProperty =
-        AvaloniaProperty.Register<AccountHeader, ICommand?>(nameof(PauseCommand));
+    public static readonly StyledProperty<ICommand?> PauseCommandProperty = AvaloniaProperty.Register<AccountHeader, ICommand?>(nameof(PauseCommand));
 
     /// <summary>Identifies the <see cref="SettingsCommand"/> styled property.</summary>
-    public static readonly StyledProperty<ICommand?> SettingsCommandProperty =
-        AvaloniaProperty.Register<AccountHeader, ICommand?>(nameof(SettingsCommand));
+    public static readonly StyledProperty<ICommand?> SettingsCommandProperty = AvaloniaProperty.Register<AccountHeader, ICommand?>(nameof(SettingsCommand));
 
     /// <summary>Identifies the <see cref="MoreCommand"/> styled property.</summary>
-    public static readonly StyledProperty<ICommand?> MoreCommandProperty =
-        AvaloniaProperty.Register<AccountHeader, ICommand?>(nameof(MoreCommand));
+    public static readonly StyledProperty<ICommand?> MoreCommandProperty = AvaloniaProperty.Register<AccountHeader, ICommand?>(nameof(MoreCommand));
 
     /// <summary>Gets or sets the display name of the account.</summary>
     public string AccountName
@@ -118,7 +111,7 @@ public static string GetProviderDisplayName(ProviderKind kind) =>
     protected override void OnInitialized()
     {
         base.OnInitialized();
-        updateBorder();
+        UpdateBorder();
         updateProviderMark();
         updateNameText();
         updateProviderNameText();
@@ -138,7 +131,7 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
         if (change.Property == PauseCommandProperty || change.Property == SettingsCommandProperty || change.Property == MoreCommandProperty) updateButtons();
     }
 
-    private void updateBorder()
+    private void UpdateBorder()
     {
         if (ContainerBorder is null) return;
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/AccountListItem.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/AccountListItem.axaml.cs
index d5a5084..69ae648 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/AccountListItem.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/AccountListItem.axaml.cs
@@ -9,36 +9,28 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class AccountListItem : UserControl
 {
     /// <summary>Identifies the <see cref="AccountName"/> styled property.</summary>
-    public static readonly StyledProperty<string> AccountNameProperty =
-        AvaloniaProperty.Register<AccountListItem, string>(nameof(AccountName), string.Empty);
+    public static readonly StyledProperty<string> AccountNameProperty = AvaloniaProperty.Register<AccountListItem, string>(nameof(AccountName), string.Empty);
 
     /// <summary>Identifies the <see cref="Email"/> styled property.</summary>
-    public static readonly StyledProperty<string> EmailProperty =
-        AvaloniaProperty.Register<AccountListItem, string>(nameof(Email), string.Empty);
+    public static readonly StyledProperty<string> EmailProperty = AvaloniaProperty.Register<AccountListItem, string>(nameof(Email), string.Empty);
 
     /// <summary>Identifies the <see cref="Kind"/> styled property.</summary>
-    public static readonly StyledProperty<ProviderKind> KindProperty =
-        AvaloniaProperty.Register<AccountListItem, ProviderKind>(nameof(Kind));
+    public static readonly StyledProperty<ProviderKind> KindProperty = AvaloniaProperty.Register<AccountListItem, ProviderKind>(nameof(Kind));
 
     /// <summary>Identifies the <see cref="UsedBytes"/> styled property.</summary>
-    public static readonly StyledProperty<long> UsedBytesProperty =
-        AvaloniaProperty.Register<AccountListItem, long>(nameof(UsedBytes));
+    public static readonly StyledProperty<long> UsedBytesProperty = AvaloniaProperty.Register<AccountListItem, long>(nameof(UsedBytes));
 
     /// <summary>Identifies the <see cref="TotalBytes"/> styled property.</summary>
-    public static readonly StyledProperty<long> TotalBytesProperty =
-        AvaloniaProperty.Register<AccountListItem, long>(nameof(TotalBytes));
+    public static readonly StyledProperty<long> TotalBytesProperty = AvaloniaProperty.Register<AccountListItem, long>(nameof(TotalBytes));
 
     /// <summary>Identifies the <see cref="FolderCount"/> styled property.</summary>
-    public static readonly StyledProperty<int> FolderCountProperty =
-        AvaloniaProperty.Register<AccountListItem, int>(nameof(FolderCount));
+    public static readonly StyledProperty<int> FolderCountProperty = AvaloniaProperty.Register<AccountListItem, int>(nameof(FolderCount));
 
     /// <summary>Identifies the <see cref="Status"/> styled property.</summary>
-    public static readonly StyledProperty<SyncStatus> StatusProperty =
-        AvaloniaProperty.Register<AccountListItem, SyncStatus>(nameof(Status));
+    public static readonly StyledProperty<SyncStatus> StatusProperty = AvaloniaProperty.Register<AccountListItem, SyncStatus>(nameof(Status));
 
     /// <summary>Identifies the <see cref="IsSelected"/> styled property.</summary>
-    public static readonly StyledProperty<bool> IsSelectedProperty =
-        AvaloniaProperty.Register<AccountListItem, bool>(nameof(IsSelected));
+    public static readonly StyledProperty<bool> IsSelectedProperty = AvaloniaProperty.Register<AccountListItem, bool>(nameof(IsSelected));
 
     /// <summary>Gets or sets the display name of the account.</summary>
     public string AccountName
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/AppButton.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/AppButton.axaml.cs
index 4698fee..d9a6d43 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/AppButton.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/AppButton.axaml.cs
@@ -9,28 +9,22 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class AppButton : UserControl
 {
     /// <summary>Identifies the <see cref="Kind"/> styled property.</summary>
-    public static readonly StyledProperty<AppButtonKind> KindProperty =
-        AvaloniaProperty.Register<AppButton, AppButtonKind>(nameof(Kind), AppButtonKind.Primary);
+    public static readonly StyledProperty<AppButtonKind> KindProperty = AvaloniaProperty.Register<AppButton, AppButtonKind>(nameof(Kind), AppButtonKind.Primary);
 
     /// <summary>Identifies the <see cref="ButtonSize"/> styled property.</summary>
-    public static readonly StyledProperty<AppButtonSize> ButtonSizeProperty =
-        AvaloniaProperty.Register<AppButton, AppButtonSize>(nameof(ButtonSize), AppButtonSize.Md);
+    public static readonly StyledProperty<AppButtonSize> ButtonSizeProperty = AvaloniaProperty.Register<AppButton, AppButtonSize>(nameof(ButtonSize), AppButtonSize.Medium);
 
     /// <summary>Identifies the <see cref="Label"/> styled property.</summary>
-    public static readonly StyledProperty<string> LabelProperty =
-        AvaloniaProperty.Register<AppButton, string>(nameof(Label), string.Empty);
+    public static readonly StyledProperty<string> LabelProperty = AvaloniaProperty.Register<AppButton, string>(nameof(Label), string.Empty);
 
     /// <summary>Identifies the <see cref="LeadingIcon"/> styled property.</summary>
-    public static readonly StyledProperty<Geometry?> LeadingIconProperty =
-        AvaloniaProperty.Register<AppButton, Geometry?>(nameof(LeadingIcon));
+    public static readonly StyledProperty<Geometry?> LeadingIconProperty = AvaloniaProperty.Register<AppButton, Geometry?>(nameof(LeadingIcon));
 
     /// <summary>Identifies the <see cref="TrailingIcon"/> styled property.</summary>
-    public static readonly StyledProperty<Geometry?> TrailingIconProperty =
-        AvaloniaProperty.Register<AppButton, Geometry?>(nameof(TrailingIcon));
+    public static readonly StyledProperty<Geometry?> TrailingIconProperty = AvaloniaProperty.Register<AppButton, Geometry?>(nameof(TrailingIcon));
 
     /// <summary>Identifies the <see cref="Command"/> styled property.</summary>
-    public static readonly StyledProperty<ICommand?> CommandProperty =
-        AvaloniaProperty.Register<AppButton, ICommand?>(nameof(Command));
+    public static readonly StyledProperty<ICommand?> CommandProperty = AvaloniaProperty.Register<AppButton, ICommand?>(nameof(Command));
 
     /// <summary>Gets or sets the visual style variant.</summary>
     public AppButtonKind Kind
@@ -132,15 +126,15 @@ private void ApplyKind()
         }
     }
 
-    private void SetButtonAppearance(string? bgKey, string? fgKey, string? borderKey, int borderThickness)
+    private void SetButtonAppearance(string? backgroundKey, string? foregroundKey, string? borderKey, int borderThickness)
     {
         if (InnerButton is null) return;
 
-        InnerButton.Background = bgKey is not null && this.TryFindResource(bgKey, out var bg) && bg is IBrush bgBrush
+        InnerButton.Background = backgroundKey is not null && this.TryFindResource(backgroundKey, out var bg) && bg is IBrush bgBrush
             ? bgBrush
             : Brushes.Transparent;
 
-        InnerButton.Foreground = fgKey is not null && this.TryFindResource(fgKey, out var fg) && fg is IBrush fgBrush
+        InnerButton.Foreground = foregroundKey is not null && this.TryFindResource(foregroundKey, out var fg) && fg is IBrush fgBrush
             ? fgBrush
             : Brushes.White;
 
@@ -156,8 +150,8 @@ private void ApplySize()
 
         var (height, fontSize) = ButtonSize switch
         {
-            AppButtonSize.Sm => (26.0, 12.0),
-            AppButtonSize.Lg => (38.0, 13.0),
+            AppButtonSize.Small => (26.0, 12.0),
+            AppButtonSize.Large => (38.0, 13.0),
             _ => (32.0, 12.5)
         };
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/AppButtonSize.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/AppButtonSize.cs
index 3e9dfa8..7a963b3 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/AppButtonSize.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/AppButtonSize.cs
@@ -1,4 +1,4 @@
 namespace AStar.Dev.CloudSyncFunctional.Controls;
 
 /// <summary>Height preset for <see cref="AppButton"/>.</summary>
-public enum AppButtonSize { Sm, Md, Lg }
+public enum AppButtonSize { Small, Medium, Large }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml b/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml
index 5e80e5c..4ddc8b9 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml
@@ -13,8 +13,8 @@
                        VerticalAlignment="Center"/>
             <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
                 <controls:StatusPill x:Name="SelectionPill"/>
-                <controls:AppButton x:Name="FilterButton" Kind="Ghost" ButtonSize="Sm" Label="Filter"/>
-                <controls:AppButton x:Name="ApplyButton" Kind="Primary" ButtonSize="Sm" Label="Apply Changes"/>
+                <controls:AppButton x:Name="FilterButton" Kind="Ghost" ButtonSize="Small" Label="Filter"/>
+                <controls:AppButton x:Name="ApplyButton" Kind="Primary" ButtonSize="Small" Label="Apply Changes"/>
             </StackPanel>
         </Grid>
     </Border>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml.cs
index 7d6c407..c3339e7 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/FolderToolbar.axaml.cs
@@ -9,24 +9,19 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class FolderToolbar : UserControl
 {
     /// <summary>Identifies the <see cref="BreadcrumbPath"/> styled property.</summary>
-    public static readonly StyledProperty<string> BreadcrumbPathProperty =
-        AvaloniaProperty.Register<FolderToolbar, string>(nameof(BreadcrumbPath), "~/AStar /");
+    public static readonly StyledProperty<string> BreadcrumbPathProperty = AvaloniaProperty.Register<FolderToolbar, string>(nameof(BreadcrumbPath), "~/AStar /");
 
     /// <summary>Identifies the <see cref="SelectionSummary"/> styled property.</summary>
-    public static readonly StyledProperty<string> SelectionSummaryProperty =
-        AvaloniaProperty.Register<FolderToolbar, string>(nameof(SelectionSummary), string.Empty);
+    public static readonly StyledProperty<string> SelectionSummaryProperty = AvaloniaProperty.Register<FolderToolbar, string>(nameof(SelectionSummary), string.Empty);
 
     /// <summary>Identifies the <see cref="CanApplyChanges"/> styled property.</summary>
-    public static readonly StyledProperty<bool> CanApplyChangesProperty =
-        AvaloniaProperty.Register<FolderToolbar, bool>(nameof(CanApplyChanges), false);
+    public static readonly StyledProperty<bool> CanApplyChangesProperty = AvaloniaProperty.Register<FolderToolbar, bool>(nameof(CanApplyChanges), false);
 
     /// <summary>Identifies the <see cref="FilterCommand"/> styled property.</summary>
-    public static readonly StyledProperty<ICommand?> FilterCommandProperty =
-        AvaloniaProperty.Register<FolderToolbar, ICommand?>(nameof(FilterCommand));
+    public static readonly StyledProperty<ICommand?> FilterCommandProperty = AvaloniaProperty.Register<FolderToolbar, ICommand?>(nameof(FilterCommand));
 
     /// <summary>Identifies the <see cref="ApplyChangesCommand"/> styled property.</summary>
-    public static readonly StyledProperty<ICommand?> ApplyChangesCommandProperty =
-        AvaloniaProperty.Register<FolderToolbar, ICommand?>(nameof(ApplyChangesCommand));
+    public static readonly StyledProperty<ICommand?> ApplyChangesCommandProperty = AvaloniaProperty.Register<FolderToolbar, ICommand?>(nameof(ApplyChangesCommand));
 
     /// <summary>Gets or sets the breadcrumb path text displayed on the left.</summary>
     public string BreadcrumbPath
@@ -70,24 +65,24 @@ public ICommand? ApplyChangesCommand
     protected override void OnInitialized()
     {
         base.OnInitialized();
-        updateBorder();
-        updateBreadcrumb();
-        updateSelectionPill();
-        updateApplyButton();
-        updateCommands();
+        UpdateBorder();
+        UpdateBreadcrumb();
+        UpdateSelectionPill();
+        UpdateApplyButton();
+        UpdateCommands();
     }
 
     /// <inheritdoc/>
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
         base.OnPropertyChanged(change);
-        if (change.Property == BreadcrumbPathProperty) updateBreadcrumb();
-        if (change.Property == SelectionSummaryProperty) updateSelectionPill();
-        if (change.Property == CanApplyChangesProperty) updateApplyButton();
-        if (change.Property == FilterCommandProperty || change.Property == ApplyChangesCommandProperty) updateCommands();
+        if (change.Property == BreadcrumbPathProperty) UpdateBreadcrumb();
+        if (change.Property == SelectionSummaryProperty) UpdateSelectionPill();
+        if (change.Property == CanApplyChangesProperty) UpdateApplyButton();
+        if (change.Property == FilterCommandProperty || change.Property == ApplyChangesCommandProperty) UpdateCommands();
     }
 
-    private void updateBorder()
+    private void UpdateBorder()
     {
         if (ContainerBorder is null) return;
 
@@ -95,7 +90,7 @@ private void updateBorder()
             ContainerBorder.BorderBrush = borderBrush;
     }
 
-    private void updateBreadcrumb()
+    private void UpdateBreadcrumb()
     {
         if (BreadcrumbText is null) return;
 
@@ -105,7 +100,7 @@ private void updateBreadcrumb()
             BreadcrumbText.Foreground = brush;
     }
 
-    private void updateSelectionPill()
+    private void UpdateSelectionPill()
     {
         if (SelectionPill is null) return;
 
@@ -113,14 +108,14 @@ private void updateSelectionPill()
         SelectionPill.IsVisible = !string.IsNullOrEmpty(SelectionSummary);
     }
 
-    private void updateApplyButton()
+    private void UpdateApplyButton()
     {
         if (ApplyButton is null) return;
 
         ApplyButton.IsEnabled = CanApplyChanges;
     }
 
-    private void updateCommands()
+    private void UpdateCommands()
     {
         if (FilterButton is null || ApplyButton is null) return;
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/FolderTreeRow.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/FolderTreeRow.axaml.cs
index 6d8de5d..1af55a2 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/FolderTreeRow.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/FolderTreeRow.axaml.cs
@@ -14,40 +14,31 @@ public partial class FolderTreeRow : UserControl
     private const long MegaByte = 1_048_576L;
 
     /// <summary>Identifies the <see cref="NodeName"/> styled property.</summary>
-    public static readonly StyledProperty<string> NodeNameProperty =
-        AvaloniaProperty.Register<FolderTreeRow, string>(nameof(NodeName), string.Empty);
+    public static readonly StyledProperty<string> NodeNameProperty = AvaloniaProperty.Register<FolderTreeRow, string>(nameof(NodeName), string.Empty);
 
     /// <summary>Identifies the <see cref="Depth"/> styled property.</summary>
-    public static readonly StyledProperty<int> DepthProperty =
-        AvaloniaProperty.Register<FolderTreeRow, int>(nameof(Depth));
+    public static readonly StyledProperty<int> DepthProperty = AvaloniaProperty.Register<FolderTreeRow, int>(nameof(Depth));
 
     /// <summary>Identifies the <see cref="ChildCount"/> styled property.</summary>
-    public static readonly StyledProperty<int> ChildCountProperty =
-        AvaloniaProperty.Register<FolderTreeRow, int>(nameof(ChildCount));
+    public static readonly StyledProperty<int> ChildCountProperty = AvaloniaProperty.Register<FolderTreeRow, int>(nameof(ChildCount));
 
     /// <summary>Identifies the <see cref="SizeBytes"/> styled property.</summary>
-    public static readonly StyledProperty<long> SizeBytesProperty =
-        AvaloniaProperty.Register<FolderTreeRow, long>(nameof(SizeBytes));
+    public static readonly StyledProperty<long> SizeBytesProperty = AvaloniaProperty.Register<FolderTreeRow, long>(nameof(SizeBytes));
 
     /// <summary>Identifies the <see cref="LastSync"/> styled property.</summary>
-    public static readonly StyledProperty<DateTimeOffset> LastSyncProperty =
-        AvaloniaProperty.Register<FolderTreeRow, DateTimeOffset>(nameof(LastSync));
+    public static readonly StyledProperty<DateTimeOffset> LastSyncProperty = AvaloniaProperty.Register<FolderTreeRow, DateTimeOffset>(nameof(LastSync));
 
     /// <summary>Identifies the <see cref="SelectionState"/> styled property.</summary>
-    public static readonly StyledProperty<CheckState> SelectionStateProperty =
-        AvaloniaProperty.Register<FolderTreeRow, CheckState>(nameof(SelectionState));
+    public static readonly StyledProperty<CheckState> SelectionStateProperty = AvaloniaProperty.Register<FolderTreeRow, CheckState>(nameof(SelectionState));
 
     /// <summary>Identifies the <see cref="IsExpanded"/> styled property.</summary>
-    public static readonly StyledProperty<bool> IsExpandedProperty =
-        AvaloniaProperty.Register<FolderTreeRow, bool>(nameof(IsExpanded));
+    public static readonly StyledProperty<bool> IsExpandedProperty = AvaloniaProperty.Register<FolderTreeRow, bool>(nameof(IsExpanded));
 
     /// <summary>Identifies the <see cref="IsSyncing"/> styled property.</summary>
-    public static readonly StyledProperty<bool> IsSyncingProperty =
-        AvaloniaProperty.Register<FolderTreeRow, bool>(nameof(IsSyncing));
+    public static readonly StyledProperty<bool> IsSyncingProperty = AvaloniaProperty.Register<FolderTreeRow, bool>(nameof(IsSyncing));
 
     /// <summary>Identifies the <see cref="HasChildren"/> styled property.</summary>
-    public static readonly StyledProperty<bool> HasChildrenProperty =
-        AvaloniaProperty.Register<FolderTreeRow, bool>(nameof(HasChildren));
+    public static readonly StyledProperty<bool> HasChildrenProperty = AvaloniaProperty.Register<FolderTreeRow, bool>(nameof(HasChildren));
 
     /// <summary>Gets or sets the display name of the folder.</summary>
     public string NodeName
@@ -263,9 +254,9 @@ private void UpdateColors()
 
         if (ink3Brush is null) return;
 
-        if (ItemCountText is not null) ItemCountText.Foreground = ink3Brush;
-        if (SizeText is not null) SizeText.Foreground = ink3Brush;
-        if (UpdatedText is not null) UpdatedText.Foreground = ink3Brush;
+        ItemCountText?.Foreground = ink3Brush;
+        SizeText?.Foreground = ink3Brush;
+        UpdatedText?.Foreground = ink3Brush;
     }
 
     private void UpdateIndent()
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/ProviderMark.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/ProviderMark.axaml.cs
index 759ff56..4187f8a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/ProviderMark.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/ProviderMark.axaml.cs
@@ -9,12 +9,10 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class ProviderMark : UserControl
 {
     /// <summary>Identifies the <see cref="Kind"/> styled property.</summary>
-    public static readonly StyledProperty<ProviderKind> KindProperty =
-        AvaloniaProperty.Register<ProviderMark, ProviderKind>(nameof(Kind));
+    public static readonly StyledProperty<ProviderKind> KindProperty = AvaloniaProperty.Register<ProviderMark, ProviderKind>(nameof(Kind));
 
     /// <summary>Identifies the <see cref="Size"/> styled property.</summary>
-    public static readonly StyledProperty<double> SizeProperty =
-        AvaloniaProperty.Register<ProviderMark, double>(nameof(Size), 26.0);
+    public static readonly StyledProperty<double> SizeProperty = AvaloniaProperty.Register<ProviderMark, double>(nameof(Size), 26.0);
 
     /// <summary>Gets or sets the cloud provider this mark represents.</summary>
     public ProviderKind Kind
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/StatusBar.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/StatusBar.axaml.cs
index 2616b3d..3e4c2d6 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/StatusBar.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/StatusBar.axaml.cs
@@ -8,28 +8,22 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class StatusBar : UserControl
 {
     /// <summary>Identifies the <see cref="HealthText"/> styled property.</summary>
-    public static readonly StyledProperty<string> HealthTextProperty =
-        AvaloniaProperty.Register<StatusBar, string>(nameof(HealthText), "All accounts healthy");
+    public static readonly StyledProperty<string> HealthTextProperty = AvaloniaProperty.Register<StatusBar, string>(nameof(HealthText), "All accounts healthy");
 
     /// <summary>Identifies the <see cref="UploadRate"/> styled property.</summary>
-    public static readonly StyledProperty<string> UploadRateProperty =
-        AvaloniaProperty.Register<StatusBar, string>(nameof(UploadRate), "↑ 0 B/s");
+    public static readonly StyledProperty<string> UploadRateProperty = AvaloniaProperty.Register<StatusBar, string>(nameof(UploadRate), "↑ 0 B/s");
 
     /// <summary>Identifies the <see cref="DownloadRate"/> styled property.</summary>
-    public static readonly StyledProperty<string> DownloadRateProperty =
-        AvaloniaProperty.Register<StatusBar, string>(nameof(DownloadRate), "↓ 0 B/s");
+    public static readonly StyledProperty<string> DownloadRateProperty = AvaloniaProperty.Register<StatusBar, string>(nameof(DownloadRate), "↓ 0 B/s");
 
     /// <summary>Identifies the <see cref="QueueSummary"/> styled property.</summary>
-    public static readonly StyledProperty<string> QueueSummaryProperty =
-        AvaloniaProperty.Register<StatusBar, string>(nameof(QueueSummary), string.Empty);
+    public static readonly StyledProperty<string> QueueSummaryProperty = AvaloniaProperty.Register<StatusBar, string>(nameof(QueueSummary), string.Empty);
 
     /// <summary>Identifies the <see cref="Version"/> styled property.</summary>
-    public static readonly StyledProperty<string> VersionProperty =
-        AvaloniaProperty.Register<StatusBar, string>(nameof(Version), string.Empty);
+    public static readonly StyledProperty<string> VersionProperty = AvaloniaProperty.Register<StatusBar, string>(nameof(Version), string.Empty);
 
     /// <summary>Identifies the <see cref="IsHealthy"/> styled property.</summary>
-    public static readonly StyledProperty<bool> IsHealthyProperty =
-        AvaloniaProperty.Register<StatusBar, bool>(nameof(IsHealthy), true);
+    public static readonly StyledProperty<bool> IsHealthyProperty = AvaloniaProperty.Register<StatusBar, bool>(nameof(IsHealthy), true);
 
     /// <summary>Gets or sets the health status text.</summary>
     public string HealthText
@@ -80,29 +74,29 @@ public bool IsHealthy
     protected override void OnInitialized()
     {
         base.OnInitialized();
-        updateBackground();
-        updateBorder();
-        updateHealthDot();
-        updateHealthText();
-        updateUploadText();
-        updateDownloadText();
-        updateQueueText();
-        updateVersionText();
+        UpdateBackground();
+        UpdateBorder();
+        UpdateHealthDot();
+        UpdateHealthText();
+        UpdateUploadText();
+        UpdateDownloadText();
+        UpdateQueueText();
+        UpdateVersionText();
     }
 
     /// <inheritdoc/>
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
         base.OnPropertyChanged(change);
-        if (change.Property == IsHealthyProperty) updateHealthDot();
-        if (change.Property == HealthTextProperty) updateHealthText();
-        if (change.Property == UploadRateProperty) updateUploadText();
-        if (change.Property == DownloadRateProperty) updateDownloadText();
-        if (change.Property == QueueSummaryProperty) updateQueueText();
-        if (change.Property == VersionProperty) updateVersionText();
+        if (change.Property == IsHealthyProperty) UpdateHealthDot();
+        if (change.Property == HealthTextProperty) UpdateHealthText();
+        if (change.Property == UploadRateProperty) UpdateUploadText();
+        if (change.Property == DownloadRateProperty) UpdateDownloadText();
+        if (change.Property == QueueSummaryProperty) UpdateQueueText();
+        if (change.Property == VersionProperty) UpdateVersionText();
     }
 
-    private void updateBackground()
+    private void UpdateBackground()
     {
         if (ContainerBorder is null) return;
 
@@ -110,7 +104,7 @@ private void updateBackground()
             ContainerBorder.Background = brush;
     }
 
-    private void updateBorder()
+    private void UpdateBorder()
     {
         if (ContainerBorder is null) return;
 
@@ -118,7 +112,7 @@ private void updateBorder()
             ContainerBorder.BorderBrush = borderBrush;
     }
 
-    private void updateHealthDot()
+    private void UpdateHealthDot()
     {
         if (HealthDot is null) return;
 
@@ -129,7 +123,7 @@ private void updateHealthDot()
             : null;
     }
 
-    private void updateHealthText()
+    private void UpdateHealthText()
     {
         if (HealthTextBlock is null) return;
 
@@ -139,7 +133,7 @@ private void updateHealthText()
             HealthTextBlock.Foreground = brush;
     }
 
-    private void updateUploadText()
+    private void UpdateUploadText()
     {
         if (UploadText is null) return;
 
@@ -149,7 +143,7 @@ private void updateUploadText()
             UploadText.Foreground = brush;
     }
 
-    private void updateDownloadText()
+    private void UpdateDownloadText()
     {
         if (DownloadText is null) return;
 
@@ -159,7 +153,7 @@ private void updateDownloadText()
             DownloadText.Foreground = brush;
     }
 
-    private void updateQueueText()
+    private void UpdateQueueText()
     {
         if (QueueText is null) return;
 
@@ -169,7 +163,7 @@ private void updateQueueText()
             QueueText.Foreground = brush;
     }
 
-    private void updateVersionText()
+    private void UpdateVersionText()
     {
         if (VersionText is null) return;
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/StatusDot.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/StatusDot.axaml.cs
index 4f1b618..7c386c6 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/StatusDot.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/StatusDot.axaml.cs
@@ -8,12 +8,10 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class StatusDot : UserControl
 {
     /// <summary>Identifies the <see cref="Fill"/> styled property.</summary>
-    public static readonly StyledProperty<IBrush?> FillProperty =
-        AvaloniaProperty.Register<StatusDot, IBrush?>(nameof(Fill));
+    public static readonly StyledProperty<IBrush?> FillProperty = AvaloniaProperty.Register<StatusDot, IBrush?>(nameof(Fill));
 
     /// <summary>Identifies the <see cref="IsPulsing"/> styled property.</summary>
-    public static readonly StyledProperty<bool> IsPulsingProperty =
-        AvaloniaProperty.Register<StatusDot, bool>(nameof(IsPulsing));
+    public static readonly StyledProperty<bool> IsPulsingProperty = AvaloniaProperty.Register<StatusDot, bool>(nameof(IsPulsing));
 
     /// <summary>Gets or sets the fill brush for the dot.</summary>
     public IBrush? Fill
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/StatusPill.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/StatusPill.axaml.cs
index 706d094..41462a5 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/StatusPill.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/StatusPill.axaml.cs
@@ -8,12 +8,10 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class StatusPill : UserControl
 {
     /// <summary>Identifies the <see cref="Label"/> styled property.</summary>
-    public static readonly StyledProperty<string> LabelProperty =
-        AvaloniaProperty.Register<StatusPill, string>(nameof(Label), string.Empty);
+    public static readonly StyledProperty<string> LabelProperty = AvaloniaProperty.Register<StatusPill, string>(nameof(Label), string.Empty);
 
     /// <summary>Identifies the <see cref="Tone"/> styled property.</summary>
-    public static readonly StyledProperty<Tone> ToneProperty =
-        AvaloniaProperty.Register<StatusPill, Tone>(nameof(Tone), Tone.Neutral);
+    public static readonly StyledProperty<Tone> ToneProperty = AvaloniaProperty.Register<StatusPill, Tone>(nameof(Tone), Tone.Neutral);
 
     /// <summary>Gets or sets the display text for the pill.</summary>
     public string Label
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/StorageBar.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/StorageBar.axaml.cs
index 202c39e..52ab170 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/StorageBar.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/StorageBar.axaml.cs
@@ -9,16 +9,13 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class StorageBar : UserControl
 {
     /// <summary>Identifies the <see cref="Used"/> styled property.</summary>
-    public static readonly StyledProperty<double> UsedProperty =
-        AvaloniaProperty.Register<StorageBar, double>(nameof(Used));
+    public static readonly StyledProperty<double> UsedProperty = AvaloniaProperty.Register<StorageBar, double>(nameof(Used));
 
     /// <summary>Identifies the <see cref="Total"/> styled property.</summary>
-    public static readonly StyledProperty<double> TotalProperty =
-        AvaloniaProperty.Register<StorageBar, double>(nameof(Total));
+    public static readonly StyledProperty<double> TotalProperty = AvaloniaProperty.Register<StorageBar, double>(nameof(Total));
 
     /// <summary>Identifies the <see cref="BarColor"/> styled property.</summary>
-    public static readonly StyledProperty<IBrush?> BarColorProperty =
-        AvaloniaProperty.Register<StorageBar, IBrush?>(nameof(BarColor));
+    public static readonly StyledProperty<IBrush?> BarColorProperty = AvaloniaProperty.Register<StorageBar, IBrush?>(nameof(BarColor));
 
     /// <summary>Gets or sets the bytes currently used.</summary>
     public double Used
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/SubTabBar.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/SubTabBar.axaml.cs
index ac2fc3c..f5786ee 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/SubTabBar.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/SubTabBar.axaml.cs
@@ -9,12 +9,10 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class SubTabBar : UserControl
 {
     /// <summary>Identifies the <see cref="SelectedTab"/> styled property.</summary>
-    public static readonly StyledProperty<SubTab> SelectedTabProperty =
-        AvaloniaProperty.Register<SubTabBar, SubTab>(nameof(SelectedTab), SubTab.SyncFolders);
+    public static readonly StyledProperty<SubTab> SelectedTabProperty = AvaloniaProperty.Register<SubTabBar, SubTab>(nameof(SelectedTab), SubTab.SyncFolders);
 
     /// <summary>Identifies the <see cref="ConflictCount"/> styled property.</summary>
-    public static readonly StyledProperty<int> ConflictCountProperty =
-        AvaloniaProperty.Register<SubTabBar, int>(nameof(ConflictCount), 0);
+    public static readonly StyledProperty<int> ConflictCountProperty = AvaloniaProperty.Register<SubTabBar, int>(nameof(ConflictCount), 0);
 
     /// <summary>Gets or sets the currently active tab.</summary>
     public SubTab SelectedTab
@@ -57,21 +55,21 @@ public static string GetTabLabel(SubTab tab) =>
     protected override void OnInitialized()
     {
         base.OnInitialized();
-        updateBorder();
-        updateTabLabels();
-        updateTabAppearances();
-        updateConflictsPill();
+        UpdateBorder();
+        UpdateTabLabels();
+        UpdateTabAppearances();
+        UpdateConflictsPill();
     }
 
     /// <inheritdoc/>
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
         base.OnPropertyChanged(change);
-        if (change.Property == SelectedTabProperty) updateTabAppearances();
-        if (change.Property == ConflictCountProperty) updateConflictsPill();
+        if (change.Property == SelectedTabProperty) UpdateTabAppearances();
+        if (change.Property == ConflictCountProperty) UpdateConflictsPill();
     }
 
-    private void updateBorder()
+    private void UpdateBorder()
     {
         if (ContainerBorder is null) return;
 
@@ -79,7 +77,7 @@ private void updateBorder()
             ContainerBorder.BorderBrush = borderBrush;
     }
 
-    private void updateTabLabels()
+    private void UpdateTabLabels()
     {
         if (SyncFoldersLabel is null || ActivityLabel is null || ConflictsLabel is null || SettingsLabel is null) return;
 
@@ -89,18 +87,18 @@ private void updateTabLabels()
         SettingsLabel.Text    = GetTabLabel(SubTab.Settings);
     }
 
-    private void updateTabAppearances()
+    private void UpdateTabAppearances()
     {
         if (SyncFoldersLabel is null || ActivityLabel is null || ConflictsLabel is null || SettingsLabel is null) return;
         if (SyncFoldersUnderline is null || ActivityUnderline is null || ConflictsUnderline is null || SettingsUnderline is null) return;
 
-        applyTabStyle(SyncFoldersLabel, SyncFoldersUnderline, SelectedTab == SubTab.SyncFolders);
-        applyTabStyle(ActivityLabel,    ActivityUnderline,    SelectedTab == SubTab.Activity);
-        applyTabStyle(ConflictsLabel,   ConflictsUnderline,   SelectedTab == SubTab.Conflicts);
-        applyTabStyle(SettingsLabel,    SettingsUnderline,    SelectedTab == SubTab.Settings);
+        ApplyTabStyle(SyncFoldersLabel, SyncFoldersUnderline, SelectedTab == SubTab.SyncFolders);
+        ApplyTabStyle(ActivityLabel,    ActivityUnderline,    SelectedTab == SubTab.Activity);
+        ApplyTabStyle(ConflictsLabel,   ConflictsUnderline,   SelectedTab == SubTab.Conflicts);
+        ApplyTabStyle(SettingsLabel,    SettingsUnderline,    SelectedTab == SubTab.Settings);
     }
 
-    private void applyTabStyle(TextBlock label, Border underline, bool isActive)
+    private void ApplyTabStyle(TextBlock label, Border underline, bool isActive)
     {
         if (isActive)
         {
@@ -123,7 +121,7 @@ private void applyTabStyle(TextBlock label, Border underline, bool isActive)
         }
     }
 
-    private void updateConflictsPill()
+    private void UpdateConflictsPill()
     {
         if (ConflictsPill is null) return;
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/ThroughputCard.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/ThroughputCard.axaml.cs
index d0aa76f..87f375b 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/ThroughputCard.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/ThroughputCard.axaml.cs
@@ -17,20 +17,16 @@ public partial class ThroughputCard : UserControl
     private const int HistoryBucketCount = 20;
 
     /// <summary>Identifies the <see cref="Buckets"/> styled property.</summary>
-    public static readonly StyledProperty<int[]> BucketsProperty =
-        AvaloniaProperty.Register<ThroughputCard, int[]>(nameof(Buckets), new int[BucketCount]);
+    public static readonly StyledProperty<int[]> BucketsProperty = AvaloniaProperty.Register<ThroughputCard, int[]>(nameof(Buckets), new int[BucketCount]);
 
     /// <summary>Identifies the <see cref="TodayGb"/> styled property.</summary>
-    public static readonly StyledProperty<double> TodayGbProperty =
-        AvaloniaProperty.Register<ThroughputCard, double>(nameof(TodayGb));
+    public static readonly StyledProperty<double> TodayGbProperty = AvaloniaProperty.Register<ThroughputCard, double>(nameof(TodayGb));
 
     /// <summary>Identifies the <see cref="FileCount"/> styled property.</summary>
-    public static readonly StyledProperty<int> FileCountProperty =
-        AvaloniaProperty.Register<ThroughputCard, int>(nameof(FileCount));
+    public static readonly StyledProperty<int> FileCountProperty = AvaloniaProperty.Register<ThroughputCard, int>(nameof(FileCount));
 
     /// <summary>Identifies the <see cref="CurrentRate"/> styled property.</summary>
-    public static readonly StyledProperty<string> CurrentRateProperty =
-        AvaloniaProperty.Register<ThroughputCard, string>(nameof(CurrentRate), string.Empty);
+    public static readonly StyledProperty<string> CurrentRateProperty = AvaloniaProperty.Register<ThroughputCard, string>(nameof(CurrentRate), string.Empty);
 
     private IBrush? _ink3Brush;
     private IBrush? _primaryBrush;
@@ -135,21 +131,21 @@ private void UpdateColors()
             _ink3Brush = ink3Brush;
             _ink3BrushSemiTransparent = new SolidColorBrush(((SolidColorBrush)ink3Brush).Color, 0.15);
 
-            if (TodayLabel is not null) TodayLabel.Foreground = ink3Brush;
-            if (AxisStartLabel is not null) AxisStartLabel.Foreground = ink3Brush;
-            if (AxisMidLabel is not null) AxisMidLabel.Foreground = ink3Brush;
-            if (AxisEndLabel is not null) AxisEndLabel.Foreground = ink3Brush;
+            TodayLabel?.Foreground = ink3Brush;
+            AxisStartLabel?.Foreground = ink3Brush;
+            AxisMidLabel?.Foreground = ink3Brush;
+            AxisEndLabel?.Foreground = ink3Brush;
         }
 
         if (this.TryFindResource("Primary", out var primaryRes) && primaryRes is IBrush primaryBrush)
         {
             _primaryBrush = primaryBrush;
 
-            if (GbText is not null) GbText.Foreground = primaryBrush;
+            GbText?.Foreground = primaryBrush;
         }
 
         if (this.TryFindResource("Ink2", out var ink2Res) && ink2Res is IBrush ink2Brush)
-            if (FilesText is not null) FilesText.Foreground = ink2Brush;
+            FilesText?.Foreground = ink2Brush;
     }
 
     private void BuildHistogram()
diff --git a/src/AStar.Dev.CloudSyncFunctional/Controls/TriStateCheckbox.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/Controls/TriStateCheckbox.axaml.cs
index 3d8a5c3..cdb0392 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Controls/TriStateCheckbox.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Controls/TriStateCheckbox.axaml.cs
@@ -9,8 +9,7 @@ namespace AStar.Dev.CloudSyncFunctional.Controls;
 public partial class TriStateCheckbox : UserControl
 {
     /// <summary>Identifies the <see cref="State"/> styled property.</summary>
-    public static readonly StyledProperty<CheckState> StateProperty =
-        AvaloniaProperty.Register<TriStateCheckbox, CheckState>(nameof(State), CheckState.Off);
+    public static readonly StyledProperty<CheckState> StateProperty = AvaloniaProperty.Register<TriStateCheckbox, CheckState>(nameof(State), CheckState.Off);
 
     /// <summary>Gets or sets the current check state.</summary>
     public CheckState State
diff --git a/src/AStar.Dev.CloudSyncFunctional/Domain/OneDriveAccount.cs b/src/AStar.Dev.CloudSyncFunctional/Domain/OneDriveAccount.cs
index 98718c0..2e3d4c6 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Domain/OneDriveAccount.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Domain/OneDriveAccount.cs
@@ -6,7 +6,7 @@ namespace AStar.Dev.CloudSyncFunctional.Domain;
 public sealed class OneDriveAccount
 {
     /// <summary>Gets the MSAL HomeAccountId identifier.</summary>
-    public string AccountId { get; init; } = string.Empty;
+    public AccountId AccountId { get; init; } = AccountId.Create(string.Empty);
 
     /// <summary>Gets the account's display name and email.</summary>
     public AccountProfile Profile { get; init; } = new(string.Empty, string.Empty);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/DriveFound.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/DriveFound.cs
new file mode 100644
index 0000000..d973e64
--- /dev/null
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/DriveFound.cs
@@ -0,0 +1,7 @@
+namespace AStar.Dev.CloudSyncFunctional.Graph;
+
+/// <summary>
+/// Represents a drive that was found for a given account, containing the Graph drive information.
+/// </summary>
+/// <param name="Drive">The Graph drive information.</param>
+public sealed record DriveFound(Microsoft.Graph.Models.Drive Drive);
\ No newline at end of file
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/GraphClientFactory.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/GraphClientFactory.cs
index 12a9079..3c4a809 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Graph/GraphClientFactory.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/GraphClientFactory.cs
@@ -1,3 +1,4 @@
+using AStar.Dev.FunctionalParadigm;
 using Microsoft.Graph;
 using Microsoft.Kiota.Abstractions.Authentication;
 
@@ -7,8 +8,14 @@ namespace AStar.Dev.CloudSyncFunctional.Graph;
 public sealed class GraphClientFactory : IGraphClientFactory
 {
     /// <inheritdoc />
-    public GraphServiceClient CreateClient(string accessToken) =>
-        new(new BaseBearerTokenAuthenticationProvider(new StaticAccessTokenProvider(accessToken)));
+    public Result<GraphServiceClient, GraphError> CreateClient(string accessToken)
+    {
+        if (string.IsNullOrWhiteSpace(accessToken))
+            return new Fail<GraphServiceClient, GraphError>(GraphErrorFactory.Unexpected("Access token must not be null or whitespace."));
+
+        return new Ok<GraphServiceClient, GraphError>(
+            new GraphServiceClient(new BaseBearerTokenAuthenticationProvider(new StaticAccessTokenProvider(accessToken))));
+    }
 
     private sealed class StaticAccessTokenProvider(string token) : IAccessTokenProvider
     {
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs
index 4d4f892..b3ee247 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs
@@ -1,5 +1,8 @@
 using AStar.Dev.FunctionalParadigm;
 using Microsoft.Extensions.Logging;
+using Microsoft.Graph;
+using Microsoft.Graph.Models;
+using GraphClient = Microsoft.Graph.GraphServiceClient;
 
 namespace AStar.Dev.CloudSyncFunctional.Graph;
 
@@ -9,47 +12,77 @@ public sealed partial class GraphService(IGraphClientFactory clientFactory, ILog
     private static readonly string[] ChildrenSelect = ["id", "name", "folder", "parentReference"];
 
     /// <inheritdoc />
-    public async Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersAsync(string accountId, string accessToken, CancellationToken ct = default)
+    public Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersAsync(string accountId, string accessToken, CancellationToken cancellationToken = default)
+        => ExecuteGraphOperationAsync(
+            accountId,
+            () => GetClientAndDriveAsync(clientFactory, accessToken, cancellationToken)
+                .BindAsync(clientAndDrive => GetRootFoldersForDriveAsync(clientAndDrive.Client, clientAndDrive.DriveFound, cancellationToken)));
+
+    private async Task<Result<T, GraphError>> ExecuteGraphOperationAsync<T>(string accountId, Func<Task<Result<T, GraphError>>> operation)
     {
         try
         {
-            var client = clientFactory.CreateClient(accessToken);
-            var drive = await client.Me.Drive.GetAsync(cancellationToken: ct).ConfigureAwait(false);
-            if (drive?.Id is null)
-                return new Fail<List<DriveFolder>, GraphError>(GraphErrorFactory.Unexpected("Drive ID was null."));
-
-            var root = await client.Drives[drive.Id].Root.GetAsync(cancellationToken: ct).ConfigureAwait(false);
-            if (root?.Id is null)
-                return new Fail<List<DriveFolder>, GraphError>(GraphErrorFactory.Unexpected("Root item ID was null."));
-
-            var page = await client.Drives[drive.Id].Items[root.Id].Children
-                .GetAsync(req => req.QueryParameters.Select = ChildrenSelect, ct)
-                .ConfigureAwait(false);
-
-            var folders = new List<DriveFolder>();
-            while (page?.Value is not null)
-            {
-                foreach (var item in page.Value.Where(i => i.Folder is not null))
-                    folders.Add(new DriveFolder(item.Id!, item.Name!, item.ParentReference?.Id));
-
-                if (page.OdataNextLink is null)
-                    break;
-
-                page = await client.Drives[drive.Id].Items[root.Id].Children
-                    .WithUrl(page.OdataNextLink).GetAsync(cancellationToken: ct)
-                    .ConfigureAwait(false);
-            }
-
-            return new Ok<List<DriveFolder>, GraphError>(folders);
+            return await operation().ConfigureAwait(false);
         }
         catch (Exception ex)
         {
             LogGraphFailed(logger, accountId, ex.Message);
 
-            return new Fail<List<DriveFolder>, GraphError>(GraphErrorFactory.Unexpected(ex.Message));
+            return new Fail<T, GraphError>(GraphErrorFactory.Unexpected(ex.Message));
         }
     }
 
+    private static Task<Result<ClientAndDriveFound, GraphError>> GetClientAndDriveAsync(IGraphClientFactory clientFactory, string accessToken, CancellationToken cancellationToken)
+        => clientFactory.CreateClient(accessToken)
+            .BindAsync(client => GetDriveAsync(client, cancellationToken)
+                .MapAsync(driveFound => new ClientAndDriveFound(client, driveFound)));
+
+    private static Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersForDriveAsync(GraphClient client, DriveFound driveFound, CancellationToken cancellationToken)
+        => GetRootAsync(client, driveFound, cancellationToken)
+            .BindAsync(rootFound => GetFolderPageAsync(client, driveFound, rootFound, null, cancellationToken)
+                .BindAsync(firstPage => GetFoldersFromPagesAsync(client, driveFound, rootFound, firstPage, null, cancellationToken)));
+
+    private static async Task<Result<DriveItemCollectionResponse, GraphError>> GetFolderPageAsync(GraphClient client, DriveFound driveFound, RootFound rootFound, string? nextLink, CancellationToken cancellationToken)
+    {
+        var children = client.Drives[driveFound.Drive.Id].Items[rootFound.DriveItem.Id].Children;
+        var page = nextLink is null
+            ? await children.GetAsync(req => req.QueryParameters.Select = ChildrenSelect, cancellationToken: cancellationToken).ConfigureAwait(false)
+            : await children.WithUrl(nextLink).GetAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+
+        return page is { }
+            ? new Ok<DriveItemCollectionResponse, GraphError>(page)
+            : new Fail<DriveItemCollectionResponse, GraphError>(GraphErrorFactory.Unexpected("Folder page was null."));
+    }
+
+    private static Task<Result<List<DriveFolder>, GraphError>> GetFoldersFromPagesAsync(GraphClient client, DriveFound driveFound, RootFound rootFound, DriveItemCollectionResponse page, IReadOnlyCollection<DriveFolder>? foldersSoFar, CancellationToken cancellationToken)
+    {
+        var folders = (foldersSoFar ?? []).Concat(GetFoldersFromPage(page)).ToList();
+
+        return page.OdataNextLink is null
+            ? Task.FromResult<Result<List<DriveFolder>, GraphError>>(new Ok<List<DriveFolder>, GraphError>(folders))
+            : GetFolderPageAsync(client, driveFound, rootFound, page.OdataNextLink, cancellationToken)
+                .BindAsync(nextPage => GetFoldersFromPagesAsync(client, driveFound, rootFound, nextPage, folders, cancellationToken));
+    }
+
+    private static IEnumerable<DriveFolder> GetFoldersFromPage(DriveItemCollectionResponse page)
+        => page.Value?
+               .Where(item => item.Folder is not null)
+               .Where(item => item.Id is not null && item.Name is not null)
+               .Select(item => new DriveFolder(item.Id!, item.Name!, item.ParentReference?.Id))
+           ?? [];
+
+    private static async Task<Result<RootFound, GraphError>> GetRootAsync(GraphClient client, DriveFound driveFound, CancellationToken cancellationToken)
+        => (await client.Drives[driveFound.Drive.Id].Root.GetAsync(cancellationToken: cancellationToken).ConfigureAwait(false)) is DriveItem { Id: not null } root
+            ? new Ok<RootFound, GraphError>(new RootFound(root))
+            : new Fail<RootFound, GraphError>(GraphErrorFactory.Unexpected("Root item was null."));
+
+    private static async Task<Result<DriveFound, GraphError>> GetDriveAsync(GraphClient client, CancellationToken cancellationToken)
+        => (await client.Me.Drive.GetAsync(cancellationToken: cancellationToken).ConfigureAwait(false)) is { Id: not null } drive
+            ? new Ok<DriveFound, GraphError>(new DriveFound(drive))
+            : new Fail<DriveFound, GraphError>(GraphErrorFactory.Unexpected("Drive was null."));
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Graph API call failed for account {AccountId}: {ErrorMessage}")]
     private static partial void LogGraphFailed(ILogger logger, string accountId, string errorMessage);
+
+    private sealed record ClientAndDriveFound(GraphClient Client, DriveFound DriveFound);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphClientFactory.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphClientFactory.cs
index bae0a82..ad4877c 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphClientFactory.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphClientFactory.cs
@@ -1,3 +1,4 @@
+using AStar.Dev.FunctionalParadigm;
 using Microsoft.Graph;
 
 namespace AStar.Dev.CloudSyncFunctional.Graph;
@@ -7,6 +8,6 @@ public interface IGraphClientFactory
 {
     /// <summary>Creates a new <see cref="GraphServiceClient"/> authenticated with the given bearer token.</summary>
     /// <param name="accessToken">The OAuth2 bearer token.</param>
-    /// <returns>A new <see cref="GraphServiceClient"/> instance.</returns>
-    GraphServiceClient CreateClient(string accessToken);
-}
+    /// <returns>A result containing a new <see cref="GraphServiceClient"/> instance, or a graph error.</returns>
+    Result<GraphServiceClient, GraphError> CreateClient(string accessToken);
+}
\ No newline at end of file
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs
index 99f7465..be2e2ce 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs
@@ -8,7 +8,7 @@ public interface IGraphService
     /// <summary>Returns the root-level folders for the given account's OneDrive.</summary>
     /// <param name="accountId">The MSAL HomeAccountId identifier.</param>
     /// <param name="accessToken">The OAuth2 bearer token for Graph API calls.</param>
-    /// <param name="ct">Token to cancel the operation.</param>
+    /// <param name="cancellationToken">Token to cancel the operation.</param>
     /// <returns>A list of root folders, or a <see cref="GraphError"/> on failure.</returns>
-    Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersAsync(string accountId, string accessToken, CancellationToken ct = default);
+    Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersAsync(string accountId, string accessToken, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/RootFound.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/RootFound.cs
new file mode 100644
index 0000000..aea0359
--- /dev/null
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/RootFound.cs
@@ -0,0 +1,9 @@
+using Microsoft.Graph.Models;
+
+namespace AStar.Dev.CloudSyncFunctional.Graph;
+
+/// <summary>
+/// Represents a root folder that was found for a given drive, containing the Graph drive item information.
+/// </summary>
+/// <param name="DriveItem">The Graph drive item information.</param>
+public sealed record RootFound(DriveItem DriveItem);
\ No newline at end of file
diff --git a/src/AStar.Dev.CloudSyncFunctional/MainWindow.axaml b/src/AStar.Dev.CloudSyncFunctional/MainWindow.axaml
index 9b173d9..208e037 100644
--- a/src/AStar.Dev.CloudSyncFunctional/MainWindow.axaml
+++ b/src/AStar.Dev.CloudSyncFunctional/MainWindow.axaml
@@ -15,6 +15,7 @@
         Width="1280" Height="820"
         MinWidth="960" MinHeight="600"
         ExtendClientAreaToDecorationsHint="True"
+        Icon="avares://AStar.Dev.CloudSyncFunctional/Assets/astar.png"
         Background="{DynamicResource Chrome}">
     <Grid RowDefinitions="38,*">
 
@@ -219,7 +220,7 @@
                         Padding="14,8">
                     <Grid ColumnDefinitions="Auto,*,Auto,Auto">
                         <controls:AppButton Grid.Column="0"
-                                            Kind="Ghost" ButtonSize="Sm"
+                                            Kind="Ghost" ButtonSize="Small"
                                             Label="Pause all"/>
                         <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="4">
                             <Button x:Name="BellButton"
diff --git a/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs b/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
index 9fa38a4..7b20683 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
@@ -4,65 +4,55 @@
 using AStar.Dev.CloudSyncFunctional.Persistence.ValueObjects;
 using AStar.Dev.FunctionalParadigm;
 using Microsoft.Extensions.Logging;
+using System.IO.Abstractions;
 
 namespace AStar.Dev.CloudSyncFunctional.Onboarding;
 
 /// <inheritdoc />
-public sealed partial class AccountOnboardingService(IAccountRepository accountRepository, ISyncRuleRepository syncRuleRepository, ILogger<AccountOnboardingService> logger) : IAccountOnboardingService
+public sealed partial class AccountOnboardingService(IAccountRepository accountRepository, ISyncRuleRepository syncRuleRepository, IFileSystem fileSystem, ILogger<AccountOnboardingService> logger) : IAccountOnboardingService
 {
     private static readonly char[] InvalidPathChars = ['\\', '/', ':', '*', '?', '"', '<', '>', '|',
         ..Enumerable.Range(0, 32).Select(i => (char)i)];
 
     /// <inheritdoc />
-    public async Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingAsync(OneDriveAccount account, CancellationToken ct = default)
+    public async Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingAsync(OneDriveAccount account, CancellationToken cancellationToken = default)
     {
         account.IsActive = true;
         var entity = MapToEntity(account);
 
-        return await accountRepository.UpsertAsync(entity, ct)
-            .BindAsync(_ => UpsertSyncRulesAsync(account, ct))
+        return await accountRepository.UpsertAsync(entity, cancellationToken)
+            .BindAsync(_ => UpsertSyncRulesAsync(account, cancellationToken))
             .MatchAsync<Unit, PersistenceError, Result<OneDriveAccount, PersistenceError>>(
                 _ =>
                 {
-                    LogOnboardingComplete(logger, account.AccountId);
+                    LogOnboardingComplete(logger, account.AccountId.Value);
                     return new Ok<OneDriveAccount, PersistenceError>(account);
                 },
                 error =>
                 {
-                    LogOnboardingFailed(logger, account.AccountId, error.Message);
+                    LogOnboardingFailed(logger, account.AccountId.Value, error.Message);
                     return new Fail<OneDriveAccount, PersistenceError>(error);
                 });
     }
 
-    private async Task<Result<Unit, PersistenceError>> UpsertSyncRulesAsync(OneDriveAccount account, CancellationToken ct)
-    {
-        foreach (var folder in account.SelectedFolders)
-        {
-            var rule = new SyncRuleEntity
-            {
-                Id = new SyncRuleId(Guid.NewGuid().ToString()),
-                AccountId = new AccountId(account.AccountId),
-                RemotePath = $"/{folder.Name}",
-                RuleType = RuleType.Include
-            };
-
-            var stopResult = await syncRuleRepository.UpsertAsync(rule, ct)
-                .MatchAsync<Unit, PersistenceError, Result<Unit, PersistenceError>?>(
-                    _ => null,
-                    error => new Fail<Unit, PersistenceError>(error))
-                .ConfigureAwait(false);
-
-            if (stopResult is not null)
-                return stopResult;
-        }
+    private Task<Result<Unit, PersistenceError>> UpsertSyncRulesAsync(OneDriveAccount account, CancellationToken cancellationToken) =>
+        account.SelectedFolders.Aggregate(
+            Task.FromResult<Result<Unit, PersistenceError>>(new Ok<Unit, PersistenceError>(Unit.Default)),
+            (current, folder) => current.BindAsync(_ => syncRuleRepository.UpsertAsync(CreateSyncRule(account, folder), cancellationToken)));
 
-        return new Ok<Unit, PersistenceError>(Unit.Default);
-    }
+    private static SyncRuleEntity CreateSyncRule(OneDriveAccount account, SelectedFolder folder) =>
+        new()
+        {
+            Id = new SyncRuleId(Guid.NewGuid().ToString()),
+            AccountId = new AccountId(account.AccountId.Value),
+            RemotePath = $"/{folder.Name}",
+            RuleType = RuleType.Include
+        };
 
-    private static AccountEntity MapToEntity(OneDriveAccount account) =>
+    private AccountEntity MapToEntity(OneDriveAccount account) =>
         new()
         {
-            Id = new AccountId(account.AccountId),
+            Id = new AccountId(account.AccountId.Value),
             Profile = new AccountProfileEntity
             {
                 DisplayName = new DisplayName(account.Profile.DisplayName),
@@ -77,12 +67,12 @@ private static AccountEntity MapToEntity(OneDriveAccount account) =>
             }
         };
 
-    private static string ComputeDefaultSyncPath(string email)
+    private string ComputeDefaultSyncPath(string email)
     {
         var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
         var sanitised = SanitiseEmail(email);
 
-        return Path.Combine(home, "OneDrive", sanitised);
+        return fileSystem.Path.Combine(home, "OneDrive", sanitised);
     }
 
     private static string SanitiseEmail(string email) =>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs b/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs
index b863ec4..65831e6 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs
@@ -8,7 +8,7 @@ public interface IAccountOnboardingService
 {
     /// <summary>Completes account onboarding and returns the finalised account.</summary>
     /// <param name="account">The account to onboard.</param>
-    /// <param name="ct">Token to cancel the operation.</param>
+    /// <param name="cancellationToken">Token to cancel the operation.</param>
     /// <returns>The finalised <see cref="OneDriveAccount"/> on success, or a <see cref="PersistenceError"/> on failure.</returns>
-    Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingAsync(OneDriveAccount account, CancellationToken ct = default);
+    Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingAsync(OneDriveAccount account, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
index de3b0f7..e6753ed 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
@@ -10,36 +10,36 @@ namespace AStar.Dev.CloudSyncFunctional.Persistence.Repositories;
 public sealed class AccountRepository(IDbContextFactory<AppDbContext> dbFactory) : IAccountRepository
 {
     /// <inheritdoc/>
-    public async Task<Option<AccountEntity, PersistenceError>> GetByIdAsync(AccountId id, CancellationToken ct = default)
+    public async Task<Option<AccountEntity>> GetByIdAsync(AccountId id, CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-        var entity = await context.Accounts.FindAsync([id], ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        var entity = await context.Accounts.FindAsync([id], cancellationToken).ConfigureAwait(false);
 
         return entity is null
-            ? new None<AccountEntity, PersistenceError>(PersistenceErrorFactory.Unexpected("Account not found."))
-            : new Some<AccountEntity, PersistenceError>(entity);
+            ? new None<AccountEntity>()
+            : new Some<AccountEntity>(entity);
     }
 
     /// <inheritdoc/>
-    public async Task<IReadOnlyList<AccountEntity>> GetAllAsync(CancellationToken ct = default)
+    public async Task<IReadOnlyList<AccountEntity>> GetAllAsync(CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
 
-        return await context.Accounts.AsNoTracking().ToListAsync(ct).ConfigureAwait(false);
+        return await context.Accounts.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.Accounts.FindAsync([entity.Id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.Accounts.FindAsync([entity.Id], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.Accounts.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
@@ -54,16 +54,16 @@ public async Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity enti
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> DeleteAsync(AccountId id, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> DeleteAsync(AccountId id, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.Accounts.FindAsync([id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.Accounts.FindAsync([id], cancellationToken).ConfigureAwait(false);
             if (existing is not null)
             {
                 context.Accounts.Remove(existing);
-                await context.SaveChangesAsync(ct).ConfigureAwait(false);
+                await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
             }
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
index 623e01c..fe6db6a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
@@ -10,28 +10,28 @@ namespace AStar.Dev.CloudSyncFunctional.Persistence.Repositories;
 public sealed class DriveStateRepository(IDbContextFactory<AppDbContext> dbFactory) : IDriveStateRepository
 {
     /// <inheritdoc/>
-    public async Task<Option<DriveStateEntity, PersistenceError>> GetByAccountAsync(AccountId accountId, CancellationToken ct = default)
+    public async Task<Option<DriveStateEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-        var entity = await context.DriveStates.FindAsync([accountId], ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        var entity = await context.DriveStates.FindAsync([accountId], cancellationToken).ConfigureAwait(false);
 
         return entity is null
-            ? new None<DriveStateEntity, PersistenceError>(PersistenceErrorFactory.Unexpected("Drive state not found."))
-            : new Some<DriveStateEntity, PersistenceError>(entity);
+            ? new None<DriveStateEntity>()
+            : new Some<DriveStateEntity>(entity);
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertAsync(DriveStateEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertAsync(DriveStateEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.DriveStates.FindAsync([entity.AccountId], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.DriveStates.FindAsync([entity.AccountId], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.DriveStates.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/FileClassificationRuleRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/FileClassificationRuleRepository.cs
index 8e98096..3353884 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/FileClassificationRuleRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/FileClassificationRuleRepository.cs
@@ -9,25 +9,25 @@ namespace AStar.Dev.CloudSyncFunctional.Persistence.Repositories;
 public sealed class FileClassificationRuleRepository(IDbContextFactory<AppDbContext> dbFactory) : IFileClassificationRuleRepository
 {
     /// <inheritdoc/>
-    public async Task<IReadOnlyList<FileClassificationRuleEntity>> GetAllAsync(CancellationToken ct = default)
+    public async Task<IReadOnlyList<FileClassificationRuleEntity>> GetAllAsync(CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
 
-        return await context.FileClassificationRules.AsNoTracking().ToListAsync(ct).ConfigureAwait(false);
+        return await context.FileClassificationRules.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertAsync(FileClassificationRuleEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertAsync(FileClassificationRuleEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.FileClassificationRules.FindAsync([entity.Id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.FileClassificationRules.FindAsync([entity.Id], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.FileClassificationRules.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
@@ -42,16 +42,16 @@ public async Task<Result<Unit, PersistenceError>> UpsertAsync(FileClassification
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> DeleteAsync(string id, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> DeleteAsync(string id, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.FileClassificationRules.FindAsync([id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.FileClassificationRules.FindAsync([id], cancellationToken).ConfigureAwait(false);
             if (existing is not null)
             {
                 context.FileClassificationRules.Remove(existing);
-                await context.SaveChangesAsync(ct).ConfigureAwait(false);
+                await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
             }
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs
index 2173adb..09d79bc 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs
@@ -12,22 +12,22 @@ public interface IAccountRepository
     /// <param name="id">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>The account if found, otherwise None.</returns>
-    Task<Option<AccountEntity, PersistenceError>> GetByIdAsync(AccountId id, CancellationToken ct = default);
+    Task<Option<AccountEntity>> GetByIdAsync(AccountId id, CancellationToken cancellationToken = default);
 
     /// <summary>Retrieves all accounts.</summary>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>All stored accounts.</returns>
-    Task<IReadOnlyList<AccountEntity>> GetAllAsync(CancellationToken ct = default);
+    Task<IReadOnlyList<AccountEntity>> GetAllAsync(CancellationToken cancellationToken = default);
 
     /// <summary>Upserts an account.</summary>
     /// <param name="entity">The account to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>Deletes an account and all its child entities.</summary>
     /// <param name="id">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> DeleteAsync(AccountId id, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> DeleteAsync(AccountId id, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs
index c9c3bb6..63d920a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs
@@ -12,11 +12,11 @@ public interface IDriveStateRepository
     /// <param name="accountId">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>The drive state if present, otherwise None.</returns>
-    Task<Option<DriveStateEntity, PersistenceError>> GetByAccountAsync(AccountId accountId, CancellationToken ct = default);
+    Task<Option<DriveStateEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default);
 
     /// <summary>Upserts the drive state for an account.</summary>
     /// <param name="entity">The drive state to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertAsync(DriveStateEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertAsync(DriveStateEntity entity, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IFileClassificationRuleRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IFileClassificationRuleRepository.cs
index b473737..3194a91 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IFileClassificationRuleRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IFileClassificationRuleRepository.cs
@@ -10,17 +10,17 @@ public interface IFileClassificationRuleRepository
     /// <summary>Retrieves all file classification rules.</summary>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>All stored classification rules.</returns>
-    Task<IReadOnlyList<FileClassificationRuleEntity>> GetAllAsync(CancellationToken ct = default);
+    Task<IReadOnlyList<FileClassificationRuleEntity>> GetAllAsync(CancellationToken cancellationToken = default);
 
     /// <summary>Upserts a file classification rule.</summary>
     /// <param name="entity">The rule to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertAsync(FileClassificationRuleEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertAsync(FileClassificationRuleEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>Deletes a file classification rule by identifier.</summary>
     /// <param name="id">The rule identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> DeleteAsync(string id, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> DeleteAsync(string id, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRepository.cs
index b762176..88fb3c6 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRepository.cs
@@ -12,29 +12,29 @@ public interface ISyncRepository
     /// <param name="accountId">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>All pending conflicts for the account.</returns>
-    Task<IReadOnlyList<SyncConflictEntity>> GetPendingConflictsAsync(AccountId accountId, CancellationToken ct = default);
+    Task<IReadOnlyList<SyncConflictEntity>> GetPendingConflictsAsync(AccountId accountId, CancellationToken cancellationToken = default);
 
     /// <summary>Upserts a sync conflict.</summary>
     /// <param name="entity">The conflict to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertConflictAsync(SyncConflictEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertConflictAsync(SyncConflictEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>Marks a conflict as resolved.</summary>
     /// <param name="id">The conflict identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> ResolveConflictAsync(SyncConflictId id, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> ResolveConflictAsync(SyncConflictId id, CancellationToken cancellationToken = default);
 
     /// <summary>Upserts a sync job.</summary>
     /// <param name="entity">The job to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertJobAsync(SyncJobEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertJobAsync(SyncJobEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>Removes all completed jobs for a given account.</summary>
     /// <param name="accountId">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> ClearCompletedJobsAsync(AccountId accountId, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> ClearCompletedJobsAsync(AccountId accountId, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRuleRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRuleRepository.cs
index f63b51f..ad2a8db 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRuleRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncRuleRepository.cs
@@ -12,17 +12,17 @@ public interface ISyncRuleRepository
     /// <param name="accountId">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>All sync rules for the account.</returns>
-    Task<IReadOnlyList<SyncRuleEntity>> GetByAccountAsync(AccountId accountId, CancellationToken ct = default);
+    Task<IReadOnlyList<SyncRuleEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default);
 
     /// <summary>Upserts a sync rule.</summary>
     /// <param name="entity">The sync rule to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertAsync(SyncRuleEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertAsync(SyncRuleEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>Deletes a sync rule by identifier.</summary>
     /// <param name="id">The sync rule identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> DeleteAsync(SyncRuleId id, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> DeleteAsync(SyncRuleId id, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs
index 9819ddd..84a1af0 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs
@@ -12,23 +12,23 @@ public interface ISyncedItemRepository
     /// <param name="id">The synced item identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>The item if found, otherwise None.</returns>
-    Task<Option<SyncedItemEntity, PersistenceError>> GetByIdAsync(SyncedItemId id, CancellationToken ct = default);
+    Task<Option<SyncedItemEntity>> GetByIdAsync(SyncedItemId id, CancellationToken cancellationToken = default);
 
     /// <summary>Retrieves all synced items for a given account.</summary>
     /// <param name="accountId">The account identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>All synced items for the account.</returns>
-    Task<IReadOnlyList<SyncedItemEntity>> GetByAccountAsync(AccountId accountId, CancellationToken ct = default);
+    Task<IReadOnlyList<SyncedItemEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default);
 
     /// <summary>Upserts a synced item.</summary>
     /// <param name="entity">The item to upsert.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> UpsertAsync(SyncedItemEntity entity, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> UpsertAsync(SyncedItemEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>Deletes a synced item by identifier.</summary>
     /// <param name="id">The item identifier.</param>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>Ok on success, Fail on error.</returns>
-    Task<Result<Unit, PersistenceError>> DeleteAsync(SyncedItemId id, CancellationToken ct = default);
+    Task<Result<Unit, PersistenceError>> DeleteAsync(SyncedItemId id, CancellationToken cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRepository.cs
index 10a827f..818c550 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRepository.cs
@@ -14,29 +14,29 @@ public sealed class SyncRepository(IDbContextFactory<AppDbContext> dbFactory) :
     private const string CompletedStatus = "Completed";
 
     /// <inheritdoc/>
-    public async Task<IReadOnlyList<SyncConflictEntity>> GetPendingConflictsAsync(AccountId accountId, CancellationToken ct = default)
+    public async Task<IReadOnlyList<SyncConflictEntity>> GetPendingConflictsAsync(AccountId accountId, CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
 
         return await context.SyncConflicts
             .AsNoTracking()
             .Where(c => c.AccountId == accountId && c.State == PendingState)
-            .ToListAsync(ct)
+            .ToListAsync(cancellationToken)
             .ConfigureAwait(false);
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertConflictAsync(SyncConflictEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertConflictAsync(SyncConflictEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncConflicts.FindAsync([entity.Id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncConflicts.FindAsync([entity.Id], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.SyncConflicts.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
@@ -51,16 +51,16 @@ public async Task<Result<Unit, PersistenceError>> UpsertConflictAsync(SyncConfli
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> ResolveConflictAsync(SyncConflictId id, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> ResolveConflictAsync(SyncConflictId id, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncConflicts.FindAsync([id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncConflicts.FindAsync([id], cancellationToken).ConfigureAwait(false);
             if (existing is not null)
             {
                 existing.State = ResolvedState;
-                await context.SaveChangesAsync(ct).ConfigureAwait(false);
+                await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
             }
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
@@ -76,17 +76,17 @@ public async Task<Result<Unit, PersistenceError>> ResolveConflictAsync(SyncConfl
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertJobAsync(SyncJobEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertJobAsync(SyncJobEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncJobs.FindAsync([entity.Id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncJobs.FindAsync([entity.Id], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.SyncJobs.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
@@ -101,17 +101,17 @@ public async Task<Result<Unit, PersistenceError>> UpsertJobAsync(SyncJobEntity e
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> ClearCompletedJobsAsync(AccountId accountId, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> ClearCompletedJobsAsync(AccountId accountId, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
             var completed = await context.SyncJobs
                 .Where(j => j.AccountId == accountId && j.Status == CompletedStatus)
-                .ToListAsync(ct)
+                .ToListAsync(cancellationToken)
                 .ConfigureAwait(false);
             context.SyncJobs.RemoveRange(completed);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRuleRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRuleRepository.cs
index 77a858d..497343b 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRuleRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncRuleRepository.cs
@@ -10,29 +10,29 @@ namespace AStar.Dev.CloudSyncFunctional.Persistence.Repositories;
 public sealed class SyncRuleRepository(IDbContextFactory<AppDbContext> dbFactory) : ISyncRuleRepository
 {
     /// <inheritdoc/>
-    public async Task<IReadOnlyList<SyncRuleEntity>> GetByAccountAsync(AccountId accountId, CancellationToken ct = default)
+    public async Task<IReadOnlyList<SyncRuleEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
 
         return await context.SyncRules
             .AsNoTracking()
             .Where(r => r.AccountId == accountId)
-            .ToListAsync(ct)
+            .ToListAsync(cancellationToken)
             .ConfigureAwait(false);
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertAsync(SyncRuleEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertAsync(SyncRuleEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncRules.FindAsync([entity.Id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncRules.FindAsync([entity.Id], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.SyncRules.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
@@ -47,16 +47,16 @@ public async Task<Result<Unit, PersistenceError>> UpsertAsync(SyncRuleEntity ent
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> DeleteAsync(SyncRuleId id, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> DeleteAsync(SyncRuleId id, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncRules.FindAsync([id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncRules.FindAsync([id], cancellationToken).ConfigureAwait(false);
             if (existing is not null)
             {
                 context.SyncRules.Remove(existing);
-                await context.SaveChangesAsync(ct).ConfigureAwait(false);
+                await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
             }
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
index 7e92af2..b44744a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
@@ -10,40 +10,40 @@ namespace AStar.Dev.CloudSyncFunctional.Persistence.Repositories;
 public sealed class SyncedItemRepository(IDbContextFactory<AppDbContext> dbFactory) : ISyncedItemRepository
 {
     /// <inheritdoc/>
-    public async Task<Option<SyncedItemEntity, PersistenceError>> GetByIdAsync(SyncedItemId id, CancellationToken ct = default)
+    public async Task<Option<SyncedItemEntity>> GetByIdAsync(SyncedItemId id, CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-        var entity = await context.SyncedItems.FindAsync([id], ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        var entity = await context.SyncedItems.FindAsync([id], cancellationToken).ConfigureAwait(false);
 
         return entity is null
-            ? new None<SyncedItemEntity, PersistenceError>(PersistenceErrorFactory.Unexpected("Synced item not found."))
-            : new Some<SyncedItemEntity, PersistenceError>(entity);
+            ? new None<SyncedItemEntity>()
+            : new Some<SyncedItemEntity>(entity);
     }
 
     /// <inheritdoc/>
-    public async Task<IReadOnlyList<SyncedItemEntity>> GetByAccountAsync(AccountId accountId, CancellationToken ct = default)
+    public async Task<IReadOnlyList<SyncedItemEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default)
     {
-        await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+        await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
 
         return await context.SyncedItems
             .AsNoTracking()
             .Where(i => i.AccountId == accountId)
-            .ToListAsync(ct)
+            .ToListAsync(cancellationToken)
             .ConfigureAwait(false);
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> UpsertAsync(SyncedItemEntity entity, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> UpsertAsync(SyncedItemEntity entity, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncedItems.FindAsync([entity.Id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncedItems.FindAsync([entity.Id], cancellationToken).ConfigureAwait(false);
             if (existing is null)
                 context.SyncedItems.Add(entity);
             else
                 context.Entry(existing).CurrentValues.SetValues(entity);
-            await context.SaveChangesAsync(ct).ConfigureAwait(false);
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
         }
@@ -58,16 +58,16 @@ public async Task<Result<Unit, PersistenceError>> UpsertAsync(SyncedItemEntity e
     }
 
     /// <inheritdoc/>
-    public async Task<Result<Unit, PersistenceError>> DeleteAsync(SyncedItemId id, CancellationToken ct = default)
+    public async Task<Result<Unit, PersistenceError>> DeleteAsync(SyncedItemId id, CancellationToken cancellationToken = default)
     {
         try
         {
-            await using var context = await dbFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-            var existing = await context.SyncedItems.FindAsync([id], ct).ConfigureAwait(false);
+            await using var context = await dbFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var existing = await context.SyncedItems.FindAsync([id], cancellationToken).ConfigureAwait(false);
             if (existing is not null)
             {
                 context.SyncedItems.Remove(existing);
-                await context.SaveChangesAsync(ct).ConfigureAwait(false);
+                await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
             }
 
             return new Ok<Unit, PersistenceError>(Unit.Default);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardView.axaml b/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardView.axaml
index dd3b5ad..ed8d30c 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardView.axaml
+++ b/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardView.axaml
@@ -191,13 +191,13 @@
         <!-- Footer buttons -->
         <Border Grid.Row="1" BorderThickness="0,1,0,0" BorderBrush="{DynamicResource Border}" Padding="24,12">
             <Grid ColumnDefinitions="Auto,*,Auto,Auto">
-                <controls:AppButton Grid.Column="0" Command="{Binding Cancel}" Label="Cancel" Kind="Ghost" ButtonSize="Sm" Width="96"/>
+                <controls:AppButton Grid.Column="0" Command="{Binding Cancel}" Label="Cancel" Kind="Ghost" ButtonSize="Small" Width="96"/>
                 <controls:AppButton Grid.Column="2" Command="{Binding Back}" Label="Back"
-                                    IsVisible="{Binding CanGoBack}" Kind="Ghost" ButtonSize="Sm" Width="96" Margin="0,0,8,0"/>
+                                    IsVisible="{Binding CanGoBack}" Kind="Ghost" ButtonSize="Small" Width="96" Margin="0,0,8,0"/>
                 <controls:AppButton Grid.Column="3"
                                     Command="{Binding AddAccount}"
                                     IsVisible="{Binding IsSelectFoldersStep}"
-                                    Label="Add account" Kind="Primary" ButtonSize="Sm" Width="96"/>
+                                    Label="Add account" Kind="Primary" ButtonSize="Small" Width="96"/>
             </Grid>
         </Border>
     </Grid>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs b/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs
index 3e67b91..541a4a9 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs
@@ -147,10 +147,10 @@ public AddAccountWizardViewModel(IAuthService authService, IGraphService graphSe
 
         var canSignIn = this.WhenAnyValue(x => x.IsWaitingForAuth, waiting => !waiting);
 
-        SelectProvider = ReactiveCommand.CreateFromTask<ProviderKind, RxUnit>((kind, ct) => ExecuteSelectProviderAsync(kind, ct));
-        SignIn = ReactiveCommand.CreateFromTask(ct => ExecuteSignInAsync(ct), canSignIn);
+        SelectProvider = ReactiveCommand.CreateFromTask<ProviderKind, RxUnit>(ExecuteSelectProviderAsync);
+        SignIn = ReactiveCommand.CreateFromTask(ExecuteSignInAsync, canSignIn);
         Back = ReactiveCommand.Create(ExecuteBack);
-        AddAccount = ReactiveCommand.CreateFromTask(ct => ExecuteAddAccountAsync(ct));
+        AddAccount = ReactiveCommand.CreateFromTask(ExecuteAddAccountAsync);
         Cancel = ReactiveCommand.CreateFromTask(ExecuteCancelAsync);
     }
 
@@ -165,7 +165,7 @@ public void Dispose()
     /// <param name="account">The account to pass with the event.</param>
     internal void SimulateCompleted(OneDriveAccount account) => Completed?.Invoke(this, account);
 
-    private async Task<RxUnit> ExecuteSelectProviderAsync(ProviderKind kind, CancellationToken ct = default)
+    private async Task<RxUnit> ExecuteSelectProviderAsync(ProviderKind kind, CancellationToken cancellationToken = default)
     {
         ShowNotImplemented = false;
         NotImplementedMessage = string.Empty;
@@ -183,10 +183,10 @@ private async Task<RxUnit> ExecuteSelectProviderAsync(ProviderKind kind, Cancell
         return RxUnit.Default;
     }
 
-    private async Task ExecuteSignInAsync(CancellationToken ct)
+    private async Task ExecuteSignInAsync(CancellationToken cancellationToken)
     {
         _authCts?.Dispose();
-        _authCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        _authCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
 
         using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
         using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_authCts.Token, timeoutCts.Token);
@@ -227,10 +227,10 @@ await _authService.SignInInteractiveAsync(linkedCts.Token)
                 });
     }
 
-    private async Task LoadFoldersAsync(AuthResult authResult, CancellationToken ct)
+    private async Task LoadFoldersAsync(AuthResult authResult, CancellationToken cancellationToken)
     {
         IsLoadingFolders = true;
-        await _graphService.GetRootFoldersAsync(authResult.AccountId, authResult.AccessToken, ct)
+        await _graphService.GetRootFoldersAsync(authResult.AccountId, authResult.AccessToken, cancellationToken)
             .MatchAsync(
                 folders =>
                 {
@@ -266,19 +266,19 @@ private void ExecuteBack()
         };
     }
 
-    private async Task ExecuteAddAccountAsync(CancellationToken ct)
+    private async Task ExecuteAddAccountAsync(CancellationToken cancellationToken)
     {
         if (_authResult is null)
             return;
 
         var account = new OneDriveAccount
         {
-            AccountId = _authResult.AccountId,
+            AccountId = AccountId.Create(_authResult.AccountId),
             Profile = _authResult.Profile,
-            SelectedFolders = Folders.Where(f => f.IsSelected).Select(f => new SelectedFolder(f.FolderId, f.Name)).ToList()
+            SelectedFolders = [.. Folders.Where(f => f.IsSelected).Select(f => new SelectedFolder(f.FolderId, f.Name))]
         };
 
-        await _onboardingService.CompleteOnboardingAsync(account, ct)
+        await _onboardingService.CompleteOnboardingAsync(account, cancellationToken)
             .MatchAsync(
                 finalAccount => Completed?.Invoke(this, finalAccount),
                 error =>
@@ -288,7 +288,7 @@ await _onboardingService.CompleteOnboardingAsync(account, ct)
                 });
     }
 
-    private Task ExecuteCancelAsync(CancellationToken ct = default)
+    private Task ExecuteCancelAsync(CancellationToken cancellationToken = default)
     {
         _authCts?.Cancel();
         Cancelled?.Invoke(this, EventArgs.Empty);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Workspace/WorkspaceViewModel.cs b/src/AStar.Dev.CloudSyncFunctional/Workspace/WorkspaceViewModel.cs
index d3f2f39..61f9f37 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Workspace/WorkspaceViewModel.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Workspace/WorkspaceViewModel.cs
@@ -88,12 +88,12 @@ public WorkspaceViewModel(IServiceProvider serviceProvider, IAccountRepository a
     /// <summary>Loads persisted accounts from the database and populates <see cref="Accounts"/>.</summary>
     /// <param name="ct">Cancellation token.</param>
     /// <returns>A task that completes when accounts are loaded and added to the collection.</returns>
-    public async Task LoadPersistedAccountsAsync(CancellationToken ct = default)
+    public async Task LoadPersistedAccountsAsync(CancellationToken cancellationToken = default)
     {
         if (_accountRepository is null)
             return;
 
-        var entities = await _accountRepository.GetAllAsync(ct);
+        var entities = await _accountRepository.GetAllAsync(cancellationToken);
         foreach (var vm in entities.Select(MapToViewModel))
             Accounts.Add(vm);
         if (Accounts.Count > 0 && SelectedAccount is null)
diff --git a/src/AStar.Dev.FunctionalParadigm/Option.cs b/src/AStar.Dev.FunctionalParadigm/Option.cs
index a803b12..95faa28 100644
--- a/src/AStar.Dev.FunctionalParadigm/Option.cs
+++ b/src/AStar.Dev.FunctionalParadigm/Option.cs
@@ -1,22 +1,44 @@
 namespace AStar.Dev.FunctionalParadigm;
 
-public abstract record Option<TResult, TError> : Result<TResult, TError>
+public abstract record Option<TResult>
 {
-    public static implicit operator TResult(Option<TResult, TError> option) =>
+    public static implicit operator TResult(Option<TResult> option) =>
         option switch
         {
-            Some<TResult, TError> some => some.Value,
+            Some<TResult> some => some.Value,
             _ => default!
         };
 
-    public static implicit operator TError(Option<TResult, TError> option) =>
+    public static implicit operator string(Option<TResult> option) =>
         option switch
         {
-            None<TResult, TError> none => none.Error,
-            _ => default!
+            None<TResult> => "missing",
+            Option<TResult>.None => "missing",
+            _ => string.Empty
         };
+        
+    /// <summary>
+    ///     Represents the absence of a value.
+    /// </summary>
+    public sealed record None : Option<TResult>
+    {
+        /// <summary>
+        ///     A helper method to create an instance of <see cref="Option{T}.None" />
+        /// </summary>
+        public static readonly None Instance = new();
+
+        private None()
+        {
+        }
+
+        /// <summary>
+        ///     Overrides the ToString method to return the type as a simple string.
+        /// </summary>
+        /// <returns>The overridden ToString</returns>
+        public override string ToString() => "None";
+    }
 }
 
-public record Some<TResult, TError>(TResult Value) : Option<TResult, TError>;
+public record Some<TResult>(TResult Value) : Option<TResult>;
 
-public record None<TResult, TError>(TError Error) : Option<TResult, TError>;
\ No newline at end of file
+public record None<TResult>() : Option<TResult>;
diff --git a/src/AStar.Dev.FunctionalParadigm/OptionExtensions.cs b/src/AStar.Dev.FunctionalParadigm/OptionExtensions.cs
index c4017ff..2beade0 100644
--- a/src/AStar.Dev.FunctionalParadigm/OptionExtensions.cs
+++ b/src/AStar.Dev.FunctionalParadigm/OptionExtensions.cs
@@ -2,60 +2,52 @@ namespace AStar.Dev.FunctionalParadigm;
 
 public static class OptionExtensions
 {
-    public static Option<TResult, TError> Tap<TResult, TError>(
-        this Option<TResult, TError> option,
-        Action<TResult> onSome,
-        Action<TError>? onNone = null)
+    public static Option<TResult> Tap<TResult>(this Option<TResult> option, Action<TResult> onSome, Action<string>? onNone = null)
     {
-        switch (option)
+        if (option is Some<TResult> some)
         {
-            case Some<TResult, TError> some:
-                onSome(some.Value);
-                return some;
-
-            case None<TResult, TError> none:
-                onNone?.Invoke(none.Error);
-                return none;
-
-            default:
-                throw new InvalidOperationException("Unexpected option type.");
+            onSome(some.Value);
+            return some;
         }
-    }
 
-    public static Option<TMapped, TError> Map<TResult, TMapped, TError>(
-        this Option<TResult, TError> option,
-        Func<TResult, TMapped> selector)
-    {
-        return option switch
+        if (option is None<TResult> none)
         {
-            Some<TResult, TError> some => new Some<TMapped, TError>(selector(some.Value)),
-            None<TResult, TError> none => new None<TMapped, TError>(none.Error),
-            _ => throw new InvalidOperationException("Unexpected option type.")
-        };
-    }
+            onNone?.Invoke(none);
+            return none;
+        }
 
-    public static Option<TMapped, TError> Bind<TResult, TMapped, TError>(
-        this Option<TResult, TError> option,
-        Func<TResult, Option<TMapped, TError>> binder)
-    {
-        return option switch
-        {
-            Some<TResult, TError> some => binder(some.Value),
-            None<TResult, TError> none => new None<TMapped, TError>(none.Error),
-            _ => throw new InvalidOperationException("Unexpected option type.")
-        };
+        throw new InvalidOperationException("Unexpected option type.");
     }
 
-    public static TOut Match<TResult, TError, TOut>(
-        this Option<TResult, TError> option,
-        Func<TResult, TOut> onSome,
-        Func<TError, TOut> onNone)
-    {
-        return option switch
-        {
-            Some<TResult, TError> some => onSome(some.Value),
-            None<TResult, TError> none => onNone(none.Error),
-            _ => throw new InvalidOperationException("Unexpected option type.")
-        };
-    }
+    public static Option<TMapped> Map<TResult, TMapped>(this Option<TResult> option, Func<TResult, TMapped> selector)
+        => option switch
+            {
+                Some<TResult> some => new Some<TMapped>(selector(some.Value)),
+                None<TResult> => new None<TMapped>(),
+                _ => throw new InvalidOperationException("Unexpected option type.")
+            };
+
+    public static Option<TMapped> Bind<TResult, TMapped>(this Option<TResult> option, Func<TResult, Option<TMapped>> binder)
+        => option switch
+            {
+                Some<TResult> some => binder(some.Value),
+                None<TResult> => new None<TMapped>(),
+                _ => throw new InvalidOperationException("Unexpected option type.")
+            };
+
+    public static TOut Match<TResult, TOut>(this Option<TResult> option, Func<TResult, TOut> onSome, Func<string, TOut> onNone)
+        => option switch
+            {
+                Some<TResult> some => onSome(some.Value),
+                None<TResult> none => onNone(none),
+                _ => throw new InvalidOperationException("Unexpected option type.")
+            };
+
+    public static TOut Match<TResult, TOut>(this Option<TResult> option, Func<TResult, TOut> onSome)
+        => option switch
+            {
+                Some<TResult> some => onSome(some.Value),
+                None<TResult> none => new None<TOut>(),
+                _ => throw new InvalidOperationException("Unexpected option type.")
+            };
 }
\ No newline at end of file
diff --git a/src/AStar.Dev.FunctionalParadigm/ResultExtensions.cs b/src/AStar.Dev.FunctionalParadigm/ResultExtensions.cs
index bb12145..41c9d59 100644
--- a/src/AStar.Dev.FunctionalParadigm/ResultExtensions.cs
+++ b/src/AStar.Dev.FunctionalParadigm/ResultExtensions.cs
@@ -34,15 +34,12 @@ public static Result<TResult, TError> Tap<TResult, TError>(this Result<TResult,
     /// <param name="result">The result to map.</param>
     /// <param name="selector">The transformation function.</param>
     /// <returns>A new result with the transformed value, or the original failure.</returns>
-    public static Result<TMapped, TError> Map<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, TMapped> selector)
+    public static Result<TMapped, TError> Map<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, TMapped> selector) => result switch
     {
-        return result switch
-        {
-            Ok<TResult, TError> ok => new Ok<TMapped, TError>(selector(ok.Value)),
-            Fail<TResult, TError> fail => new Fail<TMapped, TError>(fail.Error),
-            _ => throw new InvalidOperationException("Unexpected result type.")
-        };
-    }
+        Ok<TResult, TError> ok => new Ok<TMapped, TError>(selector(ok.Value)),
+        Fail<TResult, TError> fail => new Fail<TMapped, TError>(fail.Error),
+        _ => throw new InvalidOperationException("Unexpected result type.")
+    };
 
     /// <summary>Chains an operation that also returns a result, propagating failure.</summary>
     /// <typeparam name="TResult">The input success type.</typeparam>
@@ -51,15 +48,12 @@ public static Result<TMapped, TError> Map<TResult, TMapped, TError>(this Result<
     /// <param name="result">The result to bind.</param>
     /// <param name="binder">The chained operation.</param>
     /// <returns>The result of the chained operation, or the original failure.</returns>
-    public static Result<TMapped, TError> Bind<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, Result<TMapped, TError>> binder)
+    public static Result<TMapped, TError> Bind<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, Result<TMapped, TError>> binder) => result switch
     {
-        return result switch
-        {
-            Ok<TResult, TError> ok => binder(ok.Value),
-            Fail<TResult, TError> fail => new Fail<TMapped, TError>(fail.Error),
-            _ => throw new InvalidOperationException("Unexpected result type.")
-        };
-    }
+        Ok<TResult, TError> ok => binder(ok.Value),
+        Fail<TResult, TError> fail => new Fail<TMapped, TError>(fail.Error),
+        _ => throw new InvalidOperationException("Unexpected result type.")
+    };
 
     /// <summary>Collapses the result to a single output value by handling both cases.</summary>
     /// <typeparam name="TResult">The success value type.</typeparam>
@@ -69,50 +63,66 @@ public static Result<TMapped, TError> Bind<TResult, TMapped, TError>(this Result
     /// <param name="onSuccess">Function invoked on success.</param>
     /// <param name="onFailure">Function invoked on failure.</param>
     /// <returns>The value produced by whichever branch was taken.</returns>
-    public static TOut Match<TResult, TError, TOut>(this Result<TResult, TError> result, Func<TResult, TOut> onSuccess, Func<TError, TOut> onFailure)
+    public static TOut Match<TResult, TError, TOut>(this Result<TResult, TError> result, Func<TResult, TOut> onSuccess, Func<TError, TOut> onFailure) => result switch
     {
-        return result switch
-        {
-            Ok<TResult, TError> ok => onSuccess(ok.Value),
-            Fail<TResult, TError> fail => onFailure(fail.Error),
-            _ => throw new InvalidOperationException("Unexpected result type.")
-        };
-    }
+        Ok<TResult, TError> ok => onSuccess(ok.Value),
+        Fail<TResult, TError> fail => onFailure(fail.Error),
+        _ => throw new InvalidOperationException("Unexpected result type.")
+    };
 
-    /// <summary>Asynchronously handles both result cases as side-effects.</summary>
+    /// <param name="taskResult">The task producing the result.</param>
     /// <typeparam name="TResult">The success value type.</typeparam>
     /// <typeparam name="TError">The error type.</typeparam>
-    /// <param name="taskResult">The task producing the result.</param>
-    /// <param name="onSuccess">Action invoked on success.</param>
-    /// <param name="onFailure">Action invoked on failure.</param>
-    /// <returns>A task that completes after the appropriate action runs.</returns>
-    public static async Task MatchAsync<TResult, TError>(this Task<Result<TResult, TError>> taskResult, Action<TResult> onSuccess, Action<TError> onFailure)
+    extension<TResult, TError>(Task<Result<TResult, TError>> taskResult)
     {
-        var result = await taskResult.ConfigureAwait(false);
-        switch (result)
+        /// <summary>Asynchronously handles both result cases as side-effects.</summary>
+        /// <param name="onSuccess">Action invoked on success.</param>
+        /// <param name="onFailure">Action invoked on failure.</param>
+        /// <returns>A task that completes after the appropriate action runs.</returns>
+        public async Task MatchAsync(Action<TResult> onSuccess, Action<TError> onFailure)
         {
-            case Ok<TResult, TError> ok:
-                onSuccess(ok.Value);
-                break;
-            case Fail<TResult, TError> fail:
-                onFailure(fail.Error);
-                break;
+            var result = await taskResult.ConfigureAwait(false);
+            switch (result)
+            {
+                case Ok<TResult, TError> ok:
+                    onSuccess(ok.Value);
+                    break;
+                case Fail<TResult, TError> fail:
+                    onFailure(fail.Error);
+                    break;
+            }
         }
-    }
 
-    /// <summary>Asynchronously collapses the result to a single output value by handling both cases.</summary>
-    /// <typeparam name="TResult">The success value type.</typeparam>
-    /// <typeparam name="TError">The error type.</typeparam>
-    /// <typeparam name="TOut">The output type.</typeparam>
-    /// <param name="taskResult">The task producing the result.</param>
-    /// <param name="onSuccess">Function invoked on success.</param>
-    /// <param name="onFailure">Function invoked on failure.</param>
-    /// <returns>A task that produces the value from whichever branch was taken.</returns>
-    public static async Task<TOut> MatchAsync<TResult, TError, TOut>(this Task<Result<TResult, TError>> taskResult, Func<TResult, TOut> onSuccess, Func<TError, TOut> onFailure)
-    {
-        var result = await taskResult.ConfigureAwait(false);
+        /// <summary>Asynchronously collapses the result to a single output value by handling both cases.</summary>
+        /// <typeparam name="TOut">The output type.</typeparam>
+        /// <param name="onSuccess">Function invoked on success.</param>
+        /// <param name="onFailure">Function invoked on failure.</param>
+        /// <returns>A task that produces the value from whichever branch was taken.</returns>
+        public async Task<TOut> MatchAsync<TOut>(Func<TResult, TOut> onSuccess, Func<TError, TOut> onFailure)
+        {
+            var result = await taskResult.ConfigureAwait(false);
+
+            return result.Match(onSuccess, onFailure);
+        }
+
+        /// <summary>Asynchronously collapses the result to a single output value by handling both cases.</summary>
+        /// <typeparam name="TOut">The output type.</typeparam>
+        /// <param name="onSuccess">Function invoked on success.</param>
+        /// <param name="onFailure">Function invoked on failure.</param>
+        /// <returns>A task that produces the value from whichever branch was taken.</returns>
+        /// <exception cref="InvalidOperationException"></exception>
+        public async Task<TOut> MatchAsync<TOut>(Func<TResult, Task<TOut>> onSuccess,
+            Func<TError, Task<TOut>> onFailure)
+        {
+            var result = await taskResult.ConfigureAwait(false);
 
-        return result.Match(onSuccess, onFailure);
+            return result switch
+            {
+                Ok<TResult, TError> ok => await onSuccess(ok.Value).ConfigureAwait(false),
+                Fail<TResult, TError> fail => await onFailure(fail.Error).ConfigureAwait(false),
+                _ => throw new InvalidOperationException("Unexpected result type.")
+            };
+        }
     }
 
     /// <summary>Asynchronously chains an operation that also returns a result, propagating failure.</summary>
@@ -133,4 +143,70 @@ public static async Task<Result<TMapped, TError>> BindAsync<TResult, TMapped, TE
             _ => throw new InvalidOperationException("Unexpected result type.")
         };
     }
+    /// <summary>Chains an asynchronous operation that also returns a result, propagating failure.</summary>
+    /// <typeparam name="TResult">The input success type.</typeparam>
+    /// <typeparam name="TMapped">The output success type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <param name="result">The result to bind.</param>
+    /// <param name="binder">The async chained operation to invoke on success.</param>
+    /// <returns>The result of the chained operation, or the original failure.</returns>
+    public static async Task<Result<TMapped, TError>> BindAsync<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, Task<Result<TMapped, TError>>> binder) => result switch
+    {
+        Ok<TResult, TError> ok => await binder(ok.Value).ConfigureAwait(false),
+        Fail<TResult, TError> fail => new Fail<TMapped, TError>(fail.Error),
+        _ => throw new InvalidOperationException("Unexpected result type.")
+    };
+
+    /// <summary>Asynchronously transforms the success value using the provided selector.</summary>
+    /// <typeparam name="TResult">The input success type.</typeparam>
+    /// <typeparam name="TMapped">The output success type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <param name="result">The result to map.</param>
+    /// <param name="selector">The transformation function.</param>
+    /// <returns>A task containing a new result with the transformed value, or the original failure.</returns>
+    public static Task<Result<TMapped, TError>> MapAsync<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, TMapped> selector)
+            => Task.FromResult(result.Map(selector));
+
+    /// <summary>Asynchronously transforms the success value using the provided asynchronous selector.</summary>
+    /// <typeparam name="TResult">The input success type.</typeparam>
+    /// <typeparam name="TMapped">The output success type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <param name="result">The result to map.</param>
+    /// <param name="selector">The async transformation function.</param>
+    /// <returns>A task containing a new result with the transformed value, or the original failure.</returns>
+    public static async Task<Result<TMapped, TError>> MapAsync<TResult, TMapped, TError>(this Result<TResult, TError> result, Func<TResult, Task<TMapped>> selector) => result switch
+    {
+        Ok<TResult, TError> ok => new Ok<TMapped, TError>(await selector(ok.Value).ConfigureAwait(false)),
+        Fail<TResult, TError> fail => new Fail<TMapped, TError>(fail.Error),
+        _ => throw new InvalidOperationException("Unexpected result type.")
+    };
+
+    /// <summary>Asynchronously transforms the success value of a task result using the provided selector.</summary>
+    /// <typeparam name="TResult">The input success type.</typeparam>
+    /// <typeparam name="TMapped">The output success type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <param name="taskResult">The task producing the result to map.</param>
+    /// <param name="selector">The transformation function.</param>
+    /// <returns>A task containing a new result with the transformed value, or the original failure.</returns>
+    public static async Task<Result<TMapped, TError>> MapAsync<TResult, TMapped, TError>(this Task<Result<TResult, TError>> taskResult, Func<TResult, TMapped> selector)
+        {
+            var result = await taskResult.ConfigureAwait(false);
+
+            return result.Map(selector);
+        }
+
+        /// <summary>Asynchronously transforms the success value of a task result using the provided asynchronous selector.</summary>
+        /// <typeparam name="TResult">The input success type.</typeparam>
+        /// <typeparam name="TMapped">The output success type.</typeparam>
+        /// <typeparam name="TError">The error type.</typeparam>
+        /// <param name="taskResult">The task producing the result to map.</param>
+        /// <param name="selector">The async transformation function.</param>
+        /// <returns>A task containing a new result with the transformed value, or the original failure.</returns>
+        public static async Task<Result<TMapped, TError>> MapAsync<TResult, TMapped, TError>(this Task<Result<TResult, TError>> taskResult, Func<TResult, Task<TMapped>> selector)
+        {
+            var result = await taskResult.ConfigureAwait(false);
+
+            return await result.MapAsync(selector).ConfigureAwait(false);
+        }
+        
 }
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/AStar.Dev.CloudSyncFunctional.Tests.Integration.csproj b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/AStar.Dev.CloudSyncFunctional.Tests.Integration.csproj
index ccf05ec..9096bd5 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/AStar.Dev.CloudSyncFunctional.Tests.Integration.csproj
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/AStar.Dev.CloudSyncFunctional.Tests.Integration.csproj
@@ -23,12 +23,14 @@
     <PackageReference Include="xunit.v3.mtp-v2" Version="3.2.2" />
     <PackageReference Include="Shouldly" Version="4.3.0" />
     <PackageReference Include="NSubstitute" Version="5.3.0" />
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="10.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Data.Sqlite" Version="10.0.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.8" />
     <PackageReference Include="coverlet.collector" Version="10.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="Testably.Abstractions" Version="10.2.0" />
+    <PackageReference Include="Testably.Abstractions.Testing" Version="6.2.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Onboarding/GivenAnAccountOnboardingServiceIntegration.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Onboarding/GivenAnAccountOnboardingServiceIntegration.cs
index 7c1969d..62b0e2d 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Onboarding/GivenAnAccountOnboardingServiceIntegration.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Onboarding/GivenAnAccountOnboardingServiceIntegration.cs
@@ -6,6 +6,9 @@
 using AStar.Dev.CloudSyncFunctional.Tests.Integration.TestData;
 using AStar.Dev.FunctionalParadigm;
 using Microsoft.Extensions.Logging;
+using Testably.Abstractions;
+using Testably.Abstractions.Testing;
+using AccountId = AStar.Dev.CloudSyncFunctional.Persistence.ValueObjects.AccountId;
 
 namespace AStar.Dev.CloudSyncFunctional.Tests.Integration.Onboarding;
 
@@ -14,6 +17,7 @@ public class GivenAnAccountOnboardingServiceIntegration(DatabaseFixture db) : IC
     private AccountOnboardingService CreateSut() =>
         new(new AccountRepository(new TestDbContextFactory(db.Connection)),
             new SyncRuleRepository(new TestDbContextFactory(db.Connection)),
+            new RealFileSystem(),
             Substitute.For<ILogger<AccountOnboardingService>>());
 
     private SyncRuleRepository CreateSyncRuleRepo() =>
@@ -25,9 +29,9 @@ private AccountRepository CreateAccountRepo() =>
     private static OneDriveAccount CreateAccount(params string[] folderNames) =>
         new()
         {
-            AccountId = Guid.NewGuid().ToString(),
+            AccountId = new Auth.AccountId(Guid.NewGuid().ToString()),
             Profile = new AccountProfile("Test User", "test@example.com"),
-            SelectedFolders = folderNames.Select((name, i) => new SelectedFolder($"graph-id-{i}", name)).ToList()
+            SelectedFolders = [.. folderNames.Select((name, i) => new SelectedFolder($"graph-id-{i}", name))]
         };
 
     [Fact]
@@ -48,9 +52,9 @@ public async Task when_complete_onboarding_is_called_then_account_is_persisted()
         var sut = CreateSut();
 
         await sut.CompleteOnboardingAsync(account, CancellationToken.None);
-        var stored = await CreateAccountRepo().GetByIdAsync(new AccountId(account.AccountId), CancellationToken.None);
+        var stored = await CreateAccountRepo().GetByIdAsync(new AccountId(account.AccountId.Value), CancellationToken.None);
 
-        stored.ShouldBeOfType<Some<Persistence.Entities.AccountEntity, PersistenceError>>();
+        stored.ShouldBeOfType<Some<Persistence.Entities.AccountEntity>>();
     }
 
     [Fact]
@@ -60,7 +64,7 @@ public async Task when_complete_onboarding_is_called_then_sync_rules_are_persist
         var sut = CreateSut();
 
         await sut.CompleteOnboardingAsync(account, CancellationToken.None);
-        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId), CancellationToken.None);
+        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId.Value), CancellationToken.None);
 
         rules.Count.ShouldBe(2);
     }
@@ -72,7 +76,7 @@ public async Task when_complete_onboarding_is_called_with_no_folders_then_no_syn
         var sut = CreateSut();
 
         await sut.CompleteOnboardingAsync(account, CancellationToken.None);
-        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId), CancellationToken.None);
+        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId.Value), CancellationToken.None);
 
         rules.ShouldBeEmpty();
     }
@@ -82,14 +86,14 @@ public async Task when_complete_onboarding_is_called_then_sync_rule_remote_path_
     {
         var account = new OneDriveAccount
         {
-            AccountId = Guid.NewGuid().ToString(),
+            AccountId = new Auth.AccountId(Guid.NewGuid().ToString()),
             Profile = new AccountProfile("Test User", "test@example.com"),
             SelectedFolders = [new SelectedFolder("graph-item-id-abc123", "Documents")]
         };
         var sut = CreateSut();
 
         await sut.CompleteOnboardingAsync(account, CancellationToken.None);
-        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId), CancellationToken.None);
+        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId.Value), CancellationToken.None);
 
         rules[0].RemotePath.ShouldBe("/Documents");
     }
@@ -99,14 +103,14 @@ public async Task when_complete_onboarding_is_called_then_sync_rule_remote_path_
     {
         var account = new OneDriveAccount
         {
-            AccountId = Guid.NewGuid().ToString(),
+            AccountId = new Auth.AccountId(Guid.NewGuid().ToString()),
             Profile = new AccountProfile("Test User", "test@example.com"),
             SelectedFolders = [new SelectedFolder("graph-item-id-abc123", "Pictures")]
         };
         var sut = CreateSut();
 
         await sut.CompleteOnboardingAsync(account, CancellationToken.None);
-        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId), CancellationToken.None);
+        var rules = await CreateSyncRuleRepo().GetByAccountAsync(new AccountId(account.AccountId.Value), CancellationToken.None);
 
         rules[0].RemotePath.ShouldNotContain("graph-item-id-abc123");
     }
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenADriveStateRepository.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenADriveStateRepository.cs
index 9648f63..e47f263 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenADriveStateRepository.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenADriveStateRepository.cs
@@ -58,7 +58,7 @@ public async Task when_a_drive_state_is_retrieved_then_it_matches_what_was_store
         await sut.UpsertAsync(entity, CancellationToken.None);
         var result = await sut.GetByAccountAsync(accountId, CancellationToken.None);
 
-        var some = (Some<DriveStateEntity, PersistenceError>)result;
+        var some = (Some<DriveStateEntity>)result;
         some.Value.DeltaLink.ShouldBe(entity.DeltaLink);
     }
 
@@ -70,6 +70,6 @@ public async Task when_drive_state_for_non_existent_account_is_retrieved_then_re
 
         var result = await sut.GetByAccountAsync(missingId, CancellationToken.None);
 
-        result.ShouldBeOfType<None<DriveStateEntity, PersistenceError>>();
+        result.ShouldBeOfType<None<DriveStateEntity>>();
     }
 }
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenAnAccountRepository.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenAnAccountRepository.cs
index 9e64613..d87d857 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenAnAccountRepository.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Integration/Repositories/GivenAnAccountRepository.cs
@@ -46,7 +46,7 @@ public async Task when_an_account_is_upserted_then_it_can_be_retrieved_by_id()
         await sut.UpsertAsync(entity, CancellationToken.None);
         var result = await sut.GetByIdAsync(entity.Id, CancellationToken.None);
 
-        result.ShouldBeOfType<Some<AccountEntity, PersistenceError>>();
+        result.ShouldBeOfType<Some<AccountEntity>>();
     }
 
     [Fact]
@@ -57,7 +57,7 @@ public async Task when_a_non_existent_account_is_retrieved_then_result_is_none()
 
         var result = await sut.GetByIdAsync(missingId, CancellationToken.None);
 
-        result.ShouldBeOfType<None<AccountEntity, PersistenceError>>();
+        result.ShouldBeOfType<None<AccountEntity>>();
     }
 
     [Fact]
@@ -70,7 +70,7 @@ public async Task when_an_account_is_deleted_then_get_by_id_returns_none()
         await sut.DeleteAsync(entity.Id, CancellationToken.None);
         var result = await sut.GetByIdAsync(entity.Id, CancellationToken.None);
 
-        result.ShouldBeOfType<None<AccountEntity, PersistenceError>>();
+        result.ShouldBeOfType<None<AccountEntity>>();
     }
 
     [Fact]
@@ -108,7 +108,7 @@ public async Task when_an_account_is_retrieved_then_profile_email_is_preserved()
         await sut.UpsertAsync(entity, CancellationToken.None);
         var result = await sut.GetByIdAsync(entity.Id, CancellationToken.None);
 
-        var some = (Some<AccountEntity, PersistenceError>)result;
+        var some = (Some<AccountEntity>)result;
         some.Value.Profile.Email.Value.ShouldBe("test@example.com");
     }
 
@@ -121,7 +121,7 @@ public async Task when_an_account_is_retrieved_then_sync_config_worker_count_is_
         await sut.UpsertAsync(entity, CancellationToken.None);
         var result = await sut.GetByIdAsync(entity.Id, CancellationToken.None);
 
-        var some = (Some<AccountEntity, PersistenceError>)result;
+        var some = (Some<AccountEntity>)result;
         some.Value.SyncConfig.WorkerCount.ShouldBe(4);
     }
 
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/AStar.Dev.CloudSyncFunctional.Tests.Unit.csproj b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/AStar.Dev.CloudSyncFunctional.Tests.Unit.csproj
index 3369c34..74c9c48 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/AStar.Dev.CloudSyncFunctional.Tests.Unit.csproj
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/AStar.Dev.CloudSyncFunctional.Tests.Unit.csproj
@@ -27,11 +27,13 @@
     <PackageReference Include="xunit.v3.mtp-v2" Version="3.2.2" />
     <PackageReference Include="Shouldly" Version="4.3.0" />
     <PackageReference Include="NSubstitute" Version="5.3.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.8" />
     <PackageReference Include="coverlet.collector" Version="10.0.1">
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="Testably.Abstractions" Version="10.2.0" />
+    <PackageReference Include="Testably.Abstractions.Testing" Version="6.2.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenADriveId.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenADriveId.cs
new file mode 100644
index 0000000..79eaed3
--- /dev/null
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenADriveId.cs
@@ -0,0 +1,12 @@
+namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Auth;
+
+public sealed class GivenADriveId
+{
+    [Fact]
+    public void when_create_is_called_then_value_is_set()
+    {
+        var id = new CloudSyncFunctional.Auth.DriveId("id");
+
+        id.Value.ShouldBe("id");
+    }
+}
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountId.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountId.cs
new file mode 100644
index 0000000..9a53446
--- /dev/null
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountId.cs
@@ -0,0 +1,12 @@
+namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Auth;
+
+public sealed class GivenAnAccountId
+{
+    [Fact]
+    public void when_create_is_called_then_value_is_set()
+    {
+        var id = new CloudSyncFunctional.Auth.AccountId("id");
+
+        id.Value.ShouldBe("id");
+    }
+}
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountProfile.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountProfile.cs
new file mode 100644
index 0000000..ba772b3
--- /dev/null
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountProfile.cs
@@ -0,0 +1,15 @@
+using AStar.Dev.CloudSyncFunctional.Auth;
+
+namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Auth;
+
+public sealed class GivenAnAccountProfile
+{
+    [Fact]
+    public void when_create_is_called_then_properties_are_set()
+    {
+        var profile = AccountProfileFactory.Create("Test User", "test@example.com");
+
+        profile.DisplayName.ShouldBe("Test User");
+        profile.Email.ShouldBe("test@example.com");
+    }
+}
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAuthResult.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAuthResult.cs
index fb046b4..fec95fe 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAuthResult.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAuthResult.cs
@@ -10,7 +10,7 @@ public class GivenAnAuthResult
     [Fact]
     public void when_create_is_called_then_access_token_is_set()
     {
-        var result = AuthResultFactory.Create("token123", "account-id", TestProfile, TestExpiry);
+        var result = AuthResultFactory.Create("token123", "account-id-abc", TestProfile, TestExpiry);
 
         result.AccessToken.ShouldBe("token123");
     }
@@ -26,7 +26,7 @@ public void when_create_is_called_then_account_id_is_set()
     [Fact]
     public void when_create_is_called_then_profile_is_set()
     {
-        var result = AuthResultFactory.Create("token", "id", TestProfile, TestExpiry);
+        var result = AuthResultFactory.Create("token", "account-id", TestProfile, TestExpiry);
 
         result.Profile.ShouldBeSameAs(TestProfile);
     }
@@ -34,26 +34,8 @@ public void when_create_is_called_then_profile_is_set()
     [Fact]
     public void when_create_is_called_then_expires_on_is_set()
     {
-        var result = AuthResultFactory.Create("token", "id", TestProfile, TestExpiry);
+        var result = AuthResultFactory.Create("token", "account-id", TestProfile, TestExpiry);
 
         result.ExpiresOn.ShouldBe(TestExpiry);
     }
-
-    [Fact]
-    public void when_create_is_called_with_empty_access_token_then_throws()
-    {
-        Should.Throw<ArgumentException>(() => AuthResultFactory.Create("", "id", TestProfile, TestExpiry));
-    }
-
-    [Fact]
-    public void when_create_is_called_with_empty_account_id_then_throws()
-    {
-        Should.Throw<ArgumentException>(() => AuthResultFactory.Create("token", "", TestProfile, TestExpiry));
-    }
-
-    [Fact]
-    public void when_create_is_called_with_null_profile_then_throws()
-    {
-        Should.Throw<ArgumentNullException>(() => AuthResultFactory.Create("token", "id", null!, TestExpiry));
-    }
 }
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/FunctionalParadigm/GivenAUnit.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/FunctionalParadigm/GivenAUnit.cs
index c856b5a..af734df 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/FunctionalParadigm/GivenAUnit.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/FunctionalParadigm/GivenAUnit.cs
@@ -5,16 +5,10 @@ namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.FunctionalParadigm;
 public class GivenAUnit
 {
     [Fact]
-    public void when_default_is_accessed_then_returns_non_null_instance()
-    {
-        FpUnit.Default.ShouldNotBeNull();
-    }
+    public void when_default_is_accessed_then_returns_non_null_instance() => FpUnit.Default.ShouldNotBeNull();
 
     [Fact]
-    public void when_default_is_accessed_twice_then_same_reference_is_returned()
-    {
-        FpUnit.Default.ShouldBeSameAs(FpUnit.Default);
-    }
+    public void when_default_is_accessed_twice_then_same_reference_is_returned() => FpUnit.Default.ShouldBeSameAs(FpUnit.Default);
 
     [Fact]
     public void when_two_unit_instances_are_compared_then_they_are_equal()
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphClientFactory.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphClientFactory.cs
index 3959a99..5a7e7ac 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphClientFactory.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphClientFactory.cs
@@ -1,21 +1,45 @@
 using AStar.Dev.CloudSyncFunctional.Graph;
+using AStar.Dev.FunctionalParadigm;
+using Microsoft.Graph;
+using LocalGraphClientFactory = AStar.Dev.CloudSyncFunctional.Graph.GraphClientFactory;
 
 namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Graph;
 
-public sealed class GivenAGraphClientFactory
+public sealed class GivenALocalGraphClientFactory
 {
     [Fact]
-    public void when_create_client_with_valid_token_then_returns_non_null_client() =>
-        new GraphClientFactory().CreateClient("test-token").ShouldNotBeNull();
+    public void when_create_client_with_valid_token_then_returns_non_null_client()
+    {
+        var result = new LocalGraphClientFactory().CreateClient("test-token");
+
+        var ok = result.ShouldBeOfType<Ok<GraphServiceClient, GraphError>>();
+        ok.Value.ShouldNotBeNull();
+    }
 
     [Fact]
     public void when_create_client_with_different_tokens_then_returns_distinct_instances()
     {
-        var factory = new GraphClientFactory();
+        var factory = new LocalGraphClientFactory();
+
+        var ok1 = factory.CreateClient("token-a").ShouldBeOfType<Ok<GraphServiceClient, GraphError>>();
+        var ok2 = factory.CreateClient("token-b").ShouldBeOfType<Ok<GraphServiceClient, GraphError>>();
 
-        var client1 = factory.CreateClient("token-a");
-        var client2 = factory.CreateClient("token-b");
+        ok1.Value.ShouldNotBeSameAs(ok2.Value);
+    }
+
+    [Fact]
+    public void when_create_client_with_null_token_then_returns_failure()
+    {
+        var result = new LocalGraphClientFactory().CreateClient(null!);
+
+        result.ShouldBeOfType<Fail<GraphServiceClient, GraphError>>();
+    }
+
+    [Fact]
+    public void when_create_client_with_empty_token_then_returns_failure()
+    {
+        var result = new LocalGraphClientFactory().CreateClient(string.Empty);
 
-        client1.ShouldNotBeSameAs(client2);
+        result.ShouldBeOfType<Fail<GraphServiceClient, GraphError>>();
     }
 }
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphService.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphService.cs
index 2bd4f2c..6fc8187 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphService.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Graph/GivenAGraphService.cs
@@ -1,7 +1,9 @@
+using System.Net;
 using AStar.Dev.CloudSyncFunctional.Graph;
 using AStar.Dev.FunctionalParadigm;
 using Microsoft.Extensions.Logging;
 using Microsoft.Graph;
+using Microsoft.Kiota.Abstractions.Authentication;
 
 namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Graph;
 
@@ -14,7 +16,7 @@ private static GraphService CreateSut(IGraphClientFactory? factory = null) =>
     public async Task when_client_factory_throws_then_get_root_folders_returns_unexpected_graph_error()
     {
         var factory = Substitute.For<IGraphClientFactory>();
-        factory.CreateClient(Arg.Any<string>()).Returns<GraphServiceClient>(_ => throw new Exception("network failure"));
+        factory.CreateClient(Arg.Any<string>()).Returns(_ => throw new Exception("network failure"));
         var sut = CreateSut(factory);
 
         var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
@@ -28,7 +30,7 @@ public async Task when_client_factory_throws_then_get_root_folders_returns_unexp
     public async Task when_client_factory_throws_then_error_message_is_not_null_or_empty()
     {
         var factory = Substitute.For<IGraphClientFactory>();
-        factory.CreateClient(Arg.Any<string>()).Returns<GraphServiceClient>(_ => throw new Exception("network failure"));
+        factory.CreateClient(Arg.Any<string>()).Returns(_ => throw new Exception("network failure"));
         var sut = CreateSut(factory);
 
         var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
@@ -36,4 +38,334 @@ public async Task when_client_factory_throws_then_error_message_is_not_null_or_e
         var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
         fail.Error.Message.ShouldNotBeNullOrEmpty();
     }
-}
+
+    [Fact]
+    public async Task when_drive_is_null_then_get_root_folders_returns_unexpected_graph_error()
+    {
+        var sut = CreateSut(CreateFactory(
+            NoContentResponse()));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("Drive was null.");
+    }
+
+    [Fact]
+    public async Task when_root_is_null_then_get_root_folders_returns_unexpected_graph_error()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            NoContentResponse()));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("Root item was null.");
+    }
+
+    [Fact]
+    public async Task when_root_id_is_null_then_get_root_folders_returns_unexpected_graph_error()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "name": "root" }""")));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("Root item was null.");
+    }
+
+    [Fact]
+    public async Task when_first_folder_page_is_null_then_get_root_folders_returns_unexpected_graph_error()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            NoContentResponse()));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("Folder page was null.");
+    }
+
+    [Fact]
+    public async Task when_root_has_no_children_then_get_root_folders_returns_empty_success()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            JsonResponse("""{ "value": [] }""")));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var ok = result.ShouldBeOfType<Ok<List<DriveFolder>, GraphError>>();
+        ok.Value.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task when_root_contains_files_and_folders_then_get_root_folders_returns_only_folders()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            JsonResponse(
+                """
+                {
+                  "value": [
+                    {
+                      "id": "folder-1",
+                      "name": "Documents",
+                      "folder": {},
+                      "parentReference": { "id": "root-id" }
+                    },
+                    {
+                      "id": "file-1",
+                      "name": "notes.txt",
+                      "file": {}
+                    },
+                    {
+                      "id": "folder-2",
+                      "name": "Pictures",
+                      "folder": {}
+                    }
+                  ]
+                }
+                """)));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var ok = result.ShouldBeOfType<Ok<List<DriveFolder>, GraphError>>();
+        ok.Value.Count.ShouldBe(2);
+        ok.Value[0].ShouldBe(new DriveFolder("folder-1", "Documents", "root-id"));
+        ok.Value[1].ShouldBe(new DriveFolder("folder-2", "Pictures", null));
+    }
+
+    [Fact]
+    public async Task when_folder_results_are_paged_then_get_root_folders_returns_folders_from_all_pages()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            JsonResponse(
+                """
+                {
+                  "@odata.nextLink": "https://graph.microsoft.com/v1.0/drives/drive-id/items/root-id/children?$skiptoken=next",
+                  "value": [
+                    {
+                      "id": "folder-1",
+                      "name": "Documents",
+                      "folder": {},
+                      "parentReference": { "id": "root-id" }
+                    }
+                  ]
+                }
+                """),
+            JsonResponse(
+                """
+                {
+                  "value": [
+                    {
+                      "id": "folder-2",
+                      "name": "Pictures",
+                      "folder": {},
+                      "parentReference": { "id": "root-id" }
+                    }
+                  ]
+                }
+                """)));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var ok = result.ShouldBeOfType<Ok<List<DriveFolder>, GraphError>>();
+        ok.Value.ShouldBe([
+            new DriveFolder("folder-1", "Documents", "root-id"),
+            new DriveFolder("folder-2", "Pictures", "root-id")
+        ]);
+    }
+
+    [Fact]
+    public async Task when_next_folder_page_is_null_then_get_root_folders_returns_unexpected_graph_error()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            JsonResponse(
+                """
+                {
+                  "@odata.nextLink": "https://graph.microsoft.com/v1.0/drives/drive-id/items/root-id/children?$skiptoken=next",
+                  "value": [
+                    {
+                      "id": "folder-1",
+                      "name": "Documents",
+                      "folder": {}
+                    }
+                  ]
+                }
+                """),
+            NoContentResponse()));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("Folder page was null.");
+    }
+
+    [Fact]
+    public async Task when_graph_request_throws_then_get_root_folders_returns_unexpected_graph_error()
+    {
+        var sut = CreateSut(CreateFactory(
+            _ => throw new HttpRequestException("Graph request failed")));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("Graph request failed");
+    }
+    
+    // ... existing code ...
+
+    [Fact]
+    public async Task when_client_factory_returns_failure_then_get_root_folders_returns_that_graph_error()
+    {
+        var factory = Substitute.For<IGraphClientFactory>();
+        factory.CreateClient(Arg.Any<string>())
+            .Returns(new Fail<GraphServiceClient, GraphError>(GraphErrorFactory.Unexpected("client creation failed")));
+        var sut = CreateSut(factory);
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var fail = result.ShouldBeOfType<Fail<List<DriveFolder>, GraphError>>();
+        fail.Error.ShouldBeOfType<GraphUnexpectedError>();
+        fail.Error.Message.ShouldContain("client creation failed");
+    }
+
+    [Fact]
+    public async Task when_folder_page_has_null_value_then_get_root_folders_returns_empty_success()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            JsonResponse("""{}""")));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var ok = result.ShouldBeOfType<Ok<List<DriveFolder>, GraphError>>();
+        ok.Value.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task when_folder_items_have_missing_id_or_name_then_get_root_folders_skips_them()
+    {
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            JsonResponse(
+                """
+                {
+                  "value": [
+                    {
+                      "name": "Missing Id",
+                      "folder": {},
+                      "parentReference": { "id": "root-id" }
+                    },
+                    {
+                      "id": "missing-name",
+                      "folder": {},
+                      "parentReference": { "id": "root-id" }
+                    },
+                    {
+                      "id": "valid-folder",
+                      "name": "Valid Folder",
+                      "folder": {},
+                      "parentReference": { "id": "root-id" }
+                    }
+                  ]
+                }
+                """)));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var ok = result.ShouldBeOfType<Ok<List<DriveFolder>, GraphError>>();
+        ok.Value.ShouldBe([
+            new DriveFolder("valid-folder", "Valid Folder", "root-id")
+        ]);
+    }
+
+    [Fact]
+    public async Task when_requesting_first_folder_page_then_expected_select_fields_are_requested()
+    {
+        HttpRequestMessage? childrenRequest = null;
+
+        var sut = CreateSut(CreateFactory(
+            JsonResponse("""{ "id": "drive-id" }"""),
+            JsonResponse("""{ "id": "root-id", "name": "root" }"""),
+            request =>
+            {
+                childrenRequest = request;
+
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent("""{ "value": [] }""", System.Text.Encoding.UTF8, "application/json")
+                };
+            }));
+
+        var result = await sut.GetRootFoldersAsync("account-id", "access-token", TestContext.Current.CancellationToken);
+
+        var ok = result.ShouldBeOfType<Ok<List<DriveFolder>, GraphError>>();
+        ok.Value.ShouldBeEmpty();
+
+        childrenRequest.ShouldNotBeNull();
+        var decodedQuery = Uri.UnescapeDataString(childrenRequest.RequestUri?.Query ?? string.Empty);
+
+        decodedQuery.ShouldContain("$select=");
+        decodedQuery.ShouldContain("id");
+        decodedQuery.ShouldContain("name");
+        decodedQuery.ShouldContain("folder");
+        decodedQuery.ShouldContain("parentReference");
+    }
+
+    private static IGraphClientFactory CreateFactory(params Func<HttpRequestMessage, HttpResponseMessage>[] responses)
+    {
+        var factory = Substitute.For<IGraphClientFactory>();
+        factory.CreateClient(Arg.Any<string>()).Returns(new Ok<GraphServiceClient, GraphError>(new GraphServiceClient(
+            new HttpClient(new StubGraphMessageHandler(responses))
+            {
+                BaseAddress = new Uri("https://graph.microsoft.com/v1.0/")
+            },
+            new AnonymousAuthenticationProvider())));
+
+        return factory;
+    }
+
+    private static Func<HttpRequestMessage, HttpResponseMessage> JsonResponse(string json) =>
+        _ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json")
+        };
+
+    private static Func<HttpRequestMessage, HttpResponseMessage> NoContentResponse() =>
+        _ => new HttpResponseMessage(HttpStatusCode.NoContent);
+
+    private sealed class StubGraphMessageHandler(params Func<HttpRequestMessage, HttpResponseMessage>[] responses) : HttpMessageHandler
+    {
+        private int requestIndex;
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            requestIndex.ShouldBeLessThan(
+                responses.Length,
+                $"Unexpected Graph request: {request.Method} {request.RequestUri}");
+
+            return Task.FromResult(responses[requestIndex++](request));
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Onboarding/GivenAnAccountOnboardingService.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Onboarding/GivenAnAccountOnboardingService.cs
index e1148b4..259decd 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Onboarding/GivenAnAccountOnboardingService.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Onboarding/GivenAnAccountOnboardingService.cs
@@ -5,6 +5,9 @@
 using AStar.Dev.CloudSyncFunctional.Persistence.Repositories;
 using AStar.Dev.FunctionalParadigm;
 using Microsoft.Extensions.Logging;
+using Testably.Abstractions;
+using System.IO.Abstractions;
+using Testably.Abstractions.Testing;
 using FpUnit = AStar.Dev.FunctionalParadigm.Unit;
 
 namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Onboarding;
@@ -21,13 +24,13 @@ private static AccountOnboardingService CreateSut()
         syncRuleRepo.UpsertAsync(Arg.Any<SyncRuleEntity>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<FpUnit, PersistenceError>>(new Ok<FpUnit, PersistenceError>(FpUnit.Default)));
 
-        return new AccountOnboardingService(accountRepo, syncRuleRepo, Substitute.For<ILogger<AccountOnboardingService>>());
+        return new AccountOnboardingService(accountRepo, syncRuleRepo, new MockFileSystem(), Substitute.For<ILogger<AccountOnboardingService>>());
     }
 
     private static OneDriveAccount CreateAccount() =>
         new()
         {
-            AccountId = "test-account-id",
+            AccountId = CloudSyncFunctional.Auth.AccountId.Create("test-account-id"),
             Profile = new AccountProfile("Test User", "test@example.com"),
             SelectedFolders = [new SelectedFolder("folder-1-id", "folder-1"), new SelectedFolder("folder-2-id", "folder-2")]
         };
@@ -52,7 +55,7 @@ public async Task when_complete_onboarding_is_called_then_returned_account_has_s
         var result = await sut.CompleteOnboardingAsync(account, CancellationToken.None);
 
         var ok = (Ok<OneDriveAccount, PersistenceError>)result;
-        ok.Value.AccountId.ShouldBe("test-account-id");
+        ok.Value.AccountId.Value.ShouldBe("test-account-id");
     }
 
     [Fact]
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Wizard/GivenAnAddAccountWizardViewModel.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Wizard/GivenAnAddAccountWizardViewModel.cs
index 6a3b27a..93557d1 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Wizard/GivenAnAddAccountWizardViewModel.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Wizard/GivenAnAddAccountWizardViewModel.cs
@@ -168,7 +168,7 @@ public async Task when_sign_in_succeeds_then_step_is_select_folders()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test User", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
@@ -189,7 +189,7 @@ public async Task when_sign_in_succeeds_then_is_signed_in_is_true()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test User", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
@@ -210,7 +210,7 @@ public async Task when_sign_in_succeeds_then_waiting_for_auth_is_false()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
@@ -231,7 +231,7 @@ public async Task when_sign_in_succeeds_then_status_text_shows_email()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test User", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
@@ -351,7 +351,7 @@ public async Task when_back_on_select_folders_step_then_step_is_sign_in()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
@@ -385,7 +385,7 @@ public async Task when_add_account_succeeds_then_completed_event_is_raised()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test User", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
@@ -415,7 +415,7 @@ public async Task when_add_account_fails_then_error_is_surfaced()
     {
         var auth = Substitute.For<IAuthService>();
         var profile = new AccountProfile("Test User", "test@example.com");
-        var authResult = AuthResultFactory.Create("token", "account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
+        var authResult = AuthResultFactory.Create("token", "test-account-id", profile, DateTimeOffset.UtcNow.AddHours(1));
         auth.SignInInteractiveAsync(Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<AuthResult, AuthError>>(new Ok<AuthResult, AuthError>(authResult)));
 
diff --git a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Workspace/GivenAWorkspaceViewModel.cs b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Workspace/GivenAWorkspaceViewModel.cs
index c0cfe33..4409d68 100644
--- a/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Workspace/GivenAWorkspaceViewModel.cs
+++ b/test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Workspace/GivenAWorkspaceViewModel.cs
@@ -12,6 +12,7 @@
 using AStar.Dev.FunctionalParadigm;
 using Microsoft.Extensions.DependencyInjection;
 using ReactiveUI;
+using DriveId = AStar.Dev.CloudSyncFunctional.Persistence.ValueObjects.DriveId;
 
 namespace AStar.Dev.CloudSyncFunctional.Tests.Unit.Workspace;
 
@@ -178,7 +179,7 @@ public void when_open_add_account_wizard_is_executed_then_current_overlay_is_set
         var graph = Substitute.For<IGraphService>();
         var onboarding = Substitute.For<IAccountOnboardingService>();
         var services = new ServiceCollection();
-        services.AddTransient<AddAccountWizardViewModel>(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
+        services.AddTransient(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
         var provider = services.BuildServiceProvider();
 
         var sut = new WorkspaceViewModel(provider);
@@ -196,7 +197,7 @@ public void when_wizard_cancelled_event_fires_then_current_overlay_is_null()
         var graph = Substitute.For<IGraphService>();
         var onboarding = Substitute.For<IAccountOnboardingService>();
         var services = new ServiceCollection();
-        services.AddTransient<AddAccountWizardViewModel>(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
+        services.AddTransient(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
         var provider = services.BuildServiceProvider();
         var sut = new WorkspaceViewModel(provider);
         sut.OpenAddAccountWizard.Execute().Subscribe();
@@ -213,12 +214,12 @@ public void when_wizard_completed_then_current_overlay_is_null()
         var auth = Substitute.For<IAuthService>();
         var graph = Substitute.For<IGraphService>();
         var onboarding = Substitute.For<IAccountOnboardingService>();
-        var account = new OneDriveAccount { AccountId = "id", Profile = new AccountProfile("Name", "email@x.com"), SelectedFolders = [] };
+        var account = new OneDriveAccount { AccountId = CloudSyncFunctional.Auth.AccountId.Create("id"), Profile = new AccountProfile("Name", "email@x.com"), SelectedFolders = [] };
         onboarding.CompleteOnboardingAsync(Arg.Any<OneDriveAccount>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<OneDriveAccount, PersistenceError>>(new Ok<OneDriveAccount, PersistenceError>(account)));
 
         var services = new ServiceCollection();
-        services.AddTransient<AddAccountWizardViewModel>(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
+        services.AddTransient(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
         var provider = services.BuildServiceProvider();
         var sut = new WorkspaceViewModel(provider);
         sut.OpenAddAccountWizard.Execute().Subscribe();
@@ -235,12 +236,12 @@ public void when_wizard_completed_then_account_is_added_to_accounts()
         var auth = Substitute.For<IAuthService>();
         var graph = Substitute.For<IGraphService>();
         var onboarding = Substitute.For<IAccountOnboardingService>();
-        var account = new OneDriveAccount { AccountId = "id", Profile = new AccountProfile("New User", "new@x.com"), SelectedFolders = [new SelectedFolder("f1-id", "f1")] };
+        var account = new OneDriveAccount { AccountId = CloudSyncFunctional.Auth.AccountId.Create("id"), Profile = new AccountProfile("New User", "new@x.com"), SelectedFolders = [new SelectedFolder("f1-id", "f1")] };
         onboarding.CompleteOnboardingAsync(Arg.Any<OneDriveAccount>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult<Result<OneDriveAccount, PersistenceError>>(new Ok<OneDriveAccount, PersistenceError>(account)));
 
         var services = new ServiceCollection();
-        services.AddTransient<AddAccountWizardViewModel>(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
+        services.AddTransient(_ => new AddAccountWizardViewModel(auth, graph, onboarding));
         var provider = services.BuildServiceProvider();
         var sut = new WorkspaceViewModel(provider);
         sut.OpenAddAccountWizard.Execute().Subscribe();
@@ -260,7 +261,7 @@ public async Task when_load_persisted_accounts_is_called_then_stored_account_app
             [
                 new AccountEntity
                 {
-                    Id = new AccountId("acc-1"),
+                    Id = new Persistence.ValueObjects.AccountId("acc-1"),
                     Profile = new AccountProfileEntity { DisplayName = new DisplayName("Alice"), Email = new EmailAddress("alice@x.com") },
                     IsActive = true,
                     DriveId = new DriveId("drive-1"),
@@ -296,7 +297,7 @@ public async Task when_load_persisted_accounts_is_called_then_first_account_is_a
             [
                 new AccountEntity
                 {
-                    Id = new AccountId("acc-1"),
+                    Id = new Persistence.ValueObjects.AccountId("acc-1"),
                     Profile = new AccountProfileEntity { DisplayName = new DisplayName("Bob"), Email = new EmailAddress("bob@x.com") },
                     IsActive = true,
                     DriveId = new DriveId("drive-1"),
diff --git a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAResultMatch.cs b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAResultMatch.cs
index ac0753b..6a660af 100644
--- a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAResultMatch.cs
+++ b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAResultMatch.cs
@@ -23,4 +23,77 @@ public void when_matching_a_fail_result_then_the_failure_handler_is_used()
 
         matched.ShouldBe("fail:bad");
     }
+    
+    // ... existing code ...
+    [Fact]
+    public async Task when_task_result_is_fail_then_func_overload_returns_failure_value()
+    {
+        Task<Result<int, string>> task = Task.FromResult<Result<int, string>>(new Fail<int, string>("err"));
+
+        var result = await task.MatchAsync(
+            ok => ok * 2,
+            _ => -1);
+
+        result.ShouldBe(-1);
+    }
+
+    [Fact]
+    public async Task when_task_result_is_ok_then_async_func_overload_returns_mapped_value()
+    {
+        Task<Result<int, string>> task = Task.FromResult<Result<int, string>>(new Ok<int, string>(5));
+
+        var result = await task.MatchAsync(
+            ok => Task.FromResult(ok * 2),
+            _ => Task.FromResult(-1));
+
+        result.ShouldBe(10);
+    }
+
+    [Fact]
+    public async Task when_task_result_is_fail_then_async_func_overload_returns_failure_value()
+    {
+        Task<Result<int, string>> task = Task.FromResult<Result<int, string>>(new Fail<int, string>("err"));
+
+        var result = await task.MatchAsync(
+            ok => Task.FromResult(ok * 2),
+            _ => Task.FromResult(-1));
+
+        result.ShouldBe(-1);
+    }
+
+    [Fact]
+    public async Task when_task_result_is_ok_then_async_func_overload_does_not_call_failure_branch()
+    {
+        var failureCalled = false;
+        Task<Result<int, string>> task = Task.FromResult<Result<int, string>>(new Ok<int, string>(5));
+
+        var result = await task.MatchAsync(
+            ok => Task.FromResult(ok * 2),
+            _ =>
+            {
+                failureCalled = true;
+                return Task.FromResult(-1);
+            });
+
+        result.ShouldBe(10);
+        failureCalled.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task when_task_result_is_fail_then_async_func_overload_does_not_call_success_branch()
+    {
+        var successCalled = false;
+        Task<Result<int, string>> task = Task.FromResult<Result<int, string>>(new Fail<int, string>("err"));
+
+        var result = await task.MatchAsync(
+            ok =>
+            {
+                successCalled = true;
+                return Task.FromResult(ok * 2);
+            },
+            _ => Task.FromResult(-1));
+
+        result.ShouldBe(-1);
+        successCalled.ShouldBeFalse();
+    }
 }
diff --git a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOption.cs b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOption.cs
index 6bd4a1c..6873a83 100644
--- a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOption.cs
+++ b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOption.cs
@@ -7,7 +7,7 @@ public class GivenAnOption
     [Fact]
     public void when_a_some_option_is_created_then_implicit_conversion_returns_the_value()
     {
-        Option<int, string> result = new Some<int, string>(42);
+        Option<int> result = new Some<int>(42);
 
         int value = result;
 
@@ -17,7 +17,7 @@ public void when_a_some_option_is_created_then_implicit_conversion_returns_the_v
     [Fact]
     public void when_a_none_option_is_created_then_implicit_conversion_returns_the_error()
     {
-        Option<int, string> result = new None<int, string>("missing");
+        Option<int> result = new None<int>();
 
         string error = result;
 
diff --git a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionBind.cs b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionBind.cs
index 158a7bb..5c50d39 100644
--- a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionBind.cs
+++ b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionBind.cs
@@ -7,9 +7,9 @@ public class GivenAnOptionBind
     [Fact]
     public void when_binding_a_some_option_then_the_bound_result_is_returned()
     {
-        Option<int, string> result = new Some<int, string>(7);
+        Option<int> result = new Some<int>(7);
 
-        var bound = result.Bind(value => new Some<int, string>(value + 5));
+        var bound = result.Bind(value => new Some<int>(value + 5));
 
         bound.Match(value => value, _ => -1).ShouldBe(12);
     }
@@ -17,10 +17,10 @@ public void when_binding_a_some_option_then_the_bound_result_is_returned()
     [Fact]
     public void when_binding_a_none_option_then_the_failure_is_preserved()
     {
-        Option<int, string> result = new None<int, string>("nope");
+        Option<int> result = new None<int>();
 
-        var bound = result.Bind(value => new None<int, string>("nope"));
+        var bound = result.Bind(value => new None<int>());
 
-        bound.Match(_ => string.Empty, error => error).ShouldBe("nope");
+        bound.Match(_ => string.Empty, error => error).ShouldBe("missing");
     }
 }
diff --git a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMap.cs b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMap.cs
index e8afa92..189922d 100644
--- a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMap.cs
+++ b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMap.cs
@@ -7,7 +7,7 @@ public class GivenAnOptionMap
     [Fact]
     public void when_mapping_a_some_option_then_the_value_is_transformed()
     {
-        Option<int, string> result = new Some<int, string>(7);
+        Option<int> result = new Some<int>(7);
 
         var mapped = result.Map(value => value * 3);
 
@@ -17,10 +17,10 @@ public void when_mapping_a_some_option_then_the_value_is_transformed()
     [Fact]
     public void when_mapping_a_none_option_then_the_error_is_preserved()
     {
-        Option<int, string> result = new None<int, string>("nope");
+        Option<int> result = new None<int>();
 
         var mapped = result.Map(value => value * 3);
 
-        mapped.Match(_ => string.Empty, error => error).ShouldBe("nope");
+        mapped.Match(_ => string.Empty, error => error).ShouldBe("missing");
     }
 }
diff --git a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMatch.cs b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMatch.cs
index e358ee0..eb703a8 100644
--- a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMatch.cs
+++ b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionMatch.cs
@@ -7,7 +7,7 @@ public class GivenAnOptionMatch
     [Fact]
     public void when_matching_a_some_option_then_the_success_handler_is_used()
     {
-        Option<int, string> result = new Some<int, string>(8);
+        Option<int> result = new Some<int>(8);
 
         string matched = result.Match(value => $"ok:{value}", error => $"fail:{error}");
 
@@ -17,10 +17,10 @@ public void when_matching_a_some_option_then_the_success_handler_is_used()
     [Fact]
     public void when_matching_a_none_option_then_the_failure_handler_is_used()
     {
-        Option<int, string> result = new None<int, string>("bad");
+        Option<int> result = new None<int>();
 
         string matched = result.Match(value => $"ok:{value}", error => $"fail:{error}");
 
-        matched.ShouldBe("fail:bad");
+        matched.ShouldBe("fail:missing");
     }
 }
diff --git a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionTap.cs b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionTap.cs
index 66c1b94..085fe07 100644
--- a/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionTap.cs
+++ b/test/AStar.Dev.FunctionsParadigm.Tests.Unit/GivenAnOptionTap.cs
@@ -7,10 +7,10 @@ public class GivenAnOptionTap
     [Fact]
     public void when_tapping_a_some_option_then_the_success_action_runs()
     {
-        Option<int, string> result = new Some<int, string>(5);
+        Option<int> result = new Some<int>(5);
         var observed = 0;
 
-        result.Tap(value => observed = value * 2);
+        result.Tap(value => observed = value * 2, _ => observed = -1);
 
         observed.ShouldBe(10);
     }
@@ -18,11 +18,11 @@ public void when_tapping_a_some_option_then_the_success_action_runs()
     [Fact]
     public void when_tapping_a_none_option_then_the_failure_action_runs()
     {
-        Option<int, string> result = new None<int, string>("boom");
+        Option<int> result = new None<int>();
         string? observed = null;
 
-        result.Tap(_ => observed = "unexpected", error => observed = error);
+        result.Tap(_ => observed = "unexpected", error => observed = "error");
 
-        observed.ShouldBe("boom");
+        observed.ShouldBe("error");
     }
 }