holosphere 1.1.11 → 1.1.12

package/federation.js

@@ -3,6 +3,7 @@
  * Provides methods for creating, managing, and using federated spaces
  */
 
+import * as h3 from 'h3-js';
 
 /**
  * Creates a federation relationship between two spaces
@@ -330,14 +331,24 @@ export async function unfederate(holosphere, spaceId1, spaceId2, password1 = nul
             // For now, we'll let it proceed to attempt metadata cleanup, but a throw here might be valid.
         }
         
-        if (!fedInfo1 || !fedInfo1.federation) {
-            // If fedInfo1 or its federation array doesn't exist, log and proceed to metadata cleanup.
-            console.warn(`No federation array found for ${spaceId1} or fedInfo1 is null. Skipping its update.`);
+        if (!fedInfo1) {
+            // If fedInfo1 doesn't exist, log and proceed to metadata cleanup.
+            console.warn(`No federation info found for ${spaceId1}. Skipping its update.`);
         } else {
-            // Update first space federation info
+            // Ensure arrays exist
+            if (!fedInfo1.federation) fedInfo1.federation = [];
+            if (!fedInfo1.notify) fedInfo1.notify = [];
+            
+            // Update first space federation info - remove from both federation and notify arrays
+            const originalFederationLength = fedInfo1.federation.length;
+            const originalNotifyLength = fedInfo1.notify.length;
+            
             fedInfo1.federation = fedInfo1.federation.filter(id => id !== spaceId2);
+            fedInfo1.notify = fedInfo1.notify.filter(id => id !== spaceId2);
             fedInfo1.timestamp = Date.now();
             
+            console.log(`Unfederate: Removed ${spaceId2} from ${spaceId1}: federation ${originalFederationLength} -> ${fedInfo1.federation.length}, notify ${originalNotifyLength} -> ${fedInfo1.notify.length}`);
+            
             try {
                 await holosphere.putGlobal('federation', fedInfo1, password1);
             } catch (error) {
@@ -743,6 +754,8 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
  * @param {boolean} [options.useHolograms=true] - Use holograms for propagation (default: true)
  * @param {string[]} [options.targetSpaces] - Specific target spaces to propagate to (defaults to all federated spaces)
  * @param {string} [options.password] - Password for accessing the source holon (if needed)
+ * @param {boolean} [options.propagateToParents=true] - Whether to automatically propagate to parent hexagons (default: true)
+ * @param {number} [options.maxParentLevels=15] - Maximum number of parent levels to propagate to (default: 15)
  * @returns {Promise<object>} - Result with success count and errors
  */
 export async function propagate(holosphere, holon, lens, data, options = {}) {
@@ -750,147 +763,252 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
         throw new Error('propagate: Missing required parameters');
     }
     // Default propagation options
-    const { useHolograms = true, targetSpaces = null, password = null } = options;
+    const { 
+        useHolograms = true, 
+        targetSpaces = null, 
+        password = null,
+        propagateToParents = true,
+        maxParentLevels = 15
+    } = options;
 
     const result = {
         success: 0,
         errors: 0,
         skipped: 0,
-        messages: []
+        messages: [],
+        parentPropagation: {
+            success: 0,
+            errors: 0,
+            skipped: 0,
+            messages: []
+        }
     };
 
     try {
+        // ================================ FEDERATION PROPAGATION ================================
+        
         // Get federation info for this holon using getFederation
         const fedInfo = await getFederation(holosphere, holon, password);
         
-        // If no federation info or no federation list, return with message
-        if (!fedInfo || !fedInfo.federation || fedInfo.federation.length === 0) {
-            return {
-                ...result,
-                message: `No federation found for ${holon}`
-            };
-        }
-        
-        // If no notification list or it's empty, return with message
-        if (!fedInfo.notify || fedInfo.notify.length === 0) {
-            return {
-                ...result,
-                message: `No notification targets found for ${holon}`
-            };
-        }
-        
-        // Filter federation spaces to those in notify list
-        let spaces = fedInfo.notify;
-        
-        // Further filter by targetSpaces if provided
-        if (targetSpaces && Array.isArray(targetSpaces) && targetSpaces.length > 0) {
-            spaces = spaces.filter(space => targetSpaces.includes(space));
-        }
-        
-        if (spaces.length === 0) {
-            return {
-                ...result,
-                message: 'No valid target spaces found after filtering'
-            };
-        }
-
-        // Filter spaces based on lens configuration
-        spaces = spaces.filter(targetSpace => {
-            const spaceConfig = fedInfo.lensConfig?.[targetSpace];
-            if (!spaceConfig) {
-                result.messages.push(`No lens configuration for target space ${targetSpace}. Skipping propagation of lens '${lens}'.`);
-                result.skipped++;
-                return false;
-            }
-
-            // Ensure .federate is an array before calling .includes
-            const federateLenses = Array.isArray(spaceConfig.federate) ? spaceConfig.federate : [];
-
-            const shouldFederate = federateLenses.includes('*') || federateLenses.includes(lens);
+        // Only perform federation propagation if there's valid federation info
+        if (fedInfo && fedInfo.federation && fedInfo.federation.length > 0 && fedInfo.notify && fedInfo.notify.length > 0) {
+            // Filter federation spaces to those in notify list
+            let spaces = fedInfo.notify;
             
-            // Propagation now only depends on the 'federate' list configuration for the lens
-            const shouldPropagate = shouldFederate;
-            
-            if (!shouldPropagate) {
-                result.messages.push(`Propagation of lens '${lens}' to target space ${targetSpace} skipped: lens not in 'federate' configuration.`);
-                result.skipped++;
+            // Further filter by targetSpaces if provided
+            if (targetSpaces && Array.isArray(targetSpaces) && targetSpaces.length > 0) {
+                spaces = spaces.filter(space => targetSpaces.includes(space));
             }
             
-            return shouldPropagate;
-        });
+            if (spaces.length > 0) {
+                // Filter spaces based on lens configuration
+                spaces = spaces.filter(targetSpace => {
+                    const spaceConfig = fedInfo.lensConfig?.[targetSpace];
+                    if (!spaceConfig) {
+                        result.messages.push(`No lens configuration for target space ${targetSpace}. Skipping propagation of lens '${lens}'.`);
+                        result.skipped++;
+                        return false;
+                    }
 
-        if (spaces.length === 0) {
-            // If no specific skip messages were added and spaces is empty, add a general one.
-            if (result.skipped === 0 && fedInfo.notify && fedInfo.notify.length > 0) { 
-                result.messages.push('No target spaces were configured for federation of this specific lens, out of available notification partners.');
-            } else if (fedInfo.notify && fedInfo.notify.length === 0) {
-                result.messages.push('No notification partners available to filter for lens propagation.');
-            }
-            return {
-                ...result,
-                message: result.messages.join('; ') || 'No valid target spaces for propagation after lens filtering.'
-            };
-        }
-        
-        // Check if data is already a hologram
-        const isAlreadyHologram = holosphere.isHologram(data);
+                    // Ensure .federate is an array before calling .includes
+                    const federateLenses = Array.isArray(spaceConfig.federate) ? spaceConfig.federate : [];
 
-        // If data is already a hologram, don't re-wrap it
-        if (isAlreadyHologram && useHolograms) {
-        }
+                    const shouldFederate = federateLenses.includes('*') || federateLenses.includes(lens);
+                    
+                    // Propagation now only depends on the 'federate' list configuration for the lens
+                    const shouldPropagate = shouldFederate;
+                    
+                    if (!shouldPropagate) {
+                        result.messages.push(`Propagation of lens '${lens}' to target space ${targetSpace} skipped: lens not in 'federate' configuration.`);
+                        result.skipped++;
+                    }
+                    
+                    return shouldPropagate;
+                });
 
-        // If propagating a non-hologram and useHolograms is false, add warning
-        if (!isAlreadyHologram && !useHolograms) {
+                if (spaces.length > 0) {
+                    // Check if data is already a hologram
+                    const isAlreadyHologram = holosphere.isHologram(data);
+
+                    // For each target space, propagate the data
+                    const propagatePromises = spaces.map(async (targetSpace) => {
+                        try {
+                            let payloadToPut;
+                            const federationMeta = {
+                                origin: holon,       // The space from which this data is being propagated
+                                sourceLens: lens,    // The lens from which this data is being propagated
+                                propagatedAt: Date.now(),
+                                originalId: data.id
+                            };
+
+                            if (useHolograms && !isAlreadyHologram) {
+                                // Create a new hologram referencing the original data
+                                const newHologram = holosphere.createHologram(holon, lens, data);
+                                payloadToPut = {
+                                    ...newHologram, // This will be { id: data.id, soul: 'path/to/original' }
+                                    _federation: federationMeta
+                                };
+                            } else {
+                                // Propagate existing data (could be a full object or an existing hologram)
+                                // Make a shallow copy and update/add _federation metadata
+                                payloadToPut = {
+                                    ...data, 
+                                    _federation: {
+                                        ...(data._federation || {}), // Preserve existing _federation fields if any
+                                        ...federationMeta // Add/overwrite with current propagation info
+                                    }
+                                };
+                            }
+                            
+                            // Store in the target space with redirection disabled and no further auto-propagation
+                            await holosphere.put(targetSpace, lens, payloadToPut, null, { 
+                                disableHologramRedirection: true, 
+                                autoPropagate: false 
+                            });
+
+                            result.success++;
+                            return true;
+                        } catch (error) {
+                            result.errors++;
+                            result.messages.push(`Error propagating ${data.id} to ${targetSpace}: ${error.message}`);
+                            return false;
+                        }
+                    });
+                    
+                    await Promise.all(propagatePromises);
+                } else {
+                    result.messages.push('No valid target spaces for federation propagation after lens filtering.');
+                }
+            } else {
+                result.messages.push('No valid target spaces found for federation propagation.');
+            }
+        } else {
+            result.messages.push(`No federation found for ${holon} or no notification targets available.`);
         }
         
-        // For each target space, propagate the data
-        const propagatePromises = spaces.map(async (targetSpace) => {
+        // ================================ PARENT PROPAGATION ================================
+        
+        // Check if we should propagate to parent hexagons
+        if (propagateToParents) {
+            console.log(`[Federation] Starting parent propagation for holon: ${holon}`);
             try {
-                let payloadToPut;
-                const federationMeta = {
-                    origin: holon,       // The space from which this data is being propagated
-                    sourceLens: lens,    // The lens from which this data is being propagated
-                    propagatedAt: Date.now(),
-                    originalId: data.id
-                };
-
-                if (useHolograms && !isAlreadyHologram) {
-                    // Create a new hologram referencing the original data
-                    const newHologram = holosphere.createHologram(holon, lens, data);
-                    payloadToPut = {
-                        ...newHologram, // This will be { id: data.id, soul: 'path/to/original' }
-                        _federation: federationMeta
-                    };
-                } else {
-                    // Propagate existing data (could be a full object or an existing hologram)
-                    // Make a shallow copy and update/add _federation metadata
-                    payloadToPut = {
-                        ...data, 
-                        _federation: {
-                            ...(data._federation || {}), // Preserve existing _federation fields if any
-                            ...federationMeta // Add/overwrite with current propagation info
-                        }
-                    };
+                // Check if the holon is a valid H3 hexagon
+                let holonResolution;
+                try {
+                    holonResolution = h3.getResolution(holon);
+                    console.log(`[Federation] Holon ${holon} is valid H3 hexagon with resolution: ${holonResolution}`);
+                } catch (error) {
+                    // Not a valid H3 hexagon, skip parent propagation
+                    console.log(`[Federation] Holon ${holon} is not a valid H3 hexagon: ${error.message}`);
+                    result.parentPropagation.messages.push(`Holon ${holon} is not a valid H3 hexagon. Skipping parent propagation.`);
+                    result.parentPropagation.skipped++;
                 }
                 
-                // Store in the target space with redirection disabled and no further auto-propagation
-                await holosphere.put(targetSpace, lens, payloadToPut, null, { 
-                    disableHologramRedirection: true, 
-                    autoPropagate: false 
-                });
+                if (holonResolution !== undefined) {
+                    // Get all parent hexagons up to the specified max levels
+                    const parentHexagons = [];
+                    let currentHolon = holon;
+                    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++;
+                        } catch (error) {
+                            console.error(`[Federation] Error getting parent for ${currentHolon}: ${error.message}`);
+                            result.parentPropagation.messages.push(`Error getting parent for ${currentHolon}: ${error.message}`);
+                            result.parentPropagation.errors++;
+                            break;
+                        }
+                    }
+                    
+                    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
+                                    sourceLens: lens,        // The lens from which this data is being propagated
+                                    propagatedAt: Date.now(),
+                                    originalId: data.id,
+                                    propagationType: 'parent', // Indicate this is parent propagation
+                                    parentLevel: holonResolution - h3.getResolution(parentHexagon) // How many levels up
+                                };
 
-                result.success++;
-                return true;
+                                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
+                                    };
+                                } else {
+                                    // Propagate existing data (could be a full object or an existing hologram)
+                                    // Make a shallow copy and update/add _federation metadata
+                                    payloadToPut = {
+                                        ...data, 
+                                        _federation: {
+                                            ...(data._federation || {}), // Preserve existing _federation fields if any
+                                            ...parentFederationMeta // Add/overwrite with current propagation info
+                                        }
+                                    };
+                                }
+                                
+                                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, 
+                                    autoPropagate: false 
+                                });
+
+                                console.log(`[Federation] Successfully propagated to parent hexagon: ${parentHexagon}`);
+                                result.parentPropagation.success++;
+                                return true;
+                            } catch (error) {
+                                console.error(`[Federation] Error propagating ${data.id} to parent hexagon ${parentHexagon}: ${error.message}`);
+                                result.parentPropagation.errors++;
+                                result.parentPropagation.messages.push(`Error propagating ${data.id} to parent hexagon ${parentHexagon}: ${error.message}`);
+                                return false;
+                            }
+                        });
+                        
+                        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++;
+                    }
+                }
             } catch (error) {
-                result.errors++;
-                result.messages.push(`Error propagating ${data.id} to ${targetSpace}: ${error.message}`);
-                return false;
+                console.error(`[Federation] Error during parent propagation: ${error.message}`);
+                result.parentPropagation.errors++;
+                result.parentPropagation.messages.push(`Error during parent propagation: ${error.message}`);
             }
-        });
+        } else {
+            console.log(`[Federation] Parent propagation disabled for holon: ${holon}`);
+        }
         
-        await Promise.all(propagatePromises);
+        // ================================ END PARENT PROPAGATION ================================
         
-        result.propagated = result.success > 0;
+        result.propagated = result.success > 0 || result.parentPropagation.success > 0;
         return result;
     } catch (error) {
         return {

package/global.js

@@ -63,11 +63,15 @@ export async function putGlobal(holoInstance, tableName, data, password = null)
 
         return new Promise((resolve, reject) => {
             try {
-                // Remove isHologram field before storing - NO LONGER NEEDED
-                // if (data && data.isHologram !== undefined) {
-                // delete data.isHologram;
-                // }
-                const payload = JSON.stringify(data);
+                // Create a copy of data without the _meta field if it exists
+                let dataToStore = { ...data };
+                if (dataToStore._meta !== undefined) {
+                    delete dataToStore._meta;
+                }
+                const payload = JSON.stringify(dataToStore);
+
+                // Check if the data being stored is a hologram
+                const isHologram = holoInstance.isHologram(dataToStore);
 
                 const dataPath = password ?
                     user.get('private').get(tableName) :
@@ -79,6 +83,27 @@ export async function putGlobal(holoInstance, tableName, data, password = null)
                         if (ack.err) {
                             reject(new Error(ack.err));
                         } else {
+                            // --- Start: Hologram Tracking Logic (for data *being put*, if it's a hologram) ---
+                            if (isHologram) {
+                                try {
+                                    const storedDataSoulInfo = holoInstance.parseSoulPath(dataToStore.soul);
+                                    if (storedDataSoulInfo) {
+                                        const targetNodeRef = holoInstance.getNodeRef(dataToStore.soul); // Target of the data *being put*
+                                        // 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 {
+                                        console.warn(`Data (ID: ${data.id}) being put is a hologram, but could not parse its soul ${dataToStore.soul} for tracking.`);
+                                    }
+                                } catch (trackingError) {
+                                    console.warn(`Error updating _holograms set for the target of the data being put (data ID: ${data.id}, soul: ${dataToStore.soul}):`, trackingError);
+                                }
+                            }
+                            // --- End: Hologram Tracking Logic ---
+                            
                             resolve();
                         }
                     });
@@ -87,6 +112,27 @@ export async function putGlobal(holoInstance, tableName, data, password = null)
                         if (ack.err) {
                             reject(new Error(ack.err));
                         } else {
+                            // --- Start: Hologram Tracking Logic (for data *being put*, if it's a hologram) ---
+                            if (isHologram) {
+                                try {
+                                    const storedDataSoulInfo = holoInstance.parseSoulPath(dataToStore.soul);
+                                    if (storedDataSoulInfo) {
+                                        const targetNodeRef = holoInstance.getNodeRef(dataToStore.soul); // Target of the data *being put*
+                                        // 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 {
+                                        console.warn(`Data being put is a hologram, but could not parse its soul ${dataToStore.soul} for tracking.`);
+                                    }
+                                } catch (trackingError) {
+                                    console.warn(`Error updating _holograms set for the target of the data being put (soul: ${dataToStore.soul}):`, trackingError);
+                                }
+                            }
+                            // --- End: Hologram Tracking Logic ---
+                            
                             resolve();
                         }
                     });
@@ -421,11 +467,66 @@ export async function deleteGlobal(holoInstance, tableName, key, password = null
             });
         }
 
-        return new Promise((resolve, reject) => {
-            const dataPath = password ?
-                user.get('private').get(tableName).get(key) :
-                holoInstance.gun.get(holoInstance.appname).get(tableName).get(key);
+        const dataPath = password ?
+            user.get('private').get(tableName).get(key) :
+            holoInstance.gun.get(holoInstance.appname).get(tableName).get(key);
+
+        // --- Start: Hologram Tracking Removal ---
+        let trackingRemovalPromise = Promise.resolve(); // Default to resolved promise
+        
+        // 1. Get the data first to check if it's a hologram
+        const rawDataToDelete = await new Promise((resolve) => dataPath.once(resolve));
+        let dataToDelete = null;
+        try {
+            if (typeof rawDataToDelete === 'string') {
+                dataToDelete = JSON.parse(rawDataToDelete);
+            } else {
+                // Handle cases where it might already be an object (though likely string)
+                dataToDelete = rawDataToDelete; 
+            }
+        } catch(e) {
+            console.warn("[deleteGlobal] Could not JSON parse data for deletion check:", rawDataToDelete, e);
+            dataToDelete = null; // Ensure it's null if parsing fails
+        }
+
+        // 2. If it is a hologram, try to remove its reference from the target
+        const isDataHologram = dataToDelete && holoInstance.isHologram(dataToDelete);
+        
+        if (isDataHologram) {
+            try {
+                const targetSoul = dataToDelete.soul;
+                const targetSoulInfo = holoInstance.parseSoulPath(targetSoul);
+                
+                if (targetSoulInfo) {
+                    const targetNodeRef = holoInstance.getNodeRef(targetSoul);
+                    const deletedHologramSoul = `${holoInstance.appname}/${tableName}/${key}`;
+
+                    // Create a promise that resolves when the hologram is removed from the list
+                    trackingRemovalPromise = new Promise((resolveTrack) => { // No reject needed, just warn on error
+                        targetNodeRef.get('_holograms').get(deletedHologramSoul).put(null, (ack) => { // Remove the hologram entry completely
+                            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
+                        });
+                    });
+                } else {
+                    console.warn(`Could not parse target soul ${targetSoul} for hologram tracking removal during deleteGlobal.`);
+                }
+            } catch (trackingError) {
+                console.warn(`Error initiating hologram reference removal from target ${dataToDelete.soul} during deleteGlobal:`, trackingError);
+                // Ensure trackingRemovalPromise remains resolved if setup fails
+                trackingRemovalPromise = Promise.resolve(); 
+            }
+        }
+        // --- End: Hologram Tracking Removal ---
+
+        // 3. Wait for the tracking removal attempt to be acknowledged
+        await trackingRemovalPromise;
 
+        // 4. Proceed with the actual deletion of the hologram node itself
+        return new Promise((resolve, reject) => {
             // Request deletion
             dataPath.put(null, ack => {
                 // console.log('deleteGlobal - Deletion acknowledgment:', ack); // Optional logging
@@ -522,6 +623,70 @@ export async function deleteAllGlobal(holoInstance, tableName, password = null)
                     }
 
                     const keys = Object.keys(data).filter(key => key !== '_');
+                    
+                    // Process each key to handle holograms properly
+                    for (const key of keys) {
+                        try {
+                            // Get the data to check if it's a hologram
+                            const itemPath = password ?
+                                user.get('private').get(tableName).get(key) :
+                                holoInstance.gun.get(holoInstance.appname).get(tableName).get(key);
+
+                            const rawDataToDelete = await new Promise((resolveItem) => itemPath.once(resolveItem));
+                            let dataToDelete = null;
+                            
+                            try {
+                                if (typeof rawDataToDelete === 'string') {
+                                    dataToDelete = JSON.parse(rawDataToDelete);
+                                } else {
+                                    dataToDelete = rawDataToDelete;
+                                }
+                            } catch(e) {
+                                console.warn("[deleteAllGlobal] Could not JSON parse data for deletion check:", rawDataToDelete, e);
+                                dataToDelete = null;
+                            }
+
+                            // Check if it's a hologram and handle accordingly
+                            const isDataHologram = dataToDelete && holoInstance.isHologram(dataToDelete);
+                            
+                            if (isDataHologram) {
+                                // Handle hologram deletion - remove from target's _holograms list
+                                try {
+                                    const targetSoul = dataToDelete.soul;
+                                    const targetSoulInfo = holoInstance.parseSoulPath(targetSoul);
+                                    
+                                    if (targetSoulInfo) {
+                                        const targetNodeRef = holoInstance.getNodeRef(targetSoul);
+                                        const deletedHologramSoul = `${holoInstance.appname}/${tableName}/${key}`;
+
+                                        // Remove the hologram from target's _holograms list
+                                        await new Promise((resolveTrack) => {
+                                            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();
+                                            });
+                                        });
+                                    } else {
+                                        console.warn(`Could not parse target soul ${targetSoul} for hologram tracking removal during deleteAllGlobal.`);
+                                    }
+                                } catch (trackingError) {
+                                    console.warn(`Error removing hologram reference from target ${dataToDelete.soul} during deleteAllGlobal:`, trackingError);
+                                }
+                            }
+
+                            // Add to deletions set for tracking
+                            deletions.add(key);
+                        } catch (error) {
+                            console.warn(`Error processing key ${key} during deleteAllGlobal:`, error);
+                            // Still add to deletions set even if hologram processing failed
+                            deletions.add(key);
+                        }
+                    }
+
+                    // Now delete all the items
                     const promises = keys.map(key =>
                         new Promise((resolveDelete, rejectDelete) => {
                             const deletePath = password ?