@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

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

@@ -1,11 +1,12 @@
 import { cloneEditorTransformMatrix, combineEditorTransforms, createIdentityEditorTransformMatrix, createEditorTransformMatrixSnapshot, isEditorTransformMatrixSnapshot, readEditorTransformPosition, toEditorLocalTransformFromWorld, } from '@fps-games/editor-core';
-import { applyBabylonDefaultOutline } from '@fps-games/babylon-renderer';
+import { applyBabylonDefaultOutline, collectBabylonMaterialOwnerCandidates, resolveBabylonEffectiveMaterialOwner, } from '@fps-games/babylon-renderer';
+import { isMaterialOwnerResolutionPointerVerified, resolveMaterialOwner, } from '@fps-games/playable-contracts';
 import { applyArtistMaterialProfileToRuntimeMaterial } from './material-property-adapter.js';
 import { pickBabylonProjectionNodeIdAt, resolveBabylonPickSelectionNodeId, resolveBabylonProjectionNodeId, } from './projection-pick-resolver.js';
 import { normalizeProjectionOwnerNodePath, readProjectionSourceNodeSegment, } from './projection-source-owner-path.js';
 import { createMaterialSlotOwnerPathMatchKey, isMaterialSlotOwnerPathMatch, } from './material-slot-source-resolver.js';
 import { isBabylonPrimitiveProjectionSharedMaterial, } from './primitive-projection-instancing.js';
-const LARGE_SELECTION_EDGE_LIMIT = 200;
+import { createBabylonEditorSelectionPresentationController, } from './selection-presentation-controller.js';
 const PROJECTION_LOCAL_MATRIX_METADATA_KEY = 'editorLocalTransformMatrix';
 const MIN_SELECTION_BOUNDS_PROXY_SIZE = 0.002;
 const ASSET_MESH_SELECTION_SEPARATOR = '::assetMesh::';
@@ -16,11 +17,18 @@ function requireBabylonCtor(value, name) {
 }
 export function createBabylonEditorProjection(options) {
     const projections = new Map();
+    const projectionNodes = new Map();
     const projectionParentIds = new Map();
     const projectionAuthoredActive = new Map();
     const previewVisibilityOverrides = new Map();
     const shadowDebugOverlayObjects = [];
-    const selectionEdgesPrewarm = options.selectionEdgesPrewarm ?? 'eager';
+    const selectionPresentation = options.selectionPresentationController
+        ?? createBabylonEditorSelectionPresentationController({
+            babylon: options.babylon,
+            scene: options.scene,
+            logger: options.logger,
+            prewarm: options.selectionEdgesPrewarm !== undefined,
+        });
     const activeBatches = new Set();
     const idleWaiters = new Set();
     let nextBatchId = 1;
@@ -115,22 +123,21 @@ export function createBabylonEditorProjection(options) {
     const trackAsyncProjection = (batch, node, projection) => {
         batch.asyncNodeIds.push(node.id);
         batch.pendingNodeIds.add(node.id);
-        return loadModelProjection(options, node, projection).finally(() => {
+        return loadModelProjection(options, node, projection, () => projectionNodes.get(node.id) ?? node).finally(() => {
             batch.pendingNodeIds.delete(node.id);
             batch.settledNodeIds.add(node.id);
             if (projections.get(node.id) === projection && !projection.root.isDisposed?.()) {
                 delete projection.loadPromise;
                 applyProjectionPreviewVisibility(node.id);
-                applyProjectionOutline(node, projection);
-                scheduleProjectionSelectionEdgesPrewarm(projection);
+                applyProjectionOutline(projectionNodes.get(node.id) ?? node, projection);
+                selectionPresentation.updateProjectedNode(projection);
                 options.onProjectionReady?.({ nodeId: node.id, async: true });
             }
             scheduleBatchSettled(batch);
         });
     };
     const disposeProjectedNode = (projection) => {
-        projection.selectionEdgesPrewarmCancel?.();
-        projection.selectionEdgesPrewarmCancel = null;
+        selectionPresentation.detachProjectedNode(projection.nodeId);
         projection.importStructure = null;
         for (const animationGroup of projection.animationGroups) {
             animationGroup.dispose?.();
@@ -152,6 +159,7 @@ export function createBabylonEditorProjection(options) {
             disposeProjectedNode(projection);
         }
         projections.clear();
+        projectionNodes.clear();
         projectionParentIds.clear();
         projectionAuthoredActive.clear();
         previewVisibilityOverrides.clear();
@@ -184,17 +192,6 @@ export function createBabylonEditorProjection(options) {
         }
         return hadObjects;
     };
-    const scheduleProjectionSelectionEdgesPrewarm = (projection) => {
-        projection.selectionEdgesPrewarmCancel?.();
-        projection.selectionEdgesPrewarmCancel = null;
-        if (selectionEdgesPrewarm === 'lazy')
-            return;
-        if (selectionEdgesPrewarm === 'eager') {
-            prewarmProjectionSelectionEdges(projection);
-            return;
-        }
-        projection.selectionEdgesPrewarmCancel = scheduleIdleProjectionSelectionEdgesPrewarm(projection);
-    };
     const syncProjectionHierarchy = () => {
         for (const [nodeId, projection] of projections) {
             const parentId = projectionParentIds.get(nodeId) ?? null;
@@ -216,10 +213,12 @@ export function createBabylonEditorProjection(options) {
             root,
             outlineMeshes: [],
             selectionMeshes: [],
+            selectionPresentationTargets: [],
             animationGroups: [],
             runtimeObjects: [],
         };
         projections.set(node.id, projection);
+        projectionNodes.set(node.id, node);
         projectionParentIds.set(node.id, node.parentId ?? null);
         projectionAuthoredActive.set(node.id, node.active !== false);
         applyProjectionPreviewVisibility(node.id);
@@ -236,10 +235,9 @@ export function createBabylonEditorProjection(options) {
                 attachFallbackProjection(options.babylon, options.scene, node, projection, true);
             }
         }
-        if (!projection.loadPromise) {
+        if (!projection.loadPromise)
             applyProjectionOutline(node, projection);
-            scheduleProjectionSelectionEdgesPrewarm(projection);
-        }
+        selectionPresentation.attachProjectedNode(projection);
         if (!projection.loadPromise)
             batch.settledNodeIds.add(node.id);
         return projection;
@@ -256,6 +254,7 @@ export function createBabylonEditorProjection(options) {
         if (!existing)
             return;
         projections.delete(nodeId);
+        projectionNodes.delete(nodeId);
         projectionParentIds.delete(nodeId);
         projectionAuthoredActive.delete(nodeId);
         previewVisibilityOverrides.delete(nodeId);
@@ -309,6 +308,15 @@ export function createBabylonEditorProjection(options) {
             }
             return transforms;
         },
+        toNodeLocalTransform(nodeId, worldTransform) {
+            const projection = projections.get(nodeId);
+            if (!projection?.root)
+                return null;
+            const parent = projection.root.parent ?? null;
+            return parent
+                ? toEditorLocalTransformFromWorld(readProjectionWorldTransform(parent), worldTransform, { allowMatrixFallback: true })
+                : cloneProjectionTransformSnapshot(worldTransform);
+        },
         readNodeImportStructure(nodeId) {
             return cloneProjectionImportStructureSnapshot(projections.get(nodeId)?.importStructure ?? null);
         },
@@ -353,18 +361,20 @@ export function createBabylonEditorProjection(options) {
             const projection = projections.get(node.id);
             if (!projection)
                 return;
+            projectionNodes.set(node.id, node);
             projectionAuthoredActive.set(node.id, node.active !== false);
             applyProjectionPreviewVisibility(node.id);
             projectionParentIds.set(node.id, node.parentId ?? null);
             syncProjectionHierarchy();
             if (node.transform)
                 applyProjectionTransform(options.babylon, projection.root, node.transform);
-            scheduleProjectionSelectionEdgesPrewarm(projection);
+            selectionPresentation.updateProjectedNode(projection);
         },
         syncRuntimeNode(node) {
             const projection = projections.get(node.id);
             if (!projection || node.runtimeKind !== 'light')
                 return false;
+            projectionNodes.set(node.id, node);
             projectionAuthoredActive.set(node.id, node.active !== false);
             applyProjectionPreviewVisibility(node.id);
             projectionParentIds.set(node.id, node.parentId ?? null);
@@ -373,17 +383,21 @@ export function createBabylonEditorProjection(options) {
                 applyProjectionTransform(options.babylon, projection.root, node.transform);
             if (!syncRuntimeLightProjection(options.babylon, options.scene, node, projection))
                 return false;
-            scheduleProjectionSelectionEdgesPrewarm(projection);
+            selectionPresentation.updateProjectedNode(projection);
             return true;
         },
         syncNodeMetadata(node) {
             const projection = projections.get(node.id);
             if (!projection)
                 return;
+            projectionNodes.set(node.id, node);
             syncProjectionNodeMetadata(projection, node);
         },
         syncSelection(selection) {
-            syncProjectionSelection(options.babylon, projections, selection);
+            selectionPresentation.syncSelection(selection);
+        },
+        getSelectionPresentationDiagnostics() {
+            return selectionPresentation.getDiagnostics();
         },
         resolveProjectionNodeId(target) {
             return resolveBabylonProjectionNodeId(target);
@@ -451,6 +465,7 @@ export function createBabylonEditorProjection(options) {
         },
         dispose() {
             disposeAll();
+            selectionPresentation.dispose();
         },
     };
 }
@@ -632,10 +647,14 @@ function averagePositions(transforms) {
 function getProjectionSelectionBounds(projections, nodeIds) {
     let min = null;
     let max = null;
+    let oriented;
     for (const nodeId of nodeIds) {
-        const bounds = readProjectionBounds(resolveProjectionSelectionBoundsTarget(projections, nodeId));
+        const target = resolveProjectionSelectionBoundsTarget(projections, nodeId);
+        const bounds = readProjectionBounds(target);
         if (!bounds)
             continue;
+        if (nodeIds.length === 1)
+            oriented = readProjectionOrientedBounds(target) ?? undefined;
         min = min
             ? {
                 x: Math.min(min.x, bounds.min.x),
@@ -667,6 +686,7 @@ function getProjectionSelectionBounds(projections, nodeIds) {
             y: max.y - min.y,
             z: max.z - min.z,
         },
+        ...(oriented ? { oriented } : {}),
     };
 }
 function resolveProjectionSelectionBoundsTarget(projections, nodeId) {
@@ -712,6 +732,95 @@ function readProjectionBounds(root) {
         max: position,
     };
 }
+function readProjectionOrientedBounds(root) {
+    if (!root)
+        return null;
+    const worldMatrix = root.computeWorldMatrix?.(true) ?? root.getWorldMatrix?.();
+    const inverseWorldMatrix = worldMatrix?.clone?.();
+    if (!worldMatrix || !inverseWorldMatrix?.invert)
+        return null;
+    inverseWorldMatrix.invert();
+    const meshes = [root, ...(root.getChildMeshes?.(false) ?? [])];
+    const localPoints = [];
+    let Vector3 = null;
+    for (const mesh of meshes) {
+        mesh?.computeWorldMatrix?.(true);
+        const worldCorners = mesh?.getBoundingInfo?.()?.boundingBox?.vectorsWorld;
+        if (!Array.isArray(worldCorners))
+            continue;
+        for (const point of worldCorners) {
+            const PointVector3 = point?.constructor;
+            if (typeof PointVector3?.TransformCoordinates !== 'function')
+                continue;
+            Vector3 ?? (Vector3 = PointVector3);
+            localPoints.push(PointVector3.TransformCoordinates(point, inverseWorldMatrix));
+        }
+    }
+    if (!Vector3 || localPoints.length === 0)
+        return null;
+    const localMin = {
+        x: Math.min(...localPoints.map(point => Number(point.x))),
+        y: Math.min(...localPoints.map(point => Number(point.y))),
+        z: Math.min(...localPoints.map(point => Number(point.z))),
+    };
+    const localMax = {
+        x: Math.max(...localPoints.map(point => Number(point.x))),
+        y: Math.max(...localPoints.map(point => Number(point.y))),
+        z: Math.max(...localPoints.map(point => Number(point.z))),
+    };
+    if (![...Object.values(localMin), ...Object.values(localMax)].every(Number.isFinite))
+        return null;
+    const transformPoint = (x, y, z) => {
+        const point = Vector3.TransformCoordinates(new Vector3(x, y, z), worldMatrix);
+        return { x: Number(point.x), y: Number(point.y), z: Number(point.z) };
+    };
+    const minMinMin = transformPoint(localMin.x, localMin.y, localMin.z);
+    const maxMinMin = transformPoint(localMax.x, localMin.y, localMin.z);
+    const minMaxMin = transformPoint(localMin.x, localMax.y, localMin.z);
+    const minMinMax = transformPoint(localMin.x, localMin.y, localMax.z);
+    const maxMaxMax = transformPoint(localMax.x, localMax.y, localMax.z);
+    const xEdge = subtractProjectionVec3(maxMinMin, minMinMin);
+    const yEdge = subtractProjectionVec3(minMaxMin, minMinMin);
+    const zEdge = subtractProjectionVec3(minMinMax, minMinMin);
+    const size = {
+        x: Math.hypot(xEdge.x, xEdge.y, xEdge.z),
+        y: Math.hypot(yEdge.x, yEdge.y, yEdge.z),
+        z: Math.hypot(zEdge.x, zEdge.y, zEdge.z),
+    };
+    if (![size.x, size.y, size.z].every(value => Number.isFinite(value) && value >= 0))
+        return null;
+    const worldOrigin = transformPoint(0, 0, 0);
+    const normalizeWorldAxis = (point) => {
+        const axis = subtractProjectionVec3(point, worldOrigin);
+        const length = Math.hypot(axis.x, axis.y, axis.z);
+        return Number.isFinite(length) && length > 0.000001 ? scaleVec3(axis, 1 / length) : null;
+    };
+    const xAxis = normalizeWorldAxis(transformPoint(1, 0, 0));
+    const yAxis = normalizeWorldAxis(transformPoint(0, 1, 0));
+    const zAxis = normalizeWorldAxis(transformPoint(0, 0, 1));
+    if (!xAxis || !yAxis || !zAxis)
+        return null;
+    return {
+        center: {
+            x: (minMinMin.x + maxMaxMax.x) / 2,
+            y: (minMinMin.y + maxMaxMax.y) / 2,
+            z: (minMinMin.z + maxMaxMax.z) / 2,
+        },
+        size,
+        axes: {
+            x: xAxis,
+            y: yAxis,
+            z: zAxis,
+        },
+    };
+}
+function subtractProjectionVec3(left, right) {
+    return {
+        x: left.x - right.x,
+        y: left.y - right.y,
+        z: left.z - right.z,
+    };
+}
 export function readProjectionTransform(node) {
     return readProjectionWorldTransform(node);
 }
@@ -771,11 +880,12 @@ function createProjectionRoot(babylon, scene, node) {
     };
     return root;
 }
-async function loadModelProjection(options, node, projection) {
+async function loadModelProjection(options, node, projection, getLatestNode) {
     const asset = node.asset;
     if (!asset || !options.importModel) {
-        attachFallbackProjection(options.babylon, options.scene, node, projection, !!asset);
-        applyProjectionOutline(node, projection);
+        const latestNode = getLatestNode();
+        attachFallbackProjection(options.babylon, options.scene, latestNode, projection, !!asset);
+        applyProjectionOutline(latestNode, projection);
         return;
     }
     try {
@@ -787,22 +897,25 @@ async function loadModelProjection(options, node, projection) {
             asset,
         });
         if (!result) {
-            attachFallbackProjection(options.babylon, options.scene, node, projection, true);
-            applyProjectionOutline(node, projection);
+            const latestNode = getLatestNode();
+            attachFallbackProjection(options.babylon, options.scene, latestNode, projection, true);
+            applyProjectionOutline(latestNode, projection);
             return;
         }
         if (projection.root.isDisposed?.()) {
             disposeImportedProjectionResult(result);
             return;
         }
-        attachImportedProjectionResult(options, node, asset, projection, result);
-        applyProjectionOutline(node, projection);
+        const latestNode = getLatestNode();
+        attachImportedProjectionResult(options, latestNode, asset, projection, result);
+        applyProjectionOutline(latestNode, projection);
     }
     catch (error) {
         options.logger?.warn?.(`[BabylonEditorProjection] Failed to project model "${asset.sourceId ?? asset.id ?? node.id}"`, error);
         if (!projection.root.isDisposed?.()) {
-            attachFallbackProjection(options.babylon, options.scene, node, projection, true);
-            applyProjectionOutline(node, projection);
+            const latestNode = getLatestNode();
+            attachFallbackProjection(options.babylon, options.scene, latestNode, projection, true);
+            applyProjectionOutline(latestNode, projection);
         }
     }
 }
@@ -845,6 +958,8 @@ function attachImportedProjectionResult(options, node, asset, projection, result
             };
         }
         const materialSlots = readProjectionAssetMaterialSlots(asset, node.id);
+        const materialOwnerResolutionContext = createProjectionMaterialOwnerResolutionContext(modelRoot, node.id);
+        const explicitlyBoundSlotIds = new Set(createProjectionMaterialSlotBindings(node).map(binding => binding.slot.slotId));
         const ownerNodePathByMesh = new Map();
         const ownerMeshCountByKey = new Map();
         for (const mesh of result.meshes ?? []) {
@@ -864,19 +979,19 @@ function attachImportedProjectionResult(options, node, asset, projection, result
             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 splitPrimitiveSlot = resolveProjectionSplitPrimitiveMeshSelectionSlot(mesh, materialSlots, materialOwnerResolutionContext, explicitlyBoundSlotIds, ownerMeshCount, splitPrimitiveOrdinalByOwnerKey);
+                const primitiveSelectionMeshes = createProjectionAssetMeshSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, materialOwnerResolutionContext, explicitlyBoundSlotIds);
                 const primitiveBoundsSelectionMeshes = !splitPrimitiveSlot
                     && primitiveSelectionMeshes.length === 0
                     && !primitiveBoundsProxyOwnerKeys.has(ownerKey)
-                    ? createProjectionPrimitiveBoundsSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, ownerMeshCount)
+                    ? createProjectionPrimitiveBoundsSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, materialOwnerResolutionContext, explicitlyBoundSlotIds, 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);
+                const selectionKey = resolveProjectionAssetMeshSelectionKey(asset, mesh, ownerNodePath, materialOwnerResolutionContext, explicitlyBoundSlotIds, node.id);
                 mesh.metadata = {
                     ...(mesh.metadata ?? {}),
                     editorProjection: {
@@ -903,13 +1018,23 @@ function attachImportedProjectionResult(options, node, asset, projection, result
                 };
             }
         }
-        projection.runtimeObjects.push(...applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, result.meshes ?? []));
+        projection.runtimeObjects.push(...applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, result.meshes ?? [], materialOwnerResolutionContext));
         for (const animationGroup of result.animationGroups ?? []) {
             animationGroup.stop?.();
         }
         projection.animationGroups = result.animationGroups ?? [];
         projection.outlineMeshes = (result.meshes ?? []).filter((mesh) => mesh.getTotalVertices?.() > 0);
         projection.importStructure = createProjectionImportStructureSnapshot(node, asset, modelRoot, result);
+        const lightSync = resyncProjectionMeshLightSources(scene, result.meshes ?? []);
+        options.logger?.info?.('[BabylonEditorProjection] Model light sources synchronized', {
+            projectionNodeId: node.id,
+            sourceAssetId: asset.sourceId ?? asset.id ?? null,
+            importedMeshCount: lightSync.importedMeshCount,
+            instancedMeshCount: lightSync.instancedMeshCount,
+            lightSourceOwnerCount: lightSync.lightSourceOwnerCount,
+            activeSceneLightCount: lightSync.activeSceneLightCount,
+            resolvedLightSourceOwnerCount: lightSync.resolvedLightSourceOwnerCount,
+        });
     }
     catch (error) {
         disposeImportedProjectionResult(result);
@@ -1429,7 +1554,7 @@ function createPrimitiveProjectionMesh(babylon, scene, node, options) {
     });
     return mesh;
 }
-function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, meshes) {
+function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, meshes, materialOwnerResolutionContext) {
     const slotBindings = createProjectionMaterialSlotBindings(node);
     const hasRootProfile = !!node.artistMaterialProfile;
     const hasSlotProfiles = slotBindings.length > 0;
@@ -1484,63 +1609,83 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
         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 ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
-        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),
+    for (const slotBinding of slotBindings) {
+        const ownerResolution = materialOwnerResolutionContext.resolve(slotBinding.slot, {
+            explicitSlotBinding: true,
+        });
+        const ownerDiagnostic = createProjectionOwnerDiagnosticFields(ownerResolution);
+        if (ownerResolution.status !== 'resolved') {
+            emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                applied: false,
+                matchKind: ownerResolution.matchKind ?? 'none',
+                meshOwnerNodePath: null,
+                targetMaterialStatus: 'missingMeshOwner',
+                ...ownerDiagnostic,
+                warningMessage: ownerResolution.diagnostic.message,
             });
-            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);
+            continue;
+        }
+        const mesh = ownerResolution.target.runtimeNode;
+        const ownerNodePath = ownerResolution.candidate.canonicalPath;
+        if (!readProjectionWritableMeshMaterial(mesh)) {
             emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
-                applied: true,
-                matchKind,
+                applied: false,
+                matchKind: ownerResolution.matchKind,
                 meshOwnerNodePath: ownerNodePath,
-                targetMaterialStatus: resolution.targetMaterialStatus,
-                targetMaterialName: readProjectionMaterialName(target.material),
-                targetMaterialType: readProjectionMaterialType(target.material),
+                targetMaterialStatus: 'missingMaterial',
+                ...ownerDiagnostic,
+                warningMessage: 'Slot material profile was not applied because the resolved owner has no target material.',
             });
+            continue;
         }
-    }
-    for (const slotBinding of unmatchedSlotBindings) {
+        const materialResolution = resolveProjectionSlotMaterialTarget(mesh, materialCounts, slotBinding.slot, ownerNodePath, {
+            projectionNodeId: node.id,
+            primitiveOwnerResolvedByPointer: isMaterialOwnerResolutionPointerVerified(slotBinding.slot, ownerResolution),
+            primitiveSingleMaterialFallbackAllowed: isProjectionSinglePrimitiveMaterialSlot(slotBinding.slot, assetMaterialSlots),
+        });
+        const targetMaterial = materialResolution.target?.material ?? readProjectionWritableMeshMaterial(mesh);
+        if (!materialResolution.target) {
+            emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                applied: false,
+                matchKind: ownerResolution.matchKind,
+                meshOwnerNodePath: ownerNodePath,
+                targetMaterialStatus: materialResolution.targetMaterialStatus,
+                targetMaterialName: readProjectionMaterialName(targetMaterial),
+                targetMaterialType: readProjectionMaterialType(targetMaterial),
+                ...ownerDiagnostic,
+                warningMessage: materialResolution.warningMessage,
+            });
+            continue;
+        }
+        const target = materialResolution.target;
+        clonedMaterials.push(...target.clonedMaterials);
+        applyProjectionArtistMaterialProfile(options, target.material, slotBinding.profile);
         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.',
+            applied: true,
+            matchKind: ownerResolution.matchKind,
+            meshOwnerNodePath: ownerNodePath,
+            targetMaterialStatus: materialResolution.targetMaterialStatus,
+            targetMaterialName: readProjectionMaterialName(target.material),
+            targetMaterialType: readProjectionMaterialType(target.material),
+            ...ownerDiagnostic,
+            ...(ownerResolution.diagnostic?.severity === 'warning'
+                ? { warningMessage: ownerResolution.diagnostic.message }
+                : {}),
         });
     }
     return clonedMaterials;
 }
+function createProjectionOwnerDiagnosticFields(resolution) {
+    return {
+        ownerResolutionStatus: resolution.status,
+        ...(resolution.diagnostic ? {
+            ownerDiagnosticCode: resolution.diagnostic.code,
+            ownerDiagnosticSeverity: resolution.diagnostic.severity,
+        } : {}),
+        ownerCandidateIds: resolution.candidates.map(candidate => candidate.candidateId),
+        ...(resolution.status === 'resolved' ? { ownerIdentity: resolution.identity } : {}),
+    };
+}
 function applyProjectionArtistMaterialProfile(options, material, profile) {
     if (!profile)
         return;
@@ -1662,30 +1807,46 @@ function readProjectionMaterialSlotBoundsTuple(value) {
         return undefined;
     return tuple;
 }
-function resolveProjectionSlotBindingMatches(slotBindings, ownerNodePath, projectionNodeId) {
-    if (ownerNodePath == null)
-        return [];
-    const normalized = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
-    const normalizedMatchKey = createMaterialSlotOwnerPathMatchKey(normalized, { projectionNodeId });
-    const exactMatches = [];
-    const descendantMatches = [];
-    let descendantMatchLength = -1;
-    for (const binding of slotBindings) {
-        if (binding.slot.matchKey === normalizedMatchKey) {
-            exactMatches.push({ binding, matchKind: 'exact' });
-            continue;
-        }
-        if (isMaterialSlotOwnerPathMatch(normalized, binding.slot.normalizedOwnerNodePath, { projectionNodeId })) {
-            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 exactMatches.length > 0 ? exactMatches : descendantMatches;
+function createProjectionMaterialOwnerResolutionContext(rootNode, projectionNodeId) {
+    const candidates = collectBabylonMaterialOwnerCandidates(rootNode, {
+        readPathSegment: node => {
+            const segment = stableProjectionNodeSegment(node);
+            return segment == null
+                ? null
+                : normalizeProjectionOwnerNodePath(segment, { projectionNodeId });
+        },
+    }).map(candidate => ({
+        ...candidate,
+        canonicalPath: normalizeProjectionOwnerNodePath(candidate.canonicalPath, { projectionNodeId }),
+        ...(candidate.sourceOwnerAliases ? {
+            sourceOwnerAliases: candidate.sourceOwnerAliases.map(alias => (normalizeProjectionOwnerNodePath(alias, { projectionNodeId }))),
+        } : {}),
+    }));
+    const cache = new Map();
+    return {
+        resolve(slot, options = {}) {
+            const explicitSlotBinding = options.explicitSlotBinding === true;
+            const cacheKey = createProjectionMaterialOwnerResolutionCacheKey(slot, explicitSlotBinding);
+            const cached = cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const resolution = resolveMaterialOwner(slot, candidates, { explicitSlotBinding });
+            cache.set(cacheKey, resolution);
+            return resolution;
+        },
+    };
+}
+function createProjectionMaterialOwnerResolutionCacheKey(slot, explicitSlotBinding) {
+    return JSON.stringify([
+        explicitSlotBinding,
+        slot.ownerNodePath,
+        slot.nodeIndex ?? null,
+        slot.nodeIndexPath ?? null,
+        slot.meshIndex ?? null,
+        slot.primitiveIndex ?? null,
+        slot.sourceMaterialIndex ?? null,
+        slot.sourceMaterialIndices ?? null,
+    ]);
 }
 function buildProjectionOwnerNodePath(node, rootNode, projectionNodeId) {
     if (!node || !rootNode || node === rootNode)
@@ -1720,42 +1881,20 @@ function stableProjectionNodeSegment(node) {
 function createAssetMeshProjectionNodeId(rootNodeId, ownerNodePath) {
     return `${rootNodeId}${ASSET_MESH_SELECTION_SEPARATOR}${encodeURIComponent(ownerNodePath)}`;
 }
-function resolveProjectionAssetMeshSelectionKey(asset, ownerNodePath, projectionNodeId) {
-    const normalizedOwnerPath = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
-    let bestSlot = null;
-    for (const slot of readProjectionAssetMaterialSlots(asset, projectionNodeId)) {
-        if (!isMaterialSlotOwnerPathMatch(normalizedOwnerPath, slot.normalizedOwnerNodePath, { projectionNodeId }))
-            continue;
-        if (!bestSlot || slot.matchKey.length > bestSlot.matchKey.length) {
-            bestSlot = slot;
-        }
-    }
-    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 resolveProjectionAssetMeshSelectionKey(asset, mesh, ownerNodePath, materialOwnerResolutionContext, explicitlyBoundSlotIds, projectionNodeId) {
+    const slots = resolveProjectionAssetMeshSelectionSlots(readProjectionAssetMaterialSlots(asset, projectionNodeId), mesh, materialOwnerResolutionContext, explicitlyBoundSlotIds);
+    return slots[0]?.key ?? ownerNodePath;
 }
-function createProjectionAssetMeshSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots) {
-    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, ownerNodePath, node.id)
+function resolveProjectionAssetMeshSelectionSlots(materialSlots, mesh, materialOwnerResolutionContext, explicitlyBoundSlotIds) {
+    return materialSlots.filter(slot => {
+        const resolution = materialOwnerResolutionContext.resolve(slot, {
+            explicitSlotBinding: explicitlyBoundSlotIds.has(slot.slotId),
+        });
+        return resolution.status === 'resolved' && resolution.target.runtimeNode === mesh;
+    });
+}
+function createProjectionAssetMeshSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, materialOwnerResolutionContext, explicitlyBoundSlotIds) {
+    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, mesh, materialOwnerResolutionContext, explicitlyBoundSlotIds)
         .filter(slot => Number.isInteger(slot.primitiveIndex));
     if (primitiveSlots.length <= 1)
         return [];
@@ -1786,37 +1925,37 @@ function createProjectionAssetMeshSelectionProxies(options, node, projection, me
         proxies.push(proxy);
         projection.selectionMeshes = projection.selectionMeshes ?? [];
         projection.selectionMeshes.push(proxy);
+        registerProjectionSelectionPresentationTarget(projection, selectionNodeId, mesh);
         if (proxy.material)
             projection.runtimeObjects.push(proxy.material);
     }
     return proxies;
 }
-function resolveProjectionSplitPrimitiveMeshSelectionSlot(mesh, materialSlots, ownerNodePath, projectionNodeId, ownerMeshCount, ordinalByOwnerKey) {
+function resolveProjectionSplitPrimitiveMeshSelectionSlot(mesh, materialSlots, materialOwnerResolutionContext, explicitlyBoundSlotIds, 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)
+    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, mesh, materialOwnerResolutionContext, explicitlyBoundSlotIds)
         .filter((slot) => (Number.isInteger(slot.primitiveIndex)))
         .sort((left, right) => left.primitiveIndex - right.primitiveIndex);
+    if (primitiveSlots.length === 1 && ownerMeshCount > 1)
+        return primitiveSlots[0];
     if (primitiveSlots.length <= 1)
         return null;
     if (ownerMeshCount < primitiveSlots.length)
         return null;
-    const ownerKey = createMaterialSlotOwnerPathMatchKey(ownerNodePath, { projectionNodeId });
+    const ownerKey = primitiveSlots[0]?.matchKey ?? '';
     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) {
+function createProjectionPrimitiveBoundsSelectionProxies(options, node, projection, mesh, ownerNodePath, materialSlots, materialOwnerResolutionContext, explicitlyBoundSlotIds, ownerMeshCount) {
     const subMeshes = Array.isArray(mesh?.subMeshes) ? mesh.subMeshes : [];
     if (subMeshes.length > 1)
         return [];
-    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, ownerNodePath, node.id)
+    const primitiveSlots = resolveProjectionAssetMeshSelectionSlots(materialSlots, mesh, materialOwnerResolutionContext, explicitlyBoundSlotIds)
         .filter(slot => Number.isInteger(slot.primitiveIndex) && !!slot.boundingBox)
         .sort((left, right) => (left.primitiveIndex ?? 0) - (right.primitiveIndex ?? 0));
     if (primitiveSlots.length <= 1)
@@ -1844,11 +1983,26 @@ function createProjectionPrimitiveBoundsSelectionProxies(options, node, projecti
         proxies.push(proxy);
         projection.selectionMeshes = projection.selectionMeshes ?? [];
         projection.selectionMeshes.push(proxy);
+        registerProjectionSelectionPresentationTarget(projection, selectionNodeId, mesh);
         if (proxy.material)
             projection.runtimeObjects.push(proxy.material);
     }
     return proxies;
 }
+function registerProjectionSelectionPresentationTarget(projection, selectionNodeId, renderMesh) {
+    projection.selectionPresentationTargets = projection.selectionPresentationTargets ?? [];
+    const existing = projection.selectionPresentationTargets.find(target => target.selectionNodeId === selectionNodeId);
+    if (existing) {
+        if (!existing.renderMeshes.includes(renderMesh)) {
+            existing.renderMeshes = [...existing.renderMeshes, renderMesh];
+        }
+        return;
+    }
+    projection.selectionPresentationTargets.push({
+        selectionNodeId,
+        renderMeshes: [renderMesh],
+    });
+}
 function createProjectionPrimitiveBoundsSelectionProxy(options, node, sourceMesh, slot, metadata) {
     const { babylon, scene } = options;
     const MeshBuilder = babylon.MeshBuilder;
@@ -1923,93 +2077,6 @@ function readProjectionMaterialSlotBoundsVec3(value) {
         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;
@@ -2144,11 +2211,21 @@ function detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath) {
     if (materialUseCount <= 1)
         return { material, clonedMaterials: [], projectionOwnsMaterialLifecycle };
     const clone = typeof material.clone === 'function'
-        ? material.clone(createProjectionSlotMaterialName(material, ownerNodePath))
+        ? safelyCloneProjectionMaterial(material, createProjectionSlotMaterialName(material, ownerNodePath))
         : null;
     if (!clone)
         return null;
-    cloneProjectionSubMaterials(clone, material, ownerNodePath);
+    try {
+        cloneProjectionSubMaterials(clone, material, ownerNodePath);
+    }
+    catch {
+        safelyDisposeProjectionMaterial(clone);
+        return null;
+    }
+    if (Array.isArray(material.subMaterials) && !Array.isArray(clone.subMaterials)) {
+        safelyDisposeProjectionMaterial(clone);
+        return null;
+    }
     materialOwner.material = clone;
     materialCounts.set(material, materialUseCount - 1);
     materialCounts.set(clone, 1);
@@ -2185,8 +2262,8 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
         };
     }
     if (!Array.isArray(material.subMaterials)) {
-        const isSplitPrimitiveOwner = isProjectionRuntimeSplitPrimitiveOwnerNode(mesh, slot);
-        if (!isSplitPrimitiveOwner && (slot.primitiveIndex !== 0 || !options.primitiveSingleMaterialFallbackAllowed)) {
+        if (!options.primitiveOwnerResolvedByPointer
+            && (slot.primitiveIndex !== 0 || !options.primitiveSingleMaterialFallbackAllowed)) {
             return {
                 target: null,
                 targetMaterialStatus: 'missingSubMaterial',
@@ -2209,25 +2286,16 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
             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') {
+    const sourceSubMaterials = material.subMaterials;
+    const sourceSubMaterial = sourceSubMaterials[slot.primitiveIndex];
+    if (!sourceSubMaterial || typeof sourceSubMaterial !== 'object' || typeof sourceSubMaterial.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));
+    const clonedSubMaterial = safelyCloneProjectionMaterial(sourceSubMaterial, createProjectionSlotSubMaterialName(sourceSubMaterial, ownerNodePath, slot.primitiveIndex));
     if (!clonedSubMaterial) {
         return {
             target: null,
@@ -2235,7 +2303,22 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
             warningMessage: 'Primitive slot material profile was not applied because the target subMaterial clone failed.',
         };
     }
+    const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+    const slotMaterial = detachResult?.material;
+    if (!detachResult || !Array.isArray(slotMaterial.subMaterials)) {
+        safelyDisposeProjectionMaterial(clonedSubMaterial);
+        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 detachedSubMaterial = subMaterials[slot.primitiveIndex];
     subMaterials[slot.primitiveIndex] = clonedSubMaterial;
+    if (detachedSubMaterial !== sourceSubMaterial && detachedSubMaterial !== clonedSubMaterial) {
+        safelyDisposeProjectionMaterial(detachedSubMaterial);
+    }
     return {
         target: {
             material: clonedSubMaterial,
@@ -2247,22 +2330,27 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
         targetMaterialStatus: 'subMaterial',
     };
 }
+function safelyCloneProjectionMaterial(material, name) {
+    try {
+        return material?.clone?.(name) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function safelyDisposeProjectionMaterial(material) {
+    try {
+        material?.dispose?.();
+    }
+    catch {
+        // Best-effort cleanup for a clone that was never committed to the scene owner.
+    }
+}
 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);
+    return resolveBabylonEffectiveMaterialOwner(mesh);
 }
 function cloneProjectionSubMaterials(clone, source, ownerNodePath) {
     if (!Array.isArray(clone?.subMaterials) || !Array.isArray(source?.subMaterials))
@@ -2512,22 +2600,33 @@ function isProjectionRuntimeLightObject(runtimeObject) {
 }
 function resyncProjectionSceneLightSources(scene) {
     const meshes = Array.isArray(scene.meshes) ? scene.meshes : [];
+    resyncProjectionMeshLightSources(scene, meshes);
+}
+function resyncProjectionMeshLightSources(scene, meshes) {
+    const lightSourceOwners = new Set();
     const sourceMeshes = new Set();
     const instancedMeshes = new Set();
     for (const mesh of meshes) {
         if (!mesh || typeof mesh !== 'object')
             continue;
-        mesh._resyncLightSources?.();
         const sourceMesh = mesh.sourceMesh;
         if (sourceMesh && sourceMesh !== mesh) {
             sourceMeshes.add(sourceMesh);
             instancedMeshes.add(mesh);
         }
+        else {
+            lightSourceOwners.add(mesh);
+        }
     }
     for (const sourceMesh of sourceMeshes) {
         if (sourceMesh?.isDisposed?.())
             continue;
-        sourceMesh?._resyncLightSources?.();
+        lightSourceOwners.add(sourceMesh);
+    }
+    for (const lightSourceOwner of lightSourceOwners) {
+        if (lightSourceOwner?.isDisposed?.())
+            continue;
+        lightSourceOwner?._resyncLightSources?.();
     }
     for (const instancedMesh of instancedMeshes) {
         if (instancedMesh?.isDisposed?.())
@@ -2535,6 +2634,21 @@ function resyncProjectionSceneLightSources(scene) {
         instancedMesh?._markSubMeshesAsLightDirty?.();
     }
     scene.resetCachedMaterial?.();
+    const activeSceneLights = (Array.isArray(scene.lights) ? scene.lights : [])
+        .filter((light) => light?.isEnabled?.() !== false);
+    const resolvedLightSourceOwnerCount = [...lightSourceOwners].filter(owner => {
+        if (owner?.isDisposed?.())
+            return false;
+        const lightSources = owner?.lightSources ?? owner?._lightSources;
+        return Array.isArray(lightSources) && lightSources.length > 0;
+    }).length;
+    return {
+        importedMeshCount: meshes.length,
+        instancedMeshCount: instancedMeshes.size,
+        lightSourceOwnerCount: lightSourceOwners.size,
+        activeSceneLightCount: activeSceneLights.length,
+        resolvedLightSourceOwnerCount,
+    };
 }
 function refreshLightDirectionLines(babylon, scene, node, projection, direction) {
     const existing = scene.getMeshByName?.(`${node.id}.lightDirection`);
@@ -2811,6 +2925,15 @@ function applyProjectionWorldTransform(babylon, node, transform) {
     applyProjectionTransform(babylon, node, local);
     return true;
 }
+function cloneProjectionTransformSnapshot(transform) {
+    return isEditorTransformMatrixSnapshot(transform)
+        ? { mode: 'matrix', matrix: cloneEditorTransformMatrix(transform.matrix) }
+        : {
+            position: { ...transform.position },
+            rotation: { ...transform.rotation },
+            scale: { ...transform.scale },
+        };
+}
 function writeProjectionLocalMatrixTransform(node, matrix) {
     node.metadata = {
         ...(readProjectionObject(node?.metadata) ?? {}),
@@ -2904,94 +3027,4 @@ function rectsIntersect(left, right) {
         && left.top <= right.bottom
         && left.bottom >= right.top;
 }
-function syncProjectionSelection(babylon, projections, selection) {
-    const Color4 = babylon.Color4;
-    const selectedIds = new Set(selection.selectedIds.length > LARGE_SELECTION_EDGE_LIMIT
-        ? [selection.activeId].filter((id) => !!id)
-        : selection.selectedIds);
-    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 = 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;
-        }
-    }
-}
-function syncProjectionMeshSelection(mesh, selected, active, Color4) {
-    mesh.metadata = {
-        ...(mesh.metadata ?? {}),
-        editorProjectionSelectionEdgesSelected: selected,
-    };
-    if (!selected) {
-        mesh.disableEdgesRendering?.();
-        return;
-    }
-    mesh.enableEdgesRendering?.(0.997);
-    mesh.edgesWidth = active ? 5 : 3.5;
-    if (Color4) {
-        mesh.edgesColor = active
-            ? new Color4(1, 0.9, 0.22, 1)
-            : new Color4(0.35, 0.65, 1, 1);
-    }
-}
-function prewarmProjectionSelectionEdges(projection) {
-    for (const mesh of [...projection.outlineMeshes, ...(projection.selectionMeshes ?? [])]) {
-        if (mesh?.metadata?.editorProjectionSelectionEdgesPrewarmed)
-            continue;
-        if (mesh?.metadata?.editorProjectionSelectionEdgesSelected)
-            continue;
-        try {
-            mesh.enableEdgesRendering?.(0.997);
-            mesh.disableEdgesRendering?.();
-            mesh.metadata = {
-                ...(mesh.metadata ?? {}),
-                editorProjectionSelectionEdgesPrewarmed: true,
-            };
-        }
-        catch { }
-    }
-}
-function scheduleIdleProjectionSelectionEdgesPrewarm(projection) {
-    let canceled = false;
-    const run = () => {
-        if (canceled || projection.root?.isDisposed?.())
-            return;
-        projection.selectionEdgesPrewarmCancel = null;
-        prewarmProjectionSelectionEdges(projection);
-    };
-    const scheduleTarget = globalThis;
-    if (typeof scheduleTarget.requestIdleCallback === 'function') {
-        const handle = scheduleTarget.requestIdleCallback(run);
-        return () => {
-            canceled = true;
-            scheduleTarget.cancelIdleCallback?.(handle);
-        };
-    }
-    const handle = setTimeout(run, 0);
-    return () => {
-        canceled = true;
-        clearTimeout(handle);
-    };
-}
 //# sourceMappingURL=projection.js.map