holosphere 1.1.16 → 1.1.18

package/compute.js

@@ -286,7 +286,7 @@ export async function updateParent(holoInstance, id, report) {
         // Re-throw or handle error appropriately
         throw error;
     }
-}
+} 
 
 // Export all compute operations as default
 export default {

package/content.js

@@ -50,7 +50,6 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
                 if (soulInfo.appname !== holoInstance.appname) {
                     console.warn(`Existing hologram at ${targetHolon}/${targetLens}/${targetKey} has appname (${soulInfo.appname}) in its soul ${existingItemAtPath.soul} which does not match current HoloSphere instance appname (${holoInstance.appname}). Redirecting put to soul's holon/lens within this instance.`);
                 }
-                console.log(`Redirecting put for data (ID: ${data.id}). Original target ${targetHolon}/${targetLens}/${targetKey} contained hologram (ID: ${existingItemAtPath.id}, Soul: ${existingItemAtPath.soul}). New target is ${soulInfo.holon}/${soulInfo.lens}/${soulInfo.key}.`);
                 targetHolon = soulInfo.holon; // Redirect holon
                 targetLens = soulInfo.lens;   // Redirect lens
                 targetKey = soulInfo.key;     // Redirect key (important!)
@@ -61,7 +60,6 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
                     // It's crucial that the actual GunDB path uses targetKey.
                     // The 'data' object itself retains its original 'data.id' unless explicitly changed.
                 }
-
             } else {
                 console.warn(`Existing item at ${targetHolon}/${targetLens}/${targetKey} (ID: ${existingItemAtPath.id}) is a hologram, but its soul ('${existingItemAtPath.soul}') is invalid. Proceeding with original target.`);
             }
@@ -165,8 +163,6 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
                                     const storedHologramInstanceSoul = `${holoInstance.appname}/${targetHolon}/${targetLens}/${targetKey}`;
                                     
                                     targetNodeRef.get('_holograms').get(storedHologramInstanceSoul).put(true);
-                                    
-                                    console.log(`Data (ID: ${data.id}) being put is a hologram. Added its instance soul ${storedHologramInstanceSoul} to its target ${data.soul}'s _holograms set.`);
                                 } else {
                                     console.warn(`Data (ID: ${data.id}) being put is a hologram, but could not parse its soul ${data.soul} for tracking.`);
                                 }
@@ -191,10 +187,8 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
                                                 k !== '_' && hologramsSet[k] === true // Only active holograms (deleted ones are null/removed)
                                             );
                                             
-                                            if (hologramSouls.length > 0) {
-                                                console.log(`Updating ${hologramSouls.length} active holograms for data ${data.id}`);
-                                                
-                                                // Update each active hologram with an 'updated' timestamp
+                                                                        if (hologramSouls.length > 0) {
+                                // Update each active hologram with an 'updated' timestamp
                                                 const updatePromises = hologramSouls.map(async (hologramSoul) => {
                                                     try {
                                                         const hologramSoulInfo = holoInstance.parseSoulPath(hologramSoul);
@@ -227,9 +221,7 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
                                                                     }
                                                                 );
                                                                 
-                                                                console.log(`Updated hologram at ${hologramSoul} with timestamp`);
-                                                                
-                                                                // Add to the list of updated holograms
+                                                                                                                // Add to the list of updated holograms
                                                                 updatedHolograms.push({
                                                                     soul: hologramSoul,
                                                                     holon: hologramSoulInfo.holon,
@@ -387,23 +379,31 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
                     if (resolveHolograms && holoInstance.isHologram(parsed)) {
                         const resolvedValue = await holoInstance.resolveHologram(parsed, {
                             followHolograms: resolveHolograms,
-                            visited: visited
+                            visited: visited,
+                            maxDepth: options.maxDepth || 10,
+                            currentDepth: options.currentDepth || 0
                         });
 
-                        console.log(`### get/handleData received resolved value:`, resolvedValue);
-
                         if (resolvedValue === null) {
-                            // This means resolveHologram determined the target doesn't exist or a sub-resolution failed to null.
-                            console.warn(`Hologram at ${holon}/${lens}/${key} could not be fully resolved (target not found or sub-problem). Resolving null.`);
+                            // This means resolveHologram determined the target doesn't exist or encountered an error
+                            console.warn(`Broken hologram detected at ${holon}/${lens}/${key}. Removing it...`);
+                            
+                            try {
+                                // Delete the broken hologram
+                                await holoInstance.delete(holon, lens, key, password);
+                                console.log(`Successfully removed broken hologram from ${holon}/${lens}/${key}`);
+                            } catch (cleanupError) {
+                                console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
+                            }
+                            
                             resolve(null);
-                            return; // Important to return after resolving
+                            return;
                         }
                         // If resolveHologram encountered a circular ref, it would throw, not return.
                         // If it returned the hologram itself (if we ever revert to that), this logic would need adjustment.
                         // For now, assume resolvedValue is either the resolved data or we've returned null above.
 
                         if (resolvedValue !== parsed) { 
-                            console.log(`### get/handleData using resolved data:`, resolvedValue);
                             parsed = resolvedValue;
                         }
                     }
@@ -518,21 +518,41 @@ export async function getAll(holoInstance, holon, lens, password = null) {
 
                     // Check if this is a hologram that needs to be resolved
                     if (holoInstance.isHologram(parsed)) {
-                        const resolved = await holoInstance.resolveHologram(parsed, {
-                            followHolograms: true
-                        });
+                        try {
+                            const resolved = await holoInstance.resolveHologram(parsed, {
+                                followHolograms: true,
+                                maxDepth: 10,
+                                currentDepth: 0
+                            });
+
+                            if (resolved === null) {
+                                console.warn(`Broken hologram detected in getAll for key ${key}. Removing it...`);
+                                
+                                try {
+                                    // Delete the broken hologram
+                                    await holoInstance.delete(holon, lens, key, password);
+                                    console.log(`Successfully removed broken hologram from ${holon}/${lens}/${key}`);
+                                } catch (cleanupError) {
+                                    console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
+                                }
+                                return; // Skip adding this item to output
+                            }
 
-                        if (resolved !== parsed) {
-                            // Hologram was resolved successfully
-                            if (schema) {
-                                const valid = holoInstance.validator.validate(schema, resolved);
-                                if (valid || !holoInstance.strict) {
+                            if (resolved && resolved !== parsed) {
+                                // Hologram was resolved successfully
+                                if (schema) {
+                                    const valid = holoInstance.validator.validate(schema, resolved);
+                                    if (valid || !holoInstance.strict) {
+                                        output.set(resolved.id, resolved);
+                                    }
+                                } else {
                                     output.set(resolved.id, resolved);
                                 }
-                            } else {
-                                output.set(resolved.id, resolved);
+                                return;
                             }
-                            return;
+                        } catch (hologramError) {
+                            console.error(`Error resolving hologram for key ${key}:`, hologramError);
+                            return; // Skip this item
                         }
                     }
 
@@ -619,18 +639,57 @@ export async function parse(holoInstance, rawData) {
         } else if (rawData._) {
             // Handle potential GunDB metadata remnants (attempt cleanup)
             console.warn('Parsing raw Gun object with metadata (_) - attempting cleanup:', rawData);
+            
+            // Enhanced cleanup for complex GunDB structures
             const potentialData = Object.keys(rawData).reduce((acc, k) => {
                 if (k !== '_') {
-                    acc[k] = rawData[k];
+                    // Handle nested raw GunDB nodes
+                    if (rawData[k] && typeof rawData[k] === 'object' && rawData[k]._) {
+                        // Recursively parse nested raw nodes
+                        const parsedNested = parse(holoInstance, rawData[k]);
+                        if (parsedNested !== null) {
+                            acc[k] = parsedNested;
+                        }
+                    } else if (rawData[k] !== null) {
+                        // Only include non-null values
+                        acc[k] = rawData[k];
+                    }
                 }
                 return acc;
             }, {});
+            
             if (Object.keys(potentialData).length === 0) {
-                console.warn('Raw Gun object had only metadata (_), returning null.');
+                console.warn('Raw Gun object had only metadata (_) or null values, returning null.');
                 return null;
             }
+            
+            // Additional validation: check if the cleaned object has meaningful data
+            const hasValidData = Object.values(potentialData).some(value => 
+                value !== null && value !== undefined && 
+                (typeof value !== 'object' || Object.keys(value).length > 0)
+            );
+            
+            if (!hasValidData) {
+                console.warn('Cleaned Gun object has no valid data, returning null.');
+                return null;
+            }
+            
             return potentialData; // Return cleaned-up object
         } else {
+            // Check for objects that might be arrays of raw GunDB nodes
+            if (Array.isArray(rawData)) {
+                const cleanedArray = rawData
+                    .map(item => parse(holoInstance, item))
+                    .filter(item => item !== null);
+                
+                if (cleanedArray.length === 0) {
+                    console.warn('Array contained only invalid/raw GunDB nodes, returning null.');
+                    return null;
+                }
+                
+                return cleanedArray;
+            }
+            
             // Assume it's a regular plain object
             return rawData;
         }
@@ -739,7 +798,6 @@ export async function deleteFunc(holoInstance, holon, lens, key, password = null
                             if (ack.err) {
                                 console.warn(`[deleteFunc] Error removing hologram ${deletedHologramSoul} from target ${targetSoul}:`, ack.err);
                             }
-                            console.log(`Removed hologram ${deletedHologramSoul} from target ${targetSoul}'s _holograms list`);
                             resolveTrack(); // Resolve regardless of ack error to not block main delete
                         });
                     });
@@ -891,9 +949,8 @@ export async function deleteAll(holoInstance, holon, lens, password = null) {
                                         targetNodeRef.get('_holograms').get(deletedHologramSoul).put(null, (ack) => {
                                             if (ack.err) {
                                                 console.warn(`[deleteAll] Error removing hologram ${deletedHologramSoul} from target ${targetSoul}:`, ack.err);
-                                            }
-                                            console.log(`Removed hologram ${deletedHologramSoul} from target ${targetSoul}'s _holograms list`);
-                                            resolveTrack();
+                                                                                    }
+                                        resolveTrack();
                                         });
                                     });
                                 } else {

package/federation.js

@@ -890,7 +890,7 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
         
         // Check if we should propagate to parent hexagons
         if (propagateToParents) {
-            console.log(`[Federation] Starting parent propagation for holon: ${holon}`);
+            
             try {
                 // Validate if the holon is a proper H3 hexagon
                 // H3 hexagons should start with '8' and have a valid format
@@ -898,13 +898,12 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                 let isValidH3 = false;
                 
                 // First check: H3 hexagons should start with '8' and be at least 15 characters long
-                if (typeof holon === 'string' && holon.startsWith('8') && holon.length >= 15) {
+                if (typeof holon === 'string' && /^[8][0-9A-Fa-f]+$/.test(holon) && holon.length >= 15) {
                     try {
                         holonResolution = h3.getResolution(holon);
                         // Additional validation: resolution should be >= 0 and <= 15
                         if (holonResolution >= 0 && holonResolution <= 15) {
                             isValidH3 = true;
-                            console.log(`[Federation] Holon ${holon} is valid H3 hexagon with resolution: ${holonResolution}`);
                         } else {
                             console.log(`[Federation] Holon ${holon} has invalid resolution: ${holonResolution}`);
                         }
@@ -912,11 +911,9 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                         console.log(`[Federation] Holon ${holon} failed H3 validation: ${error.message}`);
                     }
                 } else {
-                    console.log(`[Federation] Holon ${holon} is not a valid H3 hexagon: does not start with '8' or too short`);
                 }
                 
                 if (!isValidH3) {
-                    console.log(`[Federation] Skipping parent propagation for non-H3 holon: ${holon}`);
                     result.parentPropagation.messages.push(`Holon ${holon} is not a valid H3 hexagon. Skipping parent propagation.`);
                     result.parentPropagation.skipped++;
                 }
@@ -928,13 +925,10 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                     let currentRes = holonResolution;
                     let levelsProcessed = 0;
                     
-                    console.log(`[Federation] Getting parent hexagons for ${holon} (resolution ${holonResolution}) up to ${maxParentLevels} levels`);
-                    
                     while (currentRes > 0 && levelsProcessed < maxParentLevels) {
                         try {
                             const parent = h3.cellToParent(currentHolon, currentRes - 1);
                             parentHexagons.push(parent);
-                            console.log(`[Federation] Found parent hexagon: ${parent} (resolution ${currentRes - 1})`);
                             currentHolon = parent;
                             currentRes--;
                             levelsProcessed++;
@@ -947,17 +941,14 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                     }
                     
                     if (parentHexagons.length > 0) {
-                        console.log(`[Federation] Found ${parentHexagons.length} parent hexagons to propagate to: ${parentHexagons.join(', ')}`);
                         result.parentPropagation.messages.push(`Found ${parentHexagons.length} parent hexagons to propagate to: ${parentHexagons.join(', ')}`);
                         
                         // Check if data is already a hologram (reuse from federation section)
                         const isAlreadyHologram = holosphere.isHologram(data);
-                        console.log(`[Federation] Data is already hologram: ${isAlreadyHologram}`);
                         
                         // Propagate to each parent hexagon
                         const parentPropagatePromises = parentHexagons.map(async (parentHexagon) => {
                             try {
-                                console.log(`[Federation] Propagating to parent hexagon: ${parentHexagon}`);
                                 let payloadToPut;
                                 const parentFederationMeta = {
                                     origin: holon,           // The original holon from which this data is being propagated
@@ -971,7 +962,6 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                                 if (useHolograms && !isAlreadyHologram) {
                                     // Create a new hologram referencing the original data
                                     const newHologram = holosphere.createHologram(holon, lens, data);
-                                    console.log(`[Federation] Created hologram for parent propagation:`, newHologram);
                                     payloadToPut = {
                                         ...newHologram, // This will be { id: data.id, soul: 'path/to/original' }
                                         _federation: parentFederationMeta
@@ -988,8 +978,6 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                                     };
                                 }
                                 
-                                console.log(`[Federation] Storing in parent hexagon ${parentHexagon} with payload:`, payloadToPut);
-                                
                                 // Store in the parent hexagon with redirection disabled and no further auto-propagation
                                 await holosphere.put(parentHexagon, lens, payloadToPut, null, { 
                                     disableHologramRedirection: true, 
@@ -1009,7 +997,6 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                         
                         await Promise.all(parentPropagatePromises);
                     } else {
-                        console.log(`[Federation] No parent hexagons found for ${holon} (already at resolution 0 or max levels reached)`);
                         result.parentPropagation.messages.push(`No parent hexagons found for ${holon} (already at resolution 0 or max levels reached)`);
                         result.parentPropagation.skipped++;
                     }
@@ -1019,8 +1006,6 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                 result.parentPropagation.errors++;
                 result.parentPropagation.messages.push(`Error during parent propagation: ${error.message}`);
             }
-        } else {
-            console.log(`[Federation] Parent propagation disabled for holon: ${holon}`);
         }
         
         // ================================ END PARENT PROPAGATION ================================
@@ -1230,7 +1215,7 @@ export async function resetFederation(holosphere, spaceId, password = null, opti
             error: error.message
         };
     }
-}
+} 
 
 // Export all federation operations as default
 export default {

package/global.js

@@ -94,10 +94,8 @@ export async function putGlobal(holoInstance, tableName, data, password = null)
                                         // Soul of the hologram that was *actually stored* at tableName/data.id
                                         const storedHologramInstanceSoul = `${holoInstance.appname}/${tableName}/${data.id}`;
                                         
-                                        targetNodeRef.get('_holograms').get(storedHologramInstanceSoul).put(true);
-                                        
-                                        console.log(`Data (ID: ${data.id}) being put is a hologram. Added its instance soul ${storedHologramInstanceSoul} to its target ${dataToStore.soul}'s _holograms set.`);
-                                    } else {
+                                                                        targetNodeRef.get('_holograms').get(storedHologramInstanceSoul).put(true);
+                            } else {
                                         console.warn(`Data (ID: ${data.id}) being put is a hologram, but could not parse its soul ${dataToStore.soul} for tracking.`);
                                     }
                                 } catch (trackingError) {
@@ -123,10 +121,8 @@ export async function putGlobal(holoInstance, tableName, data, password = null)
                                         // Soul of the hologram that was *actually stored* at tableName (without specific key)
                                         const storedHologramInstanceSoul = `${holoInstance.appname}/${tableName}`;
                                         
-                                        targetNodeRef.get('_holograms').get(storedHologramInstanceSoul).put(true);
-                                        
-                                        console.log(`Data being put is a hologram. Added its instance soul ${storedHologramInstanceSoul} to its target ${dataToStore.soul}'s _holograms set.`);
-                                    } else {
+                                                                    targetNodeRef.get('_holograms').get(storedHologramInstanceSoul).put(true);
+                        } else {
                                         console.warn(`Data being put is a hologram, but could not parse its soul ${dataToStore.soul} for tracking.`);
                                     }
                                 } catch (trackingError) {
@@ -228,7 +224,6 @@ export async function getGlobal(holoInstance, tableName, key, password = null) {
                         });
 
                         if (resolved === null) {
-                            console.log(`Hologram at ${tableName}/${key} points to non-existent data. Deleting hologram.`);
                             try {
                                 await holoInstance.deleteGlobal(tableName, key, password); // Use instance's deleteGlobal
                             } catch (deleteError) {
@@ -364,7 +359,6 @@ export async function getAllGlobal(holoInstance, tableName, password = null) {
                                         });
 
                                         if (resolved === null) {
-                                            console.log(`Hologram at ${tableName}/${key} points to non-existent data. Deleting hologram.`);
                                             try {
                                                 await holoInstance.deleteGlobal(tableName, key, password); // Use instance's deleteGlobal
                                             } catch (deleteError) {
@@ -515,7 +509,6 @@ export async function deleteGlobal(holoInstance, tableName, key, password = null
                             if (ack.err) {
                                 console.warn(`[deleteGlobal] Error removing hologram ${deletedHologramSoul} from target ${targetSoul}:`, ack.err);
                             }
-                            console.log(`Removed hologram ${deletedHologramSoul} from target ${targetSoul}'s _holograms list`);
                             resolveTrack(); // Resolve regardless of ack error to not block main delete
                         });
                     });
@@ -674,9 +667,8 @@ export async function deleteAllGlobal(holoInstance, tableName, password = null)
                                             targetNodeRef.get('_holograms').get(deletedHologramSoul).put(null, (ack) => {
                                                 if (ack.err) {
                                                     console.warn(`[deleteAllGlobal] Error removing hologram ${deletedHologramSoul} from target ${targetSoul}:`, ack.err);
-                                                }
-                                                console.log(`Removed hologram ${deletedHologramSoul} from target ${targetSoul}'s _holograms list`);
-                                                resolveTrack();
+                                                                                    }
+                                    resolveTrack();
                                             });
                                         });
                                     } else {
@@ -732,7 +724,7 @@ export async function deleteAllGlobal(holoInstance, tableName, password = null)
         console.error('Error in deleteAllGlobal:', error);
         throw error;
     }
-}
+} 
 
 // Export all global operations as default
 export default {

package/hologram.js

@@ -12,7 +12,6 @@ export function createHologram(holoInstance, holon, lens, data) {
     // Check if the input data is already a hologram
     if (isHologram(data)) {
         // If it is, just return its existing ID and Soul, ignoring the provided holon/lens
-        console.warn('createHologram called with data that is already a hologram. Reusing existing soul:', data.soul);
         return {
             id: data.id,
             soul: data.soul
@@ -85,6 +84,8 @@ export function isHologram(data) {
  * @param {object} [options] - Optional parameters
  * @param {boolean} [options.followHolograms=true] - Whether to follow nested holograms
  * @param {Set<string>} [options.visited] - Internal use: Tracks visited souls to prevent loops
+ * @param {number} [options.maxDepth=10] - Maximum resolution depth to prevent infinite loops
+ * @param {number} [options.currentDepth=0] - Current resolution depth
  * @returns {Promise<object|null>} - The resolved data, null if resolution failed due to target not found, or the original hologram for circular/invalid cases.
  */
 export async function resolveHologram(holoInstance, hologram, options = {}) {
@@ -92,29 +93,42 @@ export async function resolveHologram(holoInstance, hologram, options = {}) {
         return hologram; // Not a hologram, return as is
     }
 
-    const { followHolograms = true, visited = new Set() } = options;
+    const { 
+        followHolograms = true, 
+        visited = new Set(), 
+        maxDepth = 10, 
+        currentDepth = 0 
+    } = options;
+
+    // Check depth limit first
+    if (currentDepth >= maxDepth) {
+        console.warn(`!!! Maximum resolution depth (${maxDepth}) reached for soul: ${hologram.soul}. Stopping resolution.`);
+        return null;
+    }
 
-    // Check for circular hologram FIRST
+    // Check for circular hologram
     if (hologram.soul && visited.has(hologram.soul)) {
-        console.warn(`!!! CIRCULAR hologram detected for soul: ${hologram.soul}. Returning original hologram.`);
-        throw new Error(`CIRCULAR_REFERENCE:${hologram.soul}`);
-    } else {
+        console.warn(`!!! CIRCULAR hologram detected for soul: ${hologram.soul}. Breaking loop.`);
+        return null;
+    }
+
         try {
             // Handle direct soul hologram
             if (hologram.soul) {
                 const soulInfo = parseSoulPath(hologram.soul);
                 if (!soulInfo) {
                     console.warn(`Invalid soul format: ${hologram.soul}`);
-                    return hologram;
+                return null;
                 }
 
                 // Add current soul to visited set for THIS resolution path
                 const nextVisited = new Set(visited);
                 nextVisited.add(hologram.soul);
 
-                console.log(`Resolving hologram with soul: ${hologram.soul}`);
+            // Only log when actually resolving a hologram for debugging if needed
+            // console.log(`Resolving hologram: ${hologram.soul}`);
 
-                // Get original data
+            // Get original data with increased depth
                 const originalData = await holoInstance.get(
                     soulInfo.holon,
                     soulInfo.lens,
@@ -122,36 +136,41 @@ export async function resolveHologram(holoInstance, hologram, options = {}) {
                     null,
                     {
                         resolveHolograms: followHolograms,
-                        visited: nextVisited
+                    visited: nextVisited,
+                    maxDepth: maxDepth,
+                    currentDepth: currentDepth + 1
                     }
                 );
 
-                console.log('### resolveHologram received originalData:', originalData);
-
-                if (originalData) {
-                    console.log(`### Returning RESOLVED data for soul: ${hologram.soul}`);
+            if (originalData && !originalData._invalidHologram) {
                     // Structure for the returned object - isHologram (top-level) is removed
                     return {
                         ...originalData,
                         _meta: {
                             ...(originalData._meta || {}), // Preserve original _meta
                             resolvedFromHologram: true,    // This is now the primary indicator
-                            hologramSoul: hologram.soul     // Clarified meta field
+                        hologramSoul: hologram.soul,   // Clarified meta field
+                        resolutionDepth: currentDepth
                         }
                     };
                 } else {
-                    console.warn(`!!! Original data NOT FOUND for soul: ${hologram.soul}. Returning null.`);
-                    return null;
+                console.warn(`!!! Original data NOT FOUND for soul: ${hologram.soul}. Removing broken hologram.`);
+                
+                // Return null to indicate the hologram should be removed
+                return null;
                 }
             } else {
                  // Should not happen if isHologram() passed
                  console.warn('!!! resolveHologram called with object missing soul:', hologram);
-                 return hologram;
+            return null;
             }
         } catch (error) {
-            console.error(`!!! Error resolving hologram: ${error.message}`, error);
-            return hologram; // Return original hologram on error
+        if (error.message?.startsWith('CIRCULAR_REFERENCE')) {
+            console.warn(`!!! Circular reference detected during hologram resolution: ${error.message}`);
+            return null;
         }
+        console.error(`!!! Error resolving hologram: ${error.message}`, error);
+        return null; // Return null on error to prevent loops
     }
 }