diff --git a/src/PersonalWebSpace_backend/main.mo b/src/PersonalWebSpace_backend/main.mo
index 4a46978..3a33b99 100644
--- a/src/PersonalWebSpace_backend/main.mo
+++ b/src/PersonalWebSpace_backend/main.mo
@@ -24,7 +24,6 @@ import HTTP "./Http";
 
 import Stoic "./EXT/Stoic";
 
-import Protocol "./Protocol";
 import Testable "mo:matchers/Testable";
 import Blob "mo:base/Blob";
 import Hash "mo:base/Hash";
diff --git a/src/PersonalWebSpace_frontend/assets/DownloadFileExample.html b/src/PersonalWebSpace_frontend/assets/DownloadFileExample.html
index a7cf5f5..db583e2 100644
--- a/src/PersonalWebSpace_frontend/assets/DownloadFileExample.html
+++ b/src/PersonalWebSpace_frontend/assets/DownloadFileExample.html
@@ -7,7 +7,7 @@
   <body>
 
 
-    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
+    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="width: 1920; height: 1080;" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
       <a-assets>
         <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
         <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
diff --git a/src/PersonalWebSpace_frontend/assets/defaultRoom.html b/src/PersonalWebSpace_frontend/assets/defaultRoom.html
index a819c9a..2d66cc7 100644
--- a/src/PersonalWebSpace_frontend/assets/defaultRoom.html
+++ b/src/PersonalWebSpace_frontend/assets/defaultRoom.html
@@ -7,7 +7,7 @@
   <body>
 
 
-    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
+    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="width: 1920; height: 1080;" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
       <a-assets>
         <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
         <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
diff --git a/src/PersonalWebSpace_frontend/assets/defaultRoom_InternetIsland.html b/src/PersonalWebSpace_frontend/assets/defaultRoom_InternetIsland.html
index e66a785..af0635f 100644
--- a/src/PersonalWebSpace_frontend/assets/defaultRoom_InternetIsland.html
+++ b/src/PersonalWebSpace_frontend/assets/defaultRoom_InternetIsland.html
@@ -6,7 +6,7 @@
   </head>
   <body>
 
-    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
+    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="width: 1920; height: 1080;" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
       <a-assets>
         <a-asset-item id="island-glb" src="tropical_island_modified.glb"></a-asset-item> <!-- Credits: "Tropical Island" (https://skfb.ly/6THzW) by Elin is licensed under Creative Commons Attribution (http://creativecommons.org/licenses/by/4.0/). -->
         <a-asset-item id="sunbed-glb" src="at_a_beach_modified.glb"></a-asset-item> <!-- Credits:"At a beach" (https://skfb.ly/6SUss) by barcin is licensed under Creative Commons Attribution (http://creativecommons.org/licenses/by/4.0/). -->
diff --git a/src/PersonalWebSpace_frontend/assets/defaultRoom_NatureRetreat.html b/src/PersonalWebSpace_frontend/assets/defaultRoom_NatureRetreat.html
index 668f8e9..db37c08 100644
--- a/src/PersonalWebSpace_frontend/assets/defaultRoom_NatureRetreat.html
+++ b/src/PersonalWebSpace_frontend/assets/defaultRoom_NatureRetreat.html
@@ -6,7 +6,7 @@
   </head>
   <body>
 
-    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
+    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="width: 1920; height: 1080;" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
       <a-assets>
         <a-asset-item id="ground-glb" src="ground.glb"></a-asset-item>
         <a-asset-item id="single_bed-glb" src="single_bed.glb"></a-asset-item>
diff --git a/src/PersonalWebSpace_frontend/assets/defaultRoom_Web3Cockpit.html b/src/PersonalWebSpace_frontend/assets/defaultRoom_Web3Cockpit.html
index 415615f..a611690 100644
--- a/src/PersonalWebSpace_frontend/assets/defaultRoom_Web3Cockpit.html
+++ b/src/PersonalWebSpace_frontend/assets/defaultRoom_Web3Cockpit.html
@@ -6,7 +6,7 @@
   </head>
   <body>
 
-    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true" >
+    <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="width: 1920; height: 1080;" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true" >
       <a-assets>
         <a-asset-item id="ground-glb" src="ground.glb"></a-asset-item>
         <a-asset-item id="spaceshuttle-glb" src="discovery_space_shuttle.glb"></a-asset-item> <!-- Credits: "Discovery Space Shuttle" (https://skfb.ly/6R6Iu) by rsatenza is licensed under Creative Commons Attribution (http://creativecommons.org/licenses/by/4.0/). -->
diff --git a/src/PersonalWebSpace_frontend/components/GlbModelPreview.svelte b/src/PersonalWebSpace_frontend/components/GlbModelPreview.svelte
index 9d0d555..b1a2656 100644
--- a/src/PersonalWebSpace_frontend/components/GlbModelPreview.svelte
+++ b/src/PersonalWebSpace_frontend/components/GlbModelPreview.svelte
@@ -11,7 +11,7 @@
     : getStringForSpaceFromUserUploadedModel();
 </script>
 <div class="glb-model-space-preview space-y-1">
-  <iframe srcdoc={glbModelPreviewString} title="Preview of the Glb Model" width="100%" height="auto" class="py-2"></iframe>
+  <iframe id={modelUrl} srcdoc={glbModelPreviewString} title="Preview of the Glb Model" width="100%" height="auto" class="py-2"></iframe>
 </div>
 
 <style>
diff --git a/src/PersonalWebSpace_frontend/components/MediaContentPreview.svelte b/src/PersonalWebSpace_frontend/components/MediaContentPreview.svelte
index c284ccb..c85352a 100644
--- a/src/PersonalWebSpace_frontend/components/MediaContentPreview.svelte
+++ b/src/PersonalWebSpace_frontend/components/MediaContentPreview.svelte
@@ -36,7 +36,7 @@
 
 </script>
 <div class="media-content-space-preview space-y-1">
-  <iframe srcdoc={mediaContentPreviewString} title="Preview of the File's Content" width="100%" height="auto" class="py-2"></iframe>
+  <iframe id={contentUrl} srcdoc={mediaContentPreviewString} title="Preview of the File's Content" width="100%" height="auto" class="py-2"></iframe>
 </div>
 
 <style>
diff --git a/src/PersonalWebSpace_frontend/components/ProtocolEntity.svelte b/src/PersonalWebSpace_frontend/components/ProtocolEntity.svelte
index d170e97..0e22737 100644
--- a/src/PersonalWebSpace_frontend/components/ProtocolEntity.svelte
+++ b/src/PersonalWebSpace_frontend/components/ProtocolEntity.svelte
@@ -1,13 +1,32 @@
 <script lang="ts">
-  import type { Entity } from "src/integrations/BebbProtocol/bebb.did";
+  import type { BebbEntity } from "../helpers/bebb_utils";
 
-  export let entity : Entity;
+  export let entity : BebbEntity;
   export let viewerIsSpaceOwner: Boolean = false;
   export let deleteSpaceNeighborFunction; // Function passed to delete the link between the Space and the Neighbor
 
 // Helper functions to check whether the Entity has got a valid URL that can be displayed
+  let extractedEntityUrl;
+  const extractUrlFromEntity = (entity) => {
+    try {
+      // Parse the entitySpecificFields as JSON
+      const fields = JSON.parse(entity.entitySpecificFields);
+      // Extract the externalId which contains the URL
+      const url = fields.externalId;
+      return url;
+    } catch (error) {
+      console.error("Error extracting URL: ", error);
+      return null; // or handle the error as needed
+    }
+  };
+
   const entityHasValidUrl = () => {
-    return isValidUrl(entity.entitySpecificFields);
+    extractedEntityUrl = extractUrlFromEntity(entity);
+    if (extractedEntityUrl) {
+      return isValidUrl(extractedEntityUrl);
+    } else {
+      return false;
+    };
   };
 
   const isValidUrl = (url) => {
@@ -46,10 +65,10 @@
 
 {#if entityHasValidUrl()}
   <div class="space-neighbor-preview space-y-1">
-    <a target="_blank" rel="noreferrer" href={entity.entitySpecificFields} >
-      <iframe src={entity.entitySpecificFields} title="Entity Preview" width="100%" height="auto" referrerpolicy="no-referrer" sandbox="allow-scripts allow-same-origin"></iframe>
+    <a target="_blank" rel="noreferrer" href={extractedEntityUrl} >
+      <iframe src={extractedEntityUrl} title="Entity Preview" width="100%" height="auto" referrerpolicy="no-referrer" sandbox="allow-scripts allow-same-origin"></iframe>
     </a>
-    <button on:click={() => window.open(entity.entitySpecificFields,'_blank')} class="active-app-button bg-slate-500 text-white py-2 px-4 rounded font-semibold">Visit Neighbor</button>
+    <button on:click={() => window.open(extractedEntityUrl,'_blank')} class="active-app-button bg-slate-500 text-white py-2 px-4 rounded font-semibold">Visit Neighbor</button>
     {#if viewerIsSpaceOwner}
       {#if linkDeletionInProgress}
         <button disabled class="bg-slate-500 text-white py-2 px-4 rounded font-bold opacity-50 cursor-not-allowed">Deleting...</button>
@@ -66,7 +85,7 @@
     {/if}
     <button type="button" class="space-details-collapsible bg-slate-500 text-white py-2 px-4 rounded font-semibold">See Details</button>
     <div class="space-details-content">
-      <p>Address: {entity.entitySpecificFields}</p>
+      <p>Address: {extractedEntityUrl}</p>
       <p>Owner: {entity.owner}</p>
     </div>
   </div>
diff --git a/src/PersonalWebSpace_frontend/components/SpaceNeighbors.svelte b/src/PersonalWebSpace_frontend/components/SpaceNeighbors.svelte
index 5bd7d55..af3c478 100644
--- a/src/PersonalWebSpace_frontend/components/SpaceNeighbors.svelte
+++ b/src/PersonalWebSpace_frontend/components/SpaceNeighbors.svelte
@@ -1,6 +1,21 @@
 <script lang="ts">
-    import type { Principal } from "@dfinity/principal";
-    import type { EntityInitiationObject, BridgeInitiationObject, EntityAttachedBridgesResult, EntityAttachedBridges, Bridge, Entity } from "src/integrations/BebbProtocol/bebb.did";
+    import type {
+        BebbBridge,
+        BebbBridgeInitiationObject,
+        BebbEntity,
+        BebbEntityInitiationObject,
+        BebbEntityPreview,
+        BebbEntityUpdateObject,
+    } from "../helpers/bebb_utils";
+    import {
+        createBebbEntityAndBridge,
+        getBebbBridgesBetweenEntities,
+        deleteBebbBridgesByOwner,
+        getConnectedEntitiesInBebb,
+        getBebbEntityUrlPreview,
+        getBebbEntityImagePreviewFromIframe,
+        updateBebbEntity,
+    } from "../helpers/bebb_utils";
     import { onMount } from "svelte";
     import ProtocolEntity from "./ProtocolEntity.svelte";
     import UserSpaces from "./UserSpaces.svelte";
@@ -70,40 +85,79 @@
         const spaceEntityId = extractSpaceEntityId();
         if (neighborUrlInputHandler(newNeighborUrl) && spaceEntityId) {
             // Create Neighbor connection as Bridge from Space in Bebb Protocol
-            const externalId : [string] = [newNeighborUrl];
-            const entityInitiationObject : EntityInitiationObject= {
+            const spaceUrl = newNeighborUrl.replace(/\/+$/, ""); // strip any trailing slashes
+            const entitySpecificFields = {
+                externalId: spaceUrl,
+            };
+
+            const entityPreviews : Array<BebbEntityPreview> = [];    
+            try {
+                const urlSpacePreview : BebbEntityPreview = await getBebbEntityUrlPreview(spaceUrl);
+                entityPreviews.push(urlSpacePreview);
+            } catch (error) {
+                console.error("Error creating url preview for space: ", error);
+            };
+            const entityInitiationObject : BebbEntityInitiationObject = {
                 settings: [],
                 entityType: { 'Resource' : { 'Web' : null } },
                 name: [],
                 description: [`Created as a Space Neighbor in the Open Internet Metaverse at https://${PersonalWebSpace_frontend_canister_id}${appDomain}/`] as [string],
                 keywords: [["Space Neighbor", "Open Internet Metaverse", "Virtual Neighborhood"]] as [Array<string>],
-                entitySpecificFields: externalId,
+                entitySpecificFields: [JSON.stringify(entitySpecificFields)] as [string],
+                previews: [entityPreviews] as [Array<BebbEntityPreview>],
             };
 
-            const bridgeEntityInitiationObject : BridgeInitiationObject = {
+            const bridgePresentationMetadata = {
+                framework: "A-Frame",
+                environment: "Open Internet Metaverse",
+                type: "Virtual Neighbor",
+                data: {
+                    width: 1.2,
+                    height: 2,
+                },
+            };
+            const bridgeSpecificFields = {
+                presentationMetadata: bridgePresentationMetadata,
+            };
+            const bridgeEntityInitiationObject : BebbBridgeInitiationObject = {
                 settings: [],
                 name: [],
                 description: [`Created to connect two Spaces as Neighbors in the Open Internet Metaverse at https://${PersonalWebSpace_frontend_canister_id}${appDomain}/`] as [string],
                 keywords: [["Space Neighbors", "Open Internet Metaverse", "Virtual Neighborhood"]] as [Array<string>],
-                entitySpecificFields: [],
+                entitySpecificFields: [JSON.stringify(bridgeSpecificFields)],
                 bridgeType: { 'IsRelatedto' : null },
                 fromEntityId: spaceEntityId,
                 toEntityId: "",
             };
             try {
-                const createEntityResponse = await $store.protocolActor.create_entity(entityInitiationObject);
-                // @ts-ignore
-                if (createEntityResponse && createEntityResponse.Ok) {
-                    // @ts-ignore
-                    const newNeighborEntityId = createEntityResponse.Ok;
-                    bridgeEntityInitiationObject.toEntityId = newNeighborEntityId;
-                    const createBridgeResponse = await $store.protocolActor.create_bridge(bridgeEntityInitiationObject);
-                    // @ts-ignore
-                    if (createBridgeResponse && createBridgeResponse.Ok) {
-                        successfullyAddedNeighbor = true;
-                    } else {
-                        errorAddingNeighbor = true;
+                const createBebbEntityAndBridgeResponse = await createBebbEntityAndBridge(entityInitiationObject, bridgeEntityInitiationObject);
+                if (createBebbEntityAndBridgeResponse) {
+                    if (createBebbEntityAndBridgeResponse.newEntityCreated) { // The Entity did not exist already and it's thus fine to update the previews
+                        // Add image preview to Entity (if a new Entity was created)
+                        // TODO: this doesn't work for external Web resources but only iframes that contain A-Frame scenes (i.e. other spaces)
+                        if (newNeighborUrl) {
+                            try {
+                                const iframeSrc = newNeighborUrl;
+                                const iframeSelector = `iframe[src='${iframeSrc}']`;
+                                const iframeElement = document.querySelector(iframeSelector);
+                                const imageSpacePreview : BebbEntityPreview = await getBebbEntityImagePreviewFromIframe(iframeElement);
+                                entityPreviews.push(imageSpacePreview);
+                                const bebbEntityUpdateObject : BebbEntityUpdateObject = {
+                                    'id' : createBebbEntityAndBridgeResponse.entityId,
+                                    'previews' : [entityPreviews] as [Array<BebbEntityPreview>],
+                                    // don't update other fields (thus leave empty)
+                                    'name' : [],
+                                    'description' : [],
+                                    'keywords' : [],
+                                    'settings' : [],
+                                };
+                                const updateBebbEntityResponse = await updateBebbEntity(bebbEntityUpdateObject); 
+                            } catch (error) {
+                                console.error("Error creating image preview for space: ", error);
+                            };
+                        };
                     };
+                    successfullyAddedNeighbor = true;
                 } else {
                     errorAddingNeighbor = true;
                 };
@@ -127,69 +181,30 @@
         neighborCreationInProgress = false;
     };
 
-// Helper function to find Bridge(s) between Space and a Neighbor
-    const getBridgesBetweenEntities = async (spaceEntityId, neighborProtocolEntityId, bothBridgingDirections = false, includePendingBridges = false) : Promise<Bridge[]> => {
-        if (neighborProtocolEntityId && spaceEntityId) {
-            let getBridgesResponse : EntityAttachedBridgesResult;
-            try {
-                getBridgesResponse = await $store.protocolActor.get_from_bridge_ids_by_entity_id(spaceEntityId);
-            } catch (error) {
-                console.error("Error Getting Bridges", error);
-                return null;                
-            };
-            // @ts-ignore
-            if (getBridgesResponse && getBridgesResponse.Ok && getBridgesResponse.Ok.length > 0) {
-                // Filter for Bridges to Neighbor
-                // @ts-ignore
-                const bridgesRetrieved : EntityAttachedBridges = getBridgesResponse.Ok;
-                let getBridgeRequestPromises = [];
-                for (var i = 0; i < bridgesRetrieved.length; i++) {
-                    if (bridgesRetrieved[i] && bridgesRetrieved[i].id) {
-                        getBridgeRequestPromises.push($store.protocolActor.get_bridge(bridgesRetrieved[i].id)); // Send requests in parallel and then await all to speed up
-                    };
-                };
-                const getBridgeResponses = await Promise.all(getBridgeRequestPromises);
-                const bridgesBetweenEntities : Bridge[] = [];
-                for (var j = 0; j < getBridgeResponses.length; j++) {
-                    if (getBridgeResponses[j].Err) {
-                        console.error("Error retrieving Bridge", getBridgeResponses[j].Err);
-                    } else {
-                        const bridge : Bridge = getBridgeResponses[j].Ok;
-                        if (bridge && bridge.id && bridge.toEntityId === neighborProtocolEntityId) {
-                            bridgesBetweenEntities.push(bridge);
-                        };
-                    };
-                };
-                return bridgesBetweenEntities;
-            };
-        };
-        return null;
-    };
-
 // Owner clicked to delete a Neighbor
     // neighborProtocolEntityId: internal id in Bebb Protocol of the Neighbor to be deleted
     const deleteSpaceNeighbor = async (neighborProtocolEntityId) => {
         const spaceEntityId = extractSpaceEntityId();
         if (neighborProtocolEntityId && spaceEntityId && isViewerSpaceOwner()) {
             // Find id of Bridge between Space's and Neighbor's Entities in Bebb Protocol (note: there might be multiple)
-            const findBridgesResponse : Bridge[] = await getBridgesBetweenEntities(spaceEntityId, neighborProtocolEntityId);
+            let findBridgesResponse : BebbBridge[];
+            try {
+                findBridgesResponse = await getBebbBridgesBetweenEntities(spaceEntityId, neighborProtocolEntityId);
+            } catch (error) {
+                console.error("Error Getting Bridges ", error);                
+                return null;                
+            };
+            
             if (findBridgesResponse && findBridgesResponse.length > 0) {
-                // Delete Bridge(s) in Bebb Protocol owned by Space owner
-                let requestPromises = [];
-                for (var i = 0; i < findBridgesResponse.length; i++) {
-                    const bridgeId = findBridgesResponse[i].id;
-                    if (bridgeId && findBridgesResponse[i].owner?.toText() === spaceNft.owner?.toText()) {
-                        requestPromises.push($store.protocolActor.delete_bridge(bridgeId)); // Send requests in parallel and then await all to speed up
+                try {
+                    const deleteBebbBridgesByOwnerResponse = await deleteBebbBridgesByOwner(findBridgesResponse, spaceNft.owner?.toText());
+                    if (deleteBebbBridgesByOwnerResponse) {
+                        return true;
                     };
+                } catch (error) {
+                    console.error("Error deleting Space Neighbor ", error);                
+                    return null;                
                 };
-                const deletionResponses = await Promise.all(requestPromises);
-                for (var j = 0; j < deletionResponses.length; j++) {
-                    if (deletionResponses[j].Err) {
-                        console.error("Error deleting Space Neighbor", deletionResponses[j].Err);
-                        return null;
-                    };
-                };
-                return true;
             };
         };
         return null;
@@ -228,49 +243,15 @@
 
     const loadSpaceNeighbors = async () => {
         const spaceEntityId = extractSpaceEntityId();
-        let spaceNeighborsResponse : EntityAttachedBridgesResult;
-        let retrievedNeighborEntities : Entity[] = [];
+        let retrievedNeighborEntities : BebbEntity[] = [];
         try {
-            try {
-                spaceNeighborsResponse = await $store.protocolActor.get_from_bridge_ids_by_entity_id(spaceEntityId);
-            } catch (error) {
-                console.error("Error Getting Bridges", error);
-                return null;                
-            };
-            // @ts-ignore
-            if (spaceNeighborsResponse && spaceNeighborsResponse.Ok && spaceNeighborsResponse.Ok.length > 0) {
-                // @ts-ignore
-                const bridgesRetrieved : EntityAttachedBridges = spaceNeighborsResponse.Ok;
-                const bridgeIds = [];
-                let getBridgeRequestPromises = [];
-                for (var i = 0; i < bridgesRetrieved.length; i++) {
-                    if (bridgesRetrieved[i] && bridgesRetrieved[i].id && bridgesRetrieved[i].linkStatus.hasOwnProperty('CreatedOwner')) {
-                        bridgeIds.push(bridgesRetrieved[i].id);
-                        getBridgeRequestPromises.push($store.protocolActor.get_bridge(bridgesRetrieved[i].id)); // Send requests in parallel and then await all to speed up
-                    };
-                };
-                const getBridgeResponses = await Promise.all(getBridgeRequestPromises);
-                let getConnectedEntityRequestPromises = [];
-                for (var j = 0; j < getBridgeResponses.length; j++) {
-                    if (getBridgeResponses[j].Err) {
-                        console.error("Error retrieving Bridge", getBridgeResponses[j].Err);
-                    } else {
-                        const bridge : Bridge = getBridgeResponses[j].Ok;
-                        getConnectedEntityRequestPromises.push($store.protocolActor.get_entity(bridge.toEntityId)); // Send requests in parallel and then await all to speed up
-                    };
-                };
-                const getConnectedEntityResponses = await Promise.all(getConnectedEntityRequestPromises);
-                for (var j = 0; j < getConnectedEntityResponses.length; j++) {
-                    if (getConnectedEntityResponses[j].Err) {
-                        console.error("Error retrieving connected Entity", getConnectedEntityResponses[j].Err);
-                    } else {
-                        const connectedEntity : Entity = getConnectedEntityResponses[j].Ok;
-                        retrievedNeighborEntities.push(connectedEntity);
-                    };
-                };
+            const getConnectedEntitiesResponse = await getConnectedEntitiesInBebb(spaceEntityId, "from", {OwnerCreated: true});
+        for (var j = 0; j < getConnectedEntitiesResponse.length; j++) {
+                const connectedEntity : BebbEntity = getConnectedEntitiesResponse[j];
+                retrievedNeighborEntities.push(connectedEntity);
             };
         } catch(err) {
-            console.error("Error getting SpaceNeighbors", err);
+            console.error("Error getting SpaceNeighbors ", err);
             neighborsLoadingError = true;
         };
         loadingInProgress = false;
diff --git a/src/PersonalWebSpace_frontend/components/UserSpace.svelte b/src/PersonalWebSpace_frontend/components/UserSpace.svelte
index 35883b1..bbf633d 100644
--- a/src/PersonalWebSpace_frontend/components/UserSpace.svelte
+++ b/src/PersonalWebSpace_frontend/components/UserSpace.svelte
@@ -1,5 +1,10 @@
 <script lang="ts">
-  import type { BridgeInitiationObject } from "src/integrations/BebbProtocol/bebb.did";
+  import type {
+    BebbBridgeInitiationObject,
+  } from "../helpers/bebb_utils";
+  import {
+    createBebbBridge,
+  } from "../helpers/bebb_utils";
   import { canisterId as PersonalWebSpace_frontend_canister_id } from "canisters/PersonalWebSpace_frontend";
   import { onMount } from "svelte";
 
@@ -45,24 +50,36 @@
     const spaceEntityId = extractSpaceEntityId();
     if (entityIdToLinkTo !== "" && spaceEntityId) {
       // Create link as Bridge from Space in Bebb Protocol
-      const bridgeEntityInitiationObject : BridgeInitiationObject = {
+      const bridgePresentationMetadata = {
+        framework: "A-Frame",
+        environment: "Open Internet Metaverse",
+        type: "Virtual Neighbor",
+        data: {
+          width: 1.2,
+          height: 2,
+        },
+      };
+      const entitySpecificFields = {
+        presentationMetadata: bridgePresentationMetadata,
+      };
+      const bridgeEntityInitiationObject : BebbBridgeInitiationObject = {
         settings: [],
         name: [],
         description: [`Created to connect two Spaces as Neighbors in the Open Internet Metaverse at https://${PersonalWebSpace_frontend_canister_id}${appDomain}/`] as [string],
         keywords: [["Space Neighbors", "Open Internet Metaverse", "Virtual Neighborhood"]] as [Array<string>],
-        entitySpecificFields: [],
+        entitySpecificFields: [JSON.stringify(entitySpecificFields)],
         bridgeType: { 'IsRelatedto' : null },
         fromEntityId: spaceEntityId,
         toEntityId: entityIdToLinkTo,
       };
       try {
-          const createBridgeResponse = await $store.protocolActor.create_bridge(bridgeEntityInitiationObject);
-          // @ts-ignore
-          if (createBridgeResponse && createBridgeResponse.Ok) {
-            successfullyCreatedLink = true;
-          } else {
-            errorCreatingLink = true;
-          };
+        const createBridgeResponse = await createBebbBridge(bridgeEntityInitiationObject);
+        // @ts-ignore
+        if (createBridgeResponse) {
+          successfullyCreatedLink = true;
+        } else {
+          errorCreatingLink = true;
+        };
       } catch(err) {
         console.error("Link Space err", err);
         errorCreatingLink = true;
diff --git a/src/PersonalWebSpace_frontend/helpers/bebb_utils.ts b/src/PersonalWebSpace_frontend/helpers/bebb_utils.ts
new file mode 100644
index 0000000..bbdf781
--- /dev/null
+++ b/src/PersonalWebSpace_frontend/helpers/bebb_utils.ts
@@ -0,0 +1,536 @@
+import html2canvas from "html2canvas";
+import { store } from "../store";
+
+import type {
+  EntityInitiationObject,
+  BridgeInitiationObject,
+  EntityAttachedBridgesResult,
+  EntityAttachedBridges,
+  EntityAttachedBridge,
+  Bridge,
+  Entity,
+  EntityPreview,
+  EntityFilterCriterion,
+  EntityUpdateObject,
+} from "src/integrations/BebbProtocol/bebb.did";
+
+export type BebbEntity = Entity;
+export type BebbEntityInitiationObject = EntityInitiationObject;
+export type BebbBridgeInitiationObject = BridgeInitiationObject;
+export type BebbEntityAttachedBridgesResult = EntityAttachedBridgesResult;
+export type BebbEntityAttachedBridges = EntityAttachedBridges;
+export type BebbEntityAttachedBridge = EntityAttachedBridge;
+export type BebbBridge = Bridge;
+export type BebbEntityAndBridge = { entity: BebbEntity, bridge: BebbBridge };
+export type BebbEntityPreview = EntityPreview;
+export type BebbEntityFilterCriterion = EntityFilterCriterion;
+export type BebbEntityUpdateObject = EntityUpdateObject;
+
+let appStore;
+store.subscribe((value) => appStore = value);
+
+export async function createBebbEntity(entityInitiationObject: BebbEntityInitiationObject) {
+  if (!appStore) {
+    throw new Error("Error in createBebbEntity: store not initialized");
+  };
+  const createEntityResponse = await appStore.protocolActor.create_entity(entityInitiationObject);
+  // @ts-ignore
+  if (createEntityResponse && createEntityResponse.Ok) {
+    return createEntityResponse.Ok;
+  } else {
+    throw new Error("Error creating new Entity");   
+  };
+};
+
+export async function updateBebbEntity(entityUpdateObject: BebbEntityUpdateObject) {
+  if (!appStore) {
+    throw new Error("Error in updateBebbEntity: store not initialized");
+  };
+  const updateEntityResponse = await appStore.protocolActor.update_entity(entityUpdateObject);
+  // @ts-ignore
+  if (updateEntityResponse && updateEntityResponse.Ok) {
+    return updateEntityResponse.Ok;
+  } else {
+    throw new Error("Error updating Entity");   
+  };
+};
+
+export async function createBebbBridge(bridgeEntityInitiationObject: BebbBridgeInitiationObject) {
+  if (!appStore) {
+    throw new Error("Error in createBebbBridge: store not initialized");
+  };
+  const createBridgeResponse = await appStore.protocolActor.create_bridge(bridgeEntityInitiationObject);
+  // @ts-ignore
+  if (createBridgeResponse && createBridgeResponse.Ok) {
+    return createBridgeResponse.Ok;
+  } else {
+    throw new Error("Error creating new Bridge");
+  };
+};
+
+// TODO: updateBebbBridge
+
+export async function createBebbEntityIfNonExistent(entityInitiationObject: BebbEntityInitiationObject) {
+  if (!appStore) {
+    throw new Error("Error in createBebbEntityIfNonExistent: store not initialized");
+  };
+  
+  // Check that Entity doesn't already exist in Bebb
+  const entitySpecificFields = JSON.parse(entityInitiationObject.entitySpecificFields[0]);
+  const filterCriteria : BebbEntityFilterCriterion[] = [{
+    criterionKey: "externalId",
+    criterionValue: entitySpecificFields.externalId,
+  }];
+  
+  const matchResult = await appStore.protocolActor.match_entities(filterCriteria);
+
+  // Check if any Entities matched the filter criteria
+  if (matchResult && matchResult.Ok && matchResult.Ok.length > 0) {
+    // Assuming the first matched Entity is the correct one (and there are no duplicates)
+    return {
+      entityId: matchResult.Ok[0].id, // Return the id of the existing Entity
+      newEntityCreated: false,
+    };
+  };
+
+  // Entity does not exist, so create it
+  return {
+    entityId: await createBebbEntity(entityInitiationObject),
+    newEntityCreated: true,
+  };
+}
+
+
+export async function createBebbEntityAndBridge(entityInitiationObject: BebbEntityInitiationObject, bridgeEntityInitiationObject: BebbBridgeInitiationObject) {
+  if (!appStore) {
+    throw new Error("Error in createBebbEntityAndBridge: store not initialized");
+  };
+  const createEntityResponse = await createBebbEntityIfNonExistent(entityInitiationObject);
+  // @ts-ignore
+  if (createEntityResponse) {
+    // @ts-ignore
+    const newNeighborEntityId = createEntityResponse.entityId;
+    if (!bridgeEntityInitiationObject.toEntityId || bridgeEntityInitiationObject.toEntityId === "") {
+      bridgeEntityInitiationObject.toEntityId = newNeighborEntityId;
+    } else {
+      bridgeEntityInitiationObject.fromEntityId = newNeighborEntityId;
+    };
+    const createBridgeResponse = await createBebbBridge(bridgeEntityInitiationObject);
+    // @ts-ignore
+    if (createBridgeResponse) {
+      return {
+        entityId: newNeighborEntityId,
+        bridgeId: createBridgeResponse,
+        newEntityCreated: createEntityResponse.newEntityCreated,
+      };
+    } else {
+      throw new Error("Error creating new Bridge");
+    };
+  } else {
+    throw new Error("Error creating new Entity");   
+  };
+};
+
+// Helper function to find Bridge(s) between Space and a Neighbor
+export const getBebbBridgesBetweenEntities = async (bebbEntityId: string, connectedBebbEntityId: string, bridgingDirection = "from"): Promise<BebbBridge[]> => {
+  if (!appStore) {
+    throw new Error("Error in getBebbBridgesBetweenEntities: store not initialized");
+  };
+
+  if (!connectedBebbEntityId || !bebbEntityId) {
+    return null;
+  };
+
+  try {
+    const bridges = await getConnectedBridgesForEntityInBebb(bebbEntityId, bridgingDirection);
+
+    // Filter Bridges based on the connected Entity ID and the bridging direction
+    return bridges.filter(bridge => {
+      if (bridgingDirection === "from") {
+        return bridge.toEntityId === connectedBebbEntityId;
+      } else {  // If bridgingDirection is "to"
+        return bridge.fromEntityId === connectedBebbEntityId;
+      }
+    });
+  } catch (error) {
+    console.error("Error in getBebbBridgesBetweenEntities ", error);
+    return null;
+  };
+};
+
+export async function deleteBebbBridgesByOwner(bebbBridges: BebbBridge[], ownerIdentifier: string) {
+  if (!appStore) {
+    throw new Error("Error in deleteBebbBridgesByOwner: store not initialized");
+  };
+  // Delete Bridge(s) in Bebb Protocol owned by Space owner
+  let requestPromises = [];
+  for (var i = 0; i < bebbBridges.length; i++) {
+    const bridgeId = bebbBridges[i].id;
+    if (bridgeId && bebbBridges[i].owner?.toText() === ownerIdentifier) {
+      requestPromises.push(appStore.protocolActor.delete_bridge(bridgeId)); // Send requests in parallel and then await all to speed up
+    };
+  };
+  const deletionResponses = await Promise.all(requestPromises);
+  for (var j = 0; j < deletionResponses.length; j++) {
+    if (deletionResponses[j].Err) {
+      console.error("Error deleting Space Neighbor ", deletionResponses[j].Err);
+      return null;
+    };
+  };
+  return true;
+};
+
+function extractBridgeIds(bridgesRetrieved: BebbEntityAttachedBridges, filters = {}): string[] {
+  var filteredBridges = bridgesRetrieved.filter(bridge => bridge && bridge.id);
+  // @ts-ignore
+  if (filters && filters.OwnerCreated) {
+    filteredBridges = filteredBridges.filter((attachedBridge: BebbEntityAttachedBridge) => attachedBridge.linkStatus.hasOwnProperty('CreatedOwner'));
+  };
+  return filteredBridges.map(bridge => bridge.id);    
+};
+
+export async function getConnectedBridgeIdsForEntityInBebb(bebbEntityId: string, bridgingDirection = "from", filters = {}): Promise<string[]> {
+  if (!appStore) {
+    throw new Error("Error in getConnectedBridgeIdsForEntityInBebb: store not initialized");
+  };
+
+  let bridgeIdsResponse;
+  
+  try {
+    if (bridgingDirection === "from") {
+      bridgeIdsResponse = await appStore.protocolActor.get_from_bridge_ids_by_entity_id(bebbEntityId);
+    } else { // bridgingDirection === "to"
+      bridgeIdsResponse = await appStore.protocolActor.get_to_bridge_ids_by_entity_id(bebbEntityId);
+    };
+
+    if (bridgeIdsResponse && bridgeIdsResponse.Ok && bridgeIdsResponse.Ok.length > 0) {
+      return extractBridgeIds(bridgeIdsResponse.Ok, filters);
+    };    
+  } catch (error) {
+    console.error("Error in getConnectedBridgeIdsForEntityInBebb ", error);
+  };
+  
+  return [];
+};
+
+export async function getBebbBridges(bridgeIds: string[]): Promise<BebbBridge[]> {
+  if (!appStore) {
+    throw new Error("Error in getBridges: store not initialized");
+  };
+
+  let getBridgeRequestPromises = [];
+  for (var i = 0; i < bridgeIds.length; i++) {
+    if (bridgeIds[i]) {
+      getBridgeRequestPromises.push(appStore.protocolActor.get_bridge(bridgeIds[i])); // Send requests in parallel and then await all to speed up
+    };
+  };
+
+  const getBridgeResponses = await Promise.all(getBridgeRequestPromises);
+  let bridges : BebbBridge[] = [];
+  for (var j = 0; j < getBridgeResponses.length; j++) {
+    if (getBridgeResponses[j].Err) {
+      console.error("Error retrieving Bridge", getBridgeResponses[j].Err);
+    } else {
+      const bridge : BebbBridge = getBridgeResponses[j].Ok;
+      bridges.push(bridge);
+    };
+  };
+
+  return bridges;
+};
+
+export async function getConnectedBridgesForEntityInBebb(bebbEntityId: string, bridgingDirection = "from", filters = {}): Promise<BebbBridge[]> {
+  if (!appStore) {
+    throw new Error("Error in getConnectedBridgesForEntityInBebb: store not initialized");
+  };
+  
+  const bridgeIds = await getConnectedBridgeIdsForEntityInBebb(bebbEntityId, bridgingDirection, filters);
+  return getBebbBridges(bridgeIds);
+};
+
+async function getBebbEntities(entityIds: string[]) : Promise<BebbEntity[]> {
+  const getEntityPromises = entityIds.map(id => appStore.protocolActor.get_entity(id));
+  const entityResponses = await Promise.all(getEntityPromises);
+
+  let entities = [];
+  for (let response of entityResponses) {
+    if (response.Err) {
+      console.error("Error retrieving connected Entity", response.Err);
+    } else {
+      const entity : BebbEntity = response.Ok;
+      entities.push(entity);
+    };
+  };
+  return entities;
+};
+
+export async function getConnectedEntitiesInBebb(bebbEntityId: string, bridgingDirection = "from", filters = {}) : Promise<BebbEntity[]> {
+  if (!appStore) {
+    throw new Error("Error in getConnectedEntitiesInBebb: store not initialized");
+  };
+
+  try {
+    const getBridgesResponse = await getConnectedBridgesForEntityInBebb(bebbEntityId, bridgingDirection, filters);
+    const entityIds = getBridgesResponse.map((bridge: BebbBridge) => bridgingDirection === "from" ? bridge.toEntityId : bridge.fromEntityId);
+    const connectedEntities = await getBebbEntities(entityIds);
+    return connectedEntities;
+  } catch (error) {
+    console.error("Error Getting Connected Entities in Bebb ", error);
+    return null;                
+  };
+};
+
+export async function getConnectedEntitiesAndBridgesInBebb(bebbEntityId: string, bridgingDirection = "from", filters = {}) : Promise<BebbEntityAndBridge[]> {
+  if (!appStore) {
+    throw new Error("Error in getConnectedEntitiesAndBridgesInBebb: store not initialized");
+  };
+
+  try {
+    const getBridgesResponse = await getConnectedBridgesForEntityInBebb(bebbEntityId, bridgingDirection, filters);
+    const entityIds = getBridgesResponse.map((bridge: BebbBridge) => bridgingDirection === "from" ? bridge.toEntityId : bridge.fromEntityId);
+    const connectedEntities = await getBebbEntities(entityIds);
+
+    const entitiesAndBridges: BebbEntityAndBridge[] = [];
+
+    for (let bridge of getBridgesResponse) {
+      const entityId = bridgingDirection === "from" ? bridge.toEntityId : bridge.fromEntityId;
+      const entity = connectedEntities.find(e => e.id === entityId);
+      if (entity) {
+        entitiesAndBridges.push({
+          entity: entity,
+          bridge: bridge
+        });
+      }
+    }
+
+    return entitiesAndBridges;
+  } catch (error) {
+    console.error("Error Getting Connected Entities and Bridges in Bebb ", error);
+    return null;                
+  };
+};
+
+export async function getBebbEntityUrlPreview(url: string) : Promise<BebbEntityPreview> {
+  var enc = new TextEncoder(); // always utf-8
+  const urlSpacePreview : BebbEntityPreview = {
+    'previewData': enc.encode(url),
+    'previewType': { 'Other' : "URL" },
+  };
+  return urlSpacePreview;
+};
+
+// Convert the Blob to an ArrayBuffer
+const blobToArrayBuffer = (blob) => {
+  return blob.arrayBuffer();
+};
+
+// Convert the ArrayBuffer to a Uint8Array
+const arrayBufferToUint8Array = (buffer) => {
+  return new Uint8Array(buffer);
+};
+
+// Putting it all together
+const getUint8ArrayFromCanvas = async (canvas) => {
+  try {
+    const blob = await canvasToBlob(canvas);
+    const buffer = await blobToArrayBuffer(blob);
+    const uint8Array = arrayBufferToUint8Array(buffer);
+    return uint8Array; // This is the Uint8Array representation of your canvas
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+};
+
+function displayImageInPopup(screenshotArray) {
+  // Create a Blob from the Uint8Array
+  const blob = new Blob([screenshotArray], { type: 'image/jpeg' });
+
+  // Create an Object URL for the blob
+  const imageUrl = URL.createObjectURL(blob);
+
+  // Open a new popup window
+  const popup = window.open('', 'Image Preview', 'width=600,height=400');
+
+  // Check if the popup was successfully opened
+  if (popup) {
+    // Write the HTML content for the new window
+    popup.document.write(`<html><head><title>Image Preview</title></head><body><img src="${imageUrl}" onload="window.URL.revokeObjectURL('${imageUrl}')" style="max-width:100%;"></body></html>`);
+    
+    // Close the document to apply the content
+    popup.document.close();
+  } else {
+    console.log('Popup blocked or failed to open.');
+  };
+};
+
+async function captureAFrameScene(spaceHtml) : Promise<Uint8Array> {
+  return new Promise(async (resolve, reject) => {
+    // Store the original overflow value
+    const originalOverflow = document.body.style.overflow;
+    // Set overflow to auto
+    document.body.style.overflow = 'auto';
+    // This is disturbing the UI (while it captures the screenshot correctly, adding the element lets the scrollbar disappear, likely due to the errors while loading the A-Frame scene; loading it within a new iframe ensured that there weren't any UI issues but the screenshot wasn't captured correctly)
+    const container = document.createElement('div');
+    container.style.visibility = 'hidden';
+    //container.style.position = 'absolute';
+    container.style.top = '-9999px'; // Move off-screen
+    container.style.left = '-9999px';
+    container.style.zIndex = '-9999';
+    container.style.width = '1px';  // Minimize size
+    container.style.height = '1px';
+    container.innerHTML = spaceHtml;
+    document.body.appendChild(container);
+
+    const sceneEl = container.querySelector('a-scene');
+
+    // Ensure A-Frame scene has loaded
+    // @ts-ignore
+    if (!sceneEl.hasLoaded) {
+      await new Promise(resolve => sceneEl.addEventListener('loaded', resolve));
+    };
+    // Wait until assets have loaded
+    let assetsEl = sceneEl.querySelector('a-assets');
+    await new Promise(resolve =>
+      setTimeout(() => {
+        resolve("");
+      }, 3000)
+    );
+    // @ts-ignore
+    const screenshotCanvas = sceneEl.components.screenshot.getCanvas('perspective');
+    const screenshotArray = await getUint8ArrayFromCanvas(screenshotCanvas);
+    displayImageInPopup(screenshotArray);
+
+    document.body.removeChild(container);
+    // Restore the original overflow value
+    document.body.style.overflow = originalOverflow;
+
+    resolve(screenshotArray);
+  });
+};
+
+export async function getBebbEntityImagePreviewFromAframeHtml(sceneHtml: string) : Promise<BebbEntityPreview> {
+  // @ts-ignore
+  const imageData : Uint8Array = await captureAFrameScene(sceneHtml);
+  const imageSpacePreview : BebbEntityPreview = {
+    'previewData': imageData,
+    'previewType': { 'Jpg' : null },
+  };
+  return imageSpacePreview;
+};
+
+async function captureAFrameSceneFromIframe(iframe) : Promise<Uint8Array> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      // Ensure the iframe's content is fully loaded
+      if (!iframe.contentWindow || !iframe.contentWindow.document) {
+        return reject('Iframe content is not accessible or not fully loaded.');
+      };
+
+      const sceneEl = iframe.contentWindow.document.querySelector('a-scene');
+      // Ensure the A-Frame scene has loaded
+      if (!sceneEl) {
+        return reject('A-Frame scene is not loaded in the iframe.');
+      };
+      // @ts-ignore
+      if (!sceneEl.hasLoaded) {
+        await new Promise(resolve => sceneEl.addEventListener('loaded', resolve));
+      };
+
+      // Use the screenshot component or a similar method to capture the scene
+      // @ts-ignore
+      const screenshotCanvas = sceneEl.components.screenshot.getCanvas('perspective');
+      const screenshotArray = await getUint8ArrayFromCanvas(screenshotCanvas);
+
+      resolve(screenshotArray);
+    } catch (error) {
+      console.error("Error capturing A-Frame scene from iframe: ", error);
+      reject(error);
+    }
+  });
+};
+
+export async function getBebbEntityImagePreviewFromIframe(iframe) : Promise<BebbEntityPreview> {
+  // @ts-ignore
+  const imageData : Uint8Array = await captureAFrameSceneFromIframe(iframe);
+
+  const imageSpacePreview : BebbEntityPreview = {
+    'previewData': imageData,
+    'previewType': { 'Jpg' : null },
+  };
+  return imageSpacePreview;
+};
+
+async function captureImageOfAFrameSceneFromUrl(url: string) : Promise<Uint8Array> {
+  // Currently doesn't work properly as the url has to point to an A-Frame scene and we don't await until the scene is loaded in the iframe
+  return new Promise(async (resolve, reject) => {
+    let iframe = document.createElement('iframe');
+    iframe.src = url;
+    iframe.style.display = "none";
+    document.body.appendChild(iframe);
+
+    iframe.onload = async () => {
+      try {
+        // @ts-ignore
+        let canvas = iframe.contentDocument.querySelector('a-scene').components.screenshot.getCanvas('perspective');
+        const screenshotArray = await getUint8ArrayFromCanvas(canvas);
+        //displayImageInPopup(screenshotArray);
+        resolve(screenshotArray);
+      } catch (err) {
+        console.error("Error capturing image from A-Frame scene: " + err);
+        reject("Error capturing image from A-Frame scene: " + err);
+      };
+    };
+  });
+};
+
+function canvasToBlob(canvas) {
+  return new Promise((resolve) => {
+    canvas.toBlob(resolve);
+  });
+};
+
+async function captureImageOfWebsiteFromUrl(url: string) : Promise<Uint8Array> {
+  return new Promise(async (resolve, reject) => {
+    let iframe = document.createElement('iframe');
+    iframe.src = url;
+    iframe.style.display = "none";
+    document.body.appendChild(iframe);
+
+    iframe.onload = async () => {
+      try {
+        const canvas = await html2canvas(iframe.contentDocument.body);
+        // @ts-ignore
+        let blob : Blob = await canvasToBlob(canvas);
+        let arrayBuffer = await blob.arrayBuffer();
+        document.body.removeChild(iframe);
+        resolve(new Uint8Array(arrayBuffer));
+      } catch (err) {
+        console.error("Error capturing image from website: " + err);
+        reject("Error capturing image from website: " + err);
+      };
+    };
+  });
+};
+
+export async function getBebbEntityImagePreviewFromUrl(url: string) : Promise<BebbEntityPreview> {
+  if (url.includes("/#/space/")) {
+    // OIM Space URL, i.e. A-Frame scene
+    // @ts-ignore
+    const imageData : Uint8Array  = await captureImageOfAFrameSceneFromUrl(url);
+    const imageSpacePreview : BebbEntityPreview = {
+      'previewData': imageData,
+      'previewType': { 'Jpg' : null },
+    };
+    return imageSpacePreview;
+  } else {
+    // External URL
+    // @ts-ignore
+    const imageData : Uint8Array  = await captureImageOfWebsiteFromUrl(url);
+    const imageSpacePreview : BebbEntityPreview = {
+      'previewData': imageData,
+      'previewType': { 'Jpg' : null },
+    };
+    return imageSpacePreview;
+  };
+};
diff --git a/src/PersonalWebSpace_frontend/helpers/space_helpers.js b/src/PersonalWebSpace_frontend/helpers/space_helpers.js
index d55b29d..c923037 100644
--- a/src/PersonalWebSpace_frontend/helpers/space_helpers.js
+++ b/src/PersonalWebSpace_frontend/helpers/space_helpers.js
@@ -71,7 +71,7 @@ export const getStringForSpaceWithEnvironment = (envToPreview) => {
       <script src="https://unpkg.com/aframe-environment-component@1.3.3/dist/aframe-environment-component.min.js"></script>
     </head>
     <body>
-      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-entity camera="active: true" look-controls wasd-controls="acceleration:65; fly:true" position="0 1.6 0"></a-entity>
         
         <a-light type="directional" intensity="0.9" position="-1 -2  2"></a-light>
@@ -89,7 +89,7 @@ export const getStringForSpaceFromModel = (modelUrl) => {
       <script src="https://aframe.io/releases/1.4.2/aframe.min.js"></script>
     </head>
     <body>
-      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-assets>
           <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
           <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
@@ -115,7 +115,7 @@ export const getStringForSpaceFromUserUploadedModel = () => {
       <script src="https://aframe.io/releases/1.4.2/aframe.min.js"></script>
     </head>
     <body>
-      <a-scene id="aSceneForModelPreview" cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene id="aSceneForModelPreview" cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-assets>
           <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
           <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
@@ -139,7 +139,7 @@ export const getStringForSpaceFromVideoFile = (videoUrl) => {
       <script src="https://aframe.io/releases/1.4.2/aframe.min.js"></script>
     </head>
     <body>
-      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-assets>
           <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
           <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
@@ -166,7 +166,7 @@ export const getStringForSpaceFrom360VideoFile = (videoUrl) => {
       <script src="https://aframe.io/releases/1.4.2/aframe.min.js"></script>
     </head>
     <body>
-      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-assets>
           <video id="360videoToPreview" autoplay loop="true" src="${videoUrl}"></video>
         </a-assets>
@@ -188,7 +188,7 @@ export const getStringForSpaceFromImageFile = (imageUrl) => {
       <script src="https://aframe.io/releases/1.4.2/aframe.min.js"></script>
     </head>
     <body>
-      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-assets>
           <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
           <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
@@ -215,7 +215,7 @@ export const getStringForSpaceFrom360ImageFile = (imageUrl) => {
       <script src="https://aframe.io/releases/1.4.2/aframe.min.js"></script>
     </head>
     <body>
-      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;">
+      <a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" screenshot="width: 1920; height: 1080;">
         <a-assets>
           <img crossorigin="anonymous" id="skyTexture" src="${imageUrl}">
         </a-assets>
diff --git a/src/PersonalWebSpace_frontend/pages/CreateSpace.svelte b/src/PersonalWebSpace_frontend/pages/CreateSpace.svelte
index b4b448c..7cfe66a 100644
--- a/src/PersonalWebSpace_frontend/pages/CreateSpace.svelte
+++ b/src/PersonalWebSpace_frontend/pages/CreateSpace.svelte
@@ -11,7 +11,17 @@
 
   import { canisterId as backendCanisterId } from "canisters/PersonalWebSpace_backend";
   import { canisterId as PersonalWebSpace_frontend_canister_id } from "canisters/PersonalWebSpace_frontend";
-  import type { EntityInitiationObject } from "src/integrations/BebbProtocol/bebb.did";
+  import type {
+    BebbEntityInitiationObject,
+    BebbEntityPreview,
+    BebbEntityUpdateObject,
+  } from "../helpers/bebb_utils";
+  import {
+    createBebbEntity,
+    getBebbEntityUrlPreview,
+    getBebbEntityImagePreviewFromIframe,
+    updateBebbEntity,
+  } from "../helpers/bebb_utils";
 
   let webHostedGlbModelUrl : string = "";
 
@@ -40,18 +50,24 @@
 
   const createNewDefaultUserSpace = async (defaultSpace) => {
     setCreationInProgress(defaultSpace);
+    const iframeSrc = `#/${defaultSpace}`;
+    const iframeSelector = `iframe[src='${iframeSrc}']`;
+
     if (defaultSpace === "defaultspace/0") {
       const resp = await fetch("defaultRoom_Web3Cockpit.html"); // Fetches default space 0
       const defaultSpaceHtml = await resp.text();
-      await createSpace(defaultSpaceHtml);
+      const iframeElement = document.querySelector(iframeSelector);
+      await createSpace(defaultSpaceHtml, iframeElement);
     } else if (defaultSpace === "defaultspace/1") {
       const resp = await fetch("defaultRoom_NatureRetreat.html"); // Fetches default space 1
       const defaultSpaceHtml = await resp.text();
-      await createSpace(defaultSpaceHtml);
+      const iframeElement = document.querySelector(iframeSelector);
+      await createSpace(defaultSpaceHtml, iframeElement);
     } else if (defaultSpace === "defaultspace/2") {
       const resp = await fetch("defaultRoom_InternetIsland.html"); // Fetches default space 2
       const defaultSpaceHtml = await resp.text();
-      await createSpace(defaultSpaceHtml);
+      const iframeElement = document.querySelector(iframeSelector);
+      await createSpace(defaultSpaceHtml, iframeElement);
     };
     setSpaceWasCreated();
   };
@@ -149,7 +165,7 @@
     }
   };
 
-  const createSpace = async (spaceHtml) => {
+  const createSpace = async (spaceHtml, iframeElement=null) => {
     try {
       const spaceResponse = await $store.backendActor.createSpace(spaceHtml);
       // @ts-ignore
@@ -158,32 +174,64 @@
         const spaceId = spaceResponse.Ok.id;
         setSpaceWasCreated();
         // Protocol integration: create Space as Entity in Protocol
-        const externalId = `https://${PersonalWebSpace_frontend_canister_id}${appDomain}/#/space/${spaceId}`;
-        let entityInitiationObject : EntityInitiationObject = {
+        const spaceUrl = `https://${PersonalWebSpace_frontend_canister_id}${appDomain}/#/space/${spaceId}`;
+        const entitySpecificFields = {
+          externalId: spaceUrl,
+        };
+
+        const entityPreviews : Array<BebbEntityPreview> = [];    
+        try {
+          const urlSpacePreview : BebbEntityPreview = await getBebbEntityUrlPreview(spaceUrl);
+          entityPreviews.push(urlSpacePreview);
+        } catch (error) {
+          console.error("Error creating url preview for space: ", error);
+        };
+        let entityInitiationObject : BebbEntityInitiationObject = {
           settings: [],
           entityType: { 'Resource' : { 'Web' : null } },
           name: ["Personal Web Space"],
           description: ["Flaming Hot Personal Web Space"],
           keywords: [["NFT", "Space", "Open Internet Metaverse", "heeyah"]] as [Array<string>],
-          entitySpecificFields: [externalId],
+          entitySpecificFields: [JSON.stringify(entitySpecificFields)] as [string],
+          previews: [entityPreviews] as [Array<BebbEntityPreview>],
         };
-        const spaceEntityIdResponse = await $store.protocolActor.create_entity(entityInitiationObject);
+        const spaceEntityIdResponse = await createBebbEntity(entityInitiationObject);
         // @ts-ignore
-        if (spaceEntityIdResponse && spaceEntityIdResponse.Ok) {
+        if (spaceEntityIdResponse) {
           // @ts-ignore
-          const spaceEntityIdUpdateResponse = await $store.backendActor.updateSpaceEntityId(spaceId, spaceEntityIdResponse.Ok);
+          const spaceEntityIdUpdateResponse = await $store.backendActor.updateSpaceEntityId(spaceId, spaceEntityIdResponse);
           // @ts-ignore
-          if (!spaceEntityIdUpdateResponse || !spaceEntityIdUpdateResponse.Ok) {
-            console.error("Update Space Error:", spaceEntityIdUpdateResponse);
+          if (spaceEntityIdUpdateResponse && spaceEntityIdUpdateResponse.Ok) {
+            if (iframeElement) {
+              // Add image preview to Entity (if a new Entity was created)
+              try {
+                const imageSpacePreview : BebbEntityPreview = await getBebbEntityImagePreviewFromIframe(iframeElement);
+                entityPreviews.push(imageSpacePreview);
+                const bebbEntityUpdateObject : BebbEntityUpdateObject = {
+                  'id' : spaceEntityIdResponse,
+                  'previews' : [entityPreviews] as [Array<BebbEntityPreview>],
+                  // don't update other fields (thus leave empty)
+                  'name' : [],
+                  'description' : [],
+                  'keywords' : [],
+                  'settings' : [],
+                };
+                const updateBebbEntityResponse = await updateBebbEntity(bebbEntityUpdateObject);   
+              } catch (error) {
+                console.error("Error creating image preview for space: ", error);
+              };
+            };
+          } else {
+            console.error("Update Space Error: ", spaceEntityIdUpdateResponse);
           };
         } else {
-          console.error("Create Entity Error:", spaceEntityIdResponse);
+          console.error("Create Entity Error: ", spaceEntityIdResponse);
         };
       } else {
         console.error("Create Space Error:", spaceResponse);
       };
     } catch (error) {
-      console.error("Create Space Error:", error);
+      console.error("Create Space Error: ", error);
     };
   };
 
@@ -191,7 +239,10 @@
     if (modelType === "WebHostedGlbModel" && urlInputHandler(webHostedGlbModelUrl)) {
       setCreationInProgress(modelType);
       const spaceHtml = getStringForSpaceFromModel(webHostedGlbModelUrl);
-      await createSpace(spaceHtml);
+      const iframeId = webHostedGlbModelUrl;
+      const iframeSelector = `iframe[id='${iframeId}']`;
+      const iframeElement = document.querySelector(iframeSelector);
+      await createSpace(spaceHtml, iframeElement);
     };
     // Upload the user's file to the backend canister and create a new space for the user including the uploaded model
     if (modelType === "UserUploadedGlbModel" && userFileInputHandler(files, true) && (fileSizeToUpload <= fileSizeUploadLimit)) {
@@ -210,7 +261,10 @@
           ? `http://127.0.0.1:4943/file/fileId=${fileUploadResult.Ok.FileId}?canisterId=${backendCanisterId}` // e.g. http://127.0.0.1:4943/file/fileId=888?canisterId=bkyz2-fmaaa-aaaaa-qaaaq-cai
           : `https://${backendCanisterId}.raw${appDomain}/file/fileId=${fileUploadResult.Ok.FileId}`; // e.g. https://vee64-zyaaa-aaaai-acpta-cai.raw.ic0.app/file/fileId=777
         const spaceHtml = getStringForSpaceFromModel(url);
-        await createSpace(spaceHtml);
+        const iframeId = userUploadedFileURL;
+        const iframeSelector = `iframe[id='${iframeId}']`;
+        const iframeElement = document.querySelector(iframeSelector);
+        await createSpace(spaceHtml, iframeElement);
       } else {
         console.error("File Upload Error:", fileUploadResult);
       };
@@ -220,7 +274,7 @@
   const createNewUserSpaceFromFile = async () => {
     setCreationInProgress("UserUploadedFile");
     if (fileType === "glbModel") {
-      await createNewUserSpaceFromModel("UserUploadedGlbModel")
+      await createNewUserSpaceFromModel("UserUploadedGlbModel");
     };
     // Upload the user's file to the backend canister and create a new space for the user including the uploaded file
     if (fileType === "mediaContent" && userFileInputHandler(files, true) && (fileSizeToUpload <= fileSizeUploadLimit)) {
@@ -239,7 +293,10 @@
           ? `http://127.0.0.1:4943/file/fileId=${fileUploadResult.Ok.FileId}?canisterId=${backendCanisterId}` // e.g. http://127.0.0.1:4943/file/fileId=888?canisterId=bkyz2-fmaaa-aaaaa-qaaaq-cai
           : `https://${backendCanisterId}.raw${appDomain}/file/fileId=${fileUploadResult.Ok.FileId}`; // e.g. https://vee64-zyaaa-aaaai-acpta-cai.raw.ic0.app/file/fileId=777
         const spaceHtml = getStringForSpaceFromMediaFile(url, files[0].name, is360Degree);
-        await createSpace(spaceHtml);
+        const iframeId = userUploadedFileURL;
+        const iframeSelector = `iframe[id='${iframeId}']`;
+        const iframeElement = document.querySelector(iframeSelector);
+        await createSpace(spaceHtml, iframeElement);
       } else {
         console.error("File Upload Error:", fileUploadResult);
       };
@@ -567,7 +624,6 @@
     </div>
   </div>
 
-
 </section>
 
 <div class='clearfix'></div>
diff --git a/src/PersonalWebSpace_frontend/pages/DownloadFileExample.svelte b/src/PersonalWebSpace_frontend/pages/DownloadFileExample.svelte
index 4996555..d9b806e 100644
--- a/src/PersonalWebSpace_frontend/pages/DownloadFileExample.svelte
+++ b/src/PersonalWebSpace_frontend/pages/DownloadFileExample.svelte
@@ -43,7 +43,7 @@
   onMount(addAFrameTestRoom);
 </script>
 
-<a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
+<a-scene cursor="rayOrigin: mouse" gltf-model="dracoDecoderPath: https://www.gstatic.com/draco/v1/decoders/;" inspector="" keyboard-shortcuts="" screenshot="width: 1920; height: 1080;" vr-mode-ui="" device-orientation-permission-ui="" raycaster="direction: 0.9544506796854287 -0.10164039183312146 -0.2805229594810959; origin: -4.846717797159805 5.074580504821491 2.3289351396596443; useWorldCoordinates: true">
   <a-assets>
     <img crossorigin="anonymous" id="groundTexture" src="https://cdn.aframe.io/a-painter/images/floor.jpg">
     <img crossorigin="anonymous" id="skyTexture" src="https://cdn.aframe.io/a-painter/images/sky.jpg">
diff --git a/src/PersonalWebSpace_frontend/pages/Space.svelte b/src/PersonalWebSpace_frontend/pages/Space.svelte
index 56ab38a..c689c15 100644
--- a/src/PersonalWebSpace_frontend/pages/Space.svelte
+++ b/src/PersonalWebSpace_frontend/pages/Space.svelte
@@ -25,7 +25,13 @@
   import { supportedImageExtensions, supportedVideoExtensions, supported3dModelExtensions } from "../helpers/utils";
   
   import { canisterId as backendCanisterId } from "canisters/PersonalWebSpace_backend";
-  import type { Entity, EntityAttachedBridgesResult, Bridge } from "src/integrations/BebbProtocol/bebb.did";
+  import type {
+    BebbEntity,
+    BebbEntityAndBridge,
+  } from "../helpers/bebb_utils";
+  import {
+    getConnectedEntitiesAndBridgesInBebb,
+  } from "../helpers/bebb_utils";
   
 
 // This is needed for URL params
@@ -1185,7 +1191,7 @@
     // Find the camera entity
     let cameraEntity = document.querySelector('a-entity[camera]');
     // Enable flying in the space (i.e. pressing the forward button always moves into the direction of view, incl. up and down)
-    // ts-ignore
+    // @ts-ignore
     cameraEntity.setAttribute('wasd-controls', { acceleration:65, fly:true });
   };
 
@@ -1286,16 +1292,16 @@
 
   const extractSpaceEntityId = () => {
     if (spaceNft && spaceNft.metadata && spaceNft.metadata.length > 0) {
-        for (var j = 0; j < spaceNft.metadata[0].key_val_data.length; j++) {
-            let fieldKey = spaceNft.metadata[0].key_val_data[j].key;
-            if (fieldKey === "protocolEntityId") {
-                return spaceNft.metadata[0].key_val_data[j].val.TextContent;
-            };
+      for (var j = 0; j < spaceNft.metadata[0].key_val_data.length; j++) {
+        let fieldKey = spaceNft.metadata[0].key_val_data[j].key;
+        if (fieldKey === "protocolEntityId") {
+          return spaceNft.metadata[0].key_val_data[j].val.TextContent;
         };
+      };
     };
   };
 
-  const entityHasValidUrl = (entity: Entity) => {
+  const entityHasValidUrl = (entity: BebbEntity) => {
     return isValidUrl(entity.entitySpecificFields);
   };
 
@@ -1329,22 +1335,84 @@
     };
   };
 
-  function loadNeighborsIn3D(spaceNeighbors: Entity[]) {
+  function loadNeighborsIn3D(spaceNeighbors: BebbEntityAndBridge[]) {
     // Create a new entity for each neighbor
     let neighborIndex = 0;
     for (const neighbor of spaceNeighbors) {
-      // Only display neighbors that have a valid URL
-      if (entityHasValidUrl(neighbor)) {
-        // Create a new entity for the neighbor
-        let neighborEntity = document.createElement('a-entity');
-        // Set properties on the new neighbor entity
-        neighborEntity.setAttribute('id', `OIM-VR-neighbor-${neighbor.id}`);
-        neighborEntity.setAttribute('web-portal', `url:${neighbor.entitySpecificFields}; text:${neighbor.name[0] || "Neighbor " + neighborIndex};`);
-        neighborEntity.setAttribute('position', `${-5 - neighborIndex*3} 1.25 -10`); // Position all Neighbors along one line
-        // Add the neighbor entity to the scene
-        let scene = document.querySelector('a-scene');
-        scene.appendChild(neighborEntity);
-        neighborIndex++;
+      var hasAdditionalPresentationMetadata = false;
+      var additionalPresentationMetadata;
+      if (neighbor.bridge.entitySpecificFields) {
+        try {
+          const entitySpecificFields = JSON.parse(neighbor.bridge.entitySpecificFields);
+          if (entitySpecificFields.presentationMetadata) {
+            additionalPresentationMetadata = entitySpecificFields.presentationMetadata;
+            hasAdditionalPresentationMetadata = true;
+          };
+        } catch(error) {
+          hasAdditionalPresentationMetadata = false;
+        };
+      };
+      if (hasAdditionalPresentationMetadata) {
+        var neighborUrl;
+        try {
+          if (neighbor.entity.previews && neighbor.entity.previews[0]) {
+            var urlPreview;
+            for (const preview of neighbor.entity.previews) {
+              // @ts-ignore
+              if (preview.previewType.hasOwnProperty('Other') && preview.previewType.Other === "URL") {
+                var enc = new TextDecoder("utf-8");
+                const url = enc.decode(preview.previewData);
+                if (isValidUrl(url)) {
+                  neighborUrl = url;
+                  urlPreview = preview;
+                };
+              };
+            };
+          } else {
+            if (neighbor.entity.entitySpecificFields) {
+              const entitySpecificFields = JSON.parse(neighbor.entity.entitySpecificFields);
+              if (entitySpecificFields.externalId && isValidUrl(entitySpecificFields.externalId)) {
+                neighborUrl = entitySpecificFields.externalId;
+              };
+            };
+          };
+        } catch(error) {
+          console.error("Neighbor doesn't have a valid url ", error);
+        };
+        if (neighborUrl) {
+          // Create a new entity for the neighbor
+          let neighborEntity = document.createElement('a-entity');
+          // Set properties on the new neighbor entity
+          neighborEntity.setAttribute('id', `OIM-VR-neighbor-${neighbor.entity.id}`);
+          if (additionalPresentationMetadata && additionalPresentationMetadata.data && additionalPresentationMetadata.data.width && additionalPresentationMetadata.data.height) {
+            neighborEntity.setAttribute('web-portal', `url:${neighborUrl}; text:${neighbor.entity.name[0] || "Neighbor " + neighborIndex}; width:${additionalPresentationMetadata.data.width}; height:${additionalPresentationMetadata.data.height}`);
+          } else {
+            neighborEntity.setAttribute('web-portal', `url:${neighborUrl}; text:${neighbor.entity.name[0] || "Neighbor " + neighborIndex};`);
+          };
+          if (additionalPresentationMetadata && additionalPresentationMetadata.data && additionalPresentationMetadata.data.position) {
+            neighborEntity.setAttribute('position', additionalPresentationMetadata.data.position);
+          } else {
+            neighborEntity.setAttribute('position', `${-5 - neighborIndex*3} 1.25 -10`); // Position all Neighbors along one line
+          };
+          // Add the neighbor entity to the scene
+          let scene = document.querySelector('a-scene');
+          scene.appendChild(neighborEntity);
+          neighborIndex++;
+        };
+      } else { // no additional presentation metadata
+        // Only display neighbors that have a valid URL
+        if (entityHasValidUrl(neighbor.entity)) {
+          // Create a new entity for the neighbor
+          let neighborEntity = document.createElement('a-entity');
+          // Set properties on the new neighbor entity
+          neighborEntity.setAttribute('id', `OIM-VR-neighbor-${neighbor.entity.id}`);
+          neighborEntity.setAttribute('web-portal', `url:${neighbor.entity.entitySpecificFields}; text:${neighbor.entity.name[0] || "Neighbor " + neighborIndex};`);
+          neighborEntity.setAttribute('position', `${-5 - neighborIndex*3} 1.25 -10`); // Position all Neighbors along one line
+          // Add the neighbor entity to the scene
+          let scene = document.querySelector('a-scene');
+          scene.appendChild(neighborEntity);
+          neighborIndex++;
+        };
       };
     };    
   };
@@ -1352,49 +1420,15 @@
   const loadSpaceNeighborsIn3D = async () => {
     // Load the Space's Neighbors from Bebb Protocol and display them in 3D in the scene
     const spaceEntityId = extractSpaceEntityId();
-    let spaceNeighborsResponse : EntityAttachedBridgesResult;
-    let retrievedNeighborEntities : Entity[] = [];
+    let retrievedNeighborEntities : BebbEntityAndBridge[] = [];
     try {
-      try {
-          spaceNeighborsResponse = await $store.protocolActor.get_from_bridge_ids_by_entity_id(spaceEntityId);
-      } catch (error) {
-          console.error("Error Getting Bridges", error);
-          return null;                
-      };
-      // @ts-ignore
-      if (spaceNeighborsResponse && spaceNeighborsResponse.Ok && spaceNeighborsResponse.Ok.length > 0) {
-        // @ts-ignore
-        const bridgesRetrieved : EntityAttachedBridges = spaceNeighborsResponse.Ok;
-        const bridgeIds = [];
-        let getBridgeRequestPromises = [];
-        for (var i = 0; i < bridgesRetrieved.length; i++) {
-            if (bridgesRetrieved[i] && bridgesRetrieved[i].id && bridgesRetrieved[i].linkStatus.hasOwnProperty('CreatedOwner')) {
-                bridgeIds.push(bridgesRetrieved[i].id);
-                getBridgeRequestPromises.push($store.protocolActor.get_bridge(bridgesRetrieved[i].id)); // Send requests in parallel and then await all to speed up
-            };
-        };
-        const getBridgeResponses = await Promise.all(getBridgeRequestPromises);
-        let getConnectedEntityRequestPromises = [];
-        for (var j = 0; j < getBridgeResponses.length; j++) {
-            if (getBridgeResponses[j].Err) {
-                console.error("Error retrieving Bridge", getBridgeResponses[j].Err);
-            } else {
-                const bridge : Bridge = getBridgeResponses[j].Ok;
-                getConnectedEntityRequestPromises.push($store.protocolActor.get_entity(bridge.toEntityId)); // Send requests in parallel and then await all to speed up
-            };
-        };
-        const getConnectedEntityResponses = await Promise.all(getConnectedEntityRequestPromises);
-        for (var j = 0; j < getConnectedEntityResponses.length; j++) {
-            if (getConnectedEntityResponses[j].Err) {
-                console.error("Error retrieving connected Entity", getConnectedEntityResponses[j].Err);
-            } else {
-                const connectedEntity : Entity = getConnectedEntityResponses[j].Ok;
-                retrievedNeighborEntities.push(connectedEntity);
-            };
-        };
+      const getConnectedEntitiesResponse = await getConnectedEntitiesAndBridgesInBebb(spaceEntityId, "from", {OwnerCreated: true});
+      for (var j = 0; j < getConnectedEntitiesResponse.length; j++) {
+        const connectedEntity : BebbEntityAndBridge = getConnectedEntitiesResponse[j];
+        retrievedNeighborEntities.push(connectedEntity);
       };
     } catch(err) {
-        console.error("Error getting SpaceNeighbors", err);
+      console.error("Error getting SpaceNeighbors ", err);
     };
 
     // Only load Neighbors if they haven't been loaded yet or reload if new Neighbors have been added
diff --git a/src/integrations/BebbProtocol/bebb.did b/src/integrations/BebbProtocol/bebb.did
index 9f32987..bff4fb8 100644
--- a/src/integrations/BebbProtocol/bebb.did
+++ b/src/integrations/BebbProtocol/bebb.did
@@ -1,186 +1,198 @@
-type Time = int;
-type EntityUpdateObject = 
- record {
-   description: opt text;
-   id: text;
-   keywords: opt vec text;
-   name: opt text;
-   previews: opt vec EntityPreview;
-   settings: opt EntitySettings;
- };
-type EntityTypeResourceTypes = 
- variant {
-   Content;
-   DigitalAsset;
-   Web;
- };
-type EntityType = 
- variant {
-   Other: text;
-   Resource: EntityTypeResourceTypes;
- };
-type EntitySettings = record {};
-type EntityResult = 
- variant {
-   Err: EntityErrors;
-   Ok: Entity;
- };
-type EntityPreviewSupportedTypes = 
- variant {
-   Glb;
-   Gltf;
-   Jpg;
-   Other: text;
-   Png;
- };
-type EntityPreview = 
- record {
-   previewData: blob;
-   previewType: EntityPreviewSupportedTypes;
- };
-type EntityInitiationObject = 
- record {
-   description: opt text;
-   entitySpecificFields: opt text;
-   entityType: EntityType;
-   keywords: opt vec text;
-   name: opt text;
-   settings: opt EntitySettings;
- };
-type EntityIdResult = 
- variant {
-   Err: EntityIdErrors;
-   Ok: text;
- };
-type EntityIdErrors = 
- variant {
-   EntityNotFound;
-   Error;
-   PreviewTooLarge: int;
-   TooManyPreviews;
-   Unauthorized;
- };
-type EntityErrors = 
- variant {
-   EntityNotFound;
-   Error;
-   Unauthorized: text;
- };
-type EntityAttachedBridgesResult = 
- variant {
-   Err: EntityAttachedBridgesErrors;
-   Ok: EntityAttachedBridges;
- };
-type EntityAttachedBridgesErrors = 
- variant {
-   EntityNotFound;
-   Error;
- };
-type EntityAttachedBridges = vec EntityAttachedBridge;
-type EntityAttachedBridge = 
- record {
-   bridgeType: BridgeType;
-   creationTime: Time;
-   id: text;
-   linkStatus: BridgeLinkStatus;
- };
-type Entity = 
- record {
-   creationTimestamp: nat64;
-   creator: principal;
-   description: text;
-   entitySpecificFields: text;
-   entityType: EntityType;
-   fromIds: EntityAttachedBridges;
-   id: text;
-   keywords: vec text;
-   listOfEntitySpecificFieldKeys: vec text;
-   name: text;
-   owner: principal;
-   previews: vec EntityPreview;
-   settings: EntitySettings;
-   toIds: EntityAttachedBridges;
- };
-type BridgeUpdateObject = 
- record {
-   description: opt text;
-   id: text;
-   keywords: opt vec text;
-   name: opt text;
-   settings: opt BridgeSettings;
- };
-type BridgeType = 
- variant {
-   IsAttachedto;
-   IsPartOf;
-   IsRelatedto;
- };
-type BridgeSettings = record {};
-type BridgeResult = 
- variant {
-   Err: BridgeErrors;
-   Ok: Bridge;
- };
-type BridgeLinkStatus = 
- variant {
-   CreatedOther;
-   CreatedOwner;
- };
-type BridgeInitiationObject = 
- record {
-   bridgeType: BridgeType;
-   description: opt text;
-   entitySpecificFields: opt text;
-   fromEntityId: text;
-   keywords: opt vec text;
-   name: opt text;
-   settings: opt BridgeSettings;
-   toEntityId: text;
- };
-type BridgeIdResult = 
- variant {
-   Err: BridgeIdErrors;
-   Ok: text;
- };
-type BridgeIdErrors = 
- variant {
-   BridgeNotFound;
-   Error;
-   Unauthorized;
- };
-type BridgeErrors = 
- variant {
-   BridgeNotFound;
-   Error;
-   Unauthorized: text;
- };
-type Bridge = 
- record {
-   bridgeType: BridgeType;
-   creationTimestamp: nat64;
-   creator: principal;
-   description: text;
-   entitySpecificFields: text;
-   fromEntityId: text;
-   id: text;
-   keywords: vec text;
-   listOfEntitySpecificFieldKeys: vec text;
-   name: text;
-   owner: principal;
-   settings: BridgeSettings;
-   toEntityId: text;
- };
-service : {
-  create_bridge: (BridgeInitiationObject) -> (BridgeIdResult);
-  create_entity: (EntityInitiationObject) -> (EntityIdResult);
-  delete_bridge: (text) -> (BridgeIdResult);
-  delete_entity: (text) -> (EntityIdResult);
-  get_bridge: (text) -> (BridgeResult) query;
-  get_entity: (text) -> (EntityResult) query;
-  get_from_bridge_ids_by_entity_id: (text) ->
-   (EntityAttachedBridgesResult) query;
-  get_to_bridge_ids_by_entity_id: (text) ->
-   (EntityAttachedBridgesResult) query;
-  update_bridge: (BridgeUpdateObject) -> (BridgeIdResult);
-  update_entity: (EntityUpdateObject) -> (EntityIdResult);
-}
+type Time = int;
+type EntityUpdateObject = 
+ record {
+   description: opt text;
+   id: text;
+   keywords: opt vec text;
+   name: opt text;
+   previews: opt vec EntityPreview;
+   settings: opt EntitySettings;
+ };
+type EntityTypeResourceTypes = 
+ variant {
+   Content;
+   DigitalAsset;
+   Web;
+ };
+type EntityType = 
+ variant {
+   Other: text;
+   Resource: EntityTypeResourceTypes;
+ };
+type EntitySettings = record {};
+type EntityResult = 
+ variant {
+   Err: EntityErrors;
+   Ok: Entity;
+ };
+type EntityPreviewSupportedTypes = 
+ variant {
+   Glb;
+   Gltf;
+   Jpg;
+   Other: text;
+   Png;
+ };
+type EntityPreview = 
+ record {
+   previewData: blob;
+   previewType: EntityPreviewSupportedTypes;
+ };
+type EntityInitiationObject = 
+ record {
+   description: opt text;
+   entitySpecificFields: opt text;
+   entityType: EntityType;
+   keywords: opt vec text;
+   name: opt text;
+   previews: opt vec EntityPreview;
+   settings: opt EntitySettings;
+ };
+type EntityIdResult = 
+ variant {
+   Err: EntityIdErrors;
+   Ok: text;
+ };
+type EntityIdErrors = 
+ variant {
+   EntityNotFound;
+   Error;
+   PreviewTooLarge: int;
+   TooManyPreviews;
+   Unauthorized;
+ };
+type EntityFilterCriterion = 
+ record {
+   criterionKey: text;
+   criterionValue: text;
+ };
+type EntityErrors = 
+ variant {
+   EntityNotFound;
+   Error;
+   Unauthorized: text;
+ };
+type EntityAttachedBridgesResult = 
+ variant {
+   Err: EntityAttachedBridgesErrors;
+   Ok: EntityAttachedBridges;
+ };
+type EntityAttachedBridgesErrors = 
+ variant {
+   EntityNotFound;
+   Error;
+ };
+type EntityAttachedBridges = vec EntityAttachedBridge;
+type EntityAttachedBridge = 
+ record {
+   bridgeType: BridgeType;
+   creationTime: Time;
+   id: text;
+   linkStatus: BridgeLinkStatus;
+ };
+type Entity = 
+ record {
+   creationTimestamp: nat64;
+   creator: principal;
+   description: text;
+   entitySpecificFields: text;
+   entityType: EntityType;
+   fromIds: EntityAttachedBridges;
+   id: text;
+   keywords: vec text;
+   listOfEntitySpecificFieldKeys: vec text;
+   name: text;
+   owner: principal;
+   previews: vec EntityPreview;
+   settings: EntitySettings;
+   toIds: EntityAttachedBridges;
+ };
+type EntitiesResult = 
+ variant {
+   Err: EntityErrors;
+   Ok: vec Entity;
+ };
+type BridgeUpdateObject = 
+ record {
+   description: opt text;
+   id: text;
+   keywords: opt vec text;
+   name: opt text;
+   settings: opt BridgeSettings;
+ };
+type BridgeType = 
+ variant {
+   IsAttachedto;
+   IsPartOf;
+   IsRelatedto;
+ };
+type BridgeSettings = record {};
+type BridgeResult = 
+ variant {
+   Err: BridgeErrors;
+   Ok: Bridge;
+ };
+type BridgeLinkStatus = 
+ variant {
+   CreatedOther;
+   CreatedOwner;
+ };
+type BridgeInitiationObject = 
+ record {
+   bridgeType: BridgeType;
+   description: opt text;
+   entitySpecificFields: opt text;
+   fromEntityId: text;
+   keywords: opt vec text;
+   name: opt text;
+   settings: opt BridgeSettings;
+   toEntityId: text;
+ };
+type BridgeIdResult = 
+ variant {
+   Err: BridgeIdErrors;
+   Ok: text;
+ };
+type BridgeIdErrors = 
+ variant {
+   BridgeNotFound;
+   Error;
+   Unauthorized;
+ };
+type BridgeErrors = 
+ variant {
+   BridgeNotFound;
+   Error;
+   Unauthorized: text;
+ };
+type Bridge = 
+ record {
+   bridgeType: BridgeType;
+   creationTimestamp: nat64;
+   creator: principal;
+   description: text;
+   entitySpecificFields: text;
+   fromEntityId: text;
+   id: text;
+   keywords: vec text;
+   listOfEntitySpecificFieldKeys: vec text;
+   name: text;
+   owner: principal;
+   settings: BridgeSettings;
+   toEntityId: text;
+ };
+service : {
+  create_bridge: (BridgeInitiationObject) -> (BridgeIdResult);
+  create_entity: (EntityInitiationObject) -> (EntityIdResult);
+  delete_bridge: (text) -> (BridgeIdResult);
+  delete_entity: (text) -> (EntityIdResult);
+  get_bridge: (text) -> (BridgeResult) query;
+  get_entity: (text) -> (EntityResult) query;
+  get_from_bridge_ids_by_entity_id: (text) ->
+   (EntityAttachedBridgesResult) query;
+  get_to_bridge_ids_by_entity_id: (text) ->
+   (EntityAttachedBridgesResult) query;
+  match_entities: (vec EntityFilterCriterion) -> (EntitiesResult) query;
+  update_bridge: (BridgeUpdateObject) -> (BridgeIdResult);
+  update_entity: (EntityUpdateObject) -> (EntityIdResult);
+}
diff --git a/src/integrations/BebbProtocol/bebb.did.d.ts b/src/integrations/BebbProtocol/bebb.did.d.ts
index 8e4f1cb..2a09fb0 100644
--- a/src/integrations/BebbProtocol/bebb.did.d.ts
+++ b/src/integrations/BebbProtocol/bebb.did.d.ts
@@ -1,140 +1,151 @@
-import type { Principal } from '@dfinity/principal';
-import type { ActorMethod } from '@dfinity/agent';
-
-export interface Bridge {
-  'id' : string,
-  'toEntityId' : string,
-  'creator' : Principal,
-  'fromEntityId' : string,
-  'owner' : Principal,
-  'creationTimestamp' : bigint,
-  'name' : string,
-  'description' : string,
-  'keywords' : Array<string>,
-  'settings' : BridgeSettings,
-  'listOfEntitySpecificFieldKeys' : Array<string>,
-  'bridgeType' : BridgeType,
-  'entitySpecificFields' : string,
-}
-export type BridgeErrors = { 'Error' : null } |
-  { 'Unauthorized' : string } |
-  { 'BridgeNotFound' : null };
-export type BridgeIdErrors = { 'Error' : null } |
-  { 'Unauthorized' : null } |
-  { 'BridgeNotFound' : null };
-export type BridgeIdResult = { 'Ok' : string } |
-  { 'Err' : BridgeIdErrors };
-export interface BridgeInitiationObject {
-  'toEntityId' : string,
-  'fromEntityId' : string,
-  'name' : [] | [string],
-  'description' : [] | [string],
-  'keywords' : [] | [Array<string>],
-  'settings' : [] | [BridgeSettings],
-  'bridgeType' : BridgeType,
-  'entitySpecificFields' : [] | [string],
-}
-export type BridgeLinkStatus = { 'CreatedOther' : null } |
-  { 'CreatedOwner' : null };
-export type BridgeResult = { 'Ok' : Bridge } |
-  { 'Err' : BridgeErrors };
-export type BridgeSettings = {};
-export type BridgeType = { 'IsPartOf' : null } |
-  { 'IsAttachedto' : null } |
-  { 'IsRelatedto' : null };
-export interface BridgeUpdateObject {
-  'id' : string,
-  'name' : [] | [string],
-  'description' : [] | [string],
-  'keywords' : [] | [Array<string>],
-  'settings' : [] | [BridgeSettings],
-}
-export interface Entity {
-  'id' : string,
-  'creator' : Principal,
-  'toIds' : EntityAttachedBridges,
-  'previews' : Array<EntityPreview>,
-  'owner' : Principal,
-  'creationTimestamp' : bigint,
-  'name' : string,
-  'fromIds' : EntityAttachedBridges,
-  'description' : string,
-  'keywords' : Array<string>,
-  'settings' : EntitySettings,
-  'listOfEntitySpecificFieldKeys' : Array<string>,
-  'entityType' : EntityType,
-  'entitySpecificFields' : string,
-}
-export interface EntityAttachedBridge {
-  'id' : string,
-  'creationTime' : Time,
-  'bridgeType' : BridgeType,
-  'linkStatus' : BridgeLinkStatus,
-}
-export type EntityAttachedBridges = Array<EntityAttachedBridge>;
-export type EntityAttachedBridgesErrors = { 'Error' : null } |
-  { 'EntityNotFound' : null };
-export type EntityAttachedBridgesResult = { 'Ok' : EntityAttachedBridges } |
-  { 'Err' : EntityAttachedBridgesErrors };
-export type EntityErrors = { 'Error' : null } |
-  { 'EntityNotFound' : null } |
-  { 'Unauthorized' : string };
-export type EntityIdErrors = { 'Error' : null } |
-  { 'PreviewTooLarge' : bigint } |
-  { 'EntityNotFound' : null } |
-  { 'TooManyPreviews' : null } |
-  { 'Unauthorized' : null };
-export type EntityIdResult = { 'Ok' : string } |
-  { 'Err' : EntityIdErrors };
-export interface EntityInitiationObject {
-  'name' : [] | [string],
-  'description' : [] | [string],
-  'keywords' : [] | [Array<string>],
-  'settings' : [] | [EntitySettings],
-  'entityType' : EntityType,
-  'entitySpecificFields' : [] | [string],
-}
-export interface EntityPreview {
-  'previewData' : Uint8Array | number[],
-  'previewType' : EntityPreviewSupportedTypes,
-}
-export type EntityPreviewSupportedTypes = { 'Glb' : null } |
-  { 'Jpg' : null } |
-  { 'Png' : null } |
-  { 'Gltf' : null } |
-  { 'Other' : string };
-export type EntityResult = { 'Ok' : Entity } |
-  { 'Err' : EntityErrors };
-export type EntitySettings = {};
-export type EntityType = { 'Other' : string } |
-  { 'Resource' : EntityTypeResourceTypes };
-export type EntityTypeResourceTypes = { 'Web' : null } |
-  { 'DigitalAsset' : null } |
-  { 'Content' : null };
-export interface EntityUpdateObject {
-  'id' : string,
-  'previews' : [] | [Array<EntityPreview>],
-  'name' : [] | [string],
-  'description' : [] | [string],
-  'keywords' : [] | [Array<string>],
-  'settings' : [] | [EntitySettings],
-}
-export type Time = bigint;
-export interface _SERVICE {
-  'create_bridge' : ActorMethod<[BridgeInitiationObject], BridgeIdResult>,
-  'create_entity' : ActorMethod<[EntityInitiationObject], EntityIdResult>,
-  'delete_bridge' : ActorMethod<[string], BridgeIdResult>,
-  'delete_entity' : ActorMethod<[string], EntityIdResult>,
-  'get_bridge' : ActorMethod<[string], BridgeResult>,
-  'get_entity' : ActorMethod<[string], EntityResult>,
-  'get_from_bridge_ids_by_entity_id' : ActorMethod<
-    [string],
-    EntityAttachedBridgesResult
-  >,
-  'get_to_bridge_ids_by_entity_id' : ActorMethod<
-    [string],
-    EntityAttachedBridgesResult
-  >,
-  'update_bridge' : ActorMethod<[BridgeUpdateObject], BridgeIdResult>,
-  'update_entity' : ActorMethod<[EntityUpdateObject], EntityIdResult>,
-}
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export interface Bridge {
+  'id' : string,
+  'toEntityId' : string,
+  'creator' : Principal,
+  'fromEntityId' : string,
+  'owner' : Principal,
+  'creationTimestamp' : bigint,
+  'name' : string,
+  'description' : string,
+  'keywords' : Array<string>,
+  'settings' : BridgeSettings,
+  'listOfEntitySpecificFieldKeys' : Array<string>,
+  'bridgeType' : BridgeType,
+  'entitySpecificFields' : string,
+}
+export type BridgeErrors = { 'Error' : null } |
+  { 'Unauthorized' : string } |
+  { 'BridgeNotFound' : null };
+export type BridgeIdErrors = { 'Error' : null } |
+  { 'Unauthorized' : null } |
+  { 'BridgeNotFound' : null };
+export type BridgeIdResult = { 'Ok' : string } |
+  { 'Err' : BridgeIdErrors };
+export interface BridgeInitiationObject {
+  'toEntityId' : string,
+  'fromEntityId' : string,
+  'name' : [] | [string],
+  'description' : [] | [string],
+  'keywords' : [] | [Array<string>],
+  'settings' : [] | [BridgeSettings],
+  'bridgeType' : BridgeType,
+  'entitySpecificFields' : [] | [string],
+}
+export type BridgeLinkStatus = { 'CreatedOther' : null } |
+  { 'CreatedOwner' : null };
+export type BridgeResult = { 'Ok' : Bridge } |
+  { 'Err' : BridgeErrors };
+export type BridgeSettings = {};
+export type BridgeType = { 'IsPartOf' : null } |
+  { 'IsAttachedto' : null } |
+  { 'IsRelatedto' : null };
+export interface BridgeUpdateObject {
+  'id' : string,
+  'name' : [] | [string],
+  'description' : [] | [string],
+  'keywords' : [] | [Array<string>],
+  'settings' : [] | [BridgeSettings],
+}
+export type EntitiesResult = { 'Ok' : Array<Entity> } |
+  { 'Err' : EntityErrors };
+export interface Entity {
+  'id' : string,
+  'creator' : Principal,
+  'toIds' : EntityAttachedBridges,
+  'previews' : Array<EntityPreview>,
+  'owner' : Principal,
+  'creationTimestamp' : bigint,
+  'name' : string,
+  'fromIds' : EntityAttachedBridges,
+  'description' : string,
+  'keywords' : Array<string>,
+  'settings' : EntitySettings,
+  'listOfEntitySpecificFieldKeys' : Array<string>,
+  'entityType' : EntityType,
+  'entitySpecificFields' : string,
+}
+export interface EntityAttachedBridge {
+  'id' : string,
+  'creationTime' : Time,
+  'bridgeType' : BridgeType,
+  'linkStatus' : BridgeLinkStatus,
+}
+export type EntityAttachedBridges = Array<EntityAttachedBridge>;
+export type EntityAttachedBridgesErrors = { 'Error' : null } |
+  { 'EntityNotFound' : null };
+export type EntityAttachedBridgesResult = { 'Ok' : EntityAttachedBridges } |
+  { 'Err' : EntityAttachedBridgesErrors };
+export type EntityErrors = { 'Error' : null } |
+  { 'EntityNotFound' : null } |
+  { 'Unauthorized' : string };
+export interface EntityFilterCriterion {
+  'criterionKey' : string,
+  'criterionValue' : string,
+}
+export type EntityIdErrors = { 'Error' : null } |
+  { 'PreviewTooLarge' : bigint } |
+  { 'EntityNotFound' : null } |
+  { 'TooManyPreviews' : null } |
+  { 'Unauthorized' : null };
+export type EntityIdResult = { 'Ok' : string } |
+  { 'Err' : EntityIdErrors };
+export interface EntityInitiationObject {
+  'previews' : [] | [Array<EntityPreview>],
+  'name' : [] | [string],
+  'description' : [] | [string],
+  'keywords' : [] | [Array<string>],
+  'settings' : [] | [EntitySettings],
+  'entityType' : EntityType,
+  'entitySpecificFields' : [] | [string],
+}
+export interface EntityPreview {
+  'previewData' : Uint8Array | number[],
+  'previewType' : EntityPreviewSupportedTypes,
+}
+export type EntityPreviewSupportedTypes = { 'Glb' : null } |
+  { 'Jpg' : null } |
+  { 'Png' : null } |
+  { 'Gltf' : null } |
+  { 'Other' : string };
+export type EntityResult = { 'Ok' : Entity } |
+  { 'Err' : EntityErrors };
+export type EntitySettings = {};
+export type EntityType = { 'Other' : string } |
+  { 'Resource' : EntityTypeResourceTypes };
+export type EntityTypeResourceTypes = { 'Web' : null } |
+  { 'DigitalAsset' : null } |
+  { 'Content' : null };
+export interface EntityUpdateObject {
+  'id' : string,
+  'previews' : [] | [Array<EntityPreview>],
+  'name' : [] | [string],
+  'description' : [] | [string],
+  'keywords' : [] | [Array<string>],
+  'settings' : [] | [EntitySettings],
+}
+export type Time = bigint;
+export interface _SERVICE {
+  'create_bridge' : ActorMethod<[BridgeInitiationObject], BridgeIdResult>,
+  'create_entity' : ActorMethod<[EntityInitiationObject], EntityIdResult>,
+  'delete_bridge' : ActorMethod<[string], BridgeIdResult>,
+  'delete_entity' : ActorMethod<[string], EntityIdResult>,
+  'get_bridge' : ActorMethod<[string], BridgeResult>,
+  'get_entity' : ActorMethod<[string], EntityResult>,
+  'get_from_bridge_ids_by_entity_id' : ActorMethod<
+    [string],
+    EntityAttachedBridgesResult
+  >,
+  'get_to_bridge_ids_by_entity_id' : ActorMethod<
+    [string],
+    EntityAttachedBridgesResult
+  >,
+  'match_entities' : ActorMethod<
+    [Array<EntityFilterCriterion>],
+    EntitiesResult
+  >,
+  'update_bridge' : ActorMethod<[BridgeUpdateObject], BridgeIdResult>,
+  'update_entity' : ActorMethod<[EntityUpdateObject], EntityIdResult>,
+}
diff --git a/src/integrations/BebbProtocol/bebb.did.js b/src/integrations/BebbProtocol/bebb.did.js
index 356f3f0..ebfcff7 100644
--- a/src/integrations/BebbProtocol/bebb.did.js
+++ b/src/integrations/BebbProtocol/bebb.did.js
@@ -1,166 +1,180 @@
-export const idlFactory = ({ IDL }) => {
-  const BridgeSettings = IDL.Record({});
-  const BridgeType = IDL.Variant({
-    'IsPartOf' : IDL.Null,
-    'IsAttachedto' : IDL.Null,
-    'IsRelatedto' : IDL.Null,
-  });
-  const BridgeInitiationObject = IDL.Record({
-    'toEntityId' : IDL.Text,
-    'fromEntityId' : IDL.Text,
-    'name' : IDL.Opt(IDL.Text),
-    'description' : IDL.Opt(IDL.Text),
-    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
-    'settings' : IDL.Opt(BridgeSettings),
-    'bridgeType' : BridgeType,
-    'entitySpecificFields' : IDL.Opt(IDL.Text),
-  });
-  const BridgeIdErrors = IDL.Variant({
-    'Error' : IDL.Null,
-    'Unauthorized' : IDL.Null,
-    'BridgeNotFound' : IDL.Null,
-  });
-  const BridgeIdResult = IDL.Variant({
-    'Ok' : IDL.Text,
-    'Err' : BridgeIdErrors,
-  });
-  const EntitySettings = IDL.Record({});
-  const EntityTypeResourceTypes = IDL.Variant({
-    'Web' : IDL.Null,
-    'DigitalAsset' : IDL.Null,
-    'Content' : IDL.Null,
-  });
-  const EntityType = IDL.Variant({
-    'Other' : IDL.Text,
-    'Resource' : EntityTypeResourceTypes,
-  });
-  const EntityInitiationObject = IDL.Record({
-    'name' : IDL.Opt(IDL.Text),
-    'description' : IDL.Opt(IDL.Text),
-    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
-    'settings' : IDL.Opt(EntitySettings),
-    'entityType' : EntityType,
-    'entitySpecificFields' : IDL.Opt(IDL.Text),
-  });
-  const EntityIdErrors = IDL.Variant({
-    'Error' : IDL.Null,
-    'PreviewTooLarge' : IDL.Int,
-    'EntityNotFound' : IDL.Null,
-    'TooManyPreviews' : IDL.Null,
-    'Unauthorized' : IDL.Null,
-  });
-  const EntityIdResult = IDL.Variant({
-    'Ok' : IDL.Text,
-    'Err' : EntityIdErrors,
-  });
-  const Bridge = IDL.Record({
-    'id' : IDL.Text,
-    'toEntityId' : IDL.Text,
-    'creator' : IDL.Principal,
-    'fromEntityId' : IDL.Text,
-    'owner' : IDL.Principal,
-    'creationTimestamp' : IDL.Nat64,
-    'name' : IDL.Text,
-    'description' : IDL.Text,
-    'keywords' : IDL.Vec(IDL.Text),
-    'settings' : BridgeSettings,
-    'listOfEntitySpecificFieldKeys' : IDL.Vec(IDL.Text),
-    'bridgeType' : BridgeType,
-    'entitySpecificFields' : IDL.Text,
-  });
-  const BridgeErrors = IDL.Variant({
-    'Error' : IDL.Null,
-    'Unauthorized' : IDL.Text,
-    'BridgeNotFound' : IDL.Null,
-  });
-  const BridgeResult = IDL.Variant({ 'Ok' : Bridge, 'Err' : BridgeErrors });
-  const Time = IDL.Int;
-  const BridgeLinkStatus = IDL.Variant({
-    'CreatedOther' : IDL.Null,
-    'CreatedOwner' : IDL.Null,
-  });
-  const EntityAttachedBridge = IDL.Record({
-    'id' : IDL.Text,
-    'creationTime' : Time,
-    'bridgeType' : BridgeType,
-    'linkStatus' : BridgeLinkStatus,
-  });
-  const EntityAttachedBridges = IDL.Vec(EntityAttachedBridge);
-  const EntityPreviewSupportedTypes = IDL.Variant({
-    'Glb' : IDL.Null,
-    'Jpg' : IDL.Null,
-    'Png' : IDL.Null,
-    'Gltf' : IDL.Null,
-    'Other' : IDL.Text,
-  });
-  const EntityPreview = IDL.Record({
-    'previewData' : IDL.Vec(IDL.Nat8),
-    'previewType' : EntityPreviewSupportedTypes,
-  });
-  const Entity = IDL.Record({
-    'id' : IDL.Text,
-    'creator' : IDL.Principal,
-    'toIds' : EntityAttachedBridges,
-    'previews' : IDL.Vec(EntityPreview),
-    'owner' : IDL.Principal,
-    'creationTimestamp' : IDL.Nat64,
-    'name' : IDL.Text,
-    'fromIds' : EntityAttachedBridges,
-    'description' : IDL.Text,
-    'keywords' : IDL.Vec(IDL.Text),
-    'settings' : EntitySettings,
-    'listOfEntitySpecificFieldKeys' : IDL.Vec(IDL.Text),
-    'entityType' : EntityType,
-    'entitySpecificFields' : IDL.Text,
-  });
-  const EntityErrors = IDL.Variant({
-    'Error' : IDL.Null,
-    'EntityNotFound' : IDL.Null,
-    'Unauthorized' : IDL.Text,
-  });
-  const EntityResult = IDL.Variant({ 'Ok' : Entity, 'Err' : EntityErrors });
-  const EntityAttachedBridgesErrors = IDL.Variant({
-    'Error' : IDL.Null,
-    'EntityNotFound' : IDL.Null,
-  });
-  const EntityAttachedBridgesResult = IDL.Variant({
-    'Ok' : EntityAttachedBridges,
-    'Err' : EntityAttachedBridgesErrors,
-  });
-  const BridgeUpdateObject = IDL.Record({
-    'id' : IDL.Text,
-    'name' : IDL.Opt(IDL.Text),
-    'description' : IDL.Opt(IDL.Text),
-    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
-    'settings' : IDL.Opt(BridgeSettings),
-  });
-  const EntityUpdateObject = IDL.Record({
-    'id' : IDL.Text,
-    'previews' : IDL.Opt(IDL.Vec(EntityPreview)),
-    'name' : IDL.Opt(IDL.Text),
-    'description' : IDL.Opt(IDL.Text),
-    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
-    'settings' : IDL.Opt(EntitySettings),
-  });
-  return IDL.Service({
-    'create_bridge' : IDL.Func([BridgeInitiationObject], [BridgeIdResult], []),
-    'create_entity' : IDL.Func([EntityInitiationObject], [EntityIdResult], []),
-    'delete_bridge' : IDL.Func([IDL.Text], [BridgeIdResult], []),
-    'delete_entity' : IDL.Func([IDL.Text], [EntityIdResult], []),
-    'get_bridge' : IDL.Func([IDL.Text], [BridgeResult], ['query']),
-    'get_entity' : IDL.Func([IDL.Text], [EntityResult], ['query']),
-    'get_from_bridge_ids_by_entity_id' : IDL.Func(
-        [IDL.Text],
-        [EntityAttachedBridgesResult],
-        ['query'],
-      ),
-    'get_to_bridge_ids_by_entity_id' : IDL.Func(
-        [IDL.Text],
-        [EntityAttachedBridgesResult],
-        ['query'],
-      ),
-    'update_bridge' : IDL.Func([BridgeUpdateObject], [BridgeIdResult], []),
-    'update_entity' : IDL.Func([EntityUpdateObject], [EntityIdResult], []),
-  });
-};
-export const init = ({ IDL }) => { return []; };
+export const idlFactory = ({ IDL }) => {
+  const BridgeSettings = IDL.Record({});
+  const BridgeType = IDL.Variant({
+    'IsPartOf' : IDL.Null,
+    'IsAttachedto' : IDL.Null,
+    'IsRelatedto' : IDL.Null,
+  });
+  const BridgeInitiationObject = IDL.Record({
+    'toEntityId' : IDL.Text,
+    'fromEntityId' : IDL.Text,
+    'name' : IDL.Opt(IDL.Text),
+    'description' : IDL.Opt(IDL.Text),
+    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
+    'settings' : IDL.Opt(BridgeSettings),
+    'bridgeType' : BridgeType,
+    'entitySpecificFields' : IDL.Opt(IDL.Text),
+  });
+  const BridgeIdErrors = IDL.Variant({
+    'Error' : IDL.Null,
+    'Unauthorized' : IDL.Null,
+    'BridgeNotFound' : IDL.Null,
+  });
+  const BridgeIdResult = IDL.Variant({
+    'Ok' : IDL.Text,
+    'Err' : BridgeIdErrors,
+  });
+  const EntityPreviewSupportedTypes = IDL.Variant({
+    'Glb' : IDL.Null,
+    'Jpg' : IDL.Null,
+    'Png' : IDL.Null,
+    'Gltf' : IDL.Null,
+    'Other' : IDL.Text,
+  });
+  const EntityPreview = IDL.Record({
+    'previewData' : IDL.Vec(IDL.Nat8),
+    'previewType' : EntityPreviewSupportedTypes,
+  });
+  const EntitySettings = IDL.Record({});
+  const EntityTypeResourceTypes = IDL.Variant({
+    'Web' : IDL.Null,
+    'DigitalAsset' : IDL.Null,
+    'Content' : IDL.Null,
+  });
+  const EntityType = IDL.Variant({
+    'Other' : IDL.Text,
+    'Resource' : EntityTypeResourceTypes,
+  });
+  const EntityInitiationObject = IDL.Record({
+    'previews' : IDL.Opt(IDL.Vec(EntityPreview)),
+    'name' : IDL.Opt(IDL.Text),
+    'description' : IDL.Opt(IDL.Text),
+    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
+    'settings' : IDL.Opt(EntitySettings),
+    'entityType' : EntityType,
+    'entitySpecificFields' : IDL.Opt(IDL.Text),
+  });
+  const EntityIdErrors = IDL.Variant({
+    'Error' : IDL.Null,
+    'PreviewTooLarge' : IDL.Int,
+    'EntityNotFound' : IDL.Null,
+    'TooManyPreviews' : IDL.Null,
+    'Unauthorized' : IDL.Null,
+  });
+  const EntityIdResult = IDL.Variant({
+    'Ok' : IDL.Text,
+    'Err' : EntityIdErrors,
+  });
+  const Bridge = IDL.Record({
+    'id' : IDL.Text,
+    'toEntityId' : IDL.Text,
+    'creator' : IDL.Principal,
+    'fromEntityId' : IDL.Text,
+    'owner' : IDL.Principal,
+    'creationTimestamp' : IDL.Nat64,
+    'name' : IDL.Text,
+    'description' : IDL.Text,
+    'keywords' : IDL.Vec(IDL.Text),
+    'settings' : BridgeSettings,
+    'listOfEntitySpecificFieldKeys' : IDL.Vec(IDL.Text),
+    'bridgeType' : BridgeType,
+    'entitySpecificFields' : IDL.Text,
+  });
+  const BridgeErrors = IDL.Variant({
+    'Error' : IDL.Null,
+    'Unauthorized' : IDL.Text,
+    'BridgeNotFound' : IDL.Null,
+  });
+  const BridgeResult = IDL.Variant({ 'Ok' : Bridge, 'Err' : BridgeErrors });
+  const Time = IDL.Int;
+  const BridgeLinkStatus = IDL.Variant({
+    'CreatedOther' : IDL.Null,
+    'CreatedOwner' : IDL.Null,
+  });
+  const EntityAttachedBridge = IDL.Record({
+    'id' : IDL.Text,
+    'creationTime' : Time,
+    'bridgeType' : BridgeType,
+    'linkStatus' : BridgeLinkStatus,
+  });
+  const EntityAttachedBridges = IDL.Vec(EntityAttachedBridge);
+  const Entity = IDL.Record({
+    'id' : IDL.Text,
+    'creator' : IDL.Principal,
+    'toIds' : EntityAttachedBridges,
+    'previews' : IDL.Vec(EntityPreview),
+    'owner' : IDL.Principal,
+    'creationTimestamp' : IDL.Nat64,
+    'name' : IDL.Text,
+    'fromIds' : EntityAttachedBridges,
+    'description' : IDL.Text,
+    'keywords' : IDL.Vec(IDL.Text),
+    'settings' : EntitySettings,
+    'listOfEntitySpecificFieldKeys' : IDL.Vec(IDL.Text),
+    'entityType' : EntityType,
+    'entitySpecificFields' : IDL.Text,
+  });
+  const EntityErrors = IDL.Variant({
+    'Error' : IDL.Null,
+    'EntityNotFound' : IDL.Null,
+    'Unauthorized' : IDL.Text,
+  });
+  const EntityResult = IDL.Variant({ 'Ok' : Entity, 'Err' : EntityErrors });
+  const EntityAttachedBridgesErrors = IDL.Variant({
+    'Error' : IDL.Null,
+    'EntityNotFound' : IDL.Null,
+  });
+  const EntityAttachedBridgesResult = IDL.Variant({
+    'Ok' : EntityAttachedBridges,
+    'Err' : EntityAttachedBridgesErrors,
+  });
+  const EntityFilterCriterion = IDL.Record({
+    'criterionKey' : IDL.Text,
+    'criterionValue' : IDL.Text,
+  });
+  const EntitiesResult = IDL.Variant({
+    'Ok' : IDL.Vec(Entity),
+    'Err' : EntityErrors,
+  });
+  const BridgeUpdateObject = IDL.Record({
+    'id' : IDL.Text,
+    'name' : IDL.Opt(IDL.Text),
+    'description' : IDL.Opt(IDL.Text),
+    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
+    'settings' : IDL.Opt(BridgeSettings),
+  });
+  const EntityUpdateObject = IDL.Record({
+    'id' : IDL.Text,
+    'previews' : IDL.Opt(IDL.Vec(EntityPreview)),
+    'name' : IDL.Opt(IDL.Text),
+    'description' : IDL.Opt(IDL.Text),
+    'keywords' : IDL.Opt(IDL.Vec(IDL.Text)),
+    'settings' : IDL.Opt(EntitySettings),
+  });
+  return IDL.Service({
+    'create_bridge' : IDL.Func([BridgeInitiationObject], [BridgeIdResult], []),
+    'create_entity' : IDL.Func([EntityInitiationObject], [EntityIdResult], []),
+    'delete_bridge' : IDL.Func([IDL.Text], [BridgeIdResult], []),
+    'delete_entity' : IDL.Func([IDL.Text], [EntityIdResult], []),
+    'get_bridge' : IDL.Func([IDL.Text], [BridgeResult], ['query']),
+    'get_entity' : IDL.Func([IDL.Text], [EntityResult], ['query']),
+    'get_from_bridge_ids_by_entity_id' : IDL.Func(
+        [IDL.Text],
+        [EntityAttachedBridgesResult],
+        ['query'],
+      ),
+    'get_to_bridge_ids_by_entity_id' : IDL.Func(
+        [IDL.Text],
+        [EntityAttachedBridgesResult],
+        ['query'],
+      ),
+    'match_entities' : IDL.Func(
+        [IDL.Vec(EntityFilterCriterion)],
+        [EntitiesResult],
+        ['query'],
+      ),
+    'update_bridge' : IDL.Func([BridgeUpdateObject], [BridgeIdResult], []),
+    'update_entity' : IDL.Func([EntityUpdateObject], [EntityIdResult], []),
+  });
+};
+export const init = ({ IDL }) => { return []; };
