mnfst 0.5.16 → 0.5.17

package/dist/manifest.data.js

@@ -5877,6 +5877,54 @@ function createNestedObjectProxy(objTarget, dataSourceName = null, reloadDataSou
                 // This ensures we never use Alpine-wrapped objects
                 let objectToProxy = value;
 
+                // CRITICAL: If rawTarget is already proxied, check if the value itself is proxied before creating new proxy
+                // This prevents infinite recursion when Alpine wraps our proxy and accesses nested properties
+                if (isRawTargetProxied) {
+                    // Get the raw nested object from store to check cache
+                    const newPath = [...path, key];
+                    let rawNestedObject = objectToProxy;
+                    
+                    try {
+                        const getRawData = window.ManifestDataStore?.getRawData;
+                        if (getRawData && dataSourceName) {
+                            const rawDataSource = getRawData(dataSourceName);
+                            if (rawDataSource && typeof rawDataSource === 'object') {
+                                let current = rawDataSource;
+                                let pathValid = true;
+                                for (let i = 0; i < newPath.length; i++) {
+                                    const pathKey = newPath[i];
+                                    if (current && typeof current === 'object' && pathKey in current) {
+                                        current = current[pathKey];
+                                    } else {
+                                        pathValid = false;
+                                        break;
+                                    }
+                                }
+                                if (pathValid && current) {
+                                    rawNestedObject = current;
+                                }
+                            }
+                        }
+                    } catch (e) {
+                        // Silently handle errors
+                    }
+                    
+                    // If the nested object is already proxied, return the cached proxy
+                    if (window.ManifestDataProxiesCore?.nestedObjectProxyCache?.has(rawNestedObject)) {
+                        const cachedProxy = window.ManifestDataProxiesCore.nestedObjectProxyCache.get(rawNestedObject);
+                        if (cachedProxy) {
+                            if (activeProps) {
+                                activeProps.delete(propKey);
+                            }
+                            return cachedProxy;
+                        }
+                    }
+                    
+                    // If rawTarget is proxied but nested object isn't, we still need to create a proxy
+                    // But use the raw nested object from store as the target
+                    objectToProxy = rawNestedObject;
+                }
+
                 // CRITICAL: Check if this object is already a proxy we created to prevent infinite recursion
                 // This can happen when Alpine wraps our proxy and accesses properties on the wrapped proxy
                 if (window.ManifestDataProxiesCore?.nestedObjectProxyCache?.has(objectToProxy)) {
@@ -10017,11 +10065,6 @@ function registerFilesDirective() {
                     if (storeProject) {
                         latestProject = storeProject; // Use latest from store
                     } else {
-                        console.warn('[DEBUG x-data-files] Project not found in store:', {
-                            directiveInstanceId,
-                            currentProjectId,
-                            availableProjectIds: projects.map(p => p.$id)
-                        });
                     }
                 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mnfst",
-    "version": "0.5.16",
+    "version": "0.5.17",
     "private": false,
     "workspaces": [
         "templates/starter"