holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/tests/unit/integration/scenario-09-cross-dimensional.test.js

@@ -1,139 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Integration: Scenario 9 - Cross-Dimensional Federation', () => {
-  let hs;
-
-  beforeEach(() => {
-    hs = new HoloSphere({ relays: [], appName: 'scenario-09' });
-  });
-
-  it('should complete cross-dimensional federation workflow', async () => {
-    // Step 1: Create data in geographic holon (San Francisco)
-    const geoHolon = await hs.toHolon(37.7749, -122.4194, 9);
-    await hs.write(geoHolon, 'discussions', {
-      id: 'thread-001',
-      topic: 'Urban Planning',
-      messages: 12
-    });
-
-    // Step 2: Create noospheric holon (concept space)
-    const conceptHolon = 'concept://urbanism/sustainable-cities';
-    await hs.write(conceptHolon, 'discussions', {
-      id: 'thread-002',
-      topic: 'Sustainability Frameworks',
-      messages: 8
-    });
-
-    // Step 3: Federate geographic ↔ noospheric (cross-dimensional link)
-    const fedSuccess = await hs.federate(geoHolon, conceptHolon, 'discussions', {
-      direction: 'bidirectional'
-    });
-    expect(fedSuccess).toBe(true);
-
-    // Step 4: Query geographic holon - includes noospheric federated data
-    const geoDiscussions = await hs.getFederatedData(geoHolon, 'discussions');
-    expect(Array.isArray(geoDiscussions)).toBe(true);
-    expect(geoDiscussions.length).toBeGreaterThanOrEqual(2);
-
-    const hasLocal = geoDiscussions.some(d => d.id === 'thread-001');
-    const hasFederated = geoDiscussions.some(d => d.id === 'thread-002');
-    expect(hasLocal).toBe(true);
-    expect(hasFederated).toBe(true);
-
-    // Step 5: Query noospheric holon - includes geographic federated data
-    const conceptDiscussions = await hs.getFederatedData(conceptHolon, 'discussions');
-    expect(Array.isArray(conceptDiscussions)).toBe(true);
-    expect(conceptDiscussions.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('should validate noospheric holons identified by URI/URL', async () => {
-    const noosphericUris = [
-      'nostr://topic/climate',
-      'concept://philosophy/ethics',
-      'ap://community/developers',
-      'https://example.com/topic/blockchain'
-    ];
-
-    for (const uri of noosphericUris) {
-      const success = await hs.write(uri, 'content', {
-        id: 'item-001',
-        text: 'Noospheric content'
-      });
-      expect(success).toBe(true);
-    }
-  });
-
-  it('should validate federation works across geographic and conceptual dimensions', async () => {
-    const geographic = await hs.toHolon(40.7128, -74.0060, 9); // New York
-    const conceptual = 'concept://technology/ai';
-
-    await hs.write(geographic, 'research', {
-      id: 'study-001',
-      title: 'AI in Urban Settings'
-    });
-
-    await hs.write(conceptual, 'research', {
-      id: 'study-002',
-      title: 'Machine Learning Ethics'
-    });
-
-    // Inbound: geographic subscribes to receive data from conceptual
-    const fedSuccess = await hs.federate(geographic, conceptual, 'research', { direction: 'inbound' });
-    expect(fedSuccess).toBe(true);
-
-    // Geographic should see conceptual data (inbound federation)
-    const geoData = await hs.getFederatedData(geographic, 'research');
-    expect(geoData.some(d => d.id === 'study-002')).toBe(true);
-  });
-
-  it('should validate bidirectional cross-dimensional linking', async () => {
-    const geo = await hs.toHolon(37.7749, -122.4194, 9);
-    const concept = 'concept://sustainability/green-energy';
-
-    await hs.write(geo, 'projects', { id: 'proj-001', name: 'Solar Panels' });
-    await hs.write(concept, 'projects', { id: 'proj-002', name: 'Wind Farms' });
-
-    await hs.federate(geo, concept, 'projects', { direction: 'bidirectional' });
-
-    // Both directions should work
-    const geoProjects = await hs.getFederatedData(geo, 'projects');
-    const conceptProjects = await hs.getFederatedData(concept, 'projects');
-
-    expect(geoProjects.some(p => p.id === 'proj-002')).toBe(true);
-    expect(conceptProjects.some(p => p.id === 'proj-001')).toBe(true);
-  });
-
-  it('should validate unified query interface for both dimensions', async () => {
-    const geographic = await hs.toHolon(37.7749, -122.4194, 9);
-    const noospheric = 'nostr://topic/javascript';
-
-    // Same API for both dimensions
-    await hs.write(geographic, 'posts', { id: 'post-1', text: 'Geo post' });
-    await hs.write(noospheric, 'posts', { id: 'post-2', text: 'Noo post' });
-
-    const geoData = await hs.read(geographic, 'posts');
-    const nooData = await hs.read(noospheric, 'posts');
-
-    expect(Array.isArray(geoData)).toBe(true);
-    expect(Array.isArray(nooData)).toBe(true);
-  });
-
-  it('should validate cross-dimensional navigation enabled', async () => {
-    const sanFrancisco = await hs.toHolon(37.7749, -122.4194, 9);
-    const techConcept = 'concept://technology/web3';
-    const socialProtocol = 'nostr://topic/decentralization';
-
-    // Create triangle of federations
-    await hs.write(sanFrancisco, 'ideas', { id: 'idea-1', source: 'geo' });
-    await hs.write(techConcept, 'ideas', { id: 'idea-2', source: 'concept' });
-    await hs.write(socialProtocol, 'ideas', { id: 'idea-3', source: 'social' });
-
-    await hs.federate(sanFrancisco, techConcept, 'ideas');
-    await hs.federate(techConcept, socialProtocol, 'ideas');
-
-    // Navigation across dimensions should work
-    const sfIdeas = await hs.getFederatedData(sanFrancisco, 'ideas');
-    expect(sfIdeas.length).toBeGreaterThanOrEqual(2);
-  });
-});

package/tests/unit/integration/scenario-10-cross-holosphere-capabilities.test.js

@@ -1,357 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Integration: Scenario 10 - Cross-Holosphere Capability Tokens', () => {
-  // Two distinct private keys for two separate holospheres
-  const privateKeyA = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-  const privateKeyB = 'fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210';
-
-  let holosphereA;
-  let holosphereB;
-  let publicKeyA;
-  let publicKeyB;
-  let testHolon;
-
-  beforeEach(async () => {
-    // Create two independent holospheres with different private keys
-    holosphereA = new HoloSphere({
-      relays: [],
-      appName: 'scenario-10-a',
-      privateKey: privateKeyA,
-      logLevel: 'ERROR'
-    });
-
-    holosphereB = new HoloSphere({
-      relays: [],
-      appName: 'scenario-10-b',
-      privateKey: privateKeyB,
-      logLevel: 'ERROR'
-    });
-
-    // Get public keys
-    publicKeyA = holosphereA.client.publicKey;
-    publicKeyB = holosphereB.client.publicKey;
-
-    // Create a test holon (H3 cell)
-    testHolon = await holosphereA.toHolon(37.7749, -122.4194, 9);
-  });
-
-  afterEach(async () => {
-    // Clean up any subscriptions or connections
-    if (holosphereA && holosphereA.client) {
-      await holosphereA.client.close?.();
-    }
-    if (holosphereB && holosphereB.client) {
-      await holosphereB.client.close?.();
-    }
-  });
-
-  it('should have different public keys for different private keys', () => {
-    expect(publicKeyA).toBeDefined();
-    expect(publicKeyB).toBeDefined();
-    expect(publicKeyA).not.toBe(publicKeyB);
-  });
-
-  it('should NOT allow holosphere B to see data written by holosphere A without capability', async () => {
-    // Step 1: Holosphere A writes private data
-    const secretData = {
-      id: 'secret-001',
-      content: 'This is private data from Holosphere A',
-      _creator: publicKeyA
-    };
-
-    await holosphereA.write(testHolon, 'private-docs', secretData);
-
-    // Step 2: Verify holosphere A can read its own data
-    const dataFromA = await holosphereA.read(testHolon, 'private-docs', 'secret-001');
-    expect(dataFromA).toBeDefined();
-    expect(dataFromA.content).toBe('This is private data from Holosphere A');
-
-    // Step 3: Holosphere B tries to read the same data
-    // Since they use different appNames and no federation, B should NOT see A's data
-    const dataFromB = await holosphereB.read(testHolon, 'private-docs', 'secret-001');
-
-    // B should not be able to see A's data (different namespace/holosphere)
-    expect(dataFromB).toBeNull();
-  });
-
-  it('should allow access after capability token is granted', async () => {
-    // Step 1: Holosphere A writes data
-    const sharedData = {
-      id: 'shared-001',
-      content: 'This data will be shared via capability token',
-      _creator: publicKeyA
-    };
-
-    await holosphereA.write(testHolon, 'shared-docs', sharedData);
-
-    // Step 2: Verify initial state - B cannot see data
-    const initialReadByB = await holosphereB.read(testHolon, 'shared-docs', 'shared-001');
-    expect(initialReadByB).toBeNull();
-
-    // Step 3: Holosphere A issues a READ capability token to Holosphere B
-    const readCapabilityToken = await holosphereA.issueCapability(
-      ['read'],
-      { holonId: testHolon, lensName: 'shared-docs' },
-      publicKeyB,
-      {
-        expiresIn: 3600000, // 1 hour
-        issuerKey: privateKeyA
-      }
-    );
-
-    expect(typeof readCapabilityToken).toBe('string');
-
-    // Step 4: Verify the capability token is valid
-    const isValidToken = await holosphereA.verifyCapability(
-      readCapabilityToken,
-      'read',
-      { holonId: testHolon, lensName: 'shared-docs' }
-    );
-    expect(isValidToken).toBe(true);
-
-    // Step 5: Holosphere B can now verify the token
-    const bCanVerify = await holosphereB.verifyCapability(
-      readCapabilityToken,
-      'read',
-      { holonId: testHolon, lensName: 'shared-docs' }
-    );
-    expect(bCanVerify).toBe(true);
-  });
-
-  it('should allow write access with write capability token', async () => {
-    // Step 1: Holosphere A creates initial data
-    await holosphereA.write(testHolon, 'collaborative', {
-      id: 'collab-001',
-      content: 'Initial content by A',
-      _creator: publicKeyA
-    });
-
-    // Step 2: Holosphere A issues WRITE capability token to B
-    const writeCapabilityToken = await holosphereA.issueCapability(
-      ['write', 'read'],
-      { holonId: testHolon, lensName: 'collaborative' },
-      publicKeyB,
-      {
-        expiresIn: 3600000,
-        issuerKey: privateKeyA
-      }
-    );
-
-    // Step 3: Verify B has write permission with the token
-    const hasWritePermission = await holosphereB.verifyCapability(
-      writeCapabilityToken,
-      'write',
-      { holonId: testHolon, lensName: 'collaborative' }
-    );
-    expect(hasWritePermission).toBe(true);
-
-    // Step 4: B writes new data using the capability token
-    await holosphereB.write(testHolon, 'collaborative', {
-      id: 'collab-002',
-      content: 'Content added by B with capability',
-      _creator: publicKeyB
-    }, { capability: writeCapabilityToken });
-
-    // Step 5: A can verify B's contribution was written
-    const bContribution = await holosphereB.read(testHolon, 'collaborative', 'collab-002');
-    expect(bContribution).toBeDefined();
-    expect(bContribution.content).toBe('Content added by B with capability');
-  });
-
-  it('should reject operations when capability token does not include required permission', async () => {
-    // Step 1: A writes data
-    await holosphereA.write(testHolon, 'restricted', {
-      id: 'restricted-001',
-      content: 'Restricted data',
-      _creator: publicKeyA
-    });
-
-    // Step 2: A issues READ-ONLY capability token to B
-    const readOnlyToken = await holosphereA.issueCapability(
-      ['read'], // Only read, no write or delete
-      { holonId: testHolon, lensName: 'restricted' },
-      publicKeyB,
-      {
-        expiresIn: 3600000,
-        issuerKey: privateKeyA
-      }
-    );
-
-    // Step 3: Verify B has read but NOT write permission
-    const hasRead = await holosphereB.verifyCapability(
-      readOnlyToken,
-      'read',
-      { holonId: testHolon, lensName: 'restricted' }
-    );
-    expect(hasRead).toBe(true);
-
-    const hasWrite = await holosphereB.verifyCapability(
-      readOnlyToken,
-      'write',
-      { holonId: testHolon, lensName: 'restricted' }
-    );
-    expect(hasWrite).toBe(false);
-
-    const hasDelete = await holosphereB.verifyCapability(
-      readOnlyToken,
-      'delete',
-      { holonId: testHolon, lensName: 'restricted' }
-    );
-    expect(hasDelete).toBe(false);
-  });
-
-  it('should reject capability tokens for wrong scope (different lens)', async () => {
-    // Issue token for 'documents' lens
-    const documentsToken = await holosphereA.issueCapability(
-      ['read', 'write', 'delete'],
-      { holonId: testHolon, lensName: 'documents' },
-      publicKeyB,
-      {
-        expiresIn: 3600000,
-        issuerKey: privateKeyA
-      }
-    );
-
-    // Token should be valid for 'documents' lens
-    const validForDocuments = await holosphereB.verifyCapability(
-      documentsToken,
-      'read',
-      { holonId: testHolon, lensName: 'documents' }
-    );
-    expect(validForDocuments).toBe(true);
-
-    // Token should be INVALID for 'photos' lens
-    const validForPhotos = await holosphereB.verifyCapability(
-      documentsToken,
-      'read',
-      { holonId: testHolon, lensName: 'photos' }
-    );
-    expect(validForPhotos).toBe(false);
-  });
-
-  it('should reject expired capability tokens', async () => {
-    // Issue a token that is already expired
-    const expiredToken = await holosphereA.issueCapability(
-      ['read', 'write'],
-      { holonId: testHolon, lensName: 'expired-test' },
-      publicKeyB,
-      {
-        expiresIn: -1000, // Already expired
-        issuerKey: privateKeyA
-      }
-    );
-
-    // Expired token should not be valid
-    const isValid = await holosphereB.verifyCapability(
-      expiredToken,
-      'read',
-      { holonId: testHolon, lensName: 'expired-test' }
-    );
-    expect(isValid).toBe(false);
-  });
-
-  it('should allow delete access with delete capability token', async () => {
-    // Step 1: A creates data
-    await holosphereA.write(testHolon, 'deletable', {
-      id: 'to-delete-001',
-      content: 'This will be deleted by B',
-      _creator: publicKeyA
-    });
-
-    // Step 2: Verify data exists
-    const exists = await holosphereA.read(testHolon, 'deletable', 'to-delete-001');
-    expect(exists).toBeDefined();
-
-    // Step 3: B tries to delete without token - should fail
-    try {
-      await holosphereB.delete(testHolon, 'deletable', 'to-delete-001');
-      // If we reach here, the test should fail
-      expect(true).toBe(false);
-    } catch (err) {
-      // Expected: authorization error or no access
-      expect(err).toBeDefined();
-    }
-
-    // Step 4: A issues DELETE capability token to B
-    const deleteToken = await holosphereA.issueCapability(
-      ['delete'],
-      { holonId: testHolon, lensName: 'deletable' },
-      publicKeyB,
-      {
-        expiresIn: 3600000,
-        issuerKey: privateKeyA
-      }
-    );
-
-    // Step 5: Verify B has delete permission
-    const hasDeletePermission = await holosphereB.verifyCapability(
-      deleteToken,
-      'delete',
-      { holonId: testHolon, lensName: 'deletable' }
-    );
-    expect(hasDeletePermission).toBe(true);
-  });
-
-  it('complete workflow: isolation -> capability grant -> access', async () => {
-    // === PHASE 1: ISOLATION ===
-    // A writes confidential data
-    const confidentialData = {
-      id: 'confidential-001',
-      title: 'Secret Project',
-      content: 'Top secret information only for authorized users',
-      _creator: publicKeyA
-    };
-
-    await holosphereA.write(testHolon, 'projects', confidentialData);
-
-    // A can see their own data
-    const aCanSee = await holosphereA.read(testHolon, 'projects', 'confidential-001');
-    expect(aCanSee).toBeDefined();
-    expect(aCanSee.title).toBe('Secret Project');
-
-    // B cannot see A's data (isolated)
-    const bCannotSee = await holosphereB.read(testHolon, 'projects', 'confidential-001');
-    expect(bCannotSee).toBeNull();
-
-    // === PHASE 2: CAPABILITY GRANT ===
-    // A decides to grant B read access via public key
-    const capabilityToken = await holosphereA.issueCapability(
-      ['read'],
-      { holonId: testHolon, lensName: 'projects' },
-      publicKeyB, // Grant to B's public key
-      {
-        expiresIn: 7200000, // 2 hours
-        issuerKey: privateKeyA
-      }
-    );
-
-    expect(capabilityToken).toBeDefined();
-    expect(typeof capabilityToken).toBe('string');
-
-    // === PHASE 3: VERIFIED ACCESS ===
-    // B can now verify they have read access
-    const bHasReadAccess = await holosphereB.verifyCapability(
-      capabilityToken,
-      'read',
-      { holonId: testHolon, lensName: 'projects' }
-    );
-    expect(bHasReadAccess).toBe(true);
-
-    // B still cannot write (only read permission was granted)
-    const bHasWriteAccess = await holosphereB.verifyCapability(
-      capabilityToken,
-      'write',
-      { holonId: testHolon, lensName: 'projects' }
-    );
-    expect(bHasWriteAccess).toBe(false);
-
-    // Token is properly scoped - cannot access other lenses
-    const bHasAccessToOtherLens = await holosphereB.verifyCapability(
-      capabilityToken,
-      'read',
-      { holonId: testHolon, lensName: 'other-lens' }
-    );
-    expect(bHasAccessToOtherLens).toBe(false);
-  });
-});