From 34350fdbb33d38dfbaa6251d7d97e6a0f258f967 Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden1@outlook.com>
Date: Wed, 27 May 2026 13:32:22 +0100
Subject: [PATCH 1/3] change ct to cancellationToken

---
 .claude/rules/onedrive-auth.md                |  6 +--
 .claude/rules/onedrive-background.md          | 10 ++---
 .claude/rules/onedrive-di.md                  |  2 +-
 .claude/rules/onedrive-graph.md               | 22 +++++------
 .claude/rules/onedrive-onboarding.md          |  2 +-
 .claude/rules/onedrive-persistence.md         |  2 +-
 .claude/rules/onedrive-sync.md                | 10 ++---
 .../Auth/AuthService.cs                       | 10 ++---
 .../Auth/IAuthService.cs                      |  6 +--
 .../Auth/ITokenCacheService.cs                |  2 +-
 .../Auth/TokenCacheService.cs                 |  2 +-
 .../Graph/GraphService.cs                     | 10 ++---
 .../Graph/IGraphService.cs                    |  2 +-
 .../Onboarding/AccountOnboardingService.cs    | 10 ++---
 .../Onboarding/IAccountOnboardingService.cs   |  2 +-
 .../Repositories/AccountRepository.cs         | 28 +++++++-------
 .../Repositories/DriveStateRepository.cs      | 14 +++----
 .../FileClassificationRuleRepository.cs       | 22 +++++------
 .../Repositories/IAccountRepository.cs        |  8 ++--
 .../Repositories/IDriveStateRepository.cs     |  4 +-
 .../IFileClassificationRuleRepository.cs      |  6 +--
 .../Repositories/ISyncRepository.cs           | 10 ++---
 .../Repositories/ISyncRuleRepository.cs       |  6 +--
 .../Repositories/ISyncedItemRepository.cs     |  8 ++--
 .../Repositories/SyncRepository.cs            | 38 +++++++++----------
 .../Repositories/SyncRuleRepository.cs        | 22 +++++------
 .../Repositories/SyncedItemRepository.cs      | 28 +++++++-------
 .../Wizard/AddAccountWizardViewModel.cs       | 22 +++++------
 .../Workspace/WorkspaceViewModel.cs           |  4 +-
 29 files changed, 159 insertions(+), 159 deletions(-)

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..276bb69 100644
--- a/.claude/rules/onedrive-background.md
+++ b/.claude/rules/onedrive-background.md
@@ -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..32af807 100644
--- a/.claude/rules/onedrive-di.md
+++ b/.claude/rules/onedrive-di.md
@@ -67,7 +67,7 @@ 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);
diff --git a/.claude/rules/onedrive-graph.md b/.claude/rules/onedrive-graph.md
index 2411e64..064a719 100644
--- a/.claude/rules/onedrive-graph.md
+++ b/.claude/rules/onedrive-graph.md
@@ -19,7 +19,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"]);
@@ -88,7 +88,7 @@ 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
 
@@ -188,15 +188,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..7b97d26 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)
diff --git a/.claude/rules/onedrive-persistence.md b/.claude/rules/onedrive-persistence.md
index 82dd1c3..50fd28f 100644
--- a/.claude/rules/onedrive-persistence.md
+++ b/.claude/rules/onedrive-persistence.md
@@ -190,7 +190,7 @@ 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
     {
diff --git a/.claude/rules/onedrive-sync.md b/.claude/rules/onedrive-sync.md
index 833e0b0..5310182 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
@@ -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/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs
index 07c2e20..d37d211 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);
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
index aa12414..3be4f15 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
@@ -8,19 +8,19 @@ 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>
     /// <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>
     /// <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>
     /// <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..ee96062 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs
@@ -9,5 +9,5 @@ public interface ITokenCacheService
     /// <param name="app">The MSAL application whose token cache is registered.</param>
     /// <param name="ct">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/Graph/GraphService.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs
index 4d4f892..af1bfe8 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/GraphService.cs
@@ -9,21 +9,21 @@ 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 async Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersAsync(string accountId, string accessToken, CancellationToken cancellationToken = default)
     {
         try
         {
             var client = clientFactory.CreateClient(accessToken);
-            var drive = await client.Me.Drive.GetAsync(cancellationToken: ct).ConfigureAwait(false);
+            var drive = await client.Me.Drive.GetAsync(cancellationToken: cancellationToken).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);
+            var root = await client.Drives[drive.Id].Root.GetAsync(cancellationToken: cancellationToken).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)
+                .GetAsync(req => req.QueryParameters.Select = ChildrenSelect, cancellationToken: cancellationToken)
                 .ConfigureAwait(false);
 
             var folders = new List<DriveFolder>();
@@ -36,7 +36,7 @@ public async Task<Result<List<DriveFolder>, GraphError>> GetRootFoldersAsync(str
                     break;
 
                 page = await client.Drives[drive.Id].Items[root.Id].Children
-                    .WithUrl(page.OdataNextLink).GetAsync(cancellationToken: ct)
+                    .WithUrl(page.OdataNextLink).GetAsync(cancellationToken: cancellationToken)
                     .ConfigureAwait(false);
             }
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs b/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs
index 99f7465..db6ba85 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Graph/IGraphService.cs
@@ -10,5 +10,5 @@ public interface IGraphService
     /// <param name="accessToken">The OAuth2 bearer token for Graph API calls.</param>
     /// <param name="ct">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/Onboarding/AccountOnboardingService.cs b/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
index 9fa38a4..ba36745 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
@@ -14,13 +14,13 @@ public sealed partial class AccountOnboardingService(IAccountRepository accountR
         ..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>>(
                 _ =>
                 {
@@ -34,7 +34,7 @@ public async Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingA
                 });
     }
 
-    private async Task<Result<Unit, PersistenceError>> UpsertSyncRulesAsync(OneDriveAccount account, CancellationToken ct)
+    private async Task<Result<Unit, PersistenceError>> UpsertSyncRulesAsync(OneDriveAccount account, CancellationToken cancellationToken)
     {
         foreach (var folder in account.SelectedFolders)
         {
@@ -46,7 +46,7 @@ private async Task<Result<Unit, PersistenceError>> UpsertSyncRulesAsync(OneDrive
                 RuleType = RuleType.Include
             };
 
-            var stopResult = await syncRuleRepository.UpsertAsync(rule, ct)
+            var stopResult = await syncRuleRepository.UpsertAsync(rule, cancellationToken)
                 .MatchAsync<Unit, PersistenceError, Result<Unit, PersistenceError>?>(
                     _ => null,
                     error => new Fail<Unit, PersistenceError>(error))
diff --git a/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs b/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs
index b863ec4..1fe40cd 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Onboarding/IAccountOnboardingService.cs
@@ -10,5 +10,5 @@ public interface IAccountOnboardingService
     /// <param name="account">The account to onboard.</param>
     /// <param name="ct">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..cbb7ed5 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
@@ -10,10 +10,10 @@ 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, PersistenceError>> 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."))
@@ -21,25 +21,25 @@ public async Task<Option<AccountEntity, PersistenceError>> GetByIdAsync(AccountI
     }
 
     /// <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..c1a5033 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
@@ -10,10 +10,10 @@ 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, PersistenceError>> 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."))
@@ -21,17 +21,17 @@ public async Task<Option<DriveStateEntity, PersistenceError>> GetByAccountAsync(
     }
 
     /// <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..e477c29 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, PersistenceError>> 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..ee8bd66 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, PersistenceError>> 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..532a2ae 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, PersistenceError>> 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..44372b9 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
@@ -10,10 +10,10 @@ 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, PersistenceError>> 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."))
@@ -21,29 +21,29 @@ public async Task<Option<SyncedItemEntity, PersistenceError>> GetByIdAsync(Synce
     }
 
     /// <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/AddAccountWizardViewModel.cs b/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs
index 3e67b91..c21838d 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,7 +266,7 @@ private void ExecuteBack()
         };
     }
 
-    private async Task ExecuteAddAccountAsync(CancellationToken ct)
+    private async Task ExecuteAddAccountAsync(CancellationToken cancellationToken)
     {
         if (_authResult is null)
             return;
@@ -278,7 +278,7 @@ private async Task ExecuteAddAccountAsync(CancellationToken ct)
             SelectedFolders = Folders.Where(f => f.IsSelected).Select(f => new SelectedFolder(f.FolderId, f.Name)).ToList()
         };
 
-        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)

From 9937691069c5f78b09c34b587010035e5c46447e Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden1@outlook.com>
Date: Wed, 27 May 2026 22:30:53 +0100
Subject: [PATCH 2/3] small tweaks to a few files not 100% related to the
 actual change

---
 .gitignore                                    |   3 +++
 .vscode/settings.json                         |  12 ++++++++-
 .../AStar.Dev.CloudSyncFunctional.csproj      |  25 +++++++++---------
 .../App.axaml.cs                              |   2 +-
 .../Assets/astar.png                          | Bin 0 -> 15984 bytes
 .../MainWindow.axaml                          |   3 ++-
 6 files changed, 30 insertions(+), 15 deletions(-)
 create mode 100644 src/AStar.Dev.CloudSyncFunctional/Assets/astar.png

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..b6312af 100644
--- a/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
+++ b/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
@@ -23,18 +23,18 @@
       <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>
@@ -42,6 +42,7 @@
 
   <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..570e764 100644
--- a/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs
@@ -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")
diff --git a/src/AStar.Dev.CloudSyncFunctional/Assets/astar.png b/src/AStar.Dev.CloudSyncFunctional/Assets/astar.png
new file mode 100644
index 0000000000000000000000000000000000000000..74b197eaae17c8a9d66b29d6259ce99af25741e6
GIT binary patch
literal 15984
zcmV-$K99kPP)<h;3K|Lk000e1NJLTq004jh004jp1^@s6!#-il00004b3#c}2nYxW
zd<bNS001BWNkl<Zc$}5Jd9)_iRUi7>RrTF@?nymQnp<;AYK_<yk|kTl*kD3{IAlR^
zLdauf5m><q?=2h1%6sHFb|5&$hQuZq6Gvc-rx<yX+_EgSWlOSJQ%l{Fd!BChy|?f5
zeO0yJAE(Ya`|NY-wqC7u@Ap;JIs5GKw|AX7RUeHE4>14`5ttc705jg;#sCN;_5c6`
z5DXnM#0~A{oNZ*rGoK)U*tE5DJw<BhvluPhQoRfx%@Ic%s%4s<Kg9q$=2q-O4UhJG
zq!-)nB044^1vibUQIPE?^=iJh@MOmd6yvwd$;-82KWKC@Pp~30bT><f364pY=bU%2
zv$<=<BzW;^Od6l;SusYyzM;d`Bkew`9+o-#N8#~{$Ar}ai6j0`a(1x*V`9TE5y<Jz
zD2VI`jXVTu{94lYyt}cOfrJ#9kP_^oC5$}ZkrUrrA_$^c%dXS0ILIv2ZH>!v97%yM
zs!f*cx`Blv1v9RR)1NuU4U({C)HSyJQR1A$1I=#>?`)g0me&6T0b|K3Gzc6ck{Ha+
z0nABKiVr*6Fw)T6BG4P~3oD3hPC|zkU&y6}bZSTrC=kYuD93ZIEFDe_VYTA<(Bm|X
z8)JE4oHR;Wc`m_o^2o}^;jPx##|o7Sl+fXbL<-Q+tl`WjX*sC!{9r(PUT<lycY0TR
zQ|RtKoiqw(spKHasWGB9hG0Rk84Sy^iAfpMIDZ(EzJ9S|dS{XfCxm+9;3Lq(3MEO1
zzMelj0yl;ZQm6c$7(bKVA|Z}kLk^BNaTLN@6p;y~J9;{Td{ZgB4K@~^47eyH2Sy@n
zNrGgkpyZf|!`cxf9aqRYo_x_vcHg!j62vT~%g%8`+NLW-yZw|JcBQF6enw2613t|6
z%rPqnI6o7*b&(J#MjBKO$cbZ~wd8(E7gn*&r&MTErUY~-;v{y`#3n7?7KshqTivig
znYjE@WCK7Yl@65CM|>lBRG296F`4~>t1LT4^F4DFd5XHSt-O2*odAJx(vh#vHOHh9
zIQ%M|&DMbu31VI>ida;$5$mWau9Vy@ytFk5>4@URI$^_$D!pQT+r!Og+okSGn{<TO
z`9u2FmOxVjSRV*jRjB1WN?=bQN6=OFQU*_P-g4dyM=mlP^N@V$C<@~+<f*;w8{M?+
zoOCkGt#<|v9o7#VqySd>s}mz!d^39TF7J;gbkeYw`9=UZr6$Q3B0DKL69ekADPMIQ
zc%ni%dR$YKSv|9-D&Uz^D8wod7#^Kld6U=OQ4g|tfz(9^yHnl>4U?XEOGL5Lf*Pr<
zsZ)H|>B1F(s{KTeDyCUAc2|I@fNmhqBSr{9><E#lP&EOuPb)c)udn3vfI|s^#FDj;
znxN_;CXt@>xb|#F)blC~95^OmW;{dDVCyQUACf&3JJhQ9V2>?b$8+qc(h0Mmw;0DE
zy^JD`#rE(lO%)b*9+WtU9u4Nfz~KlXWyOa(*2bTdG4xH*F3`5>z|k2=R957YFstKX
z0j;St)HytA2xw{L_Y}c&8cc0jxXU7PqFC`!r&*Mjk1RY}!L~;Tv``lf{fO~+vLA=%
z()__s2Rn~#KHc=NWtb8KJmD1Z2b0S7iVD(=#B{VAUTkFP$V&mI5>|Q<LcQTl7o%pF
zEaXQ=LE7gDAySArL~~3VLCB>qnF2s)^;aFPQC+>_#)?<4on7>_+`NJWPzk*&Mqz;K
z?t@i(Qf;&h5jY0JXfP+i^hz4g$sjz{Tm_`^igyC7ZtKyul?L>-*(^yvMq&+HqUg|^
zuOzP?yJ653=3+9#PnL+WMH=B?N;gKMc#HB%c=jUQgBv$2__gF5irQ)I2EA5vf)$M+
z?*+7X<d)-+0P;&4k|I<x1;tOQ%H$~G({7{DM52A;Qshao9X3EZ3Wjnqqb$dvH1Kd7
zbarE|wCO<i2Ynd$ap7u3f}M4g_}li`wz0e$sG~u~b=WB`k`jZZU@pjOAr=I8vmzos
zTJ=>yduEQ^BuG;+cVRAfe0iv|$K&g2>seAjs5G6{lj}ioD<ZhM#oq%Fe*%rA=F;Jz
z`7m4dhVZpj2$_T0qZELz{&kSB%giu-opL;Kex7oU6?wO35~nt=0<PFT6!PQv^6auT
zgtU}YdE2~xz*l<(C<5L!w{r%P57~hn63F_(@}yHj%Jt1Lbrq0eoPF|1ol6c959F?$
z<&7ol#Z6AIH(PA12Mtw}`<8wjK{*yB5e&EOsPU6;*&?ppJu)%*Pe;N<qFOi;=(`Q`
zW1dnt8sRV5e~Od<8b2-W8If0W9$hul)D(fPag$9hmO27fQ=+6qvT|q<5iqPN`<6E2
z*)~3x`13l-*!c*FU3>11%QL*~uC=i4BqIwPqIy#|x?{o3K09QfXsv@((uubytk}yK
z_ySqc#LTCVT_S_M;)&Byb2G?Y>DU%Ze?jhcT-u0KEGs3;6Ee@c^LA_@u)N9RZUQlf
z$I+OL1g#(~Se0=!Bmit%#h4r?Y}v31S8wb0ymM%1*G&ZvtM<WlzB9Nal0wV2NJ}G_
zP`evN#6j>Sy!9*FJB0#(M}R<m!f~C~IVXY3iFWo)kT-oI{-wYIx<weVAQ5yC5f|JV
zhDQN%onr)W>QMUMy^WC<1*p@H`}RyhI-}H6QW7CIC3uzvtBqjaKoVBSsqY0u1Bd)E
z5MFWz<M=kNa{`E>sbK9<taxK6;VC2#8Pc7V!X_d!A!NXh=1n=RRk&8NE}qQVKgLbl
z7<o>}vkVX1xi%^iqm{d2k!Uhl)G+Q-N3Ms^xL4~nV?2l}`a<vx^yH4q8#zIH4i|+6
z+zY0)u+|A&uLy=DA!Ceq9?FWKqa(F7&ZPp!R?oIzQ)MT-%aa&_uzfXS&13<}Iw;F7
zF59^dJ2wwG&(cT}3@VSLY$gL)bPemDR2|eNdqhgKrtmn$Bly;aF}X^cI582FB0v=H
zOP*OC7mg7@P>>f5L*dAJAlsK*7s(*UR#&{U`ZLF_-^`8i7+fx*u7UgaOt^|WKtIVw
zVza*PBvUCtmZkw-2_@+YK5P(6)XE2Yepv9NH;LTQJb;dRcg$(QPdvCtY1)J-jD_Q9
z!-sOkmwZyHP=q%WLxD&Xd}U_rxeO=@LPm^YXbN1Hc;JpTzL`pGl8q?kT9G6wi89C6
z0g@*cZREOs;RMNa(2f#PFRavTomyufCLptex}4JD?!lUP8`m-=NH~mOP-#HH;mZCU
z<dvu<(WD!cmpz1IFt)E@ObllL5vr;}-CYJ{Ij+2X4K}Xn^X()4Lz?oKRat<1A~<B~
z4YWv#zX0Owku(wnEtr$^Lw?}_*7C-3L5OXUh`Mla6CP3OOXNQ7i6I!rEORin#C)w7
zVSq5e6$9ZX1Gs53qpy!pRg5g}091py2BE-P_e?aTC8yGx)G=|&qJ~Bx9sMps1DWN1
z$h3d7O%e(<8LqKN1d%vp9n&7p{P~b*xE~+)*O?j_LTQ=O&7!Le$i*TuCgM<c&gynT
zba3=-!Q+ZV#;uq7$mF^Lb8gPm72bNs+JpkNVs#N>^&weIA(=-8$5)F^LaA9@lBNPi
z=B!lkCd6q_->e6S_|*pp@j&*JuG-Xj8L0BR4I=3z34T)*K#V`+2as&q@fxFCzOKf^
zr~y4@24w`I+7yFeTz|y`)=d=}+?8x8-RQ&ZMj-V~rVm*^*o8Ir**|YLFJK%nDgfQa
z&P;mz4B#dg#YUEKD2c^mq&+@DP-|%NjJUW`$4r1|hq4Heh*B5w2=!o})?vcUTY)U2
z<`R!km9-eKLY5EU$8R26p(bfl^h$Y1QBYk2&06*wvF+j&L)ISD0%}U>^qnm3(G-Ey
zaMoT*Sf$H~SevjV6}U<$Y%0;xML~oR;qpe?S(i!irgH&6RO80&evG<iP?noC0H9`|
zt}8rn`<j4e{EfmKu8on5g*2uFn?x)$0U&iJWC@*!6!kWJq!}~_(2`>)`Y-odFgrDH
zqMb}Ta(q`z3N(-JAtaVZxqTg(=G;}6Fh+-S7yWe&)Kvvgj=bmxxJKDq#O`ZXVbypJ
zYg+BQ4o;IO*cO@XnBtDAI0_c8q=H-6E4W$fbR{CHg%=>W9ZaDQINQbE?JqkLIX~hs
zRv`d!f8ElIyR}b^TLJA!&5zZd7i9M~LYA2nP?oiMGBz)e<$dTa&4a5Rip~H~1NYxH
zWvD4<3?v}0&QLP_fN01^a?=Y*+cFK*zC==|H>m@`YzqOgC{#piQ<%wXZh37R_DMm1
zB18g%B)oHljAEyqCG-*CucKM;lX&SsPK=wjn|5_=j#m|fxk6noAn$ZsI-sJ1dv2cc
zVhA61&}>oDvJ-$IE4`=SSII6M-HFJdcAX96K6F9MjXr#U$onHcNc{MjyQ>sLJv;=<
zAQ$iiAei=yui@1egmc0pS?ybeu;<5%=qX8l0_MfGYa?TzKZCt}T-PQIP*#BQ4(zRF
z<{GGbxaFF0OpTFKo;hz*Wyp}#Q3z6PxmYo(D#B<IG|@{hQnoM8&{vhv`%(Td{W8@@
zDLb+9MMAR(Wczq@%HKniY1Bv|gYsmAo(%Tu_-#50Cs#Q5yJ3sDWU5L=U7Iveo2t)5
zJqX|$L^+5G6rBOwciS2tc5bUxK(iXlzGkO}UFqaL*&h#Wl1ibzjl2Z(^^j7bbw-N{
zwvTg68A+kuX>g!l`JMLO1cQX|ZlDf)3J<$H%`#ej?zV@vu3~)Pm!>eeY6N`)1E`i4
zL3sy+3{|xZ$_g-7$nzX|o}*+!juJo)W=58o&%EfMu4`m{eJH9P&L2OEQ^(IjF@TAw
z0qnW|ZRjmd1C)WQ8UUfHO7sn{!TIUqhCen}3RT6(vmBrr;Mzh7K$%r1s<K30WZ<d-
zGf>qPa>`KWLpb!xG5pJq9LD(zb)fBbCuqH9cw?KjQ)Cagv{`sl$Zsm?>Eo<DtT~o6
zybveh@pA9rsT#lYu@iXjodvdR7{JsetFdA81V%<WsC$cGCNq5tAS*hk%O0|vP;>^s
z%;<HOQ51P|`IG_7psXL06XQ5PJ%jFY2?ir`H()X_H}F}N1`V<f21eJQu9h(|IRS75
zAVb|-28fUq9dOO4xd!)^!C4MspenoIx<WQMg6`r442-Wrx5{w(_&J<Dd<6TRIf_4f
zq{i%Wr$swjE3xsTH44$DZ6`unpaVo4v>?D697OOdal^k=#{rG_A6EblKp3dGLLXK5
zsT&D5?aZ*S#26jvVAJ+Xuwla_CRPuFnp9ABmys0(z>K1Q7<F$Mlo!UBVC2OBxay&*
zN-WGT<A+ba*o?`@Gs48GVcdN0edsMro3YCZeM6%lDp2(<AS(t8cU+^cdSI?VS%JDL
zQFRwl^beuzcEMbNnb1GF4)Zf}m_ECR*Iw9<nX~87*CBlIsS;m(J_oW4U_Y}Lg@U;5
zPoBS+9agZPP9?S}4G#3NI4lUo$4s9VxFQM+=?Atmal(TIiFEzOD0?Mt*~)n5?hHgg
zS(ysHf1tp&ZELV~=LSqpcEG5SHAXQ)X67zerw@dx$@v-TnsD^st9b3eX=J$>b!zn>
zZhhb#=*>@~s!I@Z434kI@`Y1PftaK2naE}$pz5M#AfpUrxePE+3{7HodI84|pTdz>
z4`6v=8F@}1V$3cu{`(^pUO7`V3o|LaRV*SgOb01Mh|_XgscBCJX*$t?h%5r=B5fto
zVXS-0wzLu?DdksU3r1!}RaICsT;U(xo?*=-q1Qu`i;eOI`ZH|Vz6P5&ufn<wt59<n
zTmyNYqbj?|@&a|)HRw<-Bkv!^3*UPd(`V)Y2F53car=YsFa~F!GqxVp!gK?b8S1KQ
z3b&eo45)ft5D|*ODNLU@gJXwJ;qZZ%(Oa&N<v?8lMaRrHJae$ZUp@gWl!Xf#58*LX
zCs!W@Gl8<3F1ln-@_J7+v2R>+#k+Ta6aokiTY+0OO9&TzM~nu#K(XW0b&ZTmyz>Ua
z%{w!6dj^T>TJ$3z&j_2ht-+QplUToL74oJQAj%p9C>sNI@XQm>Vrij=(eXjt_O=I6
zE}cg)FlNT9dZ@eeU=Zr6L|*inT4P`eXHJ~O@z;;w@T-SV^-9=Vw?#qb(e#|qU9R!@
zr)oTUAOo_@C|n4t14A0#&Qh)r*P$YPVfDtgAikR$O+E$ambR_^&*F?duixI;Qb0<e
z5DAC1gQ#xyT+KDAvcip<89#MPhAabmr5d(rTvkAThp=Je1h#BnjSXAYqOZS$x~a;!
z?%~4BJoZ2JGDgOSu;;D!qV6uDe{2oPr8$({1v5j~89~`Aaq{R{9C`H+jvo3EvS!*W
zvkU3S7FC4208X5(@!uY;aC9aIk$UDvVtuUYFnFYMu(ER$dn=#;(M5_zi2zL%AC(o6
zfmW&&B$$NQPfYHWyFqGj%!*w`Bo~8Gl_gdW)%b_E<=D8&IDth2YTQviLq{MKIpdNI
zli0X<4K{9Bg|Vqg^cH7v_|P$&KRt~-54^pZ1zbknKZ&Keb2xVR3|@QjMVvZv5=Do=
zH6zP1*g}>vLXi{7$~<OX6u^@&mH3}e0!vj6`!*1-uT+XvXdq;@>SN&qEjJ*1XO}J#
zQMJOBKmbo5oaAZp3yWv#RjOdf_XpbZIvpg^hdiHf4C_}uB~*CFb-*o`W+*FZc=MTO
zKIc|dQ+zkGf2&syVB^+x*tlsG=FU&!>O1ep+{`?V9efq9zw|QBo}5O_Ho6Igxi5q)
zHx9rIWYjn{5z4B@-#k&_+plCG%8ZUkim}qGs1lxT+Y1K}02jqpM5Z<GrcyaT0|R~T
zJ<2*C1xApL0b6Wv;xjSu#nKv9ZW4@4#>i!_#0{Hj{M0RZ6P3o;RwG$vG?(W<uQX0!
zWh!z)Unj%VR3BEYo51Y31)Mp3!QCq;8VAa9uM;9do)K!c^9YO+=NX@Rw8D{@yphvI
zO2X(XS*<N7bj}o1MBoFV?b2x?J;n+M;9nmf91}+NHNeG$X&Ic5$Wg|~j#^6*2{6j4
z!m7avKes2thE*AQWk}5DXhUassKCTn2O}dH`uZ~*KD>aLdEmi!UX8L>;pFid9DV&1
z=I1L@*fn&DB1hd+okfv>nX&IciO=o>mg^ir$VbM%nD?uW3I(-}G_|(N%J#7UX^)m7
zuxX|WH;LwHAzJnW9J_d4Y9r^N(QB!$85v4Ecr9ViWf{uSIBk}h%d&xi93#UyCdNA$
z7|5E1AcS*gyO_Pu!-?q%JGPDC?t899U00~9E-uV0;^^UXICXRyWmyAc?jIC6p{f}V
zeYeEkS2Iv1SJnHp^G3zANGkUNl_d(sV7^~DoV$w9myeo=s27X_G!%Wrw|BC|m0m~~
zmNxRJps|u>QniaJA#9<l2WGBOmKCnu$avR{8ODYQBO^H`Ci>9n5IUV4-EP^;<1;Q?
zC^2`whh7bwoHmyeciy=LmtM6MfSJ~{H+s&VI)~#&&SCoW9L~;F_~fIEADz!&?xTq$
zO(EMdk{yUD!L+_@B2A(KLZT$bwE+<fVS5Nvh-}1+yeRSy1WprjB%p=7$3-^OiGYH0
zNo>=WbsB8(0!JoR5P^{A8BWd-CWi?>wtEP}L%Ere1JLVLP2SG1yj)@CTn|+ZloeyK
zYwp;cIDP?}HjN;s3VG3SX=7x37^~NgV8iAq{6C*LjaN?Rh|4+(#Sv-@^pfo6dU)eU
z`CIRkIxWU01Ys83e6t7vIM2w$cUNe+yPyJQ{3;jk;r<SzUzFj?L>c`W3B>WXX1YB?
z7(bBAb<DF2w_Mo)xHhwZRg)sJ%(Xu^-9=rS;xMzt9syNd<MF+(fU?|F`CI~AfvXZ(
z-a+5M0B*Z>M6srV#p+Fd%G36EAek0gHELB3iw~_wmLH9sI2^ADwoJYVQg#Z0O^+|e
zlb)veX7N8D9w0#q8T6ofG~0~>CMSo1?Q02HmZ2(3WH}s^gKL~Wzl^#faajm(?Ui-r
z%o3h^`gK%Q39cDM{}AfB0&@jMjknx1=H?l^JSsv(<OevI%6x2EhH6XXxPYP!E{(Dh
zb;zZjpfJ?w0YJ7=vEmRpz!U^&z~wt}+OwQejz)(SYJ!WkQEI+%E70jPa|0k#1cC@f
zkzsMM#{7H*`{PfP0ePM^uVpqgih{6z|7n~#IgOebWp@cgIT#u0vc#p^#;{@1^Bz9(
zF1|L1$$~{|h+uY3B5M>7a+9#4j*0IUVdR7IlA;4qi`Z=65Mmp}h~`zTpe6_e5`%HO
zxl&#mdKmjZ*6mxmiZ3^9Z|?8cwOgwJFqXR&&Yv&c{R6wzb&VqTV^kGTGvo2cUI(K9
z*QL4NPiB!x-s!`eZt!V<B=0&S*-KfWNMitxIBn)k=R!LMi9gvk)RoSVjv|HB#iL=$
z!7TSO((U566n}bDmfr0Ta%9+4kz+^H(IIz3l?`?nS8gKITzl;{!p@xUH8XhT*08O2
zxb_6?8vHyXT$u0SsqemoqSFVidMKBcQI$P#RpO3a0|`YXqLb4G4Wt#~1yZMiT}6A0
zqT#-Kra%xTafk@^>EM`2vnw>%(nOC-jU?8_sq(>xg(j*$CHGpu`1|!+fd2m6%-iP~
zh#1U-3v(5gm;Ktos;*I0#yVN<p*hbCPFsjP^x7<5KXd|l(T}{-XQZnu+_Y;F6T?XG
zqU#t1z%GzNB|06kSB;y%QjHYgU1X!sPwcKjaPfwaxT;P@pwhig8+y}z>)*5@<KrTp
z<&MekVgBE}J%d@4nZYdWV|15G%+6NLQt+k*Hp~9N0Lqe4<N(7=@uFG0QZ*p*)RTuX
zKQ{{oBg@SjMLK;2?$|Zpp*$gTpihaK4*i7eF8bLu4^Y4%iKwU|^~6XUXpVf;t5UA*
zRk1qq61kW>vvy3GHImsR0V+zgmN8ke5Jp!g1FqYiyBjuH22>^C+&MGJlV#M*4w6$i
z5%BoS6^@=YPC(5%LAyq<W?;EnW8dSif!U}j@0d%=yRI2TY!(*63Js*tTGb4el0|yU
z9{_QOHq=^>RD!e`+shS)R{tVB6(L60khVlp$l&qF-_MsGFIzXT8U|}fQ4Q&5$0QGO
z9KA7iZDREIHHvGl?dRt!^h!oX{yBhdw??NREOZ&4-do|>ql64K-gG%|`(^%)VwMr|
z=H}ATWAk|Rr6btBa}9_XS)OChb>rwOrqQcX>{!0jDZxX1BB+F6q(7zR`2D_Jswc;N
zV;eKuH-t#zDa8vHZcjZndKw{YmvD9{9NdmXUT1dSGm}menwuN9nZgc~ff-m@sxUWK
zf#8h~HkWy?o~-c)U#zhIM2@`3L3sz?c!}_t$7?Js8^h-r(5o1f0U*XRPoKox+!BzP
zOTwX{4t8JK7x5KJr{yqu4qtaEQA0dYB;!mP-|AM66m*o@jd`*)jvY9AWBFI`DF=|H
zL5hq551H3oj7Z~4)`Llw@KsA;!eHFABSTSSsLC45!1;5P<0;DwhB5(v|4fCCev@&2
z*(}mDP@ADB3LH9@;}eh6c<q$Yh?yN^R29%IYwUgG5PHj9fNL-^+<pDf3R-Hbr&>aY
ztt5hkP^g1!@@T0qBg35(3TQ+!TNdV*wnD3|MqqU)<(`ThLiBTmNy>o&#$)9%fGal;
z#zu26o5`JX=Soz~6tEq0X1>P9zh2_Y&k<_m4QU|*0eO~VvFhM2o&dhNzed(5o0=Pb
zvln{!;WNhoX5@K>+josPBef%ALioTT;EWmrUu;DAwp0MY&-wV;O6rQ$Unn^c6@gNe
zkkNR?O655{Et=4Zj*Ec*WR1{nc#9-AZ3DnH>bl0#Vuhu}$`pLLS-|n~(Fz~_-!)!7
zZHh$y#zIAxO#P4-1-^4A$0xtdm|rrBM{M2p%BwRtb7~e<Rbl-l!`QVYR%od3mF2K?
zR}jtCFEp%6wDo0J@GNX=_D{y8;VJmNfKV}^xndz53*r+o7j0>R5v*GeA&rz8Lu4X%
zh_QR8S@m1hjI(F$vjL`{`||foeB#@{T+c(kr$zxqmz{}F6giGvDDa6#83&G=H;NXy
ziNGhGIA*4p0dqB=pjwG6#tBit>slh5m)MilsO-C$c^4A%24U#9PZy`s5l!1nwhp1#
z&L~sT2!2z>XE})46woBg1~wzh<RjJP-%Y@{>=MFM^Uk01=PC!MGZ$)n>}wUi_HquU
zJm5CqH$bs4U*%bb9(V9RzXv@0Y>m1$R|gA=J^WzbVNh1!-do2La*(1J!Z8P}R9?Q=
z5^r5oHI6QeZWhDIc?3=pu~WfG<ZgbXffH}@Y}?mf8!*gT$Esfgh2)z<31cGE9w*$e
z1t>Zh<`*g~FW1O3!v4cGKK%DJ4o;ify5Y;LLl2CvEaZ99z9>3)@<%!Td~c1}c{9iG
z`jI&tJA4-F*9_u{4dj$;X-2^YkD)83H`Y5^32AOk{%7Yy?#7dpJV+__kC3@|i1;xF
z!s|_cpDBFtfKCZ1fz-yjP3UHUy#(^vQiA~O-eI7BcBTXa_`>%}eDZO^LS-O7974li
zcs8}R(M}HKMULYa3jFC_#!E+yPM&=77|OE7k6kweXB<_~IzWWS(G@ba7@rgEG+Kzj
zbvTcx6w?VN;DOm*1;D!uc|}{*cv$h+oyf|P8#QD~ASIioz=DT_UN%fHE}0_CoG&pw
z%lPQmDtzme47O}{T@u6k<R;~8<Ix~tmSyO1A0B#|@bGhtUd4F&2gh;G&7**wyb|L|
zb6N7{GT6V*z>XcK3T5ozyxryGAvu<{rL&hcpSxK`DC~F^>XTEDWZO5QkyWErP->HI
zC_*^3wH=p67xp2Tcm8yH=7EfdzQ<Usa`WClc){CE8UjyyjSw1v;m*W<0015vNkl<Z
z2<Q|A_Pt)=*trTnee*oluN%Z=8wdxE3yr((W=9?h7H6<GTKrIs-t#N6tu18buV1}q
zotpw-Ee{?SsK2k%yg9`r54XbE61OsOipdnSDG%1B2%#)-AG-O<2wplMB>U~3EbyKE
zT|9b#%rkgW&K4L9%xa-oWvti;v3D{6t{MGV4?lBjfzEIrKK0Gg^_GjErGczSGI=|r
zI(?_dOr?N0W!rX56RSRvo>-cP02=7;q~lL88Y_%sa%*8!`=ewsWHj;_MK^lP8I0k+
z3iI9EYg_r3JRGP-wbcM4YmBr5_+vFQ>Z-!}i43PN<mN0XB@2ea@d-f)x53>-oFVl~
z3{F<tio#<7n)dg1ICx%9Hvpml^)E0+sCYquA=)L`Y7-c7pD4T`!c343trwjNi~|IB
zCsSP5-hM%4yoCWxLSM=Y?I8$VTZk6?g>+*FYzr+fsW?Ldabyq)vY9;~modvfA)By;
zkA8N&?7;GfjJ<%GVxLq$as!eTLNg*sS(``q-aS{I*D&aOv(&GS={<SA;m@%}K~4`)
zvLy!Oz5nQLU(+bYAI~(|ag+LmGdeevoQ)d?B>-8-G@M=ZJ!DHZ@IdyA#u9p_ECZos
zq$U_4CF`zYnpB6Nn&k)-75F2&$g>P<*RzdXg$`ffO3JA_e@?3CZkST4(5oES7}2w;
zd&bDa!NGXkcq5^}Ak+vbbTGMMMZu**wWc8>_S%S1N0)=6QG7)*C}hxZ55_OPV*{qf
zJNT~;9l_GFc<Hlf!_0W#&b7Gn+7V2S_M=xbo_}o#UwP~dj-FbGxRt}ij_u<;d?qqh
zZ74%JvB-hl*wmH^qAm)R+MFQ75kuP>mfbvn^*j-vj-(1)E3(aX8a(u8&^<s5-6};z
zhm9F<^+X5ny=Mq-yP*$v-#F@y>+OT@+lJrzsVQ_9m+?1WKaA&JK7;q%K7il-r41et
zBs#$3mc}cGOb8#ah*ku(8C%;)-vqKeNO5I1p?^05$EYM-GS;o4O=OmZyN*)&6=bpV
z&xwa~)YNfUPlS^)Q9@DsI)eP?o!5>cqYj7&_ue!XGSGZ~>z)bRbwxj(JF<-5`_xf<
z^9S?z_}`tzC%$+JouYYRW5d{n)qVKP|9u_gI=@JC4wdIeRMrYaln@%blhcnwRB|hK
zqs^j&96Zuz8o6Qy$+4709kfkEN=VQM6eDW`voGSEC5tNGE4KZVa~Ny(+&woA<I(44
zkY$7$cJyI#yyJS>*4OVC0A(4DpXtFq50_;bzV!Gxyn1xm@sfe@zIU$&EziTI4H;Jk
z=@@y|yy=re<H^lDWyIdtGIS%QhVbmViBup%NrE7N;HUB;M~vz)9ohbD5p>YTM{HC%
zs`1)5c3q($VKSTnK`0)A<6v8Z$X^~a=hjX2;kumzc<1|H!A<|?Foyaw+;{5)KKt-#
zF*u`F)~M?WZ@PX2-*{#f_WkfI0AR7p_`shX1`*+o>&EcQ?_7t?6E%8F__x2b0~s+M
z`{5kE`Q%v?1>xuJUyu85ox<j|1wg>F2bb`l{_-#m9bEtcxaXEB?7nIgS8ndZ!4oAu
z{gvbR_y6KDj1SiM%|HGTUOaR`ID#~ScLe{qyOaPb<V9V^LdDu{$uW>PW<K*g&p(i~
zLu%95E*Nu%C~T5q!5vRvt@ItDc))kRX$?@<_`Anuuz77Cc5WEN)ObI>uy-1Ocv}ep
z_uf2-f`EH(9K^26Cvo&_g)`@t9o?Zm#$boBYx@|wUB=!YoWacb1^nn_7iVWmeB?JS
z!!4I}@ZrzAhQImNNvs|rT(`9!*X|s}7xtb7h;YM>0#~fham9uL%r)-WJ&uLBC9Iz;
z@X#aYFf-R%L7Ay!V?5s8<JUKLba$tFosOeE5*559R(v+lQ?p+=J{%)UFr2Rq;5=9Q
zqD>Dv)BBada(KpDZyv(l=PrPV@U5q3k!8S+HH>W=%u;Pzoqy+tbNH*TpE56ss2RJr
zW%w_@wg$iR%R4bV)B!+v>2Mc6Jh%X^y6Dz~Pk-$^{^DzMc>2HsmU|V}j{}EKE#t`-
zmhk**J^bNcpF)u{F5i@4e8jw=^mE^y#dlv=1mzhzIpd%I!2$f%M-SmI9zKQFkIlE}
zG>ruER7=T_tO26gWAb_x+H*RTTh>}HNNORrheSoHOJ0(aKTZ_4u@T=E4_*(9>n<I}
zrd0(_FLtnV+bGU1c2Jq6yLjuZ6G6W`%kZ(!pT=)}^bk&*>w>Zjbp^cn>JI+nzubX5
zZxlcoP;^jn!-#!kJj?Jizw-iq{ll+2o==?VBFhPNSz&mvfL)DKHQK(gL|85}Tv#If
z*_X~n(imA%3v6T~SqUXht8aR)M(Q=Z2iH_RDt8pEL&%HbRwp4zD=Cv5k6XH=N*6=Q
zxP&D6w%aFBmW&Vl!!Zy|nxd<DFYsG#7{<r{HhlYdo@dzi(lUPG_g=+2ZXd(1zH1`}
z`zl<z2DtsYaqRuUd1N^Qbqzut@n0dw4Oflhj%&xTbHe~e2H3oEUZ{$RP*r9%a?NdZ
zO(;w1naM~C$*JzdcPRMx3WTdKA~f|{D)fP%!fUf?iuXhga=kV5D;ZNGxF0xfP7d@D
z?z(yaANlK(c<h<;j=k+02l1g_+lr~d9&Wf|6i>f&0Sw^Y+g9Vd&z{4Dg$hIkzWDe&
zUU>Z={^U1z0$_{{8oC*o*TWNaMD!WO{mwt#j(e`{$0z>oBtG=@!#I4Z#A6@326-)%
z&dqD;!0rdA1fXk`IODf#*5=Fvu8St}jV<mz2ZWxRBCCC}&d_doG%U%I@T3GJD6|Ne
zA^#bPqw-x?1Nb&?-7|qsk>lZgbC_AkF}s*!W+}%H4lLpLnI5vNz?*Mu(g4@^<@?5Q
z^Od8{7?crSJ=VkYg$h80qi0J8jd`8{kgpyEZo75_Z@Q|$(K9{#)i<Vb{2b8f<S6nE
zs>=K@gk_Wf|L$59-`pJW=CrE;^@=4KfL?ev*U#dpOr;!rMDdsgZ$EaHJg*$WHFwEo
zC5Q1GwJ~LnxwUJA=(?66a~R`ow~S)%bF=7H94v(*B0T*4In)fi`Pu>Z8rS8L@$>hs
z#qdz!8eg$>7;7dvc<pqBXI`2EvH1b1x~efTlw*9<Jnb_wT;P(40^l0s!#PHVJIILf
z6K`6FvbPMP+`N6H@m_9TH$n-m+ld{S)~rk+=B5iM?Mzm&E=Y7f6=)DD8{z7wX5TCb
zi8hJZNq}zn(<24E`=+TYg%%&uO?PbU$NS&A9b2YKELJ)8A1?9l{`eI)_B-#M#Lxct
zTC5+>P*oL<oXhaXpF4{8{MaaN+A)OF^EJM`zl${!1#Z7`07p+P;NO1yD9+57wcVpb
zz+e7fSD-Je(aZWVw^-xF!}Ivq|2m96`HgKD8Sck2XQ&wXtFIo%Kl{mb=q{Cb{d|GH
z{OWORTR({VcaLLgxJI`Go;ujW$Nu&>j-6hPb9N$4+D{#FQ3I*>NP*t!B)VJk5qz*Y
zceBCg9Y7DHxxI+x5*sQ0lcJ>RAJKMX5ZHN1(fk02Ir{X$o`cYBYYD5y%?jX}&D+5b
zpRRG@%rb7eVgQ$I9K^^_j;gBh(&1%%_xT0L7dbOCHm}KX_jM!4i17Va7P0@(5-1~#
z4ghyvGlEWs@SXkhICH+jJMI|AKp)}B=jZUF(-p4R)WKjsH95IPMg<O@C^5SrZcw!t
zKFHhBc*zb40-zvOn%r*)%SANFIRZAQs~kXXZ`9C!;w6ASgmsKuCS|3!f=d^b$3&f#
zRGK0e$mh5dg<V__`S6I>lBBb!yQ3D!+sr>Cc$3k`;-HgL=tjR<K4}xHhh{g@jTA)M
zLy%-aF7wI53f*RS#f+>-1Ot|Y%hNW;i(%|cT(~|>j4O=k<Y_)#UBMwomVA*Dc3n1s
zcm4Q!jEywE)IlxAw}}uYf@8^9{HK6-FOcc)zriV4r!#9bDYDg#aR?`!>LsmbMv}Vm
z#uo$F-XwUkx+IUzY97E&q^4LW-PC_&`N{YP_pigqPzR{&o5dLm-5Srnx`_QRp9kC3
zr8>ny<|;q5lS{TG-&U?0-E;L2{^{E%uz6j9C!U?g?1j>r&J|jzrB<P=fjNbFWwUgk
zv{7|ASG6TUirjxWo(xWbW<c=zeT^nidJLW?6e74}=t*l~<-iF=I6U%#KDzG|-f~re
z2X+tQtKU72?>>7HMYVwc@K2`jp?`HLR!{b&NvYwSU{=V+=yLW;1LkATUceJC&ZDkj
z9v7E<y0)o-{S~@w>Gu;nS{TybWm;*hA#a+wRImaU8`t*Zs-45>Mz$SG?iyqedUd+8
zYzGXO%{f5Z>e3{bkvb=wln6L6U1Mf}QPqqiCu{6KRN~LSdLAGA)Nx$13HaS#*$U}6
z4*o2>Nd*VLGTlfKCVA1<Z03g?Le7I9n&fyHg$Hu)B-#~R+qxF|5Kl%$K*_MLBC`);
zkT^$@AHfq5@az9zBQD#}vE0j1yxt@3G`@u1U>)3|Cj%(_Pr9Y2F}-5M>e!WVt~p%?
zll~?L?|We$2aZ&@d=uf8YbLO7{|q`E!u#H{1sf(atefh`SD%>07alo=5B}<<D0}8@
z9bfp)S?qo4EPnUbF2`s;Veb!T@wu;`#4kL!5xchaVfA<i`(9ec#~*qPAT&P?P40Js
z^9=Zfw{OJFmk(p0pHNnWkNxc_Jp0l#-gDo2+<e6lj-BmcsmplF^`ltoRru_;X7QE1
zC$RhKF+8wm0$1-G!G}J51V4ZOCD^>C4@b}R@TXrqfp_0MiEFkEVt%p2NB{OTzW>5`
z0Km{-f%m;@JyuV4ux_d!fAg(#_{!cBxb2!T+_z^HF5f<k5C6sMc<%%2ux|ALj-Tn_
zcmM1V`Z~aW`t|KtJyc`u_!REBbv3^E{aJkeo2Oc=V-2tKskf#H2A@mW1`?Ag0=3~K
zsK|A2EmjwQ;oyG$%bd%y49~nW2d)`A*B4-By#F6>!Vq=w{{Qj{{^Oq?#QPo?!LCck
z@Q0s1h&`9)n4Md~W8a?!5#h7{`zX$wnZrX5AIJakvm3E%Bjexv;Vbwze{=xvxxIr2
z?pk9;&)^FyFn;6bH{&hW^y6QD<VF0-?>~>(nOS`By;E2{*^h5MaU5Hw2siKS!=w9-
z<Aa}g3Cr^f`1PL{#`RZ>;l+b9SX@}bM6rlHR}JAmfBF^t-M5b7%C%km>VsqW+}Drb
z_y5}gtQukb$~&f99Q^+KHe-3Ii}(N0EBKR#Uc<k7*9flKF^Xpo%pkA3SY0gP>diU+
z-~VwCUwY&)c5MXiyLAkw&MxEk{`4RK;Nd5y@duwgfNwr=O2o2Ec-mrW6L~)Z@TMrp
zQsiVqn``_N^niB<Qh&Z*mKR|A6CUEGHD|e7igf9w0o-v#A5P5|xaqpp7#bZxmIK%A
z9Kw;)CHB2Ai@SFXVD(f#0N^L?n!sOuV;aK)Io^KrFpkX>xMA07Y~4DA`K1ik?-*<h
z;Gbt)HCEu>8;0@iXJ^r?a!^*_bC1qopaa}}!x+xY0&@#poSm!i(%}*>9<K0_zdjA(
z8h2kahzm=E>A4Ddmg9?$pU00**Le7Qv*`47@YKr-c>eVg&mHRFwd2c}95yJq`>J8=
z+SI|Br4DYqb`^@jA>>7l8!sQig(br5e2Iaf4nF^#3pjG7#@C;^05D^8*j%+_x%r)<
znFYqtvxM0NY0rxkPV&6HpAvKlL)l#g#F<2_RB4JD?@_v9NMJ}^fr>uQQ$ypDsXl-R
z2M#acvW)`(3S2TWhx!sTH~*=xoWgUjnME64dU6goTsn*g_DteS-#Lq+fesEHUB<PS
z4g*z<)q_j8exrE{=;t0ef!9t}0LZ@)G$ZU-*9WdDTv+yR2t9nNYkoO&*g9qg=E}+X
z;_HjZivs=jRvCu~XJ&pgciBb6=8j+^>y|ZrAR=rY>!EMGd1UNUUp|574|ZMEUsZ5X
z$PDv#v#N4|l{G&`p-rpHFQwq5CBvtP!>!QAWRc=8DOo)is0+ieJOK#Ea@3W0IWIGY
z2Xowf`2Y@{=wjasb9nQO6Ud11qcb%=^R*dhN80=JEN0%l77yGqf+7bV`o?L1OaxJu
z;rwET|M9gsB>*+=12pUR7Q3dvS~Z%vD~JC63{_R*#96air<Qm308EW{0Lt*%$u7V^
zkr(crLj<6%OpRfGNsM8Bi=eK}ODdMSHL9w_fnz;<;oGy#xZ?K!Y6j34o5VX98V}8g
zP**i-QCnKw%1d8qa(}}~|85f{4R0w%H-mzV-ng{8&bK-a_QJk|rXsJ*Pp&o;Ff^Fs
z-~E%#ID2jhAN=n}01zJg;dz{%>EYdXjN!^1<6tm$ZXLy)H#WJH2%q0Ojj5p;H|`w3
zv#%@w%s6y(5icHD!ke!f!7bOW0sw4YKZGCOv!+p?xiw2fc<$ACoSrFh=XGNk=r=zB
zcE`12ICr7MBR`li<1nMH8?`axC+?cUx!ErM{)rh=RQ7tPOY;i(Cg@RBJ@+G))KvTS
zSHt!`JA?Vf5<mNvHQ2n~yj=RK?W4H)nn_b2!;Dwg=9Q!w5vsCsI%NXty2Scb=8dF%
z9q}Zvy1EIgE;*T{YXoUMk7#+GXCFva|3O<B{dzwb-sIokdhaIe+S<WDe~w+3P2iTR
z#&Q3xV|Z%+Ieh4|r!c!<+_<WN?>;w!UE2roOK+RP&)l~jTUQaj^w?R<FPlVj<kS-0
zefI=D{q<?QdZcTFB*GK>XR&o%fq(qg3B32gjktV6fiFLH8oPE5;b-17iN1ocW6KyG
zeR>Yxd2R-~cNX}?cW%O)Z<@lUDc}R2JchHg2B99jZ4#Gm7{smDPvC*ur?6#Jh7W%7
z7*3uqaoaVc__=#mV`z}DW9uj$dwLeX{fnEhW`wbJbw6G?+QZv!pTHg03}GOzuxix^
zzWvNB_PuxkH|;F&%MY%?Pv5r*myDJ8@?+Du<*E_9^R999WfgX8o517GoX2nf;%2O$
zAgo{AkJ&}w`!CGl?(0W!*Yy*)|Blrd9w0n@VBRS{0{dVmx)zP>B=@PWQzTz|AI&H+
z!Y8%u@qh;dXH`}CPL?GHnW1+v45SYB8`$gCnfb*IarIG^m3gV7WekRax~`FDj3Os2
z_YCycH8(4BtcRO1tE$FepZPhtg=O>m!iEgvPkwVN=9d`%`i~BwuOKY;$h}qEtoC82
zlPojo!?I!b?UrR;&a$j9&;crD)U|nkfuq+L(!AiRc1F#cpPQ|!3ZsLB`6UKrxzmT7
zi4J}TSOjH=)GKd=?B(XA1LJ!`NuuG+7Y{4;En8_8Gz^)Zd7hzL0zlqemdGm#LQxd4
zbWNeeAoQ9ahcu-Jh3~*`w!FyEtpV5{l5FHOoRG<PS%Gfzb26@9<3N6@)%<#x!(*`F
zPZo(ynOqbF%0`j)6}HCl!eY(*W`TIyYSV6^XXKGnDnU@fJEm+9&Qi--O&&9igSUjS
zbOMArm-E;<qX6=Xzb*GD;}ePVgmA=Ee<;Ru#hVyLlT}@q89#mRI;<KkuyHEGKYIHm
z7#zqWj#<*PrFpUlwut8)A=q4hQpb#P#f6q%2?PW;+5FqqBkc%!QXO6)9*@1=slTs?
z9x#<i;0UGc2d~pqVUpx1XbJUQ?&~&sYag-IIUIQ-0N0GGxAiqMhUN`m2anh2cG;2E
zZ`iOz{2LHbyldGVe2CL+e8UgM30tUCoT3z>ghuJGr>Oz7g6vm8S*8XO!ulVL)xe%o
zgc33-yr&&}Z@pK(vinK;M0#$+er+zEl#JnM<o~;V+63vIT4%xdYKztl2q%;(2(%Ev
z{u|j0(F~M8Bq@{qsvyb>=3$Q^J45a3#F3CbfKG|sRx4V{750PauZB~d%iLKNQV31S
zZ10tLGm>l7=IC(eC{Qv*EeUZ?se3>;hB)prBI%A7^9HZ~@C6aV`)s-jytm;ZK(R<z
zqtKONG0d6f&y$jml&<s{<}!EAeN`$>fl$bTk*%4OA*mPV+#HkkM-^c)wo{r2386&U
zQ$AfC>Oq*c>7du9SU%F6q!kdpB8CyHyy3vxj7F>+fj0(@qSX~|QB^C14R3l%qlaoq
zqDg?C3U%5tOw-MQ08w}kUA0$s3^)o0(!8f|T8D{gW5!^QSR78q$(2L_SXwn8b!DHn
zNl*h25YHPY(s2SYW8zJ_|KF*}vlcK-(Ye%?!ky5?g5x6LyV0zjSnI;BZfZ+k?Hsf_
zZCo!{W+XpuU-G8OChCNg)Ori1f&;NGlB6s{wqGQ85+>U|DQYK`<zK8U8A(KWQe4G6
zi7$c)x%R}OpU&E5r1XPbtlC~Y7blD_tSeXc01&sg6&`9NYd%x1nsQtJx_H?`kD{%n
zh-y*W%%FkXJFY(yLzhkkZ7UOW>Sz%?f+@8pbYLSeh_<+!Q(u}V4WVfX1BcWEQ|U)4
zkW%m->eGCWSAE5ghFQ-Sig1O8V#pGWhi!L))aLVlidhz8kP;(BF?g>=8`J6w``wjD
z!|O)YF~Q}%qbHvNjL)U`HsUo-l4xR2#ULhsiO9<ohe5oeOFSWA|9qk6PPHLg<QXAY
ztPDYI?-(}cI5K1k>O+@_6H&q)UGCDH!q0oyd@6f#*jgJsmG|2*Eu~OO`UZ*S92^vs
znv`KzWwQ`1r49L0znRP%j&Z?XWOvJqg-JKC-?SN|Z+aPH7f%OZ+hWy~5{*0`zHcbj
zqHwd2!FXJKT<q&x=IOktk7-AYH)B&9=Z!p!bp2%woA7(LXjwWo1DU-uB|EwRVZovf
zLc0lv(4yMH%9_C4P)U*_Ayi07#*kkh8&(Ff>V2D)U**Q?tK3h7kVFFVU6M0#LMLhS
zCOW8n7dp=9GBgA~B3LEJNuz5SKxlq9P{4n%Md&4{3aAXAMp#xqv=Q9Ogf@dGq5?56
zoBsK@lw$qycopMHtv%k_Qxwg^s}=#=S!Zy3Q#vupt}#W)r>KJ@4~m%7s|!Sn;KDXe
z=K{giiXcTf)V!b?_lVRhqeC(#I$2qwyN?_aO8+2*^uq=mn+ss?IBo=_pL_5EQeY{G
z=NzXvu`h49SlQal8IqC3ZD{oHSR+$Fhyy<4Z#_8nSp|~dGq|r~CW4e(wT0FjJ+Ipe
zc_M`&JZ}{!Z4pe!P&j-lvP9EBvM?R!mMy$%P;8EIN@qauRBk|n^eCG6$`}!!m&#BB
zaEnY0B1nCvUl4II<F2HA8Op*V<<(6DEb!+Yd7Hl^LQ_E6<wy7ORvoDUi@|FvVNBSP
z@`6Mkp7%)B?liiHR#cIWAf5E&;F^leJL<a(cR7Z0+;FItAC7GCfRq#J^BjJUZX>ho
zPT`FV?Hz&P!)KS|Wsd`QA!I0#X3V;dbU`f-hsPQcZHQx=xGn;Mts`jp<KEU|R<eij
zFz?LDLnGAS=&-x;Lt72dc5^vpa7r|HhNJlYy4I3pNYhg3A{a&@hSrZTFa;e_0!gn+
z5LYreUZ|y6qwjF-#2eXkBv3p^6xb9T_KYdy3&>HR&@AbaDKA|iMY+p6N0^)F_fM<p
z&xkI2Q;;Cz74I)4ZJQu{2pX0(eW4hCPrb7*<q$2RCz?qcS$)W3EMXvG&xMH^#J3Nh
zVdk)Vf^;xUqd>WzepBcQ#tsjJ*6_teB3bK*5wOHc5yA2^HKwlvNOmztnsaiE8;AcQ
zqVW}mWio;H3EmxT%R6}#(CY^D$gZY{piLM#xC7btBc9rmgwx3G33SckAJ$`~F#TOK
zz`=O!-W`6|zkIEo!x++k*O^1j?*&qk>Lc??I=&_L2uE2-CdaeAO`Jft79ervWdwz-
z=FWqKBIIUvv{TCzE;OV076T-%0u(Vvux%6hiPgSjK<QV$EK;_yaye3*utOqkxcq=n
zjS?s1y1sy51WhT%)#m0_3DK%rggOte;ltFW%-upkZF+r}lqp=w6m)Uqgo(tjhp(_D
zPiwDS;dE5Ic<4>t_jYZC(=ZTJuX?P;7SZ^jGx+D{!X&{#%g`uo&c8x{$Wx6B&Jir^
zi=p+X?bb*r(j5`eLH3<U>>N(7>b9$lGIg|dXg|J&9dnG3I4ntPhEwzGa<|caFbexm
z-L*kuKNN-MJm)&vty}oxvB_I>)55<iUJ1b*y(JZ_I3mrTtV`N%glWDgI&6Mx!Mc0X
eA^<rv@c##^mLGv1-p1Sj0000<MNUMnLSTY+>5I?+

literal 0
HcmV?d00001

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"

From f8e46e9bfae4992cd9b74a07a2e8b61fa28e0f33 Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden1@outlook.com>
Date: Thu, 28 May 2026 09:26:31 +0100
Subject: [PATCH 3/3] refactor(graph): simplify GraphService + codify patterns
 in rules

Merge GetFirstFolderPageAsync/GetNextFolderPageAsync into single
GetFolderPageAsync(string? nextLink), collapse two GetFoldersFromPagesAsync
overloads into one nullable-accumulator method, inline GetDriveFoldersAsync,
drop Children() helper, and add GraphClient type alias.

Codify the three emerging patterns in c-sharp-code-style.md (using alias,
nullable accumulator over overload pair, inline single-use wrapper) and
replace the Getting root folders prose in onedrive-graph.md with concrete
code examples from the refactored GraphService.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .claude/rules/c-sharp-code-style.md           |  34 ++
 .claude/rules/c-sharp-testing.md              |   2 +-
 .claude/rules/onedrive-background.md          |   2 +-
 .claude/rules/onedrive-di.md                  |   2 +-
 .claude/rules/onedrive-graph.md               |  62 +++-
 .claude/rules/onedrive-onboarding.md          |   2 +-
 .claude/rules/onedrive-persistence.md         |   2 +-
 .claude/rules/onedrive-sync.md                |   2 +-
 .claude/rules/onedrive-viewmodels.md          |   4 +-
 .../AStar.Dev.CloudSyncFunctional.csproj      |   2 +-
 .../App.axaml.cs                              |  31 +-
 .../Auth/AccountId.cs                         |  15 +
 .../Auth/AccountProfile.cs                    |  11 +
 .../Auth/AuthError.cs                         |   3 +-
 .../Auth/AuthService.cs                       |   4 +-
 .../Auth/DriveId.cs                           |  15 +
 .../Auth/IAuthService.cs                      |   6 +-
 .../Auth/ITokenCacheService.cs                |   2 +-
 .../Controls/AccountHeader.axaml              |   6 +-
 .../Controls/AccountHeader.axaml.cs           |  25 +-
 .../Controls/AccountListItem.axaml.cs         |  24 +-
 .../Controls/AppButton.axaml.cs               |  28 +-
 .../Controls/AppButtonSize.cs                 |   2 +-
 .../Controls/FolderToolbar.axaml              |   4 +-
 .../Controls/FolderToolbar.axaml.cs           |  43 +--
 .../Controls/FolderTreeRow.axaml.cs           |  33 +-
 .../Controls/ProviderMark.axaml.cs            |   6 +-
 .../Controls/StatusBar.axaml.cs               |  62 ++--
 .../Controls/StatusDot.axaml.cs               |   6 +-
 .../Controls/StatusPill.axaml.cs              |   6 +-
 .../Controls/StorageBar.axaml.cs              |   9 +-
 .../Controls/SubTabBar.axaml.cs               |  36 +-
 .../Controls/ThroughputCard.axaml.cs          |  24 +-
 .../Controls/TriStateCheckbox.axaml.cs        |   3 +-
 .../Domain/OneDriveAccount.cs                 |   2 +-
 .../Graph/DriveFound.cs                       |   7 +
 .../Graph/GraphClientFactory.cs               |  11 +-
 .../Graph/GraphService.cs                     |  93 +++--
 .../Graph/IGraphClientFactory.cs              |   7 +-
 .../Graph/IGraphService.cs                    |   2 +-
 .../Graph/RootFound.cs                        |   9 +
 .../Onboarding/AccountOnboardingService.cs    |  50 ++-
 .../Onboarding/IAccountOnboardingService.cs   |   2 +-
 .../Repositories/AccountRepository.cs         |   6 +-
 .../Repositories/DriveStateRepository.cs      |   6 +-
 .../Repositories/IAccountRepository.cs        |   2 +-
 .../Repositories/IDriveStateRepository.cs     |   2 +-
 .../Repositories/ISyncedItemRepository.cs     |   2 +-
 .../Repositories/SyncedItemRepository.cs      |   6 +-
 .../Wizard/AddAccountWizardView.axaml         |   6 +-
 .../Wizard/AddAccountWizardViewModel.cs       |   4 +-
 src/AStar.Dev.FunctionalParadigm/Option.cs    |  38 +-
 .../OptionExtensions.cs                       |  88 +++--
 .../ResultExtensions.cs                       | 178 ++++++---
 ...oudSyncFunctional.Tests.Integration.csproj |   6 +-
 ...enAnAccountOnboardingServiceIntegration.cs |  24 +-
 .../GivenADriveStateRepository.cs             |   4 +-
 .../Repositories/GivenAnAccountRepository.cs  |  10 +-
 ....Dev.CloudSyncFunctional.Tests.Unit.csproj |   4 +-
 .../Auth/GivenADriveId.cs                     |  12 +
 .../Auth/GivenAnAccountId.cs                  |  12 +
 .../Auth/GivenAnAccountProfile.cs             |  15 +
 .../Auth/GivenAnAuthResult.cs                 |  24 +-
 .../FunctionalParadigm/GivenAUnit.cs          |  10 +-
 .../Graph/GivenAGraphClientFactory.cs         |  38 +-
 .../Graph/GivenAGraphService.cs               | 338 +++++++++++++++++-
 .../GivenAnAccountOnboardingService.cs        |   9 +-
 .../GivenAnAddAccountWizardViewModel.cs       |  14 +-
 .../Workspace/GivenAWorkspaceViewModel.cs     |  17 +-
 .../GivenAResultMatch.cs                      |  73 ++++
 .../GivenAnOption.cs                          |   4 +-
 .../GivenAnOptionBind.cs                      |  10 +-
 .../GivenAnOptionMap.cs                       |   6 +-
 .../GivenAnOptionMatch.cs                     |   6 +-
 .../GivenAnOptionTap.cs                       |  10 +-
 75 files changed, 1167 insertions(+), 518 deletions(-)
 create mode 100644 src/AStar.Dev.CloudSyncFunctional/Auth/AccountId.cs
 create mode 100644 src/AStar.Dev.CloudSyncFunctional/Auth/DriveId.cs
 create mode 100644 src/AStar.Dev.CloudSyncFunctional/Graph/DriveFound.cs
 create mode 100644 src/AStar.Dev.CloudSyncFunctional/Graph/RootFound.cs
 create mode 100644 test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenADriveId.cs
 create mode 100644 test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountId.cs
 create mode 100644 test/AStar.Dev.CloudSyncFunctional.Tests.Unit/Auth/GivenAnAccountProfile.cs

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-background.md b/.claude/rules/onedrive-background.md
index 276bb69..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
 ```
 
diff --git a/.claude/rules/onedrive-di.md b/.claude/rules/onedrive-di.md
index 32af807..1ecec43 100644
--- a/.claude/rules/onedrive-di.md
+++ b/.claude/rules/onedrive-di.md
@@ -70,7 +70,7 @@ public class AccountRepository(IDbContextFactory<AppDbContext> dbFactory) : IAcc
     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 064a719..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
@@ -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;
 ```
@@ -93,7 +123,7 @@ static async Task EnumerateSubFolderAsync(GraphServiceClient client, DriveId dri
     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>`.
diff --git a/.claude/rules/onedrive-onboarding.md b/.claude/rules/onedrive-onboarding.md
index 7b97d26..24f3163 100644
--- a/.claude/rules/onedrive-onboarding.md
+++ b/.claude/rules/onedrive-onboarding.md
@@ -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 50fd28f..2769fcd 100644
--- a/.claude/rules/onedrive-persistence.md
+++ b/.claude/rules/onedrive-persistence.md
@@ -194,7 +194,7 @@ public async Task<Result<Unit, PersistenceError>> UpsertAsync(AccountEntity enti
 {
     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 5310182..493a9ad 100644
--- a/.claude/rules/onedrive-sync.md
+++ b/.claude/rules/onedrive-sync.md
@@ -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.
 
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/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj b/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
index b6312af..81f2d6e 100644
--- a/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
+++ b/src/AStar.Dev.CloudSyncFunctional/AStar.Dev.CloudSyncFunctional.csproj
@@ -38,10 +38,10 @@
       <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>
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs b/src/AStar.Dev.CloudSyncFunctional/App.axaml.cs
index 570e764..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();
@@ -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/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 d37d211..c2e4c97 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/AuthService.cs
@@ -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 3be4f15..0f5fd96 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Auth/IAuthService.cs
@@ -6,19 +6,19 @@ 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 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 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 cancellationToken = default);
 
diff --git a/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs b/src/AStar.Dev.CloudSyncFunctional/Auth/ITokenCacheService.cs
index ee96062..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 cancellationToken = default);
 }
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 af1bfe8..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 cancellationToken = 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: cancellationToken).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: cancellationToken).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, cancellationToken: cancellationToken)
-                .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: cancellationToken)
-                    .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 db6ba85..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 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/Onboarding/AccountOnboardingService.cs b/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
index ba36745..7b20683 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Onboarding/AccountOnboardingService.cs
@@ -4,11 +4,12 @@
 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)];
@@ -24,45 +25,34 @@ public async Task<Result<OneDriveAccount, PersistenceError>> CompleteOnboardingA
             .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 cancellationToken)
-    {
-        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, cancellationToken)
-                .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 1fe40cd..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 cancellationToken = default);
 }
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
index cbb7ed5..e6753ed 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/AccountRepository.cs
@@ -10,14 +10,14 @@ 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 cancellationToken = default)
+    public async Task<Option<AccountEntity>> GetByIdAsync(AccountId id, CancellationToken cancellationToken = default)
     {
         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/>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
index c1a5033..fe6db6a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/DriveStateRepository.cs
@@ -10,14 +10,14 @@ 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 cancellationToken = default)
+    public async Task<Option<DriveStateEntity>> GetByAccountAsync(AccountId accountId, CancellationToken cancellationToken = default)
     {
         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/>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs
index e477c29..09d79bc 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IAccountRepository.cs
@@ -12,7 +12,7 @@ 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 cancellationToken = default);
+    Task<Option<AccountEntity>> GetByIdAsync(AccountId id, CancellationToken cancellationToken = default);
 
     /// <summary>Retrieves all accounts.</summary>
     /// <param name="ct">Cancellation token.</param>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs
index ee8bd66..63d920a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/IDriveStateRepository.cs
@@ -12,7 +12,7 @@ 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 cancellationToken = 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>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs
index 532a2ae..84a1af0 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/ISyncedItemRepository.cs
@@ -12,7 +12,7 @@ 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 cancellationToken = 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>
diff --git a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
index 44372b9..b44744a 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Persistence/Repositories/SyncedItemRepository.cs
@@ -10,14 +10,14 @@ 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 cancellationToken = default)
+    public async Task<Option<SyncedItemEntity>> GetByIdAsync(SyncedItemId id, CancellationToken cancellationToken = default)
     {
         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/>
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 c21838d..541a4a9 100644
--- a/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs
+++ b/src/AStar.Dev.CloudSyncFunctional/Wizard/AddAccountWizardViewModel.cs
@@ -273,9 +273,9 @@ private async Task ExecuteAddAccountAsync(CancellationToken cancellationToken)
 
         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, cancellationToken)
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");
     }
 }