holosphere 1.3.0-alpha0 → 1.3.0-alpha4

package/holosphere-bundle.esm.js

@@ -1,9 +1,9 @@
 /**
- * HoloSphere ESM Bundle v1.3.0-alpha0
+ * HoloSphere ESM Bundle v1.3.0-alpha4
  * ES6 Module version with all dependencies bundled
  * 
  * Usage:
- * import HoloSphere from 'https://unpkg.com/holosphere@1.3.0-alpha0/holosphere-bundle.esm.js';
+ * import HoloSphere from 'https://unpkg.com/holosphere@1.3.0-alpha4/holosphere-bundle.esm.js';
  * const hs = new HoloSphere('myapp');
  */
 var __create = Object.create;
@@ -7054,7 +7054,7 @@ var require_core = __commonJS({
       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();
@@ -7835,6 +7835,7 @@ var require_pattern = __commonJS({
     "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}"`,
@@ -7847,10 +7848,18 @@ var require_pattern = __commonJS({
       $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;
@@ -10061,7 +10070,7 @@ var require__ = __commonJS({
     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,
@@ -10091,11 +10100,11 @@ var require__ = __commonJS({
         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;
@@ -24197,9 +24206,139 @@ function degsToRads(deg) {
 
 // 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");
@@ -24207,110 +24346,85 @@ async function federate(holosphere, spaceId1, spaceId2, password1 = null, passwo
   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;
@@ -24327,8 +24441,15 @@ async function subscribeFederation(holosphere, spaceId, password = null, callbac
   }
   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) => {
@@ -24342,10 +24463,13 @@ async function subscribeFederation(holosphere, spaceId, password = null, callbac
                 }
                 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);
@@ -24390,8 +24514,8 @@ async function getFederatedConfig(holosphere, spaceId, targetSpaceId, password =
     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;
@@ -24414,14 +24538,20 @@ async function unfederate(holosphere, spaceId1, spaceId2, password1 = null, pass
     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) {
@@ -24436,10 +24566,19 @@ async function unfederate(holosphere, spaceId1, spaceId2, password1 = null, pass
       } 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);
@@ -24472,19 +24611,19 @@ async function removeNotify(holosphere, spaceId1, spaceId2, password1 = null) {
     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;
   }
@@ -24519,10 +24658,29 @@ async function getFederated(holosphere, holon, lens, options = {}) {
   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(", ")}`);
@@ -24531,7 +24689,7 @@ async function getFederated(holosphere, holon, lens, options = {}) {
         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}`))
         );
@@ -24545,7 +24703,7 @@ async function getFederated(holosphere, holon, lens, options = {}) {
         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}`))
@@ -24577,24 +24735,29 @@ async function getFederated(holosphere, holon, lens, options = {}) {
             );
             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()
                 }
               };
             }
@@ -24602,55 +24765,25 @@ async function getFederated(holosphere, holon, lens, options = {}) {
             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) {
-        }
       }
     }
   }
@@ -24717,8 +24850,8 @@ async function propagate(holosphere, holon, lens, data, options = {}) {
   };
   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));
       }
@@ -24730,17 +24863,17 @@ async function propagate(holosphere, holon, lens, data, options = {}) {
             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;
@@ -24750,7 +24883,8 @@ async function propagate(holosphere, holon, lens, data, options = {}) {
                 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);
@@ -24835,6 +24969,7 @@ async function propagate(holosphere, holon, lens, data, options = {}) {
           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;
@@ -24847,8 +24982,9 @@ async function propagate(holosphere, holon, lens, data, options = {}) {
                   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);
@@ -24963,60 +25099,64 @@ async function resetFederation(holosphere, spaceId, password = null, options = {
         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;
@@ -25031,7 +25171,6 @@ async function resetFederation(holosphere, spaceId, password = null, options = {
 }
 
 // schema.js
-var import__ = __toESM(require__(), 1);
 async function setSchema(holoInstance, lens, schema) {
   if (!lens || !schema) {
     throw new Error("setSchema: Missing required parameters");
@@ -25113,6 +25252,45 @@ function clearSchemaCache(holoInstance, lens = null) {
 }
 
 // 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");
@@ -25210,10 +25388,16 @@ async function put(holoInstance, holon, lens, data, password = null, options = {
     }
     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) {
@@ -25503,7 +25687,8 @@ async function getAll(holoInstance, holon, lens, password = null) {
       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;
@@ -25520,72 +25705,75 @@ async function getAll(holoInstance, holon, lens, password = null) {
           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);
@@ -26064,6 +26252,9 @@ async function putGlobal(holoInstance, tableName, data, password = null) {
         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);
@@ -26264,7 +26455,8 @@ async function getAllGlobal(holoInstance, tableName, password = null) {
       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;
@@ -26281,52 +26473,55 @@ async function getAllGlobal(holoInstance, tableName, password = null) {
           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);
@@ -26616,116 +26811,6 @@ async function subscribeGlobal(holoInstance, tableName, key, callback, options =
   };
 }
 
-// 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;
@@ -30199,7 +30284,7 @@ var HoloSphere = class {
       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
@@ -30351,6 +30436,9 @@ var HoloSphere = class {
   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);
@@ -30393,41 +30481,37 @@ var HoloSphere = class {
     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.