@fps-games/editor 0.1.7-beta.4 → 0.1.8-beta.1

package/node_modules/@fps-games/editor-babylon/dist/projection.js

@@ -6,6 +6,7 @@ import { normalizeProjectionOwnerNodePath, readProjectionSourceNodeSegment, } fr
 import { createMaterialSlotOwnerPathMatchKey, isMaterialSlotOwnerPathMatch, } from './material-slot-source-resolver.js';
 const LARGE_SELECTION_EDGE_LIMIT = 200;
 const PROJECTION_LOCAL_MATRIX_METADATA_KEY = 'editorLocalTransformMatrix';
+const MIN_SELECTION_BOUNDS_PROXY_SIZE = 0.002;
 const ASSET_MESH_SELECTION_SEPARATOR = '::assetMesh::';
 function requireBabylonCtor(value, name) {
     if (!value)
@@ -209,6 +210,7 @@ export function createBabylonEditorProjection(options) {
             nodeId: node.id,
             root,
             outlineMeshes: [],
+            selectionMeshes: [],
             animationGroups: [],
             runtimeObjects: [],
         };
@@ -626,7 +628,7 @@ function getProjectionSelectionBounds(projections, nodeIds) {
     let min = null;
     let max = null;
     for (const nodeId of nodeIds) {
-        const bounds = readProjectionBounds(projections.get(nodeId)?.root);
+        const bounds = readProjectionBounds(resolveProjectionSelectionBoundsTarget(projections, nodeId));
         if (!bounds)
             continue;
         min = min
@@ -662,6 +664,32 @@ function getProjectionSelectionBounds(projections, nodeIds) {
         },
     };
 }
+function resolveProjectionSelectionBoundsTarget(projections, nodeId) {
+    const projection = projections.get(nodeId);
+    if (projection?.root)
+        return projection.root;
+    for (const candidateProjection of projections.values()) {
+        const selectionTarget = findProjectionSelectionMeshByNodeId(candidateProjection, nodeId);
+        if (selectionTarget)
+            return selectionTarget;
+    }
+    return null;
+}
+function findProjectionSelectionMeshByNodeId(projection, nodeId) {
+    for (const mesh of projection.selectionMeshes ?? []) {
+        if (readProjectionMeshSelectionNodeId(mesh) === nodeId)
+            return mesh;
+    }
+    for (const mesh of projection.outlineMeshes) {
+        if (readProjectionMeshSelectionNodeId(mesh) === nodeId)
+            return mesh;
+    }
+    return null;
+}
+function readProjectionMeshSelectionNodeId(mesh) {
+    const nodeId = mesh?.metadata?.editorProjection?.nodeId;
+    return typeof nodeId === 'string' && nodeId.length > 0 ? nodeId : null;
+}
 function readProjectionBounds(root) {
     if (!root)
         return null;
@@ -790,6 +818,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
             },
         };
         applyAssetDefaultsTransform(babylon, modelRoot, asset.transform);
+        collapseZeroVertexProjectionWrapperMeshes(babylon, scene, result);
         const importedNodes = [
             ...(result.transformNodes ?? []),
             ...(result.meshes ?? []),
@@ -810,20 +839,59 @@ function attachImportedProjectionResult(options, node, asset, projection, result
                 },
             };
         }
+        const materialSlots = readProjectionAssetMaterialSlots(asset, node.id);
+        const ownerNodePathByMesh = new Map();
+        const ownerMeshCountByKey = new Map();
+        for (const mesh of result.meshes ?? []) {
+            const ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
+            if (!ownerNodePath)
+                continue;
+            ownerNodePathByMesh.set(mesh, ownerNodePath);
+            const ownerKey = createMaterialSlotOwnerPathMatchKey(ownerNodePath, { projectionNodeId: node.id });
+            ownerMeshCountByKey.set(ownerKey, (ownerMeshCountByKey.get(ownerKey) ?? 0) + 1);
+        }
+        const splitPrimitiveOrdinalByOwnerKey = new Map();
+        const primitiveBoundsProxyOwnerKeys = new Set();
         for (const mesh of result.meshes ?? []) {
             mesh.isPickable = true;
             applyProjectionRenderingToMesh(node, mesh);
-            const ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
+            const ownerNodePath = ownerNodePathByMesh.get(mesh) ?? null;
             if (ownerNodePath) {
+                const ownerKey = createMaterialSlotOwnerPathMatchKey(ownerNodePath, { projectionNodeId: node.id });
+                const ownerMeshCount = ownerMeshCountByKey.get(ownerKey) ?? 0;
+                const splitPrimitiveSlot = resolveProjectionSplitPrimitiveMeshSelectionSlot(mesh, materialSlots, ownerNodePath, node.id, ownerMeshCount, splitPrimitiveOrdinalByOwnerKey);
+                const primitiveSelectionMeshes = createProjectionAssetMeshSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots);
+                const primitiveBoundsSelectionMeshes = !splitPrimitiveSlot
+                    && primitiveSelectionMeshes.length === 0
+                    && !primitiveBoundsProxyOwnerKeys.has(ownerKey)
+                    ? createProjectionPrimitiveBoundsSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, ownerMeshCount)
+                    : [];
+                if (primitiveBoundsSelectionMeshes.length > 0)
+                    primitiveBoundsProxyOwnerKeys.add(ownerKey);
+                const usesSelectionMeshes = primitiveSelectionMeshes.length > 0
+                    || primitiveBoundsSelectionMeshes.length > 0
+                    || primitiveBoundsProxyOwnerKeys.has(ownerKey);
                 const selectionKey = resolveProjectionAssetMeshSelectionKey(asset, ownerNodePath, node.id);
                 mesh.metadata = {
                     ...(mesh.metadata ?? {}),
                     editorProjection: {
-                        nodeId: createAssetMeshProjectionNodeId(node.id, selectionKey),
+                        nodeId: splitPrimitiveSlot
+                            ? createAssetMeshProjectionNodeId(node.id, splitPrimitiveSlot.key)
+                            : usesSelectionMeshes
+                                ? node.id
+                                : createAssetMeshProjectionNodeId(node.id, selectionKey),
                         rootNodeId: node.id,
                         sourceId: asset.sourceId,
                         ownerNodePath,
-                        ...(selectionKey !== ownerNodePath ? { slotSelectionKey: selectionKey } : {}),
+                        ...(splitPrimitiveSlot
+                            ? {
+                                slotSelectionKey: splitPrimitiveSlot.key,
+                                primitiveIndex: splitPrimitiveSlot.primitiveIndex,
+                            }
+                            : {}),
+                        ...(!splitPrimitiveSlot && !usesSelectionMeshes && selectionKey !== ownerNodePath
+                            ? { slotSelectionKey: selectionKey }
+                            : {}),
                         runtimeKind: 'assetMesh',
                         ...createProjectionShadowMetadata(node),
                     },
@@ -843,6 +911,141 @@ function attachImportedProjectionResult(options, node, asset, projection, result
         throw error;
     }
 }
+function collapseZeroVertexProjectionWrapperMeshes(babylon, scene, result) {
+    const meshes = result.meshes ?? [];
+    if (meshes.length === 0)
+        return;
+    const TransformNode = babylon.TransformNode;
+    if (!TransformNode)
+        return;
+    const sourceMeshes = collectProjectionSourceMeshReferences(meshes);
+    const keptMeshes = [];
+    const replacementTransformNodes = [];
+    for (const mesh of meshes) {
+        if (!canCollapseProjectionWrapperMesh(mesh, sourceMeshes)) {
+            keptMeshes.push(mesh);
+            continue;
+        }
+        const replacement = createProjectionWrapperTransformNode(TransformNode, scene, mesh);
+        if (!replacement) {
+            keptMeshes.push(mesh);
+            continue;
+        }
+        for (const child of readProjectionDirectChildren(mesh)) {
+            child.parent = replacement;
+        }
+        mesh.dispose?.(true, false);
+        replacementTransformNodes.push(replacement);
+    }
+    if (replacementTransformNodes.length === 0)
+        return;
+    result.meshes = keptMeshes;
+    result.transformNodes = [
+        ...(result.transformNodes ?? []),
+        ...replacementTransformNodes,
+    ];
+}
+function collectProjectionSourceMeshReferences(meshes) {
+    const sourceMeshes = new Set();
+    for (const mesh of meshes) {
+        const sourceMesh = mesh?.sourceMesh;
+        if (sourceMesh)
+            sourceMeshes.add(sourceMesh);
+    }
+    return sourceMeshes;
+}
+function canCollapseProjectionWrapperMesh(mesh, sourceMeshes) {
+    if (!mesh || mesh.getClassName?.() !== 'Mesh')
+        return false;
+    if (sourceMeshes.has(mesh))
+        return false;
+    if (mesh.sourceMesh)
+        return false;
+    const vertices = mesh.getTotalVertices?.();
+    if (vertices !== 0)
+        return false;
+    if (Array.isArray(mesh.instances) && mesh.instances.length > 0)
+        return false;
+    if (mesh.skeleton || mesh.morphTargetManager)
+        return false;
+    if (Array.isArray(mesh.subMeshes) && mesh.subMeshes.length > 0)
+        return false;
+    if (mesh.material)
+        return false;
+    const projection = readProjectionObject(mesh.metadata?.editorProjection);
+    const runtimeKind = projection?.runtimeKind;
+    if (runtimeKind === 'assetMeshSelectionProxy'
+        || runtimeKind === 'primitive'
+        || runtimeKind === 'camera'
+        || runtimeKind === 'light'
+        || projection?.primitiveShape != null
+        || projection?.helper != null
+        || projection?.disableStaticProjectedShadow === false) {
+        return false;
+    }
+    return true;
+}
+function createProjectionWrapperTransformNode(TransformNode, scene, mesh) {
+    const name = typeof mesh.name === 'string' ? mesh.name : typeof mesh.id === 'string' ? mesh.id : 'projectionWrapper';
+    const replacement = new TransformNode(name, scene);
+    if (typeof mesh.id === 'string')
+        replacement.id = mesh.id;
+    if (typeof mesh.name === 'string')
+        replacement.name = mesh.name;
+    replacement.parent = mesh.parent ?? null;
+    if (mesh.metadata && typeof mesh.metadata === 'object') {
+        replacement.metadata = { ...mesh.metadata };
+    }
+    if (mesh.reservedDataStore && typeof mesh.reservedDataStore === 'object') {
+        replacement.reservedDataStore = { ...mesh.reservedDataStore };
+    }
+    if (Array.isArray(mesh.animations))
+        replacement.animations = [...mesh.animations];
+    copyProjectionWrapperTransform(mesh, replacement);
+    if (typeof mesh.isEnabled === 'function' && typeof replacement.setEnabled === 'function') {
+        replacement.setEnabled(mesh.isEnabled());
+    }
+    if (typeof mesh.state === 'string')
+        replacement.state = mesh.state;
+    if (typeof mesh.layerMask === 'number')
+        replacement.layerMask = mesh.layerMask;
+    return replacement;
+}
+function copyProjectionWrapperTransform(source, target) {
+    copyBabylonVector3(source.position, target.position);
+    copyBabylonVector3(source.rotation, target.rotation);
+    copyBabylonVector3(source.scaling, target.scaling);
+    if (source.rotationQuaternion?.clone) {
+        target.rotationQuaternion = source.rotationQuaternion.clone();
+    }
+    else {
+        target.rotationQuaternion = null;
+    }
+    const pivotMatrix = source._pivotMatrix?.clone?.() ?? source.getPivotMatrix?.()?.clone?.();
+    if (pivotMatrix) {
+        if (source._usePivotMatrix && typeof target.setPreTransformMatrix === 'function') {
+            target.setPreTransformMatrix(pivotMatrix.clone?.() ?? pivotMatrix);
+        }
+        else if (typeof target.setPivotMatrix === 'function') {
+            target.setPivotMatrix(pivotMatrix.clone?.() ?? pivotMatrix, false);
+        }
+    }
+}
+function copyBabylonVector3(source, target) {
+    if (!source || !target)
+        return;
+    if (typeof target.copyFrom === 'function') {
+        target.copyFrom(source);
+        return;
+    }
+    target.x = source.x;
+    target.y = source.y;
+    target.z = source.z;
+}
+function readProjectionDirectChildren(node) {
+    const children = node?.getChildren?.((candidate) => candidate?.parent === node, true);
+    return Array.isArray(children) ? children.filter(child => child?.parent === node) : [];
+}
 function createProjectionImportStructureSnapshot(node, asset, modelRoot, result) {
     const runtimeNodes = collectProjectionImportRuntimeNodes(modelRoot, result);
     const nodeIdByRuntimeNode = new Map();
@@ -1229,31 +1432,105 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
     const materials = new Set();
     if (hasRootProfile) {
         for (const mesh of meshes) {
-            const material = mesh?.material;
-            if (material)
-                materials.add(material);
-        }
-        for (const material of materials) {
+            const material = readProjectionWritableMeshMaterial(mesh);
+            const meshOwnerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
+            if (!material) {
+                emitProjectionMaterialProfileDiagnostic(options, {
+                    projectionNodeId: node.id,
+                    source: 'rootProfile',
+                    applied: false,
+                    matchKind: 'root',
+                    targetMaterialStatus: 'missingMaterial',
+                    meshOwnerNodePath,
+                    warningMessage: 'Root material profile was not applied because an imported mesh has no target material.',
+                });
+                continue;
+            }
+            if (materials.has(material))
+                continue;
+            materials.add(material);
             applyProjectionArtistMaterialProfile(options, material, node.artistMaterialProfile);
+            emitProjectionMaterialProfileDiagnostic(options, {
+                projectionNodeId: node.id,
+                source: 'rootProfile',
+                applied: true,
+                matchKind: 'root',
+                targetMaterialStatus: 'material',
+                meshOwnerNodePath,
+                targetMaterialName: readProjectionMaterialName(material),
+                targetMaterialType: readProjectionMaterialType(material),
+            });
+        }
+        if (materials.size === 0 && meshes.length === 0) {
+            emitProjectionMaterialProfileDiagnostic(options, {
+                projectionNodeId: node.id,
+                source: 'rootProfile',
+                applied: false,
+                matchKind: 'root',
+                targetMaterialStatus: 'missingMaterial',
+                meshOwnerNodePath: null,
+                warningMessage: 'Root material profile was not applied because the imported model produced no meshes.',
+            });
         }
     }
     if (!hasSlotProfiles)
         return clonedMaterials;
     const materialCounts = countProjectionMeshMaterials(meshes);
+    const assetMaterialSlots = node.asset ? readProjectionAssetMaterialSlots(node.asset, node.id) : [];
+    const unmatchedSlotBindings = new Set(slotBindings);
     for (const mesh of meshes) {
-        const material = mesh?.material;
-        if (!material)
-            continue;
         const ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
-        const slotBinding = resolveProjectionSlotBinding(slotBindings, ownerNodePath, node.id);
-        if (!slotBinding)
-            continue;
-        const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-        if (!slotMaterial)
-            continue;
-        if (slotMaterial !== material)
-            clonedMaterials.push(slotMaterial);
-        applyProjectionArtistMaterialProfile(options, slotMaterial, slotBinding.profile);
+        const meshSlotBindingMatches = resolveProjectionSlotBindingMatches(slotBindings, ownerNodePath, node.id);
+        for (const { binding: slotBinding, matchKind } of meshSlotBindingMatches) {
+            unmatchedSlotBindings.delete(slotBinding);
+            if (!readProjectionWritableMeshMaterial(mesh)) {
+                emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                    applied: false,
+                    matchKind,
+                    meshOwnerNodePath: ownerNodePath,
+                    targetMaterialStatus: 'missingMaterial',
+                    warningMessage: 'Slot material profile was not applied because the matched mesh has no target material.',
+                });
+                continue;
+            }
+            const resolution = resolveProjectionSlotMaterialTarget(mesh, materialCounts, slotBinding.slot, ownerNodePath, {
+                projectionNodeId: node.id,
+                primitiveSingleMaterialFallbackAllowed: isProjectionSinglePrimitiveMaterialSlot(slotBinding.slot, assetMaterialSlots),
+            });
+            const targetMaterial = resolution.target?.material ?? readProjectionWritableMeshMaterial(mesh);
+            if (!resolution.target) {
+                emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                    applied: false,
+                    matchKind,
+                    meshOwnerNodePath: ownerNodePath,
+                    targetMaterialStatus: resolution.targetMaterialStatus,
+                    targetMaterialName: readProjectionMaterialName(targetMaterial),
+                    targetMaterialType: readProjectionMaterialType(targetMaterial),
+                    warningMessage: resolution.warningMessage,
+                });
+                continue;
+            }
+            const target = resolution.target;
+            clonedMaterials.push(...target.clonedMaterials);
+            applyProjectionArtistMaterialProfile(options, target.material, slotBinding.profile);
+            emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                applied: true,
+                matchKind,
+                meshOwnerNodePath: ownerNodePath,
+                targetMaterialStatus: resolution.targetMaterialStatus,
+                targetMaterialName: readProjectionMaterialName(target.material),
+                targetMaterialType: readProjectionMaterialType(target.material),
+            });
+        }
+    }
+    for (const slotBinding of unmatchedSlotBindings) {
+        emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+            applied: false,
+            matchKind: 'none',
+            meshOwnerNodePath: null,
+            targetMaterialStatus: 'missingMeshOwner',
+            warningMessage: 'Slot material profile was not applied because no imported mesh matched its owner path.',
+        });
     }
     return clonedMaterials;
 }
@@ -1265,6 +1542,40 @@ function applyProjectionArtistMaterialProfile(options, material, profile) {
         resolveTextureUrl: options.resolveTextureUrl,
     });
 }
+function emitProjectionSlotMaterialProfileDiagnostic(options, projectionNodeId, slotBinding, diagnostic) {
+    emitProjectionMaterialProfileDiagnostic(options, {
+        projectionNodeId,
+        source: slotBinding.source,
+        slotId: slotBinding.slot.slotId,
+        ownerNodePath: slotBinding.slot.ownerNodePath,
+        primitiveIndex: slotBinding.slot.primitiveIndex,
+        ...diagnostic,
+    });
+}
+function emitProjectionMaterialProfileDiagnostic(options, diagnostic) {
+    options.onMaterialProfileDiagnostic?.(diagnostic);
+    if (!diagnostic.warningMessage)
+        return;
+    options.logger?.warn?.('[BabylonEditorProjection] Material profile diagnostic warning', {
+        projectionNodeId: diagnostic.projectionNodeId,
+        source: diagnostic.source,
+        slotId: diagnostic.slotId,
+        ownerNodePath: diagnostic.ownerNodePath,
+        meshOwnerNodePath: diagnostic.meshOwnerNodePath,
+        matchKind: diagnostic.matchKind,
+        targetMaterialStatus: diagnostic.targetMaterialStatus,
+        warningMessage: diagnostic.warningMessage,
+    });
+}
+function readProjectionMaterialName(material) {
+    const name = material?.name;
+    return typeof name === 'string' && name.trim() ? name.trim() : undefined;
+}
+function readProjectionMaterialType(material) {
+    const getClassName = material?.getClassName;
+    const className = typeof getClassName === 'function' ? getClassName.call(material) : null;
+    return typeof className === 'string' && className.trim() ? className.trim() : className;
+}
 function createProjectionMaterialSlotBindings(node) {
     const bindings = [];
     const occupiedOwnerPaths = new Set();
@@ -1273,14 +1584,14 @@ function createProjectionMaterialSlotBindings(node) {
         const slot = createProjectionMaterialSlotDescriptor(binding?.slot, node.id);
         if (!profile || !slot)
             continue;
-        bindings.push({ slot, profile });
+        bindings.push({ slot, profile, source: 'slotBinding' });
         occupiedOwnerPaths.add(slot.matchKey);
     }
     for (const [ownerNodePath, profile] of Object.entries(node.artistMaterialSlotProfiles ?? {})) {
         const slot = createProjectionMaterialSlotDescriptor({ ownerNodePath }, node.id);
         if (!profile || !slot || occupiedOwnerPaths.has(slot.matchKey))
             continue;
-        bindings.push({ slot, profile });
+        bindings.push({ slot, profile, source: 'legacySlotProfile' });
         occupiedOwnerPaths.add(slot.matchKey);
     }
     return bindings;
@@ -1309,6 +1620,8 @@ function createProjectionMaterialSlotDescriptor(value, projectionNodeId) {
     const materialNames = Array.isArray(value.materialNames)
         ? value.materialNames.filter((item) => typeof item === 'string' && !!item.trim()).map(item => item.trim())
         : undefined;
+    const triangleCount = Number.isFinite(value.triangleCount) ? value.triangleCount : undefined;
+    const boundingBox = readProjectionMaterialSlotBoundingBox(value.boundingBox);
     return {
         ...(slotId ? { slotId } : {}),
         ownerNodePath,
@@ -1323,27 +1636,58 @@ function createProjectionMaterialSlotDescriptor(value, projectionNodeId) {
             : {}),
         ...(materialName ? { materialName } : {}),
         ...(materialNames && materialNames.length > 0 ? { materialNames } : {}),
+        ...(triangleCount != null ? { triangleCount } : {}),
+        ...(boundingBox ? { boundingBox } : {}),
         key: slotId || ownerNodePath,
         normalizedOwnerNodePath: ownerNodePath,
         matchKey: createMaterialSlotOwnerPathMatchKey(ownerNodePath, { projectionNodeId }),
     };
 }
-function resolveProjectionSlotBinding(slotBindings, ownerNodePath, projectionNodeId) {
+function readProjectionMaterialSlotBoundingBox(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const min = readProjectionMaterialSlotBoundsTuple(record.min);
+    const max = readProjectionMaterialSlotBoundsTuple(record.max);
+    if (!min && !max)
+        return undefined;
+    return {
+        ...(min ? { min } : {}),
+        ...(max ? { max } : {}),
+    };
+}
+function readProjectionMaterialSlotBoundsTuple(value) {
+    if (!Array.isArray(value) || value.length < 3)
+        return undefined;
+    const tuple = value.slice(0, 3).map(item => Number(item));
+    if (!tuple.every(item => Number.isFinite(item)))
+        return undefined;
+    return tuple;
+}
+function resolveProjectionSlotBindingMatches(slotBindings, ownerNodePath, projectionNodeId) {
     if (ownerNodePath == null)
-        return null;
+        return [];
     const normalized = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
     const normalizedMatchKey = createMaterialSlotOwnerPathMatchKey(normalized, { projectionNodeId });
-    let descendantMatch = null;
+    const exactMatches = [];
+    const descendantMatches = [];
+    let descendantMatchLength = -1;
     for (const binding of slotBindings) {
-        if (binding.slot.matchKey === normalizedMatchKey)
-            return binding;
+        if (binding.slot.matchKey === normalizedMatchKey) {
+            exactMatches.push({ binding, matchKind: 'exact' });
+            continue;
+        }
         if (isMaterialSlotOwnerPathMatch(normalized, binding.slot.normalizedOwnerNodePath, { projectionNodeId })) {
-            if (!descendantMatch || binding.slot.matchKey.length > descendantMatch.slot.matchKey.length) {
-                descendantMatch = binding;
+            if (binding.slot.matchKey.length > descendantMatchLength) {
+                descendantMatches.length = 0;
+                descendantMatchLength = binding.slot.matchKey.length;
+            }
+            if (binding.slot.matchKey.length === descendantMatchLength) {
+                descendantMatches.push({ binding, matchKind: 'descendant' });
             }
         }
     }
-    return descendantMatch;
+    return exactMatches.length > 0 ? exactMatches : descendantMatches;
 }
 function buildProjectionOwnerNodePath(node, rootNode, projectionNodeId) {
     if (!node || !rootNode || node === rootNode)
@@ -1390,6 +1734,363 @@ function resolveProjectionAssetMeshSelectionKey(asset, ownerNodePath, projection
     }
     return bestSlot?.key ?? ownerNodePath;
 }
+function resolveProjectionAssetMeshSelectionSlots(materialSlots, ownerNodePath, projectionNodeId) {
+    const normalizedOwnerPath = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
+    const normalizedMatchKey = createMaterialSlotOwnerPathMatchKey(normalizedOwnerPath, { projectionNodeId });
+    const exactMatches = [];
+    const descendantMatches = [];
+    let descendantMatchLength = -1;
+    for (const slot of materialSlots) {
+        if (slot.matchKey === normalizedMatchKey) {
+            exactMatches.push(slot);
+            continue;
+        }
+        if (isMaterialSlotOwnerPathMatch(normalizedOwnerPath, slot.normalizedOwnerNodePath, { projectionNodeId })) {
+            if (slot.matchKey.length > descendantMatchLength) {
+                descendantMatches.length = 0;
+                descendantMatchLength = slot.matchKey.length;
+            }
+            if (slot.matchKey.length === descendantMatchLength)
+                descendantMatches.push(slot);
+        }
+    }
+    return exactMatches.length > 0 ? exactMatches : descendantMatches;
+}
+function createProjectionAssetMeshSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots) {
+    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, ownerNodePath, node.id)
+        .filter(slot => Number.isInteger(slot.primitiveIndex));
+    if (primitiveSlots.length <= 1)
+        return [];
+    const subMeshes = Array.isArray(mesh?.subMeshes) ? mesh.subMeshes : [];
+    if (subMeshes.length <= 1)
+        return [];
+    const proxies = [];
+    const createdNodeIds = new Set();
+    for (const slot of primitiveSlots) {
+        const primitiveIndex = slot.primitiveIndex;
+        if (primitiveIndex == null || primitiveIndex < 0)
+            continue;
+        const subMesh = subMeshes[primitiveIndex];
+        if (!subMesh)
+            continue;
+        const selectionNodeId = createAssetMeshProjectionNodeId(node.id, slot.key);
+        if (createdNodeIds.has(selectionNodeId))
+            continue;
+        const proxy = createProjectionSubMeshSelectionProxy(options, node, mesh, subMesh, {
+            selectionNodeId,
+            ownerNodePath,
+            slotSelectionKey: slot.key,
+            primitiveIndex,
+        });
+        if (!proxy)
+            continue;
+        createdNodeIds.add(selectionNodeId);
+        proxies.push(proxy);
+        projection.selectionMeshes = projection.selectionMeshes ?? [];
+        projection.selectionMeshes.push(proxy);
+        if (proxy.material)
+            projection.runtimeObjects.push(proxy.material);
+    }
+    return proxies;
+}
+function resolveProjectionSplitPrimitiveMeshSelectionSlot(mesh, materialSlots, ownerNodePath, projectionNodeId, ownerMeshCount, ordinalByOwnerKey) {
+    const subMeshes = Array.isArray(mesh?.subMeshes) ? mesh.subMeshes : [];
+    if (subMeshes.length > 1)
+        return null;
+    if ((mesh?.getTotalVertices?.() ?? 0) <= 0)
+        return null;
+    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, ownerNodePath, projectionNodeId)
+        .filter((slot) => (Number.isInteger(slot.primitiveIndex)))
+        .sort((left, right) => left.primitiveIndex - right.primitiveIndex);
+    if (primitiveSlots.length <= 1)
+        return null;
+    if (ownerMeshCount < primitiveSlots.length)
+        return null;
+    const ownerKey = createMaterialSlotOwnerPathMatchKey(ownerNodePath, { projectionNodeId });
+    const ordinal = ordinalByOwnerKey.get(ownerKey) ?? 0;
+    ordinalByOwnerKey.set(ownerKey, ordinal + 1);
+    const namedSlot = primitiveSlots.find(slot => isProjectionRuntimeSplitPrimitiveOwnerNode(mesh, slot));
+    if (namedSlot)
+        return namedSlot;
+    return primitiveSlots.find(slot => slot.primitiveIndex === ordinal) ?? primitiveSlots[ordinal] ?? null;
+}
+function createProjectionPrimitiveBoundsSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, ownerMeshCount) {
+    const subMeshes = Array.isArray(mesh?.subMeshes) ? mesh.subMeshes : [];
+    if (subMeshes.length > 1)
+        return [];
+    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, ownerNodePath, node.id)
+        .filter(slot => Number.isInteger(slot.primitiveIndex) && !!slot.boundingBox)
+        .sort((left, right) => (left.primitiveIndex ?? 0) - (right.primitiveIndex ?? 0));
+    if (primitiveSlots.length <= 1)
+        return [];
+    if (ownerMeshCount >= primitiveSlots.length)
+        return [];
+    const proxies = [];
+    const createdNodeIds = new Set();
+    for (const slot of primitiveSlots) {
+        const primitiveIndex = slot.primitiveIndex;
+        if (primitiveIndex == null || primitiveIndex < 0)
+            continue;
+        const selectionNodeId = createAssetMeshProjectionNodeId(node.id, slot.key);
+        if (createdNodeIds.has(selectionNodeId))
+            continue;
+        const proxy = createProjectionPrimitiveBoundsSelectionProxy(options, node, mesh, slot, {
+            selectionNodeId,
+            ownerNodePath,
+            slotSelectionKey: slot.key,
+            primitiveIndex,
+        });
+        if (!proxy)
+            continue;
+        createdNodeIds.add(selectionNodeId);
+        proxies.push(proxy);
+        projection.selectionMeshes = projection.selectionMeshes ?? [];
+        projection.selectionMeshes.push(proxy);
+        if (proxy.material)
+            projection.runtimeObjects.push(proxy.material);
+    }
+    return proxies;
+}
+function createProjectionPrimitiveBoundsSelectionProxy(options, node, sourceMesh, slot, metadata) {
+    const { babylon, scene } = options;
+    const MeshBuilder = babylon.MeshBuilder;
+    const StandardMaterial = babylon.StandardMaterial;
+    if (!MeshBuilder?.CreateBox || !StandardMaterial)
+        return null;
+    const bounds = readProjectionPrimitiveSlotBounds(slot);
+    if (!bounds)
+        return null;
+    const size = {
+        x: Math.max(Math.abs(bounds.max.x - bounds.min.x), MIN_SELECTION_BOUNDS_PROXY_SIZE),
+        y: Math.max(Math.abs(bounds.max.y - bounds.min.y), MIN_SELECTION_BOUNDS_PROXY_SIZE),
+        z: Math.max(Math.abs(bounds.max.z - bounds.min.z), MIN_SELECTION_BOUNDS_PROXY_SIZE),
+    };
+    const center = {
+        x: (bounds.min.x + bounds.max.x) / 2,
+        y: (bounds.min.y + bounds.max.y) / 2,
+        z: (bounds.min.z + bounds.max.z) / 2,
+    };
+    const proxy = MeshBuilder.CreateBox(`${sourceMesh.name ?? node.id}.selectionBoundsProxy.${sanitizeProjectionImportSnapshotId(metadata.slotSelectionKey)}`, {
+        width: size.x,
+        height: size.y,
+        depth: size.z,
+    }, scene);
+    if (!proxy)
+        return null;
+    proxy.parent = sourceMesh;
+    proxy.position.x = center.x;
+    proxy.position.y = center.y;
+    proxy.position.z = center.z;
+    proxy.isPickable = false;
+    proxy.metadata = {
+        ...(proxy.metadata ?? {}),
+        disablePlanarShadow: true,
+        disableBlobShadow: true,
+        disableStaticProjectedShadow: true,
+        editorProjectionSelectionProxy: true,
+        editorProjectionSelectionBoundsProxy: true,
+        editorProjection: {
+            nodeId: metadata.selectionNodeId,
+            rootNodeId: node.id,
+            sourceId: node.asset?.sourceId,
+            ownerNodePath: metadata.ownerNodePath,
+            slotSelectionKey: metadata.slotSelectionKey,
+            primitiveIndex: metadata.primitiveIndex,
+            runtimeKind: 'assetMeshSelectionProxy',
+            ...createProjectionShadowMetadata(node),
+        },
+    };
+    const material = new StandardMaterial(`${proxy.name}.material`, scene);
+    material.alpha = 0;
+    material.disableLighting = true;
+    material.backFaceCulling = false;
+    if ('disableColorWrite' in material) {
+        material.disableColorWrite = true;
+    }
+    proxy.material = material;
+    return proxy;
+}
+function readProjectionPrimitiveSlotBounds(slot) {
+    const min = readProjectionMaterialSlotBoundsVec3(slot.boundingBox?.min);
+    const max = readProjectionMaterialSlotBoundsVec3(slot.boundingBox?.max);
+    if (!min || !max)
+        return null;
+    return { min, max };
+}
+function readProjectionMaterialSlotBoundsVec3(value) {
+    if (!Array.isArray(value) || value.length < 3)
+        return null;
+    const [x, y, z] = value.map(item => Number(item));
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        return null;
+    return { x, y, z };
+}
+function isProjectionRuntimeSplitPrimitiveOwnerNode(ownerNode, slot) {
+    if (slot.primitiveIndex == null)
+        return false;
+    const primitiveNames = new Set();
+    for (const baseName of [
+        slot.ownerNodePath,
+        readProjectionOwnerPathLastSegment(slot.ownerNodePath),
+        stripProjectionPrimitiveLabelSuffix(readProjectionSlotLabel(slot)),
+        readProjectionSlotLabel(slot),
+    ]) {
+        addProjectionRuntimeOwnerName(primitiveNames, appendProjectionPrimitiveOwnerSuffix(baseName, slot.primitiveIndex));
+    }
+    return collectProjectionRuntimeNodeMatchNames(ownerNode).some(name => primitiveNames.has(name));
+}
+function collectProjectionRuntimeNodeMatchNames(node) {
+    const rawNames = [
+        typeof node?.name === 'string' ? node.name : null,
+        typeof node?.id === 'string' ? node.id : null,
+        readProjectionRuntimeNodeDisplayName(node),
+        readProjectionSourceNodeSegment(node),
+    ];
+    const names = new Set();
+    for (const rawName of rawNames) {
+        addProjectionRuntimeOwnerName(names, rawName);
+        for (const tailName of collectProjectionRuntimeOwnerTailNames(rawName)) {
+            addProjectionRuntimeOwnerName(names, tailName);
+        }
+    }
+    return [...names];
+}
+function readProjectionRuntimeNodeDisplayName(node) {
+    const name = typeof node?.name === 'string' ? node.name.trim() : '';
+    const id = typeof node?.id === 'string' ? node.id.trim() : '';
+    if (name && id && name !== id)
+        return `${name} (${id})`;
+    return name || id || null;
+}
+function collectProjectionRuntimeOwnerTailNames(value) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (!raw)
+        return [];
+    const names = new Set();
+    const withoutClonePrefix = raw.replace(/^Clone of\s+/i, '').trim();
+    for (const candidate of [raw, withoutClonePrefix]) {
+        const colonTail = candidate.includes(':') ? candidate.split(':').pop() : '';
+        const dotTail = candidate.includes('.') ? candidate.split('.').pop() : '';
+        if (colonTail)
+            names.add(colonTail);
+        if (dotTail)
+            names.add(dotTail);
+    }
+    return [...names];
+}
+function readProjectionOwnerPathLastSegment(ownerNodePath) {
+    const segments = ownerNodePath.split('/').map(segment => segment.trim()).filter(Boolean);
+    return segments.length > 0 ? segments[segments.length - 1] ?? null : null;
+}
+function stripProjectionPrimitiveLabelSuffix(value) {
+    if (typeof value !== 'string')
+        return null;
+    const stripped = value.replace(/\s*\/\s*Primitive\s+\d+\s*$/i, '').trim();
+    return stripped || null;
+}
+function appendProjectionPrimitiveOwnerSuffix(value, primitiveIndex) {
+    if (typeof value !== 'string')
+        return null;
+    const baseName = stripProjectionPrimitiveLabelSuffix(value) ?? value.trim();
+    return baseName ? `${baseName}_primitive${primitiveIndex}` : null;
+}
+function readProjectionSlotLabel(slot) {
+    const label = typeof slot.label === 'string' ? slot.label.trim() : '';
+    if (label)
+        return label;
+    const materialName = typeof slot.materialName === 'string' ? slot.materialName.trim() : '';
+    return materialName || null;
+}
+function addProjectionRuntimeOwnerName(names, value) {
+    const normalized = normalizeProjectionRuntimeOwnerName(value);
+    if (normalized)
+        names.add(normalized);
+}
+function normalizeProjectionRuntimeOwnerName(value) {
+    const trimmed = typeof value === 'string' ? value.trim() : '';
+    if (!trimmed)
+        return null;
+    return createMaterialSlotOwnerPathMatchKey(trimmed);
+}
+function createProjectionSubMeshSelectionProxy(options, node, sourceMesh, subMesh, metadata) {
+    const { babylon, scene } = options;
+    const Mesh = babylon.Mesh;
+    const VertexData = babylon.VertexData;
+    const VertexBuffer = babylon.VertexBuffer;
+    const StandardMaterial = babylon.StandardMaterial;
+    if (!Mesh || !VertexData || !VertexBuffer || !StandardMaterial)
+        return null;
+    const positions = sourceMesh.getVerticesData?.(VertexBuffer.PositionKind, true, true);
+    if (!positions || positions.length < 9)
+        return null;
+    const sourceIndices = sourceMesh.getIndices?.(true, true) ?? null;
+    const subIndices = readProjectionSubMeshIndices(sourceIndices, subMesh);
+    if (subIndices.length < 3)
+        return null;
+    const indexMap = new Map();
+    const proxyPositions = [];
+    const proxyIndices = [];
+    for (const sourceIndex of subIndices) {
+        const vertexIndex = Number(sourceIndex);
+        if (!Number.isInteger(vertexIndex) || vertexIndex < 0)
+            continue;
+        let mappedIndex = indexMap.get(vertexIndex);
+        if (mappedIndex == null) {
+            const positionIndex = vertexIndex * 3;
+            if (positionIndex + 2 >= positions.length)
+                continue;
+            mappedIndex = indexMap.size;
+            indexMap.set(vertexIndex, mappedIndex);
+            proxyPositions.push(Number(positions[positionIndex] ?? 0), Number(positions[positionIndex + 1] ?? 0), Number(positions[positionIndex + 2] ?? 0));
+        }
+        proxyIndices.push(mappedIndex);
+    }
+    if (proxyPositions.length < 9 || proxyIndices.length < 3)
+        return null;
+    const proxy = new Mesh(`${sourceMesh.name ?? node.id}.selectionProxy.${sanitizeProjectionImportSnapshotId(metadata.slotSelectionKey)}`, scene);
+    proxy.parent = sourceMesh;
+    proxy.isPickable = false;
+    proxy.metadata = {
+        ...(proxy.metadata ?? {}),
+        disablePlanarShadow: true,
+        disableBlobShadow: true,
+        disableStaticProjectedShadow: true,
+        editorProjectionSelectionProxy: true,
+        editorProjection: {
+            nodeId: metadata.selectionNodeId,
+            rootNodeId: node.id,
+            sourceId: node.asset?.sourceId,
+            ownerNodePath: metadata.ownerNodePath,
+            slotSelectionKey: metadata.slotSelectionKey,
+            primitiveIndex: metadata.primitiveIndex,
+            runtimeKind: 'assetMeshSelectionProxy',
+            ...createProjectionShadowMetadata(node),
+        },
+    };
+    const vertexData = new VertexData();
+    vertexData.positions = proxyPositions;
+    vertexData.indices = proxyIndices;
+    vertexData.applyToMesh(proxy, false);
+    const material = new StandardMaterial(`${proxy.name}.material`, scene);
+    material.alpha = 0;
+    material.disableLighting = true;
+    material.backFaceCulling = false;
+    if ('disableColorWrite' in material) {
+        material.disableColorWrite = true;
+    }
+    proxy.material = material;
+    return proxy;
+}
+function readProjectionSubMeshIndices(sourceIndices, subMesh) {
+    const indexStart = Number.isInteger(subMesh?.indexStart) ? subMesh.indexStart : 0;
+    const indexCount = Number.isInteger(subMesh?.indexCount) ? subMesh.indexCount : 0;
+    if (sourceIndices && indexCount > 0) {
+        return Array.from(sourceIndices).slice(indexStart, indexStart + indexCount);
+    }
+    const verticesStart = Number.isInteger(subMesh?.verticesStart) ? subMesh.verticesStart : 0;
+    const verticesCount = Number.isInteger(subMesh?.verticesCount) ? subMesh.verticesCount : 0;
+    return Array.from({ length: Math.max(0, verticesCount) }, (_, index) => verticesStart + index);
+}
 function readProjectionAssetMaterialSlots(asset, projectionNodeId) {
     const rawSlots = asset.metadata?.materialSlots;
     if (!Array.isArray(rawSlots))
@@ -1420,30 +2121,159 @@ function readProjectionAssetMaterialSlotString(value) {
 function countProjectionMeshMaterials(meshes) {
     const counts = new Map();
     for (const mesh of meshes) {
-        const material = mesh?.material;
+        const material = readProjectionWritableMeshMaterial(mesh);
         if (!material)
             continue;
         counts.set(material, (counts.get(material) ?? 0) + 1);
     }
     return counts;
 }
+function isProjectionSinglePrimitiveMaterialSlot(slot, materialSlots) {
+    if (slot.primitiveIndex !== 0 || materialSlots.length === 0)
+        return false;
+    const matchingPrimitiveSlots = materialSlots.filter(candidate => (candidate.primitiveIndex != null
+        && candidate.matchKey === slot.matchKey
+        && isProjectionMaterialSlotSameMesh(candidate, slot)));
+    return matchingPrimitiveSlots.length === 1 && matchingPrimitiveSlots[0]?.primitiveIndex === 0;
+}
+function isProjectionMaterialSlotSameMesh(left, right) {
+    if (left.meshIndex != null || right.meshIndex != null) {
+        return left.meshIndex === right.meshIndex;
+    }
+    return true;
+}
 function detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath) {
-    const material = mesh?.material;
-    if (!material || typeof material !== 'object')
-        return material;
+    const materialOwner = resolveProjectionWritableMaterialOwner(mesh);
+    const material = materialOwner?.material;
+    if (!material)
+        return null;
+    const projectionOwnsMaterialLifecycle = materialOwner === mesh;
+    if (typeof material !== 'object') {
+        return { material, clonedMaterials: [], projectionOwnsMaterialLifecycle };
+    }
     const materialUseCount = materialCounts.get(material) ?? 0;
     if (materialUseCount <= 1)
-        return material;
+        return { material, clonedMaterials: [], projectionOwnsMaterialLifecycle };
     const clone = typeof material.clone === 'function'
         ? material.clone(createProjectionSlotMaterialName(material, ownerNodePath))
         : null;
     if (!clone)
         return null;
     cloneProjectionSubMaterials(clone, material, ownerNodePath);
-    mesh.material = clone;
+    materialOwner.material = clone;
     materialCounts.set(material, materialUseCount - 1);
     materialCounts.set(clone, 1);
-    return clone;
+    return {
+        material: clone,
+        clonedMaterials: projectionOwnsMaterialLifecycle ? [clone] : [],
+        projectionOwnsMaterialLifecycle,
+    };
+}
+function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNodePath, options) {
+    const material = readProjectionWritableMeshMaterial(mesh);
+    if (!material) {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingMaterial',
+            warningMessage: 'Slot material profile was not applied because the matched mesh has no target material.',
+        };
+    }
+    if (slot.primitiveIndex == null) {
+        const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+        if (!detachResult) {
+            return {
+                target: null,
+                targetMaterialStatus: 'missingTargetMaterial',
+                warningMessage: 'Slot material profile was not applied because the mesh material could not be detached.',
+            };
+        }
+        return {
+            target: {
+                material: detachResult.material,
+                clonedMaterials: detachResult.clonedMaterials,
+            },
+            targetMaterialStatus: 'material',
+        };
+    }
+    if (!Array.isArray(material.subMaterials)) {
+        const isSplitPrimitiveOwner = isProjectionRuntimeSplitPrimitiveOwnerNode(mesh, slot);
+        if (!isSplitPrimitiveOwner && (slot.primitiveIndex !== 0 || !options.primitiveSingleMaterialFallbackAllowed)) {
+            return {
+                target: null,
+                targetMaterialStatus: 'missingSubMaterial',
+                warningMessage: 'Primitive slot material profile was not applied because the target mesh does not expose a matching subMaterial.',
+            };
+        }
+        const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+        if (!detachResult) {
+            return {
+                target: null,
+                targetMaterialStatus: 'missingTargetMaterial',
+                warningMessage: 'Primitive slot material profile was not applied because the fallback mesh material could not be detached.',
+            };
+        }
+        return {
+            target: {
+                material: detachResult.material,
+                clonedMaterials: detachResult.clonedMaterials,
+            },
+            targetMaterialStatus: 'primitiveFallbackMaterial',
+        };
+    }
+    const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+    const slotMaterial = detachResult?.material;
+    if (!detachResult || !Array.isArray(slotMaterial.subMaterials)) {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingTargetMaterial',
+            warningMessage: 'Primitive slot material profile was not applied because the multi-material target could not be detached.',
+        };
+    }
+    const subMaterials = slotMaterial.subMaterials;
+    const subMaterial = subMaterials[slot.primitiveIndex];
+    if (!subMaterial || typeof subMaterial !== 'object' || typeof subMaterial.clone !== 'function') {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingSubMaterial',
+            warningMessage: 'Primitive slot material profile was not applied because the target subMaterial is missing or cannot be cloned.',
+        };
+    }
+    const clonedSubMaterial = subMaterial.clone(createProjectionSlotSubMaterialName(subMaterial, ownerNodePath, slot.primitiveIndex));
+    if (!clonedSubMaterial) {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingSubMaterial',
+            warningMessage: 'Primitive slot material profile was not applied because the target subMaterial clone failed.',
+        };
+    }
+    subMaterials[slot.primitiveIndex] = clonedSubMaterial;
+    return {
+        target: {
+            material: clonedSubMaterial,
+            clonedMaterials: [
+                ...detachResult.clonedMaterials,
+                ...(detachResult.projectionOwnsMaterialLifecycle ? [clonedSubMaterial] : []),
+            ],
+        },
+        targetMaterialStatus: 'subMaterial',
+    };
+}
+function readProjectionWritableMeshMaterial(mesh) {
+    return resolveProjectionWritableMaterialOwner(mesh)?.material ?? null;
+}
+function resolveProjectionWritableMaterialOwner(mesh) {
+    if (!mesh || typeof mesh !== 'object')
+        return null;
+    if (isProjectionInstancedMesh(mesh) && mesh.sourceMesh)
+        return mesh.sourceMesh;
+    return mesh;
+}
+function isProjectionInstancedMesh(mesh) {
+    if (!mesh || typeof mesh !== 'object')
+        return false;
+    const className = typeof mesh.getClassName === 'function' ? mesh.getClassName() : undefined;
+    return className === 'InstancedMesh'
+        || (mesh.constructor?.name === 'InstancedMesh' && !!mesh.sourceMesh);
 }
 function cloneProjectionSubMaterials(clone, source, ownerNodePath) {
     if (!Array.isArray(clone?.subMaterials) || !Array.isArray(source?.subMaterials))
@@ -2064,17 +2894,26 @@ function syncProjectionSelection(babylon, projections, selection) {
     for (const [nodeId, projection] of projections) {
         const rootSelected = selectedIds.has(nodeId);
         const rootActive = selection.activeId === nodeId;
+        const proxyNodeIds = new Set((projection.selectionMeshes ?? [])
+            .map(readProjectionMeshSelectionNodeId)
+            .filter((id) => !!id));
         let projectionSelected = false;
         for (const mesh of projection.outlineMeshes) {
-            const meshNodeId = typeof mesh?.metadata?.editorProjection?.nodeId === 'string'
-                ? mesh.metadata.editorProjection.nodeId
-                : nodeId;
-            const selected = rootSelected || selectedIds.has(meshNodeId);
+            const meshNodeId = readProjectionMeshSelectionNodeId(mesh) ?? nodeId;
+            const selected = rootSelected || (!proxyNodeIds.has(meshNodeId) && selectedIds.has(meshNodeId));
             const active = rootActive || selection.activeId === meshNodeId;
             if (selected)
                 projectionSelected = true;
             syncProjectionMeshSelection(mesh, selected, active, Color4);
         }
+        for (const mesh of projection.selectionMeshes ?? []) {
+            const meshNodeId = readProjectionMeshSelectionNodeId(mesh) ?? nodeId;
+            const selected = selectedIds.has(meshNodeId);
+            const active = selection.activeId === meshNodeId;
+            if (selected)
+                projectionSelected = true;
+            syncProjectionMeshSelection(mesh, selected, active, Color4);
+        }
         if (projectionSelected) {
             projection.selectionEdgesPrewarmCancel?.();
             projection.selectionEdgesPrewarmCancel = null;
@@ -2099,7 +2938,7 @@ function syncProjectionMeshSelection(mesh, selected, active, Color4) {
     }
 }
 function prewarmProjectionSelectionEdges(projection) {
-    for (const mesh of projection.outlineMeshes) {
+    for (const mesh of [...projection.outlineMeshes, ...(projection.selectionMeshes ?? [])]) {
         if (mesh?.metadata?.editorProjectionSelectionEdgesPrewarmed)
             continue;
         if (mesh?.metadata?.editorProjectionSelectionEdgesSelected)