holosphere 1.1.12 → 1.1.13

package/test/hologram-updates-return.test.js

@@ -1,166 +0,0 @@
-// hologram-updates-return.test.js
-
-import HoloSphere from '../holosphere.js';
-
-describe('Hologram Updates Return Value Tests', () => {
-    let holoSphere;
-    const testHolon = 'updateReturnTestHolon';
-    const testLens = 'testLens';
-    const otherLens = 'otherLens';
-    const appName = 'test-hologram-return-app';
-
-    const waitForGun = (ms = 300) => new Promise(resolve => setTimeout(resolve, ms));
-
-    beforeEach(async () => {
-        holoSphere = new HoloSphere(appName, false);
-        // Clean up before each test
-        try {
-            await holoSphere.deleteAll(testHolon, testLens);
-            await holoSphere.deleteAll(testHolon, otherLens);
-        } catch (error) {
-            // Ignore cleanup errors
-        }
-        
-        await waitForGun(100);
-    }, 30000);
-
-    afterEach(async () => {
-        if (holoSphere) {
-            await holoSphere.close();
-        }
-    });
-
-    test('put should return empty array when no holograms exist', async () => {
-        const originalData = { id: 'no-holograms-test', value: 'Original Value' };
-        
-        // Put original data
-        const result = await holoSphere.put(testHolon, testLens, originalData);
-        
-        expect(result).toBeDefined();
-        expect(result.success).toBe(true);
-        expect(result.updatedHolograms).toBeDefined();
-        expect(Array.isArray(result.updatedHolograms)).toBe(true);
-        expect(result.updatedHolograms).toHaveLength(0);
-    });
-
-    test('put should return list of updated holograms when they exist', async () => {
-        const originalData = { id: 'with-holograms-test', value: 'Original Value' };
-        
-        // Step 1: Put original data
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-        
-        // Step 2: Create holograms pointing to the original data
-        const hologram1 = holoSphere.createHologram(testHolon, testLens, originalData);
-        const hologram2 = holoSphere.createHologram(testHolon, testLens, originalData);
-        
-        await holoSphere.put(testHolon, otherLens, { id: 'hologram-1', soul: hologram1.soul });
-        await holoSphere.put(testHolon, otherLens, { id: 'hologram-2', soul: hologram2.soul });
-        await waitForGun(500);
-        
-        // Step 3: Update the original data and check the return value
-        const updatedData = { ...originalData, value: 'Updated Value', count: 42 };
-        const result = await holoSphere.put(testHolon, testLens, updatedData);
-        
-        expect(result).toBeDefined();
-        expect(result.success).toBe(true);
-        expect(result.updatedHolograms).toBeDefined();
-        expect(Array.isArray(result.updatedHolograms)).toBe(true);
-        expect(result.updatedHolograms.length).toBeGreaterThan(0);
-        
-        // Check that the returned hologram info is complete
-        result.updatedHolograms.forEach(hologram => {
-            expect(hologram.soul).toBeDefined();
-            expect(hologram.holon).toBe(testHolon);
-            expect(hologram.lens).toBeDefined(); // Could be testLens or otherLens
-            expect(hologram.key).toBeDefined();
-            expect(hologram.id).toBeDefined();
-            expect(hologram.timestamp).toBeDefined();
-            expect(typeof hologram.timestamp).toBe('number');
-        });
-        
-        // Verify that the souls match what we expect
-        const expectedSouls = [
-            `${appName}/${testHolon}/${otherLens}/hologram-1`,
-            `${appName}/${testHolon}/${otherLens}/hologram-2`
-        ];
-        
-        const returnedSouls = result.updatedHolograms.map(h => h.soul);
-        expectedSouls.forEach(expectedSoul => {
-            expect(returnedSouls).toContain(expectedSoul);
-        });
-    });
-
-    test('put should return updated holograms with correct structure', async () => {
-        const originalData = { id: 'structure-test', value: 'Test Value' };
-        
-        // Put original data
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-        
-        // Create one hologram
-        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
-        await holoSphere.put(testHolon, otherLens, { id: 'structure-hologram', soul: hologram.soul });
-        await waitForGun(500);
-        
-        // Update original data
-        const updatedData = { ...originalData, value: 'Updated Test Value' };
-        const result = await holoSphere.put(testHolon, testLens, updatedData);
-        
-        expect(result.updatedHolograms).toHaveLength(1);
-        
-        const updatedHologram = result.updatedHolograms[0];
-        expect(updatedHologram).toEqual({
-            soul: `${appName}/${testHolon}/${otherLens}/structure-hologram`,
-            holon: testHolon,
-            lens: otherLens,
-            key: 'structure-hologram',
-            id: 'structure-hologram',
-            timestamp: expect.any(Number)
-        });
-        
-        // Verify timestamp is recent (within last few seconds)
-        const now = Date.now();
-        expect(updatedHologram.timestamp).toBeGreaterThan(now - 5000);
-        expect(updatedHologram.timestamp).toBeLessThanOrEqual(now);
-    });
-
-    test('put with isHologramUpdate option should not return updated holograms', async () => {
-        const originalData = { id: 'no-recursive-test', value: 'Original Value' };
-        
-        // Put original data
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-        
-        // Create hologram
-        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
-        await holoSphere.put(testHolon, otherLens, { id: 'recursive-test', soul: hologram.soul });
-        await waitForGun(500);
-        
-        // Update with isHologramUpdate flag (should not trigger hologram updates)
-        const updatedData = { ...originalData, value: 'Updated Value' };
-        const result = await holoSphere.put(testHolon, testLens, updatedData, null, { isHologramUpdate: true });
-        
-        expect(result).toBeDefined();
-        expect(result.success).toBe(true);
-        expect(result.updatedHolograms).toBeDefined();
-        expect(result.updatedHolograms).toHaveLength(0);
-    });
-
-    test('put hologram should not return updated holograms', async () => {
-        const originalData = { id: 'hologram-put-test', value: 'Original Value' };
-        
-        // Put original data
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-        
-        // Put a hologram (not original data)
-        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
-        const result = await holoSphere.put(testHolon, otherLens, { id: 'test-hologram', soul: hologram.soul });
-        
-        expect(result).toBeDefined();
-        expect(result.success).toBe(true);
-        expect(result.updatedHolograms).toBeDefined();
-        expect(result.updatedHolograms).toHaveLength(0);
-    });
-}); 

package/test/hologram-updates.test.js

@@ -1,143 +0,0 @@
-// hologram-updates.test.js
-
-import HoloSphere from '../holosphere.js';
-
-describe('Hologram Update Tests', () => {
-    let holoSphere;
-    const testHolon = 'updateTestHolon';
-    const testLens = 'testLens';
-    const otherLens = 'otherLens';
-    const appName = 'test-hologram-update-app';
-
-    const waitForGun = (ms = 300) => new Promise(resolve => setTimeout(resolve, ms));
-
-    beforeEach(async () => {
-        holoSphere = new HoloSphere(appName, false);
-        // Clean up before each test
-        try {
-            await holoSphere.deleteAll(testHolon, testLens);
-            await holoSphere.deleteAll(testHolon, otherLens);
-        } catch (error) {
-            // Ignore cleanup errors
-        }
-        
-        await waitForGun(100);
-    }, 30000);
-
-    afterEach(async () => {
-        if (holoSphere) {
-            await holoSphere.close();
-        }
-    }, 30000);
-
-    test('should update active holograms when original data is modified', async () => {
-        // 1. Store original data
-        const originalData = { id: 'update-test-item', value: 'Original Value', count: 1 };
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-
-        // 2. Create and store a hologram pointing to the original data
-        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
-        await holoSphere.put(testHolon, otherLens, hologram); // Store hologram in different lens
-        await waitForGun(500);
-
-        // 3. Get the hologram before update (should not have 'updated' field)
-        const hologramBeforeUpdate = await holoSphere.get(testHolon, otherLens, originalData.id, null, { resolveHolograms: false });
-        expect(hologramBeforeUpdate).toBeDefined();
-        expect(hologramBeforeUpdate.soul).toBe(hologram.soul);
-        expect(hologramBeforeUpdate.updated).toBeUndefined();
-
-        // 4. Update the original data
-        const updatedData = { id: 'update-test-item', value: 'Updated Value', count: 2 };
-        await holoSphere.put(testHolon, testLens, updatedData);
-        await waitForGun(1000); // Give time for hologram updates to propagate
-
-        // 5. Check that the hologram now has an 'updated' timestamp
-        const hologramAfterUpdate = await holoSphere.get(testHolon, otherLens, originalData.id, null, { resolveHolograms: false });
-        expect(hologramAfterUpdate).toBeDefined();
-        expect(hologramAfterUpdate.soul).toBe(hologram.soul);
-        expect(hologramAfterUpdate.updated).toBeDefined();
-        expect(typeof hologramAfterUpdate.updated).toBe('number');
-        expect(hologramAfterUpdate.updated).toBeGreaterThan(Date.now() - 5000); // Should be recent
-
-        // 6. Verify that resolving the hologram gives the updated data
-        const resolvedData = await holoSphere.get(testHolon, otherLens, originalData.id);
-        expect(resolvedData).toBeDefined();
-        expect(resolvedData.value).toBe('Updated Value');
-        expect(resolvedData.count).toBe(2);
-    });
-
-    test('should update multiple holograms pointing to the same data', async () => {
-        // 1. Store original data
-        const originalData = { id: 'multi-hologram-test', value: 'Original Value' };
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-
-        // 2. Create and store multiple holograms pointing to the same data
-        const hologram1 = holoSphere.createHologram(testHolon, testLens, originalData);
-        const hologram2 = holoSphere.createHologram(testHolon, testLens, originalData);
-        
-        await holoSphere.put(testHolon, otherLens, { ...hologram1, id: 'hologram-1' });
-        await holoSphere.put(testHolon, otherLens, { ...hologram2, id: 'hologram-2' });
-        await waitForGun(500);
-
-        // 3. Update the original data
-        const updatedData = { id: 'multi-hologram-test', value: 'Updated Value' };
-        await holoSphere.put(testHolon, testLens, updatedData);
-        await waitForGun(1000);
-
-        // 4. Check that both holograms have been updated
-        const updatedHologram1 = await holoSphere.get(testHolon, otherLens, 'hologram-1', null, { resolveHolograms: false });
-        const updatedHologram2 = await holoSphere.get(testHolon, otherLens, 'hologram-2', null, { resolveHolograms: false });
-
-        expect(updatedHologram1.updated).toBeDefined();
-        expect(updatedHologram2.updated).toBeDefined();
-        expect(typeof updatedHologram1.updated).toBe('number');
-        expect(typeof updatedHologram2.updated).toBe('number');
-    });
-
-    test('should not update deleted holograms', async () => {
-        // 1. Store original data
-        const originalData = { id: 'delete-test-item', value: 'Original Value' };
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-
-        // 2. Create and store a hologram
-        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
-        await holoSphere.put(testHolon, otherLens, hologram);
-        await waitForGun(500);
-
-        // 3. Delete the hologram
-        await holoSphere.delete(testHolon, otherLens, originalData.id);
-        await waitForGun(500);
-
-        // 4. Update the original data
-        const updatedData = { id: 'delete-test-item', value: 'Updated Value' };
-        await holoSphere.put(testHolon, testLens, updatedData);
-        await waitForGun(1000);
-
-        // 5. Verify the original data was updated
-        const retrievedData = await holoSphere.get(testHolon, testLens, originalData.id);
-        expect(retrievedData.value).toBe('Updated Value');
-
-        // 6. Verify the hologram was not updated (since it's deleted)
-        const deletedHologram = await holoSphere.get(testHolon, otherLens, originalData.id);
-        expect(deletedHologram).toBeNull(); // Should be null since it was deleted
-    });
-
-    test('should work with data that has no holograms', async () => {
-        // 1. Store data that has no holograms pointing to it
-        const originalData = { id: 'no-holograms-test', value: 'Original Value' };
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun();
-
-        // 2. Update the data (should not cause errors even with no holograms)
-        const updatedData = { id: 'no-holograms-test', value: 'Updated Value' };
-        await holoSphere.put(testHolon, testLens, updatedData);
-        await waitForGun(1000);
-
-        // 3. Verify the data was updated successfully
-        const retrievedData = await holoSphere.get(testHolon, testLens, originalData.id);
-        expect(retrievedData.value).toBe('Updated Value');
-    });
-}); 

package/test/hologram.test.js

@@ -1,316 +0,0 @@
-import HoloSphere from '../holosphere.js';
-import { jest } from '@jest/globals';
-
-// Configure timeout
-jest.setTimeout(30000); // 30 second timeout
-
-// Utility to wait for GunDB propagation
-const waitForGun = (delay = 250) => new Promise(resolve => setTimeout(resolve, delay));
-
-// Setup
-describe('HoloSphere Reference System', () => {
-    let holoSphere;
-    const appName = 'test-hologram-app'; // Update app name
-    const testHolon = 'hologramTestHolon'; // Update holon name
-    const testLens = 'testLens';
-    
-    beforeAll(async () => {
-        // Create a single HoloSphere instance for all tests
-        holoSphere = new HoloSphere(appName);
-    });
-    
-    afterAll(async () => {
-        // Clean up after all tests
-        if (holoSphere) {
-            await holoSphere.close();
-            // Wait for connections to close
-            await new Promise(resolve => setTimeout(resolve, 500));
-        }
-    });
-    
-    test('should create and parse a hologram correctly', async () => {
-        // Test data
-        const data = { id: 'ref1', value: 'Original Data' };
-        await holoSphere.put(testHolon, testLens, data);
-        await waitForGun(); // <-- Add delay
-        
-        // Create a hologram
-        const hologram = holoSphere.createHologram(testHolon, testLens, data); // Use renamed method
-        
-        expect(hologram).toBeDefined();
-        expect(hologram.id).toBe('ref1');
-        expect(hologram.soul).toBe(`${appName}/${testHolon}/${testLens}/ref1`);
-        expect(holoSphere.isHologram(hologram)).toBe(true); // Use renamed method
-    });
-    
-    test('isHologram should return false for non-hologram objects', () => { // Rename test description
-        expect(holoSphere.isHologram(null)).toBe(false); // Use renamed method
-        expect(holoSphere.isHologram(undefined)).toBe(false); // Use renamed method
-        expect(holoSphere.isHologram({})).toBe(false); // Use renamed method
-        expect(holoSphere.isHologram({ id: 'test' })).toBe(false); // Use renamed method
-        expect(holoSphere.isHologram({ soul: 'path' })).toBe(false); // Use renamed method
-        expect(holoSphere.isHologram('string')).toBe(false); // Use renamed method
-    });
-    
-    test('should resolve a valid hologram', async () => { // Rename test description
-        const data = { id: 'ref2', value: 'Data to Resolve' };
-        await holoSphere.put(testHolon, testLens, data);
-        await waitForGun(); // <-- Add delay
-        const hologram = holoSphere.createHologram(testHolon, testLens, data); // Use renamed method
-
-        const resolved = await holoSphere.resolveHologram(hologram); // Use renamed method
-
-        expect(resolved).toBeDefined();
-        expect(resolved.id).toBe('ref2');
-        expect(resolved.value).toBe('Data to Resolve');
-        // Check for updated metadata
-        expect(resolved._meta).toBeDefined();
-        expect(resolved._meta.resolvedFromHologram).toBe(true);
-        expect(resolved._meta.hologramSoul).toBe(hologram.soul);
-        expect(resolved.isHologram).toBeUndefined(); // Ensure top-level isHologram is not present
-        // Ensure old fields are not in _meta unless they were on originalData
-        expect(resolved._meta.isHologram).toBeUndefined(); 
-        expect(resolved._meta.resolved).toBeUndefined();
-        // expect(resolved._meta.soul).toBeUndefined(); // hologramSoul is the new field for this
-    });
-    
-    test('resolveHologram should return null for a hologram pointing to non-existent data', async () => { // Rename test description
-        const nonExistentData = { id: 'ref-non-existent' }; // Data never stored
-        const hologram = holoSphere.createHologram(testHolon, testLens, nonExistentData); // Create hologram for it
-
-        const resolved = await holoSphere.resolveHologram(hologram); // Use renamed method
-        expect(resolved).toBeNull(); // Resolution should fail and return null
-    });
-    
-    test('resolveHologram should return the original object if not a hologram', async () => { // Rename test description
-        const plainObject = { id: 'not-a-ref', value: 123 };
-        const resolved = await holoSphere.resolveHologram(plainObject); // Use renamed method
-        expect(resolved).toBe(plainObject); // Should return the object itself
-    });
-    
-    // Test for nested holograms
-    test('should resolve nested holograms correctly', async () => { // Rename test description
-        // 1. Original Data stored under its own ID
-        const originalData = { id: 'actual-nested-original', value: 'level 0' };
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun(750); // <-- Increased delay
-
-        // 2. Hologram 1 pointing to Original Data, stored under 'hologram1-id'
-        const hologram1Data = holoSphere.createHologram(testHolon, testLens, originalData);
-        const hologram1Storage = { id: 'hologram1-id', soul: hologram1Data.soul }; // Soul points to originalData
-        await holoSphere.put(testHolon, testLens, hologram1Storage); 
-        await waitForGun(750); // <-- Increased delay
-
-        // 3. Hologram 2 pointing to Hologram 1, stored under 'hologram2-id'
-        // Create a temporary object representing hologram1 for creating hologram2
-        const hologram1Ref = { id: 'hologram1-id' }; // We only need the ID hologram2 should point to
-        const hologram2Data = holoSphere.createHologram(testHolon, testLens, hologram1Ref); // Soul points to hologram1Storage
-        const hologram2Storage = { id: 'hologram2-id', soul: hologram2Data.soul }; // Soul points to .../hologram1-id
-        await holoSphere.put(testHolon, testLens, hologram2Storage); 
-        await waitForGun(750); // <-- Increased delay
-
-        // Resolve Hologram 2 (which is stored at hologram2-id)
-        // The system should fetch hologram2Storage, see its soul points to hologram1-id,
-        // fetch hologram1Storage, see its soul points to actual-nested-original,
-        // fetch originalData, and return it.
-        const resolved = await holoSphere.get(testHolon, testLens, 'hologram2-id'); 
-
-        console.log("!!!!!!!!!!!!! nested hologram", resolved);
-
-        expect(resolved).toBeNull(); // Expect null if new logic dictates this for nested resolution
-
-        // Resolve Hologram 2 without following deeply - should return Hologram 1 data
-        // Fetch hologram2Storage with resolveHolograms: false. This gets the raw hologram object.
-        const fetchedHologram2 = await holoSphere.get(testHolon, testLens, 'hologram2-id', null, { resolveHolograms: false });
-        // Now, resolve *this specific hologram object* one level deep.
-        const resolvedShallow = await holoSphere.resolveHologram(fetchedHologram2, { followHolograms: false });
-        
-        console.log("!!!!!!!!!!!!! nested hologram shallow", resolvedShallow);
-
-        expect(resolvedShallow).toBeDefined();
-        // Should match hologram2Storage because of put redirection
-        expect(resolvedShallow.id).toBe('hologram2-id'); // ID from hologram2Storage
-        expect(resolvedShallow.soul).toBe(hologram2Storage.soul); // Soul from hologram2Storage
-        expect(resolvedShallow.value).toBeUndefined(); // Should not have value from originalData
-        expect(resolvedShallow.isHologram).toBeUndefined(); // Ensure top-level isHologram is not present
-        expect(resolvedShallow._meta).toBeDefined();
-        expect(resolvedShallow._meta.resolvedFromHologram).toBe(true);
-        expect(resolvedShallow._meta.hologramSoul).toBe(fetchedHologram2.soul);
-        expect(resolvedShallow._meta.isHologram).toBeUndefined();
-        expect(resolvedShallow._meta.resolved).toBeUndefined();
-    });
-    
-    // Test for circular holograms
-    test('should detect and handle circular holograms', async () => { // Rename test description
-        // Hologram A points to Hologram B's future location
-        const holoA = { id: 'holoA', soul: `${appName}/${testHolon}/${testLens}/holoB` };
-        await holoSphere.put(testHolon, testLens, holoA);
-        await waitForGun(); // <-- Add delay
-
-        // Hologram B points to Hologram A's location
-        const holoB = { id: 'holoB', soul: `${appName}/${testHolon}/${testLens}/holoA` };
-        await holoSphere.put(testHolon, testLens, holoB);
-        await waitForGun(); // <-- Add delay
-
-        // Attempt to resolve Hologram A via get, which should handle the circular error from resolveHologram
-        const resolved = await holoSphere.get(testHolon, testLens, holoA.id); 
-
-        // Should return null due to circular detection handled in get()
-        expect(resolved).toBeNull();
-    });
-
-    test('get should resolve holograms by default', async () => { // Rename test description
-        // 1. Store the actual data under its own ID
-        const actualData = { id: 'actual-data-id', value: 'Fetched via get' };
-        await holoSphere.put(testHolon, testLens, actualData);
-        await waitForGun(750); // <-- Increased delay
-
-        // 2. Create a hologram pointing to the actual data
-        // The hologram object itself will have the ID 'actual-data-id'
-        const hologramPointingToData = holoSphere.createHologram(testHolon, testLens, actualData);
-
-        // 3. Store the hologram object under the ID we want to fetch ('get-ref')
-        // We need to create a new object for storage that uses the hologram's soul
-        // but has the ID 'get-ref'.
-        const hologramStorageObject = { id: 'get-ref', soul: hologramPointingToData.soul };
-        await holoSphere.put(testHolon, testLens, hologramStorageObject); 
-        await waitForGun(750); // <-- Increased delay
-
-        // 4. Get the item by the hologram's storage ID ('get-ref')
-        // This should retrieve hologramStorageObject and then resolve its soul
-        const resolved = await holoSphere.get(testHolon, testLens, 'get-ref');
-
-        console.log("!!!!!!!!!!!!!",resolved); // Should now show resolved data + meta
-        // Assertions should check against the *actualData*
-        // expect(resolved.id).toBe('actual-data-id'); // ID comes from the resolved data
-        // expect(resolved.value).toBe('Fetched via get'); // Value comes from the resolved data
-        // expect(resolved._meta).toBeDefined();
-        // expect(resolved._meta.isHologram).toBe(true);
-        // expect(resolved._meta.resolved).toBe(true);
-        // // The soul in the meta should be the soul of the *hologram object* we fetched
-        // expect(resolved._meta.soul).toBe(hologramStorageObject.soul);
-        expect(resolved).toBeNull(); // Expect null due to circular reference caused by put redirection
-    });
-
-    test('get should not resolve holograms if resolveHolograms is false', async () => { // Rename test description
-        const data = { id: 'get-no-res', value: 'Original' };
-        await holoSphere.put(testHolon, testLens, data);
-        await waitForGun(); // <-- Add delay
-        const hologram = holoSphere.createHologram(testHolon, testLens, data); // Use renamed method
-        await holoSphere.put(testHolon, testLens, hologram); // Store the hologram itself at its ID
-        await waitForGun(); // <-- Add delay
-
-        // Get the item by ID without resolving
-        const unresolved = await holoSphere.get(testHolon, testLens, 'get-no-res', null, { resolveHolograms: false }); // Use renamed option
-
-        expect(unresolved).toBeDefined();
-        expect(unresolved.id).toBe('get-no-res');
-        expect(unresolved.soul).toBe(hologram.soul);
-        expect(unresolved.value).toBeUndefined(); // Should be the raw hologram
-        expect(unresolved._meta).toBeUndefined();
-    });
-
-    test('get should return null if hologram resolution fails (target deleted)', async () => { // Rename test description
-        const data = { id: 'get-deleted-target' };
-        // Create hologram but DO NOT store the original data
-        const hologram = holoSphere.createHologram(testHolon, testLens, data);
-        await holoSphere.put(testHolon, testLens, hologram); // Store the hologram
-        await waitForGun(); // <-- Add delay
-
-        // Get the item - resolution should fail
-        const result = await holoSphere.get(testHolon, testLens, 'get-deleted-target');
-        expect(result).toBeNull();
-    });
-
-    test('updates to original data should be reflected when resolving hologram', async () => { // Rename test description
-        const originalData = { id: 'update-ref', value: 'Version 1' };
-        await holoSphere.put(testHolon, testLens, originalData);
-        await waitForGun(750); // <-- Increased delay
-        const hologram = holoSphere.createHologram(testHolon, testLens, originalData); // Use renamed method
-        await holoSphere.put(testHolon, 'otherLens', hologram); // Store hologram elsewhere
-        await waitForGun(750); // <-- Increased delay
-
-        // Resolve initially
-        const resolved1 = await holoSphere.resolveHologram(hologram); // Use renamed method
-        expect(resolved1).toBeNull(); // Expect null, likely due to put redirection complexities
-        
-        // Update original data
-        const updatedData = { ...originalData, value: 'Version 2' };
-        await holoSphere.put(testHolon, testLens, updatedData);
-        await waitForGun(750);
-
-        // Resolve again
-        const resolved2 = await holoSphere.resolveHologram(hologram); // Use renamed method
-        expect(resolved2).toBeDefined();
-        expect(resolved2.id).toBe('update-ref');
-        expect(resolved2.value).toBe('Version 2'); 
-        expect(resolved2.isHologram).toBeUndefined(); // Ensure top-level isHologram is not present
-        expect(resolved2._meta).toBeDefined();
-        expect(resolved2._meta.resolvedFromHologram).toBe(true);
-        expect(resolved2._meta.hologramSoul).toBe(hologram.soul);
-        expect(resolved2._meta.isHologram).toBeUndefined();
-        expect(resolved2._meta.resolved).toBeUndefined();
-    });
-
-    // --- Tests for _holograms tracking ---
-    test('should add hologram soul to target _holograms set on put', async () => {
-        // 1. Store original data
-        const targetData = { id: 'target-for-tracking', value: 'Track me' };
-        await holoSphere.put(testHolon, testLens, targetData);
-        await waitForGun();
-        const targetSoul = `${appName}/${testHolon}/${testLens}/target-for-tracking`;
-
-        // 2. Store a hologram pointing to the original data
-        const hologramData = holoSphere.createHologram(testHolon, testLens, targetData);
-        const hologramStorage = { id: 'hologram-tracker-1', soul: hologramData.soul };
-        await holoSphere.put(testHolon, 'otherLens', hologramStorage); // Store in different lens
-        await waitForGun(500); // Longer wait for tracking update
-        const storedHologramSoul = `${appName}/${testHolon}/otherLens/hologram-tracker-1`;
-
-        // 3. Get the target node reference and fetch the _holograms set
-        const targetNodeRef = holoSphere.getNodeRef(targetSoul);
-        const hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
-
-        // 4. Verify the _holograms set exists and contains the stored hologram's soul
-        expect(hologramsSet).toBeDefined();
-        // Gun stores set members as keys, excluding metadata '_'
-        const hologramKeys = Object.keys(hologramsSet).filter(k => k !== '_');
-        expect(hologramKeys).toContain(storedHologramSoul);
-        expect(hologramsSet[storedHologramSoul]).toBe(true); // Check the value stored
-    });
-
-    test('should remove hologram soul from target _holograms set on delete', async () => {
-        // 1. Store original data
-        const targetData = { id: 'target-for-delete-tracking', value: 'Untrack me' };
-        await holoSphere.put(testHolon, testLens, targetData);
-        await waitForGun();
-        const targetSoul = `${appName}/${testHolon}/${testLens}/target-for-delete-tracking`;
-
-        // 2. Store a hologram pointing to the original data
-        const hologramData = holoSphere.createHologram(testHolon, testLens, targetData);
-        const hologramStorage = { id: 'hologram-tracker-2', soul: hologramData.soul };
-        await holoSphere.put(testHolon, 'otherLens', hologramStorage); // Store in different lens
-        await waitForGun(500); // Wait for put and tracking update
-        const storedHologramSoul = `${appName}/${testHolon}/otherLens/hologram-tracker-2`;
-
-        // 3. Verify hologram was added to tracking initially
-        const targetNodeRef = holoSphere.getNodeRef(targetSoul);
-        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
-        expect(hologramsSet).toBeDefined();
-        expect(hologramsSet[storedHologramSoul]).toBeDefined(); // Hologram should be tracked initially
-
-        // 4. Delete the hologram
-        await holoSphere.delete(testHolon, 'otherLens', 'hologram-tracker-2');
-        console.log("--- Waiting longer after delete for tracking update ---");
-        await waitForGun(1500); // <-- Increased wait time significantly
-
-        // 5. Fetch the _holograms set again directly
-        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
-
-        // 6. Verify the hologram's soul is completely removed (or set to null by Gun)
-        expect(hologramsSet).toBeDefined();
-        expect(hologramsSet[storedHologramSoul]).toBeNull(); // Gun stores null when we put(null)
-    });
-    // --- End tests for _holograms tracking ---
-
-});