holosphere 1.3.0-alpha0 → 1.3.0-alpha4

package/holosphere-bundle.js

@@ -1,5 +1,5 @@
 /**
- * HoloSphere Bundle v1.3.0-alpha0
+ * HoloSphere Bundle v1.3.0-alpha4
  * Holonic Geospatial Communication Infrastructure
  * 
  * Includes:
@@ -9,7 +9,7 @@
  * - Ajv (JSON schema validation)
  * 
  * Usage:
- * <script src="https://unpkg.com/holosphere@1.3.0-alpha0/holosphere-bundle.js"></script>
+ * <script src="https://unpkg.com/holosphere@1.3.0-alpha4/holosphere-bundle.js"></script>
  * <script>
  *   const hs = new HoloSphere('myapp');
  * </script>
@@ -7067,7 +7067,7 @@ var HoloSphere = (() => {
         constructor(opts = {}) {
           this.schemas = {};
           this.refs = {};
-          this.formats = {};
+          this.formats = /* @__PURE__ */ Object.create(null);
           this._compilations = /* @__PURE__ */ new Set();
           this._loading = {};
           this._cache = /* @__PURE__ */ new Map();
@@ -7848,6 +7848,7 @@ var HoloSphere = (() => {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       var code_1 = require_code2();
+      var util_1 = require_util();
       var codegen_1 = require_codegen();
       var error = {
         message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -7860,10 +7861,18 @@ var HoloSphere = (() => {
         $data: true,
         error,
         code(cxt) {
-          const { data, $data, schema, schemaCode, it } = cxt;
+          const { gen, data, $data, schema, schemaCode, it } = cxt;
           const u = it.opts.unicodeRegExp ? "u" : "";
-          const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-          cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+          if ($data) {
+            const { regExp } = it.opts.code;
+            const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+            const valid = gen.let("valid");
+            gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+            cxt.fail$data((0, codegen_1._)`!${valid}`);
+          } else {
+            const regExp = (0, code_1.usePattern)(cxt, schema);
+            cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+          }
         }
       };
       exports.default = def;
@@ -10074,7 +10083,7 @@ var HoloSphere = (() => {
       var discriminator_1 = require_discriminator();
       var json_schema_2019_09_1 = require_json_schema_2019_09();
       var META_SCHEMA_ID = "https://json-schema.org/draft/2019-09/schema";
-      var Ajv20193 = class extends core_1.default {
+      var Ajv20192 = class extends core_1.default {
         constructor(opts = {}) {
           super({
             ...opts,
@@ -10104,11 +10113,11 @@ var HoloSphere = (() => {
           return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
         }
       };
-      exports.Ajv2019 = Ajv20193;
-      module.exports = exports = Ajv20193;
-      module.exports.Ajv2019 = Ajv20193;
+      exports.Ajv2019 = Ajv20192;
+      module.exports = exports = Ajv20192;
+      module.exports.Ajv2019 = Ajv20192;
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.default = Ajv20193;
+      exports.default = Ajv20192;
       var validate_1 = require_validate();
       Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
         return validate_1.KeywordCxt;
@@ -24223,9 +24232,139 @@ var HoloSphere = (() => {
 
   // holosphere.js
   var import_gun = __toESM(require_browser(), 1);
-  var import__2 = __toESM(require__(), 1);
+  var import__ = __toESM(require__(), 1);
+
+  // hologram.js
+  function createHologram(holoInstance, holon, lens, data) {
+    if (isHologram(data)) {
+      return {
+        id: data.id,
+        soul: data.soul
+      };
+    }
+    if (!holon || !lens || !data || !data.id) {
+      throw new Error("createHologram: Missing required parameters for non-hologram data");
+    }
+    const soul = `${holoInstance.appname}/${holon}/${lens}/${data.id}`;
+    return {
+      id: data.id,
+      soul
+    };
+  }
+  function parseSoulPath(soul) {
+    if (typeof soul !== "string") return null;
+    const parts = soul.split("/");
+    if (parts.length < 4) return null;
+    const key = parts.slice(3).join("/");
+    return {
+      appname: parts[0],
+      holon: parts[1],
+      lens: parts[2],
+      key
+    };
+  }
+  function isHologram(data) {
+    if (!data || typeof data !== "object") {
+      return false;
+    }
+    if (data.id && typeof data.soul === "string" && data.soul.length > 0) {
+      if (data.soul.includes("/")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function attachHologramMeta(originalData, hologramSoul) {
+    const parts = parseSoulPath(hologramSoul);
+    return {
+      ...originalData,
+      _hologram: {
+        isHologram: true,
+        soul: hologramSoul,
+        sourceHolon: parts?.holon ?? null,
+        sourceLens: parts?.lens ?? null,
+        sourceKey: parts?.key ?? null,
+        resolvedAt: Date.now()
+      }
+    };
+  }
+  async function resolveHologram(holoInstance, hologram, options = {}) {
+    if (!isHologram(hologram)) {
+      return hologram;
+    }
+    const {
+      followHolograms = true,
+      visited = /* @__PURE__ */ new Set(),
+      maxDepth = 10,
+      currentDepth = 0
+    } = options;
+    if (currentDepth >= maxDepth) {
+      console.warn(`!!! Maximum resolution depth (${maxDepth}) reached for soul: ${hologram.soul}. Stopping resolution.`);
+      return null;
+    }
+    if (hologram.soul && visited.has(hologram.soul)) {
+      console.warn(`!!! CIRCULAR hologram detected for soul: ${hologram.soul}. Breaking loop.`);
+      return null;
+    }
+    try {
+      if (hologram.soul) {
+        const soulInfo = parseSoulPath(hologram.soul);
+        if (!soulInfo) {
+          console.warn(`Invalid soul format: ${hologram.soul}`);
+          return null;
+        }
+        const nextVisited = new Set(visited);
+        nextVisited.add(hologram.soul);
+        const originalData = await holoInstance.get(
+          soulInfo.holon,
+          soulInfo.lens,
+          soulInfo.key,
+          null,
+          {
+            resolveHolograms: followHolograms,
+            visited: nextVisited,
+            maxDepth,
+            currentDepth: currentDepth + 1
+          }
+        );
+        if (originalData && !originalData._invalidHologram) {
+          return attachHologramMeta(originalData, hologram.soul);
+        } else {
+          console.warn(`!!! Original data NOT FOUND for soul: ${hologram.soul}. Removing broken hologram.`);
+          return null;
+        }
+      } else {
+        console.warn("!!! resolveHologram called with object missing soul:", hologram);
+        return null;
+      }
+    } catch (error) {
+      if (error.message?.startsWith("CIRCULAR_REFERENCE")) {
+        console.warn(`!!! Circular reference detected during hologram resolution: ${error.message}`);
+        return null;
+      }
+      console.error(`!!! Error resolving hologram: ${error.message}`, error);
+      return null;
+    }
+  }
 
   // federation.js
+  async function getHolonName(holosphere, space) {
+    if (!holosphere || !space) return null;
+    try {
+      const settings = await holosphere.get(space, "settings", space);
+      if (!settings) return null;
+      if (Array.isArray(settings)) {
+        const found = settings.find((s) => s && typeof s.name === "string" && s.name.trim() !== "");
+        return found ? found.name : null;
+      }
+      if (typeof settings.name === "string" && settings.name.trim() !== "") {
+        return settings.name;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
   async function federate(holosphere, spaceId1, spaceId2, password1 = null, password2 = null, bidirectional = true, lensConfig = {}) {
     if (!spaceId1 || !spaceId2) {
       throw new Error("federate: Missing required space IDs");
@@ -24233,110 +24372,85 @@ var HoloSphere = (() => {
     if (spaceId1 === spaceId2) {
       throw new Error("Cannot federate a space with itself");
     }
-    const { federate: federate2 = [], notify = [] } = lensConfig;
-    if (!Array.isArray(federate2) || !Array.isArray(notify)) {
-      throw new Error("federate: lensConfig.federate and lensConfig.notify must be arrays");
-    }
-    const federateLenses = federate2;
-    const notifyLenses = notify;
+    const { inbound = [], outbound = [] } = lensConfig;
+    if (!Array.isArray(inbound) || !Array.isArray(outbound)) {
+      throw new Error("federate: lensConfig.inbound and lensConfig.outbound must be arrays");
+    }
+    const applyDirection = (fedInfo, partnerId, partnerInbound, partnerOutbound) => {
+      if (!fedInfo.federated) fedInfo.federated = [];
+      if (!fedInfo.inbound) fedInfo.inbound = [];
+      if (!fedInfo.outbound) fedInfo.outbound = [];
+      if (!fedInfo.lensConfig) fedInfo.lensConfig = {};
+      if (!fedInfo.federated.includes(partnerId)) {
+        fedInfo.federated.push(partnerId);
+      }
+      const hasInbound = partnerInbound.length > 0;
+      const hasOutbound = partnerOutbound.length > 0;
+      if (hasInbound && !fedInfo.inbound.includes(partnerId)) {
+        fedInfo.inbound.push(partnerId);
+      } else if (!hasInbound) {
+        fedInfo.inbound = fedInfo.inbound.filter((id) => id !== partnerId);
+      }
+      if (hasOutbound && !fedInfo.outbound.includes(partnerId)) {
+        fedInfo.outbound.push(partnerId);
+      } else if (!hasOutbound) {
+        fedInfo.outbound = fedInfo.outbound.filter((id) => id !== partnerId);
+      }
+      fedInfo.lensConfig[partnerId] = {
+        inbound: [...partnerInbound],
+        outbound: [...partnerOutbound],
+        timestamp: Date.now()
+      };
+      fedInfo.timestamp = Date.now();
+    };
     try {
       let fedInfo1 = null;
       try {
         fedInfo1 = await holosphere.getGlobal("federation", spaceId1, password1);
-      } catch (error) {
+      } catch {
       }
       if (fedInfo1 == null) {
         fedInfo1 = {
           id: spaceId1,
           name: spaceId1,
-          federation: [],
-          notify: [],
+          federated: [],
+          inbound: [],
+          outbound: [],
           lensConfig: {},
-          // New field for lens-specific settings
+          partnerNames: {},
           timestamp: Date.now()
         };
       }
-      if (!fedInfo1.federation) fedInfo1.federation = [];
-      if (!fedInfo1.notify) fedInfo1.notify = [];
-      if (!fedInfo1.lensConfig) fedInfo1.lensConfig = {};
-      if (!fedInfo1.federation.includes(spaceId2)) {
-        fedInfo1.federation.push(spaceId2);
-      }
-      if (!fedInfo1.notify.includes(spaceId2)) {
-        fedInfo1.notify.push(spaceId2);
-      }
-      const newLensConfigsForSpace1 = { ...fedInfo1.lensConfig || {} };
-      newLensConfigsForSpace1[spaceId2] = {
-        // Add/update config for the target spaceId2
-        federate: [...federateLenses],
-        // federateLenses & notifyLenses are from the main lensConfig parameter
-        notify: [...notifyLenses],
-        timestamp: Date.now()
-      };
-      fedInfo1.lensConfig = newLensConfigsForSpace1;
-      fedInfo1.timestamp = Date.now();
+      applyDirection(fedInfo1, spaceId2, inbound, outbound);
       try {
         await holosphere.putGlobal("federation", fedInfo1, password1);
       } catch (error) {
         throw new Error(`Failed to create federation: ${error.message}`);
       }
-      {
+      if (bidirectional) {
         let fedInfo2 = null;
         try {
           fedInfo2 = await holosphere.getGlobal("federation", spaceId2, password2);
-        } catch (error) {
+        } catch {
         }
         if (fedInfo2 == null) {
           fedInfo2 = {
             id: spaceId2,
             name: spaceId2,
-            federation: [],
-            notify: [],
+            federated: [],
+            inbound: [],
+            outbound: [],
             lensConfig: {},
-            // New field for lens-specific settings
+            partnerNames: {},
             timestamp: Date.now()
           };
         }
-        if (!fedInfo2.federation) fedInfo2.federation = [];
-        if (!fedInfo2.notify) fedInfo2.notify = [];
-        if (!fedInfo2.lensConfig) fedInfo2.lensConfig = {};
-        if (bidirectional && !fedInfo2.federation.includes(spaceId1)) {
-          fedInfo2.federation.push(spaceId1);
-        }
-        if (!fedInfo2.notify.includes(spaceId1)) {
-          fedInfo2.notify.push(spaceId1);
-        }
-        fedInfo2.lensConfig[spaceId1] = {
-          federate: bidirectional ? [...federateLenses] : [],
-          // Create a copy of the array
-          notify: bidirectional ? [...notifyLenses] : [],
-          // Create a copy of the array
-          timestamp: Date.now()
-        };
-        fedInfo2.timestamp = Date.now();
+        applyDirection(fedInfo2, spaceId1, outbound, inbound);
         try {
           await holosphere.putGlobal("federation", fedInfo2, password2);
-        } catch (error) {
+        } catch {
         }
       }
-      const federationMeta = {
-        id: `${spaceId1}_${spaceId2}`,
-        space1: spaceId1,
-        space2: spaceId2,
-        created: Date.now(),
-        status: "active",
-        bidirectional,
-        lensConfig: {
-          federate: [...federateLenses],
-          // Create a copy of the array
-          notify: [...notifyLenses]
-          // Create a copy of the array
-        }
-      };
-      try {
-        await holosphere.putGlobal("federationMeta", federationMeta);
-      } catch (error) {
-      }
       return true;
     } catch (error) {
       throw error;
@@ -24353,8 +24467,15 @@ var HoloSphere = (() => {
     }
     const subscriptions2 = [];
     let lastNotificationTime = {};
-    if (fedInfo.federation && fedInfo.federation.length > 0) {
-      for (const federatedSpace of fedInfo.federation) {
+    const partnerNames = /* @__PURE__ */ new Map();
+    if (fedInfo.inbound && fedInfo.inbound.length > 0) {
+      await Promise.all(
+        fedInfo.inbound.map(async (space) => {
+          const name = await getHolonName(holosphere, space);
+          partnerNames.set(space, name);
+        })
+      );
+      for (const federatedSpace of fedInfo.inbound) {
         for (const lens of lenses) {
           try {
             const sub = await holosphere.subscribe(federatedSpace, lens, async (data) => {
@@ -24368,10 +24489,13 @@ var HoloSphere = (() => {
                   }
                   lastNotificationTime[key] = now;
                 }
-                if (!data.federation) {
-                  data.federation = {
+                if (!data._federation) {
+                  const partnerName = partnerNames.get(federatedSpace);
+                  data._federation = {
                     origin: federatedSpace,
-                    timestamp: now
+                    sourceLens: lens,
+                    timestamp: now,
+                    ...partnerName ? { originName: partnerName } : {}
                   };
                 }
                 await callback(data, federatedSpace, lens);
@@ -24416,8 +24540,8 @@ var HoloSphere = (() => {
       const fedInfo = await getFederation(holosphere, spaceId, password);
       if (fedInfo && fedInfo.lensConfig && fedInfo.lensConfig[targetSpaceId]) {
         return {
-          federate: fedInfo.lensConfig[targetSpaceId].federate || [],
-          notify: fedInfo.lensConfig[targetSpaceId].notify || []
+          inbound: fedInfo.lensConfig[targetSpaceId].inbound || [],
+          outbound: fedInfo.lensConfig[targetSpaceId].outbound || []
         };
       }
       return null;
@@ -24440,14 +24564,20 @@ var HoloSphere = (() => {
       if (!fedInfo1) {
         console.warn(`No federation info found for ${spaceId1}. Skipping its update.`);
       } else {
-        if (!fedInfo1.federation) fedInfo1.federation = [];
-        if (!fedInfo1.notify) fedInfo1.notify = [];
-        const originalFederationLength = fedInfo1.federation.length;
-        const originalNotifyLength = fedInfo1.notify.length;
-        fedInfo1.federation = fedInfo1.federation.filter((id) => id !== spaceId2);
-        fedInfo1.notify = fedInfo1.notify.filter((id) => id !== spaceId2);
+        if (!fedInfo1.federated) fedInfo1.federated = [];
+        if (!fedInfo1.inbound) fedInfo1.inbound = [];
+        if (!fedInfo1.outbound) fedInfo1.outbound = [];
+        if (!fedInfo1.lensConfig) fedInfo1.lensConfig = {};
+        if (!fedInfo1.partnerNames) fedInfo1.partnerNames = {};
+        const beforeIn = fedInfo1.inbound.length;
+        const beforeOut = fedInfo1.outbound.length;
+        fedInfo1.federated = fedInfo1.federated.filter((id) => id !== spaceId2);
+        fedInfo1.inbound = fedInfo1.inbound.filter((id) => id !== spaceId2);
+        fedInfo1.outbound = fedInfo1.outbound.filter((id) => id !== spaceId2);
+        delete fedInfo1.lensConfig[spaceId2];
+        delete fedInfo1.partnerNames[spaceId2];
         fedInfo1.timestamp = Date.now();
-        console.log(`Unfederate: Removed ${spaceId2} from ${spaceId1}: federation ${originalFederationLength} -> ${fedInfo1.federation.length}, notify ${originalNotifyLength} -> ${fedInfo1.notify.length}`);
+        console.log(`Unfederate: removed ${spaceId2} from ${spaceId1}: inbound ${beforeIn} -> ${fedInfo1.inbound.length}, outbound ${beforeOut} -> ${fedInfo1.outbound.length}`);
         try {
           await holosphere.putGlobal("federation", fedInfo1, password1);
         } catch (error) {
@@ -24462,10 +24592,19 @@ var HoloSphere = (() => {
         } catch (error) {
           console.error(`Error getting fedInfo2 for ${spaceId2} during unfederate: ${error.message}`);
         }
-        if (!fedInfo2 || !fedInfo2.notify) {
-          console.warn(`No notify array found for ${spaceId2} or fedInfo2 is null. Skipping its update.`);
+        if (!fedInfo2) {
+          console.warn(`No federation info found for ${spaceId2}. Skipping its update.`);
         } else {
-          fedInfo2.notify = fedInfo2.notify.filter((id) => id !== spaceId1);
+          if (!fedInfo2.federated) fedInfo2.federated = [];
+          if (!fedInfo2.inbound) fedInfo2.inbound = [];
+          if (!fedInfo2.outbound) fedInfo2.outbound = [];
+          if (!fedInfo2.lensConfig) fedInfo2.lensConfig = {};
+          if (!fedInfo2.partnerNames) fedInfo2.partnerNames = {};
+          fedInfo2.federated = fedInfo2.federated.filter((id) => id !== spaceId1);
+          fedInfo2.inbound = fedInfo2.inbound.filter((id) => id !== spaceId1);
+          fedInfo2.outbound = fedInfo2.outbound.filter((id) => id !== spaceId1);
+          delete fedInfo2.lensConfig[spaceId1];
+          delete fedInfo2.partnerNames[spaceId1];
           fedInfo2.timestamp = Date.now();
           try {
             await holosphere.putGlobal("federation", fedInfo2, password2);
@@ -24498,19 +24637,19 @@ var HoloSphere = (() => {
       throw new Error("removeNotify: Missing required space IDs");
     }
     try {
-      let fedInfo = await holosphere.getGlobal("federation", spaceId1, password1);
+      const fedInfo = await holosphere.getGlobal("federation", spaceId1, password1);
       if (!fedInfo) {
         throw new Error(`No federation info found for ${spaceId1}`);
       }
-      if (!fedInfo.notify) fedInfo.notify = [];
-      if (fedInfo.notify.includes(spaceId2)) {
-        fedInfo.notify = fedInfo.notify.filter((id) => id !== spaceId2);
-        fedInfo.timestamp = Date.now();
-        await holosphere.putGlobal("federation", fedInfo, password1);
-        return true;
-      } else {
-        return false;
+      if (!fedInfo.outbound) fedInfo.outbound = [];
+      if (!fedInfo.outbound.includes(spaceId2)) return false;
+      fedInfo.outbound = fedInfo.outbound.filter((id) => id !== spaceId2);
+      if (fedInfo.lensConfig?.[spaceId2]) {
+        fedInfo.lensConfig[spaceId2].outbound = [];
       }
+      fedInfo.timestamp = Date.now();
+      await holosphere.putGlobal("federation", fedInfo, password1);
+      return true;
     } catch (error) {
       throw error;
     }
@@ -24545,10 +24684,29 @@ var HoloSphere = (() => {
     if (includeLocal) {
       spacesToQuery.push(holon);
     }
-    if (includeFederated && fedInfo && fedInfo.federation && fedInfo.federation.length > 0) {
-      const federatedSpaces = maxFederatedSpaces === -1 ? fedInfo.federation : fedInfo.federation.slice(0, maxFederatedSpaces);
+    if (includeFederated && fedInfo && fedInfo.inbound && fedInfo.inbound.length > 0) {
+      const federatedSpaces = maxFederatedSpaces === -1 ? fedInfo.inbound : fedInfo.inbound.slice(0, maxFederatedSpaces);
       spacesToQuery = spacesToQuery.concat(federatedSpaces);
     }
+    const remoteSpaces = spacesToQuery.filter((s) => s !== holon);
+    const spaceNames = /* @__PURE__ */ new Map();
+    await Promise.all(
+      remoteSpaces.map(async (space) => {
+        const name = await getHolonName(holosphere, space);
+        spaceNames.set(space, name);
+      })
+    );
+    const tagWithSource = (item, space) => {
+      if (!item || space === holon) return item;
+      const originName = spaceNames.get(space);
+      const fed = {
+        ...item._federation || {},
+        origin: space,
+        sourceLens: lens
+      };
+      if (originName) fed.originName = originName;
+      return { ...item, _federation: fed };
+    };
     for (const currentSpace of spacesToQuery) {
       if (queryIds && Array.isArray(queryIds)) {
         console.log(`Fetching specific IDs from ${currentSpace}: ${queryIds.join(", ")}`);
@@ -24557,7 +24715,7 @@ var HoloSphere = (() => {
           fetchPromises.push(
             holosphere.get(currentSpace, lens, itemId).then((item) => {
               if (item) {
-                fetchedItems.set(itemId, item);
+                fetchedItems.set(itemId, tagWithSource(item, currentSpace));
               }
             }).catch((err) => console.warn(`Error fetching item ${itemId} from ${currentSpace}: ${err.message}`))
           );
@@ -24571,7 +24729,7 @@ var HoloSphere = (() => {
           holosphere.getAll(currentSpace, lens).then((items) => {
             for (const item of items) {
               if (item && item[idField] && !fetchedItems.has(item[idField])) {
-                fetchedItems.set(item[idField], item);
+                fetchedItems.set(item[idField], tagWithSource(item, currentSpace));
               }
             }
           }).catch((err) => console.warn(`Error fetching all items from ${currentSpace}: ${err.message}`))
@@ -24603,24 +24761,29 @@ var HoloSphere = (() => {
               );
               console.log(`Original data found via soul path:`, JSON.stringify(originalData));
               if (originalData) {
-                result[i] = {
-                  ...originalData,
-                  _federation: {
-                    isReference: true,
-                    resolved: true,
-                    soul: item.soul,
-                    timestamp: Date.now()
+                const withMeta = attachHologramMeta(originalData, item.soul);
+                if (withMeta._hologram?.sourceHolon) {
+                  let sourceHolonName = spaceNames.get(withMeta._hologram.sourceHolon);
+                  if (sourceHolonName === void 0) {
+                    sourceHolonName = await getHolonName(holosphere, withMeta._hologram.sourceHolon);
+                    spaceNames.set(withMeta._hologram.sourceHolon, sourceHolonName);
                   }
-                };
+                  if (sourceHolonName) {
+                    withMeta._hologram = {
+                      ...withMeta._hologram,
+                      sourceHolonName
+                    };
+                  }
+                }
+                result[i] = withMeta;
               } else {
                 result[i] = {
                   id: item.id,
-                  _federation: {
-                    isReference: true,
-                    resolved: false,
+                  _hologram: {
+                    isHologram: false,
                     soul: item.soul,
                     error: "Referenced data not found",
-                    timestamp: Date.now()
+                    resolvedAt: Date.now()
                   }
                 };
               }
@@ -24628,55 +24791,25 @@ var HoloSphere = (() => {
               console.warn(`Soul doesn't match expected format: ${item.soul}`);
               result[i] = {
                 id: item.id,
-                _federation: {
-                  isReference: true,
-                  resolved: false,
+                _hologram: {
+                  isHologram: false,
                   soul: item.soul,
                   error: "Invalid soul format",
-                  timestamp: Date.now()
+                  resolvedAt: Date.now()
                 }
               };
             }
           } catch (refError) {
             result[i] = {
               id: item.id,
-              _federation: {
-                isReference: true,
-                resolved: false,
+              _hologram: {
+                isHologram: false,
                 soul: item.soul,
                 error: refError.message || "Error resolving reference",
-                timestamp: Date.now()
+                resolvedAt: Date.now()
               }
             };
           }
-        } else if (item._federation && item._federation.isReference) {
-          console.log(`Found legacy reference: ${item._federation.origin}/${item._federation.lens}/${item[idField]}`);
-          try {
-            const reference = item._federation;
-            console.log(`Getting original data from ${reference.origin} / ${reference.lens} / ${item[idField]}`);
-            const originalData = await holosphere.get(
-              reference.origin,
-              reference.lens,
-              item[idField],
-              null,
-              { resolveReferences: false }
-              // Prevent infinite recursion
-            );
-            console.log(`Original data found:`, JSON.stringify(originalData));
-            if (originalData) {
-              result[i] = {
-                ...originalData,
-                _federation: {
-                  ...reference,
-                  resolved: true,
-                  timestamp: Date.now()
-                }
-              };
-            } else {
-              console.warn(`Could not resolve legacy reference: original data not found`);
-            }
-          } catch (refError) {
-          }
         }
       }
     }
@@ -24743,8 +24876,8 @@ var HoloSphere = (() => {
     };
     try {
       const fedInfo = await getFederation(holosphere, holon, password);
-      if (fedInfo && fedInfo.federation && fedInfo.federation.length > 0 && fedInfo.notify && fedInfo.notify.length > 0) {
-        let spaces = fedInfo.notify;
+      if (fedInfo && fedInfo.outbound && fedInfo.outbound.length > 0) {
+        let spaces = fedInfo.outbound;
         if (targetSpaces && Array.isArray(targetSpaces) && targetSpaces.length > 0) {
           spaces = spaces.filter((space) => targetSpaces.includes(space));
         }
@@ -24756,17 +24889,17 @@ var HoloSphere = (() => {
               result.skipped++;
               return false;
             }
-            const federateLenses = Array.isArray(spaceConfig.federate) ? spaceConfig.federate : [];
-            const shouldFederate = federateLenses.includes("*") || federateLenses.includes(lens);
-            const shouldPropagate = shouldFederate;
+            const outboundLenses = Array.isArray(spaceConfig.outbound) ? spaceConfig.outbound : [];
+            const shouldPropagate = outboundLenses.includes("*") || outboundLenses.includes(lens);
             if (!shouldPropagate) {
-              result.messages.push(`Propagation of lens '${lens}' to target space ${targetSpace} skipped: lens not in 'federate' configuration.`);
+              result.messages.push(`Propagation of lens '${lens}' to target space ${targetSpace} skipped: lens not in 'outbound' configuration.`);
               result.skipped++;
             }
             return shouldPropagate;
           });
           if (spaces.length > 0) {
             const isAlreadyHologram = holosphere.isHologram(data);
+            const ownName = await getHolonName(holosphere, holon);
             const propagatePromises = spaces.map(async (targetSpace) => {
               try {
                 let payloadToPut;
@@ -24776,7 +24909,8 @@ var HoloSphere = (() => {
                   sourceLens: lens,
                   // The lens from which this data is being propagated
                   propagatedAt: Date.now(),
-                  originalId: data.id
+                  originalId: data.id,
+                  ...ownName ? { originName: ownName } : {}
                 };
                 if (useHolograms && !isAlreadyHologram) {
                   const newHologram = holosphere.createHologram(holon, lens, data);
@@ -24861,6 +24995,7 @@ var HoloSphere = (() => {
             if (parentHexagons.length > 0) {
               result.parentPropagation.messages.push(`Found ${parentHexagons.length} parent hexagons to propagate to: ${parentHexagons.join(", ")}`);
               const isAlreadyHologram = holosphere.isHologram(data);
+              const ownNameParent = await getHolonName(holosphere, holon);
               const parentPropagatePromises = parentHexagons.map(async (parentHexagon) => {
                 try {
                   let payloadToPut;
@@ -24873,8 +25008,9 @@ var HoloSphere = (() => {
                     originalId: data.id,
                     propagationType: "parent",
                     // Indicate this is parent propagation
-                    parentLevel: holonResolution - getResolution(parentHexagon)
+                    parentLevel: holonResolution - getResolution(parentHexagon),
                     // How many levels up
+                    ...ownNameParent ? { originName: ownNameParent } : {}
                   };
                   if (useHolograms && !isAlreadyHologram) {
                     const newHologram = holosphere.createHologram(holon, lens, data);
@@ -24989,60 +25125,64 @@ var HoloSphere = (() => {
           message: "No federation configuration found for this space"
         };
       }
-      result.federatedCount = fedInfo.federation?.length || 0;
-      result.notifyCount = fedInfo.notify?.length || 0;
+      const allPartners = fedInfo.federated || [];
+      result.federatedCount = allPartners.length;
+      result.inboundCount = fedInfo.inbound?.length || 0;
+      result.outboundCount = fedInfo.outbound?.length || 0;
       const emptyFedInfo = {
         id: spaceId,
         name: spaceName || spaceId,
-        federation: [],
-        notify: [],
+        federated: [],
+        inbound: [],
+        outbound: [],
+        lensConfig: {},
+        partnerNames: {},
         timestamp: Date.now()
       };
       await holosphere.putGlobal("federation", emptyFedInfo, password);
-      if (notifyPartners && fedInfo.federation && fedInfo.federation.length > 0) {
-        const updatePromises = fedInfo.federation.map(async (partnerSpace) => {
+      if (notifyPartners && allPartners.length > 0) {
+        const updatePromises = allPartners.map(async (partnerSpace) => {
           try {
             const partnerFedInfo = await getFederation(holosphere, partnerSpace);
-            if (partnerFedInfo) {
-              if (partnerFedInfo.federation) {
-                partnerFedInfo.federation = partnerFedInfo.federation.filter(
-                  (id) => id !== spaceId.toString()
-                );
-              }
-              if (partnerFedInfo.notify) {
-                partnerFedInfo.notify = partnerFedInfo.notify.filter(
-                  (id) => id !== spaceId.toString()
-                );
-              }
-              partnerFedInfo.timestamp = Date.now();
-              await holosphere.putGlobal("federation", partnerFedInfo);
-              result.partnersNotified++;
-              return true;
+            if (!partnerFedInfo) return false;
+            const sid = spaceId.toString();
+            if (partnerFedInfo.federated) {
+              partnerFedInfo.federated = partnerFedInfo.federated.filter((id) => id !== sid);
             }
-            return false;
+            if (partnerFedInfo.inbound) {
+              partnerFedInfo.inbound = partnerFedInfo.inbound.filter((id) => id !== sid);
+            }
+            if (partnerFedInfo.outbound) {
+              partnerFedInfo.outbound = partnerFedInfo.outbound.filter((id) => id !== sid);
+            }
+            if (partnerFedInfo.lensConfig) {
+              delete partnerFedInfo.lensConfig[sid];
+            }
+            if (partnerFedInfo.partnerNames) {
+              delete partnerFedInfo.partnerNames[sid];
+            }
+            partnerFedInfo.timestamp = Date.now();
+            await holosphere.putGlobal("federation", partnerFedInfo);
+            result.partnersNotified++;
+            return true;
           } catch (error) {
-            result.errors.push({
-              partner: partnerSpace,
-              error: error.message
-            });
+            result.errors.push({ partner: partnerSpace, error: error.message });
             return false;
           }
         });
         await Promise.all(updatePromises);
       }
-      if (fedInfo.federation && fedInfo.federation.length > 0) {
-        for (const partnerSpace of fedInfo.federation) {
-          try {
-            const metaId = `${spaceId}_${partnerSpace}`;
-            const altMetaId = `${partnerSpace}_${spaceId}`;
-            const meta = await holosphere.getGlobal("federationMeta", metaId) || await holosphere.getGlobal("federationMeta", altMetaId);
-            if (meta) {
-              meta.status = "inactive";
-              meta.endedAt = Date.now();
-              await holosphere.putGlobal("federationMeta", meta);
-            }
-          } catch (error) {
+      for (const partnerSpace of allPartners) {
+        try {
+          const metaId = `${spaceId}_${partnerSpace}`;
+          const altMetaId = `${partnerSpace}_${spaceId}`;
+          const meta = await holosphere.getGlobal("federationMeta", metaId) || await holosphere.getGlobal("federationMeta", altMetaId);
+          if (meta) {
+            meta.status = "inactive";
+            meta.endedAt = Date.now();
+            await holosphere.putGlobal("federationMeta", meta);
           }
+        } catch {
         }
       }
       result.success = true;
@@ -25057,7 +25197,6 @@ var HoloSphere = (() => {
   }
 
   // schema.js
-  var import__ = __toESM(require__(), 1);
   async function setSchema(holoInstance, lens, schema) {
     if (!lens || !schema) {
       throw new Error("setSchema: Missing required parameters");
@@ -25139,6 +25278,45 @@ var HoloSphere = (() => {
   }
 
   // content.js
+  function sanitizeForStorage(value, path = "", seen = /* @__PURE__ */ new WeakSet(), warnings = []) {
+    if (value === null) return null;
+    const t = typeof value;
+    if (t === "number") {
+      if (!Number.isFinite(value)) {
+        warnings.push(`${path || "<root>"}: ${value} (non-finite number)`);
+        return void 0;
+      }
+      return value;
+    }
+    if (t === "string" || t === "boolean") return value;
+    if (t === "undefined" || t === "function" || t === "symbol" || t === "bigint") {
+      warnings.push(`${path || "<root>"}: ${t}`);
+      return void 0;
+    }
+    if (t === "object") {
+      if (seen.has(value)) {
+        warnings.push(`${path || "<root>"}: circular reference`);
+        return void 0;
+      }
+      seen.add(value);
+      if (Array.isArray(value)) {
+        const out2 = [];
+        for (let i = 0; i < value.length; i++) {
+          const cleaned = sanitizeForStorage(value[i], `${path}[${i}]`, seen, warnings);
+          out2.push(cleaned === void 0 ? null : cleaned);
+        }
+        return out2;
+      }
+      const out = {};
+      for (const k of Object.keys(value)) {
+        const cleaned = sanitizeForStorage(value[k], path ? `${path}.${k}` : k, seen, warnings);
+        if (cleaned !== void 0) out[k] = cleaned;
+      }
+      return out;
+    }
+    warnings.push(`${path || "<root>"}: unsupported type ${t}`);
+    return void 0;
+  }
   async function put(holoInstance, holon, lens, data, password = null, options = {}) {
     if (!data) {
       throw new Error("put: Missing required data parameter");
@@ -25236,10 +25414,16 @@ var HoloSphere = (() => {
       }
       return new Promise((resolve, reject) => {
         try {
-          let dataToStore = { ...data };
-          if (dataToStore._meta !== void 0) {
-            delete dataToStore._meta;
+          const sanitizeWarnings = [];
+          let dataToStore = sanitizeForStorage(data, "", /* @__PURE__ */ new WeakSet(), sanitizeWarnings) || {};
+          if (sanitizeWarnings.length > 0) {
+            console.warn(
+              `holosphere.put: sanitized ${sanitizeWarnings.length} field(s) at ${targetHolon}/${targetLens}/${targetKey} (id=${data.id}):`,
+              sanitizeWarnings
+            );
           }
+          if (dataToStore._meta !== void 0) delete dataToStore._meta;
+          if (dataToStore._hologram !== void 0) delete dataToStore._hologram;
           const payload = JSON.stringify(dataToStore);
           const putCallback = async (ack) => {
             if (ack.err) {
@@ -25529,7 +25713,8 @@ var HoloSphere = (() => {
         const output = /* @__PURE__ */ new Map();
         const pendingProcessing = [];
         const dataPath = password ? user.get("private").get(lens) : holoInstance.gun.get(holoInstance.appname).get(holon).get(lens);
-        dataPath.once((data) => {
+        const shallowOnce = () => new Promise((res) => dataPath.once((d) => res(d)));
+        const processShallow = (data) => {
           if (!data) {
             resolve([]);
             return;
@@ -25546,72 +25731,75 @@ var HoloSphere = (() => {
             resolve([]);
             return;
           }
-          let receivedCount = 0;
-          dataPath.map().once(async (itemData, key) => {
-            if (!itemData || key === "_") {
-              receivedCount++;
-              if (receivedCount >= expectedCount) {
-                await Promise.all(pendingProcessing);
-                resolve(Array.from(output.values()));
-              }
-              return;
-            }
-            const processingPromise = (async () => {
-              try {
-                const parsed = await holoInstance.parse(itemData);
-                if (!parsed || !parsed.id) return;
-                if (holoInstance.isHologram(parsed)) {
-                  try {
-                    const resolved = await holoInstance.resolveHologram(parsed, {
-                      followHolograms: true,
-                      maxDepth: 10,
-                      currentDepth: 0
-                    });
-                    if (resolved === null) {
-                      console.warn(`Broken hologram detected in getAll for key ${key}. Removing it...`);
-                      try {
-                        await holoInstance.delete(holon, lens, key, password);
-                      } catch (cleanupError) {
-                        console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
-                      }
-                      return;
+          const processItem = async (itemData, key) => {
+            if (!itemData) return;
+            try {
+              const parsed = await holoInstance.parse(itemData);
+              if (!parsed || !parsed.id) return;
+              if (holoInstance.isHologram(parsed)) {
+                try {
+                  const resolved = await holoInstance.resolveHologram(parsed, {
+                    followHolograms: true,
+                    maxDepth: 10,
+                    currentDepth: 0
+                  });
+                  if (resolved === null) {
+                    console.warn(`Broken hologram detected in getAll for key ${key}. Removing it...`);
+                    try {
+                      await holoInstance.delete(holon, lens, key, password);
+                    } catch (cleanupError) {
+                      console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
                     }
-                    if (resolved && resolved !== parsed) {
-                      if (schema) {
-                        const valid = holoInstance.validator.validate(schema, resolved);
-                        if (valid || !holoInstance.strict) {
-                          output.set(resolved.id, resolved);
-                        }
-                      } else {
+                    return;
+                  }
+                  if (resolved && resolved !== parsed) {
+                    if (schema) {
+                      const valid = holoInstance.validator.validate(schema, resolved);
+                      if (valid || !holoInstance.strict) {
                         output.set(resolved.id, resolved);
                       }
-                      return;
+                    } else {
+                      output.set(resolved.id, resolved);
                     }
-                  } catch (hologramError) {
-                    console.error(`Error resolving hologram for key ${key}:`, hologramError);
                     return;
                   }
+                } catch (hologramError) {
+                  console.error(`Error resolving hologram for key ${key}:`, hologramError);
+                  return;
                 }
-                if (schema) {
-                  const valid = holoInstance.validator.validate(schema, parsed);
-                  if (valid || !holoInstance.strict) {
-                    output.set(parsed.id, parsed);
-                  }
-                } else {
+              }
+              if (schema) {
+                const valid = holoInstance.validator.validate(schema, parsed);
+                if (valid || !holoInstance.strict) {
                   output.set(parsed.id, parsed);
                 }
-              } catch (error) {
-                console.error("Error processing data:", error);
+              } else {
+                output.set(parsed.id, parsed);
               }
-            })();
-            pendingProcessing.push(processingPromise);
-            receivedCount++;
-            if (receivedCount >= expectedCount) {
-              await Promise.all(pendingProcessing);
-              resolve(Array.from(output.values()));
+            } catch (error) {
+              console.error("Error processing data:", error);
             }
-          });
-        });
+          };
+          Promise.all(keys.map((key) => {
+            const inline = data[key];
+            if (typeof inline !== "object" || inline === null) {
+              return processItem(inline, key);
+            }
+            return new Promise((resolveItem) => {
+              dataPath.get(key).once((itemData) => {
+                processItem(itemData, key).then(resolveItem, resolveItem);
+              });
+            });
+          })).then(() => resolve(Array.from(output.values())));
+        };
+        (async () => {
+          let data = await shallowOnce();
+          if (!data) {
+            await new Promise((r) => setTimeout(r, 1500));
+            data = await shallowOnce();
+          }
+          processShallow(data);
+        })();
       });
     } catch (error) {
       console.error("Error in getAll:", error);
@@ -26090,6 +26278,9 @@ var HoloSphere = (() => {
           if (dataToStore._meta !== void 0) {
             delete dataToStore._meta;
           }
+          if (dataToStore._hologram !== void 0) {
+            delete dataToStore._hologram;
+          }
           const payload = JSON.stringify(dataToStore);
           const isHologram2 = holoInstance.isHologram(dataToStore);
           const dataPath = password ? user.get("private").get(tableName) : holoInstance.gun.get(holoInstance.appname).get(tableName);
@@ -26290,7 +26481,8 @@ var HoloSphere = (() => {
         const output = [];
         const pendingProcessing = [];
         const dataPath = password ? user.get("private").get(tableName) : holoInstance.gun.get(holoInstance.appname).get(tableName);
-        dataPath.once((data) => {
+        const shallowOnce = () => new Promise((res) => dataPath.once((d) => res(d)));
+        const processShallow = (data) => {
           if (!data) {
             resolve([]);
             return;
@@ -26307,52 +26499,55 @@ var HoloSphere = (() => {
             resolve([]);
             return;
           }
-          let receivedCount = 0;
-          dataPath.map().once(async (itemData, key) => {
-            if (!itemData || key === "_") {
-              receivedCount++;
-              if (receivedCount >= expectedCount) {
-                await Promise.all(pendingProcessing);
-                resolve(output);
-              }
-              return;
-            }
-            const processingPromise = (async () => {
-              try {
-                const parsed = await holoInstance.parse(itemData);
-                if (!parsed) return;
-                if (holoInstance.isHologram(parsed)) {
-                  const resolved = await holoInstance.resolveHologram(parsed, {
-                    followHolograms: true
-                  });
-                  if (resolved === null) {
-                    try {
-                      await holoInstance.deleteGlobal(tableName, key, password);
-                    } catch (deleteError) {
-                      console.error(`Failed to delete invalid global hologram at ${tableName}/${key}:`, deleteError);
-                    }
-                    return;
-                  }
-                  if (resolved !== parsed) {
-                    output.push(resolved);
-                  } else {
-                    output.push(parsed);
+          const processItem = async (itemData, key) => {
+            if (!itemData) return;
+            try {
+              const parsed = await holoInstance.parse(itemData);
+              if (!parsed) return;
+              if (holoInstance.isHologram(parsed)) {
+                const resolved = await holoInstance.resolveHologram(parsed, {
+                  followHolograms: true
+                });
+                if (resolved === null) {
+                  try {
+                    await holoInstance.deleteGlobal(tableName, key, password);
+                  } catch (deleteError) {
+                    console.error(`Failed to delete invalid global hologram at ${tableName}/${key}:`, deleteError);
                   }
+                  return;
+                }
+                if (resolved !== parsed) {
+                  output.push(resolved);
                 } else {
                   output.push(parsed);
                 }
-              } catch (error) {
-                console.error("Error parsing data:", error);
+              } else {
+                output.push(parsed);
               }
-            })();
-            pendingProcessing.push(processingPromise);
-            receivedCount++;
-            if (receivedCount >= expectedCount) {
-              await Promise.all(pendingProcessing);
-              resolve(output);
+            } catch (error) {
+              console.error("Error parsing data:", error);
             }
-          });
-        });
+          };
+          Promise.all(keys.map((key) => {
+            const inline = data[key];
+            if (typeof inline !== "object" || inline === null) {
+              return processItem(inline, key);
+            }
+            return new Promise((resolveItem) => {
+              dataPath.get(key).once((itemData) => {
+                processItem(itemData, key).then(resolveItem, resolveItem);
+              });
+            });
+          })).then(() => resolve(output));
+        };
+        (async () => {
+          let data = await shallowOnce();
+          if (!data) {
+            await new Promise((r) => setTimeout(r, 1500));
+            data = await shallowOnce();
+          }
+          processShallow(data);
+        })();
       });
     } catch (error) {
       console.error("Error in getAllGlobal:", error);
@@ -26642,116 +26837,6 @@ var HoloSphere = (() => {
     };
   }
 
-  // hologram.js
-  function createHologram(holoInstance, holon, lens, data) {
-    if (isHologram(data)) {
-      return {
-        id: data.id,
-        soul: data.soul
-      };
-    }
-    if (!holon || !lens || !data || !data.id) {
-      throw new Error("createHologram: Missing required parameters for non-hologram data");
-    }
-    const soul = `${holoInstance.appname}/${holon}/${lens}/${data.id}`;
-    return {
-      id: data.id,
-      soul
-    };
-  }
-  function parseSoulPath(soul) {
-    if (typeof soul !== "string") return null;
-    const parts = soul.split("/");
-    if (parts.length < 4) return null;
-    const key = parts.slice(3).join("/");
-    return {
-      appname: parts[0],
-      holon: parts[1],
-      lens: parts[2],
-      key
-    };
-  }
-  function isHologram(data) {
-    if (!data || typeof data !== "object") {
-      return false;
-    }
-    if (data.id && typeof data.soul === "string" && data.soul.length > 0) {
-      if (data.soul.includes("/")) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async function resolveHologram(holoInstance, hologram, options = {}) {
-    if (!isHologram(hologram)) {
-      return hologram;
-    }
-    const {
-      followHolograms = true,
-      visited = /* @__PURE__ */ new Set(),
-      maxDepth = 10,
-      currentDepth = 0
-    } = options;
-    if (currentDepth >= maxDepth) {
-      console.warn(`!!! Maximum resolution depth (${maxDepth}) reached for soul: ${hologram.soul}. Stopping resolution.`);
-      return null;
-    }
-    if (hologram.soul && visited.has(hologram.soul)) {
-      console.warn(`!!! CIRCULAR hologram detected for soul: ${hologram.soul}. Breaking loop.`);
-      return null;
-    }
-    try {
-      if (hologram.soul) {
-        const soulInfo = parseSoulPath(hologram.soul);
-        if (!soulInfo) {
-          console.warn(`Invalid soul format: ${hologram.soul}`);
-          return null;
-        }
-        const nextVisited = new Set(visited);
-        nextVisited.add(hologram.soul);
-        const originalData = await holoInstance.get(
-          soulInfo.holon,
-          soulInfo.lens,
-          soulInfo.key,
-          null,
-          {
-            resolveHolograms: followHolograms,
-            visited: nextVisited,
-            maxDepth,
-            currentDepth: currentDepth + 1
-          }
-        );
-        if (originalData && !originalData._invalidHologram) {
-          return {
-            ...originalData,
-            _meta: {
-              ...originalData._meta || {},
-              // Preserve original _meta
-              resolvedFromHologram: true,
-              // This is now the primary indicator
-              hologramSoul: hologram.soul,
-              // Clarified meta field
-              resolutionDepth: currentDepth
-            }
-          };
-        } else {
-          console.warn(`!!! Original data NOT FOUND for soul: ${hologram.soul}. Removing broken hologram.`);
-          return null;
-        }
-      } else {
-        console.warn("!!! resolveHologram called with object missing soul:", hologram);
-        return null;
-      }
-    } catch (error) {
-      if (error.message?.startsWith("CIRCULAR_REFERENCE")) {
-        console.warn(`!!! Circular reference detected during hologram resolution: ${error.message}`);
-        return null;
-      }
-      console.error(`!!! Error resolving hologram: ${error.message}`, error);
-      return null;
-    }
-  }
-
   // compute.js
   async function computeHierarchy(holoInstance, holon, lens, options, maxLevels = 15, password = null) {
     let currentHolon = holon;
@@ -30225,7 +30310,7 @@ var HoloSphere = (() => {
         this._privateKey = null;
       }
       console.log("HoloSphere v" + HOLOSPHERE_VERSION);
-      this.validator = new import__2.default({
+      this.validator = new import__.default({
         allErrors: true,
         strict: false,
         validateSchema: true
@@ -30377,6 +30462,9 @@ var HoloSphere = (() => {
     async resolveHologram(hologram, options = {}) {
       return resolveHologram(this, hologram, options);
     }
+    attachHologramMeta(originalData, hologramSoul) {
+      return attachHologramMeta(originalData, hologramSoul);
+    }
     // ================================ COMPUTE FUNCTIONS ================================
     async computeHierarchy(holon, lens, options, maxLevels = 15, password = null) {
       return computeHierarchy(this, holon, lens, options, maxLevels, password);
@@ -30419,41 +30507,37 @@ var HoloSphere = (() => {
       return federate(this, holonId1, holonId2, password1, password2, bidirectional, lensConfig);
     }
     /**
-     * v2-compatible federation creation.
-     * Maps v2 options to v1 federate() call.
+     * Convenience wrapper around federate() for the common bidirectional case.
      * @param {string} sourceHolon - Source holon ID
      * @param {string} targetHolon - Target holon ID
      * @param {object} [options] - Federation options
-     * @param {object} [options.lensConfig] - Lens configuration
-     * @param {string} [options.partnerName] - Name of the partner holon
-     * @param {boolean} [options.skipPropagation] - Skip data propagation
+     * @param {object} [options.lensConfig] - Lens config from sourceHolon's perspective
+     * @param {string[]} [options.lensConfig.inbound] - Lenses sourceHolon receives from targetHolon
+     * @param {string[]} [options.lensConfig.outbound] - Lenses sourceHolon sends to targetHolon
+     * @param {string} [options.partnerName] - Display name for the partner
      * @returns {Promise<boolean>}
      */
     async federateHolon(sourceHolon, targetHolon, options = {}) {
       const lensConfig = options.lensConfig || {};
-      const lenses = lensConfig.lenses || lensConfig.outbound || lensConfig.federate || [];
-      if (options.partnerName) {
+      const inbound = Array.isArray(lensConfig.inbound) ? lensConfig.inbound : [];
+      const outbound = Array.isArray(lensConfig.outbound) ? lensConfig.outbound : [];
+      const ok = await federate(this, sourceHolon, targetHolon, null, null, true, {
+        inbound,
+        outbound
+      });
+      if (ok && options.partnerName) {
         try {
-          const fedInfo = await this.getFederation(sourceHolon) || {
-            id: sourceHolon,
-            name: sourceHolon,
-            federation: [],
-            notify: [],
-            lensConfig: {},
-            partnerNames: {},
-            timestamp: Date.now()
-          };
-          if (!fedInfo.partnerNames) fedInfo.partnerNames = {};
-          fedInfo.partnerNames[targetHolon] = options.partnerName;
-          await this.putGlobal("federation", fedInfo);
+          const fedInfo = await this.getFederation(sourceHolon);
+          if (fedInfo) {
+            if (!fedInfo.partnerNames) fedInfo.partnerNames = {};
+            fedInfo.partnerNames[targetHolon] = options.partnerName;
+            await this.putGlobal("federation", fedInfo);
+          }
         } catch (e) {
           console.warn("Failed to store partner name:", e.message);
         }
       }
-      return federate(this, sourceHolon, targetHolon, null, null, true, {
-        federate: lenses,
-        notify: lenses
-      });
+      return ok;
     }
     /**
      * v2-compatible federation removal.