Add COM error handling to fragment ID generation

Co-authored-by: jsdbroughton <760691+jsdbroughton@users.noreply.github.com>

Connectors/Navisworks/Directory.Build.targets

@@ -2,33 +2,63 @@
 <Project>
   <PropertyGroup>
     <UseWpf>true</UseWpf>
-
     <Description>NextGen Speckle Connector for Autodesk Navisworks Manage</Description>
     <Authors>$(Authors) jonathon@speckle.systems</Authors>
     <PackageTags>$(PackageTags) connector nwd nwc nwf navisworks manage</PackageTags>
 
     <PluginBundleTarget>$(AppData)\Autodesk\ApplicationPlugins\Speckle.Connectors.Navisworks.bundle</PluginBundleTarget>
-    <PluginVersionContentTarget>$(AppData)\Autodesk\ApplicationPlugins\Speckle.Connectors.Navisworks.bundle\Contents\$(NavisworksVersion)</PluginVersionContentTarget>
+    <PluginVersionContentTarget>$(PluginBundleTarget)\Contents\$(NavisworksVersion)</PluginVersionContentTarget>
     <RootNamespace>Speckle.Connector.Navisworks</RootNamespace>
   </PropertyGroup>
 
-  <!-- Post Builds -->
-  <ItemGroup>
-    <RibbonFiles Include="$(OutDir)Plugin\NavisworksRibbon.*"/>
-    <ResourceFiles Include="$(OutDir)Resources\**\*.png"/>
-    <ResourceFiles Include="$(OutDir)Resources\**\*.ico"/>
-    <AllFiles Include="$(OutDir)*"/>
-  </ItemGroup>
+  <Target Name="PostBuild"
+          AfterTargets="Build"
+          Condition="'$(OS)' == 'Windows_NT' and '$(NavisworksVersion)' != ''">
 
-
-  <Target Name="PostBuild" AfterTargets="Build" Condition="'$(NavisworksVersion)' != '' And '$(ContinuousIntegrationBuild)' != 'true' And '$(OS)' == 'Windows_NT'">
     <Message Text="Navisworks Version $(NavisworksVersion)" Importance="high"/>
+
     <RemoveDir Directories="$(PluginVersionContentTarget)" Condition="Exists('$(PluginVersionContentTarget)')"/>
-  
-    <Copy SourceFiles="$(OutDir)Plugin\PackageContents.xml" DestinationFolder="$(PluginBundleTarget)\"/>
-    <Copy SourceFiles="@(RibbonFiles)" DestinationFolder="$(PluginVersionContentTarget)\en-US\"/>
-    <Copy SourceFiles="@(ResourceFiles)" DestinationFolder="$(PluginVersionContentTarget)\Resources\"/>
-  
-    <Copy SourceFiles="@(AllFiles)" DestinationFolder="$(PluginVersionContentTarget)\" />
+
+    <MakeDir Directories="
+      $(PluginBundleTarget);
+      $(PluginBundleTarget)\Contents;
+      $(PluginVersionContentTarget);
+      $(PluginVersionContentTarget)\en-US;
+      $(PluginVersionContentTarget)\Resources"/>
+
+    <!-- Re-evaluate outputs at execution time -->
+    <ItemGroup>
+      <PackageXml Include="$(OutDir)Plugin\PackageContents.xml"/>
+      <RibbonFiles Include="$(OutDir)Plugin\NavisworksRibbon.*"/>
+      <ResourceFiles Include="$(OutDir)Resources\**\*.png;$(OutDir)Resources\**\*.ico"/>
+      <AllFiles Include="$(OutDir)**\*.*"/>
+
+      <Message Text="AllFiles count: @(AllFiles->Count())" Importance="high"/>
+      <Warning Condition="'@(AllFiles)' == ''" Text="No files in $(OutDir) at PostBuild time."/>
+
+    </ItemGroup>
+
+    <Copy SourceFiles="@(PackageXml)"
+          DestinationFolder="$(PluginBundleTarget)\"
+          SkipUnchangedFiles="true"/>
+
+    <Copy SourceFiles="@(RibbonFiles)"
+          DestinationFolder="$(PluginVersionContentTarget)\en-US\"
+          SkipUnchangedFiles="true"/>
+
+    <Copy SourceFiles="@(ResourceFiles)"
+          DestinationFiles="@(ResourceFiles->'$(PluginVersionContentTarget)\Resources\%(RecursiveDir)%(Filename)%(Extension)')"
+          SkipUnchangedFiles="true"/>
+
+    <Copy SourceFiles="@(AllFiles)"
+          DestinationFiles="@(AllFiles->'$(PluginVersionContentTarget)\%(RecursiveDir)%(Filename)%(Extension)')"
+          SkipUnchangedFiles="true"/>
+
+    <Message Text="Copied build to $(PluginVersionContentTarget)" Importance="high"/>
+  </Target>
+
+  <Target Name="ValidateNavisworksVersion" BeforeTargets="PostBuild"
+          Condition="'$(NavisworksVersion)' == '' and '$(OS)' == 'Windows_NT'">
+    <Error Text="NavisworksVersion property is required for PostBuild packaging."/>
   </Target>
 </Project>

Connectors/Navisworks/Speckle.Connectors.NavisworksShared/DependencyInjection/NavisworksConnectorServiceRegistration.cs

@@ -15,6 +15,7 @@ using Speckle.Connectors.DUI.Bridge;
 using Speckle.Connectors.DUI.Models;
 using Speckle.Connectors.DUI.Models.Card.SendFilter;
 using Speckle.Connectors.DUI.WebView;
+using Speckle.Converter.Navisworks.Services;
 using Speckle.Converter.Navisworks.Settings;
 using Speckle.Converters.Common;
 using Speckle.Sdk.Models.GraphTraversal;
@@ -52,6 +53,9 @@ public static class NavisworksConnectorServiceRegistration
     serviceCollection.AddScoped<NavisworksMaterialUnpacker>();
     serviceCollection.AddScoped<NavisworksColorUnpacker>();
 
+    // Register dual shared geometry stores for instancing pattern
+    serviceCollection.AddScoped<InstanceStoreManager>();
+
     serviceCollection.AddSingleton<IAppIdleManager, NavisworksIdleManager>();
 
     // Sending operations

Connectors/Navisworks/Speckle.Connectors.NavisworksShared/HostApp/NavisworksColorUnpacker.cs

@@ -16,7 +16,8 @@ public class NavisworksColorUnpacker(
   IElementSelectionService selectionService
 )
 {
-  private static T Select<T>(RepresentationMode mode, T active, T permanent, T original, T defaultValue) =>
+  private static T SelectByRepresentationMode<T>(
+    RepresentationMode mode, T active, T permanent, T original, T defaultValue) =>
     mode switch
     {
       RepresentationMode.Active => active,
@@ -71,14 +72,14 @@ public class NavisworksColorUnpacker(
 
         using var defaultColor = new NAV.Color(1.0, 1.0, 1.0);
 
-        var representationColor = Select(
+        var representationColor = SelectByRepresentationMode(
           mode,
           geometry.ActiveColor,
           geometry.PermanentColor,
           geometry.OriginalColor,
           defaultColor
         );
-        var colorId = Select(
+        var colorId = SelectByRepresentationMode(
           mode,
           $"{geometry.ActiveColor.GetHashCode()}_{geometry.ActiveTransparency}".GetHashCode(),
           $"{geometry.PermanentColor.GetHashCode()}_{geometry.PermanentTransparency}".GetHashCode(),
@@ -124,30 +125,49 @@ public class NavisworksColorUnpacker(
     var comSelection = ComBridge.ToInwOpSelection([modelItem]);
     try
     {
-      foreach (ComApi.InwOaPath path in comSelection.Paths())
+      var pathsCollection = comSelection.Paths();
+      try
       {
-        GC.KeepAlive(path);
-
-        foreach (ComApi.InwOaFragment3 fragment in path.Fragments())
+        foreach (ComApi.InwOaPath path in pathsCollection)
         {
-          GC.KeepAlive(fragment);
-
-          fragment.GenerateSimplePrimitives(ComApi.nwEVertexProperty.eNORMAL, primitiveChecker);
-
-          // Exit early if triangles are found
-          if (primitiveChecker.HasTriangles)
+          var fragmentsCollection = path.Fragments();
+          try
           {
-            return false;
+            foreach (ComApi.InwOaFragment3 fragment in fragmentsCollection.OfType<ComApi.InwOaFragment3>())
+            {
+              fragment.GenerateSimplePrimitives(ComApi.nwEVertexProperty.eNORMAL, primitiveChecker);
+
+              if (primitiveChecker.HasTriangles)
+              {
+                return false;
+              }
+            }
+          }
+          finally
+          {
+            if (fragmentsCollection != null)
+            {
+              System.Runtime.InteropServices.Marshal.ReleaseComObject(fragmentsCollection);
+            }
           }
         }
-      }
 
-      // Return true if any 2D primitives are found
-      return primitiveChecker.HasLines || primitiveChecker.HasPoints || primitiveChecker.HasSnapPoints;
+        return primitiveChecker.HasLines || primitiveChecker.HasPoints || primitiveChecker.HasSnapPoints;
+      }
+      finally
+      {
+        if (pathsCollection != null)
+        {
+          System.Runtime.InteropServices.Marshal.ReleaseComObject(pathsCollection);
+        }
+      }
     }
     finally
     {
-      System.Runtime.InteropServices.Marshal.ReleaseComObject(comSelection);
+      if (comSelection != null)
+      {
+        System.Runtime.InteropServices.Marshal.ReleaseComObject(comSelection);
+      }
     }
   }
 }

Connectors/Navisworks/Speckle.Connectors.NavisworksShared/HostApp/NavisworksMaterialUnpacker.cs

@@ -1,7 +1,11 @@
+using Autodesk.Navisworks.Api.ComApi;
+using Autodesk.Navisworks.Api.Interop.ComApi;
 using Microsoft.Extensions.Logging;
 using Speckle.Connector.Navisworks.Services;
+using Speckle.Converter.Navisworks.Constants;
 using Speckle.Converter.Navisworks.Helpers;
 using Speckle.Converter.Navisworks.Settings;
+using Speckle.Converter.Navisworks.ToSpeckle;
 using Speckle.Converters.Common;
 using Speckle.Objects.Other;
 using Speckle.Sdk;
@@ -11,12 +15,12 @@ namespace Speckle.Connector.Navisworks.HostApp;
 public class NavisworksMaterialUnpacker(
   ILogger<NavisworksMaterialUnpacker> logger,
   IConverterSettingsStore<NavisworksConversionSettings> converterSettings,
-  IElementSelectionService selectionService
+  IElementSelectionService selectionService,
+  GeometryToSpeckleConverter converter
 )
 {
-  // Helper function to select a property based on the representation mode
-  // Selector method for individual properties
-  private static T Select<T>(RepresentationMode mode, T active, T permanent, T original, T defaultValue) =>
+  private static T SelectByRepresentationMode<T>(
+    RepresentationMode mode, T active, T permanent, T original, T defaultValue) =>
     mode switch
     {
       RepresentationMode.Active => active,
@@ -64,26 +68,84 @@ public class NavisworksMaterialUnpacker(
 
         var navisworksObjectId = selectionService.GetModelItemPath(navisworksObject);
         var finalId = mergedIds.TryGetValue(navisworksObjectId, out var mergedId) ? mergedId : navisworksObjectId;
+
+        string hashId = "";
+        try
+        {
+          var item = selectionService.GetModelItemFromPath(finalId);
+          var comSelection = ComApiBridge.ToInwOpSelection([item]);
+          try
+          {
+            var paths = comSelection.Paths();
+            try
+            {
+              if (paths.Count > 0)
+              {
+                var firstPath = paths.OfType<InwOaPath>().FirstOrDefault();
+                if (firstPath != null)
+                {
+                  var fragments = firstPath.Fragments();
+                  try
+                  {
+                    if (fragments.Count > 1)
+                    {
+                      var fragmentId = converter.GenerateFragmentId(paths);
+                      hashId = $"{InstanceConstants.GEOMETRY_ID_PREFIX}{fragmentId}";
+                    }
+                  }
+                  finally
+                  {
+                    if (fragments != null)
+                    {
+                      System.Runtime.InteropServices.Marshal.ReleaseComObject(fragments);
+                    }
+                  }
+                }
+              }
+            }
+            finally
+            {
+              if (paths != null)
+              {
+                System.Runtime.InteropServices.Marshal.ReleaseComObject(paths);
+              }
+            }
+          }
+          finally
+          {
+            if (comSelection != null)
+            {
+              System.Runtime.InteropServices.Marshal.ReleaseComObject(comSelection);
+            }
+          }
+        }
+        catch (Exception ex) when (!ex.IsFatal())
+        {
+          // If COM interop fails during hash generation, fall back to using finalId
+          logger.LogWarning(ex, "Failed to generate fragment hash ID for item {ItemId}, using finalId as fallback", finalId);
+          hashId = "";
+        }
+
         var geometry = navisworksObject.Geometry;
         var mode = converterSettings.Current.User.VisualRepresentationMode;
 
         using var defaultColor = new NAV.Color(1.0, 1.0, 1.0);
 
-        var renderColor = Select(
+        var renderColor = SelectByRepresentationMode(
           mode,
           geometry.ActiveColor,
           geometry.PermanentColor,
           geometry.OriginalColor,
           defaultColor
         );
-        var renderTransparency = Select(
+        var renderTransparency = SelectByRepresentationMode(
           mode,
           geometry.ActiveTransparency,
           geometry.PermanentTransparency,
           geometry.OriginalTransparency,
           0.0
         );
-        var renderMaterialId = Select(
+        var renderMaterialId = SelectByRepresentationMode(
           mode,
           $"{geometry.ActiveColor.GetHashCode()}_{geometry.ActiveTransparency}".GetHashCode(),
           $"{geometry.PermanentColor.GetHashCode()}_{geometry.PermanentTransparency}".GetHashCode(),
@@ -92,9 +154,8 @@ public class NavisworksMaterialUnpacker(
         );
 
         var materialName =
-          $"NavisworksMaterial_{Math.Abs(ColorConverter.NavisworksColorToColor(renderColor).ToArgb())}";
+          $"{MaterialConstants.DEFAULT_MATERIAL_NAME_PREFIX}{Math.Abs(ColorConverter.NavisworksColorToColor(renderColor).ToArgb())}";
 
-        // Check Item category for material name
         var itemCategory = navisworksObject.PropertyCategories.FindCategoryByDisplayName("Item");
         if (itemCategory != null)
         {
@@ -106,7 +167,6 @@ public class NavisworksMaterialUnpacker(
           }
         }
 
-        // Check Material category for material name
         var materialPropertyCategory = navisworksObject.PropertyCategories.FindCategoryByDisplayName("Material");
         if (materialPropertyCategory != null)
         {
@@ -120,19 +180,19 @@ public class NavisworksMaterialUnpacker(
 
         if (renderMaterialProxies.TryGetValue(renderMaterialId.ToString(), out RenderMaterialProxy? value))
         {
-          value.objects.Add(finalId);
+          value.objects.Add(!string.IsNullOrEmpty(hashId) ? hashId : finalId);
         }
         else
         {
           renderMaterialProxies[renderMaterialId.ToString()] = new RenderMaterialProxy()
           {
-            value = ConvertRenderColorAndTransparencyToSpeckle(
+            value = CreateRenderMaterial(
               materialName,
               renderTransparency,
               renderColor,
               renderMaterialId
             ),
-            objects = [finalId]
+            objects = [!string.IsNullOrEmpty(hashId) ? hashId : finalId]
           };
         }
       }
@@ -145,7 +205,7 @@ public class NavisworksMaterialUnpacker(
     return renderMaterialProxies.Values.ToList();
   }
 
-  private static RenderMaterial ConvertRenderColorAndTransparencyToSpeckle(
+  private static RenderMaterial CreateRenderMaterial(
     string name,
     double transparency,
     NAV.Color navisworksColor,
@@ -156,7 +216,7 @@ public class NavisworksMaterialUnpacker(
 
     var speckleRenderMaterial = new RenderMaterial()
     {
-      name = !string.IsNullOrEmpty(name) ? name : $"NavisworksMaterial_{Math.Abs(color.ToArgb())}",
+      name = !string.IsNullOrEmpty(name) ? name : $"{MaterialConstants.DEFAULT_MATERIAL_NAME_PREFIX}{Math.Abs(color.ToArgb())}",
       opacity = 1 - transparency,
       metalness = 0,
       roughness = 1,

Connectors/Navisworks/Speckle.Connectors.NavisworksShared/Operations/Send/NavisworksRootObjectBuilder.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using Speckle.Connector.Navisworks.HostApp;
 using Speckle.Connector.Navisworks.Services;
 using Speckle.Connectors.Common.Builders;
@@ -6,6 +6,7 @@ using Speckle.Connectors.Common.Caching;
 using Speckle.Connectors.Common.Conversion;
 using Speckle.Connectors.Common.Operations;
 using Speckle.Converter.Navisworks.Helpers;
+using Speckle.Converter.Navisworks.Services;
 using Speckle.Converter.Navisworks.Settings;
 using Speckle.Converters.Common;
 using Speckle.Objects.Data;
@@ -25,7 +26,8 @@ public class NavisworksRootObjectBuilder(
   ISdkActivityFactory activityFactory,
   NavisworksMaterialUnpacker materialUnpacker,
   NavisworksColorUnpacker colorUnpacker,
-  IElementSelectionService elementSelectionService
+  IElementSelectionService elementSelectionService,
+  InstanceStoreManager instanceStoreManager
 ) : IRootObjectBuilder<NAV.ModelItem>
 {
   private bool SkipNodeMerging { get; set; }
@@ -40,32 +42,45 @@ public class NavisworksRootObjectBuilder(
   )
   {
 #if DEBUG
-    // This is a temporary workaround to disable node merging for debugging purposes - false is default, true is for debugging
-    SkipNodeMerging = false;
+    SkipNodeMerging = true;
 #endif
     using var activity = activityFactory.Start("Build");
 
     ValidateInputs(navisworksModelItems, projectId, onOperationProgressed);
 
-    // 2. Initialize root collection
     var rootCollection = InitializeRootCollection();
 
-    // 3. Convert all model items and store results
-    var (convertedElements, conversionResults) = await ConvertModelItemsAsync(
-      navisworksModelItems,
-      projectId,
-      onOperationProgressed,
-      cancellationToken
-    );
+    (Dictionary<string, Base?> convertedElements, List<SendConversionResult> conversionResults) =
+      await ConvertModelItemsAsync(navisworksModelItems, projectId, onOperationProgressed, cancellationToken);
 
     ValidateConversionResults(conversionResults);
 
     var groupedNodes = SkipNodeMerging ? [] : GroupSiblingGeometryNodes(navisworksModelItems);
     var finalElements = BuildFinalElements(convertedElements, groupedNodes);
+    List<Base> geometryDefinitions = instanceStoreManager.GetGeometryDefinitions();
 
     await AddProxiesToCollection(rootCollection, navisworksModelItems, groupedNodes);
 
-    rootCollection.elements = finalElements;
+    var geometryDefinitionsCollection = new Collection
+    {
+      name = "Geometry Definitions",
+      ["units"] = converterSettings.Current.Derived.SpeckleUnits,
+      elements = geometryDefinitions
+    };
+
+    var mainElementsCollection = new Collection
+    {
+      name = rootCollection.name,
+      ["units"] = converterSettings.Current.Derived.SpeckleUnits,
+      elements = finalElements
+    };
+
+    rootCollection.elements = [mainElementsCollection];
+    if (geometryDefinitions.Count > 0)
+    {
+      rootCollection.elements.Add(geometryDefinitionsCollection);
+    }
+
     return new RootObjectBuilderResult(rootCollection, conversionResults);
   }
 
@@ -137,12 +152,10 @@ public class NavisworksRootObjectBuilder(
     Dictionary<string, List<NAV.ModelItem>> groupedNodes
   )
   {
-    // First build the grouped nodes as before
     var finalElements = new List<Base>();
     var processedPaths = new HashSet<string>();
     AddGroupedElements(finalElements, convertedBases, groupedNodes, processedPaths);
 
-    // If hierarchy mode is enabled, reorganize into proper nested structure
     if (converterSettings.Current.User.PreserveModelHierarchy)
     {
       var hierarchyBuilder = new NavisworksHierarchyBuilder(
@@ -151,12 +164,9 @@ public class NavisworksRootObjectBuilder(
         elementSelectionService
       );
 
-      var hierarchy = hierarchyBuilder.BuildHierarchy();
-
-      return hierarchy;
+      return hierarchyBuilder.BuildHierarchy();
     }
 
-    // Otherwise continue with flat mode
     AddRemainingElements(finalElements, convertedBases, processedPaths);
     return finalElements;
   }
@@ -213,24 +223,17 @@ public class NavisworksRootObjectBuilder(
     }
   }
 
-  private (string name, string path) GetContext(string applicationId)
+  private (string name, string path) GetElementNameAndPath(string applicationId)
   {
     var modelItem = elementSelectionService.GetModelItemFromPath(applicationId);
     var context = HierarchyHelper.ExtractContext(modelItem);
     return (context.Name, context.Path);
   }
 
-  /// <summary>
-  /// Processes and adds any remaining non-grouped elements.
-  /// </summary>
-  /// <remarks>
-  /// Handles both Collection and Base type elements differently.
-  /// Only processes elements that weren't handled in grouped processing.
-  /// </remarks>
   private NavisworksObject CreateNavisworksObject(string groupKey, List<Base> siblingBases)
   {
     string cleanParentPath = ElementSelectionHelper.GetCleanPath(groupKey);
-    (string name, string path) = GetContext(cleanParentPath);
+    (string name, string path) = GetElementNameAndPath(cleanParentPath);
 
     return new NavisworksObject
     {
@@ -238,16 +241,11 @@ public class NavisworksRootObjectBuilder(
       displayValue = siblingBases.SelectMany(b => b["displayValue"] as List<Base> ?? []).ToList(),
       properties = siblingBases.First()["properties"] as Dictionary<string, object?> ?? [],
       units = converterSettings.Current.Derived.SpeckleUnits,
-      applicationId = groupKey, // Use the full composite key as applicationId to preserve uniqueness
+      applicationId = groupKey,
       ["path"] = path
     };
   }
 
-  /// <summary>
-  /// Creates a NavisworksObject from a single converted base.
-  /// </summary>
-  /// <param name="convertedBase">The converted Speckle Base object.</param>
-  /// <returns>A new NavisworksObject containing the converted data.</returns>
   private NavisworksObject? CreateNavisworksObject(Base convertedBase)
   {
     if (convertedBase.applicationId == null)
@@ -255,7 +253,7 @@ public class NavisworksRootObjectBuilder(
       return null;
     }
 
-    (string name, string path) = GetContext(convertedBase.applicationId);
+    (string name, string path) = GetElementNameAndPath(convertedBase.applicationId);
 
     return new NavisworksObject
     {
@@ -288,18 +286,16 @@ public class NavisworksRootObjectBuilder(
       rootCollection[ProxyKeys.COLOR] = colors;
     }
 
+    var instanceDefinitionProxies = instanceStoreManager.GetInstanceDefinitionProxies();
+
+    if (instanceDefinitionProxies.Count > 0)
+    {
+      rootCollection[ProxyKeys.INSTANCE_DEFINITION] = instanceDefinitionProxies.ToList();
+    }
+
     return Task.CompletedTask;
   }
 
-  /// <summary>
-  /// Converts a single Navisworks item to a Speckle object.
-  /// </summary>
-  /// <remarks>
-  /// Attempts to retrieve from cache first.
-  /// Falls back to fresh conversion if not cached.
-  /// Logs errors but doesn't throw exceptions.
-  /// </remarks>
-  /// <returns>A SendConversionResult indicating success or failure.</returns>
   private SendConversionResult ConvertNavisworksItem(
     NAV.ModelItem navisworksItem,
     Dictionary<string, Base?> convertedBases,

Converters/Navisworks/Speckle.Converters.NavisworksShared/DataExtractors/DisplayValueExtractor.cs

@@ -1,38 +1,19 @@
-using Microsoft.Extensions.Logging;
-using Speckle.Converter.Navisworks.Settings;
-using Speckle.Converters.Common;
-using Speckle.Sdk.Models;
+using Speckle.Sdk.Models;
 using static Speckle.Converter.Navisworks.Helpers.ElementSelectionHelper;
 
 namespace Speckle.Converter.Navisworks.ToSpeckle;
 
-public class DisplayValueExtractor
+public class DisplayValueExtractor(GeometryToSpeckleConverter geometryConverter)
 {
-  private readonly IConverterSettingsStore<NavisworksConversionSettings> _converterSettings;
-  private readonly ILogger<DisplayValueExtractor> _logger;
-  private readonly GeometryToSpeckleConverter _geometryConverter;
-
-  public DisplayValueExtractor(
-    IConverterSettingsStore<NavisworksConversionSettings> converterSettings,
-    ILogger<DisplayValueExtractor> logger
-  )
-  {
-    _converterSettings = converterSettings;
-    _logger = logger;
-    _geometryConverter = new GeometryToSpeckleConverter(_converterSettings.Current);
-  }
-
-  internal List<Base> GetDisplayValue(NAV.ModelItem modelItem)
-  {
-    if (modelItem == null)
-    {
-      throw new ArgumentNullException(nameof(modelItem));
-    }
-    if (!modelItem.HasGeometry)
-    {
-      return [];
-    }
-
-    return !IsElementVisible(modelItem) ? [] : _geometryConverter.Convert(modelItem);
-  }
+  internal List<Base> GetDisplayValue(NAV.ModelItem modelItem) =>
+    modelItem == null
+      ? throw new ArgumentNullException(nameof(modelItem))
+      : !modelItem.HasGeometry
+        ? ([])
+        : !IsElementVisible(modelItem)
+          ? []
+          :
+          // this can be meshes or the instance reference objects
+          // the un transformed objects stored in a separate collection
+          geometryConverter.Convert(modelItem);
 }

Converters/Navisworks/Speckle.Converters.NavisworksShared/DataExtractors/PropertySetsExtractor.cs

@@ -18,20 +18,13 @@ public class PropertySetsExtractor(IConverterSettingsStore<NavisworksConversionS
     return propertyDictionary;
   }
 
-  /// <summary>
-  /// Extracts property sets from a NAV.ModelItem and adds them to a dictionary,
-  /// PropertySets are specific to the host application source appended to Navisworks and therefore
-  /// arbitrary in nature.
-  /// </summary>
-  /// <param name="modelItem">The NAV.ModelItem from which property sets are extracted.</param>
-  /// <returns>A dictionary containing property sets of the modelItem.</returns>
   private Dictionary<string, object?> ExtractPropertySets(NAV.ModelItem modelItem)
   {
     var propertySetDictionary = new Dictionary<string, object?>();
 
     foreach (var propertyCategory in modelItem.PropertyCategories)
     {
-      if (IsCategoryToBeSkipped(propertyCategory))
+      if (ShouldSkipCategory(propertyCategory))
       {
         continue;
       }

Converters/Navisworks/Speckle.Converters.NavisworksShared/DependencyInjection/NavisworksConverterServiceRegistration.cs

@@ -46,6 +46,20 @@ public static class NavisworksConverterServiceRegistration
     serviceCollection.AddScoped<DisplayValueExtractor>();
     serviceCollection.AddScoped<GeometryToSpeckleConverter>();
 
+    // Register dual shared geometry stores for instancing pattern (.NET Framework compatible)
+    // Store 1: For geometry definitions (Mesh, Curve, etc.) - Store 2: For InstanceDefinitionProxy objects
+    serviceCollection.AddScoped<InstanceStoreManager>();
+
+    // Register ISharedGeometryStore interface using the geometry definitions store for backward compatibility
+    serviceCollection.AddScoped<ISharedGeometryStore>(provider =>
+      provider.GetRequiredService<InstanceStoreManager>().GeometryDefinitionsStore
+    );
+
+    // Register settings resolved from factory
+    serviceCollection.AddScoped<NavisworksConversionSettings>(sp =>
+      sp.GetRequiredService<INavisworksConversionSettingsFactory>().Current
+    );
+
     return serviceCollection;
   }
 }

Converters/Navisworks/Speckle.Converters.NavisworksShared/Helpers/PropertyHelpers.cs

@@ -47,24 +47,15 @@ public static class PropertyHelpers
       return handler(value, units);
     }
 
-    // Default case for unsupported types
-    return value.DataType == NAV.VariantDataType.None || value.DataType == NAV.VariantDataType.Point2D
-      ? null
-      : value.ToString();
+    return value.DataType is NAV.VariantDataType.None or NAV.VariantDataType.Point2D ? null : value.ToString();
   }
 
-  /// <summary>
-  /// Adds a property to an object (either a Base object or a Dictionary) if the value is not null or empty.
-  /// </summary>
-  /// <param name="baseObject">The object to which the property is to be added. Can be either a Base object or a Dictionary.</param>
-  /// <param name="propertyName">The name of the property to add.</param>
-  /// <param name="value">The value of the property.</param>
   internal static void AddPropertyIfNotNullOrEmpty(object baseObject, string propertyName, object? value)
   {
     switch (value)
     {
       case null:
-        break; // Do not add null values
+        break;
       case string stringValue:
       {
         if (!string.IsNullOrEmpty(stringValue))
@@ -80,9 +71,6 @@ public static class PropertyHelpers
     }
   }
 
-  /// <summary>
-  /// Helper method to assign the property to the base object or dictionary.
-  /// </summary>
   private static void AssignProperty(object baseObject, string propertyName, object value)
   {
     switch (baseObject)
@@ -98,16 +86,9 @@ public static class PropertyHelpers
     }
   }
 
-  /// <summary>
-  /// Sanitizes property names by replacing invalid characters with underscores.
-  /// </summary>
   internal static string SanitizePropertyName(string name) =>
-    // Regex pattern from speckle-sharp/Core/Core/Models/DynamicBase.cs IsPropNameValid
-    name == "Item"
-      // Item is a reserved term for Indexed Properties: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/indexers/using-indexers
-      ? "Item"
-      : Regex.Replace(name, @"[\.\/\s]", "_");
+    name == "Item" ? "Item" : Regex.Replace(name, @"[\.\/\s]", "_");
 
-  internal static bool IsCategoryToBeSkipped(NAV.PropertyCategory propertyCategory) =>
+  internal static bool ShouldSkipCategory(NAV.PropertyCategory propertyCategory) =>
     s_excludedCategories.Contains(propertyCategory.DisplayName);
 }

Converters/Navisworks/Speckle.Converters.NavisworksShared/PathConstants.cs

@@ -1,4 +1,4 @@
-namespace Speckle.Converter.Navisworks.Constants;
+namespace Speckle.Converter.Navisworks.Constants;
 
 public static class PathConstants
 {
@@ -6,3 +6,14 @@ public static class PathConstants
   public const string MATERIAL_SEPARATOR = "::";
   public const string SET_SEPARATOR = ">";
 }
+
+public static class InstanceConstants
+{
+  public const string GEOMETRY_ID_PREFIX = "geom_";
+  public const string DEFINITION_ID_PREFIX = "def_";
+}
+
+public static class MaterialConstants
+{
+  public const string DEFAULT_MATERIAL_NAME_PREFIX = "NavisworksMaterial_";
+}

Converters/Navisworks/Speckle.Converters.NavisworksShared/Services/InstanceStoreManager.cs

@@ -0,0 +1,158 @@
+using Microsoft.Extensions.Logging;
+using Speckle.Converter.Navisworks.Constants;
+using Speckle.Sdk.Models;
+using Speckle.Sdk.Models.Instances;
+
+namespace Speckle.Converter.Navisworks.Services;
+
+/// <summary>
+/// Simple wrapper class that manages two SharedGeometryStores instances for dual instancing pattern.
+/// Provides easy access to both mesh definitions store and instance definition proxies store.
+/// </summary>
+public class InstanceStoreManager(ILogger<InstanceStoreManager> logger)
+{
+  private readonly ILogger<InstanceStoreManager> _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+  /// <summary>
+  /// Store for geometry definitions (geometry data) - untransformed base geometries.
+  /// </summary>
+  internal SharedGeometryStore GeometryDefinitionsStore { get; } = new();
+
+  /// <summary>
+  /// Store for InstanceDefinitionProxy objects that reference geometry definitions.
+  /// </summary>
+  internal SharedGeometryStore InstanceDefinitionProxiesStore { get; } = new();
+
+  /// <summary>
+  /// Clears both stores for a new conversion session.
+  /// Should be called at the start of each conversion.
+  /// </summary>
+  public void ClearAll()
+  {
+    GeometryDefinitionsStore.Clear();
+    InstanceDefinitionProxiesStore.Clear();
+  }
+
+  /// <summary>
+  /// Gets all instance definition proxies from the store, cast to their specific type.
+  /// Useful for adding to root collection at end of conversion.
+  /// </summary>
+  public IReadOnlyCollection<InstanceDefinitionProxy> GetInstanceDefinitionProxies()
+  {
+    var proxies = InstanceDefinitionProxiesStore.Geometries.OfType<InstanceDefinitionProxy>().ToList().AsReadOnly();
+    _logger.LogDebug("GetInstanceDefinitionProxies returning {Count} proxies", proxies.Count);
+    return proxies;
+  }
+
+  /// <summary>
+  /// Gets all geometry definitions from the geometry definitions store.
+  /// </summary>
+  /// <returns></returns>
+  public List<Base> GetGeometryDefinitions() => [.. GeometryDefinitionsStore.Geometries.ToList().AsReadOnly()];
+
+  /// <summary>
+  /// Gets a geometry definition by its application ID from the geometry definitions store.
+  /// </summary>
+  /// <returns>The geometry if found, null otherwise.</returns>
+  public Base? GetGeometryDefinition(string fragmentId) =>
+    GeometryDefinitionsStore.Geometries.FirstOrDefault(g =>
+      g.applicationId == $"{InstanceConstants.GEOMETRY_ID_PREFIX}{fragmentId}"
+    );
+
+  /// <summary>
+  /// Gets an instance definition proxy by its application ID.
+  /// </summary>
+  /// <returns>The instance definition proxy if found, null otherwise.</returns>
+  public InstanceDefinitionProxy? GetInstanceDefinitionProxy(string fragmentId) =>
+    InstanceDefinitionProxiesStore
+      .Geometries.OfType<InstanceDefinitionProxy>()
+      .FirstOrDefault(p => p.applicationId == $"{InstanceConstants.DEFINITION_ID_PREFIX}{fragmentId}");
+
+  /// <summary>
+  /// Adds a geometry definition and corresponding instance definition proxy for shared geometry.
+  /// This is a convenience method that handles both stores in one call.
+  /// </summary>
+  /// <param name="fragmentId">The fragment-based application ID.</param>
+  /// <param name="geometry">The untransformed base geometry.</param>
+  /// <returns>True if both were added (new geometry), false if they already existed.</returns>
+  public bool AddSharedGeometry(string fragmentId, Base geometry)
+  {
+    _logger.LogDebug("AddSharedGeometry called for FragmentId={FragmentId}", fragmentId);
+
+    bool geometryAdded = false;
+    bool proxyAdded = false;
+
+    // Create prefixed IDs for 1:1:1 relationship using base fragment hash
+    var geometryId = $"{InstanceConstants.GEOMETRY_ID_PREFIX}{fragmentId}";
+    var definitionId = $"{InstanceConstants.DEFINITION_ID_PREFIX}{fragmentId}";
+
+    _logger.LogDebug("Using GeometryId={GeometryId}, DefinitionId={DefinitionId}", geometryId, definitionId);
+
+    // Add geometry definition if not exists
+    if (!GeometryDefinitionsStore.Contains(geometryId))
+    {
+      geometry.applicationId = geometryId;
+      geometryAdded = GeometryDefinitionsStore.Add(geometry);
+      _logger.LogDebug("Added geometry definition: {GeometryId}, Success={Success}", geometryId, geometryAdded);
+    }
+    else
+    {
+      _logger.LogDebug("Geometry definition already exists: {GeometryId}", geometryId);
+    }
+
+    // Add instance definition proxy if not exists
+    if (!InstanceDefinitionProxiesStore.Contains(definitionId))
+    {
+      if (geometry.applicationId == null)
+      {
+        _logger.LogWarning(
+          "Cannot create instance definition proxy - geometry.id is null for FragmentId={FragmentId}",
+          fragmentId
+        );
+        var result = geometryAdded || proxyAdded;
+        _logger.LogDebug(
+          "AddSharedGeometry completed: FragmentId={FragmentId}, Result={Result}, GeometryAdded={GeometryAdded}, ProxyAdded={ProxyAdded}",
+          fragmentId,
+          result,
+          geometryAdded,
+          proxyAdded
+        );
+        return result;
+      }
+
+      var definitionProxy = new InstanceDefinitionProxy
+      {
+        applicationId = definitionId,
+        name = $"Shared Geometry {fragmentId[..8]}...", // Show first 8 chars for readability
+        objects = [geometry.applicationId],
+        maxDepth = 0
+      };
+      proxyAdded = InstanceDefinitionProxiesStore.Add(definitionProxy);
+      _logger.LogDebug("Added instance definition proxy: {DefinitionId}, Success={Success}", definitionId, proxyAdded);
+    }
+    else
+    {
+      _logger.LogDebug("Instance definition proxy already exists: {DefinitionId}", definitionId);
+    }
+
+    var conversionSucceededResult = geometryAdded || proxyAdded;
+    _logger.LogDebug(
+      "AddSharedGeometry completed: FragmentId={FragmentId}, Result={Result}, GeometryAdded={GeometryAdded}, ProxyAdded={ProxyAdded}",
+      fragmentId,
+      conversionSucceededResult,
+      geometryAdded,
+      proxyAdded
+    );
+    return conversionSucceededResult;
+  }
+
+  /// <summary>
+  /// Checks if shared geometry already exists in both stores.
+  /// </summary>
+  /// <param name="fragmentId">The fragment-based application ID.</param>
+  /// <returns>True if geometry definition exists in both stores.</returns>
+  public bool ContainsSharedGeometry(string fragmentId) =>
+    GeometryDefinitionsStore.Contains($"{InstanceConstants.GEOMETRY_ID_PREFIX}{fragmentId}")
+  // && InstanceDefinitionProxiesStore.Contains($"{InstanceConstants.DEFINITION_ID_PREFIX}{fragmentId}")
+  ;
+}

Converters/Navisworks/Speckle.Converters.NavisworksShared/Services/SharedGeometryStores.cs

@@ -0,0 +1,92 @@
+using Speckle.InterfaceGenerator;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Converter.Navisworks.Services;
+
+[GenerateAutoInterface]
+public class SharedGeometryStore : ISharedGeometryStore
+{
+  private readonly HashSet<Base> _geometries = new();
+  private readonly Dictionary<string, Base> _geometriesByApplicationId = new();
+  private readonly object _lock = new();
+
+  /// <summary>
+  /// Gets a read-only collection of all stored geometries.
+  /// </summary>
+  public IReadOnlyCollection<Base> Geometries
+  {
+    get
+    {
+      lock (_lock)
+      {
+        return _geometries.ToList().AsReadOnly();
+      }
+    }
+  }
+
+  /// <summary>
+  /// Adds a geometry to the store if it doesn't already exist.
+  /// </summary>
+  /// <param name="geometry">The geometry to add.</param>
+  /// <returns>True if the geometry was added, false if it already existed.</returns>
+  public bool Add(Base geometry)
+  {
+    if (geometry == null)
+    {
+      throw new ArgumentNullException(nameof(geometry));
+    }
+
+    if (string.IsNullOrEmpty(geometry.applicationId))
+    {
+      throw new ArgumentException("Geometry must have an applicationId for deduplication", nameof(geometry));
+    }
+
+    lock (_lock)
+    {
+      if (geometry.applicationId != null && _geometriesByApplicationId.ContainsKey(geometry.applicationId))
+      {
+        return false; // Already exists
+      }
+
+      _geometries.Add(geometry);
+      if (geometry.applicationId != null)
+      {
+        _geometriesByApplicationId[geometry.applicationId] = geometry;
+      }
+
+      return true; // Added successfully
+    }
+  }
+
+  /// <summary>
+  /// Checks if a geometry with the specified application ID already exists in the store.
+  /// </summary>
+  /// <param name="applicationId">The application ID to check for.</param>
+  /// <returns>True if a geometry with the application ID exists, false otherwise.</returns>
+  public bool Contains(string applicationId)
+  {
+    if (string.IsNullOrEmpty(applicationId))
+    {
+      return false;
+    }
+
+    lock (_lock)
+    {
+      var contains = _geometriesByApplicationId.ContainsKey(applicationId);
+
+      return contains;
+    }
+  }
+
+  /// <summary>
+  /// Clears all stored geometries for a new conversion session.
+  /// </summary>
+  public void Clear()
+  {
+    lock (_lock)
+    {
+      _geometries.Clear();
+      _geometriesByApplicationId.Clear();
+    }
+  }
+}

Converters/Navisworks/Speckle.Converters.NavisworksShared/Speckle.Converters.NavisworksShared.projitems

@@ -9,35 +9,37 @@
     <Import_RootNamespace>Speckle.Converters.NavisworksShared</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\ClassPropertiesExtractor.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\DisplayValueExtractor.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\ModelPropertiesExtractor.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\PropertySetsExtractor.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\RevitBuiltInCategoryExtractor.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\BasePropertyHandler.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\HierarchicalPropertyHandler.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\IPropertyHandler.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\StandardPropertyHandler.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)DependencyInjection\NavisworksConverterServiceRegistration.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Extensions\ArrayExtensions.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Geometries\Primitives.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Geometries\TransformMatrix.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Helpers\ColorConverter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Helpers\HierarchyHelper.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Helpers\ElementSelectionHelper.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Helpers\PrimitiveProcessor.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Helpers\PropertyHelpers.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)GlobalUsing.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Helpers\GeometryHelpers.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)PathConstants.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Raw\GeometryToSpeckleConverter.cs" />
-    <Folder Include="$(MSBuildThisFileDirectory)Models\" />
-    <Compile Include="$(MSBuildThisFileDirectory)Services\NavisworksToSpeckleUnitConverter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Settings\ConversionModes.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Settings\NavisworksConversionSettings.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Settings\NavisworksConversionSettingsFactory.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\NavisworksRootToSpeckleConverter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Raw\BoundingBoxToSpeckleRawConverter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\TopLevel\ModelItemTopLevelConverterToSpeckle.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\ClassPropertiesExtractor.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\DisplayValueExtractor.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\ModelPropertiesExtractor.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\PropertySetsExtractor.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataExtractors\RevitBuiltInCategoryExtractor.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\BasePropertyHandler.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\HierarchicalPropertyHandler.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\IPropertyHandler.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DataHandlers\StandardPropertyHandler.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)DependencyInjection\NavisworksConverterServiceRegistration.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\ArrayExtensions.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Geometries\Primitives.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Geometries\TransformMatrix.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Helpers\ColorConverter.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Helpers\HierarchyHelper.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Helpers\ElementSelectionHelper.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Helpers\PrimitiveProcessor.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Helpers\PropertyHelpers.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)GlobalUsing.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Helpers\GeometryHelpers.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)PathConstants.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Services\SharedGeometryStores.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Services\InstanceStoreManager.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Raw\GeometryToSpeckleConverter.cs"/>
+    <Folder Include="$(MSBuildThisFileDirectory)Models\"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Services\NavisworksToSpeckleUnitConverter.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Settings\ConversionModes.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Settings\NavisworksConversionSettings.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)Settings\NavisworksConversionSettingsFactory.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\NavisworksRootToSpeckleConverter.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Raw\BoundingBoxToSpeckleRawConverter.cs"/>
+    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\TopLevel\ModelItemTopLevelConverterToSpeckle.cs"/>
   </ItemGroup>
-</Project>
+</Project>

Converters/Navisworks/Speckle.Converters.NavisworksShared/ToSpeckle/NavisworksRootToSpeckleConverter.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using Speckle.Converter.Navisworks.Helpers;
 using Speckle.Converter.Navisworks.Settings;
 using Speckle.Converters.Common;
@@ -8,9 +8,6 @@ using Speckle.Sdk.Models;
 
 namespace Speckle.Converter.Navisworks.ToSpeckle;
 
-/// <summary>
-/// Converts Navisworks ModelItem objects to Speckle Base objects.
-/// </summary>
 public class NavisworksRootToSpeckleConverter : IRootToSpeckleConverter
 {
   private readonly IConverterManager<IToSpeckleTopLevelConverter> _toSpeckle;
@@ -41,11 +38,8 @@ public class NavisworksRootToSpeckleConverter : IRootToSpeckleConverter
     }
 
     Type type = target.GetType();
-
     var objectConverter = _toSpeckle.ResolveConverter(type, true);
-
     Base result = objectConverter.Convert(modelItem);
-
     result.applicationId = ElementSelectionHelper.ResolveModelItemToIndexPath(modelItem);
 
     return result;

Converters/Navisworks/Speckle.Converters.NavisworksShared/ToSpeckle/Raw/GeometryToSpeckleConverter.cs

@@ -1,44 +1,47 @@
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
 using Autodesk.Navisworks.Api.Interop.ComApi;
-using Speckle.Converter.Navisworks.Extensions;
+using Microsoft.Extensions.Logging;
+using Speckle.Converter.Navisworks.Constants;
 using Speckle.Converter.Navisworks.Geometry;
 using Speckle.Converter.Navisworks.Helpers;
+using Speckle.Converter.Navisworks.Services;
 using Speckle.Converter.Navisworks.Settings;
+using Speckle.DoubleNumerics;
 using Speckle.Objects.Geometry;
 using Speckle.Sdk.Models;
+using Speckle.Sdk.Models.Instances;
 using ComApiBridge = Autodesk.Navisworks.Api.ComApi.ComApiBridge;
 
 namespace Speckle.Converter.Navisworks.ToSpeckle;
 
-/// <summary>
-/// Converts Navisworks geometry to Speckle displayable geometry.
-///
-/// Note: This class does not implement ITypedConverter{ModelGeometry, Base} because Navisworks geometry
-/// conversion requires COM interop access that isn't available through the public ModelGeometry class.
-/// The conversion process requires:
-/// 1. Convert ModelItem to InwOaPath3 via ComApiBridge
-/// 2. Use that to get InwOaFragmentList
-/// 3. Process each InwOaFragment3 to generate primitives
-/// 4. Convert those primitives to Speckle geometry with appropriate transforms
-/// </summary>
-public class GeometryToSpeckleConverter
+/// <remarks>
+/// Memory Safety: All COM objects (InwSelectionPathsColl, InwOaPath, InwOaFragmentList) are explicitly
+/// released using Marshal.ReleaseComObject in try-finally blocks to prevent memory leaks.
+/// NAV.Color objects are disposed using 'using' statements as they implement IDisposable.
+/// </remarks>
+public class GeometryToSpeckleConverter(
+  NavisworksConversionSettings settings,
+  InstanceStoreManager instanceStoreManager,
+  ILogger<GeometryToSpeckleConverter> logger
+)
 {
-  private readonly NavisworksConversionSettings _settings;
-  private readonly bool _isUpright;
-  private readonly SafeVector _transformVector;
-  private const double SCALE = 1.0; // Default scale factor
+  private readonly NavisworksConversionSettings _settings =
+    settings ?? throw new ArgumentNullException(nameof(settings));
 
-  public GeometryToSpeckleConverter(NavisworksConversionSettings settings)
-  {
-    _settings = settings ?? throw new ArgumentNullException(nameof(settings));
-    _isUpright = settings.Derived.IsUpright;
-    _transformVector = settings.Derived.TransformVector;
-  }
+  private readonly bool _isUpright = settings.Derived.IsUpright;
+  private readonly SafeVector _transformVector = settings.Derived.TransformVector;
+  private const double SCALE = 1.0;
+  private static readonly Matrix4x4 s_identityMatrix = new(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+  private static readonly double[] s_identityTransform = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+
+  private readonly InstanceStoreManager _instanceStoreManager =
+    instanceStoreManager ?? throw new ArgumentNullException(nameof(instanceStoreManager));
+
+  private readonly ILogger<GeometryToSpeckleConverter> _logger =
+    logger ?? throw new ArgumentNullException(nameof(logger));
 
-  /// <summary>
-  /// Converts a ModelItem's geometry to Speckle display geometry by accessing the underlying COM objects.
-  /// Applies necessary transformations and unit scaling.
-  /// </summary>
   internal List<Base> Convert(NAV.ModelItem modelItem)
   {
     if (modelItem == null)
@@ -58,13 +61,32 @@ public class GeometryToSpeckleConverter
       var paths = comSelection.Paths();
       try
       {
-        // Populate fragment stack with all fragments
+        if (paths.Count > 0)
+        {
+          var firstPath = paths.Cast<InwOaPath>().First();
+          var fragmentsCollection = firstPath.Fragments();
+          try
+          {
+            if (fragmentsCollection.Count > 1)
+            {
+              return ProcessSharedGeometry(paths, fragmentStack);
+            }
+          }
+          finally
+          {
+            if (fragmentsCollection != null)
+            {
+              Marshal.ReleaseComObject(fragmentsCollection);
+            }
+          }
+        }
+
         foreach (InwOaPath path in paths)
         {
           CollectFragments(path, fragmentStack);
         }
 
-        return ProcessFragments(fragmentStack, paths);
+        return ProcessFragments(fragmentStack, paths, true);
       }
       finally
       {
@@ -86,24 +108,69 @@ public class GeometryToSpeckleConverter
   private static void CollectFragments(InwOaPath path, Stack<InwOaFragment3> fragmentStack)
   {
     var fragments = path.Fragments();
-    foreach (var fragment in fragments.OfType<InwOaFragment3>())
+    try
     {
-      if (fragment.path?.ArrayData is not Array pathData1 || path.ArrayData is not Array pathData2)
+      foreach (var fragment in fragments.OfType<InwOaFragment3>())
       {
-        continue;
+        if (AreFragmentPathsEqual(fragment, path))
+        {
+          fragmentStack.Push(fragment);
+        }
       }
-
-      var pathArray1 = pathData1.ToArray<int>();
-      var pathArray2 = pathData2.ToArray<int>();
-
-      if (pathArray1.Length == pathArray2.Length && pathArray1.SequenceEqual(pathArray2))
+    }
+    finally
+    {
+      if (fragments != null)
       {
-        fragmentStack.Push(fragment);
+        Marshal.ReleaseComObject(fragments);
       }
     }
   }
 
-  private List<Base> ProcessFragments(Stack<InwOaFragment3> fragmentStack, InwSelectionPathsColl paths)
+  private List<Base> ProcessSharedGeometry(InwSelectionPathsColl paths, Stack<InwOaFragment3> fragmentStack)
+  {
+    var fragmentId = GenerateFragmentId(paths);
+
+    if (string.IsNullOrEmpty(fragmentId))
+    {
+      foreach (InwOaPath path in paths)
+      {
+        CollectFragments(path, fragmentStack);
+      }
+
+      return ProcessFragments(fragmentStack, paths, true);
+    }
+
+    if (_instanceStoreManager.ContainsSharedGeometry(fragmentId))
+    {
+      return CreateInstanceReference(fragmentId, paths);
+    }
+
+    foreach (InwOaPath path in paths)
+    {
+      CollectFragments(path, fragmentStack);
+    }
+
+    var baseGeometry = ExtractUntransformedGeometry(fragmentStack);
+
+    if (baseGeometry == null)
+    {
+      return ProcessFragments(fragmentStack, paths);
+    }
+
+    if (!_instanceStoreManager.AddSharedGeometry(fragmentId, baseGeometry))
+    {
+      return ProcessFragments(fragmentStack, paths);
+    }
+
+    return CreateInstanceReference(fragmentId, paths);
+  }
+
+  private List<Base> ProcessFragments(
+    Stack<InwOaFragment3> fragmentStack,
+    InwSelectionPathsColl paths,
+    bool isSingleObject = false
+  )
   {
     var callbackListeners = new List<PrimitiveProcessor>();
 
@@ -113,11 +180,6 @@ public class GeometryToSpeckleConverter
 
       foreach (var fragment in fragmentStack)
       {
-        if (!ValidateFragmentPath(fragment, path))
-        {
-          continue;
-        }
-
         var matrix = fragment.GetLocalToWorldMatrix();
         var transform = matrix as InwLTransform3f3;
         if (transform?.Matrix is not Array matrixArray)
@@ -125,27 +187,45 @@ public class GeometryToSpeckleConverter
           continue;
         }
 
-        processor.LocalToWorldTransformation = ConvertArrayToDouble(matrixArray);
+        var fragmentsForCount = path.Fragments();
+        int fragmentCount;
+        try
+        {
+          fragmentCount = fragmentsForCount.Count;
+        }
+        finally
+        {
+          if (fragmentsForCount != null)
+          {
+            Marshal.ReleaseComObject(fragmentsForCount);
+          }
+        }
+
+        double[] makeNoChange = s_identityTransform;
+        double[] transformMatrix = ConvertArrayToDouble(matrixArray);
+
+        if (isSingleObject || fragmentCount == 1)
+        {
+          processor.LocalToWorldTransformation = transformMatrix;
+        }
+        else
+        {
+          processor.LocalToWorldTransformation = makeNoChange;
+        }
+
         fragment.GenerateSimplePrimitives(nwEVertexProperty.eNORMAL, processor);
       }
 
       callbackListeners.Add(processor);
     }
 
-    var baseGeometries = ProcessGeometries(callbackListeners);
-
-    return baseGeometries;
+    return ProcessGeometries(callbackListeners);
   }
 
-  private static bool ValidateFragmentPath(InwOaFragment3 fragment, InwOaPath path)
-  {
-    if (fragment.path?.ArrayData is not Array fragmentPathData || path.ArrayData is not Array pathData)
-    {
-      return false;
-    }
-
-    return IsSameFragmentPath(fragmentPathData, pathData);
-  }
+  private static bool AreFragmentPathsEqual(InwOaFragment3 fragment, InwOaPath path) =>
+    fragment.path?.ArrayData is Array fragmentPathData
+    && path.ArrayData is Array pathData
+    && AreFragmentPathsEqual(fragmentPathData, pathData);
 
   private List<Base> ProcessGeometries(List<PrimitiveProcessor> processors)
   {
@@ -178,7 +258,6 @@ public class GeometryToSpeckleConverter
     {
       var triangle = triangles[t];
 
-      // No need to worry about disposal of COM across boundaries - we're working with our safe structs
       vertices.AddRange(
         [
           (triangle.Vertex1.X + _transformVector.X) * SCALE,
@@ -204,9 +283,8 @@ public class GeometryToSpeckleConverter
   }
 
   private List<Line> CreateLines(IReadOnlyList<SafeLine> lines) =>
-    (
-      from line in lines
-      select new Line
+    lines
+      .Select(line => new Line
       {
         start = new Point(
           (line.Start.X + _transformVector.X) * SCALE,
@@ -221,10 +299,309 @@ public class GeometryToSpeckleConverter
           _settings.Derived.SpeckleUnits
         ),
         units = _settings.Derived.SpeckleUnits
-      }
-    ).ToList();
+      })
+      .ToList();
 
-  private static double[]? ConvertArrayToDouble(Array arr)
+  public string GenerateFragmentId(InwSelectionPathsColl paths)
+  {
+    try
+    {
+      if (paths.Count == 0)
+      {
+        return string.Empty;
+      }
+
+      var fragmentHashes = new List<string>();
+
+      foreach (var fragments in from InwOaPath path in paths select path.Fragments())
+      {
+        try
+        {
+          var fragmentIndex = 0;
+          foreach (InwOaFragment3 fragment in fragments.OfType<InwOaFragment3>())
+          {
+            if (fragment.path?.ArrayData is not Array pathData || pathData.Length == 0)
+            {
+              fragmentIndex++;
+              continue;
+            }
+
+            try
+            {
+              if (pathData.Rank != 1)
+              {
+                var fragmentHashFallback = TrySimpleArrayEnumeration(pathData, fragmentIndex);
+                if (!string.IsNullOrEmpty(fragmentHashFallback))
+                {
+                  fragmentHashes.Add(fragmentHashFallback);
+                }
+
+                fragmentIndex++;
+                continue;
+              }
+
+              var lowerBound = pathData.GetLowerBound(0);
+              var upperBound = pathData.GetUpperBound(0);
+
+              var arrayLength = upperBound - lowerBound + 1;
+              var pathInts = new int[arrayLength];
+
+              for (int i = lowerBound; i <= upperBound; i++)
+              {
+                try
+                {
+                  var value = pathData.GetValue(i);
+                  var arrayIndex = i - lowerBound;
+                  pathInts[arrayIndex] = System.Convert.ToInt32(value);
+                }
+                catch (Exception ex) when (ex is COMException or InvalidCastException)
+                {
+                  var errorType = ex is COMException ? "COM array access failed" : "Type conversion failed";
+                  _logger.LogDebug(ex, "{ErrorType} at index {Index}", errorType, i);
+                }
+              }
+
+              var fragmentHash = string.Join("_", pathInts);
+              fragmentHashes.Add(fragmentHash);
+            }
+            catch (Exception ex) when (ex is COMException or IndexOutOfRangeException or RankException)
+            {
+              var errorType = ex switch
+              {
+                COMException => "COM access failed",
+                IndexOutOfRangeException => "Array bounds exceeded",
+                RankException => "Array rank mismatch",
+                _ => "Error"
+              };
+              _logger.LogDebug(ex, "{ErrorType} processing fragment {FragmentIndex}, trying simple enumeration", errorType, fragmentIndex);
+
+              var fragmentHash = TrySimpleArrayEnumeration(pathData, fragmentIndex);
+              if (!string.IsNullOrEmpty(fragmentHash))
+              {
+                fragmentHashes.Add(fragmentHash);
+              }
+
+              fragmentIndex++;
+              continue;
+            }
+
+            fragmentIndex++;
+          }
+        }
+        finally
+        {
+          if (fragments != null)
+          {
+            Marshal.ReleaseComObject(fragments);
+          }
+        }
+      }
+
+      if (fragmentHashes.Count > 0)
+      {
+        fragmentHashes.Sort();
+        var rawData = string.Join("__", fragmentHashes);
+        var fragmentId = HashRawData(rawData);
+        return fragmentId;
+      }
+      else
+      {
+        return string.Empty;
+      }
+    }
+    catch (Exception ex) when (ex is COMException or InvalidCastException or IndexOutOfRangeException)
+    {
+      var errorType = ex switch
+      {
+        COMException => "COM access failed",
+        InvalidCastException => "Type conversion failed",
+        IndexOutOfRangeException => "Array bounds exceeded",
+        _ => "Error"
+      };
+      _logger.LogWarning(ex, "{ErrorType} generating fragment ID", errorType);
+      return string.Empty;
+    }
+  }
+
+  private string TrySimpleArrayEnumeration(Array pathData, int fragmentIndex)
+  {
+    try
+    {
+      var values = new List<string>();
+      var maxAttempts = Math.Min(pathData.Length, 20);
+
+      for (int i = 0; i < maxAttempts; i++)
+      {
+        try
+        {
+          var value = pathData.GetValue(i);
+          var convertedValue = System.Convert.ToInt32(value);
+          values.Add(convertedValue.ToString());
+        }
+        catch (IndexOutOfRangeException)
+        {
+          break;
+        }
+        catch (InvalidCastException ex)
+        {
+          _logger.LogDebug(ex, "Type conversion failed at index {Index}", i);
+        }
+      }
+
+      if (values.Count <= 0)
+      {
+        return string.Empty;
+      }
+
+      return string.Join("_", values);
+    }
+    catch (COMException ex)
+    {
+      _logger.LogDebug(ex, "COM enumeration failed for fragment {FragmentIndex}", fragmentIndex);
+      return string.Empty;
+    }
+  }
+
+  private static string HashRawData(string rawData)
+  {
+    using var sha256 = SHA256.Create();
+    var inputBytes = Encoding.UTF8.GetBytes(rawData);
+    var hashBytes = sha256.ComputeHash(inputBytes);
+    return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
+  }
+
+  private Base? ExtractUntransformedGeometry(Stack<InwOaFragment3> fragmentStack)
+  {
+    var processor = new PrimitiveProcessor(_isUpright);
+
+    foreach (var fragment in fragmentStack)
+    {
+      processor.LocalToWorldTransformation = s_identityTransform;
+
+      fragment.GenerateSimplePrimitives(nwEVertexProperty.eNORMAL, processor);
+    }
+
+    return processor.Triangles.Count > 0 ? CreateMesh(processor.Triangles) : null;
+  }
+
+  private List<Base> CreateInstanceReference(string fragmentId, InwSelectionPathsColl paths)
+  {
+    var transform = ExtractInstanceTransform(paths);
+
+    var instanceReference = new InstanceProxy
+    {
+      definitionId = $"{InstanceConstants.DEFINITION_ID_PREFIX}{fragmentId}",
+      transform = transform,
+      units = _settings.Derived.SpeckleUnits,
+      maxDepth = 0,
+      applicationId = Guid.NewGuid().ToString()
+    };
+
+    return [instanceReference];
+  }
+
+  private Matrix4x4 ExtractInstanceTransform(InwSelectionPathsColl paths)
+  {
+    try
+    {
+      if (paths.Count == 0)
+      {
+        return s_identityMatrix;
+      }
+
+      var firstPath = paths.Cast<InwOaPath>().First();
+      var fragments = firstPath.Fragments();
+      try
+      {
+        if (fragments.Count == 0)
+        {
+          return s_identityMatrix;
+        }
+
+        var fragmentStack = new Stack<InwOaFragment3>();
+
+        foreach (var frag in fragments.OfType<InwOaFragment3>())
+        {
+          if (frag.path?.ArrayData is not Array pathData1 || firstPath.ArrayData is not Array pathData2)
+          {
+            continue;
+          }
+
+          var pathArray1 = pathData1.Cast<int>().ToArray();
+          var pathArray2 = pathData2.Cast<int>().ToArray();
+
+          if (pathArray1.Length == pathArray2.Length && pathArray1.SequenceEqual(pathArray2))
+          {
+            fragmentStack.Push(frag);
+          }
+        }
+
+        var fragment = fragmentStack.First();
+        var matrix = fragment.GetLocalToWorldMatrix();
+
+        if (matrix is InwLTransform3f3 { Matrix: Array matrixArray })
+        {
+          var transformArray = ConvertArrayToDouble(matrixArray);
+          var transformedMatrix = ApplyCoordinateTransform(transformArray);
+
+          var newMatrix = new Matrix4x4(
+            transformedMatrix[0],
+            transformedMatrix[1],
+            transformedMatrix[2],
+            transformedMatrix[3],
+            transformedMatrix[4],
+            transformedMatrix[5],
+            transformedMatrix[6],
+            transformedMatrix[7],
+            transformedMatrix[8],
+            transformedMatrix[9],
+            transformedMatrix[10],
+            transformedMatrix[11],
+            transformedMatrix[12],
+            transformedMatrix[13],
+            transformedMatrix[14],
+            transformedMatrix[15]
+          );
+
+          return Matrix4x4.Transpose(newMatrix);
+        }
+      }
+      finally
+      {
+        if (fragments != null)
+        {
+          Marshal.ReleaseComObject(fragments);
+        }
+      }
+    }
+    catch (Exception ex) when (ex is COMException or InvalidCastException or NullReferenceException)
+    {
+      var errorType = ex switch
+      {
+        COMException => "COM access failed",
+        InvalidCastException => "Transform matrix type conversion failed",
+        NullReferenceException => "Null reference",
+        _ => "Error"
+      };
+      _logger.LogWarning(ex, "{ErrorType} extracting instance transform", errorType);
+    }
+
+    return s_identityMatrix;
+  }
+
+  private double[] ApplyCoordinateTransform(double[] matrixArray)
+  {
+    var result = new double[16];
+    Array.Copy(matrixArray, result, 16);
+
+    result[12] = (result[12] + _transformVector.X) * SCALE;
+    result[13] = (result[13] + _transformVector.Y) * SCALE;
+    result[14] = (result[14] + _transformVector.Z) * SCALE;
+
+    return result;
+  }
+
+  private static double[] ConvertArrayToDouble(Array arr)
   {
     if (arr.Rank != 1)
     {
@@ -240,6 +617,6 @@ public class GeometryToSpeckleConverter
     return doubleArray;
   }
 
-  private static bool IsSameFragmentPath(Array a1, Array a2) =>
+  private static bool AreFragmentPathsEqual(Array a1, Array a2) =>
     a1.Length == a2.Length && a1.Cast<int>().SequenceEqual(a2.Cast<int>());
 }

Converters/Navisworks/Speckle.Converters.NavisworksShared/ToSpeckle/TopLevel/ModelItemTopLevelConverterToSpeckle.cs

@@ -1,4 +1,4 @@
-using Speckle.Converter.Navisworks.Settings;
+using Speckle.Converter.Navisworks.Settings;
 using Speckle.Converter.Navisworks.ToSpeckle.PropertyHandlers;
 using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;