Merge pull request #861 from specklesystems/dev

Dev -> Main for 3.2.2

.config/dotnet-tools.json

@@ -9,10 +9,10 @@
       ],
       "rollForward": false
     },
-    "gitversion.tool": {
-      "version": "6.0.2",
+    "dotnet-affected": {
+      "version": "5.0.0",
       "commands": [
-        "dotnet-gitversion"
+        "dotnet-affected"
       ],
       "rollForward": false
     }

.editorconfig

@@ -239,6 +239,9 @@ dotnet_diagnostic.ide0290.severity = suggestion # primary constructors: subjecti
 dotnet_diagnostic.ide0290.severity = suggestion # Use primary constructor: Subjective
 dotnet_diagnostic.ide0037.severity = suggestion # Use inferred member names: Sometimes its nice to be explicit
 dotnet_diagnostic.ide0301.severity = suggestion # Use collection expression for empty: Subjective, intent
+dotnet_diagnostic.ide0021.severity = suggestion # Use expression body for constructors : Subjective
+dotnet_diagnostic.ide0090.severity = suggestion # Simplify new expression : Subjective
+
 dotnet_diagnostic.ide0047.severity = suggestion # Parentheses preferences: IDEs don't properly pick it up
 
 # Maintainability rules
@@ -251,9 +254,10 @@ dotnet_diagnostic.ca1508.severity = warning # Avoid dead conditional code
 dotnet_diagnostic.ca1509.severity = warning # Invalid entry in code metrics configuration file
 dotnet_diagnostic.ca1861.severity = none # Prefer 'static readonly' fields over constant array arguments if the called method is called repeatedly and is not mutating the passed array (https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1861)
 
+# CA2007: Consider calling ConfigureAwait on the awaited task (this is not needed for application code, in fact we don't want to call anything but ConfigureAwait(true) which is the default)
+dotnet_diagnostic.CA2007.severity = none
+
 dotnet_diagnostic.cs8618.severity = suggestion # nullable problem
-dotnet_diagnostic.CS0809.severity = suggestion # obsolete errors
-dotnet_diagnostic.CS0618.severity = suggestion # obsolete errors
 
 
 # Performance rules
@@ -310,6 +314,9 @@ dotnet_diagnostic.NUnit2037.severity = warning # Consider using Assert.That(coll
 dotnet_diagnostic.NUnit2038.severity = warning # Consider using Assert.That(actual, Is.InstanceOf(expected)) instead of Assert.IsInstanceOf(expected, actual)
 dotnet_diagnostic.NUnit2039.severity = warning # Consider using Assert.That(actual, Is.Not.InstanceOf(expected)) instead of Assert.IsNotInstanceOf(expected, actual)
 
+# note: added to allow the copy paste from rhino inside of the ValueSet component
+dotnet_diagnostic.CA1033.severity = none
+
 [*.{appxmanifest,asax,ascx,aspx,axaml,build,c,c++,cc,cginc,compute,cp,cpp,cs,cshtml,cu,cuh,cxx,dtd,fs,fsi,fsscript,fsx,fx,fxh,h,hh,hlsl,hlsli,hlslinc,hpp,hxx,inc,inl,ino,ipp,ixx,master,ml,mli,mpp,mq4,mq5,mqh,nuspec,paml,razor,resw,resx,shader,skin,tpp,usf,ush,vb,xaml,xamlx,xoml,xsd}]
 indent_style = space
 indent_size = 2

.github/CODEOWNERS

@@ -4,33 +4,36 @@
 
 # * @specklesystems/connectors
 
-# Core
-# Not needed, falls back on team approval
-
-# Objects
-#   Converters require product owner approval, anything else falls back to team approval
-
-Objects/ConverterAutocadCivil/* @clairekuang @connorivy
-Objects/ConverterCSI/* @connorivy
-Objects/ConverterDynamo/* @teocomi @alanrynne
-Objects/ConverterMicrostation/* @connorivy
-Objects/ConverterRevit/* @connorivy @teocomi
-Objects/ConverterRhinoGh/* @alanrynne @clairekuang
-Objects/ConverterTeklaStructures/* @connorivy
-Objects/StructuralUtilities/PolygonMesher/* @connorivy
-
 # Connectors
 
-ConnectorAutocadCivil/* @clairekuang
-ConnectorArchicad/* @jozseflkiss
-ConnectorCSI/* @connorivy
-ConnectorDynamo/* @teocomi @alanrynne
-ConnectorGrasshopper/* @alanrynne @clairekuang
-ConnectorMicrostation/* @clairekuang
-ConnectorRevit/* @teocomi @connorivy
-ConnectorRhino/* @clairekuang @alanrynne
-ConnectorTeklaStructures/* @connorivy
+/Connectors/ArcGIS/* @KatKatKateryna
+/Connectors/Autocad/* @clairekuang @oguzhankoral @didimitrie
+/Connectors/Civil3d/* @clairekuang @oguzhankoral @didimitrie
+/Connectors/CSi/* @bjoernsteinhagen @dogukankaratas
+/Connectors/Navisworks/* @jsdbroughton
+/Connectors/Revit/* @clairekuang @oguzhankoral @didimitrie
+/Connectors/Rhino/* @clairekuang @oguzhankoral @didimitrie
+/Connectors/Tekla/* @bjoernsteinhagen @dogukankaratas
 
-# DesktopUI
+# Converters
+/Convertors/ArcGIS/* @KatKatKateryna
+/Convertors/Autocad/* @clairekuang @oguzhankoral @didimitrie
+/Convertors/Civil3d/* @clairekuang @oguzhankoral @didimitrie
+/Convertors/CSi/* @bjoernsteinhagen @dogukankaratas
+/Convertors/Navisworks/* @jsdbroughton
+/Convertors/Revit/* @clairekuang @oguzhankoral @didimitrie
+/Convertors/Rhino/* @clairekuang @oguzhankoral @didimitrie
+/Convertors/Tekla/* @bjoernsteinhagen @dogukankaratas
 
-DesktopUI2/* @teocomi @clairekuang
+# DUI
+
+/DUI3/* @clairekuang @oguzhankoral @didimitrie
+
+# Importers
+/Importers/* @JR-Morgan @didimitrie @oguzhankoral @adamhathcock
+
+# SDK
+/SDK/* @JR-Morgan @clairekuang @didimitrie @oguzhankoral @adamhathcock
+
+# Build
+/Build/* @JR-Morgan @oguzhankoral @adamhathcock

.github/pull_request_template.md

@@ -1,30 +1,46 @@
 <!---
 
-Provide a short summary in the Title above. Examples of good PR titles:
+Provide a short summary in the Title above. Use the following template:
 
-* "Feature: adds metrics to component"
+category(project): summary
 
-* "Fix: resolves duplication in comment thread"
+Categories:
 
-* "Update: apollo v2.34.0"
+* feat: (new feature for the user, not a new feature for build script)
+* fix: (bug fix for the user, not a fix to a build script)
+* docs: (changes to the documentation)
+* style: (formatting, missing semi colons, etc; no production code change)
+* refactor: (refactoring production code, eg. renaming a variable)
+* test: (adding missing tests, refactoring tests; no production code change)
+* chore: (updating grunt tasks etc; no production code change)
+
+Example:
+
+feat(revit): added category filter to send
 
 -->
 
-## Description & motivation
+## Description
 
 <!---
 
-Describe your changes, and why you're making them.  What benefit will this have to others?
+Describe your changes, and why you're making them.
 
-Is this linked to an open Github issue, a thread in Speckle community,
-or another pull request? Link it here.
-
-If it is related to a Github issue, and resolves it, please link to the issue number, e.g.:
-Fixes #85, Fixes #22, Fixes username/repo#123
-Connects #123
+Link related github issues here ->
+Fixes #85, Fixes #22, Connects #123
 
 -->
 
+## User Value
+
+<!---
+
+Describe in 1 sentence the user value.
+
+This can also be a link to the relevant thread in Speckle community, or a link to the Linear issue.
+-->
+
+
 ## Changes:
 
 <!---
@@ -68,35 +84,10 @@ Describe what tests have been added or amended, and why these demonstrate it wor
 
 <!---
 
-This checklist is mostly useful as a reminder of small things that can easily be
-
-forgotten – it is meant as a helpful tool rather than hoops to jump through.
-
-Put an `x` between the square brackets, e.g. [x], for all the items that apply,
-
-make notes next to any that haven't been addressed, and remove any items that are not relevant to this PR.
+This checklist is a useful reminder of related tasks to uphold our repo quality. Amend this list as needed for the pr.
 
 -->
-
-- [ ] My pull request follows the guidelines in the [Contributing guide](https://github.com/specklesystems/speckle-server/blob/main/CONTRIBUTING.md)?
-- [ ] My pull request does not duplicate any other open [Pull Requests](../../pulls) for the same update/change?
 - [ ] My commits are related to the pull request and do not amend unrelated code or documentation.
-- [ ] My code follows a similar style to existing code.
 - [ ] I have added appropriate tests.
 - [ ] I have updated or added relevant documentation.
 
-## References
-
-<!---
-
-(Optional -- remove this section if not needed )
-
-Include **important** links regarding the implementation of this PR.
-
-This usually includes a RFC or an aggregation of issues and/or individual conversations
-
-that helped put this solution together. This helps ensure we retain and share knowledge
-
-regarding the implementation, and may help others understand motivation and design decisions etc..
-
--->

.github/workflows/main.yml

@@ -1,91 +0,0 @@
-name: .NET Build and Publish
-
-on:
-  push:
-    branches: ["main", "dev"] # Continuous delivery on every long-lived branch
-    tags: ["v3.*"] # Manual delivery on every 3.x tag
-
-jobs:
-  build:
-    runs-on: windows-latest
-    outputs:
-      version: ${{ steps.set-version.outputs.version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 8.0.2xx # Align with global.json (including roll forward rules)
-
-      - name: Cache Nuget
-        uses: actions/cache@v4
-        with:
-          path: ~/.nuget/packages
-          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
-
-      - name: ⚒️ Run GitVersion
-        run: ./build.ps1 build-server-version
-
-      - name: ⚒️ Run build
-        run: ./build.ps1
-
-      - name: ⬆️ Upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: output-${{ env.GitVersion_FullSemVer }}
-          path: output/*.*
-          compression-level: 0 # no compression
-
-      - id: set-version
-        name: Set version to output
-        run: echo "version=${{ env.GitVersion_FullSemVer }}" >> "$Env:GITHUB_OUTPUT"
-
-  deploy-installers:
-    runs-on: ubuntu-latest
-    needs: build
-    env:
-      IS_TAG_BUILD: ${{ github.ref_type == 'tag' }}
-    steps:
-      - name: 🔫 Trigger Build Installers
-        uses: ALEEF02/workflow-dispatch@v3.0.0
-        with:
-          workflow: Build Installers
-          repo: specklesystems/connector-installers
-          token: ${{ secrets.CONNECTORS_GH_TOKEN }}
-          inputs: '{ "run_id": "${{ github.run_id }}", "version": "${{ needs.build.outputs.version }}", "public_release": ${{ env.IS_TAG_BUILD }} }'
-          ref: main
-          wait-for-completion: true
-          wait-for-completion-interval: 10s
-          wait-for-completion-timeout: 10m
-          display-workflow-run-url: true
-          display-workflow-run-url-interval: 10s
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 8.0.2xx # Align with global.json (including roll forward rules)
-
-      - name: Cache Nuget
-        uses: actions/cache@v4
-        with:
-          path: ~/.nuget/packages
-          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
-
-      - name: ⚒️ Run build
-        run: ./build.sh test-only
-
-      - name: Upload coverage reports to Codecov with GitHub Action
-        uses: codecov/codecov-action@v4
-        with:
-          file: Converters/**/coverage.xml
-          token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/pr.yml

@@ -1,15 +1,10 @@
 name: .NET Build
 
-on:
-  pull_request: # Run build on every pull request that is not to main
-    branches-ignore:
-      - main
+on: pull_request
 
-jobs:   
+jobs:
   build:
     runs-on: windows-latest
-    outputs:
-      version: ${{ steps.set-version.outputs.version }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -19,9 +14,9 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.2xx # Align with global.json (including roll forward rules)
-      
-      - name: Cache Nuget     
+          dotnet-version: 8.0.4xx # Align with global.json (including roll forward rules)
+
+      - name: Cache Nuget
         uses: actions/cache@v4
         with:
           path: ~/.nuget/packages
@@ -34,23 +29,28 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.2xx # Align with global.json (including roll forward rules)
-      
-      - name: Cache Nuget     
+          dotnet-version: 8.0.4xx # Align with global.json (including roll forward rules)
+
+      - name: Cache Nuget
         uses: actions/cache@v4
         with:
           path: ~/.nuget/packages
           key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
 
-      - name: ⚒️ Run build
+      - name: ⚒️ Run Build on Linux
+        run: ./build.sh build-linux
+
+      - name: ⚒️ Run tests
         run: ./build.sh test-only
-        
+
       - name: Upload coverage reports to Codecov with GitHub Action
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
-          file: Converters/**/coverage.xml
+          files: Converters/**/coverage.xml
           token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/release.yml

@@ -0,0 +1,115 @@
+name: .NET Build and Publish
+
+on:
+  push:
+    branches: ["main", "installer-test/**"]
+    tags: ["v3.*.*"] # Manual delivery on every 3.x tag
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+    env:
+      SEMVER: "unset"
+      FILE_VERSION: "unset"
+    outputs:
+      semver: ${{ steps.set-version.outputs.semver }}
+      file_version: ${{ steps.set-version.outputs.file_version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.4xx # Align with global.json (including roll forward rules)
+
+      - name: Cache Nuget
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+
+      - name: ⚒️ Run build on Windows
+        run: ./build.ps1 zip
+
+      - name: ⬆️ Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: output-${{ env.SEMVER }}
+          path: output/*.*
+          if-no-files-found: error
+          retention-days: 1
+          compression-level: 0 # no compression
+
+      - id: set-version
+        name: Set version to output
+        run: |
+          echo "semver=${{ env.SEMVER }}" >> "$Env:GITHUB_OUTPUT"
+          echo "file_version=${{ env.FILE_VERSION }}" >> "$Env:GITHUB_OUTPUT"
+
+  deploy-installers:
+    runs-on: ubuntu-latest
+    needs: build-windows
+    env:
+      IS_PUBLIC_RELEASE: ${{ github.ref_type == 'tag' }}
+    steps:
+      - name: 🔫 Trigger Build Installers
+        uses: the-actions-org/workflow-dispatch@v4.0.0
+        with:
+          workflow: Build Installers
+          repo: specklesystems/connector-installers
+          token: ${{ secrets.CONNECTORS_GH_TOKEN }}
+          inputs: '{
+            "run_id": "${{ github.run_id }}",
+            "semver": "${{ needs.build-windows.outputs.semver }}",
+            "file_version": "${{ needs.build-windows.outputs.file_version }}",
+            "repo": "${{ github.repository }}",
+            "is_public_release": ${{ env.IS_PUBLIC_RELEASE }}
+            }'
+          ref: main
+          wait-for-completion: true
+          wait-for-completion-interval: 10s
+          wait-for-completion-timeout: 10m
+          display-workflow-run-url: true
+          display-workflow-run-url-interval: 10s
+
+      - uses: geekyeggo/delete-artifact@v5
+        with:
+          name: output-*
+
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.4xx # Align with global.json (including roll forward rules)
+
+      - name: Cache Nuget
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+
+      - name: ⚒️ Run tests on Linux
+        run: ./build.sh test-only
+
+      - name: ⚒️ Run Build and Pack on Linux
+        run: ./build.sh build-linux
+
+      - name: Upload coverage reports to Codecov with GitHub Action
+        uses: codecov/codecov-action@v5
+        with:
+          files: Converters/**/coverage.xml
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Push to nuget.org
+        if: (github.ref_type == 'tag')
+        run: dotnet nuget push output/*.nupkg --source "https://api.nuget.org/v3/index.json" --api-key ${{secrets.CONNECTORS_NUGET_TOKEN }} --skip-duplicate

.gitignore

@@ -19,4 +19,5 @@ tools
 .DS_Store
 *.snupkg
 coverage.xml
-output/
+output/
+Images/Thumbs.db

Build/Affected.cs

@@ -0,0 +1,116 @@
+using GlobExpressions;
+using Microsoft.Build.Construction;
+using static SimpleExec.Command;
+
+namespace Build;
+
+public static class Affected
+{
+  public static readonly string Root = Environment.CurrentDirectory;
+  public const string AFFECTED_PROJECT = "affected.proj";
+
+  private static IEnumerable<string> GetAffectedProjects()
+  {
+    var projFile = Path.Combine(Root, AFFECTED_PROJECT);
+    Console.WriteLine("Affected project file: " + projFile);
+    var project = ProjectRootElement.Open(projFile) ?? throw new InvalidOperationException();
+    var references = project.ItemGroups.SelectMany(x => x.Items).Where(x => x.ItemType == "ProjectReference");
+
+    foreach (var refe in references)
+    {
+      var referencePath = refe.Include[(Root.Length + 1)..];
+      referencePath = Path.GetDirectoryName(referencePath) ?? throw new InvalidOperationException();
+      if (Path.DirectorySeparatorChar != '/')
+      {
+        referencePath = referencePath.Replace(Path.DirectorySeparatorChar, '/');
+      }
+
+      yield return referencePath;
+    }
+  }
+
+  public static async Task<IEnumerable<string>> GetTestProjects()
+  {
+    await ComputeAffected();
+    var projFile = Path.Combine(Root, AFFECTED_PROJECT);
+    if (File.Exists(projFile))
+    {
+      var references = GetAffectedProjects();
+      return references.Where(x => x.Contains("Tests"));
+    }
+    return Glob.Files(Root, "**/*.Tests.csproj");
+  }
+
+  public static async Task<ProjectGroup[]> GetAffectedProjectGroups()
+  {
+    await ComputeAffected();
+    var projFile = Path.Combine(Root, AFFECTED_PROJECT);
+    if (File.Exists(projFile))
+    {
+      var references = GetAffectedProjects().ToList();
+      var groups = new List<ProjectGroup>();
+      foreach (var projectGroup in Consts.ProjectGroups)
+      {
+        foreach (var referencePath in references)
+        {
+          if (projectGroup.Projects.Any(x => x.ProjectPath.Contains(referencePath)))
+          {
+            groups.Add(projectGroup);
+            break;
+          }
+        }
+      }
+
+      foreach (var group in groups)
+      {
+        Console.WriteLine("Affected project group being built: " + group.HostAppSlug);
+      }
+
+      return groups.ToArray();
+    }
+
+    Console.WriteLine("Using all project groups: " + string.Join(',', Consts.ProjectGroups));
+    return Consts.ProjectGroups;
+  }
+
+  private static bool s_affectedComputed;
+
+  public static async Task ComputeAffected()
+  {
+    if (s_affectedComputed)
+    {
+      return;
+    }
+
+    var currentTag = await Versions.GetCurrentTag();
+    var currentVersion = await Versions.ComputeVersion();
+    var lastTag = await Versions.GetPreviousTag(currentTag);
+    var lastVersion = await Versions.ComputePreviousVersion(currentTag);
+
+    Console.WriteLine($"Last tag: {lastTag}, Current tag: {currentTag}");
+    Console.WriteLine($"Last parsed version: {lastVersion}, Current parsed version: {currentVersion}");
+
+    var sort = currentVersion.CompareSortOrderTo(lastVersion);
+    if (sort == -1)
+    {
+      Console.WriteLine($"Current version {currentVersion} is less than: {lastVersion}");
+      s_affectedComputed = true;
+      return;
+    }
+
+    var majorEquals = currentVersion.Major == lastVersion.Major;
+    if (!majorEquals)
+    {
+      Console.WriteLine($"Current version {currentVersion} is not matching major version: {lastVersion}");
+      s_affectedComputed = true;
+      return;
+    }
+
+    //use tags no matter the version if major versions match
+    var (currentCommit, _) = await ReadAsync("git", $"rev-list -n 1 {currentTag}");
+    var (lastCommit, _) = await ReadAsync("git", $"rev-list -n 1 {lastTag}");
+    await RunAsync("dotnet", $"affected -v --from {currentCommit.Trim()} --to {lastCommit.Trim()}", Root);
+
+    s_affectedComputed = true;
+  }
+}

Build/Build.csproj

@@ -10,6 +10,8 @@
     <PackageReference Include="Bullseye" />
     <PackageReference Include="Glob" />
     <PackageReference Include="Microsoft.Build" />
+    <PackageReference Include="Microsoft.VisualStudio.SolutionPersistence" />
+    <PackageReference Include="Semver" />
     <PackageReference Include="SimpleExec" />
   </ItemGroup>
 </Project>

Build/Consts.cs

@@ -4,14 +4,14 @@ public static class Consts
 {
   public static readonly string[] Solutions = ["Speckle.Connectors.sln"];
 
-  public static readonly InstallerProject[] InstallerManifests =
+  public static readonly ProjectGroup[] ProjectGroups =
   {
     new("arcgis", [new("Connectors/ArcGIS/Speckle.Connectors.ArcGIS3", "net6.0-windows")]),
     new(
       "rhino",
       [
         new("Connectors/Rhino/Speckle.Connectors.Rhino7", "net48"),
-        new("Connectors/Rhino/Speckle.Connectors.Rhino8", "net48")
+        new("Connectors/Rhino/Speckle.Connectors.Rhino8", "net48"),
       ]
     ),
     new(
@@ -20,7 +20,8 @@ public static class Consts
         new("Connectors/Revit/Speckle.Connectors.Revit2022", "net48"),
         new("Connectors/Revit/Speckle.Connectors.Revit2023", "net48"),
         new("Connectors/Revit/Speckle.Connectors.Revit2024", "net48"),
-        new("Connectors/Revit/Speckle.Connectors.Revit2025", "net8.0-windows")
+        new("Connectors/Revit/Speckle.Connectors.Revit2025", "net8.0-windows"),
+        new("Connectors/Revit/Speckle.Connectors.Revit2026", "net8.0-windows")
       ]
     ),
     new(
@@ -29,13 +30,50 @@ public static class Consts
         new("Connectors/Autocad/Speckle.Connectors.Autocad2022", "net48"),
         new("Connectors/Autocad/Speckle.Connectors.Autocad2023", "net48"),
         new("Connectors/Autocad/Speckle.Connectors.Autocad2024", "net48"),
-        new("Connectors/Autocad/Speckle.Connectors.Autocad2025", "net8.0-windows")
+        new("Connectors/Autocad/Speckle.Connectors.Autocad2025", "net8.0-windows"),
+        new("Connectors/Autocad/Speckle.Connectors.Autocad2026", "net8.0-windows")
+      ]
+    ),
+    new(
+      "civil3d",
+      [
+        new("Connectors/Autocad/Speckle.Connectors.Civil3d2022", "net48"),
+        new("Connectors/Autocad/Speckle.Connectors.Civil3d2023", "net48"),
+        new("Connectors/Autocad/Speckle.Connectors.Civil3d2024", "net48"),
+        new("Connectors/Autocad/Speckle.Connectors.Civil3d2025", "net8.0-windows"),
+        new("Connectors/Autocad/Speckle.Connectors.Civil3d2026", "net8.0-windows")
+      ]
+    ),
+    new(
+      "navisworks",
+      [
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2020", "net48"),
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2021", "net48"),
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2022", "net48"),
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2023", "net48"),
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2024", "net48"),
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2025", "net48"),
+        new("Connectors/Navisworks/Speckle.Connectors.Navisworks2026", "net48")
+      ]
+    ),
+    new(
+      "teklastructures",
+      [
+        new("Connectors/Tekla/Speckle.Connector.Tekla2023", "net48"),
+        new("Connectors/Tekla/Speckle.Connector.Tekla2024", "net48")
+      ]
+    ),
+    new(
+      "etabs",
+      [
+        new("Connectors/CSi/Speckle.Connectors.ETABS21", "net48"),
+        new("Connectors/CSi/Speckle.Connectors.ETABS22", "net8.0-windows"),
       ]
     )
   };
 }
 
-public readonly record struct InstallerProject(string HostAppSlug, IReadOnlyList<InstallerAsset> Projects)
+public readonly record struct ProjectGroup(string HostAppSlug, IReadOnlyList<InstallerAsset> Projects)
 {
   public override string ToString() => $"{HostAppSlug}";
 }

Build/Github.cs

@@ -28,11 +28,11 @@ public static class Github
       Content = content
     };
     request.Headers.Add("X-GitHub-Api-Version", "2022-11-28");
-    var response = await client.SendAsync(request).ConfigureAwait(false);
+    var response = await client.SendAsync(request);
     if (!response.IsSuccessStatusCode)
     {
       throw new InvalidOperationException(
-        $"{response.StatusCode} {response.ReasonPhrase} {await response.Content.ReadAsStringAsync().ConfigureAwait(false)}"
+        $"{response.StatusCode} {response.ReasonPhrase} {await response.Content.ReadAsStringAsync()}"
       );
     }
   }

Build/Program.cs

@@ -7,15 +7,18 @@ using static SimpleExec.Command;
 const string CLEAN = "clean";
 const string RESTORE = "restore";
 const string BUILD = "build";
+const string BUILD_LINUX = "build-linux";
 const string TEST = "test";
 const string TEST_ONLY = "test-only";
 const string FORMAT = "format";
 const string ZIP = "zip";
-const string VERSION = "version";
 const string RESTORE_TOOLS = "restore-tools";
-const string BUILD_SERVER_VERSION = "build-server-version";
 const string CLEAN_LOCKS = "clean-locks";
 const string CHECK_SOLUTIONS = "check-solutions";
+const string GEN_SOLUTIONS = "generate-solutions";
+const string DEEP_CLEAN = "deep-clean";
+const string DEEP_CLEAN_LOCAL = "deep-clean-local";
+const string DETECT_AFFECTED = "detect-affected";
 
 //need to pass arguments
 /*var arguments = new List<string>();
@@ -26,17 +29,67 @@ if (args.Length > 1)
   //arguments = arguments.Skip(1).ToList();
 }*/
 
+void Restore(string solution)
+{
+  Console.WriteLine();
+  Console.WriteLine($"Restoring solution '{solution}'");
+  Console.WriteLine();
+  Run("dotnet", $"restore \".\\{solution}\" --no-cache");
+}
+void DeleteFiles(string pattern)
+{
+  foreach (var f in Glob.Files(".", pattern))
+  {
+    Console.WriteLine("Found and will delete: " + f);
+    File.Delete(f);
+  }
+}
+void DeleteDirectories(string pattern)
+{
+  foreach (var f in Glob.Directories(".", pattern))
+  {
+    if (f.StartsWith("Build"))
+    {
+      continue;
+    }
+    Console.WriteLine("Found and will delete: " + f);
+    Directory.Delete(f, true);
+  }
+}
+
+void CleanSolution(string solution, string configuration)
+{
+  Console.WriteLine("Cleaning solution: " + solution);
+
+  DeleteDirectories("**/bin");
+  DeleteDirectories("**/obj");
+  DeleteFiles("**/*.lock.json");
+  Restore(solution);
+}
+
 Target(
   CLEAN_LOCKS,
+  Consts.Solutions,
+  s =>
+  {
+    DeleteFiles("**/*.lock.json");
+    Restore(s);
+  }
+);
+
+Target(
+  DEEP_CLEAN,
+  Consts.Solutions,
+  s =>
+  {
+    CleanSolution(s, "debug");
+  }
+);
+Target(
+  DEEP_CLEAN_LOCAL,
   () =>
   {
-    foreach (var f in Glob.Files(".", "**/*.lock.json"))
-    {
-      Console.WriteLine("Found and will delete: " + f);
-      File.Delete(f);
-    }
-    Console.WriteLine("Running restore now.");
-    Run("dotnet", "restore .\\Speckle.Connectors.sln --no-cache");
+    CleanSolution("Local.sln", "Local");
   }
 );
 
@@ -66,17 +119,6 @@ Target(
   }
 );
 
-Target(
-  VERSION,
-  async () =>
-  {
-    var (output, _) = await ReadAsync("dotnet", "minver -v w").ConfigureAwait(false);
-    output = output.Trim();
-    Console.WriteLine($"Version: {output}");
-    Run("echo", $"\"version={output}\" >> $GITHUB_OUTPUT");
-  }
-);
-
 Target(
   RESTORE_TOOLS,
   () =>
@@ -85,6 +127,18 @@ Target(
   }
 );
 
+Target(
+  DETECT_AFFECTED,
+  DependsOn(RESTORE_TOOLS),
+  async () =>
+  {
+    foreach (var group in await Affected.GetAffectedProjectGroups())
+    {
+      Console.WriteLine("Affected project group being built: " + group.HostAppSlug);
+    }
+  }
+);
+
 Target(
   FORMAT,
   DependsOn(RESTORE_TOOLS),
@@ -96,20 +150,14 @@ Target(
 
 Target(
   RESTORE,
-  DependsOn(FORMAT),
+  DependsOn(FORMAT, DETECT_AFFECTED),
   Consts.Solutions,
-  s =>
+  async s =>
   {
-    Run("dotnet", $"restore {s} --locked-mode");
-  }
-);
-
-Target(
-  BUILD_SERVER_VERSION,
-  DependsOn(RESTORE_TOOLS),
-  () =>
-  {
-    Run("dotnet", "tool run dotnet-gitversion /output json /output buildserver");
+    var version = await Versions.ComputeVersion();
+    var fileVersion = await Versions.ComputeFileVersion();
+    Console.WriteLine($"Restoring: {s} - Version: {version} & {fileVersion}");
+    await RunAsync("dotnet", $"restore \"{s}\" --locked-mode");
   }
 );
 
@@ -117,37 +165,66 @@ Target(
   BUILD,
   DependsOn(RESTORE),
   Consts.Solutions,
-  s =>
+  async s =>
   {
-    var version = Environment.GetEnvironmentVariable("GitVersion_FullSemVer") ?? "3.0.0-localBuild";
-    var fileVersion = Environment.GetEnvironmentVariable("GitVersion_AssemblySemFileVer") ?? "3.0.0.0";
-    Console.WriteLine($"Version: {version} & {fileVersion}");
-    Run("dotnet", $"build {s} -c Release --no-restore -p:Version={version} -p:FileVersion={fileVersion} -v:m");
+    var version = await Versions.ComputeVersion();
+    var fileVersion = await Versions.ComputeFileVersion();
+    Console.WriteLine($"Restoring: {s} - Version: {version} & {fileVersion}");
+    await RunAsync(
+      "dotnet",
+      $"build \"{s}\" -c Release --no-restore -warnaserror -p:Version={version} -p:FileVersion={fileVersion} -v:m"
+    );
   }
 );
 
 Target(CHECK_SOLUTIONS, Solutions.CompareConnectorsToLocal);
+Target(GEN_SOLUTIONS, Solutions.GenerateSolutions);
 
 Target(
   TEST,
   DependsOn(BUILD, CHECK_SOLUTIONS),
-  Glob.Files(".", "**/*.Tests.csproj"),
-  file =>
+  async () =>
   {
-    Run("dotnet", $"test {file} -c Release --no-build --no-restore --verbosity=minimal");
+    foreach (var s in await Affected.GetTestProjects())
+    {
+      await RunAsync("dotnet", $"test \"{s}\" -c Release --no-build --no-restore --verbosity=minimal");
+    }
   }
 );
 
+//all tests on purpose
 Target(
   TEST_ONLY,
   DependsOn(FORMAT),
   Glob.Files(".", "**/*.Tests.csproj"),
   file =>
   {
-    Run("dotnet", $"restore {file} --locked-mode");
+    Run("dotnet", $"build \"{file}\" -c Release --no-incremental");
     Run(
       "dotnet",
-      $"test {file} -c Release --no-restore --verbosity=minimal  /p:AltCover=true /p:AltCoverAttributeFilter=ExcludeFromCodeCoverage /p:AltCoverVerbosity=Warning"
+      $"test \"{file}\" -c Release --no-build --verbosity=minimal /p:AltCover=true /p:AltCoverAttributeFilter=ExcludeFromCodeCoverage /p:AltCoverVerbosity=Warning"
+    );
+  }
+);
+
+Target(
+  BUILD_LINUX,
+  DependsOn(FORMAT),
+  Glob.Files(".", "**/Speckle.Importers.Ifc.csproj"),
+  async file =>
+  {
+    await RunAsync("dotnet", $"restore \"{file}\" --locked-mode");
+    var version = await Versions.ComputeVersion();
+    var fileVersion = await Versions.ComputeFileVersion();
+    Console.WriteLine($"Version: {version} & {fileVersion}");
+    await RunAsync(
+      "dotnet",
+      $"build \"{file}\" -c Release --no-restore -warnaserror -p:Version={version} -p:FileVersion={fileVersion} -v:m"
+    );
+
+    await RunAsync(
+      "dotnet",
+      $"pack \"{file}\" -c Release -o output --no-build -p:Version={version} -p:FileVersion={fileVersion} -v:m"
     );
   }
 );
@@ -155,47 +232,56 @@ Target(
 Target(
   ZIP,
   DependsOn(TEST),
-  Consts.InstallerManifests,
-  x =>
+  async () =>
   {
-    var outputDir = Path.Combine(".", "output");
-    var slugDir = Path.Combine(outputDir, x.HostAppSlug);
-
-    Directory.CreateDirectory(outputDir);
-    Directory.CreateDirectory(slugDir);
-
-    foreach (var asset in x.Projects)
+    var version = await Versions.ComputeVersion();
+    var fileVersion = await Versions.ComputeFileVersion();
+    foreach (var group in await Affected.GetAffectedProjectGroups())
     {
-      var fullPath = Path.Combine(".", asset.ProjectPath, "bin", "Release", asset.TargetName);
-      if (!Directory.Exists(fullPath))
+      Console.WriteLine($"Zipping: {group.HostAppSlug} as {version}");
+      var outputDir = Path.Combine(".", "output");
+      var slugDir = Path.Combine(outputDir, group.HostAppSlug);
+
+      Directory.CreateDirectory(outputDir);
+      Directory.CreateDirectory(slugDir);
+
+      foreach (var asset in group.Projects)
       {
-        throw new InvalidOperationException("Could not find: " + fullPath);
+        var fullPath = Path.Combine(".", asset.ProjectPath, "bin", "Release", asset.TargetName);
+        if (!Directory.Exists(fullPath))
+        {
+          throw new InvalidOperationException("Could not find: " + fullPath);
+        }
+
+        var assetName = Path.GetFileName(asset.ProjectPath);
+        var connectorDir = Path.Combine(slugDir, assetName);
+
+        Directory.CreateDirectory(connectorDir);
+        foreach (var directory in Directory.EnumerateDirectories(fullPath, "*", SearchOption.AllDirectories))
+        {
+          Directory.CreateDirectory(directory.Replace(fullPath, connectorDir));
+        }
+
+        foreach (var file in Directory.EnumerateFiles(fullPath, "*", SearchOption.AllDirectories))
+        {
+          Console.WriteLine(file);
+          File.Copy(file, file.Replace(fullPath, connectorDir), true);
+        }
       }
 
-      var assetName = Path.GetFileName(asset.ProjectPath);
-      var connectorDir = Path.Combine(slugDir, assetName);
-
-      Directory.CreateDirectory(connectorDir);
-      foreach (var directory in Directory.EnumerateDirectories(fullPath, "*", SearchOption.AllDirectories))
-      {
-        Directory.CreateDirectory(directory.Replace(fullPath, connectorDir));
-      }
-
-      foreach (var file in Directory.EnumerateFiles(fullPath, "*", SearchOption.AllDirectories))
-      {
-        Console.WriteLine(file);
-        File.Copy(file, file.Replace(fullPath, connectorDir), true);
-      }
+      var outputPath = Path.Combine(outputDir, $"{group.HostAppSlug}.zip");
+      File.Delete(outputPath);
+      Console.WriteLine($"Zipping: '{slugDir}' to '{outputPath}'");
+      ZipFile.CreateFromDirectory(slugDir, outputPath);
     }
 
-    var outputPath = Path.Combine(outputDir, $"{x.HostAppSlug}.zip");
-    File.Delete(outputPath);
-    Console.WriteLine($"Zipping: '{slugDir}' to '{outputPath}'");
-    ZipFile.CreateFromDirectory(slugDir, outputPath);
-    // Directory.Delete(slugDir, true);
+    string githubEnv = Environment.GetEnvironmentVariable("GITHUB_ENV") ?? "Unset";
+    Console.WriteLine($"GITHUB_ENV: {githubEnv}");
+    File.AppendAllText(githubEnv, $"SEMVER={version}{Environment.NewLine}");
+    File.AppendAllText(githubEnv, $"FILE_VERSION={fileVersion}{Environment.NewLine}");
   }
 );
 
-Target("default", DependsOn(FORMAT, ZIP), () => Console.WriteLine("Done!"));
+Target("default", DependsOn(TEST), () => Console.WriteLine("Done!"));
 
 await RunTargetsAndExitAsync(args).ConfigureAwait(true);

Build/Solutions.cs

@@ -1,4 +1,6 @@
 using Microsoft.Build.Construction;
+using Microsoft.VisualStudio.SolutionPersistence.Model;
+using Microsoft.VisualStudio.SolutionPersistence.Serializer;
 
 namespace Build;
 
@@ -45,7 +47,7 @@ public static class Solutions
 
     CheckAndRemoveKnown("Speckle.Objects");
     CheckAndRemoveKnown("Speckle.Sdk");
-    CheckAndRemoveKnown("Speckle.Sdk.Logging");
+    CheckAndRemoveKnown("Speckle.Sdk.Dependencies");
     if (localProjects.Count != 0)
     {
       throw new InvalidOperationException(
@@ -53,4 +55,53 @@ public static class Solutions
       );
     }
   }
+
+  public static async Task GenerateSolutions()
+  {
+    await GenerateLocalSlnx();
+    foreach (var group in Consts.ProjectGroups)
+    {
+      var path = group.Projects[0].ProjectPath.Split('/');
+      var folder = $"/{path[0]}/{path[1]}/";
+      await GenerateConnector(group.HostAppSlug, folder);
+    }
+  }
+
+  public static async Task GenerateLocalSlnx()
+  {
+    var connectors = await GetFullSlnx();
+    connectors.AddProject("..\\speckle-sharp-sdk\\src\\Speckle.Objects\\Speckle.Objects.csproj");
+    connectors.AddProject("..\\speckle-sharp-sdk\\src\\Speckle.Sdk\\Speckle.Sdk.csproj");
+    connectors.AddProject("..\\speckle-sharp-sdk\\src\\Speckle.Sdk.Dependencies\\Speckle.Sdk.Dependencies.csproj");
+    var sln = Path.Combine("C:\\Users\\adam\\Git\\speckle-sharp-connectors", "Local.slnx");
+    await SolutionSerializers.SlnXml.SaveAsync(sln, connectors, default);
+    sln = Path.Combine("C:\\Users\\adam\\Git\\speckle-sharp-connectors", "Local.sln");
+    await SolutionSerializers.SlnFileV12.SaveAsync(sln, connectors, default);
+  }
+
+  public static async Task GenerateConnector(string slug, string folder)
+  {
+    slug = string.Concat(slug[0].ToString().ToUpper(), slug.AsSpan(1));
+    var connectors = await GetFullSlnx();
+    var foldersToRemove = connectors
+      .SolutionFolders.Where(x =>
+        //need base folder
+        !x.Path.Equals("/Connectors/")
+        //don't grab all
+        && (x.Path.StartsWith("/Connectors/") && !x.Path.StartsWith(folder))
+      )
+      .ToList();
+    foreach (var folderToRemove in foldersToRemove)
+    {
+      connectors.RemoveFolder(folderToRemove);
+    }
+    var sln = Path.Combine("C:\\Users\\adam\\Git\\speckle-sharp-connectors", $"Speckle.{slug}.slnx");
+    await SolutionSerializers.SlnXml.SaveAsync(sln, connectors, default);
+  }
+
+  public static async Task<SolutionModel> GetFullSlnx()
+  {
+    var connectorsSln = Path.Combine("C:\\Users\\adam\\Git\\speckle-sharp-connectors", "Speckle.Connectors.slnx");
+    return await SolutionSerializers.SlnXml.OpenAsync(connectorsSln, default);
+  }
 }

Build/Versions.cs

@@ -0,0 +1,79 @@
+using Semver;
+using static SimpleExec.Command;
+
+namespace Build;
+
+public static class Versions
+{
+  private static string? s_currentTag;
+  private static SemVersion? s_currentVersion;
+
+  public static async Task<string> GetCurrentTag()
+  {
+    if (s_currentTag is not null)
+    {
+      return s_currentTag;
+    }
+    //finds current tag or makes one
+    var (currentTag, _) = await ReadAsync("git", "describe --tags");
+    currentTag = currentTag.Trim();
+    s_currentTag = currentTag;
+    return s_currentTag;
+  }
+
+  public static async Task<SemVersion> ComputeVersion()
+  {
+    if (s_currentVersion is not null)
+    {
+      return s_currentVersion;
+    }
+    var currentTag = await GetCurrentTag();
+
+    if (!SemVersion.TryParse(currentTag, SemVersionStyles.AllowLowerV, out var currentVersion))
+    {
+      throw new InvalidOperationException($"Could not parse version: '{currentTag}'");
+    }
+    s_currentVersion = currentVersion;
+    return s_currentVersion;
+  }
+
+  private static string? s_currentFileVersion;
+
+  public static async Task<string> ComputeFileVersion()
+  {
+    if (s_currentFileVersion is not null)
+    {
+      return s_currentFileVersion;
+    }
+    var currentVersion = await ComputeVersion();
+    s_currentFileVersion = currentVersion.WithoutPrereleaseOrMetadata() + ".0";
+    return s_currentFileVersion;
+  }
+
+  public static async Task<string> GetPreviousTag(string currentTag)
+  {
+    //finds a tag starting with current tag and adds no abbrevation
+    var (lastTag, _) = await ReadAsync("git", $"describe --abbrev=0 --tags {currentTag}^");
+    lastTag = lastTag.Trim();
+
+    return lastTag;
+  }
+
+  private static SemVersion? s_previousVersion;
+
+  public static async Task<SemVersion> ComputePreviousVersion(string currentTag)
+  {
+    if (s_previousVersion is not null)
+    {
+      return s_previousVersion;
+    }
+    var lastTag = await GetPreviousTag(currentTag);
+
+    if (!SemVersion.TryParse(lastTag, SemVersionStyles.AllowLowerV, out var lastVersion))
+    {
+      throw new InvalidOperationException($"Could not parse version: '{lastTag}'");
+    }
+    s_previousVersion = lastVersion;
+    return s_previousVersion;
+  }
+}

Build/packages.lock.json

@@ -16,18 +16,25 @@
       },
       "Microsoft.Build": {
         "type": "Direct",
-        "requested": "[17.10.4, )",
-        "resolved": "17.10.4",
-        "contentHash": "ZmGA8vhVXFzC4oo48ybQKlEybVKd0Ntfdr+Enqrn5ES1R6e/krIK9hLk0W33xuT0/G6QYd3YdhJZh+Xle717Ag==",
+        "requested": "[17.11.4, )",
+        "resolved": "17.11.4",
+        "contentHash": "UMC7DfeFEHY2GGHHaghybUuUlLaByFHEFudR2PehMgDBuRuLAUePp1iaa4eFtVzepRzMtIbeSCVJCzzX3NV2Gg==",
         "dependencies": {
-          "Microsoft.Build.Framework": "17.10.4",
-          "Microsoft.NET.StringTools": "17.10.4",
+          "Microsoft.Build.Framework": "17.11.4",
+          "Microsoft.NET.StringTools": "17.11.4",
           "System.Collections.Immutable": "8.0.0",
           "System.Configuration.ConfigurationManager": "8.0.0",
           "System.Reflection.Metadata": "8.0.0",
-          "System.Reflection.MetadataLoadContext": "8.0.0",
-          "System.Security.Principal.Windows": "5.0.0",
-          "System.Threading.Tasks.Dataflow": "8.0.0"
+          "System.Reflection.MetadataLoadContext": "8.0.0"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
         }
       },
       "Microsoft.SourceLink.GitHub": {
@@ -40,12 +47,27 @@
           "Microsoft.SourceLink.Common": "8.0.0"
         }
       },
+      "Microsoft.VisualStudio.SolutionPersistence": {
+        "type": "Direct",
+        "requested": "[1.0.52, )",
+        "resolved": "1.0.52",
+        "contentHash": "oNv2JtYXhpdJrX63nibx1JT3uCESOBQ1LAk7Dtz/sr0+laW0KRM6eKp4CZ3MHDR2siIkKsY8MmUkeP5DKkQQ5w=="
+      },
       "PolySharp": {
         "type": "Direct",
         "requested": "[1.14.1, )",
         "resolved": "1.14.1",
         "contentHash": "mOOmFYwad3MIOL14VCjj02LljyF1GNw1wP0YVlxtcPvqdxjGGMNdNJJxHptlry3MOd8b40Flm8RPOM8JOlN2sQ=="
       },
+      "Semver": {
+        "type": "Direct",
+        "requested": "[3.0.0, )",
+        "resolved": "3.0.0",
+        "contentHash": "9jZCicsVgTebqkAujRWtC9J1A5EQVlu0TVKHcgoCuv345ve5DYf4D1MjhKEnQjdRZo6x/vdv6QQrYFs7ilGzLA==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "5.0.1"
+        }
+      },
       "SimpleExec": {
         "type": "Direct",
         "requested": "[12.0.0, )",
@@ -60,18 +82,28 @@
       },
       "Microsoft.Build.Framework": {
         "type": "Transitive",
-        "resolved": "17.10.4",
-        "contentHash": "4qXCwNOXBR1dyCzuks9SwTwFJQO/xmf2wcMislotDWJu7MN/r3xDNoU8Ae5QmKIHPaLG1xmfDkYS7qBVzxmeKw=="
+        "resolved": "17.11.4",
+        "contentHash": "u28uDihlqxtt8h2dL1ZJOZ7TRkxBK+HGr+3FgQpILVo7Q7gErkw8mYW9R+RM5PtxvZTdYb/4MWDL66vdIsANBQ=="
       },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
       },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "5.0.1",
+        "contentHash": "5WPSmL4YeP7eW+Vc8XZ4DwjYWBAiSwDV9Hm63JJWcz1Ie3Xjv4KuJXzgCstj48LkLfVCYa7mLcx7y+q6yqVvtw=="
+      },
       "Microsoft.NET.StringTools": {
         "type": "Transitive",
-        "resolved": "17.10.4",
-        "contentHash": "wyABaqY+IHCMMSTQmcc3Ca6vbmg5BaEPgicnEgpll+4xyWZWlkQqUwafweUd9VAhBb4jqplMl6voUHQ6yfdUcg=="
+        "resolved": "17.11.4",
+        "contentHash": "mudqUHhNpeqIdJoUx2YDWZO/I9uEDYVowan89R6wsomfnUJQk6HteoQTlNjZDixhT2B4IXMkMtgZtoceIjLRmA=="
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
@@ -118,17 +150,6 @@
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "+TUFINV2q2ifyXauQXRwy4CiBhqvDEDZeVJU7qfxya4aRYOKzVBpN+4acx25VcPB9ywUN6C0n8drWl110PhZEg=="
-      },
-      "System.Security.Principal.Windows": {
-        "type": "Transitive",
-        "resolved": "5.0.0",
-        "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA=="
-      },
-      "System.Threading.Tasks.Dataflow": {
-        "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "7V0I8tPa9V7UxMx/+7DIwkhls5ouaEMQx6l/GwGm1Y8kJQ61On9B/PxCXFLbgu5/C47g0BP2CUYs+nMv1+Oaqw=="
       }
     }
   }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Bindings/ArcGISReceiveBinding.cs

@@ -1,12 +1,17 @@
+using ArcGIS.Desktop.Core;
+using ArcGIS.Desktop.Mapping;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Speckle.Autofac.DependencyInjection;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Operations;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Logging;
 using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card;
-using Speckle.Connectors.Utils.Cancellation;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Converters.ArcGIS3;
+using Speckle.Converters.ArcGIS3.Utils;
+using Speckle.Converters.Common;
 using Speckle.Sdk;
 
 namespace Speckle.Connectors.ArcGIS.Bindings;
@@ -14,31 +19,34 @@ namespace Speckle.Connectors.ArcGIS.Bindings;
 public sealed class ArcGISReceiveBinding : IReceiveBinding
 {
   public string Name { get; } = "receiveBinding";
-  private readonly CancellationManager _cancellationManager;
+  private readonly ICancellationManager _cancellationManager;
   private readonly DocumentModelStore _store;
-  private readonly IUnitOfWorkFactory _unitOfWorkFactory;
+  private readonly IServiceProvider _serviceProvider;
   private readonly IOperationProgressManager _operationProgressManager;
   private readonly ILogger<ArcGISReceiveBinding> _logger;
+  private readonly IArcGISConversionSettingsFactory _arcGISConversionSettingsFactory;
 
   private ReceiveBindingUICommands Commands { get; }
-  public IBridge Parent { get; }
+  public IBrowserBridge Parent { get; }
 
   public ArcGISReceiveBinding(
     DocumentModelStore store,
-    IBridge parent,
-    CancellationManager cancellationManager,
-    IUnitOfWorkFactory unitOfWorkFactory,
+    IBrowserBridge parent,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
     IOperationProgressManager operationProgressManager,
-    ILogger<ArcGISReceiveBinding> logger
+    ILogger<ArcGISReceiveBinding> logger,
+    IArcGISConversionSettingsFactory arcGisConversionSettingsFactory
   )
   {
     _store = store;
     _cancellationManager = cancellationManager;
     Parent = parent;
     Commands = new ReceiveBindingUICommands(parent);
-    _unitOfWorkFactory = unitOfWorkFactory;
+    _serviceProvider = serviceProvider;
     _operationProgressManager = operationProgressManager;
     _logger = logger;
+    _arcGISConversionSettingsFactory = arcGisConversionSettingsFactory;
   }
 
   public async Task Receive(string modelCardId)
@@ -52,27 +60,28 @@ public sealed class ArcGISReceiveBinding : IReceiveBinding
         throw new InvalidOperationException("No download model card was found.");
       }
 
-      CancellationToken cancellationToken = _cancellationManager.InitCancellationTokenSource(modelCardId);
-
-      using IUnitOfWork<ReceiveOperation> unitOfWork = _unitOfWorkFactory.Resolve<ReceiveOperation>();
-
+      using var cancellationItem = _cancellationManager.GetCancellationItem(modelCardId);
+      using var scope = _serviceProvider.CreateScope();
+      scope
+        .ServiceProvider.GetRequiredService<IConverterSettingsStore<ArcGISConversionSettings>>()
+        .Initialize(
+          _arcGISConversionSettingsFactory.Create(
+            Project.Current,
+            MapView.Active.Map,
+            new CRSoffsetRotation(MapView.Active.Map)
+          )
+        );
       // Receive host objects
-      var receiveOperationResults = await unitOfWork
-        .Service.Execute(
+      var receiveOperationResults = await scope
+        .ServiceProvider.GetRequiredService<ReceiveOperation>()
+        .Execute(
           modelCard.GetReceiveInfo("ArcGIS"), // POC: get host app name from settings? same for GetSendInfo
-          cancellationToken,
-          (status, progress) =>
-            _operationProgressManager.SetModelProgress(
-              Parent,
-              modelCardId,
-              new ModelCardProgress(modelCardId, status, progress),
-              cancellationToken
-            )
-        )
-        .ConfigureAwait(false);
+          _operationProgressManager.CreateOperationProgressEventHandler(Parent, modelCardId, cancellationItem.Token),
+          cancellationItem.Token
+        );
 
       modelCard.BakedObjectIds = receiveOperationResults.BakedObjectIds.ToList();
-      Commands.SetModelReceiveResult(
+      await Commands.SetModelReceiveResult(
         modelCardId,
         receiveOperationResults.BakedObjectIds,
         receiveOperationResults.ConversionResults
@@ -88,7 +97,7 @@ public sealed class ArcGISReceiveBinding : IReceiveBinding
     catch (Exception ex) when (!ex.IsFatal()) // UX reasons - we will report operation exceptions as model card error. We may change this later when we have more exception documentation
     {
       _logger.LogModelCardHandledError(ex);
-      Commands.SetModelError(modelCardId, ex);
+      await Commands.SetModelError(modelCardId, ex);
     }
   }
 

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Bindings/ArcGISSelectionBinding.cs

@@ -1,5 +1,6 @@
 using ArcGIS.Desktop.Mapping;
 using ArcGIS.Desktop.Mapping.Events;
+using Speckle.Connectors.ArcGIS.Utils;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
 
@@ -7,17 +8,22 @@ namespace Speckle.Connectors.ArcGIS.Bindings;
 
 public class ArcGISSelectionBinding : ISelectionBinding
 {
+  private readonly MapMembersUtils _mapMemberUtils;
   public string Name => "selectionBinding";
-  public IBridge Parent { get; }
+  public IBrowserBridge Parent { get; }
 
-  public ArcGISSelectionBinding(IBridge parent)
+  public ArcGISSelectionBinding(
+    IBrowserBridge parent,
+    MapMembersUtils mapMemberUtils,
+    ITopLevelExceptionHandler topLevelExceptionHandler
+  )
   {
+    _mapMemberUtils = mapMemberUtils;
     Parent = parent;
-    var topLevelHandler = parent.TopLevelExceptionHandler;
 
     // example: https://github.com/Esri/arcgis-pro-sdk-community-samples/blob/master/Map-Authoring/QueryBuilderControl/DefinitionQueryDockPaneViewModel.cs
     // MapViewEventArgs args = new(MapView.Active);
-    TOCSelectionChangedEvent.Subscribe(_ => topLevelHandler.CatchUnhandled(OnSelectionChanged), true);
+    TOCSelectionChangedEvent.Subscribe(_ => topLevelExceptionHandler.CatchUnhandled(OnSelectionChanged), true);
   }
 
   private void OnSelectionChanged()
@@ -50,17 +56,8 @@ public class ArcGISSelectionBinding : ISelectionBinding
     selectedMembers.AddRange(mapView.GetSelectedStandaloneTables());
 
     List<MapMember> allNestedMembers = new();
-    foreach (MapMember member in selectedMembers)
-    {
-      if (member is GroupLayer group)
-      {
-        GetLayersFromGroup(group, allNestedMembers);
-      }
-      else
-      {
-        allNestedMembers.Add(member);
-      }
-    }
+    var layerMapMembers = _mapMemberUtils.UnpackMapLayers(selectedMembers);
+    allNestedMembers.AddRange(layerMapMembers);
 
     List<string> objectTypes = allNestedMembers
       .Select(o => o.GetType().ToString().Split(".").Last())

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Bindings/ArcGISSendBinding.cs

@@ -1,14 +1,19 @@
 using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using ArcGIS.Core.Data;
+using ArcGIS.Desktop.Core;
 using ArcGIS.Desktop.Editing.Events;
 using ArcGIS.Desktop.Framework.Threading.Tasks;
 using ArcGIS.Desktop.Mapping;
 using ArcGIS.Desktop.Mapping.Events;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Speckle.Autofac.DependencyInjection;
 using Speckle.Connectors.ArcGIS.Filters;
 using Speckle.Connectors.ArcGIS.Utils;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Exceptions;
@@ -17,9 +22,9 @@ using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card;
 using Speckle.Connectors.DUI.Models.Card.SendFilter;
 using Speckle.Connectors.DUI.Settings;
-using Speckle.Connectors.Utils.Caching;
-using Speckle.Connectors.Utils.Cancellation;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Converters.ArcGIS3;
+using Speckle.Converters.ArcGIS3.Utils;
+using Speckle.Converters.Common;
 using Speckle.Sdk;
 using Speckle.Sdk.Common;
 
@@ -29,17 +34,19 @@ public sealed class ArcGISSendBinding : ISendBinding
 {
   public string Name => "sendBinding";
   public SendBindingUICommands Commands { get; }
-  public IBridge Parent { get; }
+  public IBrowserBridge Parent { get; }
 
   private readonly DocumentModelStore _store;
-  private readonly IUnitOfWorkFactory _unitOfWorkFactory; // POC: unused? :D
+  private readonly IServiceProvider _serviceProvider;
   private readonly List<ISendFilter> _sendFilters;
-  private readonly CancellationManager _cancellationManager;
+  private readonly ICancellationManager _cancellationManager;
   private readonly ISendConversionCache _sendConversionCache;
   private readonly IOperationProgressManager _operationProgressManager;
   private readonly ILogger<ArcGISSendBinding> _logger;
   private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
-  private readonly MapMembersUtils _mapMemberUtils;
+  private readonly IArcGISConversionSettingsFactory _arcGISConversionSettingsFactory;
+  private readonly IThreadContext _threadContext;
+  private readonly ISpeckleApplication _speckleApplication;
 
   /// <summary>
   /// Used internally to aggregate the changed objects' id. Note we're using a concurrent dictionary here as the expiry check method is not thread safe, and this was causing problems. See:
@@ -51,28 +58,36 @@ public sealed class ArcGISSendBinding : ISendBinding
 
   private List<FeatureLayer> SubscribedLayers { get; set; } = new();
   private List<StandaloneTable> SubscribedTables { get; set; } = new();
+  private readonly MapMembersUtils _mapMemberUtils;
 
   public ArcGISSendBinding(
     DocumentModelStore store,
-    IBridge parent,
+    IBrowserBridge parent,
     IEnumerable<ISendFilter> sendFilters,
-    IUnitOfWorkFactory unitOfWorkFactory,
-    CancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
+    ICancellationManager cancellationManager,
     ISendConversionCache sendConversionCache,
     IOperationProgressManager operationProgressManager,
     ILogger<ArcGISSendBinding> logger,
-    MapMembersUtils mapMemberUtils
+    IArcGISConversionSettingsFactory arcGisConversionSettingsFactory,
+    MapMembersUtils mapMemberUtils,
+    IThreadContext threadContext,
+    ISpeckleApplication speckleApplication,
+    ITopLevelExceptionHandler topLevelExceptionHandler
   )
   {
     _store = store;
-    _unitOfWorkFactory = unitOfWorkFactory;
+    _serviceProvider = serviceProvider;
     _sendFilters = sendFilters.ToList();
     _cancellationManager = cancellationManager;
     _sendConversionCache = sendConversionCache;
     _operationProgressManager = operationProgressManager;
     _logger = logger;
-    _topLevelExceptionHandler = parent.TopLevelExceptionHandler;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
+    _arcGISConversionSettingsFactory = arcGisConversionSettingsFactory;
     _mapMemberUtils = mapMemberUtils;
+    _threadContext = threadContext;
+    _speckleApplication = speckleApplication;
 
     Parent = parent;
     Commands = new SendBindingUICommands(parent);
@@ -83,30 +98,48 @@ public sealed class ArcGISSendBinding : ISendBinding
     };
   }
 
+  private void OnDocumentStoreChangedEvent(object _) => _sendConversionCache.ClearCache();
+
   private void SubscribeToArcGISEvents()
   {
     LayersRemovedEvent.Subscribe(
-      a => _topLevelExceptionHandler.CatchUnhandled(() => GetIdsForLayersRemovedEvent(a)),
+      a =>
+        _topLevelExceptionHandler.FireAndForget(
+          async () => await QueuedTask.Run(async () => await GetIdsForLayersRemovedEvent(a))
+        ),
       true
     );
 
     StandaloneTablesRemovedEvent.Subscribe(
-      a => _topLevelExceptionHandler.CatchUnhandled(() => GetIdsForStandaloneTablesRemovedEvent(a)),
+      a =>
+        _topLevelExceptionHandler.FireAndForget(
+          async () => await QueuedTask.Run(async () => await GetIdsForStandaloneTablesRemovedEvent(a))
+        ),
       true
     );
 
     MapPropertyChangedEvent.Subscribe(
-      a => _topLevelExceptionHandler.CatchUnhandled(() => GetIdsForMapPropertyChangedEvent(a)),
+      a =>
+        _topLevelExceptionHandler.FireAndForget(
+          async () => await QueuedTask.Run(async () => await GetIdsForMapPropertyChangedEvent(a))
+        ),
       true
     ); // Map units, CRS etc.
 
     MapMemberPropertiesChangedEvent.Subscribe(
-      a => _topLevelExceptionHandler.CatchUnhandled(() => GetIdsForMapMemberPropertiesChangedEvent(a)),
+      a =>
+        _topLevelExceptionHandler.FireAndForget(
+          async () => await QueuedTask.Run(async () => await GetIdsForMapMemberPropertiesChangedEvent(a))
+        ),
       true
     ); // e.g. Layer name
 
     ActiveMapViewChangedEvent.Subscribe(
-      _ => _topLevelExceptionHandler.CatchUnhandled(SubscribeToMapMembersDataSourceChange),
+      _ =>
+        _topLevelExceptionHandler.FireAndForget(async () =>
+        {
+          await QueuedTask.Run(SubscribeToMapMembersDataSourceChange);
+        }),
       true
     );
 
@@ -122,28 +155,24 @@ public sealed class ArcGISSendBinding : ISendBinding
 
   private void SubscribeToMapMembersDataSourceChange()
   {
-    var task = QueuedTask.Run(() =>
+    if (MapView.Active == null)
     {
-      if (MapView.Active == null)
-      {
-        return;
-      }
+      return;
+    }
 
-      // subscribe to layers
-      foreach (Layer layer in MapView.Active.Map.Layers)
+    // subscribe to layers
+    foreach (Layer layer in MapView.Active.Map.Layers)
+    {
+      if (layer is FeatureLayer featureLayer)
       {
-        if (layer is FeatureLayer featureLayer)
-        {
-          SubscribeToFeatureLayerDataSourceChange(featureLayer);
-        }
+        SubscribeToFeatureLayerDataSourceChange(featureLayer);
       }
-      // subscribe to tables
-      foreach (StandaloneTable table in MapView.Active.Map.StandaloneTables)
-      {
-        SubscribeToTableDataSourceChange(table);
-      }
-    });
-    task.Wait();
+    }
+    // subscribe to tables
+    foreach (StandaloneTable table in MapView.Active.Map.StandaloneTables)
+    {
+      SubscribeToTableDataSourceChange(table);
+    }
   }
 
   private void SubscribeToFeatureLayerDataSourceChange(FeatureLayer layer)
@@ -178,28 +207,31 @@ public sealed class ArcGISSendBinding : ISendBinding
   {
     RowCreatedEvent.Subscribe(
       (args) =>
-      {
-        OnRowChanged(args);
-      },
+        _topLevelExceptionHandler.FireAndForget(async () =>
+        {
+          await OnRowChanged(args);
+        }),
       layerTable
     );
     RowChangedEvent.Subscribe(
       (args) =>
-      {
-        OnRowChanged(args);
-      },
+        _topLevelExceptionHandler.FireAndForget(async () =>
+        {
+          await OnRowChanged(args);
+        }),
       layerTable
     );
     RowDeletedEvent.Subscribe(
       (args) =>
-      {
-        OnRowChanged(args);
-      },
+        _topLevelExceptionHandler.FireAndForget(async () =>
+        {
+          await OnRowChanged(args);
+        }),
       layerTable
     );
   }
 
-  private void OnRowChanged(RowChangedEventArgs args)
+  private async Task OnRowChanged(RowChangedEventArgs args)
   {
     if (args == null || MapView.Active == null)
     {
@@ -238,60 +270,38 @@ public sealed class ArcGISSendBinding : ISendBinding
       }
     }
 
-    RunExpirationChecks(false);
+    await RunExpirationChecks(false);
   }
 
-  private void GetIdsForLayersRemovedEvent(LayerEventsArgs args)
+  private async Task GetIdsForLayersRemovedEvent(LayerEventsArgs args)
   {
     foreach (Layer layer in args.Layers)
     {
       ChangedObjectIds[layer.URI] = 1;
     }
-    RunExpirationChecks(true);
+    await RunExpirationChecks(true);
   }
 
-  private void GetIdsForStandaloneTablesRemovedEvent(StandaloneTableEventArgs args)
+  private async Task GetIdsForStandaloneTablesRemovedEvent(StandaloneTableEventArgs args)
   {
     foreach (StandaloneTable table in args.Tables)
     {
       ChangedObjectIds[table.URI] = 1;
     }
-    RunExpirationChecks(true);
+    await RunExpirationChecks(true);
   }
 
-  private void AddChangedNestedObjectIds(GroupLayer group)
+  private async Task GetIdsForMapPropertyChangedEvent(MapPropertyChangedEventArgs args)
   {
-    ChangedObjectIds[group.URI] = 1;
-    foreach (var member in group.Layers)
+    foreach (Map map in args.Maps)
     {
-      if (member is GroupLayer subGroup)
-      {
-        AddChangedNestedObjectIds(subGroup);
-      }
-      else
+      List<MapMember> allMapMembers = _mapMemberUtils.GetAllMapMembers(map);
+      foreach (MapMember member in allMapMembers)
       {
         ChangedObjectIds[member.URI] = 1;
       }
     }
-  }
-
-  private void GetIdsForMapPropertyChangedEvent(MapPropertyChangedEventArgs args)
-  {
-    foreach (Map map in args.Maps)
-    {
-      foreach (MapMember member in map.Layers)
-      {
-        if (member is GroupLayer group)
-        {
-          AddChangedNestedObjectIds(group);
-        }
-        else
-        {
-          ChangedObjectIds[member.URI] = 1;
-        }
-      }
-    }
-    RunExpirationChecks(false);
+    await RunExpirationChecks(false);
   }
 
   private void GetIdsForLayersAddedEvent(LayerEventsArgs args)
@@ -313,7 +323,7 @@ public sealed class ArcGISSendBinding : ISendBinding
     }
   }
 
-  private void GetIdsForMapMemberPropertiesChangedEvent(MapMemberPropertiesChangedEventArgs args)
+  private async Task GetIdsForMapMemberPropertiesChangedEvent(MapMemberPropertiesChangedEventArgs args)
   {
     // don't subscribe to all events (e.g. expanding group, changing visibility etc.)
     bool validEvent = false;
@@ -341,7 +351,7 @@ public sealed class ArcGISSendBinding : ISendBinding
       {
         ChangedObjectIds[member.URI] = 1;
       }
-      RunExpirationChecks(false);
+      await RunExpirationChecks(false);
     }
   }
 
@@ -357,7 +367,7 @@ public sealed class ArcGISSendBinding : ISendBinding
   public async Task Send(string modelCardId)
   {
     //poc: dupe code between connectors
-    using var unitOfWork = _unitOfWorkFactory.Resolve<SendOperation<MapMember>>();
+
     try
     {
       if (_store.GetModelById(modelCardId) is not SenderModelCard modelCard)
@@ -366,59 +376,61 @@ public sealed class ArcGISSendBinding : ISendBinding
         throw new InvalidOperationException("No publish model card was found.");
       }
 
-      CancellationToken cancellationToken = _cancellationManager.InitCancellationTokenSource(modelCardId);
+      using var cancellationItem = _cancellationManager.GetCancellationItem(modelCardId);
 
-      var sendResult = await QueuedTask
-        .Run(async () =>
-        {
-          List<MapMember> mapMembers = modelCard
-            .SendFilter.NotNull()
-            .GetObjectIds()
-            .Select(id => (MapMember)MapView.Active.Map.FindLayer(id) ?? MapView.Active.Map.FindStandaloneTable(id))
-            .Where(obj => obj != null)
-            .ToList();
-
-          if (mapMembers.Count == 0)
-          {
-            // Handle as CARD ERROR in this function
-            throw new SpeckleSendFilterException(
-              "No objects were found to convert. Please update your publish filter!"
-            );
-          }
-
-          // subscribe to the selected layer events
-          foreach (MapMember mapMember in mapMembers)
-          {
-            if (mapMember is FeatureLayer featureLayer)
-            {
-              SubscribeToFeatureLayerDataSourceChange(featureLayer);
-            }
-            else if (mapMember is StandaloneTable table)
-            {
-              SubscribeToTableDataSourceChange(table);
-            }
-          }
-
-          var result = await unitOfWork
-            .Service.Execute(
-              mapMembers,
-              modelCard.GetSendInfo("ArcGIS"), // POC: get host app name from settings? same for GetReceiveInfo
-              (status, progress) =>
-                _operationProgressManager.SetModelProgress(
-                  Parent,
-                  modelCardId,
-                  new ModelCardProgress(modelCardId, status, progress),
-                  cancellationToken
-                ),
-              cancellationToken
+      using var scope = _serviceProvider.CreateScope();
+      List<MapMember> mapMembers = await QueuedTask.Run(() =>
+      {
+        scope
+          .ServiceProvider.GetRequiredService<IConverterSettingsStore<ArcGISConversionSettings>>()
+          .Initialize(
+            _arcGISConversionSettingsFactory.Create(
+              Project.Current,
+              MapView.Active.Map,
+              new CRSoffsetRotation(MapView.Active.Map)
             )
-            .ConfigureAwait(false);
+          );
 
-          return result;
-        })
-        .ConfigureAwait(false);
+        return modelCard
+          .SendFilter.NotNull()
+          .RefreshObjectIds()
+          .Select(id => (MapMember)MapView.Active.Map.FindLayer(id) ?? MapView.Active.Map.FindStandaloneTable(id))
+          .Where(obj => obj != null)
+          .ToList();
+      });
 
-      Commands.SetModelSendResult(modelCardId, sendResult.RootObjId, sendResult.ConversionResults);
+      if (mapMembers.Count == 0)
+      {
+        // Handle as CARD ERROR in this function
+        throw new SpeckleSendFilterException("No objects were found to convert. Please update your publish filter!");
+      }
+
+      await QueuedTask.Run(() =>
+      {
+        // subscribe to the selected layer events
+        foreach (MapMember mapMember in mapMembers)
+        {
+          if (mapMember is FeatureLayer featureLayer)
+          {
+            SubscribeToFeatureLayerDataSourceChange(featureLayer);
+          }
+          else if (mapMember is StandaloneTable table)
+          {
+            SubscribeToTableDataSourceChange(table);
+          }
+        }
+      });
+
+      var sendResult = await scope
+        .ServiceProvider.GetRequiredService<SendOperation<MapMember>>()
+        .Execute(
+          mapMembers,
+          modelCard.GetSendInfo(_speckleApplication.ApplicationAndVersion),
+          _operationProgressManager.CreateOperationProgressEventHandler(Parent, modelCardId, cancellationItem.Token),
+          cancellationItem.Token
+        );
+
+      await Commands.SetModelSendResult(modelCardId, sendResult.RootObjId, sendResult.ConversionResults);
     }
     catch (OperationCanceledException)
     {
@@ -430,7 +442,7 @@ public sealed class ArcGISSendBinding : ISendBinding
     catch (Exception ex) when (!ex.IsFatal()) // UX reasons - we will report operation exceptions as model card error. We may change this later when we have more exception documentation
     {
       _logger.LogModelCardHandledError(ex);
-      Commands.SetModelError(modelCardId, ex);
+      await Commands.SetModelError(modelCardId, ex);
     }
   }
 
@@ -439,7 +451,7 @@ public sealed class ArcGISSendBinding : ISendBinding
   /// <summary>
   /// Checks if any sender model cards contain any of the changed objects. If so, also updates the changed objects hashset for each model card - this last part is important for on send change detection.
   /// </summary>
-  private void RunExpirationChecks(bool idsDeleted)
+  private async Task RunExpirationChecks(bool idsDeleted)
   {
     var senders = _store.GetSenders();
     List<string> expiredSenderIds = new();
@@ -449,9 +461,9 @@ public sealed class ArcGISSendBinding : ISendBinding
 
     foreach (SenderModelCard sender in senders)
     {
-      var objIds = sender.SendFilter.NotNull().GetObjectIds();
+      var objIds = sender.SendFilter.NotNull().RefreshObjectIds();
       var intersection = objIds.Intersect(objectIdsList).ToList();
-      bool isExpired = sender.SendFilter.NotNull().CheckExpiry(objectIdsList);
+      bool isExpired = intersection.Count != 0;
       if (isExpired)
       {
         expiredSenderIds.Add(sender.ModelCardId.NotNull());
@@ -465,7 +477,7 @@ public sealed class ArcGISSendBinding : ISendBinding
       }
     }
 
-    Commands.SetModelsExpired(expiredSenderIds);
+    await Commands.SetModelsExpired(expiredSenderIds);
     ChangedObjectIds = new();
   }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Bindings/BasicConnectorBinding.cs

@@ -6,7 +6,7 @@ using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card;
-using Speckle.Connectors.Utils.Common;
+using Speckle.Sdk;
 using Speckle.Sdk.Common;
 using ArcProject = ArcGIS.Desktop.Core.Project;
 
@@ -16,28 +16,38 @@ namespace Speckle.Connectors.ArcGIS.Bindings;
 public class BasicConnectorBinding : IBasicConnectorBinding
 {
   public string Name => "baseBinding";
-  public IBridge Parent { get; }
+  public IBrowserBridge Parent { get; }
 
   public BasicConnectorBindingCommands Commands { get; }
   private readonly DocumentModelStore _store;
+  private readonly ISpeckleApplication _speckleApplication;
+  private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
 
-  public BasicConnectorBinding(DocumentModelStore store, IBridge parent)
+  public BasicConnectorBinding(
+    DocumentModelStore store,
+    IBrowserBridge parent,
+    ISpeckleApplication speckleApplication,
+    ITopLevelExceptionHandler topLevelExceptionHandler
+  )
   {
     _store = store;
+    _speckleApplication = speckleApplication;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
     Parent = parent;
     Commands = new BasicConnectorBindingCommands(parent);
 
     _store.DocumentChanged += (_, _) =>
-    {
-      Commands.NotifyDocumentChanged();
-    };
+      _topLevelExceptionHandler.FireAndForget(async () =>
+      {
+        await Commands.NotifyDocumentChanged();
+      });
   }
 
-  public string GetSourceApplicationName() => Speckle.Connectors.Utils.Connector.Slug;
+  public string GetSourceApplicationName() => _speckleApplication.Slug;
 
-  public string GetSourceApplicationVersion() => Speckle.Connectors.Utils.Connector.VersionString;
+  public string GetSourceApplicationVersion() => _speckleApplication.HostApplicationVersion;
 
-  public string GetConnectorVersion() => typeof(BasicConnectorBinding).Assembly.GetVersion();
+  public string GetConnectorVersion() => _speckleApplication.SpeckleVersion;
 
   public DocumentInfo? GetDocumentInfo()
   {
@@ -51,16 +61,20 @@ public class BasicConnectorBinding : IBasicConnectorBinding
 
   public DocumentModelStore GetDocumentState() => _store;
 
-  public void AddModel(ModelCard model) => _store.Models.Add(model);
+  public void AddModel(ModelCard model) => _store.AddModel(model);
 
   public void UpdateModel(ModelCard model) => _store.UpdateModel(model);
 
   public void RemoveModel(ModelCard model) => _store.RemoveModel(model);
 
-  public void HighlightObjects(List<string> objectIds) =>
-    HighlightObjectsOnView(objectIds.Select(x => new ObjectID(x)).ToList());
+  public void RemoveModels(List<ModelCard> models) => _store.RemoveModels(models);
 
-  public void HighlightModel(string modelCardId)
+  public async Task HighlightObjects(IReadOnlyList<string> objectIds)
+  {
+    await HighlightObjectsOnView(objectIds.Select(x => new ObjectID(x)).ToList());
+  }
+
+  public async Task HighlightModel(string modelCardId)
   {
     var model = _store.GetModelById(modelCardId);
 
@@ -73,7 +87,7 @@ public class BasicConnectorBinding : IBasicConnectorBinding
 
     if (model is SenderModelCard senderModelCard)
     {
-      objectIds = senderModelCard.SendFilter.NotNull().GetObjectIds().Select(x => new ObjectID(x)).ToList();
+      objectIds = senderModelCard.SendFilter.NotNull().RefreshObjectIds().Select(x => new ObjectID(x)).ToList();
     }
 
     if (model is ReceiverModelCard receiverModelCard)
@@ -85,27 +99,25 @@ public class BasicConnectorBinding : IBasicConnectorBinding
     {
       return;
     }
-    HighlightObjectsOnView(objectIds);
+    await HighlightObjectsOnView(objectIds);
   }
 
-  private async void HighlightObjectsOnView(List<ObjectID> objectIds)
+  private async Task HighlightObjectsOnView(IReadOnlyList<ObjectID> objectIds)
   {
-    MapView mapView = MapView.Active;
+    await QueuedTask.Run(() =>
+    {
+      MapView mapView = MapView.Active;
 
-    await QueuedTask
-      .Run(() =>
-      {
-        List<MapMemberFeature> mapMembersFeatures = GetMapMembers(objectIds, mapView);
-        ClearSelectionInTOC();
-        ClearSelection();
-        SelectMapMembersInTOC(mapMembersFeatures);
-        SelectMapMembersAndFeatures(mapMembersFeatures);
-        mapView.ZoomToSelected();
-      })
-      .ConfigureAwait(false);
+      List<MapMemberFeature> mapMembersFeatures = GetMapMembers(objectIds, mapView);
+      ClearSelectionInTOC();
+      ClearSelection();
+      SelectMapMembersInTOC(mapMembersFeatures);
+      SelectMapMembersAndFeatures(mapMembersFeatures);
+      mapView.ZoomToSelected();
+    });
   }
 
-  private List<MapMemberFeature> GetMapMembers(List<ObjectID> objectIds, MapView mapView)
+  private List<MapMemberFeature> GetMapMembers(IReadOnlyList<ObjectID> objectIds, MapView mapView)
   {
     // find the layer on the map (from the objectID) and add the featureID is available
     List<MapMemberFeature> mapMembersFeatures = new();
@@ -143,7 +155,7 @@ public class BasicConnectorBinding : IBasicConnectorBinding
     MapView.Active.ClearTOCSelection();
   }
 
-  private void SelectMapMembersAndFeatures(List<MapMemberFeature> mapMembersFeatures)
+  private void SelectMapMembersAndFeatures(IReadOnlyList<MapMemberFeature> mapMembersFeatures)
   {
     foreach (MapMemberFeature mapMemberFeat in mapMembersFeatures)
     {
@@ -168,7 +180,7 @@ public class BasicConnectorBinding : IBasicConnectorBinding
     }
   }
 
-  private void SelectMapMembersInTOC(List<MapMemberFeature> mapMembersFeatures)
+  private void SelectMapMembersInTOC(IReadOnlyList<MapMemberFeature> mapMembersFeatures)
   {
     List<Layer> layers = new();
     List<StandaloneTable> tables = new();
@@ -184,7 +196,7 @@ public class BasicConnectorBinding : IBasicConnectorBinding
         }
         else
         {
-          QueuedTask.Run(() => layer.SetExpanded(true));
+          layer.SetExpanded(true);
         }
       }
       else if (member is StandaloneTable table)

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Config.daml

@@ -20,7 +20,7 @@
 <ArcGIS defaultAssembly="Speckle.Connectors.ArcGIS3.dll" defaultNamespace="Speckle.Connectors.ArcGIS" xmlns="http://schemas.esri.com/DADF/Registry" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://schemas.esri.com/DADF/Registry file:///C:/Program%20Files/ArcGIS/Pro/bin/ArcGIS.Desktop.Framework.xsd">
 	<AddInInfo id="{6CB1D25C-B8BF-4A33-9099-C1F8D1B32EFC}" version="1.0" desktopVersion="3.0.34047">
 		<Name>Speckle</Name>
-		<Description>Speckle connector for ArcGIS</Description>
+		<Description>Next Gen Speckle Connector (Beta) for ArcGIS</Description>
 		<Image>Images\AddinDesktop32.png</Image>
 		<Author>Speckle Systems</Author>
 		<Company>Speckle Systems</Company>
@@ -33,14 +33,14 @@
 		<insertModule id="ConnectorArcGIS_Module" className="SpeckleModule" autoLoad="false" caption="SpeckleModule">
 			<!-- uncomment to have the control hosted on a separate tab-->
 			<tabs>
-				<!--<tab id="Speckle_Tab1" caption="New Tab">
+				<tab id="Speckle_Tab1" caption="Speckle">
           <group refID="Speckle_Group1"/>
-        </tab>-->
+        </tab>
 			</tabs>
 			<groups>
 				<!-- comment this out if you have no controls on the Addin tab to avoid
-              an empty group-->
-				<group id="Speckle_Group1" caption="Speckle" appearsOnAddInTab="true" keytip="G1">
+              an empty group. change appearsOnAddinTab to "True" if control is to be in the addin tab-->
+				<group id="Speckle_Group1" caption="Speckle" appearsOnAddInTab="false" keytip="G1">
 					<!-- host controls within groups -->
 					<button refID="SpeckleDUI3_SpeckleDUI3OpenButton" size="large" />
 				</group>
@@ -59,7 +59,7 @@
 			</controls>
 
             <dockPanes>
-                <dockPane id="SpeckleDUI3_SpeckleDUI3" caption="Speckle (Beta) for ArcGIS" className="SpeckleDUI3ViewModel" keytip="DockPane" initiallyVisible="true" dock="group" dockWith="esri_core_projectDockPane">
+                <dockPane id="SpeckleDUI3_SpeckleDUI3" caption="Speckle (Beta)" className="SpeckleDUI3ViewModel" keytip="DockPane" initiallyVisible="true" dock="group" dockWith="esri_core_projectDockPane">
                     <content className="SpeckleDUI3Wrapper" />
                 </dockPane>
             </dockPanes>

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/DependencyInjection/ArcGISConnectorModule.cs

@@ -1,24 +1,21 @@
 using ArcGIS.Desktop.Mapping;
-using Autofac;
-using Speckle.Autofac;
-using Speckle.Autofac.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using Speckle.Connectors.ArcGIS.Bindings;
 using Speckle.Connectors.ArcGIS.Filters;
 using Speckle.Connectors.ArcGIS.HostApp;
 using Speckle.Connectors.ArcGIS.Operations.Receive;
 using Speckle.Connectors.ArcGis.Operations.Send;
 using Speckle.Connectors.ArcGIS.Utils;
+using Speckle.Connectors.Common;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI;
 using Speckle.Connectors.DUI.Bindings;
-using Speckle.Connectors.DUI.Bridge;
-using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card.SendFilter;
 using Speckle.Connectors.DUI.WebView;
-using Speckle.Connectors.Utils;
-using Speckle.Connectors.Utils.Builders;
-using Speckle.Connectors.Utils.Caching;
-using Speckle.Connectors.Utils.Instances;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Converters.Common;
 using Speckle.Sdk.Models.GraphTraversal;
 
 // POC: This is a temp reference to root object senders to tweak CI failing after having generic interfaces into common project.
@@ -26,58 +23,44 @@ using Speckle.Sdk.Models.GraphTraversal;
 
 namespace Speckle.Connectors.ArcGIS.DependencyInjection;
 
-public class ArcGISConnectorModule : ISpeckleModule
+public static class ArcGISConnectorModule
 {
-  public void Load(SpeckleContainerBuilder builder)
+  public static void AddArcGIS(this IServiceCollection serviceCollection)
   {
-    builder.AddAutofac();
-    builder.AddConnectorUtils();
-    builder.AddDUI();
-    builder.AddDUIView();
+    serviceCollection.AddConnectors();
+    serviceCollection.AddDUI<DefaultThreadContext, ArcGISDocumentStore>();
+    serviceCollection.AddDUIView();
 
-    // POC: Overwriting the SyncToMainThread to SyncToCurrentThread for ArcGIS only!
-    // On SendOperation, once we called QueuedTask, it expect to run everything on same thread.
-    // builder.AddSingletonInstance<ISyncToThread, SyncToQueuedTask>();
-
-    builder.AddSingleton<DocumentModelStore, ArcGISDocumentStore>();
     // Register bindings
-    builder.AddSingleton<IBinding, TestBinding>();
-    builder.AddSingleton<IBinding, ConfigBinding>("connectorName", "ArcGIS"); // POC: Easier like this for now, should be cleaned up later
-    builder.AddSingleton<IBinding, AccountBinding>();
+    serviceCollection.AddSingleton<IBinding, TestBinding>();
+    serviceCollection.AddSingleton<IBinding, ConfigBinding>();
+    serviceCollection.AddSingleton<IBinding, AccountBinding>();
+    serviceCollection.AddSingleton<IBinding>(sp => sp.GetRequiredService<IBasicConnectorBinding>());
+    serviceCollection.AddSingleton<IBasicConnectorBinding, BasicConnectorBinding>();
 
-    builder.ContainerBuilder.RegisterType<TopLevelExceptionHandlerBinding>().As<IBinding>().AsSelf().SingleInstance();
-    builder.AddSingleton<ITopLevelExceptionHandler>(c =>
-      c.Resolve<TopLevelExceptionHandlerBinding>().Parent.TopLevelExceptionHandler
-    );
-
-    builder
-      .ContainerBuilder.RegisterType<BasicConnectorBinding>()
-      .As<IBinding>()
-      .As<IBasicConnectorBinding>()
-      .SingleInstance();
-
-    builder.AddSingleton<IBinding, ArcGISSelectionBinding>();
-    builder.AddSingleton<IBinding, ArcGISSendBinding>();
-    builder.AddSingleton<IBinding, ArcGISReceiveBinding>();
-
-    builder.AddTransient<ISendFilter, ArcGISSelectionFilter>();
-    builder.AddScoped<IHostObjectBuilder, ArcGISHostObjectBuilder>();
-    builder.AddSingleton(DefaultTraversal.CreateTraversalFunc());
+    serviceCollection.AddSingleton(DefaultTraversal.CreateTraversalFunc());
 
     // register send operation and dependencies
-    builder.AddScoped<SendOperation<MapMember>>();
-    builder.AddScoped<ArcGISRootObjectBuilder>();
-    builder.AddScoped<IRootObjectBuilder<MapMember>, ArcGISRootObjectBuilder>();
-
-    builder.AddScoped<ArcGISColorManager>();
-    builder.AddScoped<MapMembersUtils>();
-
-    builder.AddScoped<ILocalToGlobalUnpacker, LocalToGlobalUnpacker>();
-
+    serviceCollection.AddSingleton<IBinding, ArcGISSendBinding>();
+    serviceCollection.AddScoped<SendOperation<MapMember>>();
+    serviceCollection.AddSingleton<IBinding, ArcGISSelectionBinding>();
+    serviceCollection.AddTransient<ISendFilter, ArcGISSelectionFilter>();
+    serviceCollection.AddScoped<ArcGISRootObjectBuilder>();
+    serviceCollection.AddScoped<IRootObjectBuilder<MapMember>, ArcGISRootObjectBuilder>();
+    serviceCollection.AddScoped<ArcGISLayerUnpacker>();
+    serviceCollection.AddScoped<ArcGISColorUnpacker>();
     // register send conversion cache
-    builder.AddSingleton<ISendConversionCache, SendConversionCache>();
+    serviceCollection.AddSingleton<ISendConversionCache, SendConversionCache>();
+
+    // register receive operation and dependencies
+    // serviceCollection.AddSingleton<IBinding, ArcGISReceiveBinding>(); // POC: disabled until receive code is refactored
+    serviceCollection.AddScoped<LocalToGlobalConverterUtils>();
+    serviceCollection.AddScoped<ArcGISColorManager>();
+    serviceCollection.AddScoped<IHostObjectBuilder, ArcGISHostObjectBuilder>();
+
+    serviceCollection.AddScoped<MapMembersUtils>();
 
     // operation progress manager
-    builder.AddSingleton<IOperationProgressManager, OperationProgressManager>();
+    serviceCollection.AddSingleton<IOperationProgressManager, OperationProgressManager>();
   }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Esri.ArcGISPro.Extensions30.Speckle.targets

@@ -154,7 +154,6 @@
         Log.LogErrorFromException(ex);
         return false;
       }
-      return Success;
     ]]>
       </Code>
     </Task>
@@ -190,7 +189,7 @@
             {
                 Log.LogMessage(MessageImportance.Low, "RelativePaths: " + i.ToString());
             }
-            return true;
+            Success = true;
 			 ]]>
       </Code>
     </Task>
@@ -204,8 +203,8 @@
       <CleanInfo ParameterType="System.String" Output="true"/>
     </ParameterGroup>
     <Task>
-      <Reference Include="System.Xml.Linq"/>
-      <Reference Include="System.Xml"/>
+<!--      <Reference Include="System.Xml.Linq"/>-->
+<!--      <Reference Include="System.Xml"/>-->
       <Using Namespace="System"/>
       <Using Namespace="System.IO"/>
       <Using Namespace="System.Xml.Linq"/>
@@ -266,7 +265,6 @@
         CleanInfo = AssemblyName + extension;
       }
       Success = true;
-      return Success;
 	]]>
       </Code>
     </Task>

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Filters/ArcGISEverythingFilter.cs

@@ -1,10 +0,0 @@
-using Speckle.Connectors.DUI.Models.Card.SendFilter;
-
-namespace Speckle.Connectors.ArcGIS.Filters;
-
-public class ArcGISEverythingFilter : EverythingSendFilter
-{
-  public override List<string> GetObjectIds() => new(); // TODO
-
-  public override bool CheckExpiry(string[] changedObjectIds) => true;
-}

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Filters/ArcGISSelectionFilter.cs

@@ -4,7 +4,10 @@ namespace Speckle.Connectors.ArcGIS.Filters;
 
 public class ArcGISSelectionFilter : DirectSelectionSendFilter
 {
-  public override List<string> GetObjectIds() => SelectedObjectIds;
+  public ArcGISSelectionFilter()
+  {
+    IsDefault = true;
+  }
 
-  public override bool CheckExpiry(string[] changedObjectIds) => SelectedObjectIds.Intersect(changedObjectIds).Any();
+  public override List<string> RefreshObjectIds() => SelectedObjectIds;
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/GlobalUsing.cs

@@ -0,0 +1,3 @@
+global using AC = ArcGIS.Core;
+global using ACD = ArcGIS.Core.Data;
+global using ADM = ArcGIS.Desktop.Mapping;

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/HostApp/ArcGISColorManager.cs

@@ -1,68 +1,38 @@
 using System.Drawing;
 using ArcGIS.Core.CIM;
-using ArcGIS.Core.Data;
 using ArcGIS.Desktop.Mapping;
+using Speckle.Connectors.Common.Operations;
 using Speckle.Converters.ArcGIS3.Utils;
 using Speckle.Objects;
 using Speckle.Objects.Other;
 using Speckle.Sdk.Models.Collections;
+using Speckle.Sdk.Models.Extensions;
 using Speckle.Sdk.Models.GraphTraversal;
 using Speckle.Sdk.Models.Proxies;
 
 namespace Speckle.Connectors.ArcGIS.HostApp;
 
+/// <summary>
+/// TODO: definitely need to refactor this, probably will collect colors during layer iteration in the root object builder.
+/// </summary>
 public class ArcGISColorManager
 {
-  private Dictionary<string, ColorProxy> ColorProxies { get; set; } = new();
   public Dictionary<string, Color> ObjectColorsIdMap { get; set; } = new();
   public Dictionary<string, Color> ObjectMaterialsIdMap { get; set; } = new();
 
-  /// <summary>
-  /// Iterates through a given set of arcGIS map members (layers containing objects) and collects their colors.
-  /// </summary>
-  /// <param name="mapMembersWithDisplayPriority"></param>
-  /// <returns>A list of color proxies, where the application Id is argb value + display priority</returns>
-  /// <remarks>
-  /// In ArcGIS, map members contain a formula, which individual features contained in map members will use to calculate their color.
-  /// Since display priority is important for ArcGIS layers, we are creating different Color Proxies for eg the same argb color value but different display priority.
-  /// </remarks>
-  public List<ColorProxy> UnpackColors(List<(MapMember, int)> mapMembersWithDisplayPriority)
-  {
-    // injected as Singleton, so we need to clean existing proxies first
-    ColorProxies = new();
-
-    foreach ((MapMember mapMember, int priority) in mapMembersWithDisplayPriority)
-    {
-      switch (mapMember)
-      {
-        // FeatureLayer colors will be processed per feature object
-        case FeatureLayer featureLayer:
-          ProcessFeatureLayerColors(featureLayer, priority);
-          break;
-
-        // RasterLayer object colors are converted as mesh vertex colors, but we need to store displayPriority on the raster layer. Default color is used for all rasters.
-        case RasterLayer rasterLayer:
-          ProcessRasterLayerColors(rasterLayer, priority);
-          break;
-      }
-    }
-
-    return ColorProxies.Values.ToList();
-  }
-
   /// <summary>
   /// Parse Color Proxies and stores in ObjectColorsIdMap the relationship between object ids and colors
   /// </summary>
   /// <param name="colorProxies"></param>
   /// <param name="onOperationProgressed"></param>
-  public void ParseColors(List<ColorProxy> colorProxies, Action<string, double?>? onOperationProgressed)
+  public void ParseColors(List<ColorProxy> colorProxies, IProgress<CardProgress> onOperationProgressed)
   {
     // injected as Singleton, so we need to clean existing proxies first
     ObjectColorsIdMap = new();
     var count = 0;
     foreach (ColorProxy colorProxy in colorProxies)
     {
-      onOperationProgressed?.Invoke("Converting colors", (double)++count / colorProxies.Count);
+      onOperationProgressed.Report(new("Converting colors", (double)++count / colorProxies.Count));
       foreach (string objectId in colorProxy.objects)
       {
         Color convertedColor = Color.FromArgb(colorProxy.value);
@@ -76,14 +46,14 @@ public class ArcGISColorManager
   /// </summary>
   /// <param name="materialProxies"></param>
   /// <param name="onOperationProgressed"></param>
-  public void ParseMaterials(List<RenderMaterialProxy> materialProxies, Action<string, double?>? onOperationProgressed)
+  public void ParseMaterials(List<RenderMaterialProxy> materialProxies, IProgress<CardProgress> onOperationProgressed)
   {
     // injected as Singleton, so we need to clean existing proxies first
     ObjectMaterialsIdMap = new();
     var count = 0;
     foreach (RenderMaterialProxy colorProxy in materialProxies)
     {
-      onOperationProgressed?.Invoke("Converting materials", (double)++count / materialProxies.Count);
+      onOperationProgressed.Report(new("Converting materials", (double)++count / materialProxies.Count));
       foreach (string objectId in colorProxy.objects)
       {
         Color convertedColor = Color.FromArgb(colorProxy.value.diffuse);
@@ -92,6 +62,14 @@ public class ArcGISColorManager
     }
   }
 
+  public int CIMColorToInt(CIMColor color)
+  {
+    return (255 << 24)
+      | ((int)Math.Round(color.Values[0]) << 16)
+      | ((int)Math.Round(color.Values[1]) << 8)
+      | (int)Math.Round(color.Values[2]);
+  }
+
   /// <summary>
   /// Create a new CIMUniqueValueClass for UniqueRenderer per each object ID
   /// </summary>
@@ -105,6 +83,7 @@ public class ArcGISColorManager
   {
     // declare default white color
     Color color = Color.FromArgb(255, 255, 255, 255);
+    bool colorFound = false;
 
     // get color moving upwards from the object
     foreach (var parent in tc.GetAscendants())
@@ -114,16 +93,43 @@ public class ArcGISColorManager
         if (ObjectMaterialsIdMap.TryGetValue(appId, out Color objColorMaterial))
         {
           color = objColorMaterial;
+          colorFound = true;
           break;
         }
         if (ObjectColorsIdMap.TryGetValue(appId, out Color objColor))
         {
           color = objColor;
+          colorFound = true;
           break;
         }
       }
     }
 
+    // handling Revit case, where child objects have separate colors/materials
+    if (!colorFound && tc.Current is IDataObject)
+    {
+      var displayable = tc.Current.TryGetDisplayValue();
+      if (displayable != null)
+      {
+        foreach (var childObj in displayable)
+        {
+          if (childObj.applicationId is string appId)
+          {
+            if (ObjectMaterialsIdMap.TryGetValue(appId, out Color objColorMaterial))
+            {
+              color = objColorMaterial;
+              break;
+            }
+            if (ObjectColorsIdMap.TryGetValue(appId, out Color objColor))
+            {
+              color = objColor;
+              break;
+            }
+          }
+        }
+      }
+    }
+
     CIMSymbolReference symbol = CreateSymbol(speckleGeometryType, color);
 
     // First create a "CIMUniqueValueClass"
@@ -190,7 +196,7 @@ public class ArcGISColorManager
     }
 
     // declare default grey color, create default symbol for the given layer geometry type
-    var color = Color.FromArgb(ColorFactory.Instance.GreyRGB.CIMColorToInt());
+    var color = Color.FromArgb(CIMColorToInt(ColorFactory.Instance.GreyRGB));
     CIMSymbolReference defaultSymbol = CreateSymbol(fLayer.ShapeType, color);
 
     // get existing renderer classes
@@ -221,7 +227,10 @@ public class ArcGISColorManager
     foreach (var tContext in traversalContexts)
     {
       // get unique label
-      string uniqueLabel = tContext.Current.id;
+      string? uniqueLabel = tContext.Current?.id;
+
+      // remove any GIS-specific classes for now
+      /*
       if (tContext.Current is IGisFeature gisFeat)
       {
         var existingLabel = gisFeat.attributes["Speckle_ID"];
@@ -229,9 +238,9 @@ public class ArcGISColorManager
         {
           uniqueLabel = stringLabel;
         }
-      }
+      }*/
 
-      if (!listUniqueValueClasses.Select(x => x.Label).Contains(uniqueLabel))
+      if (uniqueLabel is not null && !listUniqueValueClasses.Select(x => x.Label).Contains(uniqueLabel))
       {
         CIMUniqueValueClass newUniqueValueClass = CreateColorCategory(tContext, fLayer.ShapeType, uniqueLabel);
         listUniqueValueClasses.Add(newUniqueValueClass);
@@ -253,356 +262,4 @@ public class ArcGISColorManager
       };
     return uvr;
   }
-
-  private string GetColorApplicationId(int argb, double order) => $"{argb}_{order}";
-
-  // Adds the element id to the color proxy based on colorId if it exists in ColorProxies,
-  // otherwise creates a new Color Proxy with the element id in the objects property
-  private void AddElementIdToColorProxy(string elementAppId, int colorValue, string colorId, int displayPriority)
-  {
-    if (ColorProxies.TryGetValue(colorId, out ColorProxy? colorProxy))
-    {
-      colorProxy.objects.Add(elementAppId);
-    }
-    else
-    {
-      ColorProxy newProxy =
-        new()
-        {
-          value = colorValue,
-          applicationId = colorId,
-          objects = new() { elementAppId },
-          name = colorId
-        };
-
-      newProxy["displayOrder"] = displayPriority; // 0 - top layer (top display priority), 1,2,3.. decreasing priority
-      ColorProxies.Add(colorId, newProxy);
-    }
-  }
-
-  private void ProcessRasterLayerColors(RasterLayer rasterLayer, int displayPriority)
-  {
-    string elementAppId = $"{rasterLayer.URI}_0"; // POC: explain why count = 0 here
-    int argb = -1;
-    string colorId = GetColorApplicationId(argb, displayPriority); // We are using a default color of -1 for all raster layers
-    AddElementIdToColorProxy(elementAppId, argb, colorId, displayPriority);
-  }
-
-  /// <summary>
-  /// Record colors from every feature of the layer into ColorProxies
-  /// </summary>
-  /// <param name="layer"></param>
-  /// <param name="displayPriority"></param>
-  private void ProcessFeatureLayerColors(FeatureLayer layer, int displayPriority)
-  {
-    // first get a list of layer fields
-    // field names are unique, but often their alias is used instead by renderer headings
-    // so we are storing both names and alieas in this dictionary for fast lookup
-    // POC: adding aliases are not optimal, because they do not need to be unique && they can be the same as the name of another field
-    Dictionary<string, FieldDescription> layerFieldDictionary = new();
-    foreach (FieldDescription field in layer.GetFieldDescriptions())
-    {
-      layerFieldDictionary.TryAdd(field.Name, field);
-      layerFieldDictionary.TryAdd(field.Alias, field);
-    }
-
-    CIMRenderer layerRenderer = layer.GetRenderer();
-    int count = 1;
-    using (RowCursor rowCursor = layer.Search())
-    {
-      while (rowCursor.MoveNext())
-      {
-        string elementAppId = $"{layer.URI}_{count}";
-        using (Row row = rowCursor.Current)
-        {
-          // get row color
-          int argb = GetLayerColorByRendererAndRow(layerRenderer, row, layerFieldDictionary);
-          string colorId = GetColorApplicationId(argb, displayPriority);
-          AddElementIdToColorProxy(elementAppId, argb, colorId, displayPriority);
-        }
-
-        count++;
-      }
-    }
-  }
-
-  // Attempts to retrieve the color from a CIMSymbol
-  private bool TryGetSymbolColor(CIMSymbol symbol, out int symbolColor)
-  {
-    symbolColor = -1;
-    if (symbol.GetColor() is CIMColor cimColor)
-    {
-      switch (cimColor)
-      {
-        case CIMRGBColor rgbColor:
-          symbolColor = rgbColor.CIMColorToInt();
-          return true;
-        case CIMHSVColor hsvColor:
-          symbolColor = RgbFromHsv(hsvColor);
-          return true;
-        case CIMCMYKColor cmykColor:
-          symbolColor = RgbFromCmyk(cmykColor);
-          return true;
-        default:
-          return false;
-      }
-    }
-    else
-    {
-      return false;
-    }
-  }
-
-  private int RbgToInt(int a, int r, int g, int b)
-  {
-    return (a << 24) | (r << 16) | (g << 8) | b;
-  }
-
-  private int RgbFromCmyk(CIMCMYKColor cmykColor)
-  {
-    float c = cmykColor.C;
-    float m = cmykColor.M;
-    float y = cmykColor.Y;
-    float k = cmykColor.K;
-
-    int r = Convert.ToInt32(255 * (1 - c) * (1 - k));
-    int g = Convert.ToInt32(255 * (1 - m) * (1 - k));
-    int b = Convert.ToInt32(255 * (1 - y) * (1 - k));
-    return RbgToInt(255, r, g, b);
-  }
-
-  private int RgbFromHsv(CIMHSVColor hsvColor)
-  {
-    // Translates HSV color to RGB color
-    // H: 0.0 - 360.0, S: 0.0 - 100.0, V: 0.0 - 100.0
-    // R, G, B: 0.0 - 1.0
-
-    float hue = hsvColor.H;
-    float saturation = hsvColor.S;
-    float value = hsvColor.V;
-
-    float c = (value / 100) * (saturation / 100);
-    float x = c * (1 - Math.Abs(((hue / 60) % 2) - 1));
-    float m = (value / 100) - c;
-
-    float r = 0;
-    float g = 0;
-    float b = 0;
-
-    if (hue >= 0 && hue < 60)
-    {
-      r = c;
-      g = x;
-      b = 0;
-    }
-    else if (hue >= 60 && hue < 120)
-    {
-      r = x;
-      g = c;
-      b = 0;
-    }
-    else if (hue >= 120 && hue < 180)
-    {
-      r = 0;
-      g = c;
-      b = x;
-    }
-    else if (hue >= 180 && hue < 240)
-    {
-      r = 0;
-      g = x;
-      b = c;
-    }
-    else if (hue >= 240 && hue < 300)
-    {
-      r = x;
-      g = 0;
-      b = c;
-    }
-    else if (hue >= 300 && hue < 360)
-    {
-      r = c;
-      g = 0;
-      b = x;
-    }
-
-    r += m;
-    g += m;
-    b += m;
-
-    // convert rgb 0.0-1.0 float to int
-    int red = (int)Math.Round(r * 255);
-    int green = (int)Math.Round(g * 255);
-    int blue = (int)Math.Round(b * 255);
-
-    return RbgToInt(255, red, green, blue);
-  }
-
-  private bool TryGetUniqueRendererColor(
-    CIMUniqueValueRenderer uniqueRenderer,
-    Row row,
-    Dictionary<string, FieldDescription> fields,
-    out int color
-  )
-  {
-    if (!TryGetSymbolColor(uniqueRenderer.DefaultSymbol.Symbol, out color)) // get default color
-    {
-      return false;
-    }
-
-    // note: usually there is only 1 group
-    foreach (CIMUniqueValueGroup group in uniqueRenderer.Groups)
-    {
-      string[] fieldNames = uniqueRenderer.Fields;
-      List<string> usedFields = new();
-      foreach (string fieldName in fieldNames)
-      {
-        if (fields.TryGetValue(fieldName, out FieldDescription? headingField))
-        {
-          usedFields.Add(headingField.Name);
-        }
-      }
-
-      // loop through all values in groups to see if any have met conditions that result in a different color
-      foreach (CIMUniqueValueClass groupClass in group.Classes)
-      {
-        bool groupConditionsMet = true;
-        foreach (CIMUniqueValue value in groupClass.Values)
-        {
-          // all field values have to match the row values
-          for (int i = 0; i < usedFields.Count; i++)
-          {
-            string groupValue = value.FieldValues[i].Replace("<Null>", "");
-            object? rowValue = row[usedFields[i]];
-
-            (string newRowValue, string newGroupValue) = MakeValuesComparable(rowValue, groupValue);
-            if (newGroupValue != newRowValue)
-            {
-              groupConditionsMet = false;
-              break;
-            }
-          }
-        }
-
-        // set the group color to class symbol color if conditions are met
-        if (groupConditionsMet)
-        {
-          if (!TryGetSymbolColor(groupClass.Symbol.Symbol, out color))
-          {
-            return false;
-          }
-        }
-      }
-    }
-
-    return true;
-  }
-
-  /// <summary>
-  /// Make comparable the Label string of a UniqueValueRenderer (groupValue), and a Feature Attribute value (rowValue)
-  /// </summary>
-  /// <param name="rowValue"></param>
-  /// <param name="groupValue"></param>
-  private (string, string) MakeValuesComparable(object? rowValue, string groupValue)
-  {
-    string newGroupValue = groupValue;
-    string newRowValue = Convert.ToString(rowValue) ?? "";
-
-    // int, doubles are tricky to compare with strings, trimming both to 5 digits
-    if (rowValue is int or short or long)
-    {
-      newRowValue = newRowValue.Split(".")[0];
-      newGroupValue = newGroupValue.Split(".")[0];
-    }
-    else if (rowValue is double || rowValue is float)
-    {
-      newRowValue = string.Concat(
-        newRowValue.Split(".")[0],
-        ".",
-        newRowValue.Split(".")[^1].AsSpan(0, Math.Min(5, newRowValue.Split(".")[^1].Length))
-      );
-      newGroupValue = string.Concat(
-        newGroupValue.Split(".")[0],
-        ".",
-        newGroupValue.Split(".")[^1].AsSpan(0, Math.Min(5, newGroupValue.Split(".")[^1].Length))
-      );
-    }
-
-    return (newRowValue, newGroupValue);
-  }
-
-  private bool TryGetGraduatedRendererColor(
-    CIMClassBreaksRenderer graduatedRenderer,
-    Row row,
-    Dictionary<string, FieldDescription> fields,
-    out int color
-  )
-  {
-    if (!TryGetSymbolColor(graduatedRenderer.DefaultSymbol.Symbol, out color)) // get default color
-    {
-      return false;
-    }
-
-    string? usedField = null;
-    if (fields.TryGetValue(graduatedRenderer.Field, out FieldDescription? field))
-    {
-      usedField = field.Name;
-    }
-
-    List<CIMClassBreak> reversedBreaks = new(graduatedRenderer.Breaks);
-    reversedBreaks.Reverse();
-    foreach (var rBreak in reversedBreaks)
-    {
-      // keep looping until the last matching condition
-      if (Convert.ToDouble(row[usedField]) <= rBreak.UpperBound)
-      {
-        if (!TryGetSymbolColor(rBreak.Symbol.Symbol, out color)) // get default color
-        {
-          return false;
-        }
-      }
-    }
-
-    return true;
-  }
-
-  // Tries to retrieve the feature layer color by renderer and row, or a default color of -1
-  private int GetLayerColorByRendererAndRow(CIMRenderer renderer, Row row, Dictionary<string, FieldDescription> fields)
-  {
-    // default color to white. this will be used if the renderer is not supported.
-    int color = -1;
-
-    // get color depending on renderer type
-    switch (renderer)
-    {
-      case CIMSimpleRenderer simpleRenderer:
-        if (!TryGetSymbolColor(simpleRenderer.Symbol.Symbol, out color))
-        {
-          // POC: report CONVERTED WITH WARNING when implemented
-        }
-        break;
-
-      // unique renderers have groups of conditions that may affect the color of a feature
-      // resulting in a different color than the default renderer symbol color
-      case CIMUniqueValueRenderer uniqueRenderer:
-        if (!TryGetUniqueRendererColor(uniqueRenderer, row, fields, out color)) // get default color
-        {
-          // POC: report CONVERTED WITH WARNING when implemented
-        }
-        break;
-
-      case CIMClassBreaksRenderer graduatedRenderer:
-        if (!TryGetGraduatedRendererColor(graduatedRenderer, row, fields, out color)) // get default color
-        {
-          // POC: report CONVERTED WITH WARNING when implemented
-        }
-        break;
-
-      default:
-        // POC: report CONVERTED WITH WARNING when implemented, unsupported renderer e.g. CIMProportionalRenderer
-        break;
-    }
-
-    return color;
-  }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/HostApp/ArcGISColorUnpacker.cs

@@ -0,0 +1,461 @@
+using ArcGIS.Desktop.Mapping;
+using Speckle.Sdk.Models.Proxies;
+
+namespace Speckle.Connectors.ArcGIS.HostApp;
+
+public class ArcGISColorUnpacker
+{
+  /// <summary>
+  /// Cache of all color proxies for converted features. Key is the Color proxy argb value.
+  /// </summary>
+  public Dictionary<int, ColorProxy> ColorProxyCache { get; } = new();
+
+  /// <summary>
+  /// Stores the current renderer (determined by mapMember)
+  /// </summary>
+  private AC.CIM.CIMRenderer? StoredRenderer { get; set; }
+
+  /// <summary>
+  /// Stores the current renderer (determined by tin mapmember)
+  /// </summary>
+  private AC.CIM.CIMTinRenderer? StoredTinRenderer { get; set; }
+
+  /// <summary>
+  /// Stores the used renderer fields from the layer
+  /// </summary>
+  private List<string> StoredRendererFields { get; set; }
+
+  /// <summary>
+  /// Stores an already processed color for current mapMember, to dbe used by all mapMember objects. Only applies to simple type renderers
+  /// </summary>
+  private int? StoredColor { get; set; }
+
+  /// <summary>
+  /// Stores a feature layer renderer to be used by <see cref="ProcessFeatureLayerColor"/> in <see cref="StoredRenderer"/>, any fields used by the renderer from the layer, and resets the <see cref="StoredColor"/> and <see cref="StoredRendererFields"/>
+  /// </summary>
+  /// <param name="featureLayer"></param>
+  /// <exception cref="AC.CalledOnWrongThreadException">Must be called on MCT.</exception>
+  public void StoreRendererAndFields(ADM.FeatureLayer featureLayer)
+  {
+    // field names are unique, but often their alias is used instead by renderer headings
+    // so we are storing both names and alias in this dictionary for fast lookup
+    // POC: adding aliases are not optimal, because they do not need to be unique && they can be the same as the name of another field
+    Dictionary<string, string> layerFieldDictionary = new();
+    foreach (ADM.FieldDescription field in featureLayer.GetFieldDescriptions())
+    {
+      layerFieldDictionary.TryAdd(field.Name, field.Name);
+      layerFieldDictionary.TryAdd(field.Alias, field.Name);
+    }
+
+    // clear stored values
+    StoredRendererFields = new();
+    StoredColor = null;
+    StoredRenderer = null;
+
+    AC.CIM.CIMRenderer layerRenderer = featureLayer.GetRenderer();
+    List<string> fields = new();
+    bool isSupported = false;
+    switch (layerRenderer)
+    {
+      case AC.CIM.CIMSimpleRenderer:
+        isSupported = true;
+        break;
+      case AC.CIM.CIMUniqueValueRenderer uniqueValueRenderer:
+        isSupported = true;
+        fields = uniqueValueRenderer.Fields.ToList();
+        break;
+      case AC.CIM.CIMClassBreaksRenderer classBreaksRenderer:
+        isSupported = true;
+        fields.Add(classBreaksRenderer.Field);
+        break;
+      default:
+        // TODO: log error here that a renderer is unsupported
+        break;
+    }
+
+    if (isSupported)
+    {
+      StoredRenderer = layerRenderer;
+      foreach (string field in fields)
+      {
+        if (layerFieldDictionary.TryGetValue(field, out string? fieldName))
+        {
+          StoredRendererFields.Add(fieldName);
+        }
+      }
+    }
+  }
+
+  /// <summary>
+  /// Stores a las layer renderer to be used by <see cref="ProcessLasLayerColor"/> in <see cref="StoredTinRenderer"/>
+  /// </summary>
+  /// <param name="lasLayer"></param>
+  /// <exception cref="AC.CalledOnWrongThreadException">Must be called on MCT.</exception>
+  public void StoreRenderer(ADM.LasDatasetLayer lasLayer)
+  {
+    // clear stored values
+    StoredTinRenderer = null;
+
+    // POC: not sure why we are only using the first renderer here
+    AC.CIM.CIMTinRenderer layerRenderer = lasLayer.GetRenderers()[0];
+    bool isSupported = false;
+    switch (layerRenderer)
+    {
+      case AC.CIM.CIMTinUniqueValueRenderer:
+        isSupported = true;
+        break;
+      default:
+        // TODO: log error here that a renderer is unsupported
+        break;
+    }
+
+    if (isSupported)
+    {
+      StoredTinRenderer = layerRenderer;
+    }
+  }
+
+  /// <summary>
+  /// Processes a las layer's point color by the stored <see cref="StoredRenderer"/>, and stores the point's id and color proxy to the <see cref="ColorProxyCache"/>.
+  /// POC: logic probably can be combined with ProcessFeatureLayerColor.
+  /// </summary>
+  /// <param name="point"></param>
+  public void ProcessLasLayerColor(ACD.Analyst3D.LasPoint point, string pointApplicationId)
+  {
+    // get the color from the renderer and point
+    AC.CIM.CIMColor? color;
+    switch (StoredTinRenderer)
+    {
+      case AC.CIM.CIMTinUniqueValueRenderer uniqueValueRenderer:
+        color = GetPointColorByUniqueValueRenderer(uniqueValueRenderer, point);
+        break;
+
+      default:
+        return;
+    }
+
+    // get or create the color proxy for the point
+    int argb = CIMColorToInt(color ?? point.RGBColor);
+    AddObjectIdToColorProxyCache(pointApplicationId, argb);
+  }
+
+  // Retrieves the las point color from a unique value renderer
+  // unique renderers have groups of conditions that may affect the color of a feature
+  // resulting in a different color than the default renderer symbol color
+  private AC.CIM.CIMColor? GetPointColorByUniqueValueRenderer(
+    AC.CIM.CIMTinUniqueValueRenderer renderer,
+    ACD.Analyst3D.LasPoint point
+  )
+  {
+    foreach (AC.CIM.CIMUniqueValueGroup group in renderer.Groups)
+    {
+      foreach (AC.CIM.CIMUniqueValueClass groupClass in group.Classes)
+      {
+        foreach (AC.CIM.CIMUniqueValue value in groupClass.Values)
+        {
+          // all field values have to match the row values
+          for (int i = 0; i < value.FieldValues.Length; i++)
+          {
+            string groupValue = value.FieldValues[i].Replace("<Null>", "");
+            object? pointValue = point.ClassCode;
+
+            if (ValuesAreEqual(groupValue, pointValue))
+            {
+              return groupClass.Symbol.Symbol.GetColor();
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /// <summary>
+  /// Processes a feature layer's row color by the stored <see cref="StoredRenderer"/>, and stores the row's id and color proxy to the <see cref="ColorProxyCache"/>.
+  /// </summary>
+  /// <param name="row"></param>
+  /// <returns></returns>
+  /// <exception cref="ACD.Exceptions.GeodatabaseException"></exception>
+  public void ProcessFeatureLayerColor(ACD.Row row, string rowApplicationId)
+  {
+    // if stored color is not null, this means the renderer was a simple renderer that applies to the entire layer, and was already created.
+    // just add the row application id to the color proxy.
+    if (StoredColor is int existingColorProxyId)
+    {
+      AddObjectIdToColorProxyCache(rowApplicationId, existingColorProxyId);
+      return;
+    }
+
+    // get the color from the renderer and row
+    AC.CIM.CIMColor? color = null;
+    switch (StoredRenderer)
+    {
+      // simple renderers do not rely on fields, so the color can be retrieved from the renderer directly
+      case AC.CIM.CIMSimpleRenderer simpleRenderer:
+        color = simpleRenderer.Symbol.Symbol.GetColor();
+        break;
+
+      case AC.CIM.CIMUniqueValueRenderer uniqueValueRenderer:
+        color = GetRowColorByUniqueValueRenderer(uniqueValueRenderer, row);
+        break;
+
+      case AC.CIM.CIMClassBreaksRenderer classBreaksRenderer:
+        color = GetRowColorByClassBreaksRenderer(classBreaksRenderer, row);
+        break;
+    }
+
+    if (color is null)
+    {
+      // TODO: log error or throw exception that color could not be retrieved
+      return;
+    }
+
+    // get or create the color proxy for the row
+    int argb = CIMColorToInt(color);
+    AddObjectIdToColorProxyCache(rowApplicationId, argb);
+
+    // store color if from simple renderer
+    if (StoredRenderer is AC.CIM.CIMSimpleRenderer)
+    {
+      StoredColor = argb;
+    }
+  }
+
+  // Retrieves the row color from a class breaks renderer
+  // unique renderers have groups of conditions that may affect the color of a feature
+  // resulting in a different color than the default renderer symbol color
+  private AC.CIM.CIMColor? GetRowColorByClassBreaksRenderer(AC.CIM.CIMClassBreaksRenderer renderer, ACD.Row row)
+  {
+    AC.CIM.CIMColor? color = null;
+
+    // get the default symbol color
+    if (renderer.DefaultSymbol?.Symbol.GetColor() is AC.CIM.CIMColor defaultColor)
+    {
+      color = defaultColor;
+    }
+
+    // get the first stored field, since this renderer should only have 1 field
+    double storedFieldValue = Convert.ToDouble(row[StoredRendererFields.First()]);
+
+    List<AC.CIM.CIMClassBreak> reversedBreaks = new(renderer.Breaks);
+    reversedBreaks.Reverse();
+    foreach (var rBreak in reversedBreaks)
+    {
+      // keep looping until the last matching condition
+      if (storedFieldValue <= rBreak.UpperBound)
+      {
+        if (rBreak.Symbol.Symbol.GetColor() is AC.CIM.CIMColor breakColor)
+        {
+          color = breakColor;
+        }
+        else
+        {
+          // TODO: log error here, could not retrieve break color from symbol
+        }
+      }
+    }
+
+    return color;
+  }
+
+  // Retrieves the row color from a unique value renderer
+  // unique renderers have groups of conditions that may affect the color of a feature
+  // resulting in a different color than the default renderer symbol color
+  private AC.CIM.CIMColor? GetRowColorByUniqueValueRenderer(AC.CIM.CIMUniqueValueRenderer renderer, ACD.Row row)
+  {
+    AC.CIM.CIMColor? color = null;
+
+    // get the default symbol color
+    if (renderer.DefaultSymbol?.Symbol.GetColor() is AC.CIM.CIMColor defaultColor)
+    {
+      color = defaultColor;
+    }
+
+    // note: usually there is only 1 group
+    foreach (AC.CIM.CIMUniqueValueGroup group in renderer.Groups)
+    {
+      // loop through all values in groups to see if any have met conditions that result in a different color
+      foreach (AC.CIM.CIMUniqueValueClass groupClass in group.Classes)
+      {
+        bool groupConditionsMet = true;
+        foreach (AC.CIM.CIMUniqueValue value in groupClass.Values)
+        {
+          // all field values have to match the row values
+          for (int i = 0; i < StoredRendererFields.Count; i++)
+          {
+            string groupValue = value.FieldValues[i];
+            object? rowValue = row[StoredRendererFields[i]];
+
+            if (!ValuesAreEqual(groupValue, rowValue))
+            {
+              groupConditionsMet = false;
+              break;
+            }
+          }
+        }
+
+        // set the group color to class symbol color if conditions are met
+        if (groupConditionsMet)
+        {
+          if (groupClass.Symbol.Symbol.GetColor() is AC.CIM.CIMColor groupColor)
+          {
+            color = groupColor;
+          }
+          else
+          {
+            // TODO: log error here, could not retrieve group color from symbol
+          }
+        }
+      }
+    }
+
+    return color;
+  }
+
+  /// <summary>
+  /// Compares the label string of a UniqueValueRenderer (groupValue), and an object value (row, las point), to determine if they are equal
+  /// </summary>
+  /// <param name="objectValue"></param>
+  /// <param name="groupValue"></param>
+  private bool ValuesAreEqual(string groupValue, object? objectValue)
+  {
+    switch (objectValue)
+    {
+      case int:
+      case short:
+      case long:
+      case byte:
+        string objectValueString = Convert.ToString(objectValue) ?? "";
+        return groupValue.Equals(objectValueString);
+
+      case string:
+        return groupValue.Equals(objectValue);
+
+      // POC: these are tricky to compare with the label strings accurately, so will trim both values to 5 decimal places.
+      case double d:
+        return double.TryParse(groupValue, out double groupDouble) && groupDouble - d < 0.000001;
+      case float f:
+        return float.TryParse(groupValue, out float groupFloat) && groupFloat - f < 0.000001;
+
+      default:
+        return false;
+    }
+  }
+
+  private void AddObjectIdToColorProxyCache(string objectId, int argb)
+  {
+    if (ColorProxyCache.TryGetValue(argb, out ColorProxy? colorProxy))
+    {
+      colorProxy.objects.Add(objectId);
+    }
+    else
+    {
+      ColorProxy newColorProxy =
+        new()
+        {
+          name = argb.ToString(),
+          objects = new() { objectId },
+          value = argb,
+          applicationId = argb.ToString()
+        };
+
+      ColorProxyCache.Add(argb, newColorProxy);
+    }
+  }
+
+  private int ArgbToInt(int a, int r, int g, int b)
+  {
+    return (a << 24) | (r << 16) | (g << 8) | b;
+  }
+
+  // Gets the argb int from a CIMColor
+  // Defaults to assuming CIMColor.Values represent the red, green, and blue channels.
+  private int CIMColorToInt(AC.CIM.CIMColor color)
+  {
+    switch (color)
+    {
+      case AC.CIM.CIMHSVColor hsv:
+        (float hsvR, float hsvG, float hsvB) = RgbFromHsv(hsv.H, hsv.S, hsv.V);
+        return ArgbToInt(
+          (int)Math.Round(hsv.Alpha),
+          (int)Math.Round(hsvR * 255),
+          (int)Math.Round(hsvG * 255),
+          (int)Math.Round(hsvB * 255)
+        );
+
+      case AC.CIM.CIMCMYKColor cmyk:
+        float k = cmyk.K;
+        int cmykR = Convert.ToInt32(255 * (1 - cmyk.C) * (1 - k));
+        int cmykG = Convert.ToInt32(255 * (1 - cmyk.M) * (1 - k));
+        int cmykB = Convert.ToInt32(255 * (1 - cmyk.Y) * (1 - k));
+        return ArgbToInt((int)Math.Round(cmyk.Alpha), cmykR, cmykG, cmykB);
+
+      default:
+        return ArgbToInt(
+          (int)Math.Round(color.Alpha),
+          (int)Math.Round(color.Values[0]),
+          (int)Math.Round(color.Values[1]),
+          (int)Math.Round(color.Values[2])
+        );
+    }
+  }
+
+  private (float, float, float) RgbFromHsv(float hue, float saturation, float value)
+  {
+    // Translates HSV color to RGB color
+    // H: 0.0 - 360.0, S: 0.0 - 100.0, V: 0.0 - 100.0
+    // R, G, B: 0.0 - 1.0
+
+    float c = (value / 100) * (saturation / 100);
+    float x = c * (1 - Math.Abs(((hue / 60) % 2) - 1));
+    float m = (value / 100) - c;
+
+    float r = 0;
+    float g = 0;
+    float b = 0;
+
+    if (hue >= 0 && hue < 60)
+    {
+      r = c;
+      g = x;
+      b = 0;
+    }
+    else if (hue >= 60 && hue < 120)
+    {
+      r = x;
+      g = c;
+      b = 0;
+    }
+    else if (hue >= 120 && hue < 180)
+    {
+      r = 0;
+      g = c;
+      b = x;
+    }
+    else if (hue >= 180 && hue < 240)
+    {
+      r = 0;
+      g = x;
+      b = c;
+    }
+    else if (hue >= 240 && hue < 300)
+    {
+      r = x;
+      g = 0;
+      b = c;
+    }
+    else if (hue >= 300 && hue < 360)
+    {
+      r = c;
+      g = 0;
+      b = x;
+    }
+
+    r += m;
+    g += m;
+    b += m;
+
+    return (r, g, b);
+  }
+}

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/HostApp/ArcGISLayerUnpacker.cs

@@ -0,0 +1,97 @@
+using Speckle.Connectors.ArcGIS.HostApp.Extensions;
+using Speckle.Sdk.Models.Collections;
+
+namespace Speckle.Connectors.ArcGIS.HostApp;
+
+public class ArcGISLayerUnpacker
+{
+  /// <summary>
+  /// Cache of all collections created by unpacked Layer MapMembers. Key is the Speckle applicationId (Layer URI).
+  /// </summary>
+  public Dictionary<string, Collection> CollectionCache { get; } = new();
+
+  /// <summary>
+  /// Mapmembers can be layers containing objects, or LayerContainers containing other layers.
+  /// Unpacks selected mapMembers and creates their corresponding collection on the root collection.
+  /// </summary>
+  /// <param name="mapMembers"></param>
+  /// <param name="parentCollection"></param>
+  /// <returns>List of layers containing objects.</returns>
+  /// <exception cref="AC.CalledOnWrongThreadException">Thrown when this method is *not* called on the MCT, because this method accesses mapmember fields</exception>
+  public List<ADM.MapMember> UnpackSelection(
+    IEnumerable<ADM.MapMember> mapMembers,
+    Collection parentCollection,
+    List<ADM.MapMember>? objects = null
+  )
+  {
+    if (objects is null)
+    {
+      objects = new();
+    }
+
+    foreach (ADM.MapMember mapMember in mapMembers)
+    {
+      switch (mapMember)
+      {
+        case ADM.ILayerContainer container:
+          Collection containerCollection = CreateAndCacheMapMemberCollection(mapMember, true);
+          parentCollection.elements.Add(containerCollection);
+
+          UnpackSelection(container.Layers, containerCollection, objects);
+          break;
+
+        default:
+          if (!(objects.Contains(mapMember)))
+          {
+            Collection collection = CreateAndCacheMapMemberCollection(mapMember);
+            parentCollection.elements.Add(collection);
+            objects.Add(mapMember);
+          }
+          break;
+      }
+    }
+
+    return objects;
+  }
+
+  private Collection CreateAndCacheMapMemberCollection(ADM.MapMember mapMember, bool isLayerContainer = false)
+  {
+    string mapMemberApplicationId = mapMember.GetSpeckleApplicationId();
+    Collection collection =
+      new()
+      {
+        name = mapMember.Name,
+        applicationId = mapMemberApplicationId,
+        ["type"] = mapMember.GetType().Name
+      };
+
+    switch (mapMember)
+    {
+      case ADM.IDisplayTable displayTable: // get fields from layers that implement IDisplayTable, eg FeatureLayer or StandaloneTable
+        Dictionary<string, string>? fields = displayTable
+          .GetFieldDescriptions()
+          .ToDictionary(field => field.Name, field => field.Type.ToString());
+        collection["fields"] = fields;
+        if (mapMember is ADM.BasicFeatureLayer basicFeatureLayer)
+        {
+          collection["shapeType"] = basicFeatureLayer.ShapeType.ToString();
+        }
+        break;
+
+      case ADM.Layer layer:
+        collection["mapLayerType"] = layer.MapLayerType.ToString();
+        break;
+
+      case ADM.ILayerContainer:
+      default:
+        break;
+    }
+
+    if (!isLayerContainer) // do not cache layer containers, since these won't contain any objects
+    {
+      CollectionCache.Add(mapMemberApplicationId, collection);
+    }
+
+    return collection;
+  }
+}

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/HostApp/Extensions/SpeckleApplicationIdExtensions.cs

@@ -0,0 +1,31 @@
+using ArcGIS.Core.Data.Raster;
+
+namespace Speckle.Connectors.ArcGIS.HostApp.Extensions;
+
+public static class SpeckleApplicationIdExtensions
+{
+  /// <summary>
+  /// Retrieves the Speckle application id for map members
+  /// </summary>
+  public static string GetSpeckleApplicationId(this ADM.MapMember mapMember) => mapMember.URI;
+
+  /// <summary>
+  /// Constructs the Speckle application id for Features as a concatenation of the layer URI (applicationId)
+  /// and the row OID (index of row in layer).
+  /// </summary>
+  /// <exception cref="ACD.Exceptions.GeodatabaseException">Throws when this is *not* called on MCT. Use QueuedTask.Run.</exception>
+  public static string GetSpeckleApplicationId(this ACD.Row row, string layerApplicationId) =>
+    $"{layerApplicationId}_{row.GetObjectID()}";
+
+  /// <summary>
+  /// Constructs the Speckle application id for Raster as a concatenation of the layer URI (applicationId) and 0-index
+  /// </summary>
+  public static string GetSpeckleApplicationId(this Raster _, string layerApplicationId) => $"{layerApplicationId}_0";
+
+  /// <summary>
+  /// Constructs the Speckle application id for LasDatasets as a concatenation of the layer URI (applicationId)
+  /// and point OID.
+  /// </summary>
+  public static string GetSpeckleApplicationId(this ACD.Analyst3D.LasPoint point, string layerApplicationId) =>
+    $"{layerApplicationId}_{point.PointID}";
+}

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/HostApp/SyncToQueuedTask.cs

@@ -1,9 +0,0 @@
-using ArcGIS.Desktop.Framework.Threading.Tasks;
-using Speckle.Connectors.Utils.Operations;
-
-namespace Speckle.Connectors.ArcGIS.HostApp;
-
-public class SyncToQueuedTask : ISyncToThread
-{
-  public Task<T> RunOnThread<T>(Func<T> func) => QueuedTask.Run(func);
-}

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Operations/Receive/ArcGISHostObjectBuilder.cs

@@ -5,13 +5,14 @@ using ArcGIS.Desktop.Framework.Threading.Tasks;
 using ArcGIS.Desktop.Mapping;
 using Speckle.Connectors.ArcGIS.HostApp;
 using Speckle.Connectors.ArcGIS.Utils;
-using Speckle.Connectors.Utils.Builders;
-using Speckle.Connectors.Utils.Conversion;
-using Speckle.Connectors.Utils.Instances;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Instances;
+using Speckle.Connectors.Common.Operations;
 using Speckle.Converters.ArcGIS3;
 using Speckle.Converters.ArcGIS3.Utils;
 using Speckle.Converters.Common;
-using Speckle.Objects.GIS;
+using Speckle.Objects.Data;
 using Speckle.Objects.Other;
 using Speckle.Sdk;
 using Speckle.Sdk.Models;
@@ -19,7 +20,6 @@ using Speckle.Sdk.Models.Collections;
 using Speckle.Sdk.Models.GraphTraversal;
 using Speckle.Sdk.Models.Instances;
 using Speckle.Sdk.Models.Proxies;
-using RasterLayer = Speckle.Objects.GIS.RasterLayer;
 
 namespace Speckle.Connectors.ArcGIS.Operations.Receive;
 
@@ -28,40 +28,50 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
   private readonly IRootToHostConverter _converter;
   private readonly IFeatureClassUtils _featureClassUtils;
   private readonly ILocalToGlobalUnpacker _localToGlobalUnpacker;
-  private readonly ILocalToGlobalConverterUtils _localToGlobalConverterUtils;
-  private readonly ICrsUtils _crsUtils;
+  private readonly LocalToGlobalConverterUtils _localToGlobalConverterUtils;
 
   // POC: figure out the correct scope to only initialize on Receive
-  private readonly IConversionContextStack<ArcGISDocument, Unit> _contextStack;
+  private readonly IConverterSettingsStore<ArcGISConversionSettings> _settingsStore;
   private readonly GraphTraversal _traverseFunction;
   private readonly ArcGISColorManager _colorManager;
 
   public ArcGISHostObjectBuilder(
     IRootToHostConverter converter,
-    IConversionContextStack<ArcGISDocument, Unit> contextStack,
+    IConverterSettingsStore<ArcGISConversionSettings> settingsStore,
     IFeatureClassUtils featureClassUtils,
     ILocalToGlobalUnpacker localToGlobalUnpacker,
-    ILocalToGlobalConverterUtils localToGlobalConverterUtils,
-    ICrsUtils crsUtils,
+    LocalToGlobalConverterUtils localToGlobalConverterUtils,
     GraphTraversal traverseFunction,
     ArcGISColorManager colorManager
   )
   {
     _converter = converter;
-    _contextStack = contextStack;
+    _settingsStore = settingsStore;
     _featureClassUtils = featureClassUtils;
     _localToGlobalUnpacker = localToGlobalUnpacker;
     _localToGlobalConverterUtils = localToGlobalConverterUtils;
     _traverseFunction = traverseFunction;
     _colorManager = colorManager;
-    _crsUtils = crsUtils;
   }
 
-  public async Task<HostObjectBuilderResult> Build(
+  public Task<HostObjectBuilderResult> Build(
     Base rootObject,
     string projectName,
     string modelName,
-    Action<string, double?>? onOperationProgressed,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
+  )
+  {
+    return QueuedTask.Run(
+      () => BuildInternal(rootObject, projectName, modelName, onOperationProgressed, cancellationToken)
+    );
+  }
+
+  private HostObjectBuilderResult BuildInternal(
+    Base rootObject,
+    string projectName,
+    string modelName,
+    IProgress<CardProgress> onOperationProgressed,
     CancellationToken cancellationToken
   )
   {
@@ -69,10 +79,10 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
     // ATM, GIS commit CRS is stored per layer (in FeatureClass converter), but should be moved to the Root level too
 
     // Prompt the UI conversion started. Progress bar will swoosh.
-    onOperationProgressed?.Invoke("Converting", null);
+    onOperationProgressed.Report(new("Converting", null));
 
     // get materials
-    List<RenderMaterialProxy>? materials = (rootObject["renderMaterialProxies"] as List<object>)
+    List<RenderMaterialProxy>? materials = (rootObject[ProxyKeys.RENDER_MATERIAL] as List<object>)
       ?.Cast<RenderMaterialProxy>()
       .ToList();
     if (materials != null)
@@ -81,14 +91,14 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
     }
 
     // get colors
-    List<ColorProxy>? colors = (rootObject["colorProxies"] as List<object>)?.Cast<ColorProxy>().ToList();
+    List<ColorProxy>? colors = (rootObject[ProxyKeys.COLOR] as List<object>)?.Cast<ColorProxy>().ToList();
     if (colors != null)
     {
       _colorManager.ParseColors(colors, onOperationProgressed);
     }
 
     int count = 0;
-    List<LocalToGlobalMap> objectsToConvert = GetObjectsToConvert(rootObject);
+    IReadOnlyCollection<LocalToGlobalMap> objectsToConvert = GetObjectsToConvert(rootObject);
     Dictionary<TraversalContext, ObjectConversionTracker> conversionTracker = new();
 
     // 1. convert everything
@@ -103,13 +113,15 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
       try
       {
         obj = _localToGlobalConverterUtils.TransformObjects(objectToConvert.AtomicObject, objectToConvert.Matrix);
-        object? conversionResult =
-          obj is GisNonGeometricFeature
-            ? null
-            : await QueuedTask.Run(() => _converter.Convert(obj)).ConfigureAwait(false);
+        object conversionResult = _converter.Convert(obj);
 
         string nestedLayerPath = $"{string.Join("\\", path)}";
-        if (objectToConvert.TraversalContext.Parent?.Current is not VectorLayer)
+
+        if (obj is ArcgisObject gisObj)
+        {
+          nestedLayerPath += $"\\{gisObj.name}";
+        }
+        else
         {
           nestedLayerPath += $"\\{obj.speckle_type.Split(".")[^1]}"; // add sub-layer by speckleType, for non-GIS objects
         }
@@ -124,26 +136,25 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
       {
         results.Add(new(Status.ERROR, obj, null, null, ex));
       }
-      onOperationProgressed?.Invoke("Converting", (double)++count / objectsToConvert.Count);
+      onOperationProgressed.Report(new("Converting", (double)++count / objectsToConvert.Count));
     }
 
     // 2.1. Group conversionTrackers (to write into datasets)
-    onOperationProgressed?.Invoke("Grouping features into layers", null);
-    Dictionary<string, List<(TraversalContext, ObjectConversionTracker)>> convertedGroups = await QueuedTask
-      .Run(() =>
-      {
-        return _featureClassUtils.GroupConversionTrackers(conversionTracker, onOperationProgressed);
-      })
-      .ConfigureAwait(false);
+    onOperationProgressed.Report(new("Grouping features into layers", null));
+    Dictionary<string, List<(TraversalContext, ObjectConversionTracker)>> convertedGroups =
+      _featureClassUtils.GroupConversionTrackers(
+        conversionTracker,
+        (s, progres) => onOperationProgressed.Report(new(s, progres))
+      );
 
     // 2.2. Write groups of objects to Datasets
-    onOperationProgressed?.Invoke("Writing to Database", null);
-    await QueuedTask
-      .Run(() =>
-      {
-        _featureClassUtils.CreateDatasets(conversionTracker, convertedGroups, onOperationProgressed);
-      })
-      .ConfigureAwait(false);
+    onOperationProgressed.Report(new("Writing to Database", null));
+
+    _featureClassUtils.CreateDatasets(
+      conversionTracker,
+      convertedGroups,
+      (s, progres) => onOperationProgressed.Report(new(s, progres))
+    );
 
     // 3. add layer and tables to the Map and Table Of Content
 
@@ -152,7 +163,7 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
 
     int bakeCount = 0;
     Dictionary<string, (MapMember, CIMUniqueValueRenderer?)> bakedMapMembers = new();
-    onOperationProgressed?.Invoke("Adding to Map", bakeCount);
+    onOperationProgressed.Report(new("Adding to Map", bakeCount));
 
     foreach (var item in conversionTracker)
     {
@@ -195,8 +206,7 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
       else
       {
         // no layer yet, create and add layer to Map
-        MapMember mapMember = await AddDatasetsToMap(trackerItem, createdLayerGroups, projectName, modelName)
-          .ConfigureAwait(false);
+        MapMember mapMember = AddDatasetsToMap(trackerItem, createdLayerGroups, projectName, modelName);
 
         // add layer and layer URI to tracker
         trackerItem.AddConvertedMapMember(mapMember);
@@ -214,7 +224,8 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
         // add report item
         AddResultsFromTracker(trackerItem, results);
       }
-      onOperationProgressed?.Invoke("Adding to Map", (double)++bakeCount / conversionTracker.Count);
+
+      onOperationProgressed.Report(new("Adding to Map", (double)++bakeCount / conversionTracker.Count));
     }
 
     // apply renderers to baked layers
@@ -223,28 +234,24 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
       if (bakedMember.Value.Item1 is FeatureLayer fLayer)
       {
         // Set the feature layer's renderer.
-        await QueuedTask.Run(() => fLayer.SetRenderer(bakedMember.Value.Item2)).ConfigureAwait(false);
+        fLayer.SetRenderer(bakedMember.Value.Item2);
       }
     }
     bakedObjectIds.AddRange(createdLayerGroups.Values.Select(x => x.URI));
 
     // TODO: validated a correct set regarding bakedobject ids
-    return new(bakedObjectIds, results);
+    return new HostObjectBuilderResult(bakedObjectIds, results);
   }
 
-  private List<LocalToGlobalMap> GetObjectsToConvert(Base rootObject)
+  private IReadOnlyCollection<LocalToGlobalMap> GetObjectsToConvert(Base rootObject)
   {
     // keep GISlayers in the list, because they are still needed to extract CRS of the commit (code below)
     List<TraversalContext> objectsToConvertTc = _traverseFunction.Traverse(rootObject).ToList();
 
-    // get CRS from any present VectorLayer
-    Base? vLayer = objectsToConvertTc.FirstOrDefault(x => x.Current is VectorLayer)?.Current;
-    _crsUtils.FindSetCrsDataOnReceive(vLayer);
-
     // now filter the objects
     objectsToConvertTc = objectsToConvertTc.Where(ctx => ctx.Current is not Collection).ToList();
 
-    var instanceDefinitionProxies = (rootObject["instanceDefinitionProxies"] as List<object>)
+    var instanceDefinitionProxies = (rootObject[ProxyKeys.INSTANCE_DEFINITION] as List<object>)
       ?.Cast<InstanceDefinitionProxy>()
       .ToList();
 
@@ -294,79 +301,72 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
     }
   }
 
-  private Task<MapMember> AddDatasetsToMap(
+  private MapMember AddDatasetsToMap(
     ObjectConversionTracker trackerItem,
     Dictionary<string, GroupLayer> createdLayerGroups,
     string projectName,
     string modelName
   )
   {
-    return QueuedTask.Run(() =>
+    // get layer details
+    string? datasetId = trackerItem.DatasetId; // should not be null here
+    Uri uri = new($"{_settingsStore.Current.SpeckleDatabasePath.AbsolutePath.Replace('/', '\\')}\\{datasetId}");
+    string nestedLayerName = trackerItem.NestedLayerName;
+
+    // add group for the current layer
+    string shortName = nestedLayerName.Split("\\")[^1];
+    string nestedLayerPath = string.Join("\\", nestedLayerName.Split("\\").SkipLast(1));
+
+    // if no general group layer found
+    if (createdLayerGroups.Count == 0)
     {
-      // get layer details
-      string? datasetId = trackerItem.DatasetId; // should not be null here
-      Uri uri =
-        new($"{_contextStack.Current.Document.SpeckleDatabasePath.AbsolutePath.Replace('/', '\\')}\\{datasetId}");
-      string nestedLayerName = trackerItem.NestedLayerName;
+      Map map = _settingsStore.Current.Map;
+      GroupLayer mainGroupLayer = LayerFactory.Instance.CreateGroupLayer(map, 0, $"{projectName}: {modelName}");
+      mainGroupLayer.SetExpanded(true);
+      createdLayerGroups["Basic Speckle Group"] = mainGroupLayer; // key doesn't really matter here
+    }
 
-      // add group for the current layer
-      string shortName = nestedLayerName.Split("\\")[^1];
-      string nestedLayerPath = string.Join("\\", nestedLayerName.Split("\\").SkipLast(1));
+    var groupLayer = CreateNestedGroupLayer(nestedLayerPath, createdLayerGroups);
 
-      // if no general group layer found
-      if (createdLayerGroups.Count == 0)
+    // Most of the Speckle-written datasets will be containing geometry and added as Layers
+    // although, some datasets might be just tables (e.g. native GIS Tables, in the future maybe Revit schedules etc.
+    // We can create a connection to the dataset in advance and determine its type, but this will be more
+    // expensive, than assuming by default that it's a layer with geometry (which in most cases it's expected to be)
+    try
+    {
+      var layer = LayerFactory.Instance.CreateLayer(uri, groupLayer, layerName: shortName);
+      if (layer == null)
       {
-        Map map = _contextStack.Current.Document.Map;
-        GroupLayer mainGroupLayer = LayerFactory.Instance.CreateGroupLayer(map, 0, $"{projectName}: {modelName}");
-        mainGroupLayer.SetExpanded(true);
-        createdLayerGroups["Basic Speckle Group"] = mainGroupLayer; // key doesn't really matter here
+        throw new SpeckleException($"Layer '{shortName}' was not created");
       }
+      layer.SetExpanded(false);
 
-      var groupLayer = CreateNestedGroupLayer(nestedLayerPath, createdLayerGroups);
-
-      // Most of the Speckle-written datasets will be containing geometry and added as Layers
-      // although, some datasets might be just tables (e.g. native GIS Tables, in the future maybe Revit schedules etc.
-      // We can create a connection to the dataset in advance and determine its type, but this will be more
-      // expensive, than assuming by default that it's a layer with geometry (which in most cases it's expected to be)
-      try
+      // if Scene
+      // https://community.esri.com/t5/arcgis-pro-sdk-questions/sdk-equivalent-to-changing-layer-s-elevation/td-p/1346139
+      if (_settingsStore.Current.Map.IsScene)
       {
-        var layer = LayerFactory.Instance.CreateLayer(uri, groupLayer, layerName: shortName);
-        if (layer == null)
+        var groundSurfaceLayer = _settingsStore.Current.Map.GetGroundElevationSurfaceLayer();
+        var layerElevationSurface = new CIMLayerElevationSurface { ElevationSurfaceLayerURI = groundSurfaceLayer.URI, };
+
+        // for Feature Layers
+        if (layer.GetDefinition() is CIMFeatureLayer cimLyr)
         {
-          throw new SpeckleException($"Layer '{shortName}' was not created");
+          cimLyr.LayerElevation = layerElevationSurface;
+          layer.SetDefinition(cimLyr);
         }
-        layer.SetExpanded(false);
-
-        // if Scene
-        // https://community.esri.com/t5/arcgis-pro-sdk-questions/sdk-equivalent-to-changing-layer-s-elevation/td-p/1346139
-        if (_contextStack.Current.Document.Map.IsScene)
-        {
-          var groundSurfaceLayer = _contextStack.Current.Document.Map.GetGroundElevationSurfaceLayer();
-          var layerElevationSurface = new CIMLayerElevationSurface
-          {
-            ElevationSurfaceLayerURI = groundSurfaceLayer.URI,
-          };
-
-          // for Feature Layers
-          if (layer.GetDefinition() is CIMFeatureLayer cimLyr)
-          {
-            cimLyr.LayerElevation = layerElevationSurface;
-            layer.SetDefinition(cimLyr);
-          }
-        }
-
-        return (MapMember)layer;
       }
-      catch (ArgumentException)
-      {
-        StandaloneTable table = StandaloneTableFactory.Instance.CreateStandaloneTable(
-          uri,
-          groupLayer,
-          tableName: shortName
-        );
-        return table;
-      }
-    });
+
+      return layer;
+    }
+    catch (ArgumentException)
+    {
+      StandaloneTable table = StandaloneTableFactory.Instance.CreateStandaloneTable(
+        uri,
+        groupLayer,
+        tableName: shortName
+      );
+      return table;
+    }
   }
 
   private GroupLayer CreateNestedGroupLayer(string nestedLayerPath, Dictionary<string, GroupLayer> createdLayerGroups)
@@ -408,17 +408,4 @@ public class ArcGISHostObjectBuilder : IHostObjectBuilder
     var originalPath = reverseOrderPath.Reverse().ToArray();
     return originalPath.Where(x => !string.IsNullOrEmpty(x)).ToArray();
   }
-
-  [Pure]
-  private static bool HasGISParent(TraversalContext context)
-  {
-    List<Base> gisLayers = context.GetAscendants().Where(IsGISType).Where(obj => obj != context.Current).ToList();
-    return gisLayers.Count > 0;
-  }
-
-  [Pure]
-  private static bool IsGISType(Base obj)
-  {
-    return obj is RasterLayer or VectorLayer;
-  }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Operations/Send/ArcGISRootObjectBuilder.cs

@@ -1,188 +1,362 @@
-using System.Diagnostics;
+using ArcGIS.Core.Data.Raster;
 using ArcGIS.Core.Geometry;
 using ArcGIS.Desktop.Framework.Threading.Tasks;
-using ArcGIS.Desktop.Mapping;
 using Microsoft.Extensions.Logging;
 using Speckle.Connectors.ArcGIS.HostApp;
+using Speckle.Connectors.ArcGIS.HostApp.Extensions;
 using Speckle.Connectors.ArcGIS.Utils;
-using Speckle.Connectors.Utils.Builders;
-using Speckle.Connectors.Utils.Caching;
-using Speckle.Connectors.Utils.Conversion;
-using Speckle.Connectors.Utils.Extensions;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Extensions;
+using Speckle.Connectors.Common.Operations;
 using Speckle.Converters.ArcGIS3;
 using Speckle.Converters.Common;
-using Speckle.Objects.GIS;
 using Speckle.Sdk;
+using Speckle.Sdk.Logging;
 using Speckle.Sdk.Models;
 using Speckle.Sdk.Models.Collections;
-using Speckle.Sdk.Models.Proxies;
 
 namespace Speckle.Connectors.ArcGis.Operations.Send;
 
 /// <summary>
 /// Stateless builder object to turn an ISendFilter into a <see cref="Base"/> object
 /// </summary>
-public class ArcGISRootObjectBuilder : IRootObjectBuilder<MapMember>
+public class ArcGISRootObjectBuilder : IRootObjectBuilder<ADM.MapMember>
 {
   private readonly IRootToSpeckleConverter _rootToSpeckleConverter;
-  private readonly ISendConversionCache _sendConversionCache;
-  private readonly ArcGISColorManager _colorManager;
-  private readonly IConversionContextStack<ArcGISDocument, Unit> _contextStack;
-  private readonly MapMembersUtils _mapMemberUtils;
+  private readonly ArcGISLayerUnpacker _layerUnpacker;
+  private readonly ArcGISColorUnpacker _colorUnpacker;
+  private readonly IConverterSettingsStore<ArcGISConversionSettings> _converterSettings;
   private readonly ILogger<ArcGISRootObjectBuilder> _logger;
+  private readonly ISdkActivityFactory _activityFactory;
+  private readonly MapMembersUtils _mapMemberUtils;
 
   public ArcGISRootObjectBuilder(
-    ISendConversionCache sendConversionCache,
-    ArcGISColorManager colorManager,
-    IConversionContextStack<ArcGISDocument, Unit> contextStack,
+    ArcGISLayerUnpacker layerUnpacker,
+    ArcGISColorUnpacker colorUnpacker,
+    IConverterSettingsStore<ArcGISConversionSettings> converterSettings,
     IRootToSpeckleConverter rootToSpeckleConverter,
-    MapMembersUtils mapMemberUtils,
-    ILogger<ArcGISRootObjectBuilder> logger
+    ILogger<ArcGISRootObjectBuilder> logger,
+    ISdkActivityFactory activityFactory,
+    MapMembersUtils mapMemberUtils
   )
   {
-    _sendConversionCache = sendConversionCache;
-    _colorManager = colorManager;
-    _contextStack = contextStack;
+    _layerUnpacker = layerUnpacker;
+    _colorUnpacker = colorUnpacker;
+    _converterSettings = converterSettings;
     _rootToSpeckleConverter = rootToSpeckleConverter;
-    _mapMemberUtils = mapMemberUtils;
     _logger = logger;
+    _activityFactory = activityFactory;
+    _mapMemberUtils = mapMemberUtils;
   }
 
-  public async Task<RootObjectBuilderResult> Build(
-    IReadOnlyList<MapMember> objects,
-    SendInfo sendInfo,
-    Action<string, double?>? onOperationProgressed = null,
-    CancellationToken ct = default
+  public Task<RootObjectBuilderResult> Build(
+    IReadOnlyList<ADM.MapMember> layers,
+    SendInfo __,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
+  ) => QueuedTask.Run(() => BuildInternal(layers, __, onOperationProgressed, cancellationToken));
+
+  private async Task<RootObjectBuilderResult> BuildInternal(
+    IReadOnlyList<ADM.MapMember> layers,
+    SendInfo __,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
   )
   {
     // TODO: add a warning if Geographic CRS is set
     // "Data has been sent in the units 'degrees'. It is advisable to set the project CRS to Projected type (e.g. EPSG:32631) to be able to receive geometry correctly in CAD/BIM software"
 
-    int count = 0;
 
-    Collection rootObjectCollection = new() { name = MapView.Active.Map.Name }; //TODO: Collections
+    // 0 - Create Root collection and attach CRS properties
+    // CRS properties are useful for data based workflows coming out of gis applications
+    SpatialReference sr = _converterSettings.Current.ActiveCRSoffsetRotation.SpatialReference;
+    Dictionary<string, object?> spatialReference =
+      new()
+      {
+        ["name"] = sr.Name,
+        ["unit"] = sr.Unit.Name,
+        ["wkid"] = sr.Wkid,
+        ["wkt"] = sr.Wkt,
+      };
 
-    List<SendConversionResult> results = new(objects.Count);
-    var cacheHitCount = 0;
-    List<(GroupLayer, Collection)> nestedGroups = new();
+    Dictionary<string, object?> crs =
+      new()
+      {
+        ["trueNorthRadians"] = _converterSettings.Current.ActiveCRSoffsetRotation.TrueNorthRadians,
+        ["latOffset"] = _converterSettings.Current.ActiveCRSoffsetRotation.LatOffset,
+        ["lonOffset"] = _converterSettings.Current.ActiveCRSoffsetRotation.LonOffset,
+        ["spatialReference"] = spatialReference
+      };
 
-    // reorder selected layers by Table of Content (TOC) order
-    List<(MapMember, int)> layersWithDisplayPriority = _mapMemberUtils.GetLayerDisplayPriority(
-      MapView.Active.Map,
-      objects
-    );
+    Collection rootCollection =
+      new()
+      {
+        name = ADM.MapView.Active.Map.Name,
+        ["units"] = _converterSettings.Current.SpeckleUnits,
+        ["crs"] = crs
+      };
 
-    onOperationProgressed?.Invoke("Converting", null);
-
-    foreach ((MapMember mapMember, _) in layersWithDisplayPriority)
+    // 1 - Unpack the selected mapmembers
+    // In Arcgis, mapmembers are collections of other mapmember or objects.
+    // We need to unpack the selected mapmembers into all leaf-level mapmembers (containing just objects) and build the root collection structure during unpacking.
+    // Mapmember dynamically attached properties are also added at this step.
+    List<ADM.MapMember> unpackedLayers;
+    Dictionary<ADM.MapMember, long> layersWithFeatureCount;
+    long allFeaturesCount;
+    ADM.Map map = ADM.MapView.Active.Map;
+    IEnumerable<ADM.MapMember> layersOrdered = _mapMemberUtils.GetMapMembersInOrder(map, layers);
+    using (var _ = _activityFactory.Start("Unpacking selection"))
     {
-      ct.ThrowIfCancellationRequested();
-      var collectionHost = rootObjectCollection;
-      string applicationId = mapMember.URI;
-      string sourceType = mapMember.GetType().Name;
+      unpackedLayers = _layerUnpacker.UnpackSelection(layersOrdered, rootCollection);
 
-      Base converted;
-      try
+      // count number of features to convert. Raster layers are counter as 1 feature for now (not ideal)
+      layersWithFeatureCount = CountAllFeaturesInLayers(unpackedLayers);
+      allFeaturesCount = layersWithFeatureCount.Values.Sum();
+    }
+
+    List<SendConversionResult> results = new(unpackedLayers.Count);
+    onOperationProgressed.Report(new("Converting", null));
+    using (var convertingActivity = _activityFactory.Start("Converting objects"))
+    {
+      long count = 0;
+
+      foreach (var (layer, layerFeatureCount) in layersWithFeatureCount)
       {
-        int groupCount = nestedGroups.Count; // bake here, because count will change in the loop
-        // if the layer is not a part of the group, reset groups
-        for (int i = 0; i < groupCount; i++)
-        {
-          if (nestedGroups.Count > 0 && !nestedGroups[0].Item1.Layers.Select(x => x.URI).Contains(applicationId))
-          {
-            nestedGroups.RemoveAt(0);
-          }
-          else
-          {
-            // break at the first group, which contains current layer
-            break;
-          }
-        }
+        cancellationToken.ThrowIfCancellationRequested();
+        string layerApplicationId = layer.GetSpeckleApplicationId();
 
-        // don't use cache for group layers
-        if (
-          mapMember is not GroupLayer
-          && _sendConversionCache.TryGetValue(sendInfo.ProjectId, applicationId, out ObjectReference? value)
-        )
+        try
         {
-          converted = value;
-          cacheHitCount++;
-        }
-        else
-        {
-          if (mapMember is GroupLayer group)
+          // get the corresponding collection for this layer - we'll add all converted objects to the collection
+          if (_layerUnpacker.CollectionCache.TryGetValue(layerApplicationId, out Collection? layerCollection))
           {
-            // group layer will always come before it's contained layers
-            // keep active group last in the list
-            converted = new Collection();
-            nestedGroups.Insert(0, (group, (Collection)converted));
-          }
-          else
-          {
-            converted = await QueuedTask
-              .Run(() => (Collection)_rootToSpeckleConverter.Convert(mapMember))
-              .ConfigureAwait(false);
+            var status = Status.SUCCESS;
+            var sdkStatus = SdkActivityStatusCode.Ok;
 
-            // get units & Active CRS (for writing geometry coords)
-            converted["units"] = _contextStack.Current.Document.ActiveCRSoffsetRotation.SpeckleUnitString;
-
-            var spatialRef = _contextStack.Current.Document.ActiveCRSoffsetRotation.SpatialReference;
-            converted["crs"] = new CRS
+            // TODO: check cache first to see if this layer was previously converted
+            /*
+            if (_sendConversionCache.TryGetValue(
+              sendInfo.ProjectId,
+              layerApplicationId,
+              out ObjectReference? value
+            ))
             {
-              wkt = spatialRef.Wkt,
-              name = spatialRef.Name,
-              offset_y = Convert.ToSingle(_contextStack.Current.Document.ActiveCRSoffsetRotation.LatOffset),
-              offset_x = Convert.ToSingle(_contextStack.Current.Document.ActiveCRSoffsetRotation.LonOffset),
-              rotation = Convert.ToSingle(_contextStack.Current.Document.ActiveCRSoffsetRotation.TrueNorthRadians),
-              units_native = _contextStack.Current.Document.ActiveCRSoffsetRotation.SpeckleUnitString,
-            };
+
+            }
+            */
+
+            switch (layer)
+            {
+              case ADM.FeatureLayer featureLayer:
+                List<Base> convertedFeatureLayerObjects = ConvertFeatureLayerObjects(
+                  featureLayer,
+                  count,
+                  allFeaturesCount,
+                  onOperationProgressed,
+                  cancellationToken
+                );
+                layerCollection.elements.AddRange(convertedFeatureLayerObjects);
+                break;
+              case ADM.RasterLayer rasterLayer:
+                List<Base> convertedRasterLayerObjects = ConvertRasterLayerObjects(
+                  rasterLayer,
+                  count,
+                  allFeaturesCount,
+                  onOperationProgressed,
+                  cancellationToken
+                );
+                layerCollection.elements.AddRange(convertedRasterLayerObjects);
+                break;
+              case ADM.LasDatasetLayer lasDatasetLayer:
+                List<Base> convertedLasDatasetObjects = ConvertLasDatasetLayerObjects(
+                  lasDatasetLayer,
+                  count,
+                  allFeaturesCount,
+                  onOperationProgressed,
+                  cancellationToken
+                );
+                layerCollection.elements.AddRange(convertedLasDatasetObjects);
+                break;
+              default:
+                status = Status.ERROR;
+                sdkStatus = SdkActivityStatusCode.Error;
+                break;
+            }
+
+            count += layerFeatureCount;
+            results.Add(new(status, layerApplicationId, layer.GetType().Name, layerCollection));
+            convertingActivity?.SetStatus(sdkStatus);
+          }
+          else
+          {
+            throw new SpeckleException($"No converted Collection found for layer {layerApplicationId}.");
           }
-
-          // other common properties for layers and groups
-          converted["name"] = mapMember.Name;
-          converted.applicationId = applicationId;
         }
-
-        if (nestedGroups.Count == 0 || nestedGroups.Count == 1 && nestedGroups[0].Item2.applicationId == applicationId)
+        catch (Exception ex) when (!ex.IsFatal())
         {
-          // add to host if no groups, or current root group
-          collectionHost.elements.Add(converted);
-        }
-        else
-        {
-          // if we are adding a layer inside the group
-          var parentCollection = nestedGroups.FirstOrDefault(x =>
-            x.Item1.Layers.Select(y => y.URI).Contains(applicationId)
-          );
-          parentCollection.Item2.elements.Add(converted);
+          _logger.LogSendConversionError(ex, layer.GetType().Name);
+          results.Add(new(Status.ERROR, layerApplicationId, layer.GetType().Name, null, ex));
+          convertingActivity?.SetStatus(SdkActivityStatusCode.Error);
+          convertingActivity?.RecordException(ex);
         }
 
-        results.Add(new(Status.SUCCESS, applicationId, sourceType, converted));
+        await Task.Yield();
       }
-      catch (Exception ex) when (!ex.IsFatal())
-      {
-        _logger.LogSendConversionError(ex, sourceType);
-        results.Add(new(Status.ERROR, applicationId, sourceType, null, ex));
-      }
-
-      onOperationProgressed?.Invoke("Converting", (double)++count / objects.Count);
     }
 
     if (results.All(x => x.Status == Status.ERROR))
     {
-      throw new SpeckleConversionException("Failed to convert all objects."); // fail fast instead creating empty commit! It will appear as model card error with red color.
+      throw new SpeckleException("Failed to convert all objects."); // fail fast instead creating empty commit! It will appear as model card error with red color.
     }
 
-    // POC: Add Color Proxies
-    List<ColorProxy> colorProxies = _colorManager.UnpackColors(layersWithDisplayPriority);
-    rootObjectCollection["colorProxies"] = colorProxies;
+    // 3 -  Add Color Proxies
+    rootCollection[ProxyKeys.COLOR] = _colorUnpacker.ColorProxyCache.Values.ToList();
 
-    // POC: Log would be nice, or can be removed.
-    Debug.WriteLine(
-      $"Cache hit count {cacheHitCount} out of {objects.Count} ({(double)cacheHitCount / objects.Count})"
-    );
+    return new RootObjectBuilderResult(rootCollection, results);
+  }
 
-    return new RootObjectBuilderResult(rootObjectCollection, results);
+  private Dictionary<ADM.MapMember, long> CountAllFeaturesInLayers(List<ADM.MapMember> unpackedLayers)
+  {
+    Dictionary<ADM.MapMember, long> layersFeatureCount = new();
+
+    foreach (ADM.MapMember layer in unpackedLayers)
+    {
+      switch (layer)
+      {
+        case ADM.FeatureLayer featureLayer:
+          layersFeatureCount.Add(featureLayer, featureLayer.GetFeatureClass().GetCount());
+          break;
+        case ADM.RasterLayer rasterLayer:
+          // count Raster layer as 1 feature: not optimal but this is the approach for now
+          layersFeatureCount.Add(rasterLayer, 1);
+          break;
+        case ADM.LasDatasetLayer lasDatasetLayer:
+          var dataset = lasDatasetLayer.GetLasDataset();
+          // simple dataset.GetPointCount() keeps returning null, so switched to EstimatePointCount
+          layersFeatureCount.Add(
+            lasDatasetLayer,
+            (long)dataset.EstimatePointCount(dataset.GetDefinition().GetExtent())
+          );
+          break;
+      }
+    }
+    return layersFeatureCount;
+  }
+
+  private List<Base> ConvertFeatureLayerObjects(
+    ADM.FeatureLayer featureLayer,
+    long count,
+    long allFeaturesCount,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
+  )
+  {
+    string layerApplicationId = featureLayer.GetSpeckleApplicationId();
+    List<Base> convertedObjects = new();
+    // store the layer renderer for color unpacking
+    _colorUnpacker.StoreRendererAndFields(featureLayer);
+
+    // search the rows of the layer, where each row is treated like an object
+    // RowCursor is IDisposable but is not being correctly picked up by IDE warnings.
+    // This means we need to be carefully adding using statements based on the API documentation coming from each method/class
+    using (ACD.RowCursor rowCursor = featureLayer.Search())
+    {
+      while (rowCursor.MoveNext())
+      {
+        // allow cancellation before every feature
+        cancellationToken.ThrowIfCancellationRequested();
+
+        // Same IDisposable issue appears to happen on Row class too. Docs say it should always be disposed of manually by the caller.
+        using (ACD.Row row = rowCursor.Current)
+        {
+          // get application id. test for subtypes before defaulting to base type.
+          Base converted = _rootToSpeckleConverter.Convert(row);
+          string applicationId = row.GetSpeckleApplicationId(layerApplicationId);
+          converted.applicationId = applicationId;
+
+          convertedObjects.Add(converted);
+
+          // process the object color
+          _colorUnpacker.ProcessFeatureLayerColor(row, applicationId);
+        }
+        // update report
+        onOperationProgressed.Report(new("Converting", (double)++count / allFeaturesCount));
+      }
+    }
+
+    return convertedObjects;
+  }
+
+  // POC: raster colors are stored as mesh vertex colors in RasterToSpeckleConverter. Should probably move to color unpacker.
+  private List<Base> ConvertRasterLayerObjects(
+    ADM.RasterLayer rasterLayer,
+    long count,
+    long allFeaturesCount,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
+  )
+  {
+    string layerApplicationId = rasterLayer.GetSpeckleApplicationId();
+    List<Base> convertedObjects = new();
+    Raster raster = rasterLayer.GetRaster();
+
+    // check cancellation token before conversion
+    cancellationToken.ThrowIfCancellationRequested();
+    Base converted = _rootToSpeckleConverter.Convert(raster);
+    string applicationId = raster.GetSpeckleApplicationId(layerApplicationId);
+    converted.applicationId = applicationId;
+    convertedObjects.Add(converted);
+
+    // update report
+    onOperationProgressed.Report(new("Converting", (double)++count / allFeaturesCount));
+
+    return convertedObjects;
+  }
+
+  private List<Base> ConvertLasDatasetLayerObjects(
+    ADM.LasDatasetLayer lasDatasetLayer,
+    long count,
+    long allFeaturesCount,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
+  )
+  {
+    string layerApplicationId = lasDatasetLayer.GetSpeckleApplicationId();
+    List<Base> convertedObjects = new();
+
+    try
+    {
+      // store the layer renderer for color unpacking
+      _colorUnpacker.StoreRenderer(lasDatasetLayer);
+
+      using (ACD.Analyst3D.LasPointCursor ptCursor = lasDatasetLayer.SearchPoints(new ACD.Analyst3D.LasPointFilter()))
+      {
+        while (ptCursor.MoveNext())
+        {
+          // allow cancellation before every point
+          cancellationToken.ThrowIfCancellationRequested();
+
+          using (ACD.Analyst3D.LasPoint pt = ptCursor.Current)
+          {
+            Base converted = _rootToSpeckleConverter.Convert(pt);
+            string applicationId = pt.GetSpeckleApplicationId(layerApplicationId);
+            converted.applicationId = applicationId;
+            convertedObjects.Add(converted);
+
+            // process the object color
+            _colorUnpacker.ProcessLasLayerColor(pt, applicationId);
+          }
+          // update report
+          onOperationProgressed.Report(new("Converting", (double)++count / allFeaturesCount));
+        }
+      }
+    }
+    catch (ACD.Exceptions.TinException ex)
+    {
+      throw new SpeckleException("3D analyst extension is not enabled for .las layer operations", ex);
+    }
+
+    return convertedObjects;
   }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Speckle.Connectors.ArcGIS3.csproj

@@ -27,9 +27,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\..\Converters\ArcGIS\Speckle.Converters.ArcGIS3.DependencyInjection\Speckle.Converters.ArcGIS3.DependencyInjection.csproj" />
+    <ProjectReference Include="..\..\..\Converters\ArcGIS\Speckle.Converters.ArcGIS3\Speckle.Converters.ArcGIS3.csproj" />
     <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
-    <ProjectReference Include="..\..\..\Sdk\Speckle.Connectors.Utils\Speckle.Connectors.Utils.csproj" />
+    <ProjectReference Include="..\..\..\Sdk\Speckle.Connectors.Common\Speckle.Connectors.Common.csproj" />
   </ItemGroup>
 
   <Import Project="Esri.ArcGISPro.Extensions30.Speckle.targets" />

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/SpeckleDUI3ViewModel.cs

@@ -18,7 +18,7 @@ internal sealed class SpeckleDUI3ViewModel : DockPane
   /// </summary>
   protected override async Task InitializeAsync()
   {
-    await base.InitializeAsync().ConfigureAwait(false);
+    await base.InitializeAsync();
   }
 
   /// <summary>
@@ -26,7 +26,7 @@ internal sealed class SpeckleDUI3ViewModel : DockPane
   /// </summary>
   protected override async Task UninitializeAsync()
   {
-    await base.UninitializeAsync().ConfigureAwait(false);
+    await base.UninitializeAsync();
   }
 }
 

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/SpeckleDUI3Wrapper.cs

@@ -1,4 +1,5 @@
 using System.Windows.Controls;
+using Microsoft.Extensions.DependencyInjection;
 using Speckle.Connectors.DUI.WebView;
 
 namespace Speckle.Connectors.ArcGIS;
@@ -12,6 +13,6 @@ public class SpeckleDUI3Wrapper : UserControl
 
   private void Initialize()
   {
-    Content = SpeckleModule.Current.Container.Resolve<DUI3ControlWebView>();
+    Content = SpeckleModule.Current.Container.GetRequiredService<DUI3ControlWebView>();
   }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/SpeckleModule.cs

@@ -1,11 +1,9 @@
-using System.IO;
-using System.Reflection;
 using ArcGIS.Desktop.Framework;
-using Speckle.Autofac;
-using Speckle.Autofac.DependencyInjection;
-using Speckle.Connectors.Utils;
-using Speckle.Sdk.Common;
-using Speckle.Sdk.Host;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Connectors.ArcGIS.DependencyInjection;
+using Speckle.Connectors.Common;
+using Speckle.Connectors.DUI;
+using Speckle.Converters.ArcGIS3;
 using Module = ArcGIS.Desktop.Framework.Contracts.Module;
 
 namespace Speckle.Connectors.ArcGIS;
@@ -24,22 +22,19 @@ internal sealed class SpeckleModule : Module
   public static SpeckleModule Current =>
     s_this ??= (SpeckleModule)FrameworkApplication.FindModule("ConnectorArcGIS_Module");
 
-  public SpeckleContainer Container { get; }
+  public ServiceProvider Container { get; }
 
   public SpeckleModule()
   {
     AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolver.OnAssemblyResolve<SpeckleModule>;
 
-    var builder = SpeckleContainerBuilder.CreateInstance();
+    var services = new ServiceCollection();
     // init DI
-    _disposableLogger = Connector.Initialize(HostApplications.ArcGIS, GetVersion());
-
-    Container = builder
-      .LoadAutofacModules(
-        Assembly.GetExecutingAssembly(),
-        [Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location).NotNull()]
-      )
-      .Build();
+    _disposableLogger = services.Initialize(HostApplications.ArcGIS, GetVersion());
+    services.AddArcGIS();
+    services.AddArcGISConverters();
+    Container = services.BuildServiceProvider();
+    Container.UseDUI();
   }
 
   private HostAppVersion GetVersion()
@@ -60,6 +55,7 @@ internal sealed class SpeckleModule : Module
     //TODO - add your business logic
     //return false to ~cancel~ Application close
     _disposableLogger?.Dispose();
+    Container.Dispose();
     return true;
   }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Utils/ArcGisDocumentStore.cs

@@ -3,20 +3,22 @@ using ArcGIS.Desktop.Core.Events;
 using ArcGIS.Desktop.Framework.Threading.Tasks;
 using ArcGIS.Desktop.Mapping;
 using ArcGIS.Desktop.Mapping.Events;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Models;
-using Speckle.Newtonsoft.Json;
-using Speckle.Sdk.Common;
+using Speckle.Connectors.DUI.Utils;
 
 namespace Speckle.Connectors.ArcGIS.Utils;
 
 public class ArcGISDocumentStore : DocumentModelStore
 {
   public ArcGISDocumentStore(
-    JsonSerializerSettings serializerOption,
+    ILogger<DocumentModelStore> logger,
+    IJsonSerializer jsonSerializer,
     ITopLevelExceptionHandler topLevelExceptionHandler
   )
-    : base(serializerOption, true)
+    : base(logger, jsonSerializer)
   {
     ActiveMapViewChangedEvent.Subscribe(a => topLevelExceptionHandler.CatchUnhandled(() => OnMapViewChanged(a)), true);
     ProjectSavingEvent.Subscribe(
@@ -40,7 +42,7 @@ public class ArcGISDocumentStore : DocumentModelStore
     if (!IsDocumentInit && MapView.Active != null)
     {
       IsDocumentInit = true;
-      ReadFromFile();
+      LoadState();
       OnDocumentChanged();
     }
   }
@@ -52,14 +54,14 @@ public class ArcGISDocumentStore : DocumentModelStore
       return;
     }
 
-    WriteToFile();
+    SaveState();
   }
 
   private void OnProjectSaving()
   {
     if (MapView.Active is not null)
     {
-      WriteToFile();
+      SaveState();
     }
   }
 
@@ -74,58 +76,56 @@ public class ArcGISDocumentStore : DocumentModelStore
     }
 
     IsDocumentInit = true;
-    ReadFromFile();
+    LoadState();
     OnDocumentChanged();
   }
 
-  public override void WriteToFile()
-  {
-    Map map = MapView.Active.Map;
-    QueuedTask.Run(() =>
-    {
-      // Read existing metadata - To prevent messing existing metadata. 🤞 Hope other add-in developers will do same :D
-      var existingMetadata = map.GetMetadata();
-
-      // Parse existing metadata
-      XDocument existingXmlDocument = !string.IsNullOrEmpty(existingMetadata)
-        ? XDocument.Parse(existingMetadata)
-        : new XDocument(new XElement("metadata"));
-
-      string serializedModels = Serialize();
-
-      XElement xmlModelCards = new("SpeckleModelCards", serializedModels);
-
-      // Check if SpeckleModelCards element already exists at root and update it
-      var speckleModelCardsElement = existingXmlDocument.Root?.Element("SpeckleModelCards");
-      if (speckleModelCardsElement != null)
+  protected override void HostAppSaveState(string modelCardState) =>
+    QueuedTask
+      .Run(() =>
       {
-        speckleModelCardsElement.ReplaceWith(xmlModelCards);
-      }
-      else
+        Map map = MapView.Active.Map;
+        // Read existing metadata - To prevent messing existing metadata. 🤞 Hope other add-in developers will do same :D
+        var existingMetadata = map.GetMetadata();
+
+        // Parse existing metadata
+        XDocument existingXmlDocument = !string.IsNullOrEmpty(existingMetadata)
+          ? XDocument.Parse(existingMetadata)
+          : new XDocument(new XElement("metadata"));
+
+        XElement xmlModelCards = new("SpeckleModelCards", modelCardState);
+
+        // Check if SpeckleModelCards element already exists at root and update it
+        var speckleModelCardsElement = existingXmlDocument.Root?.Element("SpeckleModelCards");
+        if (speckleModelCardsElement != null)
+        {
+          speckleModelCardsElement.ReplaceWith(xmlModelCards);
+        }
+        else
+        {
+          existingXmlDocument.Root?.Add(xmlModelCards);
+        }
+
+        map.SetMetadata(existingXmlDocument.ToString());
+      })
+      .FireAndForget();
+
+  protected override void LoadState() =>
+    QueuedTask
+      .Run(() =>
       {
-        existingXmlDocument.Root?.Add(xmlModelCards);
-      }
+        Map map = MapView.Active.Map;
+        var metadata = map.GetMetadata();
+        var root = XDocument.Parse(metadata).Root;
+        var element = root?.Element("SpeckleModelCards");
+        if (element is null)
+        {
+          ClearAndSave();
+          return;
+        }
 
-      map.SetMetadata(existingXmlDocument.ToString());
-    });
-  }
-
-  public override void ReadFromFile()
-  {
-    Map map = MapView.Active.Map;
-    QueuedTask.Run(() =>
-    {
-      var metadata = map.GetMetadata();
-      var root = XDocument.Parse(metadata).Root;
-      var element = root?.Element("SpeckleModelCards");
-      if (element is null)
-      {
-        Models = new();
-        return;
-      }
-
-      string modelsString = element.Value;
-      Models = Deserialize(modelsString).NotNull();
-    });
-  }
+        string modelsString = element.Value;
+        LoadFromString(modelsString);
+      })
+      .FireAndForget();
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/Utils/MapMembersUtils.cs

@@ -1,4 +1,3 @@
-using ArcGIS.Desktop.Internal.Mapping;
 using ArcGIS.Desktop.Mapping;
 
 namespace Speckle.Connectors.ArcGIS.Utils;
@@ -28,45 +27,35 @@ public class MapMembersUtils
     List<MapMember> mapMembers = new();
     foreach (var layer in mapMembersToUnpack)
     {
+      mapMembers.Add(layer);
       switch (layer)
       {
-        case GroupLayer subGroup:
-          mapMembers.Add(layer);
-          var subGroupMapMembers = UnpackMapLayers(subGroup.Layers);
-          mapMembers.AddRange(subGroupMapMembers);
-          break;
-        case ILayerContainerInternal subLayerContainerInternal:
-          mapMembers.Add(layer);
-          var subLayerMapMembers = UnpackMapLayers(subLayerContainerInternal.InternalLayers);
+        case ILayerContainer subGroup:
+          var subLayerMapMembers = UnpackMapLayers(subGroup.Layers);
           mapMembers.AddRange(subLayerMapMembers);
           break;
-        default:
-          mapMembers.Add(layer);
-          break;
       }
     }
 
     return mapMembers;
   }
 
-  // Gets the layer display priority for selected layers
-  public List<(MapMember, int)> GetLayerDisplayPriority(Map map, IReadOnlyList<MapMember> selectedMapMembers)
+  /// <summary>
+  /// Sorts the selected mapmembers into the same order as they appear in the Table of Contents (TOC) bar in the file.
+  /// This is a required step before unpacking layers, because depending on the user selection order, some children layers may appear before their container layer if both the container and children layers are selected.
+  /// </summary>
+  public IEnumerable<MapMember> GetMapMembersInOrder(Map map, IReadOnlyList<MapMember> selectedMapMembers)
   {
     // first get all map layers
     List<MapMember> allMapMembers = GetAllMapMembers(map);
 
     // recalculate selected layer priority from all map layers
-    List<(MapMember, int)> selectedLayers = new();
-    int newCount = 0;
     foreach (MapMember mapMember in allMapMembers)
     {
       if (selectedMapMembers.Contains(mapMember))
       {
-        selectedLayers.Add((mapMember, newCount));
-        newCount++;
+        yield return mapMember;
       }
     }
-
-    return selectedLayers;
   }
 }

Connectors/ArcGIS/Speckle.Connectors.ArcGIS3/packages.lock.json

@@ -10,9 +10,18 @@
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "Direct",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
+        }
       },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
@@ -67,6 +76,11 @@
         "resolved": "6.0.0",
         "contentHash": "yg72rrYDapfsIUrul7aF6wwNnTJBOFvuA9VdDTQpPa8AlAriHbufeXYLBcodKjfUdkCnaiggX1U/nEP08Zb5GA=="
       },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "W8DPQjkMScOMTtJbPwmPyj9c3zYSFGawDW3jwlBOOsnY+EzZFLgNQ/UMkK35JmkNOVPdCyPr2Tw7Vv9N+KA3ZQ=="
+      },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
         "resolved": "8.0.0",
@@ -79,110 +93,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg=="
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -213,6 +201,11 @@
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
       "System.Memory": {
         "type": "Transitive",
         "resolved": "4.5.3",
@@ -223,25 +216,33 @@
         "resolved": "5.0.0",
         "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
       },
-      "System.Text.Json": {
+      "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ=="
+        "resolved": "4.5.1",
+        "contentHash": "Zh8t8oqolRaFa9vmOZfdQm/qKejdqz0J9kr7o2Fu0vPeoH3BL1EOXipKWwkWtLT1JPzjByrF19fGuFlNbmPpiw=="
       },
-      "speckle.autofac": {
+      "speckle.common.meshtriangulation": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "LibTessDotNet": "[1.1.15, )",
+          "Speckle.DoubleNumerics": "[4.1.0, )"
+        }
+      },
+      "speckle.connectors.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -251,60 +252,49 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
       "speckle.converters.arcgis3": {
         "type": "Project",
         "dependencies": {
           "Esri.ArcGISPro.Extensions30": "[3.2.0.49743, )",
+          "Speckle.Common.MeshTriangulation": "[1.0.0, )",
           "Speckle.Converters.Common": "[1.0.0, )"
         }
       },
-      "speckle.converters.arcgis3.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Converters.ArcGIS3": "[1.0.0, )",
-          "Speckle.Converters.Common.DependencyInjection": "[1.0.0, )"
-        }
-      },
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
-        }
-      },
-      "Autofac": {
+      "LibTessDotNet": {
         "type": "CentralTransitive",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg=="
+        "requested": "[1.1.15, )",
+        "resolved": "1.1.15",
+        "contentHash": "KuA7N3Nv/lIeawJdQBQJR6oqWD9KETHLbWzBqapwFs+Tby+R5I4crkKujKMm5bXcSuFZ8LNtflFQVadsWCbBjg=="
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
+        }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Web.WebView2": {
@@ -313,38 +303,43 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
       }
     },
     "net6.0-windows7.0/win-x64": {

Connectors/Autocad/Directory.Build.targets

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <Target AfterTargets="Clean" Name="CleanAddinAutocad" Condition="'$(AutoCADVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true'">
+    <RemoveDir Directories="$(AppData)\Autodesk\ApplicationPlugins\Speckle.Connectors.Autocad$(AutoCADVersion);" />
+  </Target>
+
+  <Target AfterTargets="Build"  Name="AfterBuildAutoCAD" Condition="'$(AutoCADVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true'">
+    <ItemGroup>
+      <AutoCADDLLs Include="$(TargetDir)\**\*.*" />
+    </ItemGroup>
+    <Message Text="AutoCAD Version $(AutoCADVersion)" Importance="high"/>
+    <Copy DestinationFolder="$(AppData)\Autodesk\ApplicationPlugins\Speckle.Connectors.Autocad$(AutoCADVersion)\%(RecursiveDir)" SourceFiles="@(AutoCADDLLs)" />
+  </Target>
+
+  <Target AfterTargets="Clean" Name="CleanAddinCivil3D" Condition="'$(Civil3DVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true'">
+    <RemoveDir Directories="$(AppData)\Autodesk\ApplicationPlugins\Speckle.Connectors.Civil3d$(Civil3DVersion);" />
+  </Target>
+
+  <Target AfterTargets="Build"  Name="AfterBuildCivil3D" Condition="'$(Civil3DVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true'">
+    <ItemGroup>
+      <Civil3DDLLs Include="$(TargetDir)\**\*.*" />
+    </ItemGroup>
+    <Message Text="Civil3D Version $(Civil3DVersion)" Importance="high"/>
+    <Copy DestinationFolder="$(AppData)\Autodesk\ApplicationPlugins\Speckle.Connectors.Civil3d$(Civil3DVersion)\%(RecursiveDir)" SourceFiles="@(Civil3DDLLs)" />
+  </Target>
+
+  <PropertyGroup Condition="'$(AutoCADVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true'">
+    <StartAction>Program</StartAction>
+    <StartProgram>$(ProgramW6432)\Autodesk\AutoCAD $(AutoCADVersion)\acad.exe</StartProgram>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Civil3DVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true'">
+    <StartAction>Program</StartAction>
+    <StartProgram>$(ProgramW6432)\Autodesk\AutoCAD $(Civil3DVersion)\acad.exe</StartProgram>
+    <StartArguments>/product C3D</StartArguments>
+  </PropertyGroup>
+</Project>

Connectors/Autocad/Speckle.Connectors.Autocad2022/Speckle.Connectors.Autocad2022.csproj

@@ -2,17 +2,18 @@
   <PropertyGroup>
     <TargetFramework>net48</TargetFramework>
     <PlatformTarget>x64</PlatformTarget>
+    <UseWpf>true</UseWpf>
     <AutoCADVersion>2022</AutoCADVersion>
     <DefineConstants>$(DefineConstants);AUTOCAD;AUTOCAD2022;AUTOCAD2022_OR_GREATER</DefineConstants>
     <Configurations>Debug;Release;Local</Configurations>
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2022.0.2" />
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2022.0.2" ExcludeAssets="runtime"/>
   </ItemGroup>  
   
-  <ItemGroup>   
-    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2022.DependencyInjection\Speckle.Converters.Autocad2022.DependencyInjection.csproj" />
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2022\Speckle.Converters.Autocad2022.csproj" />
     <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
     <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
   </ItemGroup>

Connectors/Autocad/Speckle.Connectors.Autocad2022/packages.lock.json

@@ -2,6 +2,15 @@
   "version": 2,
   "dependencies": {
     ".NETFramework,Version=v4.8": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3"
+        }
+      },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
         "requested": "[8.0.0, )",
@@ -82,116 +91,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0",
-          "System.ComponentModel.Annotations": "4.7.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg==",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
         "dependencies": {
-          "System.Memory": "4.5.2",
-          "System.Runtime.CompilerServices.Unsafe": "4.7.0"
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
         }
       },
+      "Microsoft.NETFramework.ReferenceAssemblies.net48": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "zMk4D+9zyiEWByyQ7oPImPN/Jhpj166Ky0Nlla4eXlNL8hI/BtSJsgR8Inldd4NNpIAH3oh8yym0W2DrhXdSLQ=="
+      },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -224,22 +201,22 @@
       },
       "System.Buffers": {
         "type": "Transitive",
-        "resolved": "4.5.1",
-        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+        "resolved": "4.4.0",
+        "contentHash": "AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw=="
       },
       "System.ComponentModel.Annotations": {
         "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "0YFqjhp/mYkDGpU0Ye1GjE53HMp9UVfGN7seGpAMttAC0C40v5gw598jCgpbBLMmCo0E5YRLBv5Z2doypO49ZQ=="
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
       },
       "System.Memory": {
         "type": "Transitive",
-        "resolved": "4.5.4",
-        "contentHash": "1MbJTHS1lZ4bS4FmsJjnuGJOu88ZzTT2rLvrhW7Ygic+pC0NWA+3hgAen0HRdsocuQXCkUTdFn9yHJJhsijDXw==",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
         "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
         }
       },
       "System.Net.WebSockets.Client.Managed": {
@@ -253,8 +230,8 @@
       },
       "System.Numerics.Vectors": {
         "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "QQTlPTl06J/iiDbJCiepZ4H//BVraReU4O4EoRw1U02H5TLUIT7xn3GnDp9AXPSlJUDyFs4uWjWafNX6WrAojQ=="
+        "resolved": "4.4.0",
+        "contentHash": "UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ=="
       },
       "System.Reactive": {
         "type": "Transitive",
@@ -266,32 +243,8 @@
       },
       "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.0",
-        "contentHash": "ZD9TMpsmYJLrxbbmdvhwt9YEgG5WntEnZ/d1eH8JBX9LBp+Ju8BSBhUGbZMNVHHomWo2KVImJhTDl2hIgw/6MA=="
-      },
-      "System.Text.Encodings.Web": {
-        "type": "Transitive",
-        "resolved": "5.0.1",
-        "contentHash": "KmJ+CJXizDofbq6mpqDoRRLcxgOd2z9X3XoFNULSbvbqVRZkFX3istvr+MUjL6Zw1RT+RNdoI4GYidIINtgvqQ==",
-        "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4"
-        }
-      },
-      "System.Text.Json": {
-        "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "5.0.0",
-          "System.Text.Encodings.Web": "5.0.1",
-          "System.Threading.Tasks.Extensions": "4.5.4",
-          "System.ValueTuple": "4.5.0"
-        }
+        "resolved": "4.5.3",
+        "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw=="
       },
       "System.Threading.Tasks.Extensions": {
         "type": "Transitive",
@@ -301,25 +254,21 @@
           "System.Runtime.CompilerServices.Unsafe": "4.5.3"
         }
       },
-      "System.ValueTuple": {
-        "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ=="
-      },
-      "speckle.autofac": {
+      "speckle.connectors.common": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -329,14 +278,8 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
       "speckle.converters.autocad2022": {
         "type": "Project",
@@ -345,55 +288,39 @@
           "Speckle.Converters.Common": "[1.0.0, )"
         }
       },
-      "speckle.converters.autocad2022.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Autofac": "[5.2.0, )",
-          "Speckle.Converters.Autocad2022": "[1.0.0, )",
-          "Speckle.Converters.Common.DependencyInjection": "[1.0.0, )"
-        }
-      },
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
-        }
-      },
-      "Autofac": {
+      "Microsoft.Extensions.DependencyInjection": {
         "type": "CentralTransitive",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
         "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
       },
       "Microsoft.Web.WebView2": {
         "type": "CentralTransitive",
@@ -401,38 +328,43 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
       }
     }
   }

Connectors/Autocad/Speckle.Connectors.Autocad2023/Speckle.Connectors.Autocad2023.csproj

@@ -2,17 +2,18 @@
   <PropertyGroup>
     <TargetFramework>net48</TargetFramework>
     <PlatformTarget>x64</PlatformTarget>
+    <UseWpf>true</UseWpf>
     <AutoCADVersion>2023</AutoCADVersion>
     <DefineConstants>$(DefineConstants);AUTOCAD;AUTOCAD2023;AUTOCAD2022_OR_GREATER;AUTOCAD2023_OR_GREATER</DefineConstants>
     <Configurations>Debug;Release;Local</Configurations>
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2023.0.0" />
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2023.0.0" ExcludeAssets="runtime"/>
   </ItemGroup>  
   
-  <ItemGroup>   
-    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2023.DependencyInjection\Speckle.Converters.Autocad2023.DependencyInjection.csproj" />
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2023\Speckle.Converters.Autocad2023.csproj" />
     <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
     <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
   </ItemGroup>

Connectors/Autocad/Speckle.Connectors.Autocad2023/packages.lock.json

@@ -2,6 +2,15 @@
   "version": 2,
   "dependencies": {
     ".NETFramework,Version=v4.8": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3"
+        }
+      },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
         "requested": "[8.0.0, )",
@@ -82,116 +91,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0",
-          "System.ComponentModel.Annotations": "4.7.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg==",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
         "dependencies": {
-          "System.Memory": "4.5.2",
-          "System.Runtime.CompilerServices.Unsafe": "4.7.0"
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
         }
       },
+      "Microsoft.NETFramework.ReferenceAssemblies.net48": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "zMk4D+9zyiEWByyQ7oPImPN/Jhpj166Ky0Nlla4eXlNL8hI/BtSJsgR8Inldd4NNpIAH3oh8yym0W2DrhXdSLQ=="
+      },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -224,22 +201,22 @@
       },
       "System.Buffers": {
         "type": "Transitive",
-        "resolved": "4.5.1",
-        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+        "resolved": "4.4.0",
+        "contentHash": "AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw=="
       },
       "System.ComponentModel.Annotations": {
         "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "0YFqjhp/mYkDGpU0Ye1GjE53HMp9UVfGN7seGpAMttAC0C40v5gw598jCgpbBLMmCo0E5YRLBv5Z2doypO49ZQ=="
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
       },
       "System.Memory": {
         "type": "Transitive",
-        "resolved": "4.5.4",
-        "contentHash": "1MbJTHS1lZ4bS4FmsJjnuGJOu88ZzTT2rLvrhW7Ygic+pC0NWA+3hgAen0HRdsocuQXCkUTdFn9yHJJhsijDXw==",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
         "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
         }
       },
       "System.Net.WebSockets.Client.Managed": {
@@ -253,8 +230,8 @@
       },
       "System.Numerics.Vectors": {
         "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "QQTlPTl06J/iiDbJCiepZ4H//BVraReU4O4EoRw1U02H5TLUIT7xn3GnDp9AXPSlJUDyFs4uWjWafNX6WrAojQ=="
+        "resolved": "4.4.0",
+        "contentHash": "UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ=="
       },
       "System.Reactive": {
         "type": "Transitive",
@@ -266,32 +243,8 @@
       },
       "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.0",
-        "contentHash": "ZD9TMpsmYJLrxbbmdvhwt9YEgG5WntEnZ/d1eH8JBX9LBp+Ju8BSBhUGbZMNVHHomWo2KVImJhTDl2hIgw/6MA=="
-      },
-      "System.Text.Encodings.Web": {
-        "type": "Transitive",
-        "resolved": "5.0.1",
-        "contentHash": "KmJ+CJXizDofbq6mpqDoRRLcxgOd2z9X3XoFNULSbvbqVRZkFX3istvr+MUjL6Zw1RT+RNdoI4GYidIINtgvqQ==",
-        "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4"
-        }
-      },
-      "System.Text.Json": {
-        "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "5.0.0",
-          "System.Text.Encodings.Web": "5.0.1",
-          "System.Threading.Tasks.Extensions": "4.5.4",
-          "System.ValueTuple": "4.5.0"
-        }
+        "resolved": "4.5.3",
+        "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw=="
       },
       "System.Threading.Tasks.Extensions": {
         "type": "Transitive",
@@ -301,25 +254,21 @@
           "System.Runtime.CompilerServices.Unsafe": "4.5.3"
         }
       },
-      "System.ValueTuple": {
-        "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ=="
-      },
-      "speckle.autofac": {
+      "speckle.connectors.common": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -329,14 +278,8 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
       "speckle.converters.autocad2023": {
         "type": "Project",
@@ -345,55 +288,39 @@
           "Speckle.Converters.Common": "[1.0.0, )"
         }
       },
-      "speckle.converters.autocad2023.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Autofac": "[5.2.0, )",
-          "Speckle.Converters.Autocad2023": "[1.0.0, )",
-          "Speckle.Converters.Common.DependencyInjection": "[1.0.0, )"
-        }
-      },
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
-        }
-      },
-      "Autofac": {
+      "Microsoft.Extensions.DependencyInjection": {
         "type": "CentralTransitive",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
         "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
       },
       "Microsoft.Web.WebView2": {
         "type": "CentralTransitive",
@@ -401,38 +328,43 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
       }
     }
   }

Connectors/Autocad/Speckle.Connectors.Autocad2024/Speckle.Connectors.Autocad2024.csproj

@@ -1,18 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net48</TargetFramework>
-    <PlatformTarget>x64</PlatformTarget>
     <AutoCADVersion>2024</AutoCADVersion>
+    <PlatformTarget>x64</PlatformTarget>
+    <UseWpf>true</UseWpf>
     <DefineConstants>$(DefineConstants);AUTOCAD;AUTOCAD2024;AUTOCAD2022_OR_GREATER;AUTOCAD2023_OR_GREATER;AUTOCAD2024_OR_GREATER</DefineConstants>
     <Configurations>Debug;Release;Local</Configurations>
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2024.0.0" />
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2024.0.0" ExcludeAssets="runtime"/>
   </ItemGroup>  
   
   <ItemGroup>   
-    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2024.DependencyInjection\Speckle.Converters.Autocad2024.DependencyInjection.csproj" />
+    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2024\Speckle.Converters.Autocad2024.csproj" />
     <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
     <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
   </ItemGroup>

Connectors/Autocad/Speckle.Connectors.Autocad2024/packages.lock.json

@@ -2,6 +2,15 @@
   "version": 2,
   "dependencies": {
     ".NETFramework,Version=v4.8": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3"
+        }
+      },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
         "requested": "[8.0.0, )",
@@ -82,116 +91,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0",
-          "System.ComponentModel.Annotations": "4.7.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg==",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
         "dependencies": {
-          "System.Memory": "4.5.2",
-          "System.Runtime.CompilerServices.Unsafe": "4.7.0"
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
         }
       },
+      "Microsoft.NETFramework.ReferenceAssemblies.net48": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "zMk4D+9zyiEWByyQ7oPImPN/Jhpj166Ky0Nlla4eXlNL8hI/BtSJsgR8Inldd4NNpIAH3oh8yym0W2DrhXdSLQ=="
+      },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -224,22 +201,22 @@
       },
       "System.Buffers": {
         "type": "Transitive",
-        "resolved": "4.5.1",
-        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+        "resolved": "4.4.0",
+        "contentHash": "AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw=="
       },
       "System.ComponentModel.Annotations": {
         "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "0YFqjhp/mYkDGpU0Ye1GjE53HMp9UVfGN7seGpAMttAC0C40v5gw598jCgpbBLMmCo0E5YRLBv5Z2doypO49ZQ=="
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
       },
       "System.Memory": {
         "type": "Transitive",
-        "resolved": "4.5.4",
-        "contentHash": "1MbJTHS1lZ4bS4FmsJjnuGJOu88ZzTT2rLvrhW7Ygic+pC0NWA+3hgAen0HRdsocuQXCkUTdFn9yHJJhsijDXw==",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
         "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
         }
       },
       "System.Net.WebSockets.Client.Managed": {
@@ -253,8 +230,8 @@
       },
       "System.Numerics.Vectors": {
         "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "QQTlPTl06J/iiDbJCiepZ4H//BVraReU4O4EoRw1U02H5TLUIT7xn3GnDp9AXPSlJUDyFs4uWjWafNX6WrAojQ=="
+        "resolved": "4.4.0",
+        "contentHash": "UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ=="
       },
       "System.Reactive": {
         "type": "Transitive",
@@ -266,32 +243,8 @@
       },
       "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.0",
-        "contentHash": "ZD9TMpsmYJLrxbbmdvhwt9YEgG5WntEnZ/d1eH8JBX9LBp+Ju8BSBhUGbZMNVHHomWo2KVImJhTDl2hIgw/6MA=="
-      },
-      "System.Text.Encodings.Web": {
-        "type": "Transitive",
-        "resolved": "5.0.1",
-        "contentHash": "KmJ+CJXizDofbq6mpqDoRRLcxgOd2z9X3XoFNULSbvbqVRZkFX3istvr+MUjL6Zw1RT+RNdoI4GYidIINtgvqQ==",
-        "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4"
-        }
-      },
-      "System.Text.Json": {
-        "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "5.0.0",
-          "System.Text.Encodings.Web": "5.0.1",
-          "System.Threading.Tasks.Extensions": "4.5.4",
-          "System.ValueTuple": "4.5.0"
-        }
+        "resolved": "4.5.3",
+        "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw=="
       },
       "System.Threading.Tasks.Extensions": {
         "type": "Transitive",
@@ -301,25 +254,21 @@
           "System.Runtime.CompilerServices.Unsafe": "4.5.3"
         }
       },
-      "System.ValueTuple": {
-        "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ=="
-      },
-      "speckle.autofac": {
+      "speckle.connectors.common": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -329,14 +278,8 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
       "speckle.converters.autocad2024": {
         "type": "Project",
@@ -346,55 +289,39 @@
           "Speckle.Converters.Common": "[1.0.0, )"
         }
       },
-      "speckle.converters.autocad2024.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Autofac": "[5.2.0, )",
-          "Speckle.Converters.Autocad2024": "[1.0.0, )",
-          "Speckle.Converters.Common.DependencyInjection": "[1.0.0, )"
-        }
-      },
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
-        }
-      },
-      "Autofac": {
+      "Microsoft.Extensions.DependencyInjection": {
         "type": "CentralTransitive",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
         "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
       },
       "Microsoft.Web.WebView2": {
         "type": "CentralTransitive",
@@ -402,38 +329,43 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
       }
     }
   }

Connectors/Autocad/Speckle.Connectors.Autocad2025/Speckle.Connectors.Autocad2025.csproj

@@ -1,21 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net8.0-windows</TargetFramework>
-    <PlatformTarget>x64</PlatformTarget>
     <AutoCADVersion>2025</AutoCADVersion>
-    <DefineConstants>$(DefineConstants);AUTOCAD2025;AUTOCAD</DefineConstants>
+    <DefineConstants>$(DefineConstants);AUTOCAD;AUTOCAD2025;AUTOCAD2022_OR_GREATER;AUTOCAD2023_OR_GREATER;AUTOCAD2024_OR_GREATER;AUTOCAD2025_OR_GREATER</DefineConstants>
     <Configurations>Debug;Release;Local</Configurations>
-    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-    <RuntimeIdentifier>win-x64</RuntimeIdentifier> <!-- .NET Core uses this to move native dependencies into a root for runtime selection and usage for non-windows development https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#enablewindowstargeting -->
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- .NET Core uses this to move native dependencies into a root for runtime selection and usage for non-windows development https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#enablewindowstargeting -->
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier> <!--This is needed for managed dependencies-->
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> <!--This is needed for the rest-->
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath> <!--This is needed just to keep folder paths the same as the netframework versions of autocad/civil-->
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2025.0.0" />
-    <FrameworkReference Include="Microsoft.WindowsDesktop.App"/>
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2025.0.0" ExcludeAssets="runtime"/>
   </ItemGroup>  
   
   <ItemGroup>   
-    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2025.DependencyInjection\Speckle.Converters.Autocad2025.DependencyInjection.csproj" />
+    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2025\Speckle.Converters.Autocad2025.csproj" />
     <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
     <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
   </ItemGroup>

Connectors/Autocad/Speckle.Connectors.Autocad2025/packages.lock.json

@@ -2,6 +2,15 @@
   "version": 2,
   "dependencies": {
     "net8.0-windows7.0": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
+        }
+      },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
         "requested": "[8.0.0, )",
@@ -73,110 +82,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg=="
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -207,6 +190,11 @@
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
       "System.Memory": {
         "type": "Transitive",
         "resolved": "4.5.3",
@@ -217,25 +205,26 @@
         "resolved": "5.0.0",
         "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
       },
-      "System.Text.Json": {
+      "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ=="
+        "resolved": "4.5.1",
+        "contentHash": "Zh8t8oqolRaFa9vmOZfdQm/qKejdqz0J9kr7o2Fu0vPeoH3BL1EOXipKWwkWtLT1JPzjByrF19fGuFlNbmPpiw=="
       },
-      "speckle.autofac": {
+      "speckle.connectors.common": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -245,14 +234,8 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
       "speckle.converters.autocad2025": {
         "type": "Project",
@@ -262,52 +245,39 @@
           "Speckle.Converters.Common": "[1.0.0, )"
         }
       },
-      "speckle.converters.autocad2025.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Autofac": "[5.2.0, )",
-          "Speckle.Converters.Autocad2025": "[1.0.0, )",
-          "Speckle.Converters.Common.DependencyInjection": "[1.0.0, )"
-        }
-      },
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
-        }
-      },
-      "Autofac": {
+      "Microsoft.Extensions.DependencyInjection": {
         "type": "CentralTransitive",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
+        }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
       },
       "Microsoft.Web.WebView2": {
         "type": "CentralTransitive",
@@ -315,38 +285,42 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
       }
     },
     "net8.0-windows7.0/win-x64": {

Connectors/Autocad/Speckle.Connectors.Autocad2026/Speckle.Connectors.Autocad2026.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <AutoCADVersion>2026</AutoCADVersion>
+    <DefineConstants>$(DefineConstants);AUTOCAD;AUTOCAD2026;AUTOCAD2022_OR_GREATER;AUTOCAD2023_OR_GREATER;AUTOCAD2024_OR_GREATER;AUTOCAD2025_OR_GREATER;AUTOCAD2026_OR_GREATER</DefineConstants>
+    <Configurations>Debug;Release;Local</Configurations>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- .NET Core uses this to move native dependencies into a root for runtime selection and usage for non-windows development https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#enablewindowstargeting -->
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier> <!--This is needed for managed dependencies-->
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> <!--This is needed for the rest-->
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath> <!--This is needed just to keep folder paths the same as the netframework versions of autocad/civil-->
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2026.0.0" ExcludeAssets="runtime"/>
+  </ItemGroup>  
+  
+  <ItemGroup>   
+    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2026\Speckle.Converters.Autocad2026.csproj" />
+    <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
+    <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
+  </ItemGroup>
+  
+  <Import Project="..\Speckle.Connectors.AutocadShared\Speckle.Connectors.AutocadShared.projitems" Label="Shared" />
+</Project>

Connectors/Autocad/Speckle.Connectors.Autocad2026/packages.lock.json

@@ -0,0 +1,340 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net8.0-windows7.0": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
+        }
+      },
+      "Microsoft.SourceLink.GitHub": {
+        "type": "Direct",
+        "requested": "[8.0.0, )",
+        "resolved": "8.0.0",
+        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "8.0.0",
+          "Microsoft.SourceLink.Common": "8.0.0"
+        }
+      },
+      "PolySharp": {
+        "type": "Direct",
+        "requested": "[1.14.1, )",
+        "resolved": "1.14.1",
+        "contentHash": "mOOmFYwad3MIOL14VCjj02LljyF1GNw1wP0YVlxtcPvqdxjGGMNdNJJxHptlry3MOd8b40Flm8RPOM8JOlN2sQ=="
+      },
+      "Speckle.AutoCAD.API": {
+        "type": "Direct",
+        "requested": "[2026.0.0, )",
+        "resolved": "2026.0.0",
+        "contentHash": "WlkV81PmbK/ftoM7aGpU6LGosKbePBQej9MO/m63rFMozX89tsitEhE12o58wu7K/4FmRUdAMolYtdK20EDBnw=="
+      },
+      "Speckle.InterfaceGenerator": {
+        "type": "Direct",
+        "requested": "[0.9.6, )",
+        "resolved": "0.9.6",
+        "contentHash": "HKH7tYrYYlCK1ct483hgxERAdVdMtl7gUKW9ijWXxA1UsYR4Z+TrRHYmzZ9qmpu1NnTycSrp005NYM78GDKV1w=="
+      },
+      "GraphQL.Client": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "8yPNBbuVBpTptivyAlak4GZvbwbUcjeQTL4vN1HKHRuOykZ4r7l5fcLS6vpyPyLn0x8FsL31xbOIKyxbmR9rbA==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0",
+          "GraphQL.Client.Abstractions.Websocket": "6.0.0",
+          "System.Reactive": "5.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "h7uzWFORHZ+CCjwr/ThAyXMr0DPpzEANDa4Uo54wqCQ+j7qUKwqYTgOrb1W40sqbvNaZm9v/X7It31SUw0maHA==",
+        "dependencies": {
+          "GraphQL.Primitives": "6.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions.Websocket": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "Nr9bPf8gIOvLuXpqEpqr9z9jslYFJOvd0feHth3/kPqeR3uMbjF5pjiwh4jxyMcxHdr8Pb6QiXkV3hsSyt0v7A==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0"
+        }
+      },
+      "GraphQL.Primitives": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "yg72rrYDapfsIUrul7aF6wwNnTJBOFvuA9VdDTQpPa8AlAriHbufeXYLBcodKjfUdkCnaiggX1U/nEP08Zb5GA=="
+      },
+      "Microsoft.Build.Tasks.Git": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
+      },
+      "Microsoft.CSharp": {
+        "type": "Transitive",
+        "resolved": "4.7.0",
+        "contentHash": "pTj+D3uJWyN3My70i2Hqo+OXixq3Os2D1nJ2x92FFo6sk8fYS1m1WLNTs0Dc1uPaViH0YvEEwvzddQ7y4rhXmA=="
+      },
+      "Microsoft.Data.Sqlite": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
+        "dependencies": {
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
+          "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
+        }
+      },
+      "Microsoft.Data.Sqlite.Core": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "Microsoft.Extensions.Configuration": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
+      },
+      "Microsoft.SourceLink.Common": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
+      },
+      "Speckle.Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.2",
+        "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
+      },
+      "SQLitePCLRaw.bundle_e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "EWI1olKDjFEBMJu0+3wuxwziIAdWDVMYLhuZ3Qs84rrz+DHwD00RzWPZCa+bLnHCf3oJwuFZIRsHT5p236QXww==",
+        "dependencies": {
+          "SQLitePCLRaw.lib.e_sqlite3": "2.1.4",
+          "SQLitePCLRaw.provider.e_sqlite3": "2.1.4"
+        }
+      },
+      "SQLitePCLRaw.core": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "inBjvSHo9UDKneGNzfUfDjK08JzlcIhn1+SP5Y3m6cgXpCxXKCJDy6Mka7LpgSV+UZmKSnC8rTwB0SQ0xKu5pA==",
+        "dependencies": {
+          "System.Memory": "4.5.3"
+        }
+      },
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "SQLitePCLRaw.provider.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "CSlb5dUp1FMIkez9Iv5EXzpeq7rHryVNqwJMWnpq87j9zWZexaEMdisDktMsnnrzKM6ahNrsTkjqNodTBPBxtQ==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
+      "System.Memory": {
+        "type": "Transitive",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA=="
+      },
+      "System.Reactive": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "4.5.1",
+        "contentHash": "Zh8t8oqolRaFa9vmOZfdQm/qKejdqz0J9kr7o2Fu0vPeoH3BL1EOXipKWwkWtLT1JPzjByrF19fGuFlNbmPpiw=="
+      },
+      "speckle.connectors.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
+        }
+      },
+      "speckle.connectors.dui": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.dui.webview": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "[1.0.1938.49, )",
+          "Speckle.Connectors.DUI": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.logging": {
+        "type": "Project"
+      },
+      "speckle.converters.autocad2026": {
+        "type": "Project",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "[2026.0.0, )",
+          "Speckle.Connectors.DUI.WebView": "[1.0.0, )",
+          "Speckle.Converters.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.converters.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
+      },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
+      "Speckle.Objects": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
+        "dependencies": {
+          "Speckle.Sdk": "3.3.5"
+        }
+      },
+      "Speckle.Sdk": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
+        "dependencies": {
+          "GraphQL.Client": "6.0.0",
+          "Microsoft.CSharp": "4.7.0",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
+          "Speckle.Newtonsoft.Json": "13.0.2",
+          "Speckle.Sdk.Dependencies": "3.3.5"
+        }
+      },
+      "Speckle.Sdk.Dependencies": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
+      }
+    },
+    "net8.0-windows7.0/win-x64": {
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
+      }
+    }
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/Bindings/AutocadBasicConnectorBinding.cs

@@ -1,10 +1,11 @@
 using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
 using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card;
-using Speckle.Connectors.Utils.Common;
 using Speckle.Sdk;
 using Speckle.Sdk.Common;
 using Speckle.Sdk.Credentials;
@@ -13,31 +14,50 @@ namespace Speckle.Connectors.Autocad.Bindings;
 
 public class AutocadBasicConnectorBinding : IBasicConnectorBinding
 {
+  private readonly IAccountManager _accountManager;
   public string Name { get; set; } = "baseBinding";
-  public IBridge Parent { get; }
+  public IBrowserBridge Parent { get; }
 
   private readonly DocumentModelStore _store;
+  private readonly ISpeckleApplication _speckleApplication;
+  private readonly IThreadContext _threadContext;
+  private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
+  private readonly ILogger<AutocadBasicConnectorBinding> _logger;
 
   public BasicConnectorBindingCommands Commands { get; }
 
-  public AutocadBasicConnectorBinding(DocumentModelStore store, IBridge parent)
+  public AutocadBasicConnectorBinding(
+    DocumentModelStore store,
+    IBrowserBridge parent,
+    IAccountManager accountManager,
+    ISpeckleApplication speckleApplication,
+    ILogger<AutocadBasicConnectorBinding> logger,
+    IThreadContext threadContext,
+    ITopLevelExceptionHandler topLevelExceptionHandler
+  )
   {
     _store = store;
     Parent = parent;
+    _accountManager = accountManager;
+    _speckleApplication = speckleApplication;
     Commands = new BasicConnectorBindingCommands(parent);
+    _logger = logger;
+    _threadContext = threadContext;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
     _store.DocumentChanged += (_, _) =>
-    {
-      Commands.NotifyDocumentChanged();
-    };
+      _topLevelExceptionHandler.FireAndForget(async () =>
+      {
+        await Commands.NotifyDocumentChanged();
+      });
   }
 
-  public string GetConnectorVersion() => typeof(AutocadBasicConnectorBinding).Assembly.GetVersion();
+  public string GetConnectorVersion() => _speckleApplication.SpeckleVersion;
 
-  public string GetSourceApplicationName() => Utils.Connector.Slug;
+  public string GetSourceApplicationName() => _speckleApplication.Slug;
 
-  public string GetSourceApplicationVersion() => Utils.Connector.VersionString;
+  public string GetSourceApplicationVersion() => _speckleApplication.HostApplicationVersion;
 
-  public Account[] GetAccounts() => AccountManager.GetAccounts().ToArray();
+  public Account[] GetAccounts() => _accountManager.GetAccounts().ToArray();
 
   public DocumentInfo? GetDocumentInfo()
   {
@@ -53,23 +73,25 @@ public class AutocadBasicConnectorBinding : IBasicConnectorBinding
 
   public DocumentModelStore GetDocumentState() => _store;
 
-  public void AddModel(ModelCard model) => _store.Models.Add(model);
+  public void AddModel(ModelCard model) => _store.AddModel(model);
 
   public void UpdateModel(ModelCard model) => _store.UpdateModel(model);
 
   public void RemoveModel(ModelCard model) => _store.RemoveModel(model);
 
-  public void HighlightObjects(List<string> objectIds)
+  public void RemoveModels(List<ModelCard> models) => _store.RemoveModels(models);
+
+  public async Task HighlightObjects(IReadOnlyList<string> objectIds)
   {
     // POC: Will be addressed to move it into AutocadContext!
     var doc = Application.DocumentManager.MdiActiveDocument;
 
     var dbObjects = doc.GetObjects(objectIds);
     var acadObjectIds = dbObjects.Select(tuple => tuple.Root.Id).ToArray();
-    HighlightObjectsOnView(acadObjectIds);
+    await HighlightObjectsOnView(acadObjectIds);
   }
 
-  public void HighlightModel(string modelCardId)
+  public async Task HighlightModel(string modelCardId)
   {
     // POC: Will be addressed to move it into AutocadContext!
     var doc = Application.DocumentManager.MdiActiveDocument;
@@ -82,14 +104,16 @@ public class AutocadBasicConnectorBinding : IBasicConnectorBinding
     var objectIds = Array.Empty<ObjectId>();
 
     var model = _store.GetModelById(modelCardId);
+
     if (model == null)
     {
+      _logger.LogError("Model was null when highlighting received model");
       return;
     }
 
     if (model is SenderModelCard senderModelCard)
     {
-      var dbObjects = doc.GetObjects(senderModelCard.SendFilter.NotNull().GetObjectIds());
+      var dbObjects = doc.GetObjects(senderModelCard.SendFilter.NotNull().RefreshObjectIds());
       objectIds = dbObjects.Select(tuple => tuple.Root.Id).ToArray();
     }
 
@@ -101,22 +125,22 @@ public class AutocadBasicConnectorBinding : IBasicConnectorBinding
 
     if (objectIds.Length == 0)
     {
-      Commands.SetModelError(modelCardId, new OperationCanceledException("No objects found to highlight."));
+      await Commands.SetModelError(modelCardId, new OperationCanceledException("No objects found to highlight."));
       return;
     }
 
-    HighlightObjectsOnView(objectIds, modelCardId);
+    await HighlightObjectsOnView(objectIds, modelCardId);
   }
 
-  private void HighlightObjectsOnView(ObjectId[] objectIds, string? modelCardId = null)
+  private async Task HighlightObjectsOnView(ObjectId[] objectIds, string? modelCardId = null)
   {
     var doc = Application.DocumentManager.MdiActiveDocument;
 
-    Parent.RunOnMainThread(() =>
+    await _threadContext.RunOnMainAsync(async () =>
     {
       try
       {
-        doc.Editor.SetImpliedSelection(Array.Empty<ObjectId>()); // Deselects
+        doc.Editor.SetImpliedSelection([]); // Deselects
         try
         {
           doc.Editor.SetImpliedSelection(objectIds);
@@ -147,6 +171,7 @@ public class AutocadBasicConnectorBinding : IBasicConnectorBinding
           {
             // Note: we're swallowing exeptions here because of a weird case when receiving blocks, we would have
             // acad api throw an error on accessing entity.GeometricExtents.
+            // may also throw Autodesk.AutoCAD.Runtime.Exception for invalid extents on objects like rays and xlines
           }
         }
 
@@ -158,7 +183,7 @@ public class AutocadBasicConnectorBinding : IBasicConnectorBinding
       {
         if (modelCardId != null)
         {
-          Commands.SetModelError(modelCardId, new OperationCanceledException("Failed to highlight objects."));
+          await Commands.SetModelError(modelCardId, new OperationCanceledException("Failed to highlight objects."));
         }
         else
         {

Connectors/Autocad/Speckle.Connectors.AutocadShared/Bindings/AutocadReceiveBaseBinding.cs

@@ -0,0 +1,119 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.DUI.Logging;
+using Speckle.Connectors.DUI.Models;
+using Speckle.Connectors.DUI.Models.Card;
+using Speckle.Sdk;
+
+namespace Speckle.Connectors.Autocad.Bindings;
+
+public abstract class AutocadReceiveBaseBinding : IReceiveBinding
+{
+  public string Name => "receiveBinding";
+  public IBrowserBridge Parent { get; }
+
+  private readonly DocumentModelStore _store;
+  private readonly ICancellationManager _cancellationManager;
+  private readonly IServiceProvider _serviceProvider;
+  private readonly IOperationProgressManager _operationProgressManager;
+  private readonly ILogger<AutocadReceiveBinding> _logger;
+  private readonly ISpeckleApplication _speckleApplication;
+  private readonly IThreadContext _threadContext;
+
+  private ReceiveBindingUICommands Commands { get; }
+
+  protected AutocadReceiveBaseBinding(
+    DocumentModelStore store,
+    IBrowserBridge parent,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
+    IOperationProgressManager operationProgressManager,
+    ILogger<AutocadReceiveBinding> logger,
+    ISpeckleApplication speckleApplication,
+    IThreadContext threadContext
+  )
+  {
+    _store = store;
+    _cancellationManager = cancellationManager;
+    _serviceProvider = serviceProvider;
+    _operationProgressManager = operationProgressManager;
+    _logger = logger;
+    _speckleApplication = speckleApplication;
+    _threadContext = threadContext;
+    Parent = parent;
+    Commands = new ReceiveBindingUICommands(parent);
+  }
+
+  protected abstract void InitializeSettings(IServiceProvider serviceProvider);
+
+  public void CancelReceive(string modelCardId) => _cancellationManager.CancelOperation(modelCardId);
+
+  public async Task Receive(string modelCardId) =>
+    await _threadContext.RunOnMainAsync(async () => await ReceiveInternal(modelCardId));
+
+  private async Task ReceiveInternal(string modelCardId)
+  {
+    using var scope = _serviceProvider.CreateScope();
+    InitializeSettings(scope.ServiceProvider);
+
+    try
+    {
+      // Get receiver card
+      if (_store.GetModelById(modelCardId) is not ReceiverModelCard modelCard)
+      {
+        // Handle as GLOBAL ERROR at BrowserBridge
+        throw new InvalidOperationException("No download model card was found.");
+      }
+
+      using var cancellationItem = _cancellationManager.GetCancellationItem(modelCardId);
+
+      // Disable document activation (document creation and document switch)
+      // Not disabling results in DUI model card being out of sync with the active document
+      // The DocumentActivated event isn't usable probably because it is pushed to back of main thread queue
+      Application.DocumentManager.DocumentActivationEnabled = false;
+
+      // Receive host objects
+      var operationResults = await scope
+        .ServiceProvider.GetRequiredService<ReceiveOperation>()
+        .Execute(
+          modelCard.GetReceiveInfo(_speckleApplication.Slug),
+          _operationProgressManager.CreateOperationProgressEventHandler(Parent, modelCardId, cancellationItem.Token),
+          cancellationItem.Token
+        );
+
+      await Commands.SetModelReceiveResult(
+        modelCardId,
+        operationResults.BakedObjectIds,
+        operationResults.ConversionResults
+      );
+    }
+    catch (OperationCanceledException)
+    {
+      // SWALLOW -> UI handles it immediately, so we do not need to handle anything for now!
+      // Idea for later -> when cancel called, create promise from UI to solve it later with this catch block.
+      // So have 3 state on UI -> Cancellation clicked -> Cancelling -> Cancelled
+      return;
+    }
+    catch (Exception ex) when (!ex.IsFatal()) // UX reasons - we will report operation exceptions as model card error. We may change this later when we have more exception documentation
+    {
+      _logger.LogModelCardHandledError(ex);
+      await Commands.SetModelError(modelCardId, ex);
+    }
+    finally
+    {
+      // reenable document activation
+      Application.DocumentManager.DocumentActivationEnabled = true;
+
+      // regenerate doc to flush graphics, sometimes some objects (ellipses, nurbs curves) do not appear fully visible after receive.
+      // Adding a regen (must be run on main thread) here, but it doesn't seem to work:
+      // it's run on main thread, tried sending the "regen" string to execute, also tried regen after every object bake, but still can't fix.
+      // the objects should appear visible if you manually call the "regen" command after the operation finishes, or click on a view on the view cube which also calls regen.
+      Application.DocumentManager.CurrentDocument.Editor.Regen();
+    }
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/Bindings/AutocadReceiveBinding.cs

@@ -1,101 +1,49 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Speckle.Autofac.DependencyInjection;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
-using Speckle.Connectors.DUI.Logging;
 using Speckle.Connectors.DUI.Models;
-using Speckle.Connectors.DUI.Models.Card;
-using Speckle.Connectors.Utils.Cancellation;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Converters.Autocad;
+using Speckle.Converters.Common;
 using Speckle.Sdk;
 
 namespace Speckle.Connectors.Autocad.Bindings;
 
-public sealed class AutocadReceiveBinding : IReceiveBinding
+public sealed class AutocadReceiveBinding : AutocadReceiveBaseBinding
 {
-  public string Name => "receiveBinding";
-  public IBridge Parent { get; }
-
-  private readonly DocumentModelStore _store;
-  private readonly CancellationManager _cancellationManager;
-  private readonly IUnitOfWorkFactory _unitOfWorkFactory;
-  private readonly IOperationProgressManager _operationProgressManager;
-  private readonly ILogger<AutocadReceiveBinding> _logger;
-
-  private ReceiveBindingUICommands Commands { get; }
+  private readonly IAutocadConversionSettingsFactory _autocadConversionSettingsFactory;
 
   public AutocadReceiveBinding(
     DocumentModelStore store,
-    IBridge parent,
-    CancellationManager cancellationManager,
-    IUnitOfWorkFactory unitOfWorkFactory,
+    IBrowserBridge parent,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
     IOperationProgressManager operationProgressManager,
-    ILogger<AutocadReceiveBinding> logger
+    ILogger<AutocadReceiveBinding> logger,
+    IAutocadConversionSettingsFactory autocadConversionSettingsFactory,
+    ISpeckleApplication speckleApplication,
+    IThreadContext threadContext
   )
+    : base(
+      store,
+      parent,
+      cancellationManager,
+      serviceProvider,
+      operationProgressManager,
+      logger,
+      speckleApplication,
+      threadContext
+    )
   {
-    _store = store;
-    _cancellationManager = cancellationManager;
-    _unitOfWorkFactory = unitOfWorkFactory;
-    _operationProgressManager = operationProgressManager;
-    _logger = logger;
-    Parent = parent;
-    Commands = new ReceiveBindingUICommands(parent);
+    _autocadConversionSettingsFactory = autocadConversionSettingsFactory;
   }
 
-  public void CancelReceive(string modelCardId) => _cancellationManager.CancelOperation(modelCardId);
-
-  public async Task Receive(string modelCardId)
+  protected override void InitializeSettings(IServiceProvider serviceProvider)
   {
-    using var unitOfWork = _unitOfWorkFactory.Resolve<ReceiveOperation>();
-    try
-    {
-      // Get receiver card
-      if (_store.GetModelById(modelCardId) is not ReceiverModelCard modelCard)
-      {
-        // Handle as GLOBAL ERROR at BrowserBridge
-        throw new InvalidOperationException("No download model card was found.");
-      }
-
-      CancellationToken cancellationToken = _cancellationManager.InitCancellationTokenSource(modelCardId);
-
-      // Disable document activation (document creation and document switch)
-      // Not disabling results in DUI model card being out of sync with the active document
-      // The DocumentActivated event isn't usable probably because it is pushed to back of main thread queue
-      Application.DocumentManager.DocumentActivationEnabled = false;
-
-      // Receive host objects
-      var operationResults = await unitOfWork
-        .Service.Execute(
-          modelCard.GetReceiveInfo(Speckle.Connectors.Utils.Connector.Slug),
-          cancellationToken,
-          (status, progress) =>
-            _operationProgressManager.SetModelProgress(
-              Parent,
-              modelCardId,
-              new ModelCardProgress(modelCardId, status, progress),
-              cancellationToken
-            )
-        )
-        .ConfigureAwait(false);
-
-      Commands.SetModelReceiveResult(modelCardId, operationResults.BakedObjectIds, operationResults.ConversionResults);
-    }
-    catch (OperationCanceledException)
-    {
-      // SWALLOW -> UI handles it immediately, so we do not need to handle anything for now!
-      // Idea for later -> when cancel called, create promise from UI to solve it later with this catch block.
-      // So have 3 state on UI -> Cancellation clicked -> Cancelling -> Cancelled
-      return;
-    }
-    catch (Exception ex) when (!ex.IsFatal()) // UX reasons - we will report operation exceptions as model card error. We may change this later when we have more exception documentation
-    {
-      _logger.LogModelCardHandledError(ex);
-      Commands.SetModelError(modelCardId, ex);
-    }
-    finally
-    {
-      // reenable document activation
-      Application.DocumentManager.DocumentActivationEnabled = true;
-    }
+    serviceProvider
+      .GetRequiredService<IConverterSettingsStore<AutocadConversionSettings>>()
+      .Initialize(_autocadConversionSettingsFactory.Create(Application.DocumentManager.CurrentDocument));
   }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/Bindings/AutocadSelectionBinding.cs

@@ -1,6 +1,7 @@
 using Autodesk.AutoCAD.DatabaseServices;
 using Autodesk.AutoCAD.EditorInput;
 using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
 
@@ -8,17 +9,23 @@ namespace Speckle.Connectors.Autocad.Bindings;
 
 public class AutocadSelectionBinding : ISelectionBinding
 {
-  private const string SELECTION_EVENT = "setSelection";
   private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
+  private readonly IThreadContext _threadContext;
+  private const string SELECTION_EVENT = "setSelection";
   private readonly HashSet<Document> _visitedDocuments = new();
 
   public string Name => "selectionBinding";
 
-  public IBridge Parent { get; }
+  public IBrowserBridge Parent { get; }
 
-  public AutocadSelectionBinding(IBridge parent)
+  public AutocadSelectionBinding(
+    IBrowserBridge parent,
+    ITopLevelExceptionHandler topLevelExceptionHandler,
+    IThreadContext threadContext
+  )
   {
-    _topLevelExceptionHandler = parent.TopLevelExceptionHandler;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
+    _threadContext = threadContext;
     Parent = parent;
 
     // POC: Use here Context for doc. In converters it's OK but we are still lacking to use context into bindings.
@@ -41,7 +48,7 @@ public class AutocadSelectionBinding : ISelectionBinding
     if (!_visitedDocuments.Contains(document))
     {
       document.ImpliedSelectionChanged += (_, _) =>
-        _topLevelExceptionHandler.CatchUnhandled(() => Parent.RunOnMainThread(OnSelectionChanged));
+        _topLevelExceptionHandler.FireAndForget(async () => await _threadContext.RunOnMainAsync(OnSelectionChanged));
 
       _visitedDocuments.Add(document);
     }
@@ -52,10 +59,10 @@ public class AutocadSelectionBinding : ISelectionBinding
   // Ui requests to GetSelection() should just return this local copy that is kept up to date by the event handler.
   private SelectionInfo _selectionInfo;
 
-  private void OnSelectionChanged()
+  private async Task OnSelectionChanged()
   {
     _selectionInfo = GetSelectionInternal();
-    Parent.Send(SELECTION_EVENT, _selectionInfo);
+    await Parent.Send(SELECTION_EVENT, _selectionInfo);
   }
 
   public SelectionInfo GetSelection() => _selectionInfo;
@@ -82,6 +89,17 @@ public class AutocadSelectionBinding : ISelectionBinding
 
           objectTypes.Add(dbObject.GetType().Name);
           objs.Add(dbObject.GetSpeckleApplicationId());
+
+          // do the same also for each AttributeReference inside the BlockReference (attribute change is not affecting the block otherwise)
+          if (dbObject is BlockReference blockReference)
+          {
+            foreach (ObjectId id in blockReference.AttributeCollection)
+            {
+              var attr = (AttributeReference)tr.GetObject(id, OpenMode.ForRead);
+              objectTypes.Add(attr.GetType().Name);
+              objs.Add(attr.GetSpeckleApplicationId());
+            }
+          }
         }
 
         tr.Commit();

Connectors/Autocad/Speckle.Connectors.AutocadShared/Bindings/AutocadSendBaseBinding.cs

@@ -0,0 +1,213 @@
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.DUI.Exceptions;
+using Speckle.Connectors.DUI.Logging;
+using Speckle.Connectors.DUI.Models;
+using Speckle.Connectors.DUI.Models.Card;
+using Speckle.Connectors.DUI.Models.Card.SendFilter;
+using Speckle.Connectors.DUI.Settings;
+using Speckle.Sdk;
+using Speckle.Sdk.Common;
+
+namespace Speckle.Connectors.Autocad.Bindings;
+
+[SuppressMessage("ReSharper", "AsyncVoidMethod")]
+public abstract class AutocadSendBaseBinding : ISendBinding
+{
+  public string Name => "sendBinding";
+  public SendBindingUICommands Commands { get; }
+  private OperationProgressManager OperationProgressManager { get; }
+  public IBrowserBridge Parent { get; }
+
+  private readonly DocumentModelStore _store;
+  private readonly List<ISendFilter> _sendFilters;
+  private readonly ICancellationManager _cancellationManager;
+  private readonly IServiceProvider _serviceProvider;
+  private readonly ISendConversionCache _sendConversionCache;
+  private readonly IOperationProgressManager _operationProgressManager;
+  private readonly ILogger<AutocadSendBinding> _logger;
+  private readonly ISpeckleApplication _speckleApplication;
+  private readonly IThreadContext _threadContext;
+  private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
+  private readonly IAppIdleManager _idleManager;
+
+  /// <summary>
+  /// Used internally to aggregate the changed objects' id. Note we're using a concurrent dictionary here as the expiry check method is not thread safe, and this was causing problems. See:
+  /// [CNX-202: Unhandled Exception Occurred when receiving in Rhino](https://linear.app/speckle/issue/CNX-202/unhandled-exception-occurred-when-receiving-in-rhino)
+  /// As to why a concurrent dictionary, it's because it's the cheapest/easiest way to do so.
+  /// https://stackoverflow.com/questions/18922985/concurrent-hashsett-in-net-framework
+  /// </summary>
+  private ConcurrentBag<string> ChangedObjectIds { get; set; } = new();
+
+  protected AutocadSendBaseBinding(
+    DocumentModelStore store,
+    IBrowserBridge parent,
+    IEnumerable<ISendFilter> sendFilters,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
+    ISendConversionCache sendConversionCache,
+    IOperationProgressManager operationProgressManager,
+    ILogger<AutocadSendBinding> logger,
+    ISpeckleApplication speckleApplication,
+    IThreadContext threadContext,
+    ITopLevelExceptionHandler topLevelExceptionHandler,
+    IAppIdleManager idleManager
+  )
+  {
+    _store = store;
+    _serviceProvider = serviceProvider;
+    _cancellationManager = cancellationManager;
+    _sendFilters = sendFilters.ToList();
+    _sendConversionCache = sendConversionCache;
+    _operationProgressManager = operationProgressManager;
+    _logger = logger;
+    _speckleApplication = speckleApplication;
+    _threadContext = threadContext;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
+    _idleManager = idleManager;
+    Parent = parent;
+    Commands = new SendBindingUICommands(parent);
+
+    Application.DocumentManager.DocumentActivated += (_, args) =>
+      _topLevelExceptionHandler.CatchUnhandled(() => SubscribeToObjectChanges(args.Document));
+
+    if (Application.DocumentManager.CurrentDocument != null)
+    {
+      // catches the case when autocad just opens up with a blank new doc
+      SubscribeToObjectChanges(Application.DocumentManager.CurrentDocument);
+    }
+    // Since ids of the objects generates from same seed, we should clear the cache always whenever doc swapped.
+    _store.DocumentChanged += (_, _) =>
+    {
+      _sendConversionCache.ClearCache();
+    };
+  }
+
+  private readonly List<string> _docSubsTracker = new();
+
+  private void SubscribeToObjectChanges(Document doc)
+  {
+    if (doc == null || doc.Database == null || _docSubsTracker.Contains(doc.Name))
+    {
+      return;
+    }
+
+    _docSubsTracker.Add(doc.Name);
+    doc.Database.ObjectAppended += (_, e) => OnObjectChanged(e.DBObject);
+    doc.Database.ObjectErased += (_, e) => OnObjectChanged(e.DBObject);
+    doc.Database.ObjectModified += (_, e) => OnObjectChanged(e.DBObject);
+  }
+
+  private void OnObjectChanged(DBObject dbObject) =>
+    _topLevelExceptionHandler.CatchUnhandled(() => OnChangeChangedObjectIds(dbObject));
+
+  private void OnChangeChangedObjectIds(DBObject dBObject)
+  {
+    ChangedObjectIds.Add(dBObject.GetSpeckleApplicationId());
+    _idleManager.SubscribeToIdle(nameof(RunExpirationChecks), async () => await RunExpirationChecks());
+  }
+
+  private async Task RunExpirationChecks()
+  {
+    var senders = _store.GetSenders();
+    List<string> expiredSenderIds = new();
+
+    _sendConversionCache.EvictObjects(ChangedObjectIds);
+
+    foreach (SenderModelCard modelCard in senders)
+    {
+      var intersection = modelCard.SendFilter.NotNull().RefreshObjectIds().Intersect(ChangedObjectIds).ToList();
+      bool isExpired = intersection.Count != 0;
+      if (isExpired)
+      {
+        expiredSenderIds.Add(modelCard.ModelCardId.NotNull());
+      }
+    }
+
+    await Commands.SetModelsExpired(expiredSenderIds);
+    ChangedObjectIds = new();
+  }
+
+  public List<ISendFilter> GetSendFilters() => _sendFilters;
+
+  public List<ICardSetting> GetSendSettings() => [];
+
+  public async Task Send(string modelCardId) =>
+    await _threadContext.RunOnMainAsync(async () => await SendInternal(modelCardId));
+
+  protected abstract void InitializeSettings(IServiceProvider serviceProvider);
+
+  private async Task SendInternal(string modelCardId)
+  {
+    try
+    {
+      if (_store.GetModelById(modelCardId) is not SenderModelCard modelCard)
+      {
+        // Handle as GLOBAL ERROR at BrowserBridge
+        throw new InvalidOperationException("No publish model card was found.");
+      }
+
+      using var scope = _serviceProvider.CreateScope();
+      InitializeSettings(scope.ServiceProvider);
+
+      using var cancellationItem = _cancellationManager.GetCancellationItem(modelCardId);
+
+      // Disable document activation (document creation and document switch)
+      // Not disabling results in DUI model card being out of sync with the active document
+      // The DocumentActivated event isn't usable probably because it is pushed to back of main thread queue
+      Application.DocumentManager.DocumentActivationEnabled = false;
+
+      // Get elements to convert
+      List<AutocadRootObject> autocadObjects = Application.DocumentManager.CurrentDocument.GetObjects(
+        modelCard.SendFilter.NotNull().RefreshObjectIds()
+      );
+
+      if (autocadObjects.Count == 0)
+      {
+        // Handle as CARD ERROR in this function
+        throw new SpeckleSendFilterException("No objects were found to convert. Please update your publish filter!");
+      }
+
+      var sendResult = await scope
+        .ServiceProvider.GetRequiredService<SendOperation<AutocadRootObject>>()
+        .Execute(
+          autocadObjects,
+          modelCard.GetSendInfo(_speckleApplication.ApplicationAndVersion),
+          _operationProgressManager.CreateOperationProgressEventHandler(Parent, modelCardId, cancellationItem.Token),
+          cancellationItem.Token
+        );
+
+      await Commands.SetModelSendResult(modelCardId, sendResult.RootObjId, sendResult.ConversionResults);
+    }
+    catch (OperationCanceledException)
+    {
+      // SWALLOW -> UI handles it immediately, so we do not need to handle anything for now!
+      // Idea for later -> when cancel called, create promise from UI to solve it later with this catch block.
+      // So have 3 state on UI -> Cancellation clicked -> Cancelling -> Cancelled
+      return;
+    }
+    catch (Exception ex) when (!ex.IsFatal()) // UX reasons - we will report operation exceptions as model card error. We may change this later when we have more exception documentation
+    {
+      _logger.LogModelCardHandledError(ex);
+      await Commands.SetModelError(modelCardId, ex);
+    }
+    finally
+    {
+      // renable document activation
+      Application.DocumentManager.DocumentActivationEnabled = true;
+    }
+  }
+
+  public void CancelSend(string modelCardId) => _cancellationManager.CancelOperation(modelCardId);
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/Bindings/AutocadSendBinding.cs

@@ -1,213 +1,59 @@
-using System.Collections.Concurrent;
-using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Speckle.Autofac.DependencyInjection;
-using Speckle.Connectors.Autocad.HostApp;
-using Speckle.Connectors.Autocad.HostApp.Extensions;
-using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
-using Speckle.Connectors.DUI.Exceptions;
-using Speckle.Connectors.DUI.Logging;
 using Speckle.Connectors.DUI.Models;
-using Speckle.Connectors.DUI.Models.Card;
 using Speckle.Connectors.DUI.Models.Card.SendFilter;
-using Speckle.Connectors.DUI.Settings;
-using Speckle.Connectors.Utils.Caching;
-using Speckle.Connectors.Utils.Cancellation;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Converters.Autocad;
+using Speckle.Converters.Common;
 using Speckle.Sdk;
-using Speckle.Sdk.Common;
 
 namespace Speckle.Connectors.Autocad.Bindings;
 
-public sealed class AutocadSendBinding : ISendBinding
+public sealed class AutocadSendBinding : AutocadSendBaseBinding
 {
-  public string Name => "sendBinding";
-  public SendBindingUICommands Commands { get; }
-  private OperationProgressManager OperationProgressManager { get; }
-  public IBridge Parent { get; }
-
-  private readonly DocumentModelStore _store;
-  private readonly IAutocadIdleManager _idleManager;
-  private readonly List<ISendFilter> _sendFilters;
-  private readonly CancellationManager _cancellationManager;
-  private readonly IUnitOfWorkFactory _unitOfWorkFactory;
-  private readonly ISendConversionCache _sendConversionCache;
-  private readonly IOperationProgressManager _operationProgressManager;
-  private readonly ILogger<AutocadSendBinding> _logger;
-  private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
-
-  /// <summary>
-  /// Used internally to aggregate the changed objects' id. Note we're using a concurrent dictionary here as the expiry check method is not thread safe, and this was causing problems. See:
-  /// [CNX-202: Unhandled Exception Occurred when receiving in Rhino](https://linear.app/speckle/issue/CNX-202/unhandled-exception-occurred-when-receiving-in-rhino)
-  /// As to why a concurrent dictionary, it's because it's the cheapest/easiest way to do so.
-  /// https://stackoverflow.com/questions/18922985/concurrent-hashsett-in-net-framework
-  /// </summary>
-  private ConcurrentDictionary<string, byte> ChangedObjectIds { get; set; } = new();
+  private readonly IAutocadConversionSettingsFactory _autocadConversionSettingsFactory;
 
   public AutocadSendBinding(
     DocumentModelStore store,
-    IAutocadIdleManager idleManager,
-    IBridge parent,
+    IBrowserBridge parent,
     IEnumerable<ISendFilter> sendFilters,
-    CancellationManager cancellationManager,
-    IUnitOfWorkFactory unitOfWorkFactory,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
     ISendConversionCache sendConversionCache,
     IOperationProgressManager operationProgressManager,
-    ILogger<AutocadSendBinding> logger
+    ILogger<AutocadSendBinding> logger,
+    IAutocadConversionSettingsFactory autocadConversionSettingsFactory,
+    ISpeckleApplication speckleApplication,
+    IThreadContext threadContext,
+    ITopLevelExceptionHandler topLevelExceptionHandler,
+    IAppIdleManager appIdleManager
   )
+    : base(
+      store,
+      parent,
+      sendFilters,
+      cancellationManager,
+      serviceProvider,
+      sendConversionCache,
+      operationProgressManager,
+      logger,
+      speckleApplication,
+      threadContext,
+      topLevelExceptionHandler,
+      appIdleManager
+    )
   {
-    _store = store;
-    _idleManager = idleManager;
-    _unitOfWorkFactory = unitOfWorkFactory;
-    _cancellationManager = cancellationManager;
-    _sendFilters = sendFilters.ToList();
-    _sendConversionCache = sendConversionCache;
-    _operationProgressManager = operationProgressManager;
-    _logger = logger;
-    _topLevelExceptionHandler = parent.TopLevelExceptionHandler;
-    Parent = parent;
-    Commands = new SendBindingUICommands(parent);
-
-    Application.DocumentManager.DocumentActivated += (_, args) =>
-      _topLevelExceptionHandler.CatchUnhandled(() => SubscribeToObjectChanges(args.Document));
-
-    if (Application.DocumentManager.CurrentDocument != null)
-    {
-      // catches the case when autocad just opens up with a blank new doc
-      SubscribeToObjectChanges(Application.DocumentManager.CurrentDocument);
-    }
-    // Since ids of the objects generates from same seed, we should clear the cache always whenever doc swapped.
-    _store.DocumentChanged += (_, _) =>
-    {
-      _sendConversionCache.ClearCache();
-    };
+    _autocadConversionSettingsFactory = autocadConversionSettingsFactory;
   }
 
-  private readonly List<string> _docSubsTracker = new();
-
-  private void SubscribeToObjectChanges(Document doc)
+  protected override void InitializeSettings(IServiceProvider serviceProvider)
   {
-    if (doc == null || doc.Database == null || _docSubsTracker.Contains(doc.Name))
-    {
-      return;
-    }
-
-    _docSubsTracker.Add(doc.Name);
-    doc.Database.ObjectAppended += (_, e) => OnObjectChanged(e.DBObject);
-    doc.Database.ObjectErased += (_, e) => OnObjectChanged(e.DBObject);
-    doc.Database.ObjectModified += (_, e) => OnObjectChanged(e.DBObject);
+    serviceProvider
+      .GetRequiredService<IConverterSettingsStore<AutocadConversionSettings>>()
+      .Initialize(_autocadConversionSettingsFactory.Create(Application.DocumentManager.CurrentDocument));
   }
-
-  private void OnObjectChanged(DBObject dbObject)
-  {
-    _topLevelExceptionHandler.CatchUnhandled(() => OnChangeChangedObjectIds(dbObject));
-  }
-
-  private void OnChangeChangedObjectIds(DBObject dBObject)
-  {
-    ChangedObjectIds[dBObject.GetSpeckleApplicationId()] = 1;
-    _idleManager.SubscribeToIdle(nameof(AutocadSendBinding), RunExpirationChecks);
-  }
-
-  private void RunExpirationChecks()
-  {
-    var senders = _store.GetSenders();
-    string[] objectIdsList = ChangedObjectIds.Keys.ToArray();
-    List<string> expiredSenderIds = new();
-
-    _sendConversionCache.EvictObjects(objectIdsList);
-
-    foreach (SenderModelCard modelCard in senders)
-    {
-      var intersection = modelCard.SendFilter.NotNull().GetObjectIds().Intersect(objectIdsList).ToList();
-      bool isExpired = intersection.Count != 0;
-      if (isExpired)
-      {
-        expiredSenderIds.Add(modelCard.ModelCardId.NotNull());
-      }
-    }
-
-    Commands.SetModelsExpired(expiredSenderIds);
-    ChangedObjectIds = new();
-  }
-
-  public List<ISendFilter> GetSendFilters() => _sendFilters;
-
-  public List<ICardSetting> GetSendSettings() => [];
-
-  public Task Send(string modelCardId)
-  {
-    Parent.RunOnMainThread(async () => await SendInternal(modelCardId).ConfigureAwait(false));
-    return Task.CompletedTask;
-  }
-
-  private async Task SendInternal(string modelCardId)
-  {
-    try
-    {
-      if (_store.GetModelById(modelCardId) is not SenderModelCard modelCard)
-      {
-        // Handle as GLOBAL ERROR at BrowserBridge
-        throw new InvalidOperationException("No publish model card was found.");
-      }
-
-      using var uow = _unitOfWorkFactory.Resolve<SendOperation<AutocadRootObject>>();
-
-      CancellationToken cancellationToken = _cancellationManager.InitCancellationTokenSource(modelCardId);
-
-      // Disable document activation (document creation and document switch)
-      // Not disabling results in DUI model card being out of sync with the active document
-      // The DocumentActivated event isn't usable probably because it is pushed to back of main thread queue
-      Application.DocumentManager.DocumentActivationEnabled = false;
-
-      // Get elements to convert
-      List<AutocadRootObject> autocadObjects = Application.DocumentManager.CurrentDocument.GetObjects(
-        modelCard.SendFilter.NotNull().GetObjectIds()
-      );
-
-      if (autocadObjects.Count == 0)
-      {
-        // Handle as CARD ERROR in this function
-        throw new SpeckleSendFilterException("No objects were found to convert. Please update your publish filter!");
-      }
-
-      var sendResult = await uow
-        .Service.Execute(
-          autocadObjects,
-          modelCard.GetSendInfo(Speckle.Connectors.Utils.Connector.Slug),
-          (status, progress) =>
-            _operationProgressManager.SetModelProgress(
-              Parent,
-              modelCardId,
-              new ModelCardProgress(modelCardId, status, progress),
-              cancellationToken
-            ),
-          cancellationToken
-        )
-        .ConfigureAwait(false);
-
-      Commands.SetModelSendResult(modelCardId, sendResult.RootObjId, sendResult.ConversionResults);
-    }
-    catch (OperationCanceledException)
-    {
-      // SWALLOW -> UI handles it immediately, so we do not need to handle anything for now!
-      // Idea for later -> when cancel called, create promise from UI to solve it later with this catch block.
-      // So have 3 state on UI -> Cancellation clicked -> Cancelling -> Cancelled
-      return;
-    }
-    catch (Exception ex) when (!ex.IsFatal()) // UX reasons - we will report operation exceptions as model card error. We may change this later when we have more exception documentation
-    {
-      _logger.LogModelCardHandledError(ex);
-      Commands.SetModelError(modelCardId, ex);
-    }
-    finally
-    {
-      // renable document activation
-      Application.DocumentManager.DocumentActivationEnabled = true;
-    }
-  }
-
-  public void CancelSend(string modelCardId) => _cancellationManager.CancelOperation(modelCardId);
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/DependencyInjection/AutocadConnectorModule.cs

@@ -1,21 +1,30 @@
 #if AUTOCAD
-using Speckle.Autofac.DependencyInjection;
+using System.Reflection;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Connectors.Autocad.Bindings;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common.Builders;
 using Speckle.Connectors.DUI.Bindings;
+using Speckle.Sdk;
 
 namespace Speckle.Connectors.Autocad.DependencyInjection;
 
-public class AutocadConnectorModule : ISpeckleModule
+public static class AutocadConnectorModule
 {
-  public void Load(SpeckleContainerBuilder builder)
+  public static void AddAutocad(this IServiceCollection serviceCollection)
   {
-    SharedRegistration.Load(builder);
+    serviceCollection.AddAutocadBase();
 
-    // Operations
-    SharedRegistration.LoadSend(builder);
-    SharedRegistration.LoadReceive(builder);
+    // Send
+    serviceCollection.LoadSend();
+    serviceCollection.AddScoped<IRootObjectBuilder<AutocadRootObject>, AutocadRootObjectBuilder>();
 
-    // Register bindings
-    builder.AddSingleton<IBinding, ConfigBinding>("connectorName", "Autocad"); // POC: Easier like this for now, should be cleaned up later
+    // Receive
+    serviceCollection.LoadReceive();
+
+    // Register vertical specific bindings
+    serviceCollection.AddSingleton<IBinding, AutocadSendBinding>();
+    serviceCollection.AddMatchingInterfacesAsTransient(Assembly.GetExecutingAssembly());
   }
 }
 #endif

Connectors/Autocad/Speckle.Connectors.AutocadShared/DependencyInjection/Civil3dConnectorModule.cs

@@ -1,19 +1,19 @@
 #if CIVIL3D
-
-using Speckle.Autofac.DependencyInjection;
-using Speckle.Connectors.DUI.Bindings;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common.Builders;
 
 namespace Speckle.Connectors.Autocad.DependencyInjection;
 
-public class Civil3dConnectorModule : ISpeckleModule
+public static class Civil3dConnectorModule
 {
-  public void Load(SpeckleContainerBuilder builder)
+  public static void AddCivil3d(this IServiceCollection serviceCollection)
   {
-    SharedRegistration.Load(builder);
-    SharedRegistration.LoadSend(builder);
+    serviceCollection.AddAutocadBase();
 
-    // Register bindings
-    builder.AddSingleton<IBinding, ConfigBinding>("connectorName", "Civil3d"); // POC: Easier like this for now, should be cleaned up later
+    // send
+    serviceCollection.LoadSend();
+    serviceCollection.AddScoped<IRootObjectBuilder<AutocadRootObject>, Civil3dRootObjectBuilder>();
   }
 }
 #endif

Connectors/Autocad/Speckle.Connectors.AutocadShared/DependencyInjection/SharedRegistration.cs

@@ -1,101 +1,93 @@
 using Autodesk.AutoCAD.DatabaseServices;
-using Autofac;
-using Speckle.Autofac;
-using Speckle.Autofac.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using Speckle.Connectors.Autocad.Bindings;
 using Speckle.Connectors.Autocad.Filters;
 using Speckle.Connectors.Autocad.HostApp;
 using Speckle.Connectors.Autocad.Operations.Receive;
 using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Instances;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Connectors.Common.Threading;
 using Speckle.Connectors.DUI;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
-using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card.SendFilter;
 using Speckle.Connectors.DUI.WebView;
-using Speckle.Connectors.Utils;
-using Speckle.Connectors.Utils.Builders;
-using Speckle.Connectors.Utils.Caching;
-using Speckle.Connectors.Utils.Instances;
-using Speckle.Connectors.Utils.Operations;
-using Speckle.Converters.Common;
 using Speckle.Sdk.Models.GraphTraversal;
 
 namespace Speckle.Connectors.Autocad.DependencyInjection;
 
 public static class SharedRegistration
 {
-  public static void Load(SpeckleContainerBuilder builder)
+  public static void AddAutocadBase(this IServiceCollection serviceCollection)
   {
-    builder.AddAutofac();
-    builder.AddConnectorUtils();
-    builder.AddDUI();
-    builder.AddDUIView();
+    serviceCollection.AddConnectors();
+    serviceCollection.AddDUI<DefaultThreadContext, AutocadDocumentStore>();
+    serviceCollection.AddDUIView();
 
     // Register other connector specific types
-    builder.AddTransient<TransactionContext>();
-    builder.AddSingleton(new AutocadDocumentManager()); // TODO: Dependent to TransactionContext, can be moved to AutocadContext
-    builder.AddSingleton<DocumentModelStore, AutocadDocumentStore>();
-    builder.AddSingleton<AutocadContext>();
-    builder.AddScoped<AutocadGroupManager>();
-    builder.AddScoped<AutocadLayerManager>();
-    builder.AddScoped<AutocadColorManager>();
-    builder.AddScoped<AutocadMaterialManager>();
-    builder.AddSingleton<IAutocadIdleManager, AutocadIdleManager>();
-    builder.AddSingleton<IHostToSpeckleUnitConverter<UnitsValue>>();
+    serviceCollection.AddTransient<TransactionContext>();
+    serviceCollection.AddSingleton(new AutocadDocumentManager()); // TODO: Dependent to TransactionContext, can be moved to AutocadContext
+    serviceCollection.AddSingleton<AutocadContext>();
+
+    // Unpackers and builders
+    serviceCollection.AddScoped<AutocadLayerUnpacker>();
+    serviceCollection.AddScoped<AutocadLayerBaker>();
+
+    serviceCollection.AddScoped<AutocadInstanceUnpacker>();
+    serviceCollection.AddScoped<AutocadInstanceBaker>();
+
+    serviceCollection.AddScoped<AutocadGroupUnpacker>();
+    serviceCollection.AddScoped<AutocadGroupBaker>();
+
+    serviceCollection.AddScoped<AutocadColorUnpacker>();
+    serviceCollection.AddScoped<IAutocadColorBaker, AutocadColorBaker>();
+
+    serviceCollection.AddScoped<AutocadMaterialUnpacker>();
+    serviceCollection.AddScoped<IAutocadMaterialBaker, AutocadMaterialBaker>();
+
+    serviceCollection.AddSingleton<IAppIdleManager, AutocadIdleManager>();
 
     // operation progress manager
-    builder.AddSingleton<IOperationProgressManager, OperationProgressManager>();
+    serviceCollection.AddSingleton<IOperationProgressManager, OperationProgressManager>();
 
     // Register bindings
-    builder.AddSingleton<IBinding, TestBinding>();
-    builder.AddSingleton<IBinding, AccountBinding>();
-    builder.AddSingleton<IBinding, AutocadSelectionBinding>();
-    builder
-      .ContainerBuilder.RegisterType<AutocadBasicConnectorBinding>()
-      .As<IBinding>()
-      .As<IBasicConnectorBinding>()
-      .SingleInstance();
-
-    //Top Level ExceptionHandler
-    builder.ContainerBuilder.RegisterType<TopLevelExceptionHandlerBinding>().As<IBinding>().AsSelf().SingleInstance();
-    builder.AddSingleton<ITopLevelExceptionHandler>(c =>
-      c.Resolve<TopLevelExceptionHandlerBinding>().Parent.TopLevelExceptionHandler
-    );
+    serviceCollection.AddSingleton<IBinding, TestBinding>();
+    serviceCollection.AddSingleton<IBinding, AccountBinding>();
+    serviceCollection.AddSingleton<IBinding, AutocadSelectionBinding>();
+    serviceCollection.AddSingleton<IBinding>(sp => sp.GetRequiredService<IBasicConnectorBinding>());
+    serviceCollection.AddSingleton<IBasicConnectorBinding, AutocadBasicConnectorBinding>();
+    serviceCollection.AddSingleton<IBinding, ConfigBinding>();
   }
 
-  public static void LoadSend(SpeckleContainerBuilder builder)
+  public static void LoadSend(this IServiceCollection serviceCollection)
   {
     // Operations
-    builder.AddScoped<SendOperation<AutocadRootObject>>();
-
-    // Object Builders
-    builder.AddScoped<IRootObjectBuilder<AutocadRootObject>, AutocadRootObjectBuilder>();
-
-    // Register bindings
-    builder.AddSingleton<IBinding, AutocadSendBinding>();
+    serviceCollection.AddScoped<SendOperation<AutocadRootObject>>();
 
     // register send filters
-    builder.AddTransient<ISendFilter, AutocadSelectionFilter>();
+    serviceCollection.AddTransient<ISendFilter, AutocadSelectionFilter>();
 
     // register send conversion cache
-    builder.AddSingleton<ISendConversionCache, SendConversionCache>();
-    builder.AddScoped<
+    serviceCollection.AddSingleton<ISendConversionCache, SendConversionCache>();
+    serviceCollection.AddScoped<
       IInstanceObjectsManager<AutocadRootObject, List<Entity>>,
       InstanceObjectsManager<AutocadRootObject, List<Entity>>
     >();
-    builder.AddScoped<AutocadInstanceObjectManager>();
   }
 
-  public static void LoadReceive(SpeckleContainerBuilder builder)
+  public static void LoadReceive(this IServiceCollection serviceCollection)
   {
     // traversal
-    builder.AddSingleton(DefaultTraversal.CreateTraversalFunc());
+    serviceCollection.AddSingleton(DefaultTraversal.CreateTraversalFunc());
 
     // Object Builders
-    builder.AddScoped<IHostObjectBuilder, AutocadHostObjectBuilder>();
+    serviceCollection.AddScoped<IHostObjectBuilder, AutocadHostObjectBuilder>();
 
     // Register bindings
-    builder.AddSingleton<IBinding, AutocadReceiveBinding>();
+    serviceCollection.AddSingleton<IBinding, AutocadReceiveBinding>();
   }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/Filters/AutocadSelectionFilter.cs

@@ -4,7 +4,10 @@ namespace Speckle.Connectors.Autocad.Filters;
 
 public class AutocadSelectionFilter : DirectSelectionSendFilter
 {
-  public override List<string> GetObjectIds() => SelectedObjectIds;
+  public AutocadSelectionFilter()
+  {
+    IsDefault = true;
+  }
 
-  public override bool CheckExpiry(string[] changedObjectIds) => SelectedObjectIds.Intersect(changedObjectIds).Any();
+  public override List<string> RefreshObjectIds() => SelectedObjectIds;
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadColorBaker.cs

@@ -0,0 +1,74 @@
+using Autodesk.AutoCAD.Colors;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Operations;
+using Speckle.InterfaceGenerator;
+using Speckle.Sdk;
+using Speckle.Sdk.Models.Proxies;
+using AutocadColor = Autodesk.AutoCAD.Colors.Color;
+
+namespace Speckle.Connectors.Autocad.HostApp;
+
+/// <summary>
+/// Expects to be a scoped dependency for a given operation and helps with layer creation and cleanup.
+/// </summary>
+[GenerateAutoInterface]
+public class AutocadColorBaker(ILogger<AutocadColorBaker> logger) : IAutocadColorBaker
+{
+  /// <summary>
+  /// For receive operations
+  /// </summary>
+  public Dictionary<string, AutocadColor> ObjectColorsIdMap { get; } = new();
+
+  /// <summary>
+  /// Parse Color Proxies and stores in ObjectColorIdMap the relationship between object ids and colors
+  /// </summary>
+  /// <param name="colorProxies"></param>
+  /// <param name="onOperationProgressed"></param>
+  public void ParseColors(IReadOnlyCollection<ColorProxy> colorProxies, IProgress<CardProgress> onOperationProgressed)
+  {
+    var count = 0;
+    foreach (ColorProxy colorProxy in colorProxies)
+    {
+      try
+      {
+        onOperationProgressed.Report(new("Converting colors", (double)++count / colorProxies.Count));
+
+        // skip any colors with source = layer, since object color default source is by layer
+        if (colorProxy["source"] is string source && source == "layer")
+        {
+          continue;
+        }
+
+        foreach (string objectId in colorProxy.objects)
+        {
+          AutocadColor convertedColor = ConvertColorProxyToColor(colorProxy);
+#if NET8_0
+          ObjectColorsIdMap.TryAdd(objectId, convertedColor);
+#else
+          if (!ObjectColorsIdMap.ContainsKey(objectId))
+          {
+            ObjectColorsIdMap.Add(objectId, convertedColor);
+          }
+#endif
+        }
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        logger.LogError(ex, "Failed parsing color proxy");
+      }
+    }
+  }
+
+  private AutocadColor ConvertColorProxyToColor(ColorProxy colorProxy)
+  {
+    // if source = block, return a default ByBlock color
+    if (colorProxy["source"] is string source && source == "block")
+    {
+      return AutocadColor.FromColorIndex(ColorMethod.ByBlock, 0);
+    }
+
+    return colorProxy["autocadColorIndex"] is long index
+      ? AutocadColor.FromColorIndex(ColorMethod.ByAci, (short)index)
+      : AutocadColor.FromColor(System.Drawing.Color.FromArgb(colorProxy.value));
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadColorUnpacker.cs

@@ -1,7 +1,9 @@
 using Autodesk.AutoCAD.Colors;
 using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
 using Speckle.Connectors.Autocad.HostApp.Extensions;
 using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Sdk;
 using Speckle.Sdk.Models.Proxies;
 using AutocadColor = Autodesk.AutoCAD.Colors.Color;
 
@@ -10,21 +12,61 @@ namespace Speckle.Connectors.Autocad.HostApp;
 /// <summary>
 /// Expects to be a scoped dependency for a given operation and helps with layer creation and cleanup.
 /// </summary>
-public class AutocadColorManager
+public class AutocadColorUnpacker
 {
-  // POC: Will be addressed to move it into AutocadContext!
-  private Document Doc => Application.DocumentManager.MdiActiveDocument;
+  private readonly ILogger<AutocadColorUnpacker> _logger;
 
-  /// <summary>
-  /// For receive operations
-  /// </summary>
-  public Dictionary<string, AutocadColor> ObjectColorsIdMap { get; } = new();
+  public AutocadColorUnpacker(ILogger<AutocadColorUnpacker> logger)
+  {
+    _logger = logger;
+  }
 
   /// <summary>
   /// For send operations
   /// </summary>
   private Dictionary<string, ColorProxy> ColorProxies { get; } = new();
 
+  /// <summary>
+  /// Iterates through a given set of autocad objects and layers to collect colors.
+  /// </summary>
+  /// <param name="unpackedAutocadRootObjects">atomic root objects, including instance objects</param>
+  /// <param name="layers">layers used by atomic objects</param>
+  /// <returns></returns>
+  public List<ColorProxy> UnpackColors(
+    List<AutocadRootObject> unpackedAutocadRootObjects,
+    List<LayerTableRecord> layers
+  )
+  {
+    // Stage 1: unpack colors from objects
+    foreach (AutocadRootObject rootObj in unpackedAutocadRootObjects)
+    {
+      try
+      {
+        Entity entity = rootObj.Root;
+        ProcessObjectColor(rootObj.ApplicationId, entity.Color);
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        _logger.LogError(ex, "Failed to unpack colors from Autocad Entity");
+      }
+    }
+
+    // Stage 2: make sure we collect layer colors as well
+    foreach (LayerTableRecord layer in layers)
+    {
+      try
+      {
+        ProcessObjectColor(layer.GetSpeckleApplicationId(), layer.Color);
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        _logger.LogError(ex, "Failed to unpack colors from Autocad Layer");
+      }
+    }
+
+    return ColorProxies.Values.ToList();
+  }
+
   /// <summary>
   /// Processes an object's color and adds the object id to a color proxy in <see cref="ColorProxies"/> if object color is set ByAci, ByColor, or ByBlock.
   /// Skips processing ByPen for now, because I don't understand what this means.
@@ -68,7 +110,14 @@ public class AutocadColorManager
     string name = color.ColorNameForDisplay;
     string id = color.GetSpeckleApplicationId();
 
-    ColorProxy colorProxy = new(argb, id, name) { objects = new() };
+    ColorProxy colorProxy =
+      new()
+      {
+        value = argb,
+        applicationId = id,
+        name = name,
+        objects = new()
+      };
 
     // add the color source as well for receiving in other apps
     // POC: in order to support full fidelity color support across autocad and rhino, we need to keep track of the color source property. Not sure if this is the best place to keep track of the source, vs on a ColorSourceProxy or as a property on the atomic object.
@@ -92,77 +141,4 @@ public class AutocadColorManager
 
     return colorProxy;
   }
-
-  /// <summary>
-  /// Iterates through a given set of autocad objects and layers to collect colors.
-  /// </summary>
-  /// <param name="unpackedAutocadRootObjects">atomic root objects, including instance objects</param>
-  /// <param name="layers">layers used by atomic objects</param>
-  /// <returns></returns>
-  public List<ColorProxy> UnpackColors(
-    List<AutocadRootObject> unpackedAutocadRootObjects,
-    List<LayerTableRecord> layers
-  )
-  {
-    // Stage 1: unpack colors from objects
-    foreach (AutocadRootObject rootObj in unpackedAutocadRootObjects)
-    {
-      Entity entity = rootObj.Root;
-      ProcessObjectColor(rootObj.ApplicationId, entity.Color);
-    }
-
-    // Stage 2: make sure we collect layer colors as well
-    foreach (LayerTableRecord layer in layers)
-    {
-      ProcessObjectColor(layer.GetSpeckleApplicationId(), layer.Color);
-    }
-
-    return ColorProxies.Values.ToList();
-  }
-
-  public AutocadColor ConvertColorProxyToColor(ColorProxy colorProxy)
-  {
-    // if source = block, return a default ByBlock color
-    if (colorProxy["source"] is string source && source == "block")
-    {
-      return AutocadColor.FromColorIndex(ColorMethod.ByBlock, 0);
-    }
-
-    return colorProxy["autocadColorIndex"] is long index
-      ? AutocadColor.FromColorIndex(ColorMethod.ByAci, (short)index)
-      : AutocadColor.FromColor(System.Drawing.Color.FromArgb(colorProxy.value));
-  }
-
-  /// <summary>
-  /// Parse Color Proxies and stores in ObjectColorIdMap the relationship between object ids and colors
-  /// </summary>
-  /// <param name="colorProxies"></param>
-  /// <param name="onOperationProgressed"></param>
-  public void ParseColors(List<ColorProxy> colorProxies, Action<string, double?>? onOperationProgressed)
-  {
-    var count = 0;
-    foreach (ColorProxy colorProxy in colorProxies)
-    {
-      onOperationProgressed?.Invoke("Converting colors", (double)++count / colorProxies.Count);
-
-      // skip any colors with source = layer, since object color default source is by layer
-      if (colorProxy["source"] is string source && source == "layer")
-      {
-        continue;
-      }
-
-      foreach (string objectId in colorProxy.objects)
-      {
-        AutocadColor convertedColor = ConvertColorProxyToColor(colorProxy);
-#if NET8_0
-        ObjectColorsIdMap.TryAdd(objectId, convertedColor);
-#else
-        if (!ObjectColorsIdMap.ContainsKey(objectId))
-        {
-          ObjectColorsIdMap.Add(objectId, convertedColor);
-        }
-#endif
-      }
-    }
-  }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadDocumentModelStore.cs

@@ -1,25 +1,26 @@
+using Microsoft.Extensions.Logging;
 using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Models;
-using Speckle.Newtonsoft.Json;
-using Speckle.Sdk.Common;
+using Speckle.Connectors.DUI.Utils;
 
 namespace Speckle.Connectors.Autocad.HostApp;
 
 public class AutocadDocumentStore : DocumentModelStore
 {
-  private readonly string _nullDocumentName = "Null Doc";
+  private const string NULL_DOCUMENT_NAME = "Null Doc";
   private string _previousDocName;
   private readonly AutocadDocumentManager _autocadDocumentManager;
 
   public AutocadDocumentStore(
-    JsonSerializerSettings jsonSerializerSettings,
+    ILogger<DocumentModelStore> logger,
+    IJsonSerializer jsonSerializer,
     AutocadDocumentManager autocadDocumentManager,
     ITopLevelExceptionHandler topLevelExceptionHandler
   )
-    : base(jsonSerializerSettings, true)
+    : base(logger, jsonSerializer)
   {
     _autocadDocumentManager = autocadDocumentManager;
-    _previousDocName = _nullDocumentName;
+    _previousDocName = NULL_DOCUMENT_NAME;
 
     // POC: Will be addressed to move it into AutocadContext!
     if (Application.DocumentManager.MdiActiveDocument != null)
@@ -41,39 +42,38 @@ public class AutocadDocumentStore : DocumentModelStore
 
   private void OnDocChangeInternal(Document? doc)
   {
-    var currentDocName = doc != null ? doc.Name : _nullDocumentName;
+    var currentDocName = doc != null ? doc.Name : NULL_DOCUMENT_NAME;
     if (_previousDocName == currentDocName)
     {
       return;
     }
 
     _previousDocName = currentDocName;
-    ReadFromFile();
+    LoadState();
     OnDocumentChanged();
   }
 
-  public override void ReadFromFile()
+  protected override void LoadState()
   {
-    Models = new();
-
     // POC: Will be addressed to move it into AutocadContext!
     Document? doc = Application.DocumentManager.MdiActiveDocument;
 
     if (doc == null)
     {
+      ClearAndSave();
       return;
     }
 
     string? serializedModelCards = _autocadDocumentManager.ReadModelCards(doc);
     if (serializedModelCards == null)
     {
+      ClearAndSave();
       return;
     }
-
-    Models = Deserialize(serializedModelCards).NotNull();
+    LoadFromString(serializedModelCards);
   }
 
-  public override void WriteToFile()
+  protected override void HostAppSaveState(string modelCardState)
   {
     // POC: Will be addressed to move it into AutocadContext!
     Document doc = Application.DocumentManager.MdiActiveDocument;
@@ -83,7 +83,6 @@ public class AutocadDocumentStore : DocumentModelStore
       return;
     }
 
-    string modelCardsString = Serialize();
-    _autocadDocumentManager.WriteModelCards(doc, modelCardsString);
+    _autocadDocumentManager.WriteModelCards(doc, modelCardState);
   }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadGroupBaker.cs

@@ -0,0 +1,81 @@
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Sdk;
+using Speckle.Sdk.Dependencies;
+using Speckle.Sdk.Models.Proxies;
+
+namespace Speckle.Connectors.Autocad.HostApp;
+
+/// <summary>
+/// This resource expects to be injected "fresh" in each receive operation (scoped lifetime).
+/// Extracts group information from a set of objects into proxies in send operations; also creates groups from a set of proxies in receive operations.
+/// TODO: Oguzhan! Check whats happening on second receive unless purge groups? naming etc..
+/// </summary>
+public class AutocadGroupBaker
+{
+  private readonly ILogger<AutocadGroupBaker> _logger;
+  private readonly AutocadContext _autocadContext;
+
+  public AutocadGroupBaker(AutocadContext autocadContext, ILogger<AutocadGroupBaker> logger)
+  {
+    _autocadContext = autocadContext;
+    _logger = logger;
+  }
+
+  /// <summary>
+  /// Creates groups in the host app from a set of group proxies. Can be called after the bake operation of all atomic objects (including instances) is complete.
+  /// </summary>
+  /// <param name="groupProxies"></param>
+  /// <param name="applicationIdMap"></param>
+  /// <returns></returns>
+  // TODO: Oguzhan! Do not report here too! But this is TBD that we don't know the shape of the report yet.
+  public IReadOnlyCollection<ReceiveConversionResult> CreateGroups(
+    IEnumerable<GroupProxy> groupProxies,
+    Dictionary<string, IReadOnlyCollection<Entity>> applicationIdMap
+  )
+  {
+    HashSet<ReceiveConversionResult> results = new();
+
+    using var groupCreationTransaction =
+      Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
+
+    var groupDictionary = (DBDictionary)
+      groupCreationTransaction.GetObject(
+        Application.DocumentManager.CurrentDocument.Database.GroupDictionaryId,
+        OpenMode.ForWrite
+      );
+
+    foreach (var gp in groupProxies.OrderBy(group => group.objects.Count))
+    {
+      try
+      {
+        var entities = gp.objects.SelectMany(oldObjId => applicationIdMap[oldObjId]);
+        var ids = new ObjectIdCollection();
+
+        foreach (var entity in entities)
+        {
+          ids.Add(entity.ObjectId);
+        }
+
+        var groupName = _autocadContext.RemoveInvalidChars(gp.name);
+        var newGroup = new Group(groupName, true); // NOTE: this constructor sets both the description (as it says) but also the name at the same time
+        newGroup.Append(ids);
+
+        groupDictionary.UpgradeOpen();
+        groupDictionary.SetAt(groupName, newGroup);
+
+        groupCreationTransaction.AddNewlyCreatedDBObject(newGroup, true);
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        results.Add(new ReceiveConversionResult(Status.ERROR, gp, null, null, ex));
+        _logger.LogError(ex, "Failed to bake Autocad Group");
+      }
+    }
+
+    groupCreationTransaction.Commit();
+
+    return results.Freeze();
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadGroupManager.cs

@@ -1,116 +0,0 @@
-using Autodesk.AutoCAD.DatabaseServices;
-using Speckle.Connectors.Autocad.HostApp.Extensions;
-using Speckle.Connectors.Autocad.Operations.Send;
-using Speckle.Connectors.Utils.Conversion;
-using Speckle.Sdk;
-using Speckle.Sdk.Models.Proxies;
-
-namespace Speckle.Connectors.Autocad.HostApp;
-
-/// <summary>
-/// This resource expects to be injected "fresh" in each send/receive operation (scoped lifetime). Extracts group information from a set of objects into proxies in send operations; also creates groups from a set of proxies in receive operations.
-/// </summary>
-public class AutocadGroupManager
-{
-  private readonly AutocadContext _autocadContext;
-
-  public AutocadGroupManager(AutocadContext autocadContext)
-  {
-    _autocadContext = autocadContext;
-  }
-
-  /// <summary>
-  /// Unpacks a selection of atomic objects into their groups
-  /// </summary>
-  /// <param name="autocadObjects"></param>
-  /// <returns></returns>
-  public List<GroupProxy> UnpackGroups(IEnumerable<AutocadRootObject> autocadObjects)
-  {
-    var groupProxies = new Dictionary<string, GroupProxy>();
-
-    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
-
-    foreach (var (dbObject, applicationId) in autocadObjects)
-    {
-      var persistentReactorIds = dbObject.GetPersistentReactorIds();
-      foreach (ObjectId oReactorId in persistentReactorIds)
-      {
-        var obj = transaction.GetObject(oReactorId, OpenMode.ForRead);
-        if (obj is not Group group)
-        {
-          continue;
-        }
-        var groupAppId = group.GetSpeckleApplicationId();
-        if (groupProxies.TryGetValue(groupAppId, out GroupProxy? groupProxy))
-        {
-          groupProxy.objects.Add(applicationId);
-        }
-        else
-        {
-          groupProxies[groupAppId] = new()
-          {
-            applicationId = groupAppId,
-            name = group.Name,
-            objects = [applicationId]
-          };
-        }
-      }
-    }
-
-    return groupProxies.Values.ToList();
-  }
-
-  /// <summary>
-  /// Creates groups in the host app from a set of group proxies. Can be called after the bake operation of all atomic objects (including instances) is complete.
-  /// </summary>
-  /// <param name="groupProxies"></param>
-  /// <param name="applicationIdMap"></param>
-  /// <returns></returns>
-  public List<ReceiveConversionResult> CreateGroups(
-    IEnumerable<GroupProxy> groupProxies,
-    Dictionary<string, List<Entity>> applicationIdMap
-  )
-  {
-    List<ReceiveConversionResult> results = new();
-
-    using var groupCreationTransaction =
-      Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
-
-    var groupDictionary = (DBDictionary)
-      groupCreationTransaction.GetObject(
-        Application.DocumentManager.CurrentDocument.Database.GroupDictionaryId,
-        OpenMode.ForWrite
-      );
-
-    foreach (var gp in groupProxies.OrderBy(group => group.objects.Count))
-    {
-      try
-      {
-        var entities = gp.objects.SelectMany(oldObjId => applicationIdMap[oldObjId]);
-        var ids = new ObjectIdCollection();
-
-        foreach (var entity in entities)
-        {
-          ids.Add(entity.ObjectId);
-        }
-
-        var groupName = _autocadContext.RemoveInvalidChars(gp.name);
-        var newGroup = new Group(groupName, true); // NOTE: this constructor sets both the description (as it says) but also the name at the same time
-        newGroup.Append(ids);
-
-        groupDictionary.UpgradeOpen();
-        groupDictionary.SetAt(groupName, newGroup);
-
-        groupCreationTransaction.AddNewlyCreatedDBObject(newGroup, true);
-      }
-      catch (Exception e) when (!e.IsFatal())
-      {
-        results.Add(new ReceiveConversionResult(Status.ERROR, gp, null, null, e));
-      }
-    }
-
-    groupCreationTransaction.Commit();
-
-    return results;
-  }
-}

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadGroupUnpacker.cs

@@ -0,0 +1,69 @@
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Sdk;
+using Speckle.Sdk.Models.Proxies;
+
+namespace Speckle.Connectors.Autocad.HostApp;
+
+/// <summary>
+/// This resource expects to be injected "fresh" in each send/receive operation (scoped lifetime). Extracts group information from a set of objects into proxies in send operations; also creates groups from a set of proxies in receive operations.
+/// </summary>
+public class AutocadGroupUnpacker
+{
+  private readonly ILogger<AutocadGroupUnpacker> _logger;
+
+  public AutocadGroupUnpacker(ILogger<AutocadGroupUnpacker> logger)
+  {
+    _logger = logger;
+  }
+
+  /// <summary>
+  /// Unpacks a selection of atomic objects into their groups
+  /// </summary>
+  /// <param name="autocadObjects"></param>
+  /// <returns></returns>
+  public List<GroupProxy> UnpackGroups(IEnumerable<AutocadRootObject> autocadObjects)
+  {
+    var groupProxies = new Dictionary<string, GroupProxy>();
+
+    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
+
+    foreach (var (dbObject, applicationId) in autocadObjects)
+    {
+      try
+      {
+        var persistentReactorIds = dbObject.GetPersistentReactorIds();
+        foreach (ObjectId oReactorId in persistentReactorIds)
+        {
+          var obj = transaction.GetObject(oReactorId, OpenMode.ForRead);
+          if (obj is not Group group)
+          {
+            continue;
+          }
+          var groupAppId = group.GetSpeckleApplicationId();
+          if (groupProxies.TryGetValue(groupAppId, out GroupProxy? groupProxy))
+          {
+            groupProxy.objects.Add(applicationId);
+          }
+          else
+          {
+            groupProxies[groupAppId] = new()
+            {
+              applicationId = groupAppId,
+              name = group.Name,
+              objects = [applicationId]
+            };
+          }
+        }
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        _logger.LogError(ex, "Failed on unpacking Autocad group");
+      }
+    }
+
+    return groupProxies.Values.ToList();
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadIdleManager.cs

@@ -3,23 +3,17 @@ using Speckle.InterfaceGenerator;
 
 namespace Speckle.Connectors.Autocad.HostApp;
 
+public partial interface IAutocadIdleManager : IAppIdleManager;
+
 [GenerateAutoInterface]
-public class AutocadIdleManager(IIdleCallManager idleCallManager) : IAutocadIdleManager
+public sealed class AutocadIdleManager(IIdleCallManager idleCallManager)
+  : AppIdleManager(idleCallManager),
+    IAutocadIdleManager
 {
-  /// <summary>
-  /// Subscribe deferred action to AutocadIdle event to run it whenever Autocad become idle.
-  /// </summary>
-  /// <param name="action"> Action to call whenever Autocad become Idle.</param>
-  public void SubscribeToIdle(string id, Action action) =>
-    idleCallManager.SubscribeToIdle(
-      id,
-      action,
-      () =>
-      {
-        Application.Idle += AutocadAppOnIdle;
-      }
-    );
+  private readonly IIdleCallManager _idleCallManager = idleCallManager;
+
+  protected override void AddEvent() => Application.Idle += AutocadAppOnIdle;
 
   private void AutocadAppOnIdle(object? sender, EventArgs e) =>
-    idleCallManager.AppOnIdle(() => Application.Idle -= AutocadAppOnIdle);
+    _idleCallManager.AppOnIdle(() => Application.Idle -= AutocadAppOnIdle);
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadInstanceBaker.cs

@@ -1,13 +1,18 @@
+using System.Diagnostics.CodeAnalysis;
 using Autodesk.AutoCAD.DatabaseServices;
 using Autodesk.AutoCAD.Geometry;
+using Microsoft.Extensions.Logging;
 using Speckle.Connectors.Autocad.HostApp.Extensions;
-using Speckle.Connectors.Autocad.Operations.Send;
-using Speckle.Connectors.Utils.Conversion;
-using Speckle.Connectors.Utils.Instances;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Instances;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Converters.Autocad;
 using Speckle.Converters.Common;
 using Speckle.DoubleNumerics;
 using Speckle.Sdk;
 using Speckle.Sdk.Common;
+using Speckle.Sdk.Common.Exceptions;
+using Speckle.Sdk.Dependencies;
 using Speckle.Sdk.Models;
 using Speckle.Sdk.Models.Collections;
 using Speckle.Sdk.Models.Instances;
@@ -16,158 +21,40 @@ using AutocadColor = Autodesk.AutoCAD.Colors.Color;
 namespace Speckle.Connectors.Autocad.HostApp;
 
 /// <summary>
-///  Expects to be a scoped dependency per send or receive operation.
-/// POC: Split later unpacker and baker.
+/// Expects to be a scoped dependency receive operation.
 /// </summary>
-public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>, IInstanceBaker<List<Entity>>
+public class AutocadInstanceBaker : IInstanceBaker<IReadOnlyCollection<Entity>>
 {
-  private readonly AutocadLayerManager _autocadLayerManager;
-  private readonly AutocadColorManager _autocadColorManager;
-  private readonly AutocadMaterialManager _autocadMaterialManager;
-  private readonly IHostToSpeckleUnitConverter<UnitsValue> _unitsConverter;
+  private readonly AutocadLayerBaker _layerBaker;
+  private readonly IAutocadColorBaker _colorBaker;
+  private readonly IAutocadMaterialBaker _materialBaker;
   private readonly AutocadContext _autocadContext;
+  private readonly ILogger<AutocadInstanceBaker> _logger;
+  private readonly IConverterSettingsStore<AutocadConversionSettings> _converterSettings;
 
-  private readonly IInstanceObjectsManager<AutocadRootObject, List<Entity>> _instanceObjectsManager;
-
-  public AutocadInstanceObjectManager(
-    AutocadLayerManager autocadLayerManager,
-    AutocadColorManager autocadColorManager,
-    AutocadMaterialManager autocadMaterialManager,
-    IHostToSpeckleUnitConverter<UnitsValue> unitsConverter,
+  public AutocadInstanceBaker(
+    AutocadLayerBaker layerBaker,
+    IAutocadColorBaker colorBaker,
+    IAutocadMaterialBaker materialBaker,
     AutocadContext autocadContext,
-    IInstanceObjectsManager<AutocadRootObject, List<Entity>> instanceObjectsManager
+    ILogger<AutocadInstanceBaker> logger,
+    IConverterSettingsStore<AutocadConversionSettings> converterSettings
   )
   {
-    _autocadLayerManager = autocadLayerManager;
-    _autocadColorManager = autocadColorManager;
-    _autocadMaterialManager = autocadMaterialManager;
-    _unitsConverter = unitsConverter;
+    _layerBaker = layerBaker;
+    _colorBaker = colorBaker;
+    _materialBaker = materialBaker;
     _autocadContext = autocadContext;
-    _instanceObjectsManager = instanceObjectsManager;
-  }
-
-  public UnpackResult<AutocadRootObject> UnpackSelection(IEnumerable<AutocadRootObject> objects)
-  {
-    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
-
-    foreach (var obj in objects)
-    {
-      // Note: isDynamicBlock always returns false for a selection of doc objects. Instances of dynamic blocks are represented in the document as blocks that have
-      // a definition reference to the anonymous block table record.
-      if (obj.Root is BlockReference blockReference && !blockReference.IsDynamicBlock)
-      {
-        UnpackInstance(blockReference, 0, transaction);
-      }
-      _instanceObjectsManager.AddAtomicObject(obj.ApplicationId, obj);
-    }
-    return _instanceObjectsManager.GetUnpackResult();
-  }
-
-  private void UnpackInstance(BlockReference instance, int depth, Transaction transaction)
-  {
-    string instanceId = instance.GetSpeckleApplicationId();
-
-    // If this instance has a reference to an anonymous block, it means it's spawned from a dynamic block. Anonymous blocks are
-    // used to represent specific "instances" of dynamic ones.
-    // We do not want to send the full dynamic block definition, but its current "instance", as such here we're making sure we
-    // take up the anon block table reference definition (if it exists). If it's not an instance of a dynamic block, we're
-    // using the normal def reference.
-    ObjectId definitionId = !instance.AnonymousBlockTableRecord.IsNull
-      ? instance.AnonymousBlockTableRecord
-      : instance.BlockTableRecord;
-
-    InstanceProxy instanceProxy =
-      new()
-      {
-        applicationId = instanceId,
-        definitionId = definitionId.ToString(),
-        maxDepth = depth,
-        transform = GetMatrix(instance.BlockTransform.ToArray()),
-        units = _unitsConverter.ConvertOrThrow(Application.DocumentManager.CurrentDocument.Database.Insunits)
-      };
-    _instanceObjectsManager.AddInstanceProxy(instanceId, instanceProxy);
-
-    // For each block instance that has the same definition, we need to keep track of the "maximum depth" at which is found.
-    // This will enable on receive to create them in the correct order (descending by max depth, interleaved definitions and instances).
-    // We need to interleave the creation of definitions and instances, as some definitions may depend on instances.
-    if (
-      !_instanceObjectsManager.TryGetInstanceProxiesFromDefinitionId(
-        definitionId.ToString(),
-        out List<InstanceProxy> instanceProxiesWithSameDefinition
-      )
-    )
-    {
-      instanceProxiesWithSameDefinition = new List<InstanceProxy>();
-      _instanceObjectsManager.AddInstanceProxiesByDefinitionId(
-        definitionId.ToString(),
-        instanceProxiesWithSameDefinition
-      );
-    }
-
-    // We ensure that all previous instance proxies that have the same definition are at this max depth. I kind of have a feeling this can be done more elegantly, but YOLO
-    foreach (var instanceProxyWithSameDefinition in instanceProxiesWithSameDefinition)
-    {
-      if (instanceProxyWithSameDefinition.maxDepth < depth)
-      {
-        instanceProxyWithSameDefinition.maxDepth = depth;
-      }
-    }
-
-    instanceProxiesWithSameDefinition.Add(_instanceObjectsManager.GetInstanceProxy(instanceId));
-
-    if (
-      _instanceObjectsManager.TryGetInstanceDefinitionProxy(definitionId.ToString(), out InstanceDefinitionProxy value)
-    )
-    {
-      int depthDifference = depth - value.maxDepth;
-      if (depthDifference > 0)
-      {
-        // all MaxDepth of children definitions and its instances should be increased with difference of depth
-        _instanceObjectsManager.UpdateChildrenMaxDepth(value, depthDifference);
-      }
-      return;
-    }
-
-    var definition = (BlockTableRecord)transaction.GetObject(definitionId, OpenMode.ForRead);
-    var definitionProxy = new InstanceDefinitionProxy()
-    {
-      applicationId = definitionId.ToString(),
-      objects = new(),
-      maxDepth = depth,
-      name = !instance.AnonymousBlockTableRecord.IsNull ? "Dynamic instance " + definitionId : definition.Name,
-      ["comments"] = definition.Comments
-    };
-
-    // Go through each definition object
-    foreach (ObjectId id in definition)
-    {
-      Entity obj = (Entity)transaction.GetObject(id, OpenMode.ForRead);
-
-      // In the case of dynamic blocks, this prevents sending objects that are not visibile in its current state.
-      if (!obj.Visible)
-      {
-        continue;
-      }
-
-      string appId = obj.GetSpeckleApplicationId();
-      definitionProxy.objects.Add(appId);
-
-      if (obj is BlockReference blockReference)
-      {
-        UnpackInstance(blockReference, depth + 1, transaction);
-      }
-
-      _instanceObjectsManager.AddAtomicObject(appId, new(obj, appId));
-    }
-
-    _instanceObjectsManager.AddDefinitionProxy(definitionId.ToString(), definitionProxy);
+    _logger = logger;
+    _converterSettings = converterSettings;
   }
 
+  [SuppressMessage("Maintainability", "CA1506:Avoid excessive class coupling")]
   public BakeResult BakeInstances(
-    List<(Collection[] collectionPath, IInstanceComponent obj)> instanceComponents,
-    Dictionary<string, List<Entity>> applicationIdMap,
+    ICollection<(Collection[] collectionPath, IInstanceComponent obj)> instanceComponents,
+    Dictionary<string, IReadOnlyCollection<Entity>> applicationIdMap,
     string baseLayerName,
-    Action<string, double?>? onOperationProgressed
+    IProgress<CardProgress> onOperationProgressed
   )
   {
     var sortedInstanceComponents = instanceComponents
@@ -178,21 +65,24 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
     var definitionIdAndApplicationIdMap = new Dictionary<string, ObjectId>();
 
     using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
-    var conversionResults = new List<ReceiveConversionResult>();
-    var createdObjectIds = new List<string>();
-    var consumedObjectIds = new List<string>();
+    var conversionResults = new HashSet<ReceiveConversionResult>();
+    var createdObjectIds = new HashSet<string>();
+    var consumedObjectIds = new HashSet<string>();
     var count = 0;
 
     foreach (var (collectionPath, instanceOrDefinition) in sortedInstanceComponents)
     {
       try
       {
-        onOperationProgressed?.Invoke("Converting blocks", (double)++count / sortedInstanceComponents.Count);
+        onOperationProgressed.Report(new("Converting blocks", (double)++count / sortedInstanceComponents.Count));
+
         if (instanceOrDefinition is InstanceDefinitionProxy { applicationId: not null } definitionProxy)
         {
           // TODO: create definition (block table record)
           var constituentEntities = definitionProxy
-            .objects.Select(id => applicationIdMap.TryGetValue(id, out List<Entity>? value) ? value : null)
+            .objects.Select(id =>
+              applicationIdMap.TryGetValue(id, out IReadOnlyCollection<Entity>? value) ? value : null
+            )
             .Where(x => x is not null)
             .SelectMany(ent => ent!)
             .ToList();
@@ -222,8 +112,8 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
           definitionIdAndApplicationIdMap[definitionProxy.applicationId] = id;
           transaction.AddNewlyCreatedDBObject(record, true);
           var consumedEntitiesHandleValues = constituentEntities.Select(ent => ent.GetSpeckleApplicationId()).ToArray();
-          consumedObjectIds.AddRange(consumedEntitiesHandleValues);
-          createdObjectIds.RemoveAll(newId => consumedEntitiesHandleValues.Contains(newId));
+          consumedObjectIds.UnionWith(consumedEntitiesHandleValues);
+          createdObjectIds.RemoveWhere(newId => consumedEntitiesHandleValues.Contains(newId));
         }
         else if (
           instanceOrDefinition is InstanceProxy instanceProxy
@@ -238,20 +128,14 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
           );
 
           // POC: collectionPath for instances should be an array of size 1, because we are flattening collections on traversal
-          string layerName = _autocadLayerManager.CreateLayerForReceive(collectionPath, baseLayerName);
+          string layerName = _layerBaker.CreateLayerForReceive(collectionPath, baseLayerName);
 
           // get color and material if any
-          string instanceId = instanceProxy.applicationId ?? instanceProxy.id;
-          AutocadColor? objColor = _autocadColorManager.ObjectColorsIdMap.TryGetValue(
-            instanceId,
-            out AutocadColor? color
-          )
+          string instanceId = instanceProxy.applicationId ?? instanceProxy.id.NotNull();
+          AutocadColor? objColor = _colorBaker.ObjectColorsIdMap.TryGetValue(instanceId, out AutocadColor? color)
             ? color
             : null;
-          ObjectId objMaterial = _autocadMaterialManager.ObjectMaterialsIdMap.TryGetValue(
-            instanceId,
-            out ObjectId matId
-          )
+          ObjectId objMaterial = _materialBaker.ObjectMaterialsIdMap.TryGetValue(instanceId, out ObjectId matId)
             ? matId
             : ObjectId.Null;
 
@@ -280,12 +164,13 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
       }
       catch (Exception ex) when (!ex.IsFatal())
       {
+        _logger.LogError(ex, "Failed to create an instance from proxy");
         conversionResults.Add(new(Status.ERROR, instanceOrDefinition as Base ?? new Base(), null, null, ex));
       }
     }
 
     transaction.Commit();
-    return new(createdObjectIds, consumedObjectIds, conversionResults);
+    return new(createdObjectIds.Freeze(), consumedObjectIds.Freeze(), conversionResults.Freeze());
   }
 
   /// <summary>
@@ -346,34 +231,9 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
     transaction.Commit();
   }
 
-  private Matrix4x4 GetMatrix(double[] t)
-  {
-    return new Matrix4x4(
-      t[0],
-      t[1],
-      t[2],
-      t[3],
-      t[4],
-      t[5],
-      t[6],
-      t[7],
-      t[8],
-      t[9],
-      t[10],
-      t[11],
-      t[12],
-      t[13],
-      t[14],
-      t[15]
-    );
-  }
-
   private Matrix3d GetMatrix3d(Matrix4x4 matrix, string units)
   {
-    var sf = Units.GetConversionFactor(
-      units,
-      _unitsConverter.ConvertOrThrow(Application.DocumentManager.CurrentDocument.Database.Insunits)
-    );
+    var sf = Units.GetConversionFactor(units, _converterSettings.Current.SpeckleUnits);
 
     var scaledTransform = new[]
     {
@@ -405,7 +265,7 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
   }
 
   // https://forums.autodesk.com/t5/net/set-blocktransform-values/m-p/6452121#M49479
-  private static double[] MakePerpendicular(Matrix3d matrix)
+  private double[] MakePerpendicular(Matrix3d matrix)
   {
     // Get the basis vectors of the matrix
     Vector3d right = new(matrix[0, 0], matrix[1, 0], matrix[2, 0]);
@@ -414,8 +274,8 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
     Vector3d newForward = right.CrossProduct(up).GetNormal();
     Vector3d newUp = newForward.CrossProduct(right).GetNormal();
 
-    return new[]
-    {
+    return
+    [
       right.X,
       newUp.X,
       newForward.X,
@@ -431,7 +291,7 @@ public class AutocadInstanceObjectManager : IInstanceUnpacker<AutocadRootObject>
       0.0,
       0.0,
       0.0,
-      matrix[3, 3],
-    };
+      matrix[3, 3]
+    ];
   }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadInstanceUnpacker.cs

@@ -0,0 +1,178 @@
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common.Instances;
+using Speckle.Converters.Common;
+using Speckle.DoubleNumerics;
+using Speckle.Sdk;
+using Speckle.Sdk.Models.Instances;
+
+namespace Speckle.Connectors.Autocad.HostApp;
+
+/// <summary>
+/// Expects to be a scoped dependency per send operation.
+/// </summary>
+public class AutocadInstanceUnpacker : IInstanceUnpacker<AutocadRootObject>
+{
+  private readonly IHostToSpeckleUnitConverter<UnitsValue> _unitsConverter;
+  private readonly IInstanceObjectsManager<AutocadRootObject, List<Entity>> _instanceObjectsManager;
+  private readonly ILogger<AutocadInstanceUnpacker> _logger;
+
+  public AutocadInstanceUnpacker(
+    IHostToSpeckleUnitConverter<UnitsValue> unitsConverter,
+    IInstanceObjectsManager<AutocadRootObject, List<Entity>> instanceObjectsManager,
+    ILogger<AutocadInstanceUnpacker> logger
+  )
+  {
+    _unitsConverter = unitsConverter;
+    _instanceObjectsManager = instanceObjectsManager;
+    _logger = logger;
+  }
+
+  public UnpackResult<AutocadRootObject> UnpackSelection(IEnumerable<AutocadRootObject> objects)
+  {
+    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
+
+    foreach (var obj in objects)
+    {
+      // Note: isDynamicBlock always returns false for a selection of doc objects. Instances of dynamic blocks are represented in the document as blocks that have
+      // a definition reference to the anonymous block table record.
+      if (obj.Root is BlockReference blockReference && !blockReference.IsDynamicBlock)
+      {
+        UnpackInstance(blockReference, 0, transaction);
+      }
+      _instanceObjectsManager.AddAtomicObject(obj.ApplicationId, obj);
+    }
+    return _instanceObjectsManager.GetUnpackResult();
+  }
+
+  private void UnpackInstance(BlockReference instance, int depth, Transaction transaction)
+  {
+    try
+    {
+      string instanceId = instance.GetSpeckleApplicationId();
+
+      // If this instance has a reference to an anonymous block, it means it's spawned from a dynamic block. Anonymous blocks are
+      // used to represent specific "instances" of dynamic ones.
+      // We do not want to send the full dynamic block definition, but its current "instance", as such here we're making sure we
+      // take up the anon block table reference definition (if it exists). If it's not an instance of a dynamic block, we're
+      // using the normal def reference.
+      ObjectId definitionId = !instance.AnonymousBlockTableRecord.IsNull
+        ? instance.AnonymousBlockTableRecord
+        : instance.BlockTableRecord;
+
+      InstanceProxy instanceProxy =
+        new()
+        {
+          applicationId = instanceId,
+          definitionId = definitionId.ToString(),
+          maxDepth = depth,
+          transform = GetMatrix(instance.BlockTransform.ToArray()),
+          units = _unitsConverter.ConvertOrThrow(Application.DocumentManager.CurrentDocument.Database.Insunits)
+        };
+      _instanceObjectsManager.AddInstanceProxy(instanceId, instanceProxy);
+
+      // For each block instance that has the same definition, we need to keep track of the "maximum depth" at which is found.
+      // This will enable on receive to create them in the correct order (descending by max depth, interleaved definitions and instances).
+      // We need to interleave the creation of definitions and instances, as some definitions may depend on instances.
+      if (
+        !_instanceObjectsManager.TryGetInstanceProxiesFromDefinitionId(
+          definitionId.ToString(),
+          out List<InstanceProxy>? instanceProxiesWithSameDefinition
+        )
+      )
+      {
+        instanceProxiesWithSameDefinition = new List<InstanceProxy>();
+        _instanceObjectsManager.AddInstanceProxiesByDefinitionId(
+          definitionId.ToString(),
+          instanceProxiesWithSameDefinition
+        );
+      }
+
+      // We ensure that all previous instance proxies that have the same definition are at this max depth. I kind of have a feeling this can be done more elegantly, but YOLO
+      foreach (var instanceProxyWithSameDefinition in instanceProxiesWithSameDefinition)
+      {
+        if (instanceProxyWithSameDefinition.maxDepth < depth)
+        {
+          instanceProxyWithSameDefinition.maxDepth = depth;
+        }
+      }
+
+      instanceProxiesWithSameDefinition.Add(_instanceObjectsManager.GetInstanceProxy(instanceId));
+
+      // Add text attributes from Instances as separate atomic objects:
+      // AttributeReferences found on Instances are just a text, not a part of the Instance
+      // They are not actually references and are not linked to AttributeDefinition (as one would expect),
+      // and already have the correct position (no need for transforms).
+      // We don't want to create a new BlockDefinition for every changed text for now, because AutoCAD API doesn't provide one,
+      // e.g. AnonymousBlockTableRecord is provided for each dynamic blocks with geometry changes, but not for Attribute changes.
+      // Docs on AttributeReference usage (used totally independent of AttributeDefinition): https://help.autodesk.com/view/OARX/2025/ENU/?guid=GUID-BA69D85A-2AED-43C2-B5B7-73022B5F28F8
+      // Case of trying to match AttributeDefinition with AttributeReference via Tag value (which is not unique): https://forums.autodesk.com/t5/net-forum/get-the-value-of-an-attribute-in-c/td-p/9060940
+
+      foreach (ObjectId id in instance.AttributeCollection)
+      {
+        var reference = (AttributeReference)transaction.GetObject(id, OpenMode.ForRead);
+        string refAppId = reference.GetSpeckleApplicationId();
+        _instanceObjectsManager.AddAtomicObject(refAppId, new(reference, refAppId));
+      }
+
+      // rely on already converted Definition
+      if (
+        _instanceObjectsManager.TryGetInstanceDefinitionProxy(
+          definitionId.ToString(),
+          out InstanceDefinitionProxy? value
+        )
+      )
+      {
+        int depthDifference = depth - value.maxDepth;
+        if (depthDifference > 0)
+        {
+          // all MaxDepth of children definitions and its instances should be increased with difference of depth
+          _instanceObjectsManager.UpdateChildrenMaxDepth(value, depthDifference);
+        }
+        return;
+      }
+
+      var definition = (BlockTableRecord)transaction.GetObject(definitionId, OpenMode.ForRead);
+      var definitionProxy = new InstanceDefinitionProxy()
+      {
+        applicationId = definitionId.ToString(),
+        objects = new(),
+        maxDepth = depth,
+        name = !instance.AnonymousBlockTableRecord.IsNull ? "Dynamic instance " + definitionId : definition.Name
+      };
+
+      // Go through each definition object
+      foreach (ObjectId id in definition)
+      {
+        Entity obj = (Entity)transaction.GetObject(id, OpenMode.ForRead);
+
+        // In the case of dynamic blocks, this prevents sending objects that are not visible in its current state.
+        // Also skipping AttributeDefinition because it only contains default text values. We convert AttributeReference above instead, as a separate object.
+        if (!obj.Visible || obj is AttributeDefinition)
+        {
+          continue;
+        }
+        string appId = obj.GetSpeckleApplicationId();
+        definitionProxy.objects.Add(appId);
+
+        if (obj is BlockReference blockReference)
+        {
+          UnpackInstance(blockReference, depth + 1, transaction);
+        }
+
+        _instanceObjectsManager.AddAtomicObject(appId, new(obj, appId));
+      }
+
+      _instanceObjectsManager.AddDefinitionProxy(definitionId.ToString(), definitionProxy);
+    }
+    catch (Exception ex) when (!ex.IsFatal())
+    {
+      _logger.LogError(ex, "Failed unpacking Autocad instance");
+    }
+  }
+
+  private Matrix4x4 GetMatrix(double[] t) =>
+    new(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11], t[12], t[13], t[14], t[15]);
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadLayerBaker.cs

@@ -1,59 +1,31 @@
-using Autodesk.AutoCAD.DatabaseServices;
+using Autodesk.AutoCAD.DatabaseServices;
 using Autodesk.AutoCAD.EditorInput;
 using Autodesk.AutoCAD.LayerManager;
-using Speckle.Connectors.Autocad.HostApp.Extensions;
-using Speckle.Converters.Common;
+using Speckle.Connectors.Common.Operations.Receive;
+using Speckle.Sdk.Common;
 using Speckle.Sdk.Models.Collections;
-using Speckle.Sdk.Models.GraphTraversal;
 using AutocadColor = Autodesk.AutoCAD.Colors.Color;
 
 namespace Speckle.Connectors.Autocad.HostApp;
 
-/// <summary>
-/// Expects to be a scoped dependency for a given operation and helps with layer creation and cleanup.
-/// </summary>
-public class AutocadLayerManager
+public class AutocadLayerBaker : TraversalContextUnpacker
 {
-  private readonly AutocadContext _autocadContext;
-  private readonly AutocadMaterialManager _materialManager;
-  private readonly AutocadColorManager _colorManager;
   private readonly string _layerFilterName = "Speckle";
-  public Dictionary<string, Layer> CollectionCache { get; } = new();
-
-  // POC: Will be addressed to move it into AutocadContext!
+  private readonly AutocadContext _autocadContext;
+  private readonly IAutocadMaterialBaker _materialBaker;
+  private readonly IAutocadColorBaker _colorBaker;
   private Document Doc => Application.DocumentManager.MdiActiveDocument;
   private readonly HashSet<string> _uniqueLayerNames = new();
 
-  public AutocadLayerManager(
+  public AutocadLayerBaker(
     AutocadContext autocadContext,
-    AutocadMaterialManager materialManager,
-    AutocadColorManager colorManager
+    IAutocadMaterialBaker materialBaker,
+    IAutocadColorBaker colorBaker
   )
   {
     _autocadContext = autocadContext;
-    _materialManager = materialManager;
-    _colorManager = colorManager;
-  }
-
-  public Layer GetOrCreateSpeckleLayer(Entity entity, Transaction tr, out LayerTableRecord? layer)
-  {
-    string layerName = entity.Layer;
-    layer = null;
-    if (CollectionCache.TryGetValue(layerName, out Layer? speckleLayer))
-    {
-      return speckleLayer;
-    }
-    if (tr.GetObject(entity.LayerId, OpenMode.ForRead) is LayerTableRecord autocadLayer)
-    {
-      // Layers and geometries can have same application ids.....
-      // We should prevent it for sketchup converter. Because when it happens "objects_to_bake" definition
-      // is changing on the way if it happens.
-      speckleLayer = new Layer(layerName) { applicationId = autocadLayer.GetSpeckleApplicationId() }; // Do not use handle directly, see note in the 'GetSpeckleApplicationId' method
-      CollectionCache[layerName] = speckleLayer;
-      layer = autocadLayer;
-      return speckleLayer;
-    }
-    throw new SpeckleConversionException("Unexpected condition in GetOrCreateSpeckleLayer");
+    _materialBaker = materialBaker;
+    _colorBaker = colorBaker;
   }
 
   /// <summary>
@@ -73,7 +45,7 @@ public class AutocadLayerManager
     // get the color and material if any, of the leaf collection with a color
     AutocadColor? layerColor = null;
     ObjectId layerMaterial = ObjectId.Null;
-    if (_colorManager.ObjectColorsIdMap.Count > 0 || _materialManager.ObjectMaterialsIdMap.Count > 0)
+    if (_colorBaker.ObjectColorsIdMap.Count > 0 || _materialBaker.ObjectMaterialsIdMap.Count > 0)
     {
       bool foundColor = false;
       bool foundMaterial = false;
@@ -81,16 +53,16 @@ public class AutocadLayerManager
       // Goes up the tree to find any potential parent layer that has a material/color
       for (int j = layerPath.Length - 1; j >= 0; j--)
       {
-        string layerId = layerPath[j].applicationId ?? layerPath[j].id;
+        string layerId = layerPath[j].applicationId ?? layerPath[j].id.NotNull();
 
         if (!foundColor)
         {
-          foundColor = _colorManager.ObjectColorsIdMap.TryGetValue(layerId, out layerColor);
+          foundColor = _colorBaker.ObjectColorsIdMap.TryGetValue(layerId, out layerColor);
         }
 
         if (!foundMaterial)
         {
-          foundMaterial = _materialManager.ObjectMaterialsIdMap.TryGetValue(layerId, out layerMaterial);
+          foundMaterial = _materialBaker.ObjectMaterialsIdMap.TryGetValue(layerId, out layerMaterial);
         }
 
         if (foundColor && foundMaterial)
@@ -227,22 +199,4 @@ public class AutocadLayerManager
     groupFilter.NestedFilters.Add(layerFilter);
     Doc.Database.LayerFilters = layerFilterTree;
   }
-
-  /// <summary>
-  /// Gets a valid collection representing a layer for a given context.
-  /// </summary>
-  /// <param name="context"></param>
-  /// <returns>A new Speckle Layer object</returns>
-  public Collection[] GetLayerPath(TraversalContext context)
-  {
-    Collection[] collectionBasedPath = context.GetAscendantOfType<Collection>().Reverse().ToArray();
-
-    if (collectionBasedPath.Length == 0)
-    {
-      string[] path = context.GetPropertyPath().Reverse().ToArray();
-      collectionBasedPath = [new Collection(string.Join("-", path))];
-    }
-
-    return collectionBasedPath;
-  }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadLayerUnpacker.cs

@@ -0,0 +1,30 @@
+using Autodesk.AutoCAD.DatabaseServices;
+using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Sdk;
+using Speckle.Sdk.Models.Collections;
+
+namespace Speckle.Connectors.Autocad.HostApp;
+
+public class AutocadLayerUnpacker
+{
+  private readonly Dictionary<string, Layer> _layerCollectionCache = new();
+
+  public Layer GetOrCreateSpeckleLayer(Entity entity, Transaction tr, out LayerTableRecord? layer)
+  {
+    string layerName = entity.Layer;
+    layer = null;
+    if (_layerCollectionCache.TryGetValue(layerName, out Layer? speckleLayer))
+    {
+      return speckleLayer;
+    }
+    if (tr.GetObject(entity.LayerId, OpenMode.ForRead) is LayerTableRecord autocadLayer)
+    {
+      speckleLayer = new Layer(layerName) { applicationId = autocadLayer.GetSpeckleApplicationId() }; // Do not use handle directly, see note in the 'GetSpeckleApplicationId' method
+      _layerCollectionCache[layerName] = speckleLayer;
+      layer = autocadLayer;
+      return speckleLayer;
+    }
+
+    throw new SpeckleException("Unexpected condition in GetOrCreateSpeckleLayer");
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadMaterialBaker.cs

@@ -1,11 +1,14 @@
 using Autodesk.AutoCAD.Colors;
 using Autodesk.AutoCAD.DatabaseServices;
 using Autodesk.AutoCAD.GraphicsInterface;
-using Speckle.Connectors.Autocad.HostApp.Extensions;
-using Speckle.Connectors.Autocad.Operations.Send;
-using Speckle.Connectors.Utils.Conversion;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Operations;
+using Speckle.InterfaceGenerator;
 using Speckle.Objects.Other;
 using Speckle.Sdk;
+using Speckle.Sdk.Common;
+using Speckle.Sdk.Models;
 using Material = Autodesk.AutoCAD.DatabaseServices.Material;
 using RenderMaterial = Speckle.Objects.Other.RenderMaterial;
 
@@ -14,104 +17,132 @@ namespace Speckle.Connectors.Autocad.HostApp;
 /// <summary>
 /// Expects to be a scoped dependency for a given operation and helps with layer creation and cleanup.
 /// </summary>
-public class AutocadMaterialManager
+[GenerateAutoInterface]
+public class AutocadMaterialBaker : IAutocadMaterialBaker
 {
+  private readonly ILogger<AutocadMaterialBaker> _logger;
   private readonly AutocadContext _autocadContext;
-
-  // POC: Will be addressed to move it into AutocadContext!
   private Document Doc => Application.DocumentManager.MdiActiveDocument;
-
   public Dictionary<string, ObjectId> ObjectMaterialsIdMap { get; } = new();
 
-  public AutocadMaterialManager(AutocadContext autocadContext)
+  public AutocadMaterialBaker(AutocadContext autocadContext, ILogger<AutocadMaterialBaker> logger)
   {
     _autocadContext = autocadContext;
-  }
-
-  private RenderMaterialProxy ConvertMaterialToRenderMaterialProxy(Material material, string id)
-  {
-    EntityColor diffuseColor = material.Diffuse.Color.Color;
-    System.Drawing.Color diffuse = System.Drawing.Color.FromArgb(
-      diffuseColor.Red,
-      diffuseColor.Green,
-      diffuseColor.Blue
-    );
-
-    string name = material.Name;
-    double opacity = material.Opacity.Percentage;
-
-    RenderMaterial renderMaterial = new(opacity: opacity, diffuse: diffuse) { name = name, applicationId = id };
-
-    // Add additional properties
-    renderMaterial["ior"] = material.Refraction.Index;
-    renderMaterial["reflectivity"] = material.Reflectivity;
-
-    return new(renderMaterial, new()) { applicationId = id };
+    _logger = logger;
   }
 
   /// <summary>
-  /// Iterates through a given set of autocad objects and collects their materials. Note: expects objects to be "atomic", and extracted out of their instances already.
+  /// Try to get material id from original object or its parent (if provided) as fallback).
+  /// It covers one-to-many problem, i.e.
+  ///  - rhino: Brep (material id is extracted into render material proxy objects) -> [Mesh, Mesh, ...] (child objects application ids ARE NOT EXIST in render material proxy objects)
+  ///  - revit : RevitElement (material IS NOT extracted into render material proxy objects) -> [Mesh, Mesh...] (child objects application ids EXIST in render material proxy objects)
   /// </summary>
-  /// <param name="unpackedAutocadObjects"></param>
-  /// <param name="layers"></param>
-  /// <returns></returns>
-  public List<RenderMaterialProxy> UnpackMaterials(
-    List<AutocadRootObject> unpackedAutocadObjects,
-    List<LayerTableRecord> layers
+  /// <remarks>
+  /// This is a question that we need to answer where to handle these cases.
+  /// We alsa do reverse search for layer render materials on Revit Receive, and mutating the proxy list accordingly.
+  /// These cases are increasing, and need some ideation around it before going more messy.
+  /// </remarks>
+  public bool TryGetMaterialId(Base originalObject, Base? parentObject, out ObjectId materialId)
+  {
+    materialId = ObjectId.Null;
+    var originalObjectId = originalObject.applicationId ?? originalObject.id.NotNull();
+    if (ObjectMaterialsIdMap.TryGetValue(originalObjectId, out ObjectId originalObjectMaterialId))
+    {
+      materialId = originalObjectMaterialId;
+      return true;
+    }
+
+    if (parentObject is null)
+    {
+      return false;
+    }
+
+    var subObjectId = parentObject.applicationId ?? parentObject.id.NotNull();
+    if (ObjectMaterialsIdMap.TryGetValue(subObjectId, out ObjectId subObjectMaterialId))
+    {
+      materialId = subObjectMaterialId;
+      return true;
+    }
+
+    return false;
+  }
+
+  /// <summary>
+  /// Removes all materials with a name starting with <paramref name="namePrefix"/> from the active document
+  /// </summary>
+  /// <param name="namePrefix"></param>
+  public void PurgeMaterials(string namePrefix)
+  {
+    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
+    if (transaction.GetObject(Doc.Database.MaterialDictionaryId, OpenMode.ForWrite) is DBDictionary materialDict)
+    {
+      foreach (var entry in materialDict)
+      {
+        try
+        {
+          if (entry.Key.Contains(namePrefix))
+          {
+            materialDict.Remove(entry.Value);
+          }
+        }
+        catch (Exception ex) when (!ex.IsFatal())
+        {
+          _logger.LogError(ex, "Failed to purge a material from the document");
+        }
+      }
+    }
+    transaction.Commit();
+  }
+
+  public void ParseAndBakeRenderMaterials(
+    IReadOnlyCollection<RenderMaterialProxy> materialProxies,
+    string baseLayerPrefix,
+    IProgress<CardProgress> onOperationProgressed
   )
   {
-    Dictionary<string, RenderMaterialProxy> materialProxies = new();
     using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
+    var materialDict = transaction.GetObject(Doc.Database.MaterialDictionaryId, OpenMode.ForWrite) as DBDictionary;
 
-    // Stage 1: unpack materials from objects
-    foreach (AutocadRootObject rootObj in unpackedAutocadObjects)
+    if (materialDict == null)
     {
-      Entity entity = rootObj.Root;
+      // POC: we should report failed conversion here if material dict is not accessible, but it is not linked to a Base source
+      transaction.Commit();
+      return;
+    }
 
-      // skip inherited materials
-      if (entity.Material == "ByLayer" || entity.Material == "ByBlock")
+    var count = 0;
+    foreach (RenderMaterialProxy materialProxy in materialProxies)
+    {
+      onOperationProgressed.Report(new("Converting render materials", (double)++count / materialProxies.Count));
+
+      // bake render material
+      RenderMaterial renderMaterial = materialProxy.value;
+      string renderMaterialId = renderMaterial.applicationId ?? renderMaterial.id.NotNull();
+      ObjectId materialId = ObjectId.Null;
+
+      if (!ObjectMaterialsIdMap.TryGetValue(renderMaterialId, out materialId))
+      {
+        (materialId, ReceiveConversionResult result) = BakeMaterial(
+          renderMaterial,
+          baseLayerPrefix,
+          materialDict,
+          transaction
+        );
+      }
+
+      if (materialId == ObjectId.Null)
       {
         continue;
       }
 
-      if (transaction.GetObject(entity.MaterialId, OpenMode.ForRead) is Material material)
+      // parse render material object ids
+      foreach (string objectId in materialProxy.objects)
       {
-        string materialId = material.GetSpeckleApplicationId();
-        if (materialProxies.TryGetValue(materialId, out RenderMaterialProxy? value))
-        {
-          value.objects.Add(rootObj.ApplicationId);
-        }
-        else
-        {
-          RenderMaterialProxy materialProxy = ConvertMaterialToRenderMaterialProxy(material, materialId);
-          materialProxy.objects.Add(rootObj.ApplicationId);
-          materialProxies[materialId] = materialProxy;
-        }
-      }
-    }
-
-    // Stage 2: make sure we collect layer colors as well
-    foreach (LayerTableRecord layer in layers)
-    {
-      if (transaction.GetObject(layer.MaterialId, OpenMode.ForRead) is Material material)
-      {
-        string materialId = material.GetSpeckleApplicationId();
-        string layerId = layer.GetSpeckleApplicationId(); // Do not use handle directly, see note in the 'GetSpeckleApplicationId' method
-        if (materialProxies.TryGetValue(materialId, out RenderMaterialProxy? value))
-        {
-          value.objects.Add(layerId);
-        }
-        else
-        {
-          RenderMaterialProxy materialProxy = ConvertMaterialToRenderMaterialProxy(material, materialId);
-          materialProxy.objects.Add(layerId);
-          materialProxies[materialId] = materialProxy;
-        }
+        ObjectMaterialsIdMap[objectId] = materialId;
       }
     }
 
     transaction.Commit();
-    return materialProxies.Values.ToList();
   }
 
   private (ObjectId, ReceiveConversionResult) BakeMaterial(
@@ -127,7 +158,7 @@ public class AutocadMaterialManager
     {
       // POC: Currently we're relying on the render material name for identification if it's coming from speckle and from which model; could we do something else?
       // POC: we should assume render materials all have application ids?
-      string renderMaterialId = renderMaterial.applicationId ?? renderMaterial.id;
+      string renderMaterialId = renderMaterial.applicationId ?? renderMaterial.id.NotNull();
       string matName = _autocadContext.RemoveInvalidChars(
         $"{renderMaterial.name}-({renderMaterialId})-{baseLayerPrefix}"
       );
@@ -165,103 +196,8 @@ public class AutocadMaterialManager
     }
     catch (Exception ex) when (!ex.IsFatal())
     {
+      _logger.LogError(ex, "Failed to add a material to the document");
       return (materialId, new(Status.ERROR, renderMaterial, null, null, ex));
     }
   }
-
-  /// <summary>
-  /// Removes all materials with a name starting with <paramref name="namePrefix"/> from the active document
-  /// </summary>
-  /// <param name="namePrefix"></param>
-  public void PurgeMaterials(string namePrefix)
-  {
-    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
-    if (transaction.GetObject(Doc.Database.MaterialDictionaryId, OpenMode.ForWrite) is DBDictionary materialDict)
-    {
-      foreach (var entry in materialDict)
-      {
-        if (entry.Key.Contains(namePrefix))
-        {
-          materialDict.Remove(entry.Value);
-        }
-      }
-    }
-    transaction.Commit();
-  }
-
-  public List<ReceiveConversionResult> ParseAndBakeRenderMaterials(
-    List<RenderMaterialProxy> materialProxies,
-    string baseLayerPrefix,
-    Action<string, double?>? onOperationProgressed
-  )
-  {
-    List<ReceiveConversionResult> results = new();
-    Dictionary<string, string> objectRenderMaterialsIdMap = new();
-
-    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
-    var materialDict = transaction.GetObject(Doc.Database.MaterialDictionaryId, OpenMode.ForWrite) as DBDictionary;
-
-    if (materialDict == null)
-    {
-      // POC: we should report failed conversion here if material dict is not accessible, but it is not linked to a Base source
-      transaction.Commit();
-      return results;
-    }
-
-    var count = 0;
-    foreach (RenderMaterialProxy materialProxy in materialProxies)
-    {
-      onOperationProgressed?.Invoke("Converting render materials", (double)++count / materialProxies.Count);
-
-      // bake render material
-      RenderMaterial renderMaterial = materialProxy.value;
-      string renderMaterialId = renderMaterial.applicationId ?? renderMaterial.id;
-      ObjectId materialId = ObjectId.Null;
-
-      if (!ObjectMaterialsIdMap.TryGetValue(renderMaterialId, out materialId))
-      {
-        (materialId, ReceiveConversionResult result) = BakeMaterial(
-          renderMaterial,
-          baseLayerPrefix,
-          materialDict,
-          transaction
-        );
-
-        results.Add(result);
-      }
-      else
-      {
-        // POC: this shouldn't happen, but will if there are render materials with the same applicationID
-        results.Add(
-          new(
-            Status.ERROR,
-            renderMaterial,
-            exception: new ArgumentException("Another render material of the same id has already been created.")
-          )
-        );
-      }
-
-      if (materialId == ObjectId.Null)
-      {
-        results.Add(
-          new(
-            Status.ERROR,
-            renderMaterial,
-            exception: new InvalidOperationException("Render material failed to be added to document.")
-          )
-        );
-
-        continue;
-      }
-
-      // parse render material object ids
-      foreach (string objectId in materialProxy.objects)
-      {
-        ObjectMaterialsIdMap[objectId] = materialId;
-      }
-    }
-
-    transaction.Commit();
-    return results;
-  }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadMaterialUnpacker.cs

@@ -0,0 +1,133 @@
+using Autodesk.AutoCAD.Colors;
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.HostApp.Extensions;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Objects.Other;
+using Speckle.Sdk;
+using Material = Autodesk.AutoCAD.DatabaseServices.Material;
+using RenderMaterial = Speckle.Objects.Other.RenderMaterial;
+
+namespace Speckle.Connectors.Autocad.HostApp;
+
+/// <summary>
+/// Expects to be a scoped dependency for a given operation and helps with layer creation and cleanup.
+/// </summary>
+public class AutocadMaterialUnpacker
+{
+  private readonly ILogger<AutocadMaterialUnpacker> _logger;
+
+  public AutocadMaterialUnpacker(ILogger<AutocadMaterialUnpacker> logger)
+  {
+    _logger = logger;
+  }
+
+  /// <summary>
+  /// Iterates through a given set of autocad objects and collects their materials. Note: expects objects to be "atomic", and extracted out of their instances already.
+  /// </summary>
+  /// <param name="unpackedAutocadObjects"></param>
+  /// <param name="layers"></param>
+  /// <returns></returns>
+  public List<RenderMaterialProxy> UnpackMaterials(
+    List<AutocadRootObject> unpackedAutocadObjects,
+    List<LayerTableRecord> layers
+  )
+  {
+    Dictionary<string, RenderMaterialProxy> materialProxies = new();
+    using var transaction = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
+
+    // Stage 1: unpack materials from objects
+    foreach (AutocadRootObject rootObj in unpackedAutocadObjects)
+    {
+      try
+      {
+        Entity entity = rootObj.Root;
+
+        // skip inherited materials
+        if (entity.Material == "ByLayer" || entity.Material == "ByBlock")
+        {
+          continue;
+        }
+
+        if (transaction.GetObject(entity.MaterialId, OpenMode.ForRead) is Material material)
+        {
+          string materialId = material.GetSpeckleApplicationId();
+          if (materialProxies.TryGetValue(materialId, out RenderMaterialProxy? value))
+          {
+            value.objects.Add(rootObj.ApplicationId);
+          }
+          else
+          {
+            RenderMaterialProxy materialProxy = ConvertMaterialToRenderMaterialProxy(material, materialId);
+            materialProxy.objects.Add(rootObj.ApplicationId);
+            materialProxies[materialId] = materialProxy;
+          }
+        }
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        _logger.LogError(ex, "Failed to unpack render material from Autocad Entity");
+      }
+    }
+
+    // Stage 2: make sure we collect layer materials as well
+    foreach (LayerTableRecord layer in layers)
+    {
+      try
+      {
+        if (transaction.GetObject(layer.MaterialId, OpenMode.ForRead) is Material material)
+        {
+          string materialId = material.GetSpeckleApplicationId();
+          string layerId = layer.GetSpeckleApplicationId(); // Do not use handle directly, see note in the 'GetSpeckleApplicationId' method
+          if (materialProxies.TryGetValue(materialId, out RenderMaterialProxy? value))
+          {
+            value.objects.Add(layerId);
+          }
+          else
+          {
+            RenderMaterialProxy materialProxy = ConvertMaterialToRenderMaterialProxy(material, materialId);
+            materialProxy.objects.Add(layerId);
+            materialProxies[materialId] = materialProxy;
+          }
+        }
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        _logger.LogError(ex, "Failed to unpack render material from Autocad Layer");
+      }
+    }
+
+    transaction.Commit();
+    return materialProxies.Values.ToList();
+  }
+
+  private RenderMaterialProxy ConvertMaterialToRenderMaterialProxy(Material material, string id)
+  {
+    EntityColor diffuseColor = material.Diffuse.Color.Color;
+    System.Drawing.Color diffuse = System.Drawing.Color.FromArgb(
+      diffuseColor.Red,
+      diffuseColor.Green,
+      diffuseColor.Blue
+    );
+
+    RenderMaterial renderMaterial =
+      new()
+      {
+        name = material.Name,
+        opacity = material.Opacity.Percentage,
+        diffuse = diffuse.ToArgb(),
+        applicationId = id
+      };
+
+    // Add additional properties
+    renderMaterial["ior"] = material.Refraction.Index;
+    renderMaterial["reflectivity"] = material.Reflectivity;
+
+    return new RenderMaterialProxy()
+    {
+      value = renderMaterial,
+      objects = new(),
+      applicationId = id
+    };
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/Operations/Receive/AutocadHostObjectBuilder.cs

@@ -1,17 +1,18 @@
 using Autodesk.AutoCAD.DatabaseServices;
 using Speckle.Connectors.Autocad.HostApp;
 using Speckle.Connectors.Autocad.HostApp.Extensions;
-using Speckle.Connectors.Utils.Builders;
-using Speckle.Connectors.Utils.Conversion;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Extensions;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Connectors.Common.Operations.Receive;
 using Speckle.Converters.Common;
-using Speckle.Objects.Other;
 using Speckle.Sdk;
+using Speckle.Sdk.Common;
+using Speckle.Sdk.Dependencies;
 using Speckle.Sdk.Models;
 using Speckle.Sdk.Models.Collections;
-using Speckle.Sdk.Models.GraphTraversal;
 using Speckle.Sdk.Models.Instances;
-using Speckle.Sdk.Models.Proxies;
 using AutocadColor = Autodesk.AutoCAD.Colors.Color;
 
 namespace Speckle.Connectors.Autocad.Operations.Receive;
@@ -19,222 +20,176 @@ namespace Speckle.Connectors.Autocad.Operations.Receive;
 /// <summary>
 /// <para>Expects to be a scoped dependency per receive operation.</para>
 /// </summary>
-public class AutocadHostObjectBuilder : IHostObjectBuilder
+public class AutocadHostObjectBuilder(
+  IRootToHostConverter converter,
+  AutocadLayerBaker layerBaker,
+  AutocadGroupBaker groupBaker,
+  AutocadInstanceBaker instanceBaker,
+  IAutocadMaterialBaker materialBaker,
+  IAutocadColorBaker colorBaker,
+  AutocadContext autocadContext,
+  RootObjectUnpacker rootObjectUnpacker
+) : IHostObjectBuilder
 {
-  private readonly AutocadLayerManager _autocadLayerManager;
-  private readonly IRootToHostConverter _converter;
-  private readonly GraphTraversal _traversalFunction;
-  private readonly ISyncToThread _syncToThread;
-  private readonly AutocadGroupManager _groupManager;
-  private readonly AutocadMaterialManager _materialManager;
-  private readonly AutocadColorManager _colorManager;
-  private readonly AutocadInstanceObjectManager _instanceObjectsManager;
-  private readonly AutocadContext _autocadContext;
-
-  public AutocadHostObjectBuilder(
-    IRootToHostConverter converter,
-    GraphTraversal traversalFunction,
-    AutocadLayerManager autocadLayerManager,
-    AutocadGroupManager groupManager,
-    AutocadInstanceObjectManager instanceObjectsManager,
-    AutocadMaterialManager materialManager,
-    AutocadColorManager colorManager,
-    ISyncToThread syncToThread,
-    AutocadContext autocadContext
-  )
-  {
-    _converter = converter;
-    _traversalFunction = traversalFunction;
-    _autocadLayerManager = autocadLayerManager;
-    _groupManager = groupManager;
-    _instanceObjectsManager = instanceObjectsManager;
-    _materialManager = materialManager;
-    _colorManager = colorManager;
-    _syncToThread = syncToThread;
-    _autocadContext = autocadContext;
-  }
-
   public Task<HostObjectBuilderResult> Build(
     Base rootObject,
     string projectName,
     string modelName,
-    Action<string, double?>? onOperationProgressed,
-    CancellationToken _
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
   )
   {
-    return _syncToThread.RunOnThread(() =>
+    // Prompt the UI conversion started. Progress bar will swoosh.
+    onOperationProgressed.Report(new("Converting", null));
+
+    // Layer filter for received commit with project and model name
+    layerBaker.CreateLayerFilter(projectName, modelName);
+
+    // 0 - Clean then Rock n Roll!
+    string baseLayerPrefix = autocadContext.RemoveInvalidChars($"SPK-{projectName}-{modelName}-");
+    PreReceiveDeepClean(baseLayerPrefix);
+
+    // 1 - Unpack objects and proxies from root commit object
+    var unpackedRoot = rootObjectUnpacker.Unpack(rootObject);
+
+    // 2 - Split atomic objects and instance components with their path
+    var (atomicObjects, instanceComponents) = rootObjectUnpacker.SplitAtomicObjectsAndInstances(
+      unpackedRoot.ObjectsToConvert
+    );
+    var atomicObjectsWithPath = layerBaker.GetAtomicObjectsWithPath(atomicObjects);
+    var instanceComponentsWithPath = layerBaker.GetInstanceComponentsWithPath(instanceComponents);
+
+    // POC: these are not captured by traversal, so we need to re-add them here
+    if (unpackedRoot.DefinitionProxies != null && unpackedRoot.DefinitionProxies.Count > 0)
     {
-      // Prompt the UI conversion started. Progress bar will swoosh.
-      onOperationProgressed?.Invoke("Converting", null);
+      var transformed = unpackedRoot.DefinitionProxies.Select(proxy =>
+        (Array.Empty<Collection>(), proxy as IInstanceComponent)
+      );
+      instanceComponentsWithPath.AddRange(transformed);
+    }
 
-      // Layer filter for received commit with project and model name
-      _autocadLayerManager.CreateLayerFilter(projectName, modelName);
-
-      string baseLayerPrefix = _autocadContext.RemoveInvalidChars($"SPK-{projectName}-{modelName}-");
-
-      PreReceiveDeepClean(baseLayerPrefix);
-
-      List<ReceiveConversionResult> results = new();
-      List<string> bakedObjectIds = new();
-
-      var objectGraph = _traversalFunction.Traverse(rootObject).Where(obj => obj.Current is not Collection);
-
-      // POC: these are not captured by traversal, so we need to re-add them here
-      var instanceDefinitionProxies = (rootObject["instanceDefinitionProxies"] as List<object>)
-        ?.Cast<InstanceDefinitionProxy>()
-        .ToList();
-
-      var instanceComponents = new List<(Collection[] path, IInstanceComponent obj)>();
-      // POC: these are not captured by traversal, so we need to re-add them here
-      if (instanceDefinitionProxies != null && instanceDefinitionProxies.Count > 0)
-      {
-        var transformed = instanceDefinitionProxies.Select(proxy =>
-          (Array.Empty<Collection>(), proxy as IInstanceComponent)
-        );
-        instanceComponents.AddRange(transformed);
-      }
-
-      // POC: get colors
-      List<ColorProxy>? colors = (rootObject["colorProxies"] as List<object>)?.Cast<ColorProxy>().ToList();
-      if (colors != null)
-      {
-        _colorManager.ParseColors(colors, onOperationProgressed);
-      }
-
-      // POC: get render materials
-      List<RenderMaterialProxy>? renderMaterials = (rootObject["renderMaterialProxies"] as List<object>)
-        ?.Cast<RenderMaterialProxy>()
-        .ToList();
-
-      if (renderMaterials != null)
-      {
-        List<ReceiveConversionResult> materialResults = _materialManager.ParseAndBakeRenderMaterials(
-          renderMaterials,
-          baseLayerPrefix,
-          onOperationProgressed
-        );
-
-        results.AddRange(materialResults);
-      }
-
-      // POC: get group proxies
-      var groupProxies = (rootObject["groupProxies"] as List<object>)?.Cast<GroupProxy>().ToList();
-
-      var atomicObjects = new List<(Collection[] layerPath, Base obj)>();
-
-      foreach (TraversalContext tc in objectGraph)
-      {
-        // create new speckle layer from layer path
-        Collection[] layerPath = _autocadLayerManager.GetLayerPath(tc);
-        switch (tc.Current)
-        {
-          case IInstanceComponent instanceComponent:
-            instanceComponents.Add((layerPath, instanceComponent));
-            break;
-          case GroupProxy:
-            continue;
-          default:
-            atomicObjects.Add((layerPath, tc.Current));
-            break;
-        }
-      }
-
-      // Stage 1: Convert atomic objects
-      Dictionary<string, List<Entity>> applicationIdMap = new();
-      var count = 0;
-      foreach (var (layerPath, atomicObject) in atomicObjects)
-      {
-        string objectId = atomicObject.applicationId ?? atomicObject.id;
-        onOperationProgressed?.Invoke("Converting objects", (double)++count / atomicObjects.Count);
-        try
-        {
-          List<Entity> convertedObjects = ConvertObject(atomicObject, layerPath, baseLayerPrefix).ToList();
-
-          applicationIdMap[objectId] = convertedObjects;
-
-          results.AddRange(
-            convertedObjects.Select(e => new ReceiveConversionResult(
-              Status.SUCCESS,
-              atomicObject,
-              e.GetSpeckleApplicationId(),
-              e.GetType().ToString()
-            ))
-          );
-
-          bakedObjectIds.AddRange(convertedObjects.Select(e => e.GetSpeckleApplicationId()));
-        }
-        catch (Exception ex) when (!ex.IsFatal())
-        {
-          results.Add(new(Status.ERROR, atomicObject, null, null, ex));
-        }
-      }
-
-      // Stage 2: Convert instances
-      var (createdInstanceIds, consumedObjectIds, instanceConversionResults) = _instanceObjectsManager.BakeInstances(
-        instanceComponents,
-        applicationIdMap,
+    // 3 - Bake materials and colors, as they are used later down the line by layers and objects
+    if (unpackedRoot.RenderMaterialProxies != null)
+    {
+      materialBaker.ParseAndBakeRenderMaterials(
+        unpackedRoot.RenderMaterialProxies,
         baseLayerPrefix,
         onOperationProgressed
       );
+    }
 
-      bakedObjectIds.RemoveAll(id => consumedObjectIds.Contains(id));
-      bakedObjectIds.AddRange(createdInstanceIds);
-      results.RemoveAll(result => result.ResultId != null && consumedObjectIds.Contains(result.ResultId));
-      results.AddRange(instanceConversionResults);
+    if (unpackedRoot.ColorProxies != null)
+    {
+      colorBaker.ParseColors(unpackedRoot.ColorProxies, onOperationProgressed);
+    }
 
-      // Stage 3: Create group
-      if (groupProxies != null)
+    // 4 - Convert atomic objects
+    HashSet<ReceiveConversionResult> results = new();
+    HashSet<string> bakedObjectIds = new();
+    Dictionary<string, IReadOnlyCollection<Entity>> applicationIdMap = new();
+    var count = 0;
+    foreach (var (layerPath, atomicObject) in atomicObjectsWithPath)
+    {
+      string objectId = atomicObject.applicationId ?? atomicObject.id.NotNull();
+      onOperationProgressed.Report(new("Converting objects", (double)++count / atomicObjects.Count));
+      cancellationToken.ThrowIfCancellationRequested();
+      try
       {
-        List<ReceiveConversionResult> groupResults = _groupManager.CreateGroups(groupProxies, applicationIdMap);
-        results.AddRange(groupResults);
-      }
+        IReadOnlyCollection<Entity> convertedObjects = ConvertObject(atomicObject, layerPath, baseLayerPrefix);
 
-      return new HostObjectBuilderResult(bakedObjectIds, results);
-    });
+        applicationIdMap[objectId] = convertedObjects;
+
+        results.UnionWith(
+          convertedObjects.Select(e => new ReceiveConversionResult(
+            Status.SUCCESS,
+            atomicObject,
+            e.GetSpeckleApplicationId(),
+            e.GetType().ToString()
+          ))
+        );
+
+        bakedObjectIds.UnionWith(convertedObjects.Select(e => e.GetSpeckleApplicationId()));
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        results.Add(new(Status.ERROR, atomicObject, null, null, ex));
+      }
+    }
+
+    // 5 - Convert instances
+    var (createdInstanceIds, consumedObjectIds, instanceConversionResults) = instanceBaker.BakeInstances(
+      instanceComponentsWithPath,
+      applicationIdMap,
+      baseLayerPrefix,
+      onOperationProgressed
+    );
+
+    bakedObjectIds.RemoveWhere(id => consumedObjectIds.Contains(id));
+    bakedObjectIds.UnionWith(createdInstanceIds);
+    results.RemoveWhere(result => result.ResultId != null && consumedObjectIds.Contains(result.ResultId));
+    results.UnionWith(instanceConversionResults);
+
+    // 6 - Create groups
+    if (unpackedRoot.GroupProxies != null)
+    {
+      IReadOnlyCollection<ReceiveConversionResult> groupResults = groupBaker.CreateGroups(
+        unpackedRoot.GroupProxies,
+        applicationIdMap
+      );
+      results.UnionWith(groupResults);
+    }
+
+    return Task.FromResult(new HostObjectBuilderResult(bakedObjectIds, results));
   }
 
   private void PreReceiveDeepClean(string baseLayerPrefix)
   {
-    _autocadLayerManager.DeleteAllLayersByPrefix(baseLayerPrefix);
-    _instanceObjectsManager.PurgeInstances(baseLayerPrefix);
-    _materialManager.PurgeMaterials(baseLayerPrefix);
+    layerBaker.DeleteAllLayersByPrefix(baseLayerPrefix);
+    instanceBaker.PurgeInstances(baseLayerPrefix);
+    materialBaker.PurgeMaterials(baseLayerPrefix);
   }
 
-  private IEnumerable<Entity> ConvertObject(Base obj, Collection[] layerPath, string baseLayerNamePrefix)
+  private IReadOnlyCollection<Entity> ConvertObject(Base obj, Collection[] layerPath, string baseLayerNamePrefix)
   {
-    string layerName = _autocadLayerManager.CreateLayerForReceive(layerPath, baseLayerNamePrefix);
-    var convertedEntities = new List<Entity>();
+    string layerName = layerBaker.CreateLayerForReceive(layerPath, baseLayerNamePrefix);
+    var convertedEntities = new HashSet<Entity>();
 
     using var tr = Application.DocumentManager.CurrentDocument.Database.TransactionManager.StartTransaction();
 
     // 1: convert
-    var converted = _converter.Convert(obj);
+    var converted = converter.Convert(obj);
 
     // 2: handle result
-    if (converted is Entity entity)
+    switch (converted)
     {
-      var bakedEntity = BakeObject(entity, obj, layerName);
-      convertedEntities.Add(bakedEntity);
-    }
-    else if (converted is IEnumerable<(object, Base)> fallbackConversionResult)
-    {
-      var bakedFallbackEntities = BakeObjectsAsGroup(fallbackConversionResult, obj, layerName, baseLayerNamePrefix);
-      convertedEntities.AddRange(bakedFallbackEntities);
+      case Entity entity:
+        var bakedEntity = BakeObject(entity, obj, layerName);
+        convertedEntities.Add(bakedEntity);
+        break;
+
+      case List<(Entity, Base)> listConversionResult: // this is from fallback conversion for brep/brepx/subdx/extrusionx/polycurve
+        var bakedFallbackEntities = BakeObjectsAsGroup(listConversionResult, obj, layerName, baseLayerNamePrefix);
+        convertedEntities.UnionWith(bakedFallbackEntities);
+        break;
+
+      default:
+        // TODO: capture defualt case with report object here? Same as in Rhino
+        break;
     }
 
     tr.Commit();
-    return convertedEntities;
+    return convertedEntities.Freeze();
   }
 
-  private Entity BakeObject(Entity entity, Base originalObject, string layerName)
+  private Entity BakeObject(Entity entity, Base originalObject, string layerName, Base? parentObject = null)
   {
-    var objId = originalObject.applicationId ?? originalObject.id;
-    if (_colorManager.ObjectColorsIdMap.TryGetValue(objId, out AutocadColor? color))
+    var objId = originalObject.applicationId ?? originalObject.id.NotNull();
+    if (colorBaker.ObjectColorsIdMap.TryGetValue(objId, out AutocadColor? color))
     {
       entity.Color = color;
     }
 
-    if (_materialManager.ObjectMaterialsIdMap.TryGetValue(objId, out ObjectId matId))
+    if (materialBaker.TryGetMaterialId(originalObject, parentObject, out ObjectId matId))
     {
       entity.MaterialId = matId;
     }
@@ -244,33 +199,32 @@ public class AutocadHostObjectBuilder : IHostObjectBuilder
   }
 
   private List<Entity> BakeObjectsAsGroup(
-    IEnumerable<(object, Base)> fallbackConversionResult,
-    Base originatingObject,
+    List<(Entity, Base)> fallbackConversionResult,
+    Base parentObject,
     string layerName,
     string baseLayerName
   )
   {
     var ids = new ObjectIdCollection();
     var entities = new List<Entity>();
-    foreach (var (conversionResult, originalBaseObject) in fallbackConversionResult)
+    foreach (var (conversionResult, originalObject) in fallbackConversionResult)
     {
-      if (conversionResult is not Entity entity)
-      {
-        // TODO: throw?
-        continue;
-      }
+      BakeObject(conversionResult, originalObject, layerName, parentObject);
+      ids.Add(conversionResult.ObjectId);
+      entities.Add(conversionResult);
+    }
 
-      BakeObject(entity, originalBaseObject, layerName);
-      ids.Add(entity.ObjectId);
-      entities.Add(entity);
+    if (entities.Count <= 1) // return if empty list or only one, because we don't want to create empty or single item groups.
+    {
+      return entities;
     }
 
     var tr = Application.DocumentManager.CurrentDocument.Database.TransactionManager.TopTransaction;
     var groupDictionary = (DBDictionary)
       tr.GetObject(Application.DocumentManager.CurrentDocument.Database.GroupDictionaryId, OpenMode.ForWrite);
 
-    var groupName = _autocadContext.RemoveInvalidChars(
-      $@"{originatingObject.speckle_type.Split('.').Last()} - {originatingObject.applicationId ?? originatingObject.id}  ({baseLayerName})"
+    var groupName = autocadContext.RemoveInvalidChars(
+      $@"{parentObject.speckle_type.Split('.').Last()} - {parentObject.applicationId ?? parentObject.id}  ({baseLayerName})"
     );
 
     var newGroup = new Group(groupName, true);

Connectors/Autocad/Speckle.Connectors.AutocadShared/Operations/Send/AutocadRootObjectBaseBuilder.cs

@@ -0,0 +1,185 @@
+using System.Diagnostics.CodeAnalysis;
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.HostApp;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Extensions;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Converters.Common;
+using Speckle.Sdk;
+using Speckle.Sdk.Logging;
+using Speckle.Sdk.Models;
+using Speckle.Sdk.Models.Collections;
+using Speckle.Sdk.Models.Instances;
+
+namespace Speckle.Connectors.Autocad.Operations.Send;
+
+public abstract class AutocadRootObjectBaseBuilder : IRootObjectBuilder<AutocadRootObject>
+{
+  private readonly IRootToSpeckleConverter _converter;
+  private readonly string[] _documentPathSeparator = ["\\"];
+  private readonly ISendConversionCache _sendConversionCache;
+  private readonly AutocadInstanceUnpacker _instanceUnpacker;
+  private readonly AutocadMaterialUnpacker _materialUnpacker;
+  private readonly AutocadColorUnpacker _colorUnpacker;
+  private readonly AutocadGroupUnpacker _groupUnpacker;
+  private readonly ILogger<AutocadRootObjectBuilder> _logger;
+  private readonly ISdkActivityFactory _activityFactory;
+
+  protected AutocadRootObjectBaseBuilder(
+    IRootToSpeckleConverter converter,
+    ISendConversionCache sendConversionCache,
+    AutocadInstanceUnpacker instanceObjectManager,
+    AutocadMaterialUnpacker materialUnpacker,
+    AutocadColorUnpacker colorUnpacker,
+    AutocadGroupUnpacker groupUnpacker,
+    ILogger<AutocadRootObjectBuilder> logger,
+    ISdkActivityFactory activityFactory
+  )
+  {
+    _converter = converter;
+    _sendConversionCache = sendConversionCache;
+    _instanceUnpacker = instanceObjectManager;
+    _materialUnpacker = materialUnpacker;
+    _colorUnpacker = colorUnpacker;
+    _groupUnpacker = groupUnpacker;
+    _logger = logger;
+    _activityFactory = activityFactory;
+  }
+
+  [SuppressMessage(
+    "Maintainability",
+    "CA1506:Avoid excessive class coupling",
+    Justification = """
+      It is already simplified but has many different references since it is a builder. Do not know can we simplify it now.
+      Later we might consider to refactor proxies from one proxy manager? but we do not know the shape of it all potential
+      proxy classes yet. So I'm supressing this one now!!!
+      """
+  )]
+  public Task<RootObjectBuilderResult> Build(
+    IReadOnlyList<AutocadRootObject> objects,
+    SendInfo sendInfo,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken
+  )
+  {
+    // 0 - Init the root
+    Collection root =
+      new()
+      {
+        name = Application
+          .DocumentManager.CurrentDocument.Name // POC: https://spockle.atlassian.net/browse/CNX-9319
+          .Split(_documentPathSeparator, StringSplitOptions.None)
+          .Reverse()
+          .First()
+      };
+
+    // TODO: better handling for document and transactions!!
+    Document doc = Application.DocumentManager.CurrentDocument;
+    using Transaction tr = doc.Database.TransactionManager.StartTransaction();
+
+    // 1 - Unpack the instances
+    var (atomicObjects, instanceProxies, instanceDefinitionProxies) = _instanceUnpacker.UnpackSelection(objects);
+    root[ProxyKeys.INSTANCE_DEFINITION] = instanceDefinitionProxies;
+
+    // 2 - Unpack the groups
+    root[ProxyKeys.GROUP] = _groupUnpacker.UnpackGroups(atomicObjects);
+    using (var _ = _activityFactory.Start("Converting objects"))
+    {
+      // 3 - Convert atomic objects
+      List<LayerTableRecord> usedAcadLayers = new(); // Keeps track of autocad layers used, so we can pass them on later to the material and color unpacker.
+      List<SendConversionResult> results = new();
+      int count = 0;
+      foreach (var (entity, applicationId) in atomicObjects)
+      {
+        cancellationToken.ThrowIfCancellationRequested();
+        using (var convertActivity = _activityFactory.Start("Converting object"))
+        {
+          // Create and add a collection for this entity if not done so already.
+          (Collection objectCollection, LayerTableRecord? autocadLayer) = CreateObjectCollection(entity, tr);
+
+          if (autocadLayer is not null)
+          {
+            usedAcadLayers.Add(autocadLayer);
+            root.elements.Add(objectCollection);
+          }
+
+          var result = ConvertAutocadEntity(
+            entity,
+            applicationId,
+            objectCollection,
+            instanceProxies,
+            sendInfo.ProjectId
+          );
+          results.Add(result);
+
+          onOperationProgressed.Report(new("Converting", (double)++count / atomicObjects.Count));
+        }
+      }
+
+      if (results.All(x => x.Status == Status.ERROR))
+      {
+        throw new SpeckleException("Failed to convert all objects."); // fail fast instead creating empty commit! It will appear as model card error with red color.
+      }
+
+      // 4 - Unpack the render material proxies
+      root[ProxyKeys.RENDER_MATERIAL] = _materialUnpacker.UnpackMaterials(atomicObjects, usedAcadLayers);
+
+      // 5 - Unpack the color proxies
+      root[ProxyKeys.COLOR] = _colorUnpacker.UnpackColors(atomicObjects, usedAcadLayers);
+
+      // add any additional properties (most likely from verticals)
+      AddAdditionalProxiesToRoot(root);
+
+      return Task.FromResult(new RootObjectBuilderResult(root, results));
+    }
+  }
+
+  public virtual (Collection, LayerTableRecord?) CreateObjectCollection(Entity entity, Transaction tr)
+  {
+    return (new(), null);
+  }
+
+  public virtual void AddAdditionalProxiesToRoot(Collection rootCollection)
+  {
+    return;
+  }
+
+  private SendConversionResult ConvertAutocadEntity(
+    Entity entity,
+    string applicationId,
+    Collection collectionHost,
+    IReadOnlyDictionary<string, InstanceProxy> instanceProxies,
+    string projectId
+  )
+  {
+    string sourceType = entity.GetType().ToString();
+    try
+    {
+      Base converted;
+      if (entity is BlockReference && instanceProxies.TryGetValue(applicationId, out InstanceProxy? instanceProxy))
+      {
+        converted = instanceProxy;
+      }
+      else if (_sendConversionCache.TryGetValue(projectId, applicationId, out ObjectReference? value))
+      {
+        converted = value;
+      }
+      else
+      {
+        converted = _converter.Convert(entity);
+        converted.applicationId = applicationId;
+      }
+
+      collectionHost.elements.Add(converted);
+      return new(Status.SUCCESS, applicationId, sourceType, converted);
+    }
+    catch (Exception ex) when (!ex.IsFatal())
+    {
+      _logger.LogSendConversionError(ex, sourceType);
+      return new(Status.ERROR, applicationId, sourceType, null, ex);
+    }
+  }
+}

Connectors/Autocad/Speckle.Connectors.AutocadShared/Operations/Send/AutocadRootObjectBuilder.cs

@@ -1,180 +1,46 @@
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using Autodesk.AutoCAD.DatabaseServices;
 using Microsoft.Extensions.Logging;
 using Speckle.Connectors.Autocad.HostApp;
-using Speckle.Connectors.Utils.Builders;
-using Speckle.Connectors.Utils.Caching;
-using Speckle.Connectors.Utils.Conversion;
-using Speckle.Connectors.Utils.Extensions;
-using Speckle.Connectors.Utils.Operations;
+using Speckle.Connectors.Common.Caching;
 using Speckle.Converters.Common;
-using Speckle.Objects.Other;
-using Speckle.Sdk;
-using Speckle.Sdk.Models;
+using Speckle.Sdk.Logging;
 using Speckle.Sdk.Models.Collections;
-using Speckle.Sdk.Models.Instances;
-using Speckle.Sdk.Models.Proxies;
 
 namespace Speckle.Connectors.Autocad.Operations.Send;
 
-public class AutocadRootObjectBuilder : IRootObjectBuilder<AutocadRootObject>
+public sealed class AutocadRootObjectBuilder : AutocadRootObjectBaseBuilder
 {
-  private readonly IRootToSpeckleConverter _converter;
-  private readonly string[] _documentPathSeparator = ["\\"];
-  private readonly ISendConversionCache _sendConversionCache;
-  private readonly AutocadInstanceObjectManager _instanceObjectsManager;
-  private readonly AutocadMaterialManager _materialManager;
-  private readonly AutocadColorManager _colorManager;
-  private readonly AutocadLayerManager _layerManager;
-  private readonly AutocadGroupManager _groupManager;
-  private readonly ISyncToThread _syncToThread;
-  private readonly ILogger<AutocadRootObjectBuilder> _logger;
+  private readonly AutocadLayerUnpacker _layerUnpacker;
 
   public AutocadRootObjectBuilder(
+    AutocadLayerUnpacker layerUnpacker,
     IRootToSpeckleConverter converter,
     ISendConversionCache sendConversionCache,
-    AutocadInstanceObjectManager instanceObjectManager,
-    AutocadMaterialManager materialManager,
-    AutocadColorManager colorManager,
-    AutocadLayerManager layerManager,
-    AutocadGroupManager groupManager,
-    ISyncToThread syncToThread,
-    ILogger<AutocadRootObjectBuilder> logger
+    AutocadInstanceUnpacker instanceObjectManager,
+    AutocadMaterialUnpacker materialUnpacker,
+    AutocadColorUnpacker colorUnpacker,
+    AutocadGroupUnpacker groupUnpacker,
+    ILogger<AutocadRootObjectBuilder> logger,
+    ISdkActivityFactory activityFactory
   )
+    : base(
+      converter,
+      sendConversionCache,
+      instanceObjectManager,
+      materialUnpacker,
+      colorUnpacker,
+      groupUnpacker,
+      logger,
+      activityFactory
+    )
   {
-    _converter = converter;
-    _sendConversionCache = sendConversionCache;
-    _instanceObjectsManager = instanceObjectManager;
-    _materialManager = materialManager;
-    _colorManager = colorManager;
-    _layerManager = layerManager;
-    _groupManager = groupManager;
-    _syncToThread = syncToThread;
-    _logger = logger;
+    _layerUnpacker = layerUnpacker;
   }
 
-  [SuppressMessage(
-    "Maintainability",
-    "CA1506:Avoid excessive class coupling",
-    Justification = """
-      It is already simplified but has many different references since it is a builder. Do not know can we simplify it now.
-      Later we might consider to refactor proxies from one proxy manager? but we do not know the shape of it all potential
-      proxy classes yet. So I'm supressing this one now!!!
-      """
-  )]
-  public Task<RootObjectBuilderResult> Build(
-    IReadOnlyList<AutocadRootObject> objects,
-    SendInfo sendInfo,
-    Action<string, double?>? onOperationProgressed = null,
-    CancellationToken ct = default
-  )
+  public override (Collection, LayerTableRecord?) CreateObjectCollection(Entity entity, Transaction tr)
   {
-    return _syncToThread.RunOnThread(() =>
-    {
-      Collection modelWithLayers =
-        new()
-        {
-          name = Application
-            .DocumentManager.CurrentDocument.Name // POC: https://spockle.atlassian.net/browse/CNX-9319
-            .Split(_documentPathSeparator, StringSplitOptions.None)
-            .Reverse()
-            .First()
-        };
+    Layer layer = _layerUnpacker.GetOrCreateSpeckleLayer(entity, tr, out LayerTableRecord? autocadLayer);
 
-      // TODO: better handling for document and transactions!!
-      Document doc = Application.DocumentManager.CurrentDocument;
-      using Transaction tr = doc.Database.TransactionManager.StartTransaction();
-
-      // Keeps track of autocad layers used, so we can pass them on later to the material and color unpacker.
-      List<LayerTableRecord> usedAcadLayers = new();
-      int count = 0;
-
-      var (atomicObjects, instanceProxies, instanceDefinitionProxies) = _instanceObjectsManager.UnpackSelection(
-        objects
-      );
-
-      List<SendConversionResult> results = new();
-      var cacheHitCount = 0;
-
-      foreach (var (entity, applicationId) in atomicObjects)
-      {
-        ct.ThrowIfCancellationRequested();
-        string sourceType = entity.GetType().ToString();
-        try
-        {
-          Base converted;
-          if (entity is BlockReference && instanceProxies.TryGetValue(applicationId, out InstanceProxy? instanceProxy))
-          {
-            converted = instanceProxy;
-          }
-          else if (_sendConversionCache.TryGetValue(sendInfo.ProjectId, applicationId, out ObjectReference? value))
-          {
-            converted = value;
-            cacheHitCount++;
-          }
-          else
-          {
-            converted = _converter.Convert(entity);
-            converted.applicationId = applicationId;
-          }
-
-          // Create and add a collection for each layer if not done so already.
-          Layer layer = _layerManager.GetOrCreateSpeckleLayer(entity, tr, out LayerTableRecord? autocadLayer);
-          if (autocadLayer is not null)
-          {
-            usedAcadLayers.Add(autocadLayer);
-            modelWithLayers.elements.Add(layer);
-          }
-
-          layer.elements.Add(converted);
-          results.Add(new(Status.SUCCESS, applicationId, sourceType, converted));
-        }
-        catch (Exception ex) when (!ex.IsFatal())
-        {
-          _logger.LogSendConversionError(ex, sourceType);
-
-          results.Add(new(Status.ERROR, applicationId, sourceType, null, ex));
-        }
-        onOperationProgressed?.Invoke("Converting", (double)++count / atomicObjects.Count);
-      }
-
-      if (results.All(x => x.Status == Status.ERROR))
-      {
-        throw new SpeckleConversionException("Failed to convert all objects."); // fail fast instead creating empty commit! It will appear as model card error with red color.
-      }
-
-      // POC: Log would be nice, or can be removed.
-      Debug.WriteLine(
-        $"Cache hit count {cacheHitCount} out of {objects.Count} ({(double)cacheHitCount / objects.Count})"
-      );
-
-      var conversionFailedAppIds = results
-        .FindAll(result => result.Status == Status.ERROR)
-        .Select(result => result.SourceId);
-
-      // Cleans up objects that failed to convert from definition proxies.
-      // see https://linear.app/speckle/issue/CNX-115/viewer-handle-gracefully-instances-with-elements-that-failed-to
-      foreach (var definitionProxy in instanceDefinitionProxies)
-      {
-        definitionProxy.objects.RemoveAll(id => conversionFailedAppIds.Contains(id));
-      }
-      // Set definition proxies
-      modelWithLayers["instanceDefinitionProxies"] = instanceDefinitionProxies;
-
-      // set groups
-      List<GroupProxy> groupProxies = _groupManager.UnpackGroups(atomicObjects);
-      modelWithLayers["groupProxies"] = groupProxies;
-
-      // set materials
-      List<RenderMaterialProxy> materialProxies = _materialManager.UnpackMaterials(atomicObjects, usedAcadLayers);
-      modelWithLayers["renderMaterialProxies"] = materialProxies;
-
-      // set colors
-      List<ColorProxy> colorProxies = _colorManager.UnpackColors(atomicObjects, usedAcadLayers);
-      modelWithLayers["colorProxies"] = colorProxies;
-
-      return new RootObjectBuilderResult(modelWithLayers, results);
-    });
+    return (layer, autocadLayer);
   }
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/Plugin/AppUtils.cs

@@ -1,30 +1,30 @@
-using Speckle.Sdk.Host;
+using Speckle.Connectors.Common;
 
 namespace Speckle.Connectors.Autocad.Plugin;
 
 public static class AppUtils
 {
-  public static HostApplication App =>
+  public static Speckle.Sdk.Application App =>
 #if CIVIL3D
     HostApplications.Civil3D;
 #elif AUTOCAD
     HostApplications.AutoCAD;
 #else
-    throw new NotImplementedException();
+    throw new NotSupportedException();
 #endif
 
   public static HostAppVersion Version =>
-#if CIVIL3D2024
-    HostAppVersion.v2024;
-#elif AUTOCAD2025
+#if AUTOCAD2026 || CIVIL3D2026
+    HostAppVersion.v2026;
+#elif AUTOCAD2025 || CIVIL3D2025
     HostAppVersion.v2025;
-#elif AUTOCAD2024
+#elif AUTOCAD2024 || CIVIL3D2024
     HostAppVersion.v2024;
-#elif AUTOCAD2023
+#elif AUTOCAD2023|| CIVIL3D2023
     HostAppVersion.v2023;
-#elif AUTOCAD2022
+#elif AUTOCAD2022 || CIVIL3D2022
     HostAppVersion.v2022;
 #else
-    throw new NotImplementedException();
+    throw new NotSupportedException();
 #endif
 }

Connectors/Autocad/Speckle.Connectors.AutocadShared/Plugin/AutocadCommand.cs

@@ -1,20 +1,24 @@
 using System.Drawing;
-using System.IO;
-using System.Reflection;
 using Autodesk.AutoCAD.Runtime;
 using Autodesk.AutoCAD.Windows;
-using Speckle.Autofac.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Connectors.Common;
+using Speckle.Connectors.DUI;
 using Speckle.Connectors.DUI.WebView;
-using Speckle.Connectors.Utils;
-using Speckle.Sdk.Common;
-
+#if AUTOCAD
+using Speckle.Connectors.Autocad.DependencyInjection;
+using Speckle.Converters.Autocad;
+#elif CIVIL3D
+using Speckle.Converters.Civil3dShared;
+using Speckle.Connectors.Civil3dShared.DependencyInjection;
+#endif
 namespace Speckle.Connectors.Autocad.Plugin;
 
 public class AutocadCommand
 {
   private static PaletteSet? PaletteSet { get; set; }
   private static readonly Guid s_id = new("3223E594-1B09-4E54-B3DD-8EA0BECE7BA5");
-  public SpeckleContainer? Container { get; private set; }
+  public ServiceProvider? Container { get; private set; }
   private IDisposable? _disposableLogger;
   public const string COMMAND_STRING = "SpeckleBeta";
 
@@ -27,26 +31,28 @@ public class AutocadCommand
       return;
     }
 
-    PaletteSet = new PaletteSet("Speckle (Beta) for Autocad", s_id)
+    PaletteSet = new PaletteSet($"Speckle (Beta)", s_id)
     {
       Size = new Size(400, 500),
       DockEnabled = (DockSides)((int)DockSides.Left + (int)DockSides.Right)
     };
 
-    var builder = SpeckleContainerBuilder.CreateInstance();
-
     // init DI
-    _disposableLogger = Connector.Initialize(AppUtils.App, AppUtils.Version);
-    Container = builder
-      .LoadAutofacModules(
-        Assembly.GetExecutingAssembly(),
-        [Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location).NotNull()]
-      )
-      .Build();
+    var services = new ServiceCollection();
+    _disposableLogger = services.Initialize(AppUtils.App, AppUtils.Version);
+#if AUTOCAD
+    services.AddAutocad();
+    services.AddAutocadConverters();
+#elif CIVIL3D
+    services.AddCivil3d();
+    services.AddCivil3dConverters();
+#endif
+    Container = services.BuildServiceProvider();
+    Container.UseDUI();
 
-    var panelWebView = Container.Resolve<DUI3ControlWebView>();
+    var panelWebView = Container.GetRequiredService<DUI3ControlWebView>();
 
-    PaletteSet.AddVisual("Speckle (Beta) for Autocad WebView", panelWebView);
+    PaletteSet.AddVisual("Speckle (Beta)", panelWebView);
 
     FocusPalette();
   }

Connectors/Autocad/Speckle.Connectors.AutocadShared/Plugin/AutocadExtensionApplication.cs

@@ -1,5 +1,5 @@
 using Autodesk.AutoCAD.Runtime;
-using Speckle.Autofac;
+using Speckle.Connectors.Common;
 
 namespace Speckle.Connectors.Autocad.Plugin;
 

Connectors/Autocad/Speckle.Connectors.AutocadShared/Plugin/AutocadRibbon.cs

@@ -1,10 +1,11 @@
-using System.IO;
 using System.Reflection;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using Autodesk.Windows;
 using Speckle.Sdk;
-using Speckle.Sdk.Logging;
+#if !AUTOCAD2025_OR_GREATER && !CIVIL3D2025_OR_GREATER
+using System.IO;
+#endif
 
 namespace Speckle.Connectors.Autocad.Plugin;
 
@@ -47,20 +48,20 @@ public class AutocadRibbon
 
   private void Create()
   {
-    RibbonTab tab = FindOrMakeTab("Add-ins");
-    RibbonPanelSource source = new() { Title = "Speckle 2 (New Beta)" };
+    RibbonTab tab = FindOrMakeTab("Speckle");
+    RibbonPanelSource source = new() { Title = "Speckle (Beta)" };
     RibbonPanel panel = new() { Source = source };
     tab.Panels.Add(panel);
 
     RibbonToolTip speckleToolTip =
       new()
       {
-        Title = "Speckle 2 (New Beta)",
-        Content = "Speckle Connector for " + AppUtils.App.Name,
+        Title = "Speckle (Beta)",
+        Content = $"Next Gen Speckle Connector (Beta) for {AppUtils.App.Name}",
         IsHelpEnabled = true // Without this "Press F1 for help" does not appear in the tooltip
       };
 
-    _ = CreateSpeckleButton("Connector " + AppUtils.App.Name + " (New)", source, null, speckleToolTip, "logo");
+    _ = CreateSpeckleButton("Speckle (Beta)", source, null, speckleToolTip, "logo");
   }
 
   private void ComponentManager_ItemInitialized(object? sender, RibbonItemEventArgs e)
@@ -178,18 +179,9 @@ public class AutocadRibbon
     {
       stream = assembly.GetManifestResourceStream(resource);
     }
-    catch (FileLoadException flEx)
-    {
-      SpeckleLog.Logger.Error(flEx, "Could not load app image source: {exceptionMessage}");
-    }
-    catch (FileNotFoundException fnfEx)
-    {
-      SpeckleLog.Logger.Error(fnfEx, "Could not find app image source: {exceptionMessage}");
-    }
-    catch (NotImplementedException niEx)
-    {
-      SpeckleLog.Logger.Error(niEx, "App image source could not be loaded: {exceptionMessage}");
-    }
+    catch (FileLoadException) { }
+    catch (FileNotFoundException) { }
+    catch (NotImplementedException) { }
 
     if (stream is null)
     {

Connectors/Autocad/Speckle.Connectors.AutocadShared/Speckle.Connectors.AutocadShared.projitems

@@ -9,23 +9,29 @@
     <Import_RootNamespace>Speckle.Connectors.AutocadShared</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Bindings\AutocadReceiveBaseBinding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bindings\AutocadSelectionBinding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bindings\AutocadReceiveBinding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bindings\AutocadSendBinding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bindings\AutocadBasicConnectorBinding.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Bindings\AutocadSendBaseBinding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DependencyInjection\SharedRegistration.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DependencyInjection\AutocadConnectorModule.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DependencyInjection\Civil3dConnectorModule.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Filters\AutocadSelectionFilter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadMaterialManager.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadGroupManager.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadInstanceObjectManager.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadColorBaker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadColorUnpacker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadGroupBaker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadGroupUnpacker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadIdleManager.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadInstanceBaker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadInstanceUnpacker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadLayerBaker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadLayerUnpacker.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadMaterialBaker.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadContext.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadDocumentManager.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadDocumentModelStore.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadIdleManager.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadColorManager.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadLayerManager.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HostApp\AutocadMaterialUnpacker.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\Extensions\DatabaseExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\Extensions\DocumentExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\Extensions\EditorExtensions.cs" />
@@ -34,6 +40,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)HostApp\TransactionContext.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Operations\Receive\AutocadHostObjectBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Operations\Send\AutocadRootObject.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Operations\Send\AutocadRootObjectBaseBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Operations\Send\AutocadRootObjectBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Plugin\AutocadRibbon.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Plugin\AutocadExtensionApplication.cs" />

Connectors/Autocad/Speckle.Connectors.Civil3d2022/Speckle.Connectors.Civil3d2022.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net48</TargetFramework>
+    <PlatformTarget>x64</PlatformTarget>
+    <UseWpf>true</UseWpf>
+    <Civil3DVersion>2022</Civil3DVersion>
+    <DefineConstants>$(DefineConstants);CIVIL3D;CIVIL3D2022;CIVIL3D2022_OR_GREATER</DefineConstants>
+    <Configurations>Debug;Release;Local</Configurations>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Speckle.AutoCAD.API"  VersionOverride="2022.0.2" ExcludeAssets="runtime"/>
+    <PackageReference Include="Speckle.Civil3D.API"  VersionOverride="2022.0.2" ExcludeAssets="runtime"/>
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Converters\Civil3d\Speckle.Converters.Civil3d2022\Speckle.Converters.Civil3d2022.csproj" />
+    <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
+    <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
+  </ItemGroup>
+  
+  <Import Project="..\..\Autocad\Speckle.Connectors.AutocadShared\Speckle.Connectors.AutocadShared.projitems" Label="Shared" />
+  <Import Project="..\..\Autocad\Speckle.Connectors.Civil3dShared\Speckle.Connectors.Civil3dShared.projitems" Label="Shared" />
+</Project>

Connectors/Autocad/Speckle.Connectors.Civil3d2022/packages.lock.json

@@ -0,0 +1,381 @@
+{
+  "version": 2,
+  "dependencies": {
+    ".NETFramework,Version=v4.8": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3"
+        }
+      },
+      "Microsoft.SourceLink.GitHub": {
+        "type": "Direct",
+        "requested": "[8.0.0, )",
+        "resolved": "8.0.0",
+        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "8.0.0",
+          "Microsoft.SourceLink.Common": "8.0.0"
+        }
+      },
+      "PolySharp": {
+        "type": "Direct",
+        "requested": "[1.14.1, )",
+        "resolved": "1.14.1",
+        "contentHash": "mOOmFYwad3MIOL14VCjj02LljyF1GNw1wP0YVlxtcPvqdxjGGMNdNJJxHptlry3MOd8b40Flm8RPOM8JOlN2sQ=="
+      },
+      "Speckle.AutoCAD.API": {
+        "type": "Direct",
+        "requested": "[2022.0.2, )",
+        "resolved": "2022.0.2",
+        "contentHash": "NFHXnlkBjzM8Bau52d6eF6m0+etHddGx7qlWN8YyrfTtGyz+AmPvF8fgxcLgyjAcB3W4Wim11JeYuEoTNH1X0w=="
+      },
+      "Speckle.Civil3D.API": {
+        "type": "Direct",
+        "requested": "[2022.0.2, )",
+        "resolved": "2022.0.2",
+        "contentHash": "H36v9rA2Ynh4gDCzpBeUcWs4BQwWi3MwgTAnClM22vNbQXZlxjK85iO8i/mJsX57hh8VfqLB8EA7CUw94gBddw==",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "2022.0.2"
+        }
+      },
+      "Speckle.InterfaceGenerator": {
+        "type": "Direct",
+        "requested": "[0.9.6, )",
+        "resolved": "0.9.6",
+        "contentHash": "HKH7tYrYYlCK1ct483hgxERAdVdMtl7gUKW9ijWXxA1UsYR4Z+TrRHYmzZ9qmpu1NnTycSrp005NYM78GDKV1w=="
+      },
+      "GraphQL.Client": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "8yPNBbuVBpTptivyAlak4GZvbwbUcjeQTL4vN1HKHRuOykZ4r7l5fcLS6vpyPyLn0x8FsL31xbOIKyxbmR9rbA==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0",
+          "GraphQL.Client.Abstractions.Websocket": "6.0.0",
+          "System.Net.WebSockets.Client.Managed": "1.0.22",
+          "System.Reactive": "5.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "h7uzWFORHZ+CCjwr/ThAyXMr0DPpzEANDa4Uo54wqCQ+j7qUKwqYTgOrb1W40sqbvNaZm9v/X7It31SUw0maHA==",
+        "dependencies": {
+          "GraphQL.Primitives": "6.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions.Websocket": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "Nr9bPf8gIOvLuXpqEpqr9z9jslYFJOvd0feHth3/kPqeR3uMbjF5pjiwh4jxyMcxHdr8Pb6QiXkV3hsSyt0v7A==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0"
+        }
+      },
+      "GraphQL.Primitives": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "yg72rrYDapfsIUrul7aF6wwNnTJBOFvuA9VdDTQpPa8AlAriHbufeXYLBcodKjfUdkCnaiggX1U/nEP08Zb5GA=="
+      },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "W8DPQjkMScOMTtJbPwmPyj9c3zYSFGawDW3jwlBOOsnY+EzZFLgNQ/UMkK35JmkNOVPdCyPr2Tw7Vv9N+KA3ZQ==",
+        "dependencies": {
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
+      "Microsoft.Build.Tasks.Git": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
+      },
+      "Microsoft.CSharp": {
+        "type": "Transitive",
+        "resolved": "4.7.0",
+        "contentHash": "pTj+D3uJWyN3My70i2Hqo+OXixq3Os2D1nJ2x92FFo6sk8fYS1m1WLNTs0Dc1uPaViH0YvEEwvzddQ7y4rhXmA=="
+      },
+      "Microsoft.Data.Sqlite": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
+        "dependencies": {
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
+          "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
+        }
+      },
+      "Microsoft.Data.Sqlite.Core": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "Microsoft.Extensions.Configuration": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net48": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "zMk4D+9zyiEWByyQ7oPImPN/Jhpj166Ky0Nlla4eXlNL8hI/BtSJsgR8Inldd4NNpIAH3oh8yym0W2DrhXdSLQ=="
+      },
+      "Microsoft.SourceLink.Common": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
+      },
+      "Speckle.Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.2",
+        "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
+      },
+      "SQLitePCLRaw.bundle_e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "EWI1olKDjFEBMJu0+3wuxwziIAdWDVMYLhuZ3Qs84rrz+DHwD00RzWPZCa+bLnHCf3oJwuFZIRsHT5p236QXww==",
+        "dependencies": {
+          "SQLitePCLRaw.lib.e_sqlite3": "2.1.4",
+          "SQLitePCLRaw.provider.dynamic_cdecl": "2.1.4"
+        }
+      },
+      "SQLitePCLRaw.core": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "inBjvSHo9UDKneGNzfUfDjK08JzlcIhn1+SP5Y3m6cgXpCxXKCJDy6Mka7LpgSV+UZmKSnC8rTwB0SQ0xKu5pA==",
+        "dependencies": {
+          "System.Memory": "4.5.3"
+        }
+      },
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "SQLitePCLRaw.provider.dynamic_cdecl": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "ZsaKKhgYF9B1fvcnOGKl3EycNAwd9CRWX7v0rEfuPWhQQ5Jjpvf2VEHahiLIGHio3hxi3EIKFJw9KvyowWOUAw==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "System.Buffers": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw=="
+      },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
+      "System.Memory": {
+        "type": "Transitive",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
+        "dependencies": {
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
+        }
+      },
+      "System.Net.WebSockets.Client.Managed": {
+        "type": "Transitive",
+        "resolved": "1.0.22",
+        "contentHash": "WqEOxPlXjuZrIjUtXNE9NxEfU/n5E35iV2PtoZdJSUC4tlrqwHnTee+wvMIM4OUaJWmwrymeqcgYrE0IkGAgLA==",
+        "dependencies": {
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0"
+        }
+      },
+      "System.Numerics.Vectors": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ=="
+      },
+      "System.Reactive": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+        "dependencies": {
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "4.5.3",
+        "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw=="
+      },
+      "System.Threading.Tasks.Extensions": {
+        "type": "Transitive",
+        "resolved": "4.5.4",
+        "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==",
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+        }
+      },
+      "speckle.connectors.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
+        }
+      },
+      "speckle.connectors.dui": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.dui.webview": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "[1.0.1938.49, )",
+          "Speckle.Connectors.DUI": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.logging": {
+        "type": "Project"
+      },
+      "speckle.converters.civil3d2022": {
+        "type": "Project",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "[2022.0.2, )",
+          "Speckle.Civil3D.API": "[2022.0.2, )",
+          "Speckle.Converters.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.converters.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
+      },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
+      "Speckle.Objects": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
+        "dependencies": {
+          "Speckle.Sdk": "3.3.5"
+        }
+      },
+      "Speckle.Sdk": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
+        "dependencies": {
+          "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
+          "Microsoft.CSharp": "4.7.0",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
+          "Speckle.Newtonsoft.Json": "13.0.2",
+          "Speckle.Sdk.Dependencies": "3.3.5"
+        }
+      },
+      "Speckle.Sdk.Dependencies": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
+      }
+    }
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3d2023/Speckle.Connectors.Civil3d2023.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net48</TargetFramework>
+    <PlatformTarget>x64</PlatformTarget>
+    <UseWpf>true</UseWpf>
+    <Civil3DVersion>2023</Civil3DVersion>
+    <DefineConstants>$(DefineConstants);CIVIL3D;CIVIL3D2023;CIVIL3D2022_OR_GREATER;CIVIL3D2023_OR_GREATER</DefineConstants>
+    <Configurations>Debug;Release;Local</Configurations>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2023.0.0" ExcludeAssets="runtime"/>
+    <PackageReference Include="Speckle.Civil3D.API" VersionOverride="2023.0.0" ExcludeAssets="runtime"/>
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Converters\Civil3d\Speckle.Converters.Civil3d2023\Speckle.Converters.Civil3d2023.csproj" />
+    <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
+    <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
+  </ItemGroup>
+  
+  <Import Project="..\..\Autocad\Speckle.Connectors.AutocadShared\Speckle.Connectors.AutocadShared.projitems" Label="Shared" />
+  <Import Project="..\..\Autocad\Speckle.Connectors.Civil3dShared\Speckle.Connectors.Civil3dShared.projitems" Label="Shared" />
+</Project>

Connectors/Autocad/Speckle.Connectors.Civil3d2023/packages.lock.json

@@ -0,0 +1,381 @@
+{
+  "version": 2,
+  "dependencies": {
+    ".NETFramework,Version=v4.8": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3"
+        }
+      },
+      "Microsoft.SourceLink.GitHub": {
+        "type": "Direct",
+        "requested": "[8.0.0, )",
+        "resolved": "8.0.0",
+        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "8.0.0",
+          "Microsoft.SourceLink.Common": "8.0.0"
+        }
+      },
+      "PolySharp": {
+        "type": "Direct",
+        "requested": "[1.14.1, )",
+        "resolved": "1.14.1",
+        "contentHash": "mOOmFYwad3MIOL14VCjj02LljyF1GNw1wP0YVlxtcPvqdxjGGMNdNJJxHptlry3MOd8b40Flm8RPOM8JOlN2sQ=="
+      },
+      "Speckle.AutoCAD.API": {
+        "type": "Direct",
+        "requested": "[2023.0.0, )",
+        "resolved": "2023.0.0",
+        "contentHash": "aNfiNw9zRW8pCl8AAQK7afEJuea4bJ4sFNsGVSDrdq1egaonZrwALU01dSyFNCE8tne86eVjlprpOGG6r0+G/A=="
+      },
+      "Speckle.Civil3D.API": {
+        "type": "Direct",
+        "requested": "[2023.0.0, )",
+        "resolved": "2023.0.0",
+        "contentHash": "URb0wfrxm4jcAApRxZ15a1dmxWDRry8WAuGmUwC7saP5+ltkJOVSOYb6WeJKYhDiJbO3UlVCesTFNnsNjMFd5A==",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "2022.0.2"
+        }
+      },
+      "Speckle.InterfaceGenerator": {
+        "type": "Direct",
+        "requested": "[0.9.6, )",
+        "resolved": "0.9.6",
+        "contentHash": "HKH7tYrYYlCK1ct483hgxERAdVdMtl7gUKW9ijWXxA1UsYR4Z+TrRHYmzZ9qmpu1NnTycSrp005NYM78GDKV1w=="
+      },
+      "GraphQL.Client": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "8yPNBbuVBpTptivyAlak4GZvbwbUcjeQTL4vN1HKHRuOykZ4r7l5fcLS6vpyPyLn0x8FsL31xbOIKyxbmR9rbA==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0",
+          "GraphQL.Client.Abstractions.Websocket": "6.0.0",
+          "System.Net.WebSockets.Client.Managed": "1.0.22",
+          "System.Reactive": "5.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "h7uzWFORHZ+CCjwr/ThAyXMr0DPpzEANDa4Uo54wqCQ+j7qUKwqYTgOrb1W40sqbvNaZm9v/X7It31SUw0maHA==",
+        "dependencies": {
+          "GraphQL.Primitives": "6.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions.Websocket": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "Nr9bPf8gIOvLuXpqEpqr9z9jslYFJOvd0feHth3/kPqeR3uMbjF5pjiwh4jxyMcxHdr8Pb6QiXkV3hsSyt0v7A==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0"
+        }
+      },
+      "GraphQL.Primitives": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "yg72rrYDapfsIUrul7aF6wwNnTJBOFvuA9VdDTQpPa8AlAriHbufeXYLBcodKjfUdkCnaiggX1U/nEP08Zb5GA=="
+      },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "W8DPQjkMScOMTtJbPwmPyj9c3zYSFGawDW3jwlBOOsnY+EzZFLgNQ/UMkK35JmkNOVPdCyPr2Tw7Vv9N+KA3ZQ==",
+        "dependencies": {
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
+      "Microsoft.Build.Tasks.Git": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
+      },
+      "Microsoft.CSharp": {
+        "type": "Transitive",
+        "resolved": "4.7.0",
+        "contentHash": "pTj+D3uJWyN3My70i2Hqo+OXixq3Os2D1nJ2x92FFo6sk8fYS1m1WLNTs0Dc1uPaViH0YvEEwvzddQ7y4rhXmA=="
+      },
+      "Microsoft.Data.Sqlite": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
+        "dependencies": {
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
+          "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
+        }
+      },
+      "Microsoft.Data.Sqlite.Core": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "Microsoft.Extensions.Configuration": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net48": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "zMk4D+9zyiEWByyQ7oPImPN/Jhpj166Ky0Nlla4eXlNL8hI/BtSJsgR8Inldd4NNpIAH3oh8yym0W2DrhXdSLQ=="
+      },
+      "Microsoft.SourceLink.Common": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
+      },
+      "Speckle.Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.2",
+        "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
+      },
+      "SQLitePCLRaw.bundle_e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "EWI1olKDjFEBMJu0+3wuxwziIAdWDVMYLhuZ3Qs84rrz+DHwD00RzWPZCa+bLnHCf3oJwuFZIRsHT5p236QXww==",
+        "dependencies": {
+          "SQLitePCLRaw.lib.e_sqlite3": "2.1.4",
+          "SQLitePCLRaw.provider.dynamic_cdecl": "2.1.4"
+        }
+      },
+      "SQLitePCLRaw.core": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "inBjvSHo9UDKneGNzfUfDjK08JzlcIhn1+SP5Y3m6cgXpCxXKCJDy6Mka7LpgSV+UZmKSnC8rTwB0SQ0xKu5pA==",
+        "dependencies": {
+          "System.Memory": "4.5.3"
+        }
+      },
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "SQLitePCLRaw.provider.dynamic_cdecl": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "ZsaKKhgYF9B1fvcnOGKl3EycNAwd9CRWX7v0rEfuPWhQQ5Jjpvf2VEHahiLIGHio3hxi3EIKFJw9KvyowWOUAw==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "System.Buffers": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw=="
+      },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
+      "System.Memory": {
+        "type": "Transitive",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
+        "dependencies": {
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
+        }
+      },
+      "System.Net.WebSockets.Client.Managed": {
+        "type": "Transitive",
+        "resolved": "1.0.22",
+        "contentHash": "WqEOxPlXjuZrIjUtXNE9NxEfU/n5E35iV2PtoZdJSUC4tlrqwHnTee+wvMIM4OUaJWmwrymeqcgYrE0IkGAgLA==",
+        "dependencies": {
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0"
+        }
+      },
+      "System.Numerics.Vectors": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ=="
+      },
+      "System.Reactive": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+        "dependencies": {
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "4.5.3",
+        "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw=="
+      },
+      "System.Threading.Tasks.Extensions": {
+        "type": "Transitive",
+        "resolved": "4.5.4",
+        "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==",
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+        }
+      },
+      "speckle.connectors.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
+        }
+      },
+      "speckle.connectors.dui": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.dui.webview": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "[1.0.1938.49, )",
+          "Speckle.Connectors.DUI": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.logging": {
+        "type": "Project"
+      },
+      "speckle.converters.civil3d2023": {
+        "type": "Project",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "[2023.0.0, )",
+          "Speckle.Civil3D.API": "[2023.0.0, )",
+          "Speckle.Converters.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.converters.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
+      },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
+      "Speckle.Objects": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
+        "dependencies": {
+          "Speckle.Sdk": "3.3.5"
+        }
+      },
+      "Speckle.Sdk": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
+        "dependencies": {
+          "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
+          "Microsoft.CSharp": "4.7.0",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
+          "Speckle.Newtonsoft.Json": "13.0.2",
+          "Speckle.Sdk.Dependencies": "3.3.5"
+        }
+      },
+      "Speckle.Sdk.Dependencies": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
+      }
+    }
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3d2024/Speckle.Connectors.Civil3d2024.csproj

@@ -2,21 +2,23 @@
   <PropertyGroup>
     <TargetFramework>net48</TargetFramework>
     <PlatformTarget>x64</PlatformTarget>
+    <UseWpf>true</UseWpf>
     <Civil3DVersion>2024</Civil3DVersion>
-    <DefineConstants>$(DefineConstants);CIVIL3D;CIVIL3D2024;CIVIL3D2024_OR_GREATER</DefineConstants>
+    <DefineConstants>$(DefineConstants);CIVIL3D;CIVIL3D2024;CIVIL3D2022_OR_GREATER;CIVIL3D2023_OR_GREATER;CIVIL3D2024_OR_GREATER</DefineConstants>
     <Configurations>Debug;Release;Local</Configurations>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2024.0.0" />
-    <PackageReference Include="Speckle.Civil3D.API" VersionOverride="2024.0.0" />
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2024.0.0" ExcludeAssets="runtime"/>
+    <PackageReference Include="Speckle.Civil3D.API" VersionOverride="2024.0.0" ExcludeAssets="runtime"/>
   </ItemGroup>
   
   <ItemGroup>
-    <ProjectReference Include="..\..\..\Converters\Autocad\Speckle.Converters.Autocad2023.DependencyInjection\Speckle.Converters.Autocad2023.DependencyInjection.csproj" />
+    <ProjectReference Include="..\..\..\Converters\Civil3d\Speckle.Converters.Civil3d2024\Speckle.Converters.Civil3d2024.csproj" />
     <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
     <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
   </ItemGroup>
   
   <Import Project="..\..\Autocad\Speckle.Connectors.AutocadShared\Speckle.Connectors.AutocadShared.projitems" Label="Shared" />
+  <Import Project="..\..\Autocad\Speckle.Connectors.Civil3dShared\Speckle.Connectors.Civil3dShared.projitems" Label="Shared" />
 </Project>

Connectors/Autocad/Speckle.Connectors.Civil3d2024/packages.lock.json

@@ -2,6 +2,15 @@
   "version": 2,
   "dependencies": {
     ".NETFramework,Version=v4.8": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3"
+        }
+      },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
         "requested": "[8.0.0, )",
@@ -91,116 +100,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0",
-          "System.ComponentModel.Annotations": "4.7.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg==",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
         "dependencies": {
-          "System.Memory": "4.5.2",
-          "System.Runtime.CompilerServices.Unsafe": "4.7.0"
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
         }
       },
+      "Microsoft.NETFramework.ReferenceAssemblies.net48": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "zMk4D+9zyiEWByyQ7oPImPN/Jhpj166Ky0Nlla4eXlNL8hI/BtSJsgR8Inldd4NNpIAH3oh8yym0W2DrhXdSLQ=="
+      },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -233,22 +210,22 @@
       },
       "System.Buffers": {
         "type": "Transitive",
-        "resolved": "4.5.1",
-        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+        "resolved": "4.4.0",
+        "contentHash": "AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw=="
       },
       "System.ComponentModel.Annotations": {
         "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "0YFqjhp/mYkDGpU0Ye1GjE53HMp9UVfGN7seGpAMttAC0C40v5gw598jCgpbBLMmCo0E5YRLBv5Z2doypO49ZQ=="
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
       },
       "System.Memory": {
         "type": "Transitive",
-        "resolved": "4.5.4",
-        "contentHash": "1MbJTHS1lZ4bS4FmsJjnuGJOu88ZzTT2rLvrhW7Ygic+pC0NWA+3hgAen0HRdsocuQXCkUTdFn9yHJJhsijDXw==",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
         "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+          "System.Buffers": "4.4.0",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
         }
       },
       "System.Net.WebSockets.Client.Managed": {
@@ -262,8 +239,8 @@
       },
       "System.Numerics.Vectors": {
         "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "QQTlPTl06J/iiDbJCiepZ4H//BVraReU4O4EoRw1U02H5TLUIT7xn3GnDp9AXPSlJUDyFs4uWjWafNX6WrAojQ=="
+        "resolved": "4.4.0",
+        "contentHash": "UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ=="
       },
       "System.Reactive": {
         "type": "Transitive",
@@ -275,32 +252,8 @@
       },
       "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.0",
-        "contentHash": "ZD9TMpsmYJLrxbbmdvhwt9YEgG5WntEnZ/d1eH8JBX9LBp+Ju8BSBhUGbZMNVHHomWo2KVImJhTDl2hIgw/6MA=="
-      },
-      "System.Text.Encodings.Web": {
-        "type": "Transitive",
-        "resolved": "5.0.1",
-        "contentHash": "KmJ+CJXizDofbq6mpqDoRRLcxgOd2z9X3XoFNULSbvbqVRZkFX3istvr+MUjL6Zw1RT+RNdoI4GYidIINtgvqQ==",
-        "dependencies": {
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4"
-        }
-      },
-      "System.Text.Json": {
-        "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ==",
-        "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
-          "System.Buffers": "4.5.1",
-          "System.Memory": "4.5.4",
-          "System.Numerics.Vectors": "4.5.0",
-          "System.Runtime.CompilerServices.Unsafe": "5.0.0",
-          "System.Text.Encodings.Web": "5.0.1",
-          "System.Threading.Tasks.Extensions": "4.5.4",
-          "System.ValueTuple": "4.5.0"
-        }
+        "resolved": "4.5.3",
+        "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw=="
       },
       "System.Threading.Tasks.Extensions": {
         "type": "Transitive",
@@ -310,25 +263,21 @@
           "System.Runtime.CompilerServices.Unsafe": "4.5.3"
         }
       },
-      "System.ValueTuple": {
-        "type": "Transitive",
-        "resolved": "4.5.0",
-        "contentHash": "okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ=="
-      },
-      "speckle.autofac": {
+      "speckle.connectors.common": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -338,71 +287,50 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
-      "speckle.converters.autocad2023": {
+      "speckle.converters.civil3d2024": {
         "type": "Project",
         "dependencies": {
-          "Speckle.AutoCAD.API": "[2023.0.0, )",
+          "Speckle.AutoCAD.API": "[2024.0.0, )",
+          "Speckle.Civil3D.API": "[2024.0.0, )",
           "Speckle.Converters.Common": "[1.0.0, )"
         }
       },
-      "speckle.converters.autocad2023.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Autofac": "[5.2.0, )",
-          "Speckle.Converters.Autocad2023": "[1.0.0, )",
-          "Speckle.Converters.Common.DependencyInjection": "[1.0.0, )"
-        }
-      },
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
-        "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
-        }
-      },
-      "Autofac": {
+      "Microsoft.Extensions.DependencyInjection": {
         "type": "CentralTransitive",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
         "dependencies": {
-          "Microsoft.Bcl.AsyncInterfaces": "1.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
       },
       "Microsoft.Web.WebView2": {
         "type": "CentralTransitive",
@@ -410,38 +338,43 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
+          "Microsoft.Bcl.AsyncInterfaces": "5.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
       }
     }
   }

Connectors/Autocad/Speckle.Connectors.Civil3d2025/Speckle.Connectors.Civil3d2025.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <Civil3DVersion>2025</Civil3DVersion>
+    <DefineConstants>$(DefineConstants);CIVIL3D2025;CIVIL3D;CIVIL3D2022_OR_GREATER;CIVIL3D2023_OR_GREATER;CIVIL3D2024_OR_GREATER;CIVIL3D2025_OR_GREATER</DefineConstants>
+    <Configurations>Debug;Release;Local</Configurations>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- .NET Core uses this to move native dependencies into a root for runtime selection and usage for non-windows development https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#enablewindowstargeting -->
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier> <!--This is needed for managed dependencies-->
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> <!--This is needed for the rest-->
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath> <!--This is needed just to keep folder paths the same as the netframework versions of autocad/civil-->
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2025.0.0" ExcludeAssets="runtime"/>
+    <PackageReference Include="Speckle.Civil3d.API" VersionOverride="2025.0.0" ExcludeAssets="runtime"/>
+  </ItemGroup>  
+  
+  <ItemGroup>   
+    <ProjectReference Include="..\..\..\Converters\Civil3d\Speckle.Converters.Civil3d2025\Speckle.Converters.Civil3d2025.csproj" />
+    <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
+    <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
+  </ItemGroup>
+  
+  <Import Project="..\Speckle.Connectors.Civil3dShared\Speckle.Connectors.Civil3dShared.projitems" Label="Shared" />
+  
+  <Import Project="..\Speckle.Connectors.AutocadShared\Speckle.Connectors.AutocadShared.projitems" Label="Shared" />
+</Project>

Connectors/Autocad/Speckle.Connectors.Civil3d2025/packages.lock.json

@@ -2,11 +2,14 @@
   "version": 2,
   "dependencies": {
     "net8.0-windows7.0": {
-      "Autofac": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[5.2.0, )",
-        "resolved": "5.2.0",
-        "contentHash": "V8dBH0dsv75uDzl7Sw+HkhKDPUw2eXnlMjcSVMH+tLo2s67MpTKGyDj1pDcpR+IF2u4YRs0s3/x7R88YJzIWvg=="
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
+        }
       },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
@@ -24,6 +27,21 @@
         "resolved": "1.14.1",
         "contentHash": "mOOmFYwad3MIOL14VCjj02LljyF1GNw1wP0YVlxtcPvqdxjGGMNdNJJxHptlry3MOd8b40Flm8RPOM8JOlN2sQ=="
       },
+      "Speckle.AutoCAD.API": {
+        "type": "Direct",
+        "requested": "[2025.0.0, )",
+        "resolved": "2025.0.0",
+        "contentHash": "dqEgZ+bTqAG0tx0WwdnTZcbNKH2igzhOr3SMXtRYai7yIqXiz5btZ4Mf2bmfxbmxLucww3GKVpdZoI+PSZlMuQ=="
+      },
+      "Speckle.Civil3D.API": {
+        "type": "Direct",
+        "requested": "[2025.0.0, )",
+        "resolved": "2025.0.0",
+        "contentHash": "zWxdzk7M2JE1+PgIpGrCycDUwbmTqJ+YCNMaJPbjUgVKoAiI5w7Ou9ynbFgmQkRuYrkTflbL+s799Fw62PJixQ==",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "2025.0.0"
+        }
+      },
       "Speckle.InterfaceGenerator": {
         "type": "Direct",
         "requested": "[0.9.6, )",
@@ -73,110 +91,84 @@
       },
       "Microsoft.Data.Sqlite": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "tiNmV1oPy+Z2R7Wd0bPB/FxCr8B+/5q11OpDMG751GA/YuOL7MZrBFfzv5oFRlFe08K6sjrnbrauzzGIeNrzLQ==",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
         "dependencies": {
-          "Microsoft.Data.Sqlite.Core": "7.0.7",
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
         }
       },
       "Microsoft.Data.Sqlite.Core": {
         "type": "Transitive",
-        "resolved": "7.0.7",
-        "contentHash": "21FRzcJhaTrlv7kTrqr/ltFcSQM2TyuTTPhUcjO8H73od7Bb3QraNW90c7lUucNI/245XPkKZG4fp7/7OsKCSg==",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
         "dependencies": {
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "Lu41BWNmwhKr6LgyQvcYBOge0pPvmiaK8R5UHXX4//wBhonJyWcT2OK1mqYfEM5G7pTf31fPrpIHOT6sN7EGOA==",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "ESz6bVoDQX7sgWdKHF6G9Pq672T8k+19AFb/txDXwdz7MoqaNQj2/in3agm/3qae9V+WvQZH86LLTNVo0it8vQ==",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
         "dependencies": {
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.Primitives": "2.2.0"
         }
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "o9eELDBfNkR7sUtYysFZ1Q7BQ1mYt27DMkups/3vu7xgPyOpMD+iAfrBZFzUXT2iw0fmFb8s1gfNBZS+IgjKdQ==",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "3.1.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection": {
-        "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "KVkv3aF2MQpmGFRh4xRx2CNbc2sjDFk+lH4ySrjWSOS+XoY1Xc+sJphw3N0iYOpoeCCq8976ceVYDH8sdx2qIQ==",
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0"
+          "Microsoft.Extensions.Configuration": "2.2.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "44rDtOf1JXXAFpNT2EXMExaDm/4OJ2RXOL9i9lE4bK427nzC7Exphv+beB6IgluyE2GIoo8zezTStMXI7MQ8WA=="
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
       },
       "Microsoft.Extensions.Options": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "9b6JHY7TAXrSfZ6EEGf+j8XnqKIiMPErfmaNXhJYSCb+BUW2H4RtzkNJvwLJzwgzqBP0wtTjyA6Uw4BPPdmkMw==",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Primitives": "3.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
         }
       },
       "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
-        "resolved": "3.1.0",
-        "contentHash": "LEKAnX7lhUhSoIc2XraCTK3M4IU/LdVUzCe464Sa4+7F4ZJuXHHRzZli2mDbiT4xzAZhgqXbvfnb5+CNDcQFfg=="
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "8.0.0",
         "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       },
-      "Polly": {
-        "type": "Transitive",
-        "resolved": "7.2.3",
-        "contentHash": "DeCY0OFbNdNxsjntr1gTXHJ5pKUwYzp04Er2LLeN3g6pWhffsGuKVfMBLe1lw7x76HrPkLxKEFxBlpRxS2nDEQ=="
-      },
-      "Polly.Contrib.WaitAndRetry": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "1MUQLiSo4KDkQe6nzQRhIU05lm9jlexX5BVsbuw0SL82ynZ+GzAHQxJVDPVBboxV37Po3SG077aX8DuSy8TkaA=="
-      },
-      "Polly.Extensions.Http": {
-        "type": "Transitive",
-        "resolved": "3.0.0",
-        "contentHash": "drrG+hB3pYFY7w1c3BD+lSGYvH2oIclH8GRSehgfyP5kjnFnHKQuuBhuHLv+PWyFuaTDyk/vfRpnxOzd11+J8g==",
-        "dependencies": {
-          "Polly": "7.1.0"
-        }
-      },
-      "Speckle.DoubleNumerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "MzEQ1Im0zTja+tEsdRIk/WlPiKqb22NmTOJcR1ZKm/mz46pezyyID3/wRz6vJUELMpSLnG7LhsxBL+nxbr7V0w=="
-      },
       "Speckle.Newtonsoft.Json": {
         "type": "Transitive",
         "resolved": "13.0.2",
         "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
       },
-      "Speckle.Sdk.Logging": {
-        "type": "Transitive",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "rzzJTTlTyeC7O2XOBAGqTrAbd7vk245mXat1v2okqlnEIvoAQj+kiId53v69i+3jv9svoqohkvaWJ2ZD8MkDXA=="
-      },
       "SQLitePCLRaw.bundle_e_sqlite3": {
         "type": "Transitive",
         "resolved": "2.1.4",
@@ -207,6 +199,11 @@
           "SQLitePCLRaw.core": "2.1.4"
         }
       },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
       "System.Memory": {
         "type": "Transitive",
         "resolved": "4.5.3",
@@ -217,25 +214,26 @@
         "resolved": "5.0.0",
         "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
       },
-      "System.Text.Json": {
+      "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
-        "resolved": "5.0.2",
-        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ=="
+        "resolved": "4.5.1",
+        "contentHash": "Zh8t8oqolRaFa9vmOZfdQm/qKejdqz0J9kr7o2Fu0vPeoH3BL1EOXipKWwkWtLT1JPzjByrF19fGuFlNbmPpiw=="
       },
-      "speckle.autofac": {
+      "speckle.connectors.common": {
         "type": "Project",
         "dependencies": {
-          "Autofac": "[5.2.0, )"
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
         }
       },
       "speckle.connectors.dui": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Connectors.Utils": "[1.0.0, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )",
-          "System.Threading.Tasks.Dataflow": "[6.0.0, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
         }
       },
       "speckle.connectors.dui.webview": {
@@ -245,19 +243,14 @@
           "Speckle.Connectors.DUI": "[1.0.0, )"
         }
       },
-      "speckle.connectors.utils": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.Extensions.Logging": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )",
-          "Speckle.Sdk": "[3.0.1-rc.118, )"
-        }
+      "speckle.connectors.logging": {
+        "type": "Project"
       },
-      "speckle.converters.autocad2025": {
+      "speckle.converters.civil3d2025": {
         "type": "Project",
         "dependencies": {
           "Speckle.AutoCAD.API": "[2025.0.0, )",
+          "Speckle.Civil3d.API": "[2025.0.0, )",
           "Speckle.Connectors.DUI.WebView": "[1.0.0, )",
           "Speckle.Converters.Common": "[1.0.0, )"
         }
@@ -265,35 +258,36 @@
       "speckle.converters.common": {
         "type": "Project",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "[3.1.0, )",
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Objects": "[3.0.1-rc.118, )"
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
         }
       },
-      "speckle.converters.common.dependencyinjection": {
-        "type": "Project",
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
         "dependencies": {
-          "Speckle.Autofac": "[1.0.0, )",
-          "Speckle.Converters.Common": "[1.0.0, )"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "P+8sKQ8L4ooL79sxxqwFPxGGC3aBrUDLB/dZqhs4J0XjTyrkeeyJQ4D4nzJB6OnAhy78HIIgQ/RbD6upOXLynw==",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "3.1.0",
-          "Microsoft.Extensions.DependencyInjection": "3.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "3.1.0",
-          "Microsoft.Extensions.Options": "3.1.0"
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions": {
         "type": "CentralTransitive",
-        "requested": "[3.1.0, )",
-        "resolved": "3.1.0",
-        "contentHash": "jjo4YXRx6MIpv6DiRxJjSpl+sPP0+5VW0clMEdLyIAz44PPwrDTFrd5PZckIxIXl1kKZ2KK6IL2nkt0+ug2MQg=="
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
       },
       "Microsoft.Web.WebView2": {
         "type": "CentralTransitive",
@@ -301,44 +295,55 @@
         "resolved": "1.0.1938.49",
         "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       },
-      "Speckle.AutoCAD.API": {
+      "Speckle.DoubleNumerics": {
         "type": "CentralTransitive",
-        "requested": "[2023.0.0, )",
-        "resolved": "2025.0.0",
-        "contentHash": "dqEgZ+bTqAG0tx0WwdnTZcbNKH2igzhOr3SMXtRYai7yIqXiz5btZ4Mf2bmfxbmxLucww3GKVpdZoI+PSZlMuQ=="
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
       },
       "Speckle.Objects": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "5VgLOrOMGsdGqZJwZXjyUrLX+kO+wb6qy0nQgDWuHG+aZdPyGmjyLW3YeaCnDQBu/uDJnQu7ddj5LqbIlTif0w==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
         "dependencies": {
-          "Speckle.Sdk": "3.0.1-rc.118"
+          "Speckle.Sdk": "3.3.5"
         }
       },
       "Speckle.Sdk": {
         "type": "CentralTransitive",
-        "requested": "[3.0.1-rc.118, )",
-        "resolved": "3.0.1-rc.118",
-        "contentHash": "cKiVG0LMRmF4vgTWq2L8xOYoTGiAF9n8OyycmWHCdW6l7wLTre6B4AOWtW9j9NA427C3sJmZ4R9dSbNYRLxDRQ==",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
         "dependencies": {
           "GraphQL.Client": "6.0.0",
           "Microsoft.CSharp": "4.7.0",
-          "Microsoft.Data.Sqlite": "7.0.7",
-          "Polly": "7.2.3",
-          "Polly.Contrib.WaitAndRetry": "1.1.1",
-          "Polly.Extensions.Http": "3.0.0",
-          "Speckle.DoubleNumerics": "4.0.1",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
           "Speckle.Newtonsoft.Json": "13.0.2",
-          "Speckle.Sdk.Logging": "3.0.1-rc.118",
-          "System.Text.Json": "5.0.2"
+          "Speckle.Sdk.Dependencies": "3.3.5"
         }
       },
-      "System.Threading.Tasks.Dataflow": {
+      "Speckle.Sdk.Dependencies": {
         "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "+tyDCU3/B1lDdOOAJywHQoFwyXIUghIaP2BxG79uvhfTnO+D9qIgjVlL/JV2NTliYbMHpd6eKDmHp2VHpij7MA=="
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
+      }
+    },
+    "net8.0-windows7.0/win-x64": {
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
       }
     }
   }

Connectors/Autocad/Speckle.Connectors.Civil3d2026/Speckle.Connectors.Civil3d2026.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <Civil3DVersion>2026</Civil3DVersion>
+    <DefineConstants>$(DefineConstants);CIVIL3D2026;CIVIL3D;CIVIL3D2022_OR_GREATER;CIVIL3D2023_OR_GREATER;CIVIL3D2024_OR_GREATER;CIVIL3D2025_OR_GREATER;CIVIL3D2026_OR_GREATER</DefineConstants>
+    <Configurations>Debug;Release;Local</Configurations>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- .NET Core uses this to move native dependencies into a root for runtime selection and usage for non-windows development https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#enablewindowstargeting -->
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier> <!--This is needed for managed dependencies-->
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> <!--This is needed for the rest-->
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath> <!--This is needed just to keep folder paths the same as the netframework versions of autocad/civil-->
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Speckle.AutoCAD.API" VersionOverride="2026.0.0" ExcludeAssets="runtime"/>
+    <PackageReference Include="Speckle.Civil3d.API" VersionOverride="2026.0.0" ExcludeAssets="runtime"/>
+  </ItemGroup>  
+  
+  <ItemGroup>   
+    <ProjectReference Include="..\..\..\Converters\Civil3d\Speckle.Converters.Civil3d2026\Speckle.Converters.Civil3d2026.csproj" />   
+    <ProjectReference Include="..\..\..\DUI3\Speckle.Connectors.DUI.WebView\Speckle.Connectors.DUI.WebView.csproj" />
+    <ProjectReference Include="..\..\..\Sdk\Speckle.Converters.Common\Speckle.Converters.Common.csproj" />
+  </ItemGroup>
+  
+  <Import Project="..\Speckle.Connectors.Civil3dShared\Speckle.Connectors.Civil3dShared.projitems" Label="Shared" />
+  
+  <Import Project="..\Speckle.Connectors.AutocadShared\Speckle.Connectors.AutocadShared.projitems" Label="Shared" />
+</Project>

Connectors/Autocad/Speckle.Connectors.Civil3d2026/packages.lock.json

@@ -0,0 +1,350 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net8.0-windows7.0": {
+      "Microsoft.NETFramework.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.0.3, )",
+        "resolved": "1.0.3",
+        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
+        "dependencies": {
+          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
+        }
+      },
+      "Microsoft.SourceLink.GitHub": {
+        "type": "Direct",
+        "requested": "[8.0.0, )",
+        "resolved": "8.0.0",
+        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "8.0.0",
+          "Microsoft.SourceLink.Common": "8.0.0"
+        }
+      },
+      "PolySharp": {
+        "type": "Direct",
+        "requested": "[1.14.1, )",
+        "resolved": "1.14.1",
+        "contentHash": "mOOmFYwad3MIOL14VCjj02LljyF1GNw1wP0YVlxtcPvqdxjGGMNdNJJxHptlry3MOd8b40Flm8RPOM8JOlN2sQ=="
+      },
+      "Speckle.AutoCAD.API": {
+        "type": "Direct",
+        "requested": "[2026.0.0, )",
+        "resolved": "2026.0.0",
+        "contentHash": "WlkV81PmbK/ftoM7aGpU6LGosKbePBQej9MO/m63rFMozX89tsitEhE12o58wu7K/4FmRUdAMolYtdK20EDBnw=="
+      },
+      "Speckle.Civil3D.API": {
+        "type": "Direct",
+        "requested": "[2026.0.0, )",
+        "resolved": "2026.0.0",
+        "contentHash": "JcQvKvA3KC+9hzJiWlaZ3REtvqJV+AFHPIU5J6Xp7JHlNyhnaalN37WXpWIKhNAUwL9ppUBOXMZpQupbFytUwg==",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "2026.0.0"
+        }
+      },
+      "Speckle.InterfaceGenerator": {
+        "type": "Direct",
+        "requested": "[0.9.6, )",
+        "resolved": "0.9.6",
+        "contentHash": "HKH7tYrYYlCK1ct483hgxERAdVdMtl7gUKW9ijWXxA1UsYR4Z+TrRHYmzZ9qmpu1NnTycSrp005NYM78GDKV1w=="
+      },
+      "GraphQL.Client": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "8yPNBbuVBpTptivyAlak4GZvbwbUcjeQTL4vN1HKHRuOykZ4r7l5fcLS6vpyPyLn0x8FsL31xbOIKyxbmR9rbA==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0",
+          "GraphQL.Client.Abstractions.Websocket": "6.0.0",
+          "System.Reactive": "5.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "h7uzWFORHZ+CCjwr/ThAyXMr0DPpzEANDa4Uo54wqCQ+j7qUKwqYTgOrb1W40sqbvNaZm9v/X7It31SUw0maHA==",
+        "dependencies": {
+          "GraphQL.Primitives": "6.0.0"
+        }
+      },
+      "GraphQL.Client.Abstractions.Websocket": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "Nr9bPf8gIOvLuXpqEpqr9z9jslYFJOvd0feHth3/kPqeR3uMbjF5pjiwh4jxyMcxHdr8Pb6QiXkV3hsSyt0v7A==",
+        "dependencies": {
+          "GraphQL.Client.Abstractions": "6.0.0"
+        }
+      },
+      "GraphQL.Primitives": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "yg72rrYDapfsIUrul7aF6wwNnTJBOFvuA9VdDTQpPa8AlAriHbufeXYLBcodKjfUdkCnaiggX1U/nEP08Zb5GA=="
+      },
+      "Microsoft.Build.Tasks.Git": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
+      },
+      "Microsoft.CSharp": {
+        "type": "Transitive",
+        "resolved": "4.7.0",
+        "contentHash": "pTj+D3uJWyN3My70i2Hqo+OXixq3Os2D1nJ2x92FFo6sk8fYS1m1WLNTs0Dc1uPaViH0YvEEwvzddQ7y4rhXmA=="
+      },
+      "Microsoft.Data.Sqlite": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "KGxbPeWsQMnmQy43DSBxAFtHz3l2JX8EWBSGUCvT3CuZ8KsuzbkqMIJMDOxWtG8eZSoCDI04aiVQjWuuV8HmSw==",
+        "dependencies": {
+          "Microsoft.Data.Sqlite.Core": "7.0.5",
+          "SQLitePCLRaw.bundle_e_sqlite3": "2.1.4"
+        }
+      },
+      "Microsoft.Data.Sqlite.Core": {
+        "type": "Transitive",
+        "resolved": "7.0.5",
+        "contentHash": "FTerRmQPqHrCrnoUzhBu+E+1DNGwyrAMLqHkAqOOOu5pGfyMOj8qQUBxI/gDtWtG11p49UxSfWmBzRNlwZqfUg==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "Microsoft.Extensions.Configuration": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "nOP8R1mVb/6mZtm2qgAJXn/LFm/2kMjHDAg/QJLFG6CuWYJtaD3p1BwQhufBVvRzL9ceJ/xF0SQ0qsI2GkDQAA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "65MrmXCziWaQFrI0UHkQbesrX5wTwf9XPjY5yFm/VkgJKFJ5gqvXRoXjIZcf2wLi5ZlwGz/oMYfyURVCWbM5iw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "vJ9xvOZCnUAIHcGC3SU35r3HKmHTVIeHzo6u/qzlHAqD8m6xv92MLin4oJntTvkpKxVX3vI1GFFkIQtU3AdlsQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "f9hstgjVmr6rmrfGSpfsVOl2irKAgr1QjrSi3FgnS7kulxband50f2brRLwySAQTADPZeTdow0mpSMcoAdadCw=="
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "UpZLNLBpIZ0GTebShui7xXYh6DmBHjWM8NxGxZbdQh/bPZ5e6YswqI+bru6BnEL5eWiOdodsXtEz3FROcgi/qg==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Primitives": "2.2.0",
+          "System.ComponentModel.Annotations": "4.5.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "2.2.0",
+        "contentHash": "azyQtqbm4fSaDzZHD/J+V6oWMFaf2tWP4WEGIYePLCMw3+b2RQdj9ybgbQyjCshcitQKQ4lEDOZjmSlTTrHxUg==",
+        "dependencies": {
+          "System.Memory": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
+        "type": "Transitive",
+        "resolved": "1.0.3",
+        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
+      },
+      "Microsoft.SourceLink.Common": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
+      },
+      "Speckle.Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.2",
+        "contentHash": "g1BejUZwax5PRfL6xHgLEK23sqHWOgOj9hE7RvfRRlN00AGt8GnPYt8HedSK7UB3HiRW8zCA9Pn0iiYxCK24BA=="
+      },
+      "SQLitePCLRaw.bundle_e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "EWI1olKDjFEBMJu0+3wuxwziIAdWDVMYLhuZ3Qs84rrz+DHwD00RzWPZCa+bLnHCf3oJwuFZIRsHT5p236QXww==",
+        "dependencies": {
+          "SQLitePCLRaw.lib.e_sqlite3": "2.1.4",
+          "SQLitePCLRaw.provider.e_sqlite3": "2.1.4"
+        }
+      },
+      "SQLitePCLRaw.core": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "inBjvSHo9UDKneGNzfUfDjK08JzlcIhn1+SP5Y3m6cgXpCxXKCJDy6Mka7LpgSV+UZmKSnC8rTwB0SQ0xKu5pA==",
+        "dependencies": {
+          "System.Memory": "4.5.3"
+        }
+      },
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "SQLitePCLRaw.provider.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "CSlb5dUp1FMIkez9Iv5EXzpeq7rHryVNqwJMWnpq87j9zWZexaEMdisDktMsnnrzKM6ahNrsTkjqNodTBPBxtQ==",
+        "dependencies": {
+          "SQLitePCLRaw.core": "2.1.4"
+        }
+      },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "UxYQ3FGUOtzJ7LfSdnYSFd7+oEv6M8NgUatatIN2HxNtDdlcvFAf+VIq4Of9cDMJEJC0aSRv/x898RYhB4Yppg=="
+      },
+      "System.Memory": {
+        "type": "Transitive",
+        "resolved": "4.5.3",
+        "contentHash": "3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA=="
+      },
+      "System.Reactive": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "4.5.1",
+        "contentHash": "Zh8t8oqolRaFa9vmOZfdQm/qKejdqz0J9kr7o2Fu0vPeoH3BL1EOXipKWwkWtLT1JPzjByrF19fGuFlNbmPpiw=="
+      },
+      "speckle.connectors.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "[2.2.0, )",
+          "Speckle.Connectors.Logging": "[1.0.0, )",
+          "Speckle.Objects": "[3.3.5, )",
+          "Speckle.Sdk": "[3.3.5, )",
+          "Speckle.Sdk.Dependencies": "[3.3.5, )"
+        }
+      },
+      "speckle.connectors.dui": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Connectors.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.dui.webview": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "[1.0.1938.49, )",
+          "Speckle.Connectors.DUI": "[1.0.0, )"
+        }
+      },
+      "speckle.connectors.logging": {
+        "type": "Project"
+      },
+      "speckle.converters.civil3d2026": {
+        "type": "Project",
+        "dependencies": {
+          "Speckle.AutoCAD.API": "[2026.0.0, )",
+          "Speckle.Civil3d.API": "[2026.0.0, )",
+          "Speckle.Connectors.DUI.WebView": "[1.0.0, )",
+          "Speckle.Converters.Common": "[1.0.0, )"
+        }
+      },
+      "speckle.converters.common": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "[2.2.0, )",
+          "Speckle.Objects": "[3.3.5, )"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "MZtBIwfDFork5vfjpJdG5g8wuJFt7d/y3LOSVVtDK/76wlbtz6cjltfKHqLx2TKVqTj5/c41t77m1+h20zqtPA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "Nxqhadc9FCmFHzU+fz3oc8sFlE6IadViYg8dfUdGzJZ2JUxnCsRghBhhOWdM4B2zSZqEc+0BjliBh/oNdRZuig==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Binder": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Options": "2.2.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[2.2.0, )",
+        "resolved": "2.2.0",
+        "contentHash": "B2WqEox8o+4KUOpL7rZPyh6qYjik8tHi2tN8Z9jZkHzED8ElYgZa/h6K+xliB435SqUcWT290Fr2aa8BtZjn8A=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
+      },
+      "Speckle.DoubleNumerics": {
+        "type": "CentralTransitive",
+        "requested": "[4.1.0, )",
+        "resolved": "4.1.0",
+        "contentHash": "20DtS+FsDRsOD9+AU3TwNFZ0qrKo5f6f7B5ZR9wStsIHHHC9k7DpjbCvuNtmnSjx54MD+TJC7wV2f5iyGVPj1A=="
+      },
+      "Speckle.Objects": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "VPbYI8TyPDlKlNUHPLPAL1HveN9649LKVxw8opgGypoqq0MC5I7WxQjDcuB8xKnQ1PCSO8suu4hEJgdyPcEvWg==",
+        "dependencies": {
+          "Speckle.Sdk": "3.3.5"
+        }
+      },
+      "Speckle.Sdk": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "7r8CmugwinniEF6v0N0bWuC+xpJaRfa/EnEjzj8NLpFG1b3uAjOxteGlQgR+evVacxTCEsuNkio7Mdv97odgpg==",
+        "dependencies": {
+          "GraphQL.Client": "6.0.0",
+          "Microsoft.CSharp": "4.7.0",
+          "Microsoft.Data.Sqlite": "7.0.5",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging": "2.2.0",
+          "Speckle.DoubleNumerics": "4.1.0",
+          "Speckle.Newtonsoft.Json": "13.0.2",
+          "Speckle.Sdk.Dependencies": "3.3.5"
+        }
+      },
+      "Speckle.Sdk.Dependencies": {
+        "type": "CentralTransitive",
+        "requested": "[3.3.5, )",
+        "resolved": "3.3.5",
+        "contentHash": "RukqLb0lVNgtmhKPeZJCncibnyutQ6Dr6+UQCa4PjWinIXpSm3A3ywK9ISkU+5StW1QoejiR7kc9a6qmiLys6w=="
+      }
+    },
+    "net8.0-windows7.0/win-x64": {
+      "SQLitePCLRaw.lib.e_sqlite3": {
+        "type": "Transitive",
+        "resolved": "2.1.4",
+        "contentHash": "2C9Q9eX7CPLveJA0rIhf9RXAvu+7nWZu1A2MdG6SD/NOu26TakGgL1nsbc0JAspGijFOo3HoN79xrx8a368fBg=="
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.1938.49, )",
+        "resolved": "1.0.1938.49",
+        "contentHash": "z8KnFnaTYzhA/ZnyRX0qGfS1NU5ZBJeClAH64F0fVDvdDJTvME7xl6zTJ0Jlfe1BtL3C0NH9xTy64shg2baKdw=="
+      }
+    }
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3dShared/Bindings/Civil3dReceiveBinding.cs

@@ -0,0 +1,60 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.Bindings;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.DUI.Models;
+using Speckle.Converters.Autocad;
+using Speckle.Converters.Civil3dShared;
+using Speckle.Converters.Common;
+using Speckle.Sdk;
+
+namespace Speckle.Connectors.Civil3dShared.Bindings;
+
+public sealed class Civil3dReceiveBinding : AutocadReceiveBaseBinding
+{
+  private readonly ICivil3dConversionSettingsFactory _civil3dConversionSettingsFactory;
+  private readonly IAutocadConversionSettingsFactory _autocadConversionSettingsFactory;
+
+  public Civil3dReceiveBinding(
+    DocumentModelStore store,
+    IBrowserBridge parent,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
+    IOperationProgressManager operationProgressManager,
+    ILogger<AutocadReceiveBinding> logger,
+    ICivil3dConversionSettingsFactory civil3dConversionSettingsFactory,
+    IAutocadConversionSettingsFactory autocadConversionSettingsFactory,
+    ISpeckleApplication speckleApplication,
+    IThreadContext threadContext
+  )
+    : base(
+      store,
+      parent,
+      cancellationManager,
+      serviceProvider,
+      operationProgressManager,
+      logger,
+      speckleApplication,
+      threadContext
+    )
+  {
+    _civil3dConversionSettingsFactory = civil3dConversionSettingsFactory;
+    _autocadConversionSettingsFactory = autocadConversionSettingsFactory;
+  }
+
+  // POC: we're registering the conversion settings for autocad here because we need the autocad conversion settings to be able to use the autocad typed converters.
+  // POC: We need a separate receive binding for civil3d due to using a different unit converter (needed for conversion settings construction)
+  protected override void InitializeSettings(IServiceProvider serviceProvider)
+  {
+    serviceProvider
+      .GetRequiredService<IConverterSettingsStore<Civil3dConversionSettings>>()
+      .Initialize(_civil3dConversionSettingsFactory.Create(Application.DocumentManager.CurrentDocument));
+
+    serviceProvider
+      .GetRequiredService<IConverterSettingsStore<AutocadConversionSettings>>()
+      .Initialize(_autocadConversionSettingsFactory.Create(Application.DocumentManager.CurrentDocument));
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3dShared/Bindings/Civil3dSendBinding.cs

@@ -0,0 +1,70 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.Bindings;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.DUI.Models;
+using Speckle.Connectors.DUI.Models.Card.SendFilter;
+using Speckle.Converters.Autocad;
+using Speckle.Converters.Civil3dShared;
+using Speckle.Converters.Common;
+using Speckle.Sdk;
+
+namespace Speckle.Connectors.Civil3dShared.Bindings;
+
+public sealed class Civil3dSendBinding : AutocadSendBaseBinding
+{
+  private readonly ICivil3dConversionSettingsFactory _civil3dConversionSettingsFactory;
+  private readonly IAutocadConversionSettingsFactory _autocadConversionSettingsFactory;
+
+  public Civil3dSendBinding(
+    DocumentModelStore store,
+    IBrowserBridge parent,
+    IEnumerable<ISendFilter> sendFilters,
+    ICancellationManager cancellationManager,
+    IServiceProvider serviceProvider,
+    ISendConversionCache sendConversionCache,
+    IOperationProgressManager operationProgressManager,
+    ILogger<AutocadSendBinding> logger,
+    ICivil3dConversionSettingsFactory civil3dConversionSettingsFactory,
+    IAutocadConversionSettingsFactory autocadConversionSettingsFactory,
+    ISpeckleApplication speckleApplication,
+    IThreadContext threadContext,
+    ITopLevelExceptionHandler topLevelExceptionHandler,
+    IAppIdleManager appIdleManager
+  )
+    : base(
+      store,
+      parent,
+      sendFilters,
+      cancellationManager,
+      serviceProvider,
+      sendConversionCache,
+      operationProgressManager,
+      logger,
+      speckleApplication,
+      threadContext,
+      topLevelExceptionHandler,
+      appIdleManager
+    )
+  {
+    _civil3dConversionSettingsFactory = civil3dConversionSettingsFactory;
+    _autocadConversionSettingsFactory = autocadConversionSettingsFactory;
+  }
+
+  // POC: we're registering the conversion settings for autocad here because we need the autocad conversion settings to be able to use the autocad typed converters.
+  // POC: We need a separate send binding for civil3d due to using a different unit converter (needed for conversion settings construction)
+  protected override void InitializeSettings(IServiceProvider serviceProvider)
+  {
+    serviceProvider
+      .GetRequiredService<IConverterSettingsStore<Civil3dConversionSettings>>()
+      .Initialize(_civil3dConversionSettingsFactory.Create(Application.DocumentManager.CurrentDocument));
+
+    serviceProvider
+      .GetRequiredService<IConverterSettingsStore<AutocadConversionSettings>>()
+      .Initialize(_autocadConversionSettingsFactory.Create(Application.DocumentManager.CurrentDocument));
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3dShared/DependencyInjection/Civil3dConnectorModule.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Connectors.Autocad.DependencyInjection;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Civil3dShared.Bindings;
+using Speckle.Connectors.Civil3dShared.Operations.Send;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Converters.Civil3dShared.ToSpeckle;
+using Speckle.Sdk;
+
+namespace Speckle.Connectors.Civil3dShared.DependencyInjection;
+
+public static class Civil3dConnectorModule
+{
+  public static void AddCivil3d(this IServiceCollection serviceCollection)
+  {
+    serviceCollection.AddAutocadBase();
+
+    // add send
+    serviceCollection.LoadSend();
+    serviceCollection.AddScoped<IRootObjectBuilder<AutocadRootObject>, Civil3dRootObjectBuilder>();
+    serviceCollection.AddSingleton<IBinding, Civil3dSendBinding>();
+
+    // add receive
+    serviceCollection.LoadReceive();
+    serviceCollection.AddSingleton<IBinding, Civil3dReceiveBinding>();
+
+    // additional classes
+    serviceCollection.AddScoped<PropertySetDefinitionHandler>();
+
+    // automatically detects the Class:IClass interface pattern to register all generated interfaces
+    serviceCollection.AddMatchingInterfacesAsTransient(Assembly.GetExecutingAssembly());
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3dShared/Operations/Send/Civil3dRootObjectBuilder.cs

@@ -0,0 +1,57 @@
+using Autodesk.AutoCAD.DatabaseServices;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Autocad.HostApp;
+using Speckle.Connectors.Autocad.Operations.Send;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Converters.Civil3dShared.ToSpeckle;
+using Speckle.Converters.Common;
+using Speckle.Sdk.Logging;
+using Speckle.Sdk.Models.Collections;
+
+namespace Speckle.Connectors.Civil3dShared.Operations.Send;
+
+public sealed class Civil3dRootObjectBuilder : AutocadRootObjectBaseBuilder
+{
+  private readonly AutocadLayerUnpacker _layerUnpacker;
+  private readonly PropertySetDefinitionHandler _propertySetDefinitionHandler;
+
+  public Civil3dRootObjectBuilder(
+    AutocadLayerUnpacker layerUnpacker,
+    PropertySetDefinitionHandler propertySetDefinitionHandler,
+    IRootToSpeckleConverter converter,
+    ISendConversionCache sendConversionCache,
+    AutocadInstanceUnpacker instanceObjectManager,
+    AutocadMaterialUnpacker materialUnpacker,
+    AutocadColorUnpacker colorUnpacker,
+    AutocadGroupUnpacker groupUnpacker,
+    ILogger<AutocadRootObjectBuilder> logger,
+    ISdkActivityFactory activityFactory
+  )
+    : base(
+      converter,
+      sendConversionCache,
+      instanceObjectManager,
+      materialUnpacker,
+      colorUnpacker,
+      groupUnpacker,
+      logger,
+      activityFactory
+    )
+  {
+    _layerUnpacker = layerUnpacker;
+    _propertySetDefinitionHandler = propertySetDefinitionHandler;
+  }
+
+  public override (Collection, LayerTableRecord?) CreateObjectCollection(Entity entity, Transaction tr)
+  {
+    Layer layer = _layerUnpacker.GetOrCreateSpeckleLayer(entity, tr, out LayerTableRecord? autocadLayer);
+
+    return (layer, autocadLayer);
+  }
+
+  public override void AddAdditionalProxiesToRoot(Collection rootObject)
+  {
+    rootObject[ProxyKeys.PROPERTYSET_DEFINITIONS] = _propertySetDefinitionHandler.Definitions;
+  }
+}

Connectors/Autocad/Speckle.Connectors.Civil3dShared/Speckle.Connectors.Civil3dShared.projitems

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>55E65D72-2FE8-4E61-891C-16A4D551CCF7</SharedGUID>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>Speckle.Connectors.Civil3dShared</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Bindings\Civil3dReceiveBinding.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)DependencyInjection\Civil3dConnectorModule.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Operations\Send\Civil3dRootObjectBuilder.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Bindings\Civil3dSendBinding.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="$(MSBuildThisFileDirectory)DependencyInjection\" />
+    <Folder Include="$(MSBuildThisFileDirectory)Operations\Send\" />
+  </ItemGroup>
+</Project>

Connectors/Autocad/Speckle.Connectors.Civil3dShared/Speckle.Connectors.Civil3dShared.shproj

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EFD01520-93E8-4CCA-8E03-9CDC635F55F4}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
+  <Import Project="Speckle.Connectors.Civil3dShared.projitems" Label="Shared" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
+</Project>

Connectors/CSi/Speckle.Connectors.CSiShared/Bindings/CsiSharedBasicConnectorBinding.cs

@@ -0,0 +1,74 @@
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.DUI.Models;
+using Speckle.Connectors.DUI.Models.Card;
+using Speckle.Sdk;
+
+namespace Speckle.Connectors.CSiShared.Bindings;
+
+public class CsiSharedBasicConnectorBinding : IBasicConnectorBinding
+{
+  private readonly ISpeckleApplication _speckleApplication;
+  private readonly DocumentModelStore _store;
+  private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
+  private readonly IThreadContext _threadContext;
+  public string Name => "baseBinding";
+  public IBrowserBridge Parent { get; }
+  public BasicConnectorBindingCommands Commands { get; }
+
+  public CsiSharedBasicConnectorBinding(
+    IBrowserBridge parent,
+    ISpeckleApplication speckleApplication,
+    DocumentModelStore store,
+    ITopLevelExceptionHandler topLevelExceptionHandler,
+    IThreadContext threadContext
+  )
+  {
+    _threadContext = threadContext;
+    Parent = parent;
+    _speckleApplication = speckleApplication;
+    _store = store;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
+    Commands = new BasicConnectorBindingCommands(Parent);
+
+    _store.DocumentChanged += (_, _) =>
+      _topLevelExceptionHandler.FireAndForget(async () =>
+      {
+        // enforce main thread
+        await _threadContext.RunOnMainAsync(async () =>
+        {
+          await Commands.NotifyDocumentChanged();
+        });
+      });
+  }
+
+  public string GetConnectorVersion() => _speckleApplication.SpeckleVersion;
+
+  public string GetSourceApplicationName() => _speckleApplication.Slug;
+
+  public string GetSourceApplicationVersion() => _speckleApplication.HostApplicationVersion;
+
+  public DocumentInfo? GetDocumentInfo() => new("ETABS Model", "ETABS Model", "1");
+
+  public DocumentModelStore GetDocumentState() => _store;
+
+  /// <remarks>Operations must run on the main thread for ETABS and SAP 2000</remarks>
+  public void AddModel(ModelCard model) =>
+    _topLevelExceptionHandler.CatchUnhandled(() => _threadContext.RunOnThread(() => _store.AddModel(model), true));
+
+  /// <remarks>Operations must run on the main thread for ETABS and SAP 2000</remarks>
+  public void UpdateModel(ModelCard model) =>
+    _topLevelExceptionHandler.CatchUnhandled(() => _threadContext.RunOnThread(() => _store.UpdateModel(model), true));
+
+  /// <remarks>Operations must run on the main thread for ETABS and SAP 2000</remarks>
+  public void RemoveModel(ModelCard model) =>
+    _topLevelExceptionHandler.CatchUnhandled(() => _threadContext.RunOnThread(() => _store.RemoveModel(model), true));
+
+  public void RemoveModels(List<ModelCard> models) =>
+    _topLevelExceptionHandler.CatchUnhandled(() => _threadContext.RunOnThread(() => _store.RemoveModels(models), true));
+
+  public Task HighlightModel(string modelCardId) => Task.CompletedTask;
+
+  public Task HighlightObjects(IReadOnlyList<string> objectIds) => Task.CompletedTask;
+}

Connectors/CSi/Speckle.Connectors.CSiShared/Bindings/CsiSharedSelectionBinding.cs

@@ -0,0 +1,108 @@
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.CSiShared.HostApp;
+using Speckle.Connectors.CSiShared.Utils;
+using Speckle.Connectors.DUI.Bindings;
+using Speckle.Connectors.DUI.Bridge;
+using Speckle.Converters.CSiShared.Utils;
+using Timer = System.Timers.Timer;
+
+namespace Speckle.Connectors.CSiShared.Bindings;
+
+public class CsiSharedSelectionBinding : ISelectionBinding, IDisposable
+{
+  private bool _disposed;
+  private readonly Timer _selectionTimer;
+  private readonly ICsiApplicationService _csiApplicationService;
+  private readonly IThreadContext _threadContext;
+  private HashSet<string> _lastSelection = new();
+  private readonly ITopLevelExceptionHandler _topLevelExceptionHandler;
+
+  public IBrowserBridge Parent { get; }
+  public string Name => "selectionBinding";
+
+  public CsiSharedSelectionBinding(
+    IBrowserBridge parent,
+    ICsiApplicationService csiApplicationService,
+    ITopLevelExceptionHandler topLevelExceptionHandler,
+    IThreadContext threadContext
+  )
+  {
+    _threadContext = threadContext;
+    Parent = parent;
+    _csiApplicationService = csiApplicationService;
+    _topLevelExceptionHandler = topLevelExceptionHandler;
+
+    _selectionTimer = new Timer(1000);
+    _selectionTimer.Elapsed += (_, _) =>
+      _topLevelExceptionHandler.CatchUnhandled(() => _threadContext.RunOnMain(CheckSelectionChanged));
+    _selectionTimer.Start();
+  }
+
+  private void CheckSelectionChanged()
+  {
+    // timer callbacks are on a background thread, but CSI API calls must be on main thread
+    var currentSelection = GetSelection();
+    var currentIds = new HashSet<string>(currentSelection.SelectedObjectIds);
+
+    if (!_lastSelection.SetEquals(currentIds))
+    {
+      _lastSelection = currentIds;
+      // ensure UI updates also run on main thread
+      _threadContext.RunOnMain(
+        () =>
+          _topLevelExceptionHandler.CatchUnhandled(
+            () => Parent.Send(SelectionBindingEvents.SET_SELECTION, currentSelection)
+          )
+      );
+    }
+  }
+
+  protected virtual void Dispose(bool disposing)
+  {
+    if (!_disposed)
+    {
+      if (disposing)
+      {
+        _selectionTimer?.Dispose();
+      }
+      _disposed = true;
+    }
+  }
+
+  public void Dispose()
+  {
+    Dispose(true);
+    GC.SuppressFinalize(this);
+  }
+
+  /// <summary>
+  /// Gets the selection and creates an encoded ID (objectType and objectName).
+  /// </summary>
+  /// <remarks>
+  /// Refer to ObjectIdentifier.cs for more info.
+  /// </remarks>
+  public SelectionInfo GetSelection()
+  {
+    int numberItems = 0;
+    int[] objectType = [];
+    string[] objectName = [];
+
+    _csiApplicationService.SapModel.SelectObj.GetSelected(ref numberItems, ref objectType, ref objectName);
+
+    var encodedIds = new List<string>(numberItems);
+    var typeCounts = new Dictionary<string, int>();
+    for (int i = 0; i < numberItems; i++)
+    {
+      var typeKey = (ModelObjectType)objectType[i];
+      var typeName = typeKey.ToString();
+      encodedIds.Add(ObjectIdentifier.Encode(objectType[i], objectName[i]));
+      typeCounts[typeName] = (typeCounts.TryGetValue(typeName, out var count) ? count : 0) + 1; // NOTE: Cross-framework compatibility (net 48 and net8)
+    }
+    var summary =
+      encodedIds.Count == 0
+        ? "No objects selected."
+        : $"{encodedIds.Count} objects ({string.Join(", ", 
+            typeCounts.Select(kv => $"{kv.Value} {kv.Key}"))})";
+    return new SelectionInfo(encodedIds, summary);
+  }
+}