holosphere 1.1.6 → 1.1.7

package/examples/environmentalData.js

@@ -0,0 +1,380 @@
+import HoloSphere from '../holosphere.js';
+import * as environmentalApi from '../services/environmentalApi.js';
+import * as h3 from 'h3-js';
+
+/**
+ * Example script demonstrating how to save environmental data to HoloSphere
+ * This creates a structured dataset that can be federated across different holons
+ */
+async function storeEnvironmentalData() {
+  // Initialize HoloSphere
+  const holosphere = new HoloSphere('environmental-data', true);
+  
+  try {
+    // Define schemas for different environmental data types
+    await setupSchemas(holosphere);
+    
+    // Example coordinates (Rome, Italy)
+    const lat = 41.9;
+    const lon = 12.5;
+    const countryCode = 'ITA';
+    
+    // Get the H3 index for this location at different resolutions
+    const cityHolon = await holosphere.getHolon(lat, lon, 7);    // City level
+    const regionHolon = await holosphere.getHolon(lat, lon, 5);  // Region level
+    const countryHolon = await holosphere.getHolon(lat, lon, 3); // Country level
+    
+    console.log(`Processing data for holons:
+      - City: ${cityHolon}
+      - Region: ${regionHolon}
+      - Country: ${countryHolon}`);
+    
+    // Set up federation between different levels
+    await holosphere.federate(cityHolon, regionHolon);
+    await holosphere.federate(regionHolon, countryHolon);
+    
+    // Fetch environmental data
+    console.log('Fetching environmental data...');
+    
+    // Air quality data (city level)
+    let airQualityRecord;
+    const airQualityData = await environmentalApi.getAirQuality(lat, lon);
+    if (airQualityData) {
+      airQualityRecord = transformAirQualityData(airQualityData, cityHolon);
+      await holosphere.put(cityHolon, 'air-quality', airQualityRecord);
+      console.log('Stored air quality data in city holon');
+    }
+    
+    // Carbon sequestration data (region level)
+    const carbonData = await environmentalApi.getCarbonSequestration(lat, lon);
+    if (carbonData) {
+      const carbonRecord = transformCarbonData(carbonData, regionHolon);
+      await holosphere.put(regionHolon, 'carbon-sequestration', carbonRecord);
+      console.log('Stored carbon sequestration data in region holon');
+    }
+    
+    // Soil carbon data (region level)
+    const soilCarbonData = await environmentalApi.getSoilCarbon(lat, lon);
+    if (soilCarbonData) {
+      const soilCarbonRecord = transformSoilCarbonData(soilCarbonData, regionHolon);
+      await holosphere.put(regionHolon, 'soil-data', soilCarbonRecord);
+      console.log('Stored soil carbon data in region holon');
+    }
+    
+    // Biodiversity data (country level)
+    const biodiversityData = await environmentalApi.getBiodiversityData(countryCode);
+    if (biodiversityData) {
+      const biodiversityRecord = transformBiodiversityData(biodiversityData, countryHolon);
+      await holosphere.put(countryHolon, 'biodiversity', biodiversityRecord);
+      console.log('Stored biodiversity data in country holon');
+    }
+    
+    // Define and add the environmental metrics schema
+    const metricsSchema = {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        holon: { type: 'string' },
+        timestamp: { type: 'number' },
+        metrics: {
+          type: 'object',
+          properties: {
+            airQualityIndex: { type: 'number' },
+            carbonSequestration: { type: 'number' },
+            soilCarbon: { type: 'number' },
+            biodiversityCount: { type: 'number' }
+          }
+        }
+      },
+      required: ['id', 'holon', 'timestamp', 'metrics']
+    };
+    await holosphere.setSchema('environmental-metrics', metricsSchema);
+    console.log('Set schema for environmental metrics');
+    
+    // Create initial empty metrics object
+    const metricsRecord = {
+      id: `env-metrics-${Date.now()}`,
+      holon: countryHolon,
+      timestamp: Date.now(),
+      metrics: {
+        airQualityIndex: 0,
+        carbonSequestration: 0,
+        soilCarbon: 0,
+        biodiversityCount: 0
+      }
+    };
+    await holosphere.put(countryHolon, 'environmental-metrics', metricsRecord);
+    console.log('Added initial environmental metrics record');
+    
+    // Propagate data to create federation references
+    console.log('Setting up data federation...');
+    
+    // Propagate air quality data up to region
+    if (airQualityRecord) {
+      await holosphere.propagate(cityHolon, 'air-quality', airQualityRecord, {
+        targetSpaces: [regionHolon]
+      });
+      console.log('Propagated air quality data to region holon');
+    }
+    
+    // Aggregate environmental metrics at country level - manual approach since compute has issues
+    console.log('Manually updating environmental metrics...');
+    try {
+      // Get data from various sources
+      const airData = airQualityRecord || { airQualityIndex: 0 };
+      const carbonData = await holosphere.get(regionHolon, 'carbon-sequestration');
+      const soilData = await holosphere.get(regionHolon, 'soil-data');
+      const bioData = await holosphere.get(countryHolon, 'biodiversity');
+      
+      // Update metrics manually
+      const updatedMetrics = {
+        id: metricsRecord.id,
+        holon: countryHolon,
+        timestamp: Date.now(),
+        metrics: {
+          airQualityIndex: airData.airQualityIndex || 0,
+          carbonSequestration: carbonData?.carbonSequestration || 0,
+          soilCarbon: soilData?.soilCarbon || 0,
+          biodiversityCount: bioData?.biodiversityCount || 0
+        }
+      };
+      
+      await holosphere.put(countryHolon, 'environmental-metrics', updatedMetrics);
+      console.log('Updated environmental metrics at country level:', updatedMetrics);
+    } catch (updateError) {
+      console.error('Error updating environmental metrics:', updateError);
+    }
+    
+    // Get and display the metrics directly instead of using getFederated
+    console.log('Retrieving environmental metrics...');
+    try {
+      const environmentalMetrics = await holosphere.get(countryHolon, 'environmental-metrics');
+      console.log('Environmental metrics:', environmentalMetrics);
+    } catch (getError) {
+      console.error('Error retrieving metrics:', getError);
+    }
+    
+  } catch (error) {
+    console.error('Error storing environmental data:', error);
+  } finally {
+    // Close HoloSphere instance
+    await holosphere.close();
+    console.log('HoloSphere instance closed successfully');
+  }
+}
+
+/**
+ * Set up schemas for environmental data
+ */
+async function setupSchemas(holosphere) {
+  // Air quality schema
+  const airQualitySchema = {
+    type: 'object',
+    properties: {
+      id: { type: 'string' },
+      holon: { type: 'string' },
+      timestamp: { type: 'number' },
+      coordinates: { 
+        type: 'object',
+        properties: {
+          lat: { type: 'number' },
+          lon: { type: 'number' }
+        }
+      },
+      airQualityIndex: { type: 'number' },
+      pollutants: {
+        type: 'object',
+        properties: {
+          co: { type: 'number' },
+          no2: { type: 'number' },
+          o3: { type: 'number' },
+          pm2_5: { type: 'number' },
+          pm10: { type: 'number' },
+          so2: { type: 'number' }
+        }
+      }
+    },
+    required: ['id', 'holon', 'timestamp', 'coordinates', 'airQualityIndex']
+  };
+  
+  // Carbon sequestration schema
+  const carbonSchema = {
+    type: 'object',
+    properties: {
+      id: { type: 'string' },
+      holon: { type: 'string' },
+      timestamp: { type: 'number' },
+      coordinates: { 
+        type: 'object',
+        properties: {
+          lat: { type: 'number' },
+          lon: { type: 'number' }
+        }
+      },
+      carbonSequestration: { type: 'number' },
+      temperature: { type: 'number' },
+      precipitation: { type: 'number' }
+    },
+    required: ['id', 'holon', 'timestamp', 'coordinates', 'carbonSequestration']
+  };
+  
+  // Soil carbon schema
+  const soilSchema = {
+    type: 'object',
+    properties: {
+      id: { type: 'string' },
+      holon: { type: 'string' },
+      timestamp: { type: 'number' },
+      coordinates: { 
+        type: 'object',
+        properties: {
+          lat: { type: 'number' },
+          lon: { type: 'number' }
+        }
+      },
+      soilCarbon: { type: 'number' },
+      soilType: { type: 'string' },
+      soilDepth: { type: 'string' }
+    },
+    required: ['id', 'holon', 'timestamp', 'coordinates', 'soilCarbon']
+  };
+  
+  // Biodiversity schema
+  const biodiversitySchema = {
+    type: 'object',
+    properties: {
+      id: { type: 'string' },
+      holon: { type: 'string' },
+      timestamp: { type: 'number' },
+      countryCode: { type: 'string' },
+      biodiversityCount: { type: 'number' },
+      species: { 
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            scientificName: { type: 'string' },
+            count: { type: 'number' }
+          }
+        }
+      }
+    },
+    required: ['id', 'holon', 'timestamp', 'countryCode', 'biodiversityCount']
+  };
+  
+  // Set schemas
+  await holosphere.setSchema('air-quality', airQualitySchema);
+  await holosphere.setSchema('carbon-sequestration', carbonSchema);
+  await holosphere.setSchema('soil-data', soilSchema);
+  await holosphere.setSchema('biodiversity', biodiversitySchema);
+  
+  console.log('Environmental data schemas set up successfully');
+}
+
+/**
+ * Transform air quality data from API into our schema
+ */
+function transformAirQualityData(apiData, holon) {
+  const components = apiData.list?.[0]?.components || {};
+  const main = apiData.list?.[0]?.main || {};
+  
+  return {
+    id: `air-quality-${Date.now()}`,
+    holon: holon,
+    timestamp: Date.now(),
+    coordinates: {
+      lat: apiData.coord?.lat || 0,
+      lon: apiData.coord?.lon || 0
+    },
+    airQualityIndex: main.aqi || 0,
+    pollutants: {
+      co: components.co || 0,
+      no2: components.no2 || 0,
+      o3: components.o3 || 0,
+      pm2_5: components.pm2_5 || 0,
+      pm10: components.pm10 || 0,
+      so2: components.so2 || 0
+    }
+  };
+}
+
+/**
+ * Transform carbon sequestration data from API into our schema
+ */
+function transformCarbonData(apiData, holon) {
+  const parameters = apiData.properties?.parameter || {};
+  const temperature = parameters.T2M?.['20230701'] || 0;
+  const precipitation = parameters.PRECTOT?.['20230701'] || 0;
+  
+  // Calculate a simplified carbon sequestration estimate
+  // (In a real app, use actual models based on temperature, precipitation, etc.)
+  const carbonSequestration = (temperature * 0.5) + (precipitation * 2);
+  
+  return {
+    id: `carbon-seq-${Date.now()}`,
+    holon: holon,
+    timestamp: Date.now(),
+    coordinates: {
+      lat: apiData.geometry?.coordinates[1] || 0,
+      lon: apiData.geometry?.coordinates[0] || 0
+    },
+    carbonSequestration: carbonSequestration,
+    temperature: temperature,
+    precipitation: precipitation
+  };
+}
+
+/**
+ * Transform soil carbon data from API into our schema
+ */
+function transformSoilCarbonData(apiData, holon) {
+  const properties = apiData.properties || {};
+  const soilCarbon = properties.soilGrids?.properties?.soc?.mean || 0;
+  
+  return {
+    id: `soil-carbon-${Date.now()}`,
+    holon: holon,
+    timestamp: Date.now(),
+    coordinates: {
+      lat: apiData.geometry?.coordinates[1] || 0,
+      lon: apiData.geometry?.coordinates[0] || 0
+    },
+    soilCarbon: soilCarbon,
+    soilType: properties.soilType || 'Unknown',
+    soilDepth: '0-30cm'
+  };
+}
+
+/**
+ * Transform biodiversity data from API into our schema
+ */
+function transformBiodiversityData(apiData, holon) {
+  const results = apiData.results || [];
+  const species = {};
+  
+  // Count species occurrences
+  results.forEach(occurrence => {
+    const name = occurrence.scientificName || 'Unknown';
+    species[name] = (species[name] || 0) + 1;
+  });
+  
+  // Convert to array format
+  const speciesArray = Object.keys(species).map(name => ({
+    scientificName: name,
+    count: species[name]
+  }));
+  
+  return {
+    id: `biodiversity-${Date.now()}`,
+    holon: holon,
+    timestamp: Date.now(),
+    countryCode: results[0]?.countryCode || 'Unknown',
+    biodiversityCount: results.length,
+    species: speciesArray
+  };
+}
+
+// Execute the example
+storeEnvironmentalData()
+  .then(() => console.log('Environmental data example completed'))
+  .catch(error => console.error('Error in environmental data example:', error)); 

package/examples/federation.js

@@ -0,0 +1,154 @@
+/**
+ * Organization Federation Example for HoloSphere
+ * 
+ * This example demonstrates a real-world use case where a tech team creates tasks
+ * that are federated to the parent organization for visibility.
+ */
+
+import HoloSphere from './holosphere.js';
+
+async function organizationFederationExample() {
+  const holoSphere = new HoloSphere('organization-example');
+  
+  try {
+    console.log('Starting Organization Federation Example...');
+    
+    // Define our spaces/holons
+    const orgHolon = 'acme-organization';
+    const techTeamHolon = 'acme-tech-team';
+    
+    // Step 1: Create federation relationship between tech team and organization
+    console.log('\nStep 1: Creating federation relationship...');
+    
+    await holoSphere.federate(techTeamHolon, orgHolon);
+    console.log('Federation created between tech team and organization');
+    
+    // Step 2: Set up bidirectional notification settings (critical!)
+    console.log('\nStep 2: Setting up bidirectional notification...');
+    
+    // First set up tech team to notify organization
+    const techTeamFedSettings = await holoSphere.getGlobal('federation', techTeamHolon);
+    if (techTeamFedSettings) {
+      techTeamFedSettings.notify = techTeamFedSettings.notify || [];
+      if (!techTeamFedSettings.notify.includes(orgHolon)) {
+        techTeamFedSettings.notify.push(orgHolon);
+        await holoSphere.putGlobal('federation', techTeamFedSettings);
+        console.log('Tech team set to notify organization');
+      }
+    }
+    
+    // Then set up organization to notify tech team (if needed)
+    const orgFedSettings = await holoSphere.getGlobal('federation', orgHolon);
+    if (orgFedSettings) {
+      orgFedSettings.notify = orgFedSettings.notify || [];
+      if (!orgFedSettings.notify.includes(techTeamHolon)) {
+        orgFedSettings.notify.push(techTeamHolon);
+        await holoSphere.putGlobal('federation', orgFedSettings);
+        console.log('Organization set to notify tech team');
+      }
+    }
+    
+    // Step 3: Verify federation is set up properly
+    console.log('\nStep 3: Verifying federation setup...');
+    
+    const techTeamFedInfo = await holoSphere.getFederation(techTeamHolon);
+    console.log('Tech team federation info:', techTeamFedInfo);
+    
+    // Step 4: Create a task in the tech team holon
+    console.log('\nStep 4: Creating a task in the tech team holon...');
+    
+    const task = {
+      id: 'task-123',
+      title: 'Implement new authentication system',
+      description: 'Replace the current auth system with OAuth2',
+      assignee: 'dev@example.com',
+      status: 'in_progress',
+      priority: 'high',
+      dueDate: '2023-12-31',
+      createdAt: new Date().toISOString(),
+      tags: ['security', 'infrastructure']
+    };
+    
+    // Store the task in the tech team holon
+    await holoSphere.put(techTeamHolon, 'tasks', task);
+    console.log('Task created in tech team holon:', task.id);
+    
+    // Step 5: Propagate the task to the organization holon
+    console.log('\nStep 5: Propagating task to organization holon...');
+    
+    await holoSphere.propagate(techTeamHolon, 'tasks', task);
+    console.log('Task propagated to organization holon');
+    
+    // Step 6: Allow time for propagation
+    console.log('\nStep 6: Waiting for propagation to complete...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Step 7: Verify task in both holons
+    console.log('\nStep 7: Verifying task is in both holons...');
+    
+    // Check tech team holon directly
+    const techTeamTask = await holoSphere.get(techTeamHolon, 'tasks', 'task-123');
+    console.log('Task in tech team holon:', techTeamTask ? 'Found' : 'Not found');
+    if (techTeamTask) console.log('Tech team task status:', techTeamTask.status);
+    
+    // Check organization holon directly
+    const orgTask = await holoSphere.get(orgHolon, 'tasks', 'task-123');
+    console.log('Task in organization holon:', orgTask ? 'Found' : 'Not found');
+    if (orgTask) {
+      console.log('Organization task status:', orgTask.status);
+      console.log('Federation metadata:', orgTask.federation);
+    }
+    
+    // Step 8: Use getFederated to view all tasks across holons
+    console.log('\nStep 8: Using getFederated to view all tasks...');
+    
+    const allOrgTasks = await holoSphere.getFederated(orgHolon, 'tasks');
+    console.log(`Organization holon has access to ${allOrgTasks.length} tasks`);
+    
+    const allTechTasks = await holoSphere.getFederated(techTeamHolon, 'tasks');
+    console.log(`Tech team holon has access to ${allTechTasks.length} tasks`);
+    
+    // Step 9: Update the task in tech team and propagate the change
+    console.log('\nStep 9: Updating task in tech team holon...');
+    
+    const updatedTask = {
+      ...task,
+      status: 'completed',
+      completedAt: new Date().toISOString()
+    };
+    
+    await holoSphere.put(techTeamHolon, 'tasks', updatedTask);
+    await holoSphere.propagate(techTeamHolon, 'tasks', updatedTask);
+    console.log('Task updated and propagated');
+    
+    // Step 10: Allow time for propagation
+    console.log('\nStep 10: Waiting for propagation to complete...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Step 11: Verify updates in both holons
+    console.log('\nStep 11: Verifying updated task in both holons...');
+    
+    const updatedTechTeamTask = await holoSphere.get(techTeamHolon, 'tasks', 'task-123');
+    console.log('Updated task in tech team holon status:', updatedTechTeamTask?.status);
+    
+    const updatedOrgTask = await holoSphere.get(orgHolon, 'tasks', 'task-123');
+    console.log('Updated task in organization holon status:', updatedOrgTask?.status);
+    
+    // Step 12: Clean up - remove federation
+    console.log('\nStep 12: Cleaning up - removing federation...');
+    
+    await holoSphere.unfederate(techTeamHolon, orgHolon);
+    console.log('Federation removed between tech team and organization');
+    
+    console.log('\nOrganization federation example completed successfully!');
+  } catch (error) {
+    console.error('Error in organization federation example:', error);
+  } finally {
+    // Always close the HoloSphere instance
+    await holoSphere.close();
+    console.log('HoloSphere instance closed');
+  }
+}
+
+// Run the example
+organizationFederationExample().catch(console.error); 

package/examples/queryEnvironmentalData.js

@@ -0,0 +1,147 @@
+import HoloSphere from '../holosphere.js';
+import * as h3 from 'h3-js';
+
+/**
+ * Example demonstrating how to query environmental data from HoloSphere
+ * This shows how to access data across federated holons at different scales
+ */
+async function queryEnvironmentalData() {
+  // Initialize HoloSphere with the same appname used to store the data
+  const holosphere = new HoloSphere('environmental-data');
+  
+  try {
+    // Example coordinates (Rome, Italy)
+    const lat = 41.9;
+    const lon = 12.5;
+    
+    // Get the holons at different resolutions
+    const cityHolon = await holosphere.getHolon(lat, lon, 7);  // City level
+    const regionHolon = await holosphere.getHolon(lat, lon, 5); // Region level
+    const countryHolon = await holosphere.getHolon(lat, lon, 3); // Country level
+    
+    console.log(`Querying environmental data for location (${lat}, ${lon})`);
+    console.log(`  - City: ${cityHolon}`);
+    console.log(`  - Region: ${regionHolon}`);
+    console.log(`  - Country: ${countryHolon}`);
+    
+    // Query 1: Get air quality data from the city level
+    console.log('\n=== CITY LEVEL: Air Quality Data ===');
+    const airQualityData = await holosphere.getAll(cityHolon, 'air-quality');
+    if (airQualityData.length > 0) {
+      const latest = airQualityData.sort((a, b) => b.timestamp - a.timestamp)[0];
+      console.log(`Latest Air Quality Index: ${latest.airQualityIndex}`);
+      console.log('Pollutant levels:');
+      Object.entries(latest.pollutants).forEach(([pollutant, value]) => {
+        console.log(`  - ${pollutant}: ${value}`);
+      });
+    } else {
+      console.log('No air quality data available for this location');
+    }
+    
+    // Query 2: Use federation to get soil data referenced at the region level
+    console.log('\n=== REGION LEVEL: Soil Carbon Data ===');
+    const soilData = await holosphere.getAll(regionHolon, 'soil-data');
+    if (soilData.length > 0) {
+      const latest = soilData.sort((a, b) => b.timestamp - a.timestamp)[0];
+      console.log(`Soil Carbon: ${latest.soilCarbon} g/kg`);
+      console.log(`Soil Type: ${latest.soilType}`);
+      console.log(`Soil Depth: ${latest.soilDepth}`);
+    } else {
+      console.log('No soil data available for this region');
+    }
+    
+    // Query 3: Get carbon sequestration data at region level
+    console.log('\n=== REGION LEVEL: Carbon Sequestration ===');
+    const carbonData = await holosphere.getAll(regionHolon, 'carbon-sequestration');
+    if (carbonData.length > 0) {
+      const latest = carbonData.sort((a, b) => b.timestamp - a.timestamp)[0];
+      console.log(`Carbon Sequestration: ${latest.carbonSequestration} tons/hectare/year`);
+      console.log(`Temperature: ${latest.temperature}°C`);
+      console.log(`Precipitation: ${latest.precipitation} mm`);
+    } else {
+      console.log('No carbon sequestration data available for this region');
+    }
+    
+    // Query 4: Get biodiversity data at country level
+    console.log('\n=== COUNTRY LEVEL: Biodiversity ===');
+    const biodiversityData = await holosphere.getAll(countryHolon, 'biodiversity');
+    if (biodiversityData.length > 0) {
+      const latest = biodiversityData.sort((a, b) => b.timestamp - a.timestamp)[0];
+      console.log(`Biodiversity Count: ${latest.biodiversityCount} species`);
+      console.log(`Country Code: ${latest.countryCode}`);
+      console.log(`Top 5 Species:`);
+      
+      // Sort species by count and show top 5
+      const topSpecies = latest.species.sort((a, b) => b.count - a.count).slice(0, 5);
+      topSpecies.forEach((species, index) => {
+        console.log(`  ${index + 1}. ${species.scientificName}: ${species.count} occurrences`);
+      });
+    } else {
+      console.log('No biodiversity data available for this country');
+    }
+    
+    // Query 5: Get federated data across all levels
+    console.log('\n=== FEDERATED DATA: Environmental Metrics ===');
+    const federatedData = await holosphere.getFederated(countryHolon, 'environmental-metrics', {
+      resolveReferences: true,
+      aggregate: true,
+      idField: 'id'
+    });
+    
+    if (federatedData.length > 0) {
+      console.log('Aggregated Environmental Metrics:');
+      federatedData.forEach(data => {
+        if (data.metrics) {
+          Object.entries(data.metrics).forEach(([metric, value]) => {
+            console.log(`  - ${metric}: ${value}`);
+          });
+        } else {
+          console.log('No metrics available in federated data');
+        }
+      });
+    } else {
+      console.log('No federated environmental metrics available');
+    }
+    
+    // Query 6: Get references to air quality data from the region level
+    // This demonstrates accessing data via federation references
+    console.log('\n=== FEDERATION REFERENCES: Air Quality Data from Region ===');
+    const airQualityRefs = await holosphere.getAll(regionHolon, 'air-quality');
+    if (airQualityRefs.length > 0) {
+      console.log(`Found ${airQualityRefs.length} air quality references in region`);
+      
+      // Get the first reference and resolve it
+      const ref = airQualityRefs[0];
+      console.log('Reference details:');
+      
+      if (ref.soul) {
+        console.log(`  - Soul path: ${ref.soul}`);
+        
+        // Resolve reference manually to show the process
+        const resolvedData = await holosphere.getNodeBySoul(ref.soul);
+        if (resolvedData) {
+          console.log('Successfully resolved reference to original air quality data:');
+          console.log(`  - Air Quality Index: ${resolvedData.airQualityIndex}`);
+          console.log(`  - Source Holon: ${resolvedData.holon}`);
+        } else {
+          console.log('Could not resolve reference - original data not found');
+        }
+      } else {
+        console.log('Not a soul reference:', ref);
+      }
+    } else {
+      console.log('No air quality references found at region level');
+    }
+    
+  } catch (error) {
+    console.error('Error querying environmental data:', error);
+  } finally {
+    // Always close the HoloSphere instance
+    await holosphere.close();
+  }
+}
+
+// Execute the example
+queryEnvironmentalData()
+  .then(() => console.log('\nEnvironmental data query example completed'))
+  .catch(error => console.error('Error in environmental data query example:', error));