Report progress before saving SQLite

Report increment rather than total position
Bump actions/checkout from 4 to 5 (#376 )
2025-08-26 10:31:43 +01:00 · 2025-08-26 10:04:14 +01:00 · 2025-08-20 10:32:24 +01:00 · 2025-08-06 13:28:59 +01:00 · 2025-08-06 13:13:39 +01:00 · 2025-08-04 14:21:50 +00:00
76 changed files with 2046 additions and 322 deletions
@@ -3,18 +3,11 @@
  "isRoot": true,
  "tools": {
    "csharpier": {
-      "version": "1.0.2",
+      "version": "1.1.2",
      "commands": [
        "csharpier"
      ],
      "rollForward": false
-    },
-    "gitversion.tool": {
-      "version": "6.1.0",
-      "commands": [
-        "dotnet-gitversion"
-      ],
-      "rollForward": false
    }
  }
 }
@@ -13,7 +13,7 @@ To ensure high-quality and consistent commits, please follow these guidelines:
 3. **Test your changes**
    - Run all unit tests before committing.
    - Add or update xUnit tests as needed.
-    - Use FluentAssertions for assertions and Moq for mocking in tests.
+    - Use AwesomeAssertions for assertions and Moq for mocking in tests.

 4. **Review your changes**
    - Double-check for accidental debug code or commented-out code.
@@ -8,9 +8,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
+      uses: actions/checkout@v5

    - name: Setup .NET
      uses: actions/setup-dotnet@v4
@@ -21,9 +19,25 @@ jobs:
      with:
        path: ~/.nuget/packages
        key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
-
+        
+    - id: set-version
+      name: Set version to output
+      run: |
+        SEMVER="3.0.99.${{ github.run_number }}"
+        FILE_VERSION=$(echo "$SEMVER" | sed -E 's/^([0-9]+\.[0-9]+\.[0-9]+).*/\1/')
+        FILE_VERSION="$FILE_VERSION.${{ github.run_number }}"
+        
+        echo "semver=$SEMVER" >> "$GITHUB_OUTPUT"
+        echo "fileVersion=$FILE_VERSION" >> "$GITHUB_OUTPUT"
+        
+        echo $SEMVER
+        echo $FILE_VERSION
+        
    - name: 🔫 Build All
      run: ./build.sh
+      env:
+        SEMVER: ${{ steps.set-version.outputs.SEMVER }}
+        FILE_VERSION: ${{ steps.set-version.outputs.FILE_VERSION }}
      
    - name: Upload coverage reports to Codecov with GitHub Action
      uses: codecov/codecov-action@v5
@@ -2,7 +2,6 @@ name: .NET Build and Publish

 on:
  push:
-    branches: ["main", "dev"] 
    tags: ["3.*"]

 jobs:
@@ -10,23 +9,41 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
+        uses: actions/checkout@v5
+        
      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: 8.x.x
-          
+
      - uses: actions/cache@v4
        with:
          path: ~/.nuget/packages
          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+          
+      - id: set-version
+        name: Set version to output
+        run: |
+          TAG=${{ github.ref_name }}
+          if [[ "${{ github.ref }}" != refs/tags/* ]]; then
+            TAG="3.0.99.${{ github.run_number }}"
+          fi
+          SEMVER="${TAG}"
+          FILE_VERSION=$(echo "$TAG" | sed -E 's/^([0-9]+\.[0-9]+\.[0-9]+).*/\1/')
+          FILE_VERSION="$FILE_VERSION.${{ github.run_number }}"
+
+          echo "semver=$SEMVER" >> "$GITHUB_OUTPUT"
+          echo "fileVersion=$FILE_VERSION" >> "$GITHUB_OUTPUT"
+
+          echo $SEMVER
+          echo $FILE_VERSION
              
      - name: 🔫 Build and Pack
        run: ./build.sh pack
-        
+        env:
+          SEMVER: ${{ steps.set-version.outputs.SEMVER }}
+          FILE_VERSION: ${{ steps.set-version.outputs.FILE_VERSION }}
+          
      - name: Upload coverage reports to Codecov with GitHub Action
        uses: codecov/codecov-action@v5
        with:
@@ -15,6 +15,7 @@ tests/TestArchives/Scratch
 tools
 .vscode
 .idea/
+.volumes/

 .DS_Store
 *.snupkg
@@ -1,6 +0,0 @@
-workflow: GitFlow/v1
-next-version: 3.0.0
-branches:
-  main:
-    prevent-increment:
-      when-current-commit-tagged: true
@@ -9,9 +9,12 @@ Speckle | Sharp | SDK
 ### .NET SDK, Tests, and Objects

 [![codecov](https://codecov.io/gh/specklesystems/speckle-sharp-sdk/branch/dev/graph/badge.svg?token=TTM5OGr38m)](https://codecov.io/gh/specklesystems/speckle-sharp-sdk)
+<a href="https://www.nuget.org/packages/Speckle.Sdk/"><img alt="NuGet Version" src="https://img.shields.io/nuget/v/Speckle.Sdk?label=Speckle.Sdk"></a>
+<a href="https://www.nuget.org/packages/Speckle.Objects/"><img alt="NuGet Version" src="https://img.shields.io/nuget/v/Speckle.Sdk?label=Speckle.Objects"></a>
+<a href="https://www.nuget.org/packages/Speckle.Automate.Sdk/"><img alt="NuGet Version" src="https://img.shields.io/nuget/v/Speckle.Sdk?label=Speckle.Automate.Sdk"></a>

 > [!WARNING]
-> This is an early beta release, not meant for use in production! We're working to stabilise the 3.0 API, and until then there will be breaking changes. You have been warned!
+> Releases Speckle.Sdk and Speckle.Objects are reliable for production use, but the APIs may not be wholly stable, and there may be breaking changes between releases, with little documentation.

 # Repo structure

@@ -28,11 +31,13 @@ This repo is the home of our next-generation Speckle .NET SDK. It uses .NET Stan

 ### Other repos

-Make sure to also check and ⭐️ these other Speckle next generation repositories:
+Make sure to also check and ⭐️ these other  repositories:

- [`speckle-sharp-connectors`](https://github.com/specklesystems/speckle-sharp-connectors): our csharp repo of next gen connectors
- [`speckle-sketchup`](https://github.com/specklesystems/speckle-sketchup): Sketchup connector
- [`speckle-powerbi`](https://github.com/specklesystems/speckle-powerbi): PowerBi connector
+- [`speckle-sharp-connectors`](https://github.com/specklesystems/speckle-sharp-connectors): our csharp repo of next gen connectors.
+- [`speckle-server`](https://github.com/specklesystems/speckle-server): the speckle server.
+- [`speckle-sketchup`](https://github.com/specklesystems/speckle-blender): Blender connector.
+- [`speckle-sketchup`](https://github.com/specklesystems/speckle-sketchup): Sketchup connector.
+- [`speckle-powerbi`](https://github.com/specklesystems/speckle-powerbi): PowerBi connector.
 - and more [connectors & tooling](https://github.com/specklesystems/)!

 ## Documentation
@@ -45,18 +50,24 @@ Comprehensive developer and user documentation can be found in our:

 ### Building

-Make sure you clone this repository together with its submodules: `git clone https://github.com/specklesystems/speckle-sharp-sdk.git -recursive`.
-Afterwards, just restore all the NuGet packages and hit Build!
+Ensure you're using a [8.0.4xx](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) .NET SDK. 
+After cloning this repository, just restore all the NuGet packages and hit Build!

 ### Developing

-This project is evolving fast, to better understand how to use Core we suggest checking out the Unit and Integration tests. Running the integration tests locally requires a local server running on your computer.
+It is highly recommended you use
+ - Either Jetbrains Rider or Visual Studio 2022
+ - Ensure your IDE is set to use [the correct .NET SDK version](https://github.com/specklesystems/speckle-sharp-sdk/blob/main/global.json) (newer major versions may work, but may incorrectly run analysers we haven't configured)
+ - You should install the cshapier plugin ([Rider](https://plugins.jetbrains.com/plugin/18243-csharpier), [VS](https://marketplace.visualstudio.com/items?itemName=csharpier.CSharpier)) and configure it to run on save

-We'll be also adding [preliminary documentation on our forum](https://discourse.speckle.works/c/speckle-insider/10).
+Docs are a bit patchy [https://docs.speckle.systems/developers/looking-for-developer-docs](https://docs.speckle.systems/developers/looking-for-developer-docs)

 ### Tests

-There are two test projects, one for unit tests and one for integration tests. The latter needs a server running locally in order to run.
+There are several test projects. It is a requirement that all tests pass for PRs to be merged.
+The Integration test projects require a local server to be running.
+
+You must have docker installed. Then you can run `docker compose up --wait` from the root of the repo to start the required containers.

 ## Contributing

@@ -23,7 +23,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "config", "config", "{DA2AED
 		Directory.Packages.props = Directory.Packages.props
 		global.json = global.json
 		README.md = README.md
-		GitVersion.yml = GitVersion.yml
 		docker-compose.yml = docker-compose.yml
 		CodeMetricsConfig.txt = CodeMetricsConfig.txt
 		Directory.Build.Targets = Directory.Build.Targets
@@ -11,7 +11,6 @@
    <File Path="Directory.Build.Targets" />
    <File Path="Directory.Packages.props" />
    <File Path="docker-compose.yml" />
-    <File Path="GitVersion.yml" />
    <File Path="global.json" />
    <File Path="README.md" />
    <File Path=".github\copilot-instructions.md" />
@@ -43,4 +42,4 @@
    <Project Path="tests/Speckle.Sdk.Serialization.Tests/Speckle.Sdk.Serialization.Tests.csproj" />
    <Project Path="tests/Speckle.Sdk.Tests.Unit/Speckle.Sdk.Tests.Unit.csproj" />
  </Folder>
-</Solution>
+</Solution>
@@ -1,4 +1,3 @@
-using System.Text.Json;
 using GlobExpressions;
 using static Bullseye.Targets;
 using static SimpleExec.Command;
@@ -16,14 +15,13 @@ const string CLEAN_LOCKS = "clean-locks";
 const string PERF = "perf";
 const string DEEP_CLEAN = "deep-clean";

-static async Task<(string, string)> GetVersions()
+static (string semver, string fileVerison) GetVersions()
 {
-  var (output, _) = await ReadAsync("dotnet", "dotnet-gitversion /output json").ConfigureAwait(false);
-  output = output.Trim();
-  var jDoc = JsonDocument.Parse(output);
-  var version = jDoc.RootElement.GetProperty("FullSemVer").GetString() ?? "3.0.0-localBuild";
-  var fileVersion = jDoc.RootElement.GetProperty("AssemblySemFileVer").GetString() ?? "3.0.0.0";
-  return (version, fileVersion);
+  string semver =
+    Environment.GetEnvironmentVariable("SEMVER") ?? throw new ArgumentException("Expected SEMVER env var");
+  string fileVersion =
+    Environment.GetEnvironmentVariable("FILE_VERSION") ?? throw new ArgumentException("Expected FILE_VERSION env var");
+  return (semver, fileVersion);
 }

 Target(
@@ -77,7 +75,7 @@ Target(
  dependsOn: [RESTORE],
  async () =>
  {
-    var (version, fileVersion) = await GetVersions().ConfigureAwait(false);
+    var (version, fileVersion) = GetVersions();
    Console.WriteLine($"Version: {version} & {fileVersion}");
    await RunAsync(
        "dotnet",
@@ -174,7 +172,7 @@ Target(
  async () =>
  {
    {
-      var (version, fileVersion) = await GetVersions().ConfigureAwait(false);
+      var (version, fileVersion) = GetVersions();
      Console.WriteLine($"Version: {version} & {fileVersion}");
      await RunAsync("dotnet", $"pack Speckle.Sdk.sln -c Release -o output --no-build -p:Version={version}")
        .ConfigureAwait(false);
@@ -1,4 +1,3 @@
-version: "3.9"
 name: "speckle-server"

 services:
@@ -22,7 +21,7 @@ services:
      retries: 30

  redis:
-    image: "redis:6.0-alpine"
+    image: "valkey/valkey:8.1-alpine@sha256:0d27f0bca0249f61d060029a6aaf2e16b2c417d68d02a508e1dfb763fa2948b4"
    restart: always
    volumes:
      - redis-data:/data
@@ -38,6 +37,9 @@ services:
    restart: always
    volumes:
      - minio-data:/data
+    ports:
+      - '127.0.0.1:9000:9000'
+      - '127.0.0.1:9001:9001'
    healthcheck:
      test:
        [
@@ -53,11 +55,11 @@ services:
    image: speckle/speckle-server:latest
    restart: always
    healthcheck:
-      test:
+      test: 
        - CMD
        - /nodejs/bin/node
        - -e
-        - "try { require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/readiness', method: 'GET', timeout: 2000 }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(res.statusCode != 200 || body.toLowerCase().includes('error'));}); }).end(); } catch { process.exit(1); }"
+        - "try { require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/readiness', method: 'GET', timeout: 2000 }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(Number(res.statusCode != 200 || body.toLowerCase().includes('error')));}); }).end(); } catch { process.exit(1); }"
      interval: 10s
      timeout: 10s
      retries: 3
@@ -79,8 +81,9 @@ services:

      # TODO: Change thvolumes:
      REDIS_URL: "redis://redis"
-
+      
      S3_ENDPOINT: "http://minio:9000"
+      S3_PUBLIC_ENDPOINT: 'http://127.0.0.1:9000'
      S3_ACCESS_KEY: "minioadmin"
      S3_SECRET_KEY: "minioadmin"
      S3_BUCKET: "speckle-server"
@@ -102,6 +105,10 @@ services:
      ENABLE_MP: "false"
      
      LOG_PRETTY: "true"
+      
+      FF_NEXT_GEN_FILE_IMPORTER_ENABLED: "true"
+      FF_LARGE_FILE_IMPORTS_ENABLED: "true"
+      

 networks:
  default:
@@ -110,4 +117,4 @@ networks:
 volumes:
  postgres-data:
  redis-data:
-  minio-data:
+  minio-data:
@@ -0,0 +1,20 @@
+using Speckle.Objects.Data;
+using Speckle.Sdk.Models;
+using Speckle.Sdk.Models.Proxies;
+
+namespace Speckle.Objects.Other;
+
+/// <summary>
+/// Proxy for levels as DataObject value.
+/// <remarks> These proxy lives in Objects library because it depends on DataObject</remarks>
+/// </summary>
+[SpeckleType("Objects.Other.LevelProxy")]
+public class LevelProxy : Base, IProxyCollection
+{
+  /// <summary>
+  /// The list of application ids of objects that use this level
+  /// </summary>
+  public required List<string> objects { get; set; }
+
+  public required DataObject value { get; set; }
+}
@@ -1,7 +1,6 @@
 using System.Drawing;
 using Speckle.Newtonsoft.Json;
 using Speckle.Sdk.Models;
-using Speckle.Sdk.Models.Proxies;

 namespace Speckle.Objects.Other;

@@ -39,20 +38,3 @@ public class RenderMaterial : Base
    set => diffuse = value.ToArgb();
  }
 }
-
-/// <summary>
-/// Used to store render material to object relationships in root collections
-/// </summary>
-[SpeckleType("Objects.Other.RenderMaterialProxy")]
-public class RenderMaterialProxy : Base, IProxyCollection
-{
-  /// <summary>
-  /// The list of application ids of objects that use this render material
-  /// </summary>
-  public required List<string> objects { get; set; }
-
-  /// <summary>
-  /// The render material used by <see cref="objects"/>
-  /// </summary>
-  public required RenderMaterial value { get; set; }
-}
@@ -0,0 +1,22 @@
+using Speckle.Sdk.Models;
+using Speckle.Sdk.Models.Proxies;
+
+namespace Speckle.Objects.Other;
+
+/// <summary>
+/// Used to store render material to object relationships in root collections
+/// <remarks> These proxy lives in Objects library because it depends on RenderMaterial</remarks>
+/// </summary>
+[SpeckleType("Objects.Other.RenderMaterialProxy")]
+public class RenderMaterialProxy : Base, IProxyCollection
+{
+  /// <summary>
+  /// The list of application ids of objects that use this render material
+  /// </summary>
+  public required List<string> objects { get; set; }
+
+  /// <summary>
+  /// The render material used by <see cref="objects"/>
+  /// </summary>
+  public required RenderMaterial value { get; set; }
+}
@@ -22,23 +22,4 @@ public static class Collections
 public static class EnumerableExtensions
 {
  public static IEnumerable<int> RangeFrom(int from, int to) => Enumerable.Range(from, to - from + 1);
-
-#if NETSTANDARD2_0
-  public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
-    this IEnumerable<TSource> source,
-    Func<TSource, TKey> keySelector
-  )
-  {
-    var keys = new HashSet<TKey>();
-    foreach (var element in source)
-    {
-      if (keys.Contains(keySelector(element)))
-      {
-        continue;
-      }
-      keys.Add(keySelector(element));
-      yield return element;
-    }
-  }
-#endif
 }
@@ -5,7 +5,7 @@ namespace Speckle.Sdk.Dependencies.Serialization;

 public abstract class ChannelLoader<T>(CancellationToken cancellationToken)
 {
-  private const int RECEIVE_CAPACITY = 5000;
+  private const int RECEIVE_CAPACITY = 10000;

  private const int HTTP_GET_CHUNK_SIZE = 500;
  private const int MAX_PARALLELISM_HTTP = 4;
@@ -109,6 +109,9 @@ public abstract class ChannelLoader<T>(CancellationToken cancellationToken)
    Exception = ex;
    _channel.Writer.TryComplete(ex);
    //cancel everything!
-    _cts.Cancel();
+    if (!_cts.IsCancellationRequested)
+    {
+      _cts.Cancel();
+    }
  }
 }
@@ -8,13 +8,13 @@ namespace Speckle.Sdk.Dependencies.Serialization;
 public abstract class ChannelSaver<T>
  where T : IHasByteSize
 {
-  private const int SEND_CAPACITY = 1000;
+  private const int SEND_CAPACITY = 10000;
  private const int HTTP_SEND_CHUNK_SIZE = 25_000_000; //bytes
  private static readonly TimeSpan HTTP_BATCH_TIMEOUT = TimeSpan.FromSeconds(2);
  private const int MAX_PARALLELISM_HTTP = 4;
  private const int HTTP_CAPACITY = 500;
-  private const int MAX_CACHE_WRITE_PARALLELISM = 4;
-  private const int MAX_CACHE_BATCH = 500;
+  private const int MAX_CACHE_WRITE_PARALLELISM = 1;
+  private const int MAX_CACHE_BATCH = 1000;

  private readonly Channel<T> _checkCacheChannel = Channel.CreateBounded<T>(
    new BoundedChannelOptions(SEND_CAPACITY)
@@ -45,9 +45,9 @@ public abstract class ChannelSaver<T>
        cancellationToken
      )
      .Join()
-      .Batch(cacheBatchSize ?? MAX_CACHE_BATCH)
+      .Batch(cacheBatchSize ?? MAX_CACHE_BATCH, singleReader: true)
      .WithTimeout(HTTP_BATCH_TIMEOUT)
-      .ReadAllConcurrently(maxParallelism ?? MAX_CACHE_WRITE_PARALLELISM, SaveToCache, cancellationToken)
+      .ReadAllConcurrently(MAX_CACHE_WRITE_PARALLELISM, SaveToCache, cancellationToken)
      .ContinueWith(
        t =>
        {
@@ -41,13 +41,7 @@ internal sealed class SpeckleHttpClientHandler : DelegatingHandler
      activity?.InjectHeaders((k, v) => request.Headers.TryAddWithoutValidation(k, v));

      var policyResult = await _resiliencePolicy
-        .ExecuteAndCaptureAsync(
-          ctx =>
-          {
-            return base.SendAsync(request, cancellationToken);
-          },
-          context
-        )
+        .ExecuteAndCaptureAsync(ctx => base.SendAsync(request, cancellationToken), context)
        .ConfigureAwait(false);
      context.TryGetValue("retryCount", out var retryCount);
      activity?.SetTag("retryCount", retryCount);
@@ -0,0 +1,271 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text;
+using Speckle.InterfaceGenerator;
+using Speckle.Newtonsoft.Json;
+using Speckle.Sdk.Api.GraphQL.Resources;
+using Speckle.Sdk.Common;
+using Speckle.Sdk.Credentials;
+using Speckle.Sdk.Helpers;
+using Speckle.Sdk.Logging;
+using Speckle.Sdk.Transports;
+using Speckle.Sdk.Transports.ServerUtils;
+
+namespace Speckle.Sdk.Api.Blob;
+
+public partial interface IBlobApi : IDisposable;
+
+/// <summary>
+/// Low level access to the blob API
+/// </summary>
+/// <seealso cref="FileImportResource"/>
+/// <seealso cref="ServerApi"/>
+[GenerateAutoInterface]
+public sealed class BlobApi : IBlobApi
+{
+  public const int DEFAULT_TIMEOUT_SECONDS = SpeckleHttp.DEFAULT_TIMEOUT_SECONDS;
+  private static readonly string[] s_filenameSeparator = ["filename="];
+
+  private readonly ISdkActivityFactory _activityFactory;
+
+  /// <summary>
+  /// HTTP client for communicating with Speckle Server with auth token header
+  /// </summary>
+  private readonly HttpClient _authedClient;
+
+  /// <summary>
+  /// HTTP client for communicating with pre-signed s3 url
+  /// </summary>
+  private readonly HttpClient _unauthedClient;
+
+  public BlobApi(
+    ISpeckleHttp speckleHttp,
+    ISdkActivityFactory activityFactory,
+    Account account,
+    int timeoutSeconds = DEFAULT_TIMEOUT_SECONDS
+  )
+  {
+    _activityFactory = activityFactory;
+    _authedClient = speckleHttp.CreateHttpClient(
+      new HttpClientHandler { AutomaticDecompression = DecompressionMethods.GZip },
+      timeoutSeconds: timeoutSeconds,
+      authorizationToken: account.token
+    );
+    _authedClient.BaseAddress = new(account.serverInfo.url);
+
+    _unauthedClient = speckleHttp.CreateHttpClient(
+      new HttpClientHandler { AutomaticDecompression = DecompressionMethods.GZip },
+      timeoutSeconds: timeoutSeconds
+    );
+  }
+
+  private static string GetBlobDownloadPath(string blobId, HttpResponseMessage response)
+  {
+    response.Content.Headers.TryGetValues("Content-Disposition", out IEnumerable<string>? cdHeaderValues);
+    var cdHeader = (cdHeaderValues?.FirstOrDefault()).NotNull(
+      "Expected response from server to contain attachment header"
+    );
+    string fileName = cdHeader.Split(s_filenameSeparator, StringSplitOptions.None)[1].TrimStart('"').TrimEnd('"');
+    return Path.Combine(
+      SpecklePathProvider.BlobStoragePath(),
+      $"{blobId[..Models.Blob.LocalHashPrefixLength]}-{fileName}"
+    );
+  }
+
+  /// <param name="blobId">The ID of the blob to download</param>
+  /// <param name="progress"></param>
+  /// <param name="cancellationToken"></param>
+  /// <exception cref="HttpRequestException">Request for the blob fails</exception>
+  /// <exception cref="OperationCanceledException"></exception>
+  /// <returns>File Path of the downloaded file</returns>
+  public async Task<string> DownloadBlob(
+    string projectId,
+    string blobId,
+    string? pathOverride = null,
+    IProgress<ProgressArgs>? progress = null,
+    CancellationToken cancellationToken = default
+  )
+  {
+    using var _ = _activityFactory.Start();
+
+    var url = new Uri($"api/stream/{projectId}/blob/{blobId}", UriKind.Relative);
+
+    using var response = await _authedClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+    response.EnsureSuccessStatusCode();
+
+    string fileLocation = pathOverride ?? GetBlobDownloadPath(blobId, response);
+    using var source = new ProgressStream(
+#if NET5_0_OR_GREATER
+      await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false),
+#else
+      await response.Content.ReadAsStreamAsync().ConfigureAwait(false),
+#endif
+      response.Content.Headers.ContentLength,
+      progress,
+      true
+    );
+
+    using var fs = new FileStream(fileLocation, FileMode.OpenOrCreate);
+#if NET5_0_OR_GREATER
+    await source.CopyToAsync(fs, cancellationToken).ConfigureAwait(false);
+#else
+    await source.CopyToAsync(fs).ConfigureAwait(false);
+#endif
+    return fileLocation;
+  }
+
+  /// <summary>Queries the server for diff of the given <paramref name="blobIds"/></summary>
+  /// <param name="blobIds"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns>A list of blob ids that the server doesn't have</returns>
+  /// <exception cref="HttpRequestException">Request for the blob fails</exception>
+  /// <exception cref="OperationCanceledException"></exception>
+  /// <exception cref="ArgumentNullException"></exception>
+  public async Task<List<string>> HasBlobs(
+    string projectId,
+    IReadOnlyCollection<string> blobIds,
+    CancellationToken cancellationToken
+  )
+  {
+    using var _ = _activityFactory.Start();
+
+    cancellationToken.ThrowIfCancellationRequested();
+    var payload = JsonConvert.SerializeObject(blobIds);
+
+    var url = new Uri($"/api/stream/{projectId}/blob/diff", UriKind.Relative);
+
+    using StringContent stringContent = new(payload, Encoding.UTF8, "application/json");
+
+    using var response = await _authedClient.PostAsync(url, stringContent, cancellationToken).ConfigureAwait(false);
+    response.EnsureSuccessStatusCode();
+
+#if NET5_0_OR_GREATER
+    var responseString = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+#else
+    var responseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+#endif
+    var parsed = JsonConvert
+      .DeserializeObject<List<string>>(responseString)
+      .NotNull($"Failed to deserialize successful response {response.Content}");
+
+    return parsed;
+  }
+
+  /// <summary>
+  /// Uploads a single file to the given S3 url.
+  /// This method should be used together with the <see cref="FileImportResource"/> <see cref="FileImportResource.GenerateUploadUrl"/> method,
+  /// which generates a pre-signed S3 url, that can be used to upload the file to.
+  /// </summary>
+  /// <param name="filePath"></param>
+  /// <param name="url"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns>etag header</returns>
+  /// <seealso cref="FileImportResource"/>
+  /// <exception cref="HttpRequestException"></exception>
+  /// <exception cref="ArgumentException">Unexpected response header the server</exception>
+  /// <exception cref="FileNotFoundException"><paramref name="filePath"/> does not point to a file</exception>
+  /// <exception cref="OperationCanceledException"></exception>
+  public async Task<string> UploadFile(
+    string filePath,
+    Uri url,
+    IProgress<ProgressArgs>? progress = null,
+    CancellationToken cancellationToken = default
+  )
+  {
+    using var _ = _activityFactory.Start();
+
+    if (!File.Exists(filePath))
+    {
+      throw new FileNotFoundException("File not found.", filePath);
+    }
+
+    var fileInfo = new FileInfo(filePath);
+
+    using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
+    using var requestMessage = new HttpRequestMessage(HttpMethod.Put, url);
+    requestMessage.Content = progress is null
+      ? new StreamContent(fileStream)
+      : new ProgressContent(new StreamContent(fileStream), progress);
+
+    requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+    requestMessage.Content.Headers.ContentLength = fileInfo.Length;
+
+    using var response = await _unauthedClient.SendAsync(requestMessage, cancellationToken).ConfigureAwait(false);
+    response.EnsureSuccessStatusCode();
+
+    return ParseEtagHeader(response.Headers);
+  }
+
+  private static string ParseEtagHeader(HttpResponseHeaders headers)
+  {
+    if (!headers.TryGetValues("ETag", out var etagValues))
+    {
+      throw new ArgumentException(
+        "Response does not have an ETag attached to it, cannot use this as an upload",
+        nameof(headers)
+      );
+    }
+
+    var etagValuesArray = etagValues.ToArray();
+
+    if (etagValuesArray.Length != 1)
+    {
+      throw new ArgumentException(
+        $"Expected Etag header to have a single value but got {etagValuesArray.Length}",
+        nameof(headers)
+      );
+    }
+
+    return etagValuesArray[0];
+  }
+
+  /// <summary>
+  /// Uploads blobs via the <c>"/api/stream/:streamId/blob"</c> endpoint
+  /// </summary>
+  /// <param name="projectId"></param>
+  /// <param name="blobPaths"></param>
+  /// <param name="progress"></param>
+  /// <param name="cancellationToken"></param>
+  public async Task UploadBlobs(
+    string projectId,
+    IReadOnlyCollection<(string id, string filePath)> blobPaths,
+    IProgress<ProgressArgs>? progress,
+    CancellationToken cancellationToken
+  )
+  {
+    using var _ = _activityFactory.Start();
+
+    cancellationToken.ThrowIfCancellationRequested();
+    if (blobPaths.Count == 0)
+    {
+      return;
+    }
+
+    using var multipartFormDataContent = new MultipartFormDataContent();
+    foreach (var (id, filePath) in blobPaths)
+    {
+      var fileName = Path.GetFileName(filePath);
+
+      var stream = File.OpenRead(filePath);
+      var fsc = new StreamContent(stream);
+      multipartFormDataContent.Add(fsc, $"hash:{id}", fileName);
+    }
+
+    using HttpContent content = progress is null
+      ? multipartFormDataContent
+      : new ProgressContent(multipartFormDataContent, progress);
+
+    var url = new Uri($"/api/stream/{projectId}/blob", UriKind.Relative);
+
+    using var response = await _authedClient.PostAsync(url, content, cancellationToken).ConfigureAwait(false);
+
+    response.EnsureSuccessStatusCode();
+  }
+
+  [AutoInterfaceIgnore]
+  public void Dispose()
+  {
+    _authedClient.Dispose();
+    _unauthedClient.Dispose();
+  }
+}
@@ -0,0 +1,13 @@
+using Speckle.InterfaceGenerator;
+using Speckle.Sdk.Credentials;
+using Speckle.Sdk.Helpers;
+using Speckle.Sdk.Logging;
+
+namespace Speckle.Sdk.Api.Blob;
+
+[GenerateAutoInterface]
+public sealed class BlobApiFactory(ISpeckleHttp speckleHttp, ISdkActivityFactory activityFactory) : IBlobApiFactory
+{
+  public IBlobApi Create(Account account, int timeoutSeconds = BlobApi.DEFAULT_TIMEOUT_SECONDS) =>
+    new BlobApi(speckleHttp, activityFactory, account, timeoutSeconds);
+}
@@ -126,3 +126,14 @@ public sealed class WorkspacePermissionException : SpeckleGraphQLException
  public WorkspacePermissionException(string? message, Exception? innerException)
    : base(message, innerException) { }
 }
+
+public sealed class CannotCreateCommitException : SpeckleGraphQLException
+{
+  public CannotCreateCommitException() { }
+
+  public CannotCreateCommitException(string? message)
+    : base(message) { }
+
+  public CannotCreateCommitException(string? message, Exception? innerException)
+    : base(message, innerException) { }
+}
@@ -4,6 +4,7 @@ using GraphQL.Client.Http;
 using Microsoft.Extensions.Logging;
 using Speckle.InterfaceGenerator;
 using Speckle.Newtonsoft.Json;
+using Speckle.Sdk.Api.Blob;
 using Speckle.Sdk.Api.GraphQL;
 using Speckle.Sdk.Api.GraphQL.Resources;
 using Speckle.Sdk.Credentials;
@@ -33,6 +34,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
  public SubscriptionResource Subscription { get; }
  public WorkspaceResource Workspace { get; }
  public ServerResource Server { get; }
+  public FileImportResource FileImport { get; }

  public Uri ServerUrl => new(Account.serverInfo.url);

@@ -48,12 +50,15 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
    ILogger<Client> logger,
    ISdkActivityFactory activityFactory,
    IGraphQLClientFactory graphqlClientFactory,
-    Account account
+    IBlobApiFactory blobApiFactory,
+    [NotNull] Account? account
  )
  {
    _logger = logger;
    _activityFactory = activityFactory;
+
    Account = account ?? throw new ArgumentException("Provided account is null.");
+    GQLClient = graphqlClientFactory.CreateGraphQLClient(account);

    Project = new(this);
    Model = new(this);
@@ -65,8 +70,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
    Subscription = new(this);
    Workspace = new(this);
    Server = new(this);
-
-    GQLClient = graphqlClientFactory.CreateGraphQLClient(account);
+    FileImport = new(this, blobApiFactory.Create(account));
  }

  [AutoInterfaceIgnore]
@@ -74,6 +78,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
  {
    try
    {
+      FileImport.Dispose();
      Subscription.Dispose();
      GQLClient.Dispose();
    }
@@ -127,10 +132,10 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
      activity?.SetStatus(SdkActivityStatusCode.Ok);
      return ret;
    }
-    catch (Exception ex)
+    catch (Exception)
    {
      activity?.SetStatus(SdkActivityStatusCode.Error);
-      activity?.RecordException(ex);
+      // Don't record exception as it's rethrown.
      throw;
    }
  }
@@ -1,5 +1,6 @@
 using Microsoft.Extensions.Logging;
 using Speckle.InterfaceGenerator;
+using Speckle.Sdk.Api.Blob;
 using Speckle.Sdk.Credentials;
 using Speckle.Sdk.Logging;

@@ -9,9 +10,10 @@ namespace Speckle.Sdk.Api;
 public class ClientFactory(
  ILoggerFactory loggerFactory,
  ISdkActivityFactory activityFactory,
-  IGraphQLClientFactory graphQLClientFactory
+  IGraphQLClientFactory graphQLClientFactory,
+  IBlobApiFactory blobApiFactory
 ) : IClientFactory
 {
  public IClient Create(Account account) =>
-    new Client(loggerFactory.CreateLogger<Client>(), activityFactory, graphQLClientFactory, account);
+    new Client(loggerFactory.CreateLogger<Client>(), activityFactory, graphQLClientFactory, blobApiFactory, account);
 }
@@ -33,6 +33,7 @@ internal static class GraphQLErrorHandler
        "BAD_USER_INPUT" => new SpeckleGraphQLBadInputException(message),
        "INTERNAL_SERVER_ERROR" => new SpeckleGraphQLInternalErrorException(message),
        "WORKSPACES_MODULE_DISABLED_ERROR" => new SpeckleGraphQLWorkspaceNotEnabledException(message),
+        "COMMIT_CREATE_ERROR" => new CannotCreateCommitException(message),
        _ => new SpeckleGraphQLException(message),
      };
      exceptions.Add(ex);
@@ -40,7 +40,8 @@ public static class GraphQLHttpClientExtensions
    response.EnsureGraphQLSuccess();

    string versionString = response.Data.data.data;
-    if (versionString == "dev")
+    //Local server builds will have a non-numerical version string
+    if (versionString == "dev" || versionString == "custom")
    {
      return new Version(999, 999, 999);
    }
@@ -0,0 +1,38 @@
+namespace Speckle.Sdk.Api.GraphQL.Inputs;
+
+public record GenerateFileUploadUrlInput(string projectId, string fileName);
+
+public record StartFileImportInput(string projectId, string modelId, string fileId, string etag);
+
+public record FileImportResult(
+  double durationSeconds,
+  double downloadDurationSeconds,
+  double parseDurationSeconds,
+  string parser,
+  string? versionId
+);
+
+public abstract class FileImportInputBase
+{
+  public required string projectId { get; init; }
+  public required string jobId { get; init; }
+  public required IReadOnlyCollection<string> warnings { get; init; }
+  public required FileImportResult result { get; init; }
+}
+
+#pragma warning disable CA1822 //Mark members as static
+
+public sealed class FileImportSuccessInput() : FileImportInputBase()
+{
+  public const string TYPE_STATUS = "success";
+
+  public string status => TYPE_STATUS;
+}
+
+public sealed class FileImportErrorInput() : FileImportInputBase()
+{
+  public const string TYPE_STATUS = "error";
+
+  public string status => TYPE_STATUS;
+  public required string reason { get; init; }
+}
@@ -0,0 +1,13 @@
+namespace Speckle.Sdk.Api.GraphQL.Models;
+
+public sealed class FileImport
+{
+  public string id { get; init; }
+  public string projectId { get; init; }
+  public string? convertedVersionId { get; init; }
+  public string userId { get; init; }
+  public int convertedStatus { get; init; }
+  public string? convertedMessage { get; init; }
+  public string? modelId { get; init; }
+  public DateTime updatedAt { get; init; }
+}
@@ -0,0 +1,7 @@
+namespace Speckle.Sdk.Api.GraphQL.Models;
+
+public sealed class FileUploadUrl
+{
+  public Uri url { get; init; }
+  public string fileId { get; init; }
+}
@@ -1,16 +1,20 @@
 namespace Speckle.Sdk.Api.GraphQL.Models;

-public sealed class Workspace
+public class LimitedWorkspace
 {
  public string id { get; init; }
  public string name { get; init; }
-  public string role { get; init; }
+  public string? role { get; init; }
  public string slug { get; init; }
-  public string? description { get; init; }
  public string? logo { get; init; }
-  public DateTime? createdAt { get; init; }
-  public DateTime? updatedAt { get; init; }
-  public bool? readOnly { get; init; }
+  public string? description { get; init; }
+}
+
+public class Workspace : LimitedWorkspace
+{
+  public DateTime createdAt { get; init; }
+  public DateTime updatedAt { get; init; }
+  public bool readOnly { get; init; }
  public WorkspacePermissionChecks permissions { get; init; }
  public WorkspaceCreationState? creationState { get; init; }
 }
@@ -313,10 +313,11 @@ public sealed class ActiveUserResource
  }

  /// <param name="cancellationToken"></param>
-  /// <returns></returns>
+  /// <returns>The active (last selected) workspace</returns>
+  /// <remarks>note this returns a <see cref="LimitedWorkspace"/>, because it may be a workspace the user is not a member of</remarks>
  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
  /// <exception cref="SpeckleException">The ActiveUser could not be found (e.g. the client is not authenticated)</exception>
-  public async Task<Workspace?> GetActiveWorkspace(CancellationToken cancellationToken = default)
+  public async Task<LimitedWorkspace?> GetActiveWorkspace(CancellationToken cancellationToken = default)
  {
    //language=graphql
    const string QUERY = """
@@ -328,21 +329,7 @@ public sealed class ActiveUserResource
            role
            slug
            logo
-            createdAt
-            updatedAt
-            readOnly
            description
-            creationState
-            {
-              completed
-            }
-            permissions {
-              canCreateProject {
-                authorized
-                code
-                message
-              }
-            }
          }
        }
      }
@@ -351,7 +338,7 @@ public sealed class ActiveUserResource
    var request = new GraphQLRequest { Query = QUERY };

    var response = await _client
-      .ExecuteGraphQLRequest<NullableResponse<NullableResponse<Workspace?>?>>(request, cancellationToken)
+      .ExecuteGraphQLRequest<NullableResponse<NullableResponse<LimitedWorkspace?>?>>(request, cancellationToken)
      .ConfigureAwait(false);

    if (response.data is null)
@@ -0,0 +1,214 @@
+using System.Diagnostics;
+using GraphQL;
+using Speckle.Sdk.Api.Blob;
+using Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Api.GraphQL.Models.Responses;
+using Speckle.Sdk.Transports;
+
+namespace Speckle.Sdk.Api.GraphQL.Resources;
+
+public sealed class FileImportResource : IDisposable
+{
+  private readonly ISpeckleGraphQLClient _client;
+  private readonly IBlobApi _blobApi;
+
+  internal FileImportResource(ISpeckleGraphQLClient client, IBlobApi blobApi)
+  {
+    _client = client;
+    _blobApi = blobApi;
+  }
+
+  /// <summary>
+  /// This is mostly an internal api, that marks a file import job finished.
+  /// </summary>
+  /// <param name="input">Either <see cref="FileImportSuccessInput"/> or <see cref="FileImportErrorInput"/></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  /// <remarks>
+  /// Only use this if you are writing a file importer, that is responsible for
+  /// processing file import jobs.
+  /// Only works on servers version >=2.25.8
+  /// </remarks>
+  public async Task<bool> FinishFileImportJob(FileImportInputBase input, CancellationToken cancellationToken)
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation FinishFileImport($input: FinishFileImportInput!) {
+          data:fileUploadMutations {
+              data:finishFileImport(input: $input)
+          }
+      }
+      """;
+    var request = new GraphQLRequest { Query = QUERY, Variables = new { input } };
+
+    var response = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<bool>>>(request, cancellationToken)
+      .ConfigureAwait(false);
+
+    return response.data.data;
+  }
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  /// <remarks>Only works on servers version >=2.25.8</remarks>
+  public async Task<FileImport> StartFileImportJob(
+    StartFileImportInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation StartFileImport($input: StartFileImportInput!) {
+          data:fileUploadMutations {
+              data:startFileImport(input: $input) {
+                  id
+                  projectId
+                  convertedVersionId
+                  userId
+                  convertedStatus
+                  convertedMessage
+                  modelId
+                  updatedAt
+              }
+          }
+      }
+      """;
+    var request = new GraphQLRequest { Query = QUERY, Variables = new { input } };
+
+    var response = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<FileImport>>>(request, cancellationToken)
+      .ConfigureAwait(false);
+
+    return response.data.data;
+  }
+
+  /// <summary>
+  /// Get a file upload url from the Speckle server.
+  /// This method asks the server to create a pre-signed S3 url,
+  /// which can be used as a short term authenticated route, to put a file to the server.
+  /// </summary>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  /// <remarks>Only works on servers version >=2.25.8</remarks>
+  public async Task<FileUploadUrl> GenerateUploadUrl(
+    GenerateFileUploadUrlInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation GenerateUploadUrl($input: GenerateFileUploadUrlInput!) {
+          data:fileUploadMutations {
+              data:generateUploadUrl(input: $input) {
+                  fileId
+                  url
+              }
+          }
+      }
+      """;
+    var request = new GraphQLRequest { Query = QUERY, Variables = new { input } };
+
+    var response = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<FileUploadUrl>>>(request, cancellationToken)
+      .ConfigureAwait(false);
+
+    return response.data.data;
+  }
+
+  /// <inheritdoc cref="Blob.BlobApi.UploadFile"/>
+  [DebuggerStepThrough]
+  public Task<string> UploadFile(
+    string filePath,
+    Uri url,
+    IProgress<ProgressArgs>? progress = null,
+    CancellationToken cancellationToken = default
+  ) => _blobApi.UploadFile(filePath, url, progress, cancellationToken);
+
+  /// <inheritdoc cref="Blob.BlobApi.DownloadBlob"/>
+  [DebuggerStepThrough]
+  public Task DownloadFile(
+    string projectId,
+    string fileId,
+    string targetFile,
+    IProgress<ProgressArgs>? progress = null,
+    CancellationToken cancellationToken = default
+  ) => _blobApi.DownloadBlob(projectId, fileId, targetFile, progress, cancellationToken);
+
+  /// <param name="projectId"></param>
+  /// <param name="modelId"></param>
+  /// <param name="limit"></param>
+  /// <param name="cursor"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  /// <remarks>Only works on servers version >=2.25.8</remarks>
+  public async Task<ResourceCollection<FileImport>> GetModelFileImportJobs(
+    string projectId,
+    string modelId,
+    int limit = ServerLimits.DEFAULT_PAGINATION_REQUEST,
+    string? cursor = null,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      query ModelFileImportJobs(
+          $projectId: String!,
+          $modelId: String!,
+          $input: GetModelUploadsInput
+      ) {
+        data:project(id: $projectId) {
+          data:model(id: $modelId) {
+              data:uploads(input: $input) {
+                  totalCount
+                  cursor
+                  items {
+                      id
+                      projectId
+                      convertedVersionId
+                      userId
+                      convertedStatus
+                      convertedMessage
+                      modelId
+                      updatedAt
+                  }
+              }
+          }
+        }
+      }
+      """;
+    var request = new GraphQLRequest
+    {
+      Query = QUERY,
+      Variables = new
+      {
+        projectId,
+        modelId,
+        input = new { limit, cursor },
+      },
+    };
+
+    var response = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ResourceCollection<FileImport>>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return response.data.data.data;
+  }
+
+  public void Dispose()
+  {
+    _blobApi.Dispose();
+  }
+}
@@ -47,6 +47,11 @@ public partial class Operations
      receiveActivity?.SetStatus(SdkActivityStatusCode.Ok);
      return results;
    }
+    catch (OperationCanceledException)
+    {
+      //this is handled by the caller
+      throw;
+    }
    catch (Exception ex)
    {
      receiveActivity?.SetStatus(SdkActivityStatusCode.Error);
@@ -0,0 +1,22 @@
+using Speckle.InterfaceGenerator;
+
+namespace Speckle.Sdk.Caching;
+
+/// <summary>
+/// This mocks away the file system operations for testing purposes.
+/// </summary>
+[GenerateAutoInterface]
+public class FileSystem : IFileSystem
+{
+  public bool DirectoryExists(string path) => Directory.Exists(path);
+
+  public void CreateDirectory(string path) => Directory.CreateDirectory(path);
+
+  public IEnumerable<string> EnumerateFiles(string path) => Directory.EnumerateFiles(path);
+
+  public void DeleteFile(string path) => File.Delete(path);
+
+  public long GetFileSize(string path) => new FileInfo(path).Length;
+
+  public string Combine(params string[] paths) => Path.Combine(paths);
+}
@@ -0,0 +1,93 @@
+using Microsoft.Extensions.Logging;
+using Speckle.InterfaceGenerator;
+using Speckle.Sdk.Logging;
+using Speckle.Sdk.Transports;
+
+namespace Speckle.Sdk.Caching;
+
+/// <summary>
+/// This class manages the cache for model data, providing methods to get stream paths, clear the cache, and calculate cache size.
+/// </summary>
+[GenerateAutoInterface]
+public class ModelCacheManager(ILogger<ModelCacheManager> logger, IFileSystem fileSystem) : IModelCacheManager
+{
+  private const string DATA_FOLDER = "Projects";
+  private static readonly string s_basePath = SpecklePathProvider.UserSpeckleFolderPath;
+
+  private static string CacheFolder => Path.Combine(s_basePath, DATA_FOLDER);
+
+  public string GetStreamPath(string streamId) => GetDbPath(streamId);
+
+  public static string GetDbPath(string streamId)
+  {
+    var db = Path.Combine(CacheFolder, $"{streamId}.db");
+    try
+    {
+      Directory.CreateDirectory(CacheFolder); //ensure dir is there
+      return db;
+    }
+    catch (Exception ex)
+      when (ex is ArgumentException or IOException or UnauthorizedAccessException or NotSupportedException)
+    {
+      throw new TransportException($"Path was invalid or could not be created {db}", ex);
+    }
+  }
+
+  public void ClearCache()
+  {
+    try
+    {
+      if (!fileSystem.DirectoryExists(CacheFolder))
+      {
+        return;
+      }
+
+      foreach (var db in fileSystem.EnumerateFiles(CacheFolder))
+      {
+        try
+        {
+          fileSystem.DeleteFile(db);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or NotSupportedException)
+        {
+          logger.LogWarning(ex, "Failed to delete cache file {filePath}", db);
+        }
+      }
+    }
+    catch (Exception ex)
+      when (ex is ArgumentException or IOException or UnauthorizedAccessException or NotSupportedException)
+    {
+      throw new TransportException($"Cache folder could not be cleared: {CacheFolder}", ex);
+    }
+  }
+
+  public long GetCacheSize()
+  {
+    try
+    {
+      if (!fileSystem.DirectoryExists(CacheFolder))
+      {
+        return 0;
+      }
+
+      long size = 0;
+      foreach (var file in fileSystem.EnumerateFiles(CacheFolder))
+      {
+        try
+        {
+          size += fileSystem.GetFileSize(file);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or NotSupportedException)
+        {
+          logger.LogWarning(ex, "Failed to get size for cache file {a}", file);
+        }
+      }
+      return size;
+    }
+    catch (Exception ex)
+      when (ex is ArgumentException or IOException or UnauthorizedAccessException or NotSupportedException)
+    {
+      throw new TransportException($"Cache folder size could not be determined: {CacheFolder}", ex);
+    }
+  }
+}
@@ -174,7 +174,7 @@ public sealed class AccountManager(
    account.id = null!; //TODO this is gross so remove when id is nullable

    RemoveAccount(id);
-    _accountStorage.SaveObject(account.id.NotNull(), JsonConvert.SerializeObject(account));
+    _accountStorage.UpdateObject(account.id.NotNull(), JsonConvert.SerializeObject(account));
  }

  public IEnumerable<Account> GetAccounts(string serverUrl)
@@ -407,7 +407,7 @@ public sealed class AccountManager(
      {
        account.isDefault = true;
      }
-      _accountStorage.SaveObject(account.id, JsonConvert.SerializeObject(account));
+      _accountStorage.UpdateObject(account.id, JsonConvert.SerializeObject(account));
    }
  }

@@ -15,10 +15,14 @@ internal static class TypeLoader
  private static ConcurrentDictionary<string, Type> s_cachedTypes = new();
  private static ConcurrentDictionary<Type, string> s_fullTypeStrings = new();
  private static ConcurrentDictionary<PropertyInfo, JsonPropertyAttribute?> s_jsonPropertyAttribute = new();
+  private static readonly ConcurrentDictionary<PropertyInfo, bool> s_obsolete = new();
  private static ConcurrentDictionary<Type, IReadOnlyList<PropertyInfo>> s_propInfoCache = new();

  public static IEnumerable<LoadedType> Types => s_availableTypes;

+  public static bool IsObsolete(PropertyInfo property) =>
+    s_obsolete.GetOrAdd(property, p => p.IsDefined(typeof(ObsoleteAttribute), true));
+
  public static JsonPropertyAttribute? GetJsonPropertyAttribute(PropertyInfo property) =>
    s_jsonPropertyAttribute.GetOrAdd(property, p => p.GetCustomAttribute<JsonPropertyAttribute>(true));

@@ -3,7 +3,6 @@ using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using Speckle.Newtonsoft.Json;
 using Speckle.Newtonsoft.Json.Linq;
-using Speckle.Sdk.Common;
 using Speckle.Sdk.Helpers;
 using Speckle.Sdk.Host;
 using Speckle.Sdk.Serialisation;
@@ -92,8 +91,7 @@ public class Base : DynamicBase, ISpeckleObject
    var typedProps = @base.GetInstanceMembers();
    foreach (var prop in typedProps.Where(p => p.CanRead))
    {
-      bool isIgnored =
-        prop.IsDefined(typeof(ObsoleteAttribute), true) || prop.IsDefined(typeof(JsonIgnoreAttribute), true);
+      bool isIgnored = TypeLoader.IsObsolete(prop) || prop.IsDefined(typeof(JsonIgnoreAttribute), true);
      if (isIgnored)
      {
        continue;
@@ -171,8 +169,7 @@ public class Base : DynamicBase, ISpeckleObject

        return count;
      }
-      case IEnumerable e
-      and not string:
+      case IEnumerable e and not string:
      {
        foreach (var arrValue in e)
        {
@@ -193,30 +190,4 @@ public class Base : DynamicBase, ISpeckleObject
        return count;
    }
  }
-
-  /// <summary>
-  /// Creates a shallow copy of the current base object.
-  /// This operation does NOT copy/duplicate the data inside each prop.
-  /// The new object's property values will be pointers to the original object's property value.
-  /// </summary>
-  /// <returns>A shallow copy of the original object.</returns>
-  public Base ShallowCopy()
-  {
-    Type type = GetType();
-    Base myDuplicate = (Base)Activator.CreateInstance(type).NotNull();
-    myDuplicate.id = id;
-    myDuplicate.applicationId = applicationId;
-
-    foreach (var kvp in GetMembers())
-    {
-      var propertyInfo = type.GetProperty(kvp.Key);
-      if (propertyInfo is not null && !propertyInfo.CanWrite)
-      {
-        continue;
-      }
-      myDuplicate[kvp.Key] = kvp.Value;
-    }
-
-    return myDuplicate;
-  }
 }
@@ -7,7 +7,7 @@ namespace Speckle.Sdk.Models;

 /// <summary>
 /// Base class implementing a bunch of nice dynamic object methods, like adding and removing props dynamically. Makes c# feel like json.
-/// <para>Orginally adapted from Rick Strahl 🤘</para>
+/// <para>Originally adapted from Rick Strahl 🤘</para>
 /// <para>https://weblog.west-wind.com/posts/2012/feb/08/creating-a-dynamic-extensible-c-expando-object</para>
 /// </summary>
 public class DynamicBase : DynamicObject, IDynamicMetaObjectProvider
@@ -84,6 +84,44 @@ public class DynamicBase : DynamicObject, IDynamicMetaObjectProvider
    }
  }

+  /// <summary>
+  /// Creates a shallow copy of the current base object.
+  /// This operation does NOT copy/duplicate the data inside each prop.
+  /// The new object's property values will be pointers to the original object's property value.
+  /// </summary>
+  /// <returns>A shallow copy of the original object.</returns>
+  public DynamicBase ShallowCopy()
+  {
+    Type type = GetType();
+    DynamicBase myDuplicate = (DynamicBase)(
+      Activator.CreateInstance(type) ?? throw new SpeckleException($"Failed to create instance of {type.Name}")
+    );
+
+    // Add dynamic members
+    foreach (var kvp in _properties)
+    {
+      myDuplicate._properties[kvp.Key] = kvp.Value;
+    }
+
+    var pinfos = TypeLoader.GetBaseProperties(type).Where(x => !TypeLoader.IsObsolete(x));
+    foreach (var pi in pinfos)
+    {
+      if (pi.CanWrite)
+      {
+        try
+        {
+          pi.SetValue(myDuplicate, pi.GetValue(this));
+        }
+        catch (Exception ex) when (!ex.IsFatal())
+        {
+          throw new SpeckleException($"Failed to set value for {type.Name}.{pi.Name}", ex);
+        }
+      }
+    }
+
+    return myDuplicate;
+  }
+
  /// <inheritdoc />
  /// <summary>
  /// Gets properties via the dot syntax.
@@ -232,7 +270,7 @@ public class DynamicBase : DynamicObject, IDynamicMetaObjectProvider
        .GetBaseProperties(GetType())
        .Where(x =>
        {
-          var hasObsolete = x.IsDefined(typeof(ObsoleteAttribute), true);
+          var hasObsolete = TypeLoader.IsObsolete(x);

          // If obsolete is false and prop has obsolete attr
          // OR
@@ -13,7 +13,26 @@ public sealed class SqLiteJsonCacheManager : ISqLiteJsonCacheManager
 {
  private readonly CacheDbCommandPool _pool;

-  public SqLiteJsonCacheManager(string path, int concurrency)
+  public static ISqLiteJsonCacheManager FromMemory(int concurrency) => new SqLiteJsonCacheManager(concurrency);
+
+  private SqLiteJsonCacheManager(int concurrency)
+  {
+    //disable pooling as we pool ourselves
+    var builder = new SqliteConnectionStringBuilder
+    {
+      Pooling = false,
+      DataSource = ":memory:",
+      Cache = SqliteCacheMode.Shared,
+      Mode = SqliteOpenMode.Memory,
+    };
+    _pool = new CacheDbCommandPool(builder.ToString(), concurrency);
+    Initialize();
+  }
+
+  public static ISqLiteJsonCacheManager FromFilePath(string path, int concurrency) =>
+    new SqLiteJsonCacheManager(path, concurrency);
+
+  private SqLiteJsonCacheManager(string path, int concurrency)
  {
    //disable pooling as we pool ourselves
    var builder = new SqliteConnectionStringBuilder { Pooling = false, DataSource = path };
@@ -47,12 +66,6 @@ public sealed class SqLiteJsonCacheManager : ISqLiteJsonCacheManager
        command.ExecuteNonQuery();
      }

-      // Insert Optimisations
-
-      //Note / Hack: This setting has the potential to corrupt the db.
-      //cmd = new SqliteCommand("PRAGMA synchronous=OFF;", Connection);
-      //cmd.ExecuteNonQuery();
-
      using (SqliteCommand cmd1 = new("PRAGMA count_changes=OFF;", c))
      {
        cmd1.ExecuteNonQuery();
@@ -1,19 +1,20 @@
 using Speckle.InterfaceGenerator;
+using Speckle.Sdk.Caching;
 using Speckle.Sdk.Logging;
-using Speckle.Sdk.Serialisation.Utilities;

 namespace Speckle.Sdk.SQLite;

 [GenerateAutoInterface]
-public class SqLiteJsonCacheManagerFactory : ISqLiteJsonCacheManagerFactory
+public class SqLiteJsonCacheManagerFactory(IModelCacheManager modelCacheManager) : ISqLiteJsonCacheManagerFactory
 {
  public const int INITIAL_CONCURRENCY = 4;

-  private ISqLiteJsonCacheManager Create(string path, int concurrency) => new SqLiteJsonCacheManager(path, concurrency);
+  private ISqLiteJsonCacheManager Create(string path, int concurrency) =>
+    SqLiteJsonCacheManager.FromFilePath(path, concurrency);

  public ISqLiteJsonCacheManager CreateForUser(string scope) =>
    Create(Path.Combine(SpecklePathProvider.UserApplicationDataPath(), "Speckle", $"{scope}.db"), 1);

  public ISqLiteJsonCacheManager CreateFromStream(string streamId) =>
-    Create(SqlitePaths.GetDBPath(streamId), INITIAL_CONCURRENCY);
+    Create(modelCacheManager.GetStreamPath(streamId), INITIAL_CONCURRENCY);
 }
@@ -1,30 +0,0 @@
-using Speckle.Sdk.Logging;
-using Speckle.Sdk.Transports;
-
-namespace Speckle.Sdk.Serialisation.Utilities;
-
-public static class SqlitePaths
-{
-  private const string APPLICATION_NAME = "Speckle";
-  private const string DATA_FOLDER = "Projects";
-  private static readonly string basePath = SpecklePathProvider.UserApplicationDataPath();
-
-  public static string BlobStorageFolder =>
-    SpecklePathProvider.BlobStoragePath(Path.Combine(basePath, APPLICATION_NAME));
-
-  public static string GetDBPath(string streamId)
-  {
-    var dir = Path.Combine(basePath, APPLICATION_NAME, DATA_FOLDER);
-    var db = Path.Combine(dir, $"{streamId}.db");
-    try
-    {
-      Directory.CreateDirectory(dir); //ensure dir is there
-      return db;
-    }
-    catch (Exception ex)
-      when (ex is ArgumentException or IOException or UnauthorizedAccessException or NotSupportedException)
-    {
-      throw new TransportException($"Path was invalid or could not be created {db}", ex);
-    }
-  }
-}
@@ -171,7 +171,7 @@ public sealed class ObjectLoader(
    cancellationToken.ThrowIfCancellationRequested();
    if (Exception is not null)
    {
-      throw new SpeckleException("Error while loading", Exception);
+      throw new SpeckleException($"Error while loading: {Exception.Message}", Exception);
    }
  }
 }
@@ -38,10 +38,11 @@ public sealed class ObjectSaver(
  private long _cached;

  private long _objectsSerialized;
+  private bool _disposed;

  protected override async Task SendToServerInternal(Batch<BaseItem> batch)
  {
-    if (_cancellationTokenSource.IsCancellationRequested)
+    if (IsCancelled())
    {
      return;
    }
@@ -66,7 +67,7 @@ public sealed class ObjectSaver(
    }
    catch (OperationCanceledException)
    {
-      _cancellationTokenSource.Cancel();
+      CancelSaving();
    }
 #pragma warning disable CA1031
    catch (Exception e)
@@ -91,7 +92,7 @@ public sealed class ObjectSaver(

  public override void SaveToCache(List<BaseItem> batch)
  {
-    if (_cancellationTokenSource.IsCancellationRequested)
+    if (IsCancelled())
    {
      return;
    }
@@ -99,14 +100,14 @@ public sealed class ObjectSaver(
    {
      if (!_options.SkipCacheWrite && batch.Count != 0)
      {
-        sqLiteJsonCacheManager.SaveObjects(batch.Select(x => (x.Id.Value, x.Json.Value)));
        Interlocked.Add(ref _cached, batch.Count);
        progress?.Report(new(ProgressEvent.CachedToLocal, _cached, _objectsSerialized));
+        sqLiteJsonCacheManager.SaveObjects(batch.Select(x => (x.Id.Value, x.Json.Value)));
      }
    }
    catch (OperationCanceledException)
    {
-      _cancellationTokenSource.Cancel();
+      CancelSaving();
    }
 #pragma warning disable CA1031
    catch (Exception e)
@@ -123,8 +124,23 @@ public sealed class ObjectSaver(
    }
  }

+  private bool IsCancelled() => _disposed || _cancellationTokenSource.IsCancellationRequested;
+
+  private void CancelSaving()
+  {
+    if (IsCancelled())
+    {
+      return;
+    }
+    _cancellationTokenSource.Cancel();
+  }
+
  private void RecordException(Exception e)
  {
+    if (IsCancelled())
+    {
+      return;
+    }
    //order here matters
    logger.LogError(e, "Error in SDK: {message}", e.Message);
    Exception = e;
@@ -133,6 +149,7 @@ public sealed class ObjectSaver(

  public void Dispose()
  {
+    _disposed = true;
    _cancellationTokenSource.Dispose();
    sqLiteJsonCacheManager.Dispose();
  }
@@ -16,8 +16,8 @@ public record SerializeProcessOptions(
  bool SkipFindTotalObjects = false
 )
 {
-  public int? MaxHttpSendSize { get; set; }
-  public int? MaxCacheSize { get; set; }
+  public int? MaxHttpSendBatchSize { get; set; }
+  public int? MaxCacheBatchSize { get; set; }
  public int? MaxParallelism { get; set; }
 }

@@ -47,6 +47,7 @@ public sealed class SerializeProcess(
    cancellationToken
  );
  private readonly ILogger<SerializeProcess> _logger = loggerFactory.CreateLogger<SerializeProcess>();
+  private bool _disposed;

  //async dispose
  [SuppressMessage("Usage", "CA2213:Disposable fields should be disposed")]
@@ -83,6 +84,7 @@ public sealed class SerializeProcess(
  [AutoInterfaceIgnore]
  public async ValueTask DisposeAsync()
  {
+    _disposed = true;
    await WaitForSchedulerCompletion().ConfigureAwait(false);
    await _highest.DisposeAsync().ConfigureAwait(false);
    await _belowNormal.DisposeAsync().ConfigureAwait(false);
@@ -95,7 +97,7 @@ public sealed class SerializeProcess(
    //order here matters...null with cancellation means a user did it, otherwise it's a real Exception
    if (objectSaver.Exception is not null)
    {
-      throw new SpeckleException("Error while sending", objectSaver.Exception);
+      throw new SpeckleException($"Error while sending: {objectSaver.Exception.Message}", objectSaver.Exception);
    }
    _processSource.Token.ThrowIfCancellationRequested();
  }
@@ -112,8 +114,8 @@ public sealed class SerializeProcess(
    {
      var channelTask = objectSaver.Start(
        options?.MaxParallelism,
-        options?.MaxHttpSendSize,
-        options?.MaxCacheSize,
+        options?.MaxHttpSendBatchSize,
+        options?.MaxCacheBatchSize,
        _processSource.Token
      );
      var findTotalObjectsTask = Task.CompletedTask;
@@ -148,7 +150,7 @@ public sealed class SerializeProcess(

  private void TraverseTotal(Base obj)
  {
-    if (_processSource.Token.IsCancellationRequested)
+    if (IsCancelled())
    {
      return;
    }
@@ -162,7 +164,7 @@ public sealed class SerializeProcess(

  private async Task<Dictionary<Id, NodeInfo>> Traverse(Base obj)
  {
-    if (_processSource.Token.IsCancellationRequested)
+    if (IsCancelled())
    {
      return EMPTY_CLOSURES;
    }
@@ -174,7 +176,7 @@ public sealed class SerializeProcess(
      {
        // tmp is necessary because of the way closures close over loop variables
        var tmp = child;
-        if (_processSource.Token.IsCancellationRequested)
+        if (IsCancelled())
        {
          return EMPTY_CLOSURES;
        }
@@ -191,7 +193,7 @@ public sealed class SerializeProcess(
        tasks.Add(t);
      }

-      if (_processSource.Token.IsCancellationRequested)
+      if (IsCancelled())
      {
        return EMPTY_CLOSURES;
      }
@@ -218,7 +220,7 @@ public sealed class SerializeProcess(
      }
      _taskResultPool.Return(tasks);

-      if (_processSource.Token.IsCancellationRequested)
+      if (IsCancelled())
      {
        return EMPTY_CLOSURES;
      }
@@ -226,22 +228,30 @@ public sealed class SerializeProcess(
      var childClosures = _childClosurePool.Get();
      foreach (var childClosure in taskClosures)
      {
+        if (IsCancelled())
+        {
+          return EMPTY_CLOSURES;
+        }
        foreach (var kvp in childClosure)
        {
          childClosures[kvp.Key] = kvp.Value;
+          if (IsCancelled())
+          {
+            return EMPTY_CLOSURES;
+          }
        }

        _currentClosurePool.Return(childClosure);
      }

-      if (_processSource.Token.IsCancellationRequested)
+      if (IsCancelled())
      {
        return EMPTY_CLOSURES;
      }

      var items = baseSerializer.Serialise(obj, childClosures, _options.SkipCacheRead, _processSource.Token);

-      if (_processSource.Token.IsCancellationRequested)
+      if (IsCancelled())
      {
        return EMPTY_CLOSURES;
      }
@@ -253,13 +263,13 @@ public sealed class SerializeProcess(
        progress?.Report(new(ProgressEvent.FromCacheOrSerialized, _objectCount, Math.Max(_objectCount, _objectsFound)));
        foreach (var item in items)
        {
+          if (IsCancelled())
+          {
+            return EMPTY_CLOSURES;
+          }
+
          if (item.NeedsStorage)
          {
-            if (_processSource.Token.IsCancellationRequested)
-            {
-              return EMPTY_CLOSURES;
-            }
-
            Interlocked.Increment(ref _objectsSerialized);
            await objectSaver.SaveAsync(item).ConfigureAwait(false);
          }
@@ -290,6 +300,8 @@ public sealed class SerializeProcess(
    }
  }

+  public bool IsCancelled() => _disposed || _processSource.IsCancellationRequested;
+
  public void RecordException(Exception e)
  {
    if (e is OperationCanceledException)
@@ -304,6 +316,11 @@ public sealed class SerializeProcess(
    {
      return;
    }
+    if (IsCancelled())
+    {
+      //if we are already cancelled, don't log or save the exceptions
+      return;
+    }
    //order here matters
    _logger.LogError(e, "Error in SDK: {message}", e.Message);
    objectSaver.Exception = e;
@@ -64,18 +64,10 @@ public class SerializeProcessFactory(
 #pragma warning disable CA2000
    var memoryJsonCacheManager = new MemoryJsonCacheManager(jsonCache);
 #pragma warning restore CA2000
-    return new SerializeProcess(
+    return CreateSerializeProcess(
+      memoryJsonCacheManager,
+      new MemoryServerObjectManager(objects),
      progress,
-      new ObjectSaver(
-        progress,
-        memoryJsonCacheManager,
-        new MemoryServerObjectManager(objects),
-        loggerFactory.CreateLogger<ObjectSaver>(),
-        cancellationToken
-      ),
-      baseChildFinder,
-      new BaseSerializer(memoryJsonCacheManager, objectSerializerFactory),
-      loggerFactory,
      cancellationToken,
      options
    );
@@ -2,6 +2,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.Blob;
 using Speckle.Sdk.Credentials;
 using Speckle.Sdk.Dependencies;
 using Speckle.Sdk.Host;
@@ -86,6 +87,7 @@ public static class ServiceRegistration
      typeof(ServerApi),
      typeof(SqLiteJsonCacheManager),
      typeof(ServerObjectManager),
+      typeof(BlobApi),
      typeof(BaseSerializer),
      typeof(SerializeProcess),
      typeof(ObjectSaver),
@@ -3,9 +3,9 @@ using System.Diagnostics;
 using System.Text;
 using System.Timers;
 using Microsoft.Data.Sqlite;
+using Speckle.Sdk.Caching;
 using Speckle.Sdk.Logging;
 using Speckle.Sdk.Models;
-using Speckle.Sdk.Serialisation.Utilities;
 using Timer = System.Timers.Timer;

 namespace Speckle.Sdk.Transports;
@@ -28,7 +28,7 @@ public sealed class SQLiteTransport2 : IDisposable, ICloneable, ITransport, IBlo
  {
    _streamId = streamId;

-    _rootPath = SqlitePaths.GetDBPath(streamId);
+    _rootPath = ModelCacheManager.GetDbPath(streamId);

    _connectionString = $"Data Source={_rootPath};";

@@ -50,7 +50,7 @@ public sealed class SQLiteTransport2 : IDisposable, ICloneable, ITransport, IBlo
  private SqliteConnection Connection { get; set; }
  private readonly SemaphoreSlim _connectionLock = new(1, 1);

-  public string BlobStorageFolder => SqlitePaths.BlobStorageFolder;
+  public string BlobStorageFolder => SpecklePathProvider.UserSpeckleFolderPath;

  public void SaveBlob(Blob obj)
  {
@@ -20,7 +20,7 @@ internal sealed class ProgressStream(
  {
    int n = _stream.Read(buffer, offset, count);
    _position += n;
-    progress?.Report(new(ProgressEvent.DownloadBytes, _position, streamLength));
+    progress?.Report(new(ProgressEvent.DownloadBytes, n, streamLength));
    return n;
  }

@@ -28,7 +28,7 @@ internal sealed class ProgressStream(
  {
    _stream.Write(buffer, offset, count);
    _position += count;
-    progress?.Report(new(ProgressEvent.UploadBytes, _position, streamLength));
+    progress?.Report(new(ProgressEvent.UploadBytes, count, streamLength));
  }

  public override bool CanRead => true;
@@ -123,7 +123,7 @@ public class DetachedTests
      objects,
      null,
      default,
-      new SerializeProcessOptions(false, false, true, true) { MaxParallelism = 1, MaxHttpSendSize = 1 }
+      new SerializeProcessOptions(false, false, true, true) { MaxParallelism = 1, MaxHttpSendBatchSize = 1 }
    );
    var results = await serializeProcess.Serialize(@base);

@@ -150,7 +150,7 @@ public class DetachedTests
      objects,
      null,
      default,
-      new SerializeProcessOptions(false, false, true, true) { MaxParallelism = 1, MaxHttpSendSize = 1 }
+      new SerializeProcessOptions(false, false, true, true) { MaxParallelism = 1, MaxHttpSendBatchSize = 1 }
    );
    var results = await serializeProcess.Serialize(@base);

@@ -172,7 +172,7 @@ public class DetachedTests
      objects,
      null,
      default,
-      new SerializeProcessOptions(false, false, true, true) { MaxParallelism = 1, MaxHttpSendSize = 1 }
+      new SerializeProcessOptions(false, false, true, true) { MaxParallelism = 1, MaxHttpSendBatchSize = 1 }
    );
    var results = await serializeProcess.Serialize(@base);

@@ -6,6 +6,6 @@
    "Message": "The method or operation is not implemented.",
    "Type": "NotImplementedException"
  },
-  "Message": "Error while sending",
+  "Message": "Error while sending: The method or operation is not implemented.",
  "Type": "SpeckleException"
 }
@@ -6,6 +6,6 @@
    "Message": "Count exceeded",
    "Type": "Exception"
  },
-  "Message": "Error while sending",
+  "Message": "Error while sending: Count exceeded",
  "Type": "SpeckleException"
 }
@@ -6,6 +6,6 @@
    "Message": "The method or operation is not implemented.",
    "Type": "NotImplementedException"
  },
-  "Message": "Error while loading",
+  "Message": "Error while loading: The method or operation is not implemented.",
  "Type": "SpeckleException"
 }
@@ -6,6 +6,6 @@
    "Message": "The method or operation is not implemented.",
    "Type": "NotImplementedException"
  },
-  "Message": "Error while sending",
+  "Message": "Error while sending: The method or operation is not implemented.",
  "Type": "SpeckleException"
 }
@@ -95,8 +95,8 @@ public class ExceptionTests
      default,
      new SerializeProcessOptions(false, false, false, true)
      {
-        MaxHttpSendSize = 1,
-        MaxCacheSize = 1,
+        MaxHttpSendBatchSize = 1,
+        MaxCacheBatchSize = 1,
        MaxParallelism = 1,
      }
    );
@@ -14,6 +14,7 @@ using Speckle.Sdk.Serialisation.V2;
 using Speckle.Sdk.Serialisation.V2.Receive;
 using Speckle.Sdk.Serialisation.V2.Send;
 using Speckle.Sdk.Serialization.Tests.Framework;
+using Speckle.Sdk.SQLite;
 using Speckle.Sdk.Testing.Framework;

 namespace Speckle.Sdk.Serialization.Tests;
@@ -50,45 +51,45 @@ public class SerializationTests
    public void Dispose() { }
  }

-  [Theory]
-  [InlineData("RevitObject.json.gz")]
-  public async Task Basic_Namespace_Validation(string fileName)
-  {
-    var closures = TestFileManager.GetFileAsClosures(fileName);
-    var deserializer = new SpeckleObjectDeserializer
+  /*  [Theory]
+    [InlineData("RevitObject.json.gz")]
+    public async Task Basic_Namespace_Validation(string fileName)
    {
-      ReadTransport = new TestTransport(closures),
-      CancellationToken = default,
-    };
-
-    foreach (var (id, objJson) in closures)
-    {
-      var jObject = JObject.Parse(objJson);
-      var oldSpeckleType = jObject["speckle_type"].NotNull().Value<string>().NotNull();
-      var starts = oldSpeckleType.StartsWith("Speckle.Core.") || oldSpeckleType.StartsWith("Objects.");
-      starts.Should().BeTrue($"{oldSpeckleType} isn't expected");
-
-      var baseType = await deserializer.DeserializeAsync(objJson);
-      baseType.id.Should().Be(id);
-
-      var oldType = TypeLoader.GetAtomicType(oldSpeckleType);
-      if (oldType == typeof(Base))
+      var closures = TestFileManager.GetFileAsClosures(fileName);
+      var deserializer = new SpeckleObjectDeserializer
      {
-        oldSpeckleType.Should().NotContain("Base");
-      }
-      else
+        ReadTransport = new TestTransport(closures),
+        CancellationToken = default,
+      };
+  
+      foreach (var (id, objJson) in closures)
      {
-        starts = baseType.speckle_type.StartsWith("Speckle.Core.") || baseType.speckle_type.StartsWith("Objects.");
-        starts.Should().BeTrue($"{baseType.speckle_type} isn't expected");
-
-        var type = TypeLoader.GetAtomicType(baseType.speckle_type);
-        type.Should().NotBeNull();
-        var name = TypeLoader.GetTypeString(type) ?? throw new ArgumentNullException($"Could not find: {type}");
-        starts = name.StartsWith("Speckle.Core") || name.StartsWith("Objects");
-        starts.Should().BeTrue($"{name} isn't expected");
+        var jObject = JObject.Parse(objJson);
+        var oldSpeckleType = jObject["speckle_type"].NotNull().Value<string>().NotNull();
+        var starts = oldSpeckleType.StartsWith("Speckle.Core.") || oldSpeckleType.StartsWith("Objects.");
+        starts.Should().BeTrue($"{oldSpeckleType} isn't expected");
+  
+        var baseType = await deserializer.DeserializeAsync(objJson);
+        baseType.id.Should().Be(id);
+  
+        var oldType = TypeLoader.GetAtomicType(oldSpeckleType);
+        if (oldType == typeof(Base))
+        {
+          oldSpeckleType.Should().NotContain("Base");
+        }
+        else
+        {
+          starts = baseType.speckle_type.StartsWith("Speckle.Core.") || baseType.speckle_type.StartsWith("Objects.");
+          starts.Should().BeTrue($"{baseType.speckle_type} isn't expected");
+  
+          var type = TypeLoader.GetAtomicType(baseType.speckle_type);
+          type.Should().NotBeNull();
+          var name = TypeLoader.GetTypeString(type) ?? throw new ArgumentNullException($"Could not find: {type}");
+          starts = name.StartsWith("Speckle.Core") || name.StartsWith("Objects");
+          starts.Should().BeTrue($"{name} isn't expected");
+        }
      }
-    }
-  }
+    }*/

  [Theory]
  [InlineData("RevitObject.json.gz")]
@@ -184,9 +185,16 @@ public class SerializationTests
  }

  [Theory]
-  [InlineData("RevitObject.json.gz", "3416d3fe01c9196115514c4a2f41617b", 7818, 4674)]
-  public async Task Roundtrip_Test_New(string fileName, string rootId, int oldCount, int newCount)
+  [InlineData(1)]
+  [InlineData(2)]
+  [InlineData(3)]
+  [InlineData(4)]
+  public async Task Roundtrip_Test_New(int concurrency)
  {
+    string fileName = "RevitObject.json.gz";
+    string rootId = "3416d3fe01c9196115514c4a2f41617b";
+    int oldCount = 7818;
+    int newCount = 4674;
    var closures = TestFileManager.GetFileAsClosures(fileName);
    closures.Count.Should().Be(oldCount);

@@ -218,11 +226,11 @@ public class SerializationTests

    await using (
      var serializeProcess = _factory.CreateSerializeProcess(
-        new ConcurrentDictionary<Id, Json>(),
-        newIdToJson,
+        SqLiteJsonCacheManager.FromMemory(1),
+        new MemoryServerObjectManager(newIdToJson),
        null,
        default,
-        new SerializeProcessOptions(true, true, false, true)
+        new SerializeProcessOptions(false, false, false, true) { MaxCacheBatchSize = 1, MaxParallelism = concurrency }
      )
    )
    {
@@ -0,0 +1,6 @@
+{
+  "Data": {},
+  "Message": "Response status code does not indicate success: 404 (Not Found).",
+  "StatusCode": "NotFound",
+  "Type": "HttpRequestException"
+}
@@ -0,0 +1,6 @@
+{
+  "Data": {},
+  "Message": "Response status code does not indicate success: 404 (Not Found).",
+  "StatusCode": "NotFound",
+  "Type": "HttpRequestException"
+}
@@ -0,0 +1,6 @@
+{
+  "Data": {},
+  "Message": "Response status code does not indicate success: 404 (Not Found).",
+  "StatusCode": "NotFound",
+  "Type": "HttpRequestException"
+}
@@ -0,0 +1,6 @@
+{
+  "Data": {},
+  "Message": "Response status code does not indicate success: 404 (Not Found).",
+  "StatusCode": "NotFound",
+  "Type": "HttpRequestException"
+}
@@ -0,0 +1,106 @@
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.Blob;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Sdk.Tests.Integration.Api.GraphQL.Resources;
+
+public class BlobApiExceptionalTests : IAsyncLifetime
+{
+  private IBlobApi _sut;
+  private IClient _client;
+  private Project _project;
+
+  public async Task InitializeAsync()
+  {
+    var serviceProvider = TestServiceSetup.GetServiceProvider();
+    var account = await Fixtures.SeedUser().ConfigureAwait(false);
+    _client = serviceProvider.GetRequiredService<IClientFactory>().Create(account);
+    var factory = serviceProvider.GetRequiredService<IBlobApiFactory>();
+    _project = await _client.Project.Create(new("test", null, null));
+    _sut = factory.Create(account);
+  }
+
+  [Fact]
+  public async Task DownloadBlob_Throws_NonExistentId()
+  {
+    var ex = await Assert.ThrowsAsync<HttpRequestException>(async () =>
+      await _sut.DownloadBlob(_project.id, "non-existent-id", cancellationToken: CancellationToken.None)
+    );
+    await Verify(ex);
+  }
+
+  [Fact]
+  public async Task DownloadBlob_Throws_NonExistentProject()
+  {
+    var ex = await Assert.ThrowsAsync<HttpRequestException>(async () =>
+      await _sut.DownloadBlob("non-existent-project", "non-existent-id", cancellationToken: CancellationToken.None)
+    );
+    await Verify(ex);
+  }
+
+  [Fact]
+  public async Task DownloadBlob_Throws_Cancellation()
+  {
+    using var cancellationTokenSource = new CancellationTokenSource();
+    cancellationTokenSource.Cancel();
+
+    await Assert.ThrowsAnyAsync<OperationCanceledException>(async () =>
+      await _sut.DownloadBlob(_project.id, "non-existent-id", cancellationToken: cancellationTokenSource.Token)
+    );
+  }
+
+  [Fact]
+  public async Task UploadBlobs_Throws_NonExistentProject()
+  {
+    const string PAYLOAD = "Hello World!";
+    string filePath = Path.GetTempFileName();
+    await using (var writer = File.CreateText(filePath))
+    {
+      await writer.WriteLineAsync(PAYLOAD);
+    }
+    string id = HashUtility.HashFile(filePath);
+    var ex = await Assert.ThrowsAsync<HttpRequestException>(async () =>
+      await _sut.UploadBlobs("non-existent-project", [(id, filePath)], null, CancellationToken.None)
+    );
+    await Verify(ex);
+  }
+
+  [Fact]
+  public async Task UploadBlobs_Throws_Cancellation()
+  {
+    using var cancellationTokenSource = new CancellationTokenSource();
+    cancellationTokenSource.Cancel();
+
+    await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+      await _sut.UploadBlobs(_project.id, [("id", "path")], null, cancellationTokenSource.Token)
+    );
+  }
+
+  [Fact]
+  public async Task HasBlobs_Throws_Cancellation()
+  {
+    using var cancellationTokenSource = new CancellationTokenSource();
+    cancellationTokenSource.Cancel();
+
+    await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+      await _sut.HasBlobs(_project.id, ["non-existent-id"], cancellationTokenSource.Token)
+    );
+  }
+
+  [Fact]
+  public async Task HasBlobs_Throws_NonExistentProject()
+  {
+    var ex = await Assert.ThrowsAsync<HttpRequestException>(async () =>
+      await _sut.HasBlobs("non-existent-project", ["non-existent-id"], CancellationToken.None)
+    );
+    await Verify(ex);
+  }
+
+  public Task DisposeAsync()
+  {
+    _client.Dispose();
+    return Task.CompletedTask;
+  }
+}
@@ -0,0 +1,62 @@
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.Blob;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Logging;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Sdk.Tests.Integration.Api.Blob;
+
+public class BlobApiTests : IAsyncLifetime
+{
+  private IBlobApi _blobApi;
+  private IClient _client;
+  private Project _project;
+
+  public async Task InitializeAsync()
+  {
+    var serviceProvider = TestServiceSetup.GetServiceProvider();
+    var account = await Fixtures.SeedUser().ConfigureAwait(false);
+    _client = serviceProvider.GetRequiredService<IClientFactory>().Create(account);
+    var factory = serviceProvider.GetRequiredService<IBlobApiFactory>();
+    _project = await _client.Project.Create(new("test", null, null));
+    _blobApi = factory.Create(account);
+  }
+
+  [Fact(Skip = "Blob creation returns 201, but fetching the blob returns 404. Seems like a server regression")]
+  public async Task BlobEndToEndTest()
+  {
+    //assemble
+    const string PAYLOAD = "Hello World!";
+    string filePath = Path.GetTempFileName();
+    await using (var writer = File.CreateText(filePath))
+    {
+      await writer.WriteLineAsync(PAYLOAD);
+    }
+    string id = HashUtility.HashFile(filePath);
+
+    //act
+    var preDiff = await _blobApi.HasBlobs(_project.id, [id], CancellationToken.None);
+    await _blobApi.UploadBlobs(_project.id, [(id, filePath)], null, CancellationToken.None);
+    var postDiff = await _blobApi.HasBlobs(_project.id, [id], CancellationToken.None);
+    var res = await _blobApi.DownloadBlob(_project.id, id);
+
+    //assert
+    preDiff.Should().BeEquivalentTo([id]);
+    postDiff.Should().BeEquivalentTo([]);
+    var file = new FileInfo(res);
+    file.Name.Should().StartWith(id[..Models.Blob.LocalHashPrefixLength]);
+    file.Directory?.FullName.Should().Be(SpecklePathProvider.BlobStoragePath());
+
+    string[] lines = await File.ReadAllLinesAsync(res);
+    lines[0].Should().Be(PAYLOAD);
+    lines.Length.Should().Be(1);
+  }
+
+  public Task DisposeAsync()
+  {
+    _client.Dispose();
+    return Task.CompletedTask;
+  }
+}
@@ -10,6 +10,8 @@ namespace Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;

 public class CommentResourceTests : IAsyncLifetime
 {
+  public const string SERVER_SKIP_MESSAGE =
+    "comment creation started failing, server responds with 'Attempting to attach invalid blobs to comment', I cba to troubleshoot right now";
  private IClient _testUser;
  private CommentResource Sut;
  private Project _project;
@@ -35,7 +37,7 @@ public class CommentResourceTests : IAsyncLifetime
    return Task.CompletedTask;
  }

-  [Fact]
+  [Fact(Skip = SERVER_SKIP_MESSAGE)]
  public async Task Get()
  {
    var comment = await Sut.Get(_comment.id, _project.id);
@@ -45,7 +47,7 @@ public class CommentResourceTests : IAsyncLifetime
    comment.authorId.Should().Be(_testUser.Account.userInfo.id);
  }

-  [Fact]
+  [Fact(Skip = SERVER_SKIP_MESSAGE)]
  public async Task GetProjectComments()
  {
    var comments = await Sut.GetProjectComments(_project.id);
@@ -63,7 +65,7 @@ public class CommentResourceTests : IAsyncLifetime
    comment.createdAt.Should().Be(_comment.createdAt);
  }

-  [Fact]
+  [Fact(Skip = SERVER_SKIP_MESSAGE)]
  public async Task MarkViewed()
  {
    await Sut.MarkViewed(new(_comment.id, _project.id));
@@ -72,7 +74,7 @@ public class CommentResourceTests : IAsyncLifetime
    res.viewedAt.Should().NotBeNull();
  }

-  [Fact]
+  [Fact(Skip = SERVER_SKIP_MESSAGE)]
  public async Task Archive()
  {
    await Sut.Archive(new(_comment.id, _project.id, true));
@@ -86,7 +88,7 @@ public class CommentResourceTests : IAsyncLifetime
    unarchived.archived.Should().BeFalse();
  }

-  [Fact]
+  [Fact(Skip = SERVER_SKIP_MESSAGE)]
  public async Task Edit()
  {
    var blobs = await Fixtures.SendBlobData(_testUser.Account, _project.id);
@@ -102,7 +104,7 @@ public class CommentResourceTests : IAsyncLifetime
    editedComment.updatedAt.Should().BeOnOrAfter(_comment.updatedAt);
  }

-  [Fact]
+  [Fact(Skip = SERVER_SKIP_MESSAGE)]
  public async Task Reply()
  {
    var blobs = await Fixtures.SendBlobData(_testUser.Account, _project.id);
@@ -0,0 +1,124 @@
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Api.GraphQL.Resources;
+
+namespace Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;
+
+public class FileUploadResourceTests : IAsyncLifetime
+{
+  private FileImportResource Sut => _client.FileImport;
+  private IClient _client;
+  private Project _project;
+  private FileInfo _payload;
+  private const string PAYLOAD_CONTENTS = "Hello World!";
+
+  public async Task InitializeAsync()
+  {
+    var serviceProvider = TestServiceSetup.GetServiceProvider();
+    var account = await Fixtures.SeedUser().ConfigureAwait(false);
+    _client = serviceProvider.GetRequiredService<IClientFactory>().Create(account);
+    _project = await _client.Project.Create(new("test", null, null));
+
+    string filePath = $"{Path.GetTempPath()}/{Guid.NewGuid()}.ifc";
+    await using (var writer = File.CreateText(filePath))
+    {
+      await writer.WriteLineAsync(PAYLOAD_CONTENTS);
+    }
+
+    _payload = new FileInfo(filePath);
+  }
+
+  public Task DisposeAsync()
+  {
+    _client.Dispose();
+    if (File.Exists(_payload.FullName))
+    {
+      File.Delete(_payload.FullName);
+    }
+    return Task.CompletedTask;
+  }
+
+  [Fact]
+  public async Task GenerateUploadUrl_CreatesUrl()
+  {
+    var input = new GenerateFileUploadUrlInput(_project.id, "foo.txt");
+
+    var res = await Sut.GenerateUploadUrl(input);
+    res.fileId.Should().HaveLength(10);
+
+    //Just check the url path is expected. The query string will contain signatures and dates...
+    var expectedUrlPath = new Uri(
+      _client.ServerUrl,
+      $"http://127.0.0.1:9000/speckle-server/assets/{_project.id}/{res.fileId}"
+    );
+    new Uri(res.url.GetLeftPart(UriPartial.Path)).Should().Be(expectedUrlPath);
+  }
+
+  [Fact]
+  public async Task UploadThenDownloadFile()
+  {
+    //act
+    var input = new GenerateFileUploadUrlInput(_project.id, _payload.Name);
+    var res = await Sut.GenerateUploadUrl(input);
+    _ = await Sut.UploadFile(_payload.FullName, res.url);
+
+    string temp = Path.GetTempFileName();
+    await Sut.DownloadFile(_project.id, res.fileId, temp);
+
+    //assert
+    File.ReadAllLines(temp).Should().BeEquivalentTo([PAYLOAD_CONTENTS]);
+  }
+
+  [Theory]
+  [InlineData(true)]
+  [InlineData(false)]
+  public async Task StartAndFinishJobFail(bool testSuccessCase)
+  {
+    //assemble
+    Model model = await _client.Model.Create(new("test model", null, _project.id));
+    var uploadUrl = await Sut.GenerateUploadUrl(new GenerateFileUploadUrlInput(_project.id, _payload.Name));
+    string etag = await Sut.UploadFile(_payload.FullName, uploadUrl.url);
+    FileImportResult fakeResult = new(100, 100, 100, "integrationTests", "some value");
+
+    //act
+    FileImport job = await Sut.StartFileImportJob(new(_project.id, model.id, uploadUrl.fileId, etag));
+    var prePendingJobs = await Sut.GetModelFileImportJobs(_project.id, model.id);
+
+    FileImportInputBase input;
+    if (testSuccessCase)
+    {
+      input = new FileImportSuccessInput()
+      {
+        projectId = _project.id,
+        jobId = job.id,
+        result = fakeResult,
+        warnings = [],
+      };
+    }
+    else
+    {
+      input = new FileImportErrorInput()
+      {
+        projectId = _project.id,
+        jobId = job.id,
+        reason = "We're testing failure!",
+        result = fakeResult,
+        warnings = [],
+      };
+    }
+
+    bool res = await Sut.FinishFileImportJob(input, CancellationToken.None);
+
+    var postPendingJobs = await Sut.GetModelFileImportJobs(_project.id, model.id);
+
+    //assert
+    prePendingJobs.items.Should().HaveCount(1);
+    prePendingJobs.items.Where(x => x.convertedStatus == 0).Should().HaveCount(1);
+    res.Should().BeTrue();
+    postPendingJobs.items.Should().HaveCount(1);
+    postPendingJobs.items.Where(x => x.convertedStatus == 0).Should().HaveCount(0);
+  }
+}
@@ -114,7 +114,7 @@ public class SubscriptionResourceTests : IAsyncLifetime
    subscriptionMessage.version.Should().NotBeNull();
  }

-  [Fact]
+  [Fact(Skip = CommentResourceTests.SERVER_SKIP_MESSAGE)]
  public async Task ProjectCommentsUpdated_SubscriptionIsCalled()
  {
    string resourceIdString = $"{_testProject.id},{_testModel.id},{_testVersion}";
@@ -11,6 +11,7 @@ using Speckle.Sdk.Common;
 using Speckle.Sdk.Credentials;
 using Speckle.Sdk.Host;
 using Speckle.Sdk.Models;
+using Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;
 using Speckle.Sdk.Transports;
 using Version = Speckle.Sdk.Api.GraphQL.Models.Version;

@@ -142,6 +143,7 @@ public static class Fixtures
    return new Blob(filePath);
  }

+  [Obsolete(CommentResourceTests.SERVER_SKIP_MESSAGE)]
  internal static async Task<Comment> CreateComment(IClient client, string projectId, string modelId, string versionId)
  {
    var blobs = await SendBlobData(client.Account, projectId);
@@ -5,6 +5,7 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using RichardSzalay.MockHttp;
 using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.Blob;
 using Speckle.Sdk.Api.GraphQL.Models;
 using Speckle.Sdk.Api.GraphQL.Serializer;
 using Speckle.Sdk.Credentials;
@@ -45,6 +46,7 @@ public class ClientTests : MoqTest
      Create<ILogger<Client>>(MockBehavior.Loose).Object,
      Create<ISdkActivityFactory>(MockBehavior.Loose).Object,
      graphqlClientFactory.Object,
+      Create<IBlobApiFactory>(MockBehavior.Loose).Object,
      account
    );

@@ -23,6 +23,7 @@ public class GraphQLErrorHandlerTests
    ];
    yield return [typeof(SpeckleGraphQLException), new Map { { "foo", "bar" } }];
    yield return [typeof(SpeckleGraphQLException), new Map { { "code", "CUSTOM_THING" } }];
+    yield return [typeof(CannotCreateCommitException), new Map { { "code", "COMMIT_CREATE_ERROR" } }];
  }

  [Theory]
@@ -0,0 +1,420 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using Speckle.Newtonsoft.Json;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Credentials;
+using Speckle.Sdk.Helpers;
+using Speckle.Sdk.SQLite;
+using Speckle.Sdk.Testing;
+
+namespace Speckle.Sdk.Tests.Unit.Credentials;
+
+public class AccountManagerTests : MoqTest
+{
+  private class TestAccountFactory : IAccountFactory
+  {
+    public Task<Account> CreateAccount(
+      Uri serverUrl,
+      string speckleToken,
+      string? refreshToken = default,
+      CancellationToken cancellationToken = default
+    ) => throw new NotImplementedException();
+
+    public Task<ActiveUserServerInfoResponse> GetUserServerInfo(
+      Uri serverUrl,
+      string? authToken,
+      CancellationToken ct
+    ) => throw new NotImplementedException();
+  }
+
+  private readonly Mock<ISpeckleApplication> _mockApplication;
+  private readonly Mock<ILogger<AccountManager>> _mockLogger;
+  private readonly Mock<IGraphQLClientFactory> _mockGraphQLClientFactory;
+  private readonly Mock<ISpeckleHttp> _mockSpeckleHttp;
+  private readonly IAccountFactory _mockAccountFactory;
+  private readonly Mock<ISqLiteJsonCacheManagerFactory> _mockSqLiteJsonCacheManagerFactory;
+  private readonly Mock<ISqLiteJsonCacheManager> _mockAccountStorage;
+  private readonly Mock<ISqLiteJsonCacheManager> _mockAccountAddLockStorage;
+
+  private readonly AccountManager _accountManager;
+
+  public AccountManagerTests()
+  {
+    _mockApplication = Create<ISpeckleApplication>();
+    _mockLogger = Create<ILogger<AccountManager>>(MockBehavior.Loose);
+    _mockGraphQLClientFactory = Create<IGraphQLClientFactory>();
+    _mockSpeckleHttp = Create<ISpeckleHttp>();
+    _mockAccountFactory = new TestAccountFactory();
+    _mockSqLiteJsonCacheManagerFactory = Create<ISqLiteJsonCacheManagerFactory>();
+
+    _mockAccountStorage = Create<ISqLiteJsonCacheManager>();
+    _mockAccountAddLockStorage = Create<ISqLiteJsonCacheManager>();
+
+    _mockSqLiteJsonCacheManagerFactory.Setup(f => f.CreateForUser("Accounts")).Returns(_mockAccountStorage.Object);
+    _mockSqLiteJsonCacheManagerFactory
+      .Setup(f => f.CreateForUser("AccountAddFlow"))
+      .Returns(_mockAccountAddLockStorage.Object);
+
+    _accountManager = new AccountManager(
+      _mockApplication.Object,
+      _mockLogger.Object,
+      _mockGraphQLClientFactory.Object,
+      _mockSpeckleHttp.Object,
+      _mockAccountFactory,
+      _mockSqLiteJsonCacheManagerFactory.Object
+    );
+  }
+
+  [Fact]
+  public void GetDefaultServerUrl_ReturnsDefaultUrl_WhenNoCustomUrlProvided()
+  {
+    // Act
+    var result = _accountManager.GetDefaultServerUrl();
+
+    // Assert
+    Assert.Equal(new Uri(AccountManager.DEFAULT_SERVER_URL), result);
+  }
+
+  [Fact]
+  public void GetAccount_ReturnsAccount_WhenExists()
+  {
+    // Arrange
+    var accountId = "test-account-id";
+    var account = CreateTestAccount(accountId);
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(new[] { (accountId, JsonConvert.SerializeObject(account)) });
+
+    // Act
+    var result = _accountManager.GetAccount(accountId);
+
+    // Assert
+    Assert.Equal(accountId, result.id);
+    Assert.Equal(account.userInfo.name, result.userInfo.name);
+  }
+
+  [Fact]
+  public void GetAccount_ThrowsException_WhenNotExists()
+  {
+    // Arrange
+    var accountId = "non-existent-id";
+
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns([]);
+
+    // Act & Assert
+    var exception = Assert.Throws<SpeckleAccountManagerException>(() => _accountManager.GetAccount(accountId));
+    Assert.Equal($"Account {accountId} not found", exception.Message);
+  }
+
+  [Fact]
+  public void GetAccounts_StringParameter_CallsUriOverload()
+  {
+    // Arrange
+    var serverUrl = "https://test.speckle.systems";
+    var account = CreateTestAccount("test-account-id");
+    account.serverInfo.url = serverUrl;
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(new[] { (account.id, JsonConvert.SerializeObject(account)) });
+
+    // Act
+    var result = _accountManager.GetAccounts(serverUrl).ToList();
+
+    // Assert
+    Assert.Single(result);
+    Assert.Equal(serverUrl, result[0].serverInfo.url);
+  }
+
+  [Fact]
+  public void GetAccounts_UriParameter_ReturnsMatchingAccounts()
+  {
+    // Arrange
+    var serverUri = new Uri("https://test.speckle.systems");
+    var account = CreateTestAccount("test-account-id");
+    account.serverInfo.url = serverUri.ToString();
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(new[] { (account.id, JsonConvert.SerializeObject(account)) });
+
+    // Act
+    var result = _accountManager.GetAccounts(serverUri).ToList();
+
+    // Assert
+    Assert.Single(result);
+    Assert.Equal(serverUri.ToString(), result[0].serverInfo.url);
+  }
+
+  [Fact]
+  public void GetDefaultAccount_ReturnsMarkedDefaultAccount_WhenExists()
+  {
+    // Arrange
+    var defaultAccount = CreateTestAccount("default-account");
+    defaultAccount.isDefault = true;
+
+    var regularAccount = CreateTestAccount("regular-account");
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(
+        new[]
+        {
+          (defaultAccount.id, JsonConvert.SerializeObject(defaultAccount)),
+          (regularAccount.id, JsonConvert.SerializeObject(regularAccount)),
+        }
+      );
+
+    // Act
+    var result = _accountManager.GetDefaultAccount();
+
+    // Assert
+    Assert.NotNull(result);
+    Assert.Equal("default-account", result!.id);
+    Assert.True(result.isDefault);
+  }
+
+  [Fact]
+  public void GetDefaultAccount_ReturnsFirstAccount_WhenNoDefaultExists()
+  {
+    // Arrange
+    var account1 = CreateTestAccount("account-1");
+    var account2 = CreateTestAccount("account-2");
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(
+        new[]
+        {
+          (account1.id, JsonConvert.SerializeObject(account1)),
+          (account2.id, JsonConvert.SerializeObject(account2)),
+        }
+      );
+
+    // Act
+    var result = _accountManager.GetDefaultAccount();
+
+    // Assert
+    Assert.NotNull(result);
+    Assert.Equal("account-1", result!.id);
+  }
+
+  [Fact]
+  public void GetDefaultAccount_ReturnsNull_WhenNoAccounts()
+  {
+    // Arrange
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns([]);
+
+    // Act
+    var result = _accountManager.GetDefaultAccount();
+
+    // Assert
+    Assert.Null(result);
+  }
+
+  [Fact]
+  public void GetAccounts_SkipsInvalidAccounts()
+  {
+    // Arrange
+    var validAccount = CreateTestAccount("valid-account");
+    validAccount.isDefault = true;
+
+    var invalidAccount = new Account { id = "invalid-account" };
+
+    var deleteCalled = false;
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(() =>
+      {
+        if (deleteCalled)
+        {
+          return [(validAccount.id, JsonConvert.SerializeObject(validAccount))];
+        }
+        return
+        [
+          (validAccount.id, JsonConvert.SerializeObject(validAccount)),
+          (invalidAccount.id, JsonConvert.SerializeObject(invalidAccount)),
+        ];
+      });
+
+    _mockAccountStorage.Setup(s => s.DeleteObject(invalidAccount.id)).Callback(() => deleteCalled = true);
+    // Act
+    var result = _accountManager.GetAccounts().ToList();
+
+    // Assert
+    Assert.Single(result);
+    Assert.Equal("valid-account", result[0].id);
+    _mockAccountStorage.Verify(s => s.DeleteObject(invalidAccount.id), Times.Once);
+  }
+
+  [Fact]
+  public void RemoveAccount_RemovesAccount()
+  {
+    // Arrange
+    var accountId = "account-to-remove";
+
+    _mockAccountStorage.Setup(s => s.DeleteObject(accountId));
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns([]);
+
+    // Act
+    _accountManager.RemoveAccount(accountId);
+
+    // Assert
+    _mockAccountStorage.Verify(s => s.DeleteObject(accountId), Times.Once);
+  }
+
+  [Fact]
+  public void RemoveAccount_SetsNewDefaultAccount_WhenDefaultRemoved()
+  {
+    // Arrange
+    var defaultAccountId = "default-account";
+    var regularAccountId = "regular-account";
+
+    var regularAccount = CreateTestAccount(regularAccountId);
+
+    _mockAccountStorage.Setup(s => s.DeleteObject(defaultAccountId));
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(new[] { (regularAccountId, JsonConvert.SerializeObject(regularAccount)) });
+    _mockAccountStorage.Setup(s => s.UpdateObject(regularAccountId, It.IsAny<string>()));
+
+    // Act
+    _accountManager.RemoveAccount(defaultAccountId);
+
+    // Assert
+    _mockAccountStorage.Verify(s => s.DeleteObject(defaultAccountId), Times.Once);
+    _mockAccountStorage.Verify(
+      s => s.UpdateObject(regularAccountId, It.Is<string>(json => json.Contains("\"isDefault\":true"))),
+      Times.Once
+    );
+  }
+
+  [Fact]
+  public void ChangeDefaultAccount_UpdatesDefaultAccount()
+  {
+    // Arrange
+    var account1 = CreateTestAccount("account-1");
+    account1.isDefault = true;
+
+    var account2 = CreateTestAccount("account-2");
+
+    _mockAccountStorage
+      .Setup(s => s.GetAllObjects())
+      .Returns(
+        new[]
+        {
+          (account1.id, JsonConvert.SerializeObject(account1)),
+          (account2.id, JsonConvert.SerializeObject(account2)),
+        }
+      );
+
+    _mockAccountStorage.Setup(s => s.UpdateObject(account1.id, It.IsAny<string>()));
+    _mockAccountStorage.Setup(s => s.UpdateObject(account2.id, It.IsAny<string>()));
+
+    // Act
+    _accountManager.ChangeDefaultAccount(account2.id);
+
+    // Assert
+    _mockAccountStorage.Verify(
+      s => s.UpdateObject(account1.id, It.Is<string>(json => json.Contains("\"isDefault\":false"))),
+      Times.Once
+    );
+    _mockAccountStorage.Verify(
+      s => s.UpdateObject(account2.id, It.Is<string>(json => json.Contains("\"isDefault\":true"))),
+      Times.Once
+    );
+  }
+
+  [Fact]
+  public void GetLocalIdentifierForAccount_ReturnsIdentifier_WhenAccountExists()
+  {
+    // Arrange
+    var account = CreateTestAccount("test-account");
+    var expectedUri = new Uri($"{account.serverInfo.url}?id={account.userInfo.id}");
+
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns(new[] { ("bad", JsonConvert.SerializeObject(account)) });
+
+    // Act
+    var result = _accountManager.GetLocalIdentifierForAccount(account);
+
+    // Assert
+    Assert.NotNull(result);
+    Assert.Equal(expectedUri, result);
+  }
+
+  [Fact]
+  public void GetLocalIdentifierForAccount_ReturnsNull_WhenAccountDoesNotExist()
+  {
+    // Arrange
+    var account = CreateTestAccount("non-existent-account");
+
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns([]);
+
+    // Act
+    var result = _accountManager.GetLocalIdentifierForAccount(account);
+
+    // Assert
+    Assert.Null(result);
+  }
+
+  [Fact]
+  public void GetAccountForLocalIdentifier_ReturnsAccount_WhenMatches()
+  {
+    // Arrange
+    var account = CreateTestAccount("test-account");
+    var localIdentifier = new Uri($"{account.serverInfo.url}?id={account.userInfo.id}");
+
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns(new[] { ("bad", JsonConvert.SerializeObject(account)) });
+
+    // Act
+    var result = _accountManager.GetAccountForLocalIdentifier(localIdentifier);
+
+    // Assert
+    Assert.NotNull(result);
+    Assert.Equal(account.id, result!.id);
+  }
+
+  [Fact]
+  public void GetAccountForLocalIdentifier_ReturnsNull_WhenNoMatch()
+  {
+    // Arrange
+    var account = CreateTestAccount("test-account");
+    var localIdentifier = new Uri("https://different.url?u=different-user");
+
+    _mockAccountStorage.Setup(s => s.GetAllObjects()).Returns(new[] { ("bad", JsonConvert.SerializeObject(account)) });
+
+    // Act
+    var result = _accountManager.GetAccountForLocalIdentifier(localIdentifier);
+
+    // Assert
+    Assert.Null(result);
+  }
+
+  // Helper method to create a test account
+  private static Account CreateTestAccount(string id)
+  {
+    return new Account
+    {
+      id = id,
+      token = "test-token",
+      refreshToken = "refresh-token",
+      isDefault = false,
+      isOnline = true,
+      userInfo = new UserInfo
+      {
+        id = "user-id",
+        name = "Test User",
+        email = "test@example.com",
+        company = "Test Company",
+      },
+      serverInfo = new ServerInfo
+      {
+        name = "Test Server",
+        url = "https://test.speckle.systems",
+        company = "Speckle",
+      },
+    };
+  }
+}
@@ -18,7 +18,7 @@ public class SpecklePathTests
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
    {
-      pattern = @"\/Users\/.*\/\.config";
+      pattern = @"\/Users\/.*\/Library\/Application Support";
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
    {
@@ -57,7 +57,7 @@ public class SpecklePathTests
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
    {
-      pattern = @"\/Users\/.*\/\.config";
+      pattern = @"\/Users\/.*\/Library\/Application Support";
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
    {
@@ -0,0 +1,83 @@
+using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Speckle.Sdk.Caching;
+using Speckle.Sdk.Testing;
+
+namespace Speckle.Sdk.Tests.Unit;
+
+public class ModelCacheManagerMockTests : MoqTest
+{
+  private readonly Mock<IFileSystem> _fileSystemMock;
+  private readonly ModelCacheManager _manager;
+
+  public ModelCacheManagerMockTests()
+  {
+    Mock<ILogger<ModelCacheManager>> loggerMock = Create<ILogger<ModelCacheManager>>(MockBehavior.Loose);
+    _fileSystemMock = Create<IFileSystem>();
+    _manager = new ModelCacheManager(loggerMock.Object, _fileSystemMock.Object);
+  }
+
+  [Fact]
+  public void ClearCache_ShouldNotDeleteFiles_WhenDirectoryDoesNotExist()
+  {
+    _fileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(false);
+    _manager.ClearCache();
+    _fileSystemMock.Verify(fs => fs.EnumerateFiles(It.IsAny<string>()), Times.Never);
+    _fileSystemMock.Verify(fs => fs.DeleteFile(It.IsAny<string>()), Times.Never);
+  }
+
+  [Fact]
+  public void ClearCache_ShouldDeleteFiles_WhenDirectoryExists()
+  {
+    var files = new List<string> { "file1.db", "file2.db" };
+    _fileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(true);
+    _fileSystemMock.Setup(fs => fs.EnumerateFiles(It.IsAny<string>())).Returns(files);
+    foreach (var file in files)
+    {
+      _fileSystemMock.Setup(fs => fs.DeleteFile(file));
+    }
+    _manager.ClearCache();
+  }
+
+  [Fact]
+  public void ClearCache_ShouldLogWarning_WhenDeleteFileThrows()
+  {
+    var files = new List<string> { "file1.db" };
+    _fileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(true);
+    _fileSystemMock.Setup(fs => fs.EnumerateFiles(It.IsAny<string>())).Returns(files);
+    _fileSystemMock.Setup(fs => fs.DeleteFile(It.IsAny<string>())).Throws<IOException>();
+    _manager.ClearCache();
+  }
+
+  [Fact]
+  public void GetCacheSize_ShouldReturnZero_WhenDirectoryDoesNotExist()
+  {
+    _fileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(false);
+    var size = _manager.GetCacheSize();
+    size.Should().Be(0);
+  }
+
+  [Fact]
+  public void GetCacheSize_ShouldSumFileSizes()
+  {
+    var files = new List<string> { "file1.db", "file2.db" };
+    _fileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(true);
+    _fileSystemMock.Setup(fs => fs.EnumerateFiles(It.IsAny<string>())).Returns(files);
+    _fileSystemMock.Setup(fs => fs.GetFileSize("file1.db")).Returns(10);
+    _fileSystemMock.Setup(fs => fs.GetFileSize("file2.db")).Returns(20);
+    var size = _manager.GetCacheSize();
+    size.Should().Be(30);
+  }
+
+  [Fact]
+  public void GetCacheSize_ShouldLogWarning_WhenGetFileSizeThrows()
+  {
+    var files = new List<string> { "file1.db" };
+    _fileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(true);
+    _fileSystemMock.Setup(fs => fs.EnumerateFiles(It.IsAny<string>())).Returns(files);
+    _fileSystemMock.Setup(fs => fs.GetFileSize(It.IsAny<string>())).Throws<IOException>();
+    var size = _manager.GetCacheSize();
+    size.Should().Be(0);
+  }
+}
@@ -213,7 +213,9 @@ public class BaseTests
  [Fact]
  public void CanShallowCopy()
  {
-    var sample = new SampleObject();
+    var sample = new SampleObject { id = "sampleId" };
+    dynamic x = sample;
+    x.test = "test";
    var copy = sample.ShallowCopy();

    var selectedMembers = DynamicBaseMemberType.Dynamic | DynamicBaseMemberType.Instance;
@@ -0,0 +1,141 @@
+using FluentAssertions;
+using Microsoft.CSharp.RuntimeBinder;
+using Speckle.Sdk.Host;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Sdk.Tests.Unit.Models;
+
+public class DynamicBaseTests
+{
+  public DynamicBaseTests()
+  {
+    TypeLoader.Reset();
+    TypeLoader.Initialize(typeof(Base).Assembly, typeof(BaseTests).Assembly);
+  }
+
+  [Fact]
+  public void Indexer_SetAndGet()
+  {
+    // Arrange
+    var dynamicBase = new DynamicBase();
+    var key = "testProperty";
+    var value = "testValue";
+
+    // Act
+    dynamicBase[key] = value;
+    var result = dynamicBase[key];
+
+    // Assert
+    result.Should().Be(value);
+  }
+
+  [Fact]
+  public void DynamicProperty_SetAndGet()
+  {
+    // Arrange
+    dynamic dynamicBase = new DynamicBase();
+    var value = "dynamicValue";
+
+    // Act
+    dynamicBase.dynamicProperty = value;
+    object result = dynamicBase.dynamicProperty;
+
+    // Assert
+    result.Should().Be(value);
+  }
+
+  [Fact]
+  public void GetMembers_Default()
+  {
+    // Arrange
+    dynamic dynamicBase = new DynamicBase();
+    dynamicBase.dynamicProp = "hello";
+
+    // Act
+    IDictionary<string, object?> members = dynamicBase.GetMembers();
+
+    // Assert
+    members.Should().ContainKey("dynamicProp");
+  }
+
+  [Fact]
+  public void GetMembers_Instance()
+  {
+    // Arrange
+    var dynamicBase = new TestDynamicBase();
+
+    // Act
+    var members = dynamicBase.GetMembers(DynamicBaseMemberType.Instance);
+
+    // Assert
+    members.Should().ContainKey(nameof(TestDynamicBase.InstanceProperty));
+    members.Should().NotContainKey("dynamicProp");
+  }
+
+  [Fact]
+  public void GetDynamicMemberNames()
+  {
+    // Arrange
+    dynamic dynamicBase = new DynamicBase();
+    dynamicBase.prop1 = 1;
+    dynamicBase.prop2 = "test";
+
+    // Act
+    IEnumerable<string> memberNames = dynamicBase.GetDynamicMemberNames();
+
+    // Assert
+    memberNames.Should().BeEquivalentTo(["DynamicPropertyKeys", "prop1", "prop2"]);
+  }
+
+  [Fact]
+  public void TryGetMember_Existing()
+  {
+    // Arrange
+    dynamic dynamicBase = new DynamicBase();
+    dynamicBase.existingProp = "I exist";
+
+    // Act
+    var result = dynamicBase.existingProp;
+
+    // Assert
+    ((object)result)
+      .Should()
+      .Be("I exist");
+  }
+
+  [Fact]
+  public void TryGetMember_NonExisting()
+  {
+    // Arrange
+    dynamic dynamicBase = new DynamicBase();
+
+    // Act
+    Action act = () =>
+    {
+      var result = dynamicBase.nonExistingProp;
+    };
+
+    // Assert
+    act.Should().Throw<RuntimeBinderException>();
+  }
+
+  [Fact]
+  public void TrySetMember()
+  {
+    // Arrange
+    dynamic dynamicBase = new DynamicBase();
+
+    // Act
+    dynamicBase.newProp = "newValue";
+
+    // Assert
+    ((object)dynamicBase.newProp)
+      .Should()
+      .Be("newValue");
+  }
+
+  private class TestDynamicBase : DynamicBase
+  {
+    public string InstanceProperty { get; set; } = "instance";
+  }
+}
@@ -22,7 +22,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  public void TestGetAll()
  {
    var data = new List<(string id, string json)>() { ("id1", "1"), ("id2", "2") };
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    manager.SaveObjects(data);
    var items = manager.GetAllObjects();
    items.Count.Should().Be(data.Count);
@@ -38,7 +38,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  public void TestGet()
  {
    var data = new List<(string id, string json)>() { ("id1", "1"), ("id2", "2") };
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    foreach (var d in data)
    {
      manager.SaveObject(d.id, d.json);
@@ -84,7 +84,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  public void TestLargeJsonPayload()
  {
    var largeJson = new string('a', 100_000);
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    manager.SaveObject("large", largeJson);
    var result = manager.GetObject("large");
    result.Should().Be(largeJson);
@@ -96,7 +96,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
    var id = "spécial_字符_!@#$%^&*()";
    var json = /*lang=json,strict*/
      "{\"value\": \"特殊字符!@#$%^&*()\"}";
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    manager.SaveObject(id, json);
    var result = manager.GetObject(id);
    result.Should().Be(json);
@@ -108,7 +108,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  [Fact]
  public void TestBulkInsertEmptyCollection()
  {
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    manager.SaveObjects(new List<(string, string)>());
    manager.GetAllObjects().Count.Should().Be(0);
  }
@@ -116,7 +116,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  [Fact]
  public void TestRepeatedUpdateAndDelete()
  {
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    manager.SaveObject("id", "1");
    manager.UpdateObject("id", "2");
    manager.UpdateObject("id", "3");
@@ -129,7 +129,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  [Fact]
  public void TestGetAndDeleteNonExistentId()
  {
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    manager.GetObject("doesnotexist").Should().BeNull();
    manager.HasObject("doesnotexist").Should().BeFalse();
    manager.DeleteObject("doesnotexist"); // Should not throw
@@ -138,7 +138,7 @@ public class SQLiteJsonCacheManagerTests : IDisposable
  [Fact]
  public void TestNullOrEmptyInput()
  {
-    using var manager = new SqLiteJsonCacheManager(_basePath, 2);
+    using var manager = SqLiteJsonCacheManager.FromFilePath(_basePath, 2);
    // Empty id
    Assert.Throws<ArgumentException>(() => manager.SaveObject("", "emptyid"));
    // Empty json
@@ -39,7 +39,7 @@ public abstract class PrimitiveTestFixture
    }.Select(x => new object[] { x });

  public static Half[] Float16TestCases { get; } =
-    [default, Half.Epsilon, Half.MaxValue, Half.MinValue, Half.PositiveInfinity, Half.NegativeInfinity, Half.NaN];
+  [default, Half.Epsilon, Half.MaxValue, Half.MinValue, Half.PositiveInfinity, Half.NegativeInfinity, Half.NaN];

  public static float[] FloatIntegralTestCases { get; } = [0, 1, int.MaxValue, int.MinValue];

@@ -1,7 +1,7 @@
 using FluentAssertions;
 using Microsoft.Data.Sqlite;
+using Speckle.Sdk.Caching;
 using Speckle.Sdk.Common;
-using Speckle.Sdk.Serialisation.Utilities;
 using Speckle.Sdk.Transports;

 namespace Speckle.Sdk.Tests.Unit.Transports;
@@ -13,7 +13,7 @@ public sealed class SQLiteTransport2Tests : TransportTests, IDisposable
  private SQLiteTransport2? _sqlite;

  private static readonly string s_name = $"test-{Guid.NewGuid()}";
-  private static readonly string s_basePath = SqlitePaths.GetDBPath(s_name);
+  private static readonly string s_basePath = ModelCacheManager.GetDbPath(s_name);

  public SQLiteTransport2Tests()
  {
Author	SHA1	Message	Date
Adam Hathcock	637997bd18	Report progress before saving SQLite .NET Build and Publish / build (push) Has been cancelled Details	2025-08-26 10:31:43 +01:00
Adam Hathcock	6c89748fd0	Report increment rather than total position	2025-08-26 10:04:14 +01:00
dependabot[bot]	647c4733cb	Bump actions/checkout from 4 to 5 (#376 ) Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/checkout dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-08-20 10:32:24 +01:00
Jedd Morgan	f7ddc19086	Merge pull request #375 from specklesystems/jrm/main-dev-7 Main -> Dev	2025-08-06 13:28:59 +01:00
Jedd Morgan	6d06901b4f	Merge branch 'dev' into jrm/main-dev-7	2025-08-06 13:13:39 +01:00
Jedd Morgan	4b588fc287	Do not dispose the activity factory (#372 ) .NET Build and Publish / build (push) Has been cancelled Details	2025-08-04 14:21:50 +00:00
Jedd Morgan	786e683d89	Merge pull request #371 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details Dev -> Main for 3.5.0 stable	2025-08-01 14:49:47 +01:00
Jedd Morgan	8d999f4f9c	Update README.md (#370 )	2025-07-30 07:53:10 +00:00
Jedd Morgan	bb7542e254	chore(ci): Remove Gitversion (#369 ) * Strip out gitversion * Pr workflow * fix? * fix x2 * pass envvars properly	2025-07-30 08:41:32 +01:00
Jedd Morgan	d6f6254a92	feat(file-import): Added file import resource and blob api functions (#367 ) .NET Build and Publish / build (push) Has been cancelled Details * add file import resource * disabled health check * re-enable healthcheck * git ignore volumes * disabled importer * start_period * Skipped broken tests * Verify tests * Fixed tests * reverted volumes path * Update docker-compose.yml	2025-07-29 14:52:12 +00:00
Jedd Morgan	f60f85b639	Merge pull request #368 from specklesystems/jrm/main-dev-5 chore: main -> dev	2025-07-28 18:01:43 +01:00
Jedd Morgan	bcdf73cc70	Updated active workspace query (#365 )	2025-07-25 08:42:43 +01:00
Adam Hathcock	47e72ee1a7	Merge pull request #364 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details Main to dev	2025-07-23 14:19:52 +01:00
Adam Hathcock	f3de5324db	Merge pull request #362 from specklesystems/main Main to dev	2025-07-23 13:44:14 +01:00
Adam Hathcock	4dd6db886f	insert or replace always...don't use ignore or insert (#363 ) * SaveObject is always insert or replace. Never use insert or ignore * add/fix tests * always replace even for bulk	2025-07-23 12:16:08 +00:00
Adam Hathcock	4b82db8ea2	Merge pull request #361 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details Main to dev	2025-07-23 10:23:04 +01:00
Adam Hathcock	9e7f26f7a6	Add ModelCacheManager class and use it (#356 ) * Introduce ModelCacheManager to manage cache and sizes and deletions * move and abstract * add tests and format * Update src/Speckle.Sdk/Caching/ModelCacheManager.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Clean up --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-07-23 10:07:57 +01:00
Adam Hathcock	b19f8c4219	Merge pull request #358 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details (NO SQUASH) Main to dev for release	2025-07-21 15:49:49 +01:00
Adam Hathcock	c517e61517	Merge pull request #360 from specklesystems/main-dev Main to dev	2025-07-21 15:47:38 +01:00
Adam Hathcock	b3e0623856	Merge remote-tracking branch 'origin/main' into main-dev	2025-07-21 15:36:30 +01:00
Adam Hathcock	e5d1ef2448	Merge pull request #354 from specklesystems/main-dev Merge pull request #348 from specklesystems/dev	2025-07-21 11:12:54 +01:00
Adam Hathcock	83c3de05fa	Merge remote-tracking branch 'origin/dev' into main-dev	2025-07-21 11:02:02 +01:00
Adam Hathcock	507ded7d4a	Fix shallow copy allocations and perf (#357 ) * add more DynamicBase Tests * Move ShallowCopy to dynamic and try to be faster with copy * Correct tests for macOS * use cache obsolete attribute * Update src/Speckle.Sdk/Models/DynamicBase.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update tests/Speckle.Sdk.Tests.Unit/Models/DynamicBaseTests.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update tests/Speckle.Sdk.Tests.Unit/Models/DynamicBaseTests.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * fix AI --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-07-21 11:01:00 +01:00
Adam Hathcock	e15029bab3	Merge pull request #350 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details (dev to main) If we're already cancelling, ignore extra exceptions (#349)	2025-07-14 10:34:06 +01:00
Adam Hathcock	a43fd44206	Stop recording an exception that's rethrown (#355 ) * Stop recording an exception that's rethrown * Update src/Speckle.Sdk/Api/GraphQL/Client.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-07-14 10:15:40 +01:00
Adam Hathcock	1bcd8ac3a4	Merge branch 'dev' into main-dev	2025-07-03 10:42:05 +01:00
Adam Hathcock	a8dc93e22b	Adds detail to message so that user isn't going WTF SDK (#351 ) * Adds detail to message so that user isn't going WTF SDK * update exception tests	2025-07-03 09:39:53 +00:00
Jedd Morgan	5a0f883b98	Add compatibility with `:local` docker images (#353 ) Co-authored-by: Adam Hathcock <adamhathcock@users.noreply.github.com>	2025-07-03 10:28:35 +01:00
Adam Hathcock	a5d035671a	If we're already cancelling, ignore extra exceptions (#349 ) * If we're already cancelling, ignore extra exceptions * Do more robust cancellation * Try to have more robust disposal and cancellation check	2025-07-01 10:20:32 +01:00
Adam Hathcock	cd6ebad619	Merge pull request #348 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details New release for connectors	2025-06-30 15:15:51 +01:00
Adam Hathcock	33c2e6e1a4	Better handle graphql commit errors (#343 ) * Better handle graphql commit errors * add graphql error test	2025-06-30 10:54:44 +00:00
Adam Hathcock	b97702adb1	Small fixes to SDK (#347 ) * Increase channel capacity to make things more performant * Avoid logging send cancellation exceptions, caller did it * Try to avoid collection modified errors when cancelling by more aggressive checks * oops, rethrow, don't catch	2025-06-30 10:37:30 +00:00
Adam Hathcock	80c4f694ec	Merge pull request #346 from specklesystems/main-dev Main to dev	2025-06-30 11:26:36 +01:00
Adam Hathcock	fb5042004f	Merge remote-tracking branch 'origin/dev' into main-dev	2025-06-30 08:58:57 +01:00
Adam Hathcock	c0a9291632	Merge pull request #344 from specklesystems/oguzhan/level-proxies .NET Build and Publish / build (push) Has been cancelled Details Feat(objects): level proxies	2025-06-23 15:05:15 +01:00
oguzhankoral	b783d2acb6	Format	2025-06-23 15:57:24 +03:00
oguzhankoral	93539adc1e	Add level proxies	2025-06-23 15:42:48 +03:00
Adam Hathcock	98005933de	Remove DistinctBy as we don't use it (#342 )	2025-06-19 09:34:34 +01:00
Adam Hathcock	50906b172a	Merge pull request #340 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details	2025-06-11 17:35:27 +01:00
Adam Hathcock	05f7353925	Revert "Merge pull request #335 from specklesystems/adam/cnx-1786-allow-multiple-sends-to-access-sqlite-in-a-non-locking-2" (#339 ) This reverts commit `59019bf846`, reversing changes made to `3afaf61a1a`. Co-authored-by: Adam Hathcock <adam@Adams-Mac-mini.localdomain>	2025-06-11 15:32:06 +00:00
Adam Hathcock	8328498553	Merge pull request #338 from specklesystems/dev .NET Build and Publish / build (push) Has been cancelled Details Dev to Main (no squash)	2025-06-11 11:07:20 +01:00
Adam Hathcock	59019bf846	Merge pull request #335 from specklesystems/adam/cnx-1786-allow-multiple-sends-to-access-sqlite-in-a-non-locking-2 Use an object saver per stream instead of sqlite manager per stream	2025-06-11 10:50:34 +01:00
Adam Hathcock	3afaf61a1a	Merge pull request #337 from specklesystems/main Main to dev (no squash)	2025-06-11 10:50:18 +01:00
Adam Hathcock	424609fad0	fix tests	2025-06-10 13:18:34 +01:00
Adam Hathcock	46c067308e	Fix DI dependency and tests	2025-06-10 11:39:42 +01:00
Adam Hathcock	0e33e8df8f	add tests	2025-06-10 11:33:17 +01:00
Adam Hathcock	bc81c21e9d	format	2025-06-10 11:15:30 +01:00
Adam Hathcock	7f8b59d348	Pool object savers instead of sqlite	2025-06-10 11:15:01 +01:00
Adam Hathcock	44ba61e4a5	Adjustments to avoid sqlite "database is locked" errors (#333 ) * add new exception test * Make memory tests and file path tests be explicit * set the default write parallelism to 1 * set to single reader for caching channel * format * Try to have consistent DB locked error test * always a single reader of the channel * Remove extra snapshot * Revert "Try to have consistent DB locked error test" This reverts commit `93669c57a3`. * remove extra test that doesn't do anything	2025-06-09 16:24:39 +00:00