@xyo-network/os-runtime 4.1.1 → 4.1.3

package/dist/node/index.mjs

@@ -1,9 +1,15 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/access-interfaces/registered-names/helpers/AccessNodeQueries.ts
 import { assertEx as assertEx25 } from "@xylabs/assert";
 import { asArchivistInstance as asArchivistInstance7 } from "@xyo-network/archivist-model";
 
 // src/classes/cache/RunningAccessDappCache.ts
 var RunningDappAccessCache = class {
+  static {
+    __name(this, "RunningDappAccessCache");
+  }
   static _cache = {};
   static get(key) {
     return this._cache[key];
@@ -43,6 +49,10 @@ var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
 var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
 var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
 var OsCallerBase = class {
+  static {
+    __name(this, "OsCallerBase");
+  }
+  context;
   constructor(context) {
     this.context = context;
   }
@@ -53,47 +63,38 @@ var OsCallerBase = class {
   }
   // Get the dapps archivist development
   async getDappsArchivistDevelopment() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
-      () => `${DappsArchivistDevelopmentModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistDevelopmentModuleName), () => `${DappsArchivistDevelopmentModuleName} not found`);
     return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`);
   }
   // Get the dapps archivist payload diviner
   async getDappsArchivistPayloadDiviner() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
-      () => `${DappsArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName), () => `${DappsArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`);
   }
   // Get the dapps archivist payload diviner development
   async getDappsArchivistPayloadDivinerDevelopment() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
-      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName), () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`);
     return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`);
   }
   // Get the registered dapp interfaces archivist
   async getRegisteredDappInterfacesArchivist() {
-    const mod = assertEx(
-      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
-      () => `${RegisteredDappInterfacesArchivistModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName), () => `${RegisteredDappInterfacesArchivistModuleName} not found`);
     return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`);
   }
 };
 
 // src/classes/dapp/access/Caller.ts
 var DappAccessCaller = class extends OsCallerBase {
+  static {
+    __name(this, "DappAccessCaller");
+  }
+  registeredDapps;
+  allowedNames;
+  xnsNodeUrl;
+  xnsNetwork;
+  platformLocator;
   constructor(context, registeredDapps, allowedNames, xnsNodeUrl, xnsNetwork, platformLocator = new ModuleFactoryLocator()) {
-    super(context);
-    this.registeredDapps = registeredDapps;
-    this.allowedNames = allowedNames;
-    this.xnsNodeUrl = xnsNodeUrl;
-    this.xnsNetwork = xnsNetwork;
-    this.platformLocator = platformLocator;
+    super(context), this.registeredDapps = registeredDapps, this.allowedNames = allowedNames, this.xnsNodeUrl = xnsNodeUrl, this.xnsNetwork = xnsNetwork, this.platformLocator = platformLocator;
   }
   async start() {
     const registeredDappAccessDappSets = this.registeredDapps.filter(isRegisteredDappAccessDappSet);
@@ -119,9 +120,13 @@ var DappAccessCaller = class extends OsCallerBase {
   async saveRegisteredDappInterfaces(registeredDappAccess) {
     const archivist = await this.getRegisteredDappInterfacesArchivist();
     const hash = await PayloadBuilder.dataHash(registeredDappAccess);
-    const [existing] = await archivist.get([hash]);
+    const [existing] = await archivist.get([
+      hash
+    ]);
     if (existing) return;
-    await archivist.insert([registeredDappAccess]);
+    await archivist.insert([
+      registeredDappAccess
+    ]);
     console.debug("[DEBUG] -", `Registered ${registeredDappAccess.registeringDappId} with ${registeredDappAccess.name} interface`);
   }
 };
@@ -135,9 +140,13 @@ var DappAccessRequestQueries = {
     const query = {
       limit: 1,
       schema: PayloadDivinerQuerySchema,
-      schemas: [DappAccessRequestSchema]
+      schemas: [
+        DappAccessRequestSchema
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     if (results.length === 0) {
       return noResults;
     }
@@ -147,9 +156,13 @@ var DappAccessRequestQueries = {
     const query = {
       limit: 1,
       schema: PayloadDivinerQuerySchema,
-      schemas: [RegisteredDappAccessSchema]
+      schemas: [
+        RegisteredDappAccessSchema
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     if (results.length === 0) {
       return noResults;
     }
@@ -171,42 +184,37 @@ var IntentArchivistModuleName = "IntentArchivist";
 var IntentArchivistPayloadDivinerModuleName = "IntentArchivistPayloadDiviner";
 var DappArchivistPayloadDivinerModuleName = "DappArchivistPayloadDiviner";
 var DappCallerBase = class {
+  static {
+    __name(this, "DappCallerBase");
+  }
+  context;
   constructor(context) {
     this.context = context;
   }
   /**
-   * Get the DappArchivist
-   */
+  * Get the DappArchivist
+  */
   async getDappArchivist() {
-    const mod = assertEx3(
-      await this.context.root.resolve(DappArchivistModuleName),
-      () => `${DappArchivistModuleName} not found [${toJsonString(this.context.root.publicChildren())}]`
-    );
+    const mod = assertEx3(await this.context.root.resolve(DappArchivistModuleName), () => `${DappArchivistModuleName} not found [${toJsonString(this.context.root.publicChildren())}]`);
     return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`);
   }
   /**
-   * Get the DappArchivistPayloadDiviner
-   */
+  * Get the DappArchivistPayloadDiviner
+  */
   async getDappArchivistPayloadDiviner() {
-    const mod = assertEx3(
-      await this.context.root.resolve(DappArchivistPayloadDivinerModuleName),
-      () => `${DappArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx3(await this.context.root.resolve(DappArchivistPayloadDivinerModuleName), () => `${DappArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`);
   }
   /**
-   * Get the IntentArchivist
-   */
+  * Get the IntentArchivist
+  */
   async getDappIntentArchivist() {
     const mod = assertEx3(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`);
     return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`);
   }
   // Get the IntentArchivistPayloadDiviner
   async getDappIntentArchivistPayloadDiviner() {
-    const mod = assertEx3(
-      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
-      () => `${IntentArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx3(await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName), () => `${IntentArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`);
   }
 };
@@ -215,36 +223,38 @@ var DappCallerBase = class {
 import { asDivinerInstance as asDivinerInstance3 } from "@xyo-network/diviner-model";
 import { ResolveHelper } from "@xyo-network/module-model";
 import { NameRegistrarTransformer } from "@xyo-network/module-resolver";
-var initializeXns = async (xnsNode) => {
+var initializeXns = /* @__PURE__ */ __name(async (xnsNode) => {
   if (ResolveHelper.transformers.length === 0) {
     const registrarDiviner = asDivinerInstance3(await xnsNode?.resolve("AddressRecords:AddressRecordIndexDiviner"));
     if (registrarDiviner) {
       const transformer = new NameRegistrarTransformer(registrarDiviner, "xyo");
-      ResolveHelper.transformers = [transformer];
+      ResolveHelper.transformers = [
+        transformer
+      ];
       return true;
     }
   }
   return false;
-};
+}, "initializeXns");
 
 // src/lib/isPayload.ts
 import { AsObjectFactory } from "@xylabs/object";
-var isObject = (x) => {
+var isObject = /* @__PURE__ */ __name((x) => {
   return typeof x === "object" && !Array.isArray(x);
-};
-var isAnyPayload = (obj) => {
+}, "isObject");
+var isAnyPayload = /* @__PURE__ */ __name((obj) => {
   if (isObject(obj)) {
     return typeof obj.schema === "string";
   }
   return false;
-};
-var isPayload = (schema) => (obj) => {
+}, "isAnyPayload");
+var isPayload = /* @__PURE__ */ __name((schema) => (obj) => {
   if (isAnyPayload(obj)) {
     return schema.includes(obj.schema);
   }
   return false;
-};
-var asPayload = (schema) => AsObjectFactory.create(isPayload(schema));
+}, "isPayload");
+var asPayload = /* @__PURE__ */ __name((schema) => AsObjectFactory.create(isPayload(schema)), "asPayload");
 
 // src/lib/ModuleNames.ts
 var DevelopArchivist = "DevelopArchivist";
@@ -252,9 +262,15 @@ var NodeSentinel = "NodeSentinel";
 
 // src/lib/ModuleAccountPaths.ts
 var RemoteNodeArchivistOffsetPaths = {
-  Kerplunk: { [DevelopArchivist]: "118" },
-  Local: { [DevelopArchivist]: "115" },
-  Main: { [DevelopArchivist]: "121" }
+  Kerplunk: {
+    [DevelopArchivist]: "118"
+  },
+  Local: {
+    [DevelopArchivist]: "115"
+  },
+  Main: {
+    [DevelopArchivist]: "121"
+  }
 };
 var ModuleOffsetPaths = {
   IdWitness: "1",
@@ -274,6 +290,10 @@ var ModuleOffsetPaths = {
 
 // src/lib/NameTransforms.ts
 var NameTransforms = class _NameTransforms {
+  static {
+    __name(this, "NameTransforms");
+  }
+  value;
   constructor(value) {
     this.value = value;
   }
@@ -299,32 +319,36 @@ var NameTransforms = class _NameTransforms {
 
 // src/lib/PayloadStore.ts
 var PayloadStore = class {
+  static {
+    __name(this, "PayloadStore");
+  }
+  archivist;
+  latest;
+  deleteListeners;
+  insertListeners;
+  listeners;
   constructor(archivist) {
     this.archivist = archivist;
+    this.latest = [];
+    this.deleteListeners = [];
+    this.insertListeners = [];
+    this.listeners = [];
   }
-  latest = [];
-  deleteListeners = [];
-  insertListeners = [];
-  listeners = [];
   /**
-   * Initialize listeners on the archivist that update class member variables when new payloads are inserted
-   */
-  static async create({
-    archivist,
-    getLatest,
-    idFunction
-  }) {
+  * Initialize listeners on the archivist that update class member variables when new payloads are inserted
+  */
+  static async create({ archivist, getLatest, idFunction }) {
     const instance = new this(archivist);
-    const insertListener = async ({ payloads }) => {
+    const insertListener = /* @__PURE__ */ __name(async ({ payloads }) => {
       if (payloads.some(idFunction)) {
         instance.latest = await getLatest();
         instance.emitChange();
       }
-    };
-    const deleteListener = async () => {
+    }, "insertListener");
+    const deleteListener = /* @__PURE__ */ __name(async () => {
       instance.latest = await getLatest();
       instance.emitChange();
-    };
+    }, "deleteListener");
     const weakRefInsertListener = new WeakRef(insertListener);
     const weakRefDeleteListener = new WeakRef(deleteListener);
     const insertListenerRef = weakRefInsertListener.deref();
@@ -337,8 +361,8 @@ var PayloadStore = class {
     return instance;
   }
   /**
-   * Remove all listeners and reset their class members
-   */
+  * Remove all listeners and reset their class members
+  */
   cleanupListeners() {
     this.removeListeners(this.insertListeners, "inserted");
     this.removeListeners(this.deleteListeners, "deleted");
@@ -346,16 +370,16 @@ var PayloadStore = class {
     this.deleteListeners = [];
   }
   /**
-   * Get the current value of the store
-   */
+  * Get the current value of the store
+  */
   getSnapshot() {
     return this.latest;
   }
   /**
-   * Add a call back function that is invoked when new Payloads are inserted
-   *
-   * @param  {PayloadListener} onStoreChange
-   */
+  * Add a call back function that is invoked when new Payloads are inserted
+  *
+  * @param  {PayloadListener} onStoreChange
+  */
   subscribe(onStoreChange) {
     this.listeners.push(onStoreChange);
     return () => {
@@ -378,23 +402,29 @@ var PayloadStore = class {
 
 // src/lib/tokenPlacesSplit.ts
 import { assertEx as assertEx4 } from "@xylabs/assert";
-var tokenPlacesSplit = (value, places) => {
+var tokenPlacesSplit = /* @__PURE__ */ __name((value, places) => {
   assertEx4(places >= 0, () => "Places has to be >= 0");
   const factor = BigInt(10 ** Math.abs(places));
   const remainder = value % factor;
   const wholeValue = value / factor;
-  return [wholeValue, remainder];
-};
-var tokenPlacesSplitString = (value, places) => {
+  return [
+    wholeValue,
+    remainder
+  ];
+}, "tokenPlacesSplit");
+var tokenPlacesSplitString = /* @__PURE__ */ __name((value, places) => {
   if (value === void 0) {
     return "-";
   }
   const [wholeValue, remainder] = tokenPlacesSplit(value, places);
   return `${wholeValue}.${remainder.toString().padStart(Math.abs(places), "0")}`;
-};
+}, "tokenPlacesSplitString");
 
 // src/classes/dapp/access/Resource.ts
 var DappAccessRequestResource = class extends DappCallerBase {
+  static {
+    __name(this, "DappAccessRequestResource");
+  }
   _accessRequestListener;
   _registeredInterfacesListener;
   constructor(context) {
@@ -408,14 +438,14 @@ var DappAccessRequestResource = class extends DappCallerBase {
   }
   get subscriptions() {
     return {
-      accessRequests: (cb) => this.accessRequestListener.subscribe(cb),
-      registeredInterfaces: (cb) => this.registeredInterfacesListener.subscribe(cb)
+      accessRequests: /* @__PURE__ */ __name((cb) => this.accessRequestListener.subscribe(cb), "accessRequests"),
+      registeredInterfaces: /* @__PURE__ */ __name((cb) => this.registeredInterfacesListener.subscribe(cb), "registeredInterfaces")
     };
   }
   get views() {
     return {
-      accessRequests: () => this.accessRequestListener.getSnapshot(),
-      registeredInterfaces: () => this.registeredInterfacesListener.getSnapshot()
+      accessRequests: /* @__PURE__ */ __name(() => this.accessRequestListener.getSnapshot(), "accessRequests"),
+      registeredInterfaces: /* @__PURE__ */ __name(() => this.registeredInterfacesListener.getSnapshot(), "registeredInterfaces")
     };
   }
   cleanupListeners() {
@@ -427,12 +457,12 @@ var DappAccessRequestResource = class extends DappCallerBase {
     const diviner = await this.getDappArchivistPayloadDiviner();
     this._accessRequestListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await DappAccessRequestQueries.getAccessRequests(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappAccessRequestQueries.getAccessRequests(diviner), "getLatest"),
       idFunction: isDappAccessRequestWithMeta
     });
     this._registeredInterfacesListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await DappAccessRequestQueries.getRegisteredInterfaces(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappAccessRequestQueries.getRegisteredInterfaces(diviner), "getLatest"),
       idFunction: isRegisteredDappAccess
     });
   }
@@ -451,24 +481,35 @@ var DappDefaultsResourceQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema2,
-      schemas: [DappInjectableParamsSchema],
+      schemas: [
+        DappInjectableParamsSchema
+      ],
       source: "route"
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   },
   async getNodeOsInfo(diviner) {
     const query = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema2,
-      schemas: [NodeOsInfoSchema]
+      schemas: [
+        NodeOsInfoSchema
+      ]
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   }
 };
 
 // src/classes/dapp/DefaultsResource.ts
 var DappDefaultsResource = class extends DappCallerBase {
+  static {
+    __name(this, "DappDefaultsResource");
+  }
   _dappInjectableParamsFromRouteListener;
   _nodeOsInfoListener;
   constructor(context) {
@@ -482,14 +523,14 @@ var DappDefaultsResource = class extends DappCallerBase {
   }
   get subscriptions() {
     return {
-      dappInjectableParamsFromRoute: (cb) => this.dappInjectableParamsFromRouteListener.subscribe(cb),
-      nodeOsInfo: (cb) => this.nodeOsInfoListener.subscribe(cb)
+      dappInjectableParamsFromRoute: /* @__PURE__ */ __name((cb) => this.dappInjectableParamsFromRouteListener.subscribe(cb), "dappInjectableParamsFromRoute"),
+      nodeOsInfo: /* @__PURE__ */ __name((cb) => this.nodeOsInfoListener.subscribe(cb), "nodeOsInfo")
     };
   }
   get views() {
     return {
-      dappInjectableParamsFromRoute: () => this.dappInjectableParamsFromRouteListener.getSnapshot(),
-      nodeOsInfo: () => this.nodeOsInfoListener.getSnapshot()
+      dappInjectableParamsFromRoute: /* @__PURE__ */ __name(() => this.dappInjectableParamsFromRouteListener.getSnapshot(), "dappInjectableParamsFromRoute"),
+      nodeOsInfo: /* @__PURE__ */ __name(() => this.nodeOsInfoListener.getSnapshot(), "nodeOsInfo")
     };
   }
   cleanupListeners() {
@@ -500,57 +541,51 @@ var DappDefaultsResource = class extends DappCallerBase {
     const diviner = await this.getDappArchivistPayloadDiviner();
     this._nodeOsInfoListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner), "getLatest"),
       idFunction: isNodeOsInfo
     });
     this._dappInjectableParamsFromRouteListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner), "getLatest"),
       idFunction: isDappInjectableParams
     });
   }
 };
 
 // src/classes/lib/Insertable.ts
-var createInsertable = (insertable, ...params) => new insertable(...params);
+var createInsertable = /* @__PURE__ */ __name((insertable, ...params) => new insertable(...params), "createInsertable");
 
 // src/classes/menu/Caller.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema5 } from "@xyo-network/diviner-payload-model";
-import {
-  DappInjectableParamsSchema as DappInjectableParamsSchema3,
-  DappNavItemSelectionSchema
-} from "@xyo-network/os-model";
+import { DappInjectableParamsSchema as DappInjectableParamsSchema3, DappNavItemSelectionSchema } from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 
 // src/Caller.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema4 } from "@xyo-network/diviner-payload-model";
-import {
-  DappAccessRequestSchema as DappAccessRequestSchema2,
-  DappInjectableParamsSchema as DappInjectableParamsSchema2,
-  DappIntentTypes,
-  DappMode as DappMode2,
-  RegisteredDappAccessSchema as RegisteredDappAccessSchema2
-} from "@xyo-network/os-model";
+import { DappAccessRequestSchema as DappAccessRequestSchema2, DappInjectableParamsSchema as DappInjectableParamsSchema2, DappIntentTypes, DappMode as DappMode2, RegisteredDappAccessSchema as RegisteredDappAccessSchema2 } from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 
 // src/intent/Caller.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema3 } from "@xyo-network/diviner-payload-model";
 import { DappIntentSchema, DappMode } from "@xyo-network/os-model";
 var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
+  static {
+    __name(this, "DappIntentCaller");
+  }
   static OsDappName = "XyOs";
   constructor(context) {
     super(context);
   }
   /**
-   * Build a new intent
-   * @param  {DappId} sourceDappId
-   * @param  {DappIntentTypes} intent
-   * @param  {DappId} targetDappId
-   * @param  {DappMode} targetMode
-   * @param  {DappIntent['params']} params?
-   * @returns DappIntent
-   */
+  * Build a new intent
+  * @param  {DappId} sourceDappId
+  * @param  {DappIntentTypes} intent
+  * @param  {DappId} targetDappId
+  * @param  {DappMode} targetMode
+  * @param  {DappIntent['params']} params?
+  * @returns DappIntent
+  */
   static buildIntent(sourceDappId, intent, targetDappId, targetMode = DappMode.Window, params) {
     return {
       intent,
@@ -566,7 +601,9 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
   async addIntent(id, intent, mode) {
     const intentArchivist = await this.getDappIntentArchivist();
     const newIntent = _DappIntentCaller.buildIntent(id, intent, mode);
-    await intentArchivist.insert([newIntent]);
+    await intentArchivist.insert([
+      newIntent
+    ]);
   }
   // Get all intents
   async allIntents() {
@@ -587,7 +624,9 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
       schema: PayloadDivinerQuerySchema3,
       sourceDappId: dappName
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   }
 };
 
@@ -596,6 +635,9 @@ import { assertEx as assertEx7 } from "@xylabs/assert";
 import { isDappIntent } from "@xyo-network/os-model";
 var NO_RESULTS = [];
 var DappIntentResource = class extends DappCallerBase {
+  static {
+    __name(this, "DappIntentResource");
+  }
   _allDappIntents;
   _latestDappIntent;
   constructor(context) {
@@ -609,14 +651,14 @@ var DappIntentResource = class extends DappCallerBase {
   }
   get subscriptions() {
     return {
-      allDappIntents: (cb) => this.allDappIntents.subscribe(cb),
-      latestDappIntent: (cb) => this.latestDappIntent.subscribe(cb)
+      allDappIntents: /* @__PURE__ */ __name((cb) => this.allDappIntents.subscribe(cb), "allDappIntents"),
+      latestDappIntent: /* @__PURE__ */ __name((cb) => this.latestDappIntent.subscribe(cb), "latestDappIntent")
     };
   }
   get views() {
     return {
-      allDappIntents: () => this.allDappIntents.getSnapshot(),
-      latestDappIntent: () => this.latestDappIntent.getSnapshot()
+      allDappIntents: /* @__PURE__ */ __name(() => this.allDappIntents.getSnapshot(), "allDappIntents"),
+      latestDappIntent: /* @__PURE__ */ __name(() => this.latestDappIntent.getSnapshot(), "latestDappIntent")
     };
   }
   cleanupListeners() {
@@ -627,16 +669,18 @@ var DappIntentResource = class extends DappCallerBase {
     const archivist = await this.getDappIntentArchivist();
     this._allDappIntents = await PayloadStore.create({
       archivist,
-      getLatest: async () => await archivist.all(),
+      getLatest: /* @__PURE__ */ __name(async () => await archivist.all(), "getLatest"),
       idFunction: isDappIntent
     });
     this._latestDappIntent = await PayloadStore.create({
       archivist,
-      getLatest: async () => {
+      getLatest: /* @__PURE__ */ __name(async () => {
         const all = await archivist.all();
-        const result = all.length > 0 ? [all.at(-1)] : NO_RESULTS;
+        const result = all.length > 0 ? [
+          all.at(-1)
+        ] : NO_RESULTS;
         return result;
-      },
+      }, "getLatest"),
       idFunction: isDappIntent
     });
   }
@@ -644,14 +688,17 @@ var DappIntentResource = class extends DappCallerBase {
 
 // src/Caller.ts
 var DappCaller = class extends DappCallerBase {
+  static {
+    __name(this, "DappCaller");
+  }
   constructor(context) {
     super(context);
   }
   /**
-   * Add payloads to the dapp archivist
-   * @param  {Payload[]} payloads
-   * @param  {Boolean} force
-   */
+  * Add payloads to the dapp archivist
+  * @param  {Payload[]} payloads
+  * @param  {Boolean} force
+  */
   async addPayloadsToDappArchivist(payloads = [], force = false) {
     const dappArchivist = await this.getDappArchivist();
     if (force) {
@@ -659,19 +706,23 @@ var DappCaller = class extends DappCallerBase {
     } else {
       for (const payload of payloads) {
         const hash = await PayloadBuilder2.dataHash(payload);
-        const [existing] = await dappArchivist.get([hash]);
+        const [existing] = await dappArchivist.get([
+          hash
+        ]);
         if (existing) continue;
-        await dappArchivist.insert([payload]);
+        await dappArchivist.insert([
+          payload
+        ]);
       }
     }
   }
   /**
-   * Build Access Request
-   * @param  {DappAccessRequest['mode']} mode
-   * @param  {Hash} registeredDappAccessHash
-   * @param  {string} requestingDappId
-   * @param  {string | undefined} destinationArchivist
-   */
+  * Build Access Request
+  * @param  {DappAccessRequest['mode']} mode
+  * @param  {Hash} registeredDappAccessHash
+  * @param  {string} requestingDappId
+  * @param  {string | undefined} destinationArchivist
+  */
   buildAccessRequest(mode, registeredDappAccessHash, requestingDappId, destinationArchivist) {
     const accessRequest = {
       destinationArchivist,
@@ -684,43 +735,51 @@ var DappCaller = class extends DappCallerBase {
     return accessRequest;
   }
   /**
-   * Get all available dapp access requests
-   */
+  * Get all available dapp access requests
+  */
   async getDappAccessPayloads() {
     const diviner = await this.getDappArchivistPayloadDiviner();
     const query = {
       order: "desc",
       schema: PayloadDivinerQuerySchema4,
-      schemas: [RegisteredDappAccessSchema2]
+      schemas: [
+        RegisteredDappAccessSchema2
+      ]
     };
-    return diviner.divine([query]);
+    return diviner.divine([
+      query
+    ]);
   }
   /**
-   * Get the most recent dapp injectable params
-   * @returns Promise
-   */
+  * Get the most recent dapp injectable params
+  * @returns Promise
+  */
   async getDappInjectableParams() {
     const diviner = await this.getDappArchivistPayloadDiviner();
     return await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner);
   }
   /**
-   * Get the most recent dapp intent
-   * @param  {string} name
-   */
+  * Get the most recent dapp intent
+  * @param  {string} name
+  */
   async getRegisteredDappAccessByName(name) {
     const diviner = await this.getDappArchivistPayloadDiviner();
     const query = {
       limit: 1,
       name,
       schema: PayloadDivinerQuerySchema4,
-      schemas: [RegisteredDappAccessSchema2]
+      schemas: [
+        RegisteredDappAccessSchema2
+      ]
     };
-    const [payload] = assertEx8(await diviner.divine([query]), () => "Unable to find registered dapp access");
+    const [payload] = assertEx8(await diviner.divine([
+      query
+    ]), () => "Unable to find registered dapp access");
     return payload;
   }
   /**
-   * Get the user wallet
-   */
+  * Get the user wallet
+  */
   getUserAccount(dappName) {
     const account = this.context.user.signers?.get(dappName);
     if (account) {
@@ -730,48 +789,56 @@ var DappCaller = class extends DappCallerBase {
     }
   }
   /**
-   * Get all wallets for the user
-   */
+  * Get all wallets for the user
+  */
   getUserAccountsAll() {
-    return [...this.context.user.signers?.values() ?? []];
+    return [
+      ...this.context.user.signers?.values() ?? []
+    ];
   }
   /**
-   * Make Dapp Access Request
-   * @param {string} requestingDappId
-   * @param {string} registeredDappAccessHash
-   * @param {string} mode
-   * @param {string} destinationArchivist
-   */
+  * Make Dapp Access Request
+  * @param {string} requestingDappId
+  * @param {string} registeredDappAccessHash
+  * @param {string} mode
+  * @param {string} destinationArchivist
+  */
   async makeDappAccessRequest(requestingDappId, registeredDappAccessHash, mode, destinationArchivist) {
     const archivist = await this.getDappArchivist();
-    const registeredDappAccessPayload = await archivist.get([registeredDappAccessHash]);
+    const registeredDappAccessPayload = await archivist.get([
+      registeredDappAccessHash
+    ]);
     if (!registeredDappAccessPayload) {
       throw new Error("No registered dapp access found");
     }
     const accessRequest = this.buildAccessRequest(mode, registeredDappAccessHash, requestingDappId, destinationArchivist);
-    await archivist.insert([accessRequest]);
+    await archivist.insert([
+      accessRequest
+    ]);
   }
   /**
-   * Make Dapp Intent Request
-   * @param  {DappId} sourceDappId
-   * @param  {DappId} targetDappId
-   * @param  {DappIntentTypes=DappIntentTypes.Launch} intent
-   * @param  {DappIntent['params']} mode
-   */
+  * Make Dapp Intent Request
+  * @param  {DappId} sourceDappId
+  * @param  {DappId} targetDappId
+  * @param  {DappIntentTypes=DappIntentTypes.Launch} intent
+  * @param  {DappIntent['params']} mode
+  */
   async makeDappIntentRequest(sourceDappId, targetDappId, intent = DappIntentTypes.Launch, mode = DappMode2.Window, params) {
     if (!sourceDappId) {
       throw new Error("No source dapp id provided, dApps must declare a sourceDappId");
     }
     const archivist = await this.getDappArchivist();
     const dappIntent = DappIntentCaller.buildIntent(sourceDappId, intent, targetDappId, mode, params);
-    return await archivist.insert([dappIntent]);
+    return await archivist.insert([
+      dappIntent
+    ]);
   }
   /**
-   * Set the dapp injectable params
-   *
-   * @param  {URLSearchParams} searchParams
-   * @param  {string} pathname
-   */
+  * Set the dapp injectable params
+  *
+  * @param  {URLSearchParams} searchParams
+  * @param  {string} pathname
+  */
   async setDappInjectableRouteParams(searchParams = new URLSearchParams(), pathname) {
     const dappArchivist = await this.getDappArchivist();
     const params = {};
@@ -785,25 +852,32 @@ var DappCaller = class extends DappCallerBase {
       source: "route",
       timestamp: Date.now()
     };
-    await dappArchivist.insert([payload]);
+    await dappArchivist.insert([
+      payload
+    ]);
   }
 };
 
 // src/classes/menu/Caller.ts
 var DappMenuCaller = class extends DappCaller {
+  static {
+    __name(this, "DappMenuCaller");
+  }
   constructor(context) {
     super(context);
   }
   /**
-   * Add new Payloads to the dappArchivist if they haven't already
-   *
-   * @param  {Payload[]} payloads
-   */
+  * Add new Payloads to the dappArchivist if they haven't already
+  *
+  * @param  {Payload[]} payloads
+  */
   async add(payloads, force = false) {
     const dappArchivist = await this.getDappArchivist();
     for (const payload of payloads) {
       const hash = await PayloadBuilder3.dataHash(payload);
-      const [existing] = await dappArchivist.get([hash]);
+      const [existing] = await dappArchivist.get([
+        hash
+      ]);
       if (!existing || force) {
         await dappArchivist.insert(payloads);
       }
@@ -815,17 +889,21 @@ var DappMenuCaller = class extends DappCaller {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema5,
-      schemas: [DappNavItemSelectionSchema]
+      schemas: [
+        DappNavItemSelectionSchema
+      ]
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   }
   /*
-   * Indicate to the system that a nav item was selected
-   *
-   * @param  {string} path
-   * @params {string} injectableParamsPath
-   * @returns Promise
-   */
+  * Indicate to the system that a nav item was selected
+  *
+  * @param  {string} path
+  * @params {string} injectableParamsPath
+  * @returns Promise
+  */
   async makeNavItemSelection(path, injectableParamsPath) {
     const dappArchivist = await this.getDappArchivist();
     const payload = {
@@ -833,7 +911,9 @@ var DappMenuCaller = class extends DappCaller {
       schema: DappNavItemSelectionSchema,
       timestamp: Date.now()
     };
-    await dappArchivist.insert([payload]);
+    await dappArchivist.insert([
+      payload
+    ]);
     if (injectableParamsPath) {
       const injectableParams = {
         params: {},
@@ -842,7 +922,9 @@ var DappMenuCaller = class extends DappCaller {
         source: "route",
         timestamp: Date.now()
       };
-      await dappArchivist.insert([injectableParams]);
+      await dappArchivist.insert([
+        injectableParams
+      ]);
     }
   }
 };
@@ -853,11 +935,7 @@ import { isDappNavItemSelection, isDappNavMenuConfig } from "@xyo-network/os-mod
 
 // src/classes/menu/Queries.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema6 } from "@xyo-network/diviner-payload-model";
-import {
-  DappNavItemSchema,
-  DappNavItemSelectionSchema as DappNavItemSelectionSchema2,
-  DappNavMenuConfigSchema
-} from "@xyo-network/os-model";
+import { DappNavItemSchema, DappNavItemSelectionSchema as DappNavItemSelectionSchema2, DappNavMenuConfigSchema } from "@xyo-network/os-model";
 var NO_ITEMS = [];
 var DappMenuQueries = {
   async getMenuConfigs(diviner) {
@@ -865,17 +943,25 @@ var DappMenuQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema6,
-      schemas: [DappNavMenuConfigSchema]
+      schemas: [
+        DappNavMenuConfigSchema
+      ]
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   },
   async getMenuItems(diviner) {
     const query = {
       order: "desc",
       schema: PayloadDivinerQuerySchema6,
-      schemas: [DappNavItemSchema]
+      schemas: [
+        DappNavItemSchema
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     return results.length > 0 ? results : NO_ITEMS;
   },
   async getNavItemSelections(diviner) {
@@ -883,24 +969,35 @@ var DappMenuQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema6,
-      schemas: [DappNavItemSelectionSchema2]
+      schemas: [
+        DappNavItemSelectionSchema2
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     return results.length > 0 ? results : NO_ITEMS;
   },
   async getVisibleMenuItems(diviner) {
     const query = {
       order: "desc",
       schema: PayloadDivinerQuerySchema6,
-      schemas: [DappNavItemSchema]
+      schemas: [
+        DappNavItemSchema
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     return results.filter((menuItem) => menuItem.hidden !== true).sort((a, b) => (a.weight ?? 0) > (b.weight ?? 0) ? 1 : -1);
   }
 };
 
 // src/classes/menu/Resource.ts
 var DappMenuResource = class extends DappCaller {
+  static {
+    __name(this, "DappMenuResource");
+  }
   _menuConfigListener;
   _menuItemListener;
   _menuItemSelectionListener;
@@ -923,55 +1020,55 @@ var DappMenuResource = class extends DappCaller {
   /** subscribe to latest set of payloads */
   get subscriptions() {
     return {
-      menuConfigs: (cb) => this.menuConfigListener.subscribe(cb),
-      menuItemSelections: (cb) => this.menuItemSelectionListener.subscribe(cb),
-      menuItems: (cb) => this.menuItemListener.subscribe(cb),
-      menuItemsVisible: (cb) => this.menuItemVisibleListener.subscribe(cb)
+      menuConfigs: /* @__PURE__ */ __name((cb) => this.menuConfigListener.subscribe(cb), "menuConfigs"),
+      menuItemSelections: /* @__PURE__ */ __name((cb) => this.menuItemSelectionListener.subscribe(cb), "menuItemSelections"),
+      menuItems: /* @__PURE__ */ __name((cb) => this.menuItemListener.subscribe(cb), "menuItems"),
+      menuItemsVisible: /* @__PURE__ */ __name((cb) => this.menuItemVisibleListener.subscribe(cb), "menuItemsVisible")
     };
   }
   /**
-   * Return the latest menu payloads from the repository
-   */
+  * Return the latest menu payloads from the repository
+  */
   get views() {
     return {
-      menuConfigs: () => this.menuConfigListener.getSnapshot(),
-      menuItemSelections: () => this.menuItemSelectionListener.getSnapshot(),
-      menuItems: () => this.menuItemListener.getSnapshot(),
-      menuItemsVisible: () => this.menuItemVisibleListener.getSnapshot()
+      menuConfigs: /* @__PURE__ */ __name(() => this.menuConfigListener.getSnapshot(), "menuConfigs"),
+      menuItemSelections: /* @__PURE__ */ __name(() => this.menuItemSelectionListener.getSnapshot(), "menuItemSelections"),
+      menuItems: /* @__PURE__ */ __name(() => this.menuItemListener.getSnapshot(), "menuItems"),
+      menuItemsVisible: /* @__PURE__ */ __name(() => this.menuItemVisibleListener.getSnapshot(), "menuItemsVisible")
     };
   }
   /**
-   * Remove all listeners and reset their class members
-   */
+  * Remove all listeners and reset their class members
+  */
   cleanupListeners() {
     this.menuConfigListener.cleanupListeners();
     this.menuItemListener.cleanupListeners();
     this.menuItemSelectionListener.cleanupListeners();
   }
   /**
-   * Start the resource
-   */
+  * Start the resource
+  */
   async start() {
     const dappArchivist = await this.getDappArchivist();
     const dappArchivistPayloadDiviner = await this.getDappArchivistPayloadDiviner();
     this._menuConfigListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner), "getLatest"),
       idFunction: isDappNavMenuConfig
     });
     this._menuItemListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner), "getLatest"),
       idFunction: isDappNavMenuConfig
     });
     this._menuItemVisibleListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner), "getLatest"),
       idFunction: isDappNavMenuConfig
     });
     this._menuItemSelectionListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner),
+      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner), "getLatest"),
       idFunction: isDappNavItemSelection
     });
   }
@@ -988,14 +1085,17 @@ import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema7 } from "@xyo-ne
 import { DappWalletSeedPhraseSchema } from "@xyo-network/os-model";
 import { v4 as uuid } from "uuid";
 var DappSeedPhraseRepository = class extends OsCallerBase {
-  constructor(xyOs, allowedNames) {
-    super(xyOs);
-    this.allowedNames = allowedNames;
+  static {
+    __name(this, "DappSeedPhraseRepository");
   }
+  allowedNames;
   // record of all dapps that have requested a seed phrase with the OS
-  dappIdRepository = /* @__PURE__ */ new Map();
+  dappIdRepository;
   // record of all walletIds that have been issued to registered dapps
-  walletIdRepository = /* @__PURE__ */ new Map();
+  walletIdRepository;
+  constructor(xyOs, allowedNames) {
+    super(xyOs), this.allowedNames = allowedNames, this.dappIdRepository = /* @__PURE__ */ new Map(), this.walletIdRepository = /* @__PURE__ */ new Map();
+  }
   async add(dappId) {
     const archivist = await this.getDappsArchivist();
     const seedPhrase = this.newPhrase();
@@ -1006,7 +1106,9 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       seedPhrase,
       walletId
     };
-    await archivist.insert([payload]);
+    await archivist.insert([
+      payload
+    ]);
     this.dappIdRepository.set(dappId, payload);
     this.walletIdRepository.set(walletId, payload);
     return walletId;
@@ -1038,9 +1140,13 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema7,
-      schemas: [DappWalletSeedPhraseSchema]
+      schemas: [
+        DappWalletSeedPhraseSchema
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     return results.length > 0 ? results[0] : void 0;
   }
   async checkWalletId(walletId) {
@@ -1049,10 +1155,14 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema7,
-      schemas: [DappWalletSeedPhraseSchema],
+      schemas: [
+        DappWalletSeedPhraseSchema
+      ],
       walletId
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     return results.length > 0 ? results[0] : void 0;
   }
   newPhrase() {
@@ -1068,7 +1178,9 @@ import { DappPackageManifestPayloadSchema } from "@xyo-network/manifest";
 
 // src/manifest/manifestReplacementTokens.ts
 import { getXnsDomain } from "@xyo-network/kernel";
-var manifestReplacementTokens = (xnsNodeUrl, xnsNetwork) => ({ "[REPLACE_WITH_NS_NODE_URL]": getXnsDomain(xnsNodeUrl, xnsNetwork) });
+var manifestReplacementTokens = /* @__PURE__ */ __name((xnsNodeUrl, xnsNetwork) => ({
+  "[REPLACE_WITH_NS_NODE_URL]": getXnsDomain(xnsNodeUrl, xnsNetwork)
+}), "manifestReplacementTokens");
 
 // src/manifest/os-node.manifest.json
 var os_node_manifest_default = {
@@ -1209,6 +1321,10 @@ import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder"
 
 // src/classes/node/DefaultPayloads/DappAccessPayloads.ts
 var DappAccessPayloads = class {
+  static {
+    __name(this, "DappAccessPayloads");
+  }
+  context;
   constructor(context, _dappName) {
     this.context = context;
   }
@@ -1222,6 +1338,10 @@ var DappAccessPayloads = class {
 // src/classes/node/DefaultPayloads/NodeInfoPayload.ts
 import { NodeOsInfoSchema as NodeOsInfoSchema2 } from "@xyo-network/os-model";
 var NodeInfoPayload = class {
+  static {
+    __name(this, "NodeInfoPayload");
+  }
+  _context;
   constructor(_context, _dappName) {
     this._context = _context;
   }
@@ -1237,19 +1357,30 @@ var NodeInfoPayload = class {
       publicAddress: exposedNode?.address ?? "",
       schema: NodeOsInfoSchema2
     };
-    return [nodeOsInfo];
+    return [
+      nodeOsInfo
+    ];
   }
 };
 
 // src/classes/node/DefaultPayloads/DefaultPayloads.ts
 var DefaultPayloads = class {
+  static {
+    __name(this, "DefaultPayloads");
+  }
+  dappArchivist;
+  xyOs;
+  dappName;
   constructor(dappArchivist, xyOs, dappName) {
     this.dappArchivist = dappArchivist;
     this.xyOs = xyOs;
     this.dappName = dappName;
   }
   async insert() {
-    const insertables = [NodeInfoPayload, DappAccessPayloads];
+    const insertables = [
+      NodeInfoPayload,
+      DappAccessPayloads
+    ];
     const insertPayloads = [];
     for (const insertable of insertables) {
       const classInstance = createInsertable(insertable, this.xyOs, this.dappName);
@@ -1257,16 +1388,32 @@ var DefaultPayloads = class {
       insertPayloads.push(...payloads);
     }
     for (const payload of insertPayloads) {
-      const [existing] = await this.dappArchivist.get([await PayloadBuilder4.dataHash(payload)]);
+      const [existing] = await this.dappArchivist.get([
+        await PayloadBuilder4.dataHash(payload)
+      ]);
       if (existing) continue;
-      await this.dappArchivist.insert([payload]);
+      await this.dappArchivist.insert([
+        payload
+      ]);
     }
   }
 };
 
 // src/classes/node/ExternalModulePermissions/ExternalModulePermissions.ts
-var ALLOWED_MODULES_FROM_PARENT = ["IntentArchivist", "OsSettingsNode", "OsPubSubNetworkStackNode", "OsXyoPublicNetworkStackNode"];
+var ALLOWED_MODULES_FROM_PARENT = [
+  "IntentArchivist",
+  "OsSettingsNode",
+  "OsPubSubNetworkStackNode",
+  "OsXyoPublicNetworkStackNode"
+];
 var ExternalModulePermissions = class {
+  static {
+    __name(this, "ExternalModulePermissions");
+  }
+  context;
+  dappWindowNode;
+  dappName;
+  externalPermissions;
   constructor(context, dappWindowNode, dappName, externalPermissions) {
     this.context = context;
     this.dappWindowNode = dappWindowNode;
@@ -1303,6 +1450,17 @@ var ExternalModulePermissions = class {
 
 // src/classes/node/Creator.ts
 var DappContextCreator = class _DappContextCreator {
+  static {
+    __name(this, "DappContextCreator");
+  }
+  targetDappManifestParams;
+  dappId;
+  context;
+  rootWallet;
+  externalPermissions;
+  sharedLocator;
+  // Designated offset path for the wallet used by windowed dapps. In the future, other offsets could be used for other dapp modes
+  static DAPP_WINDOW_WALLET_PATH = "1";
   constructor(targetDappManifestParams, dappId, context, rootWallet, externalPermissions, sharedLocator) {
     this.targetDappManifestParams = targetDappManifestParams;
     this.dappId = dappId;
@@ -1311,25 +1469,19 @@ var DappContextCreator = class _DappContextCreator {
     this.externalPermissions = externalPermissions;
     this.sharedLocator = sharedLocator;
   }
-  // Designated offset path for the wallet used by windowed dapps. In the future, other offsets could be used for other dapp modes
-  static DAPP_WINDOW_WALLET_PATH = "1";
   static async create(params, xnsNodeUrl, xnsNetwork) {
-    const {
-      config,
-      locator,
-      context,
-      wallet
-    } = params;
-    const {
-      payload,
-      dappName,
-      publicChildren,
-      privateChildren
-    } = config;
+    const { config, locator, context, wallet } = params;
+    const { payload, dappName, publicChildren, privateChildren } = config;
     const { external, manifestPayload } = this.parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork);
     console.debug("[DEBUG] dApp manifest", manifestPayload);
     const dappWallet = await wallet.derivePath(_DappContextCreator.DAPP_WINDOW_WALLET_PATH);
-    const targetDappManifestParams = [manifestPayload, dappWallet, locator, publicChildren, privateChildren];
+    const targetDappManifestParams = [
+      manifestPayload,
+      dappWallet,
+      locator,
+      publicChildren,
+      privateChildren
+    ];
     const instance = new this(targetDappManifestParams, dappName, context, wallet, external?.modules, locator);
     return instance;
   }
@@ -1354,7 +1506,10 @@ var DappContextCreator = class _DappContextCreator {
     };
     console.log("DappContextCreator:parseDappPackageManifestPayload", xnsNodeUrl, xnsNetwork);
     const manifestPayload = replaceManifestTokens(manifestPayloadRaw, manifestReplacementTokens(xnsNodeUrl, xnsNetwork));
-    return { external, manifestPayload };
+    return {
+      external,
+      manifestPayload
+    };
   }
   async loadDappContext(context) {
     console.log("DappNodesCreator:loadDappContext", this.dappId);
@@ -1375,13 +1530,15 @@ var DappContextCreator = class _DappContextCreator {
 };
 
 // src/classes/node/createDappContext.ts
-var GenericPayloadDivinerTags = { "network.xyo.generic.payload.diviner": "GenericPayloadDiviner" };
-var resolveLocator = (existingLocator) => {
+var GenericPayloadDivinerTags = {
+  "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
+};
+var resolveLocator = /* @__PURE__ */ __name((existingLocator) => {
   const locator = existingLocator ?? new ModuleFactoryLocator2();
   locator.register(GenericPayloadDiviner, GenericPayloadDivinerTags);
   return locator;
-};
-var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwork) => {
+}, "resolveLocator");
+var createDappContext = /* @__PURE__ */ __name(async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwork) => {
   console.log("createNodes");
   try {
     const dappSeedPhraseRepository = new DappSeedPhraseRepository(context, allowedNames);
@@ -1394,7 +1551,10 @@ var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwo
     const { config: dappConfig, params: dappParams } = dapp;
     const locator = resolveLocator((dappParams.locator ?? new ModuleFactoryLocator2()).merge(context.platformLocator));
     const params = {
-      config: { dappName, payload: dappConfig.manifest },
+      config: {
+        dappName,
+        payload: dappConfig.manifest
+      },
       context,
       locator,
       wallet
@@ -1411,23 +1571,21 @@ var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwo
     console.error(`Error creating dappWindow node: ${error.stack}`);
     throw new Error(`Error creating dappWindow node: ${error.message}`);
   }
-};
+}, "createDappContext");
 
 // src/classes/registration/DappRegistrationService.ts
 import { forget as forget2 } from "@xylabs/forget";
 import { fulfilled, rejected } from "@xylabs/promise";
 import { ModuleFactoryLocator as ModuleFactoryLocator5 } from "@xyo-network/module-factory-locator";
-import {
-  DappIntentTypes as DappIntentTypes2,
-  DappMode as DappMode3,
-  isRegisteredDappAccessDappSet as isRegisteredDappAccessDappSet2,
-  isRegisteredDappExposedDappSet
-} from "@xyo-network/os-model";
+import { DappIntentTypes as DappIntentTypes2, DappMode as DappMode3, isRegisteredDappAccessDappSet as isRegisteredDappAccessDappSet2, isRegisteredDappExposedDappSet } from "@xyo-network/os-model";
 
 // src/event/bus/Connection.ts
 import { assertEx as assertEx11 } from "@xylabs/assert";
 import { BaseEmitter } from "@xyo-network/module-event-emitter";
 var EventBusConnection = class extends BaseEmitter {
+  static {
+    __name(this, "EventBusConnection");
+  }
   _id;
   description;
   type;
@@ -1447,19 +1605,15 @@ var EventBusConnection = class extends BaseEmitter {
 // src/event/bus/EventBus.ts
 import { assertEx as assertEx12 } from "@xylabs/assert";
 import { forget } from "@xylabs/forget";
-import {
-  asArchivistInstance as asArchivistInstance4,
-  MemoryArchivist,
-  MemoryArchivistConfigSchema
-} from "@xyo-network/archivist";
-import {
-  isEventBusEvent,
-  isPubSubConnections
-} from "@xyo-network/os-model";
+import { asArchivistInstance as asArchivistInstance4, MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist";
+import { isEventBusEvent, isPubSubConnections } from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { Mutex } from "async-mutex";
 import { v4 as uuid2 } from "uuid";
 var EventBus = class {
+  static {
+    __name(this, "EventBus");
+  }
   // Internal Archivist to store event data
   _archivist;
   // Store all connections
@@ -1468,10 +1622,7 @@ var EventBus = class {
   publisherCallbacks = {};
   startMutex = new Mutex();
   get archivist() {
-    return asArchivistInstance4(
-      assertEx12(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
-      "not a valid archivist instance"
-    );
+    return asArchivistInstance4(assertEx12(this._archivist, () => "Archivist not found.  Did you forget to call start()?"), "not a valid archivist instance");
   }
   addConnection(connection) {
     const id = uuid2();
@@ -1500,7 +1651,12 @@ var EventBus = class {
         console.warn("EventBus already started");
         return this;
       }
-      this._archivist = await MemoryArchivist.create({ config: { name: storeName, schema: MemoryArchivistConfigSchema } });
+      this._archivist = await MemoryArchivist.create({
+        config: {
+          name: storeName,
+          schema: MemoryArchivistConfigSchema
+        }
+      });
       this.archivist.on("inserted", ({ payloads }) => {
         const eventBusEvent = payloads.find(isEventBusEvent);
         if (!eventBusEvent) return;
@@ -1510,7 +1666,9 @@ var EventBus = class {
             for (const [eventName, callback] of connection.subscribableEvents.entries()) {
               if (eventName !== eventBusEvent.name) continue;
               if (callback) {
-                const forgettable = async () => await callback({ payloads });
+                const forgettable = /* @__PURE__ */ __name(async () => await callback({
+                  payloads
+                }), "forgettable");
                 forget(forgettable());
               }
             }
@@ -1522,16 +1680,22 @@ var EventBus = class {
   }
   handlePublisherAdd(connection) {
     for (const eventName of connection.publishableEvents ?? []) {
-      const connectionPublisherCallback = async ({ payloads }) => {
-        const event = { name: eventName, schema: "network.xyo.event.bus.event" };
+      const connectionPublisherCallback = /* @__PURE__ */ __name(async ({ payloads }) => {
+        const event = {
+          name: eventName,
+          schema: "network.xyo.event.bus.event"
+        };
         const eventPayloads = payloads ?? [];
         event.sources = await PayloadBuilder5.dataHashes(eventPayloads);
         try {
-          await this.archivist.insert([event, ...payloads ?? []]);
+          await this.archivist.insert([
+            event,
+            ...payloads ?? []
+          ]);
         } catch (e) {
           console.error("Error inserting event into archivist", e);
         }
-      };
+      }, "connectionPublisherCallback");
       connection.on(eventName, connectionPublisherCallback);
       const callbackId = connection.id + eventName;
       this.publisherCallbacks[callbackId] = connectionPublisherCallback;
@@ -1548,6 +1712,9 @@ var EventBus = class {
 
 // src/event/bus/PubSubConnection.ts
 var EventBusPubSubConnection = class extends EventBusConnection {
+  static {
+    __name(this, "EventBusPubSubConnection");
+  }
   publishableEvents;
   subscribableEvents;
   constructor(request) {
@@ -1563,49 +1730,61 @@ var EventBusPubSubConnection = class extends EventBusConnection {
 // src/event/connections/DappAccessRequest.ts
 var DappAccessRequestEvent = "dappAccessRequest";
 var dappAccessRequestConnectionRequest = {
-  publishableEvents: [DappAccessRequestEvent],
+  publishableEvents: [
+    DappAccessRequestEvent
+  ],
   type: "PubSub"
 };
-var dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest);
+var dappAccessRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(dappAccessRequestConnectionRequest), "dappAccessRequestConnection");
 
 // src/event/connections/DappsReady.ts
 var dappsReadyConnectionRequest = {
-  publishableEvents: ["dappsReady"],
+  publishableEvents: [
+    "dappsReady"
+  ],
   type: "PubSub"
 };
-var dappsReadyConnection = () => new EventBusPubSubConnection(dappsReadyConnectionRequest);
+var dappsReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(dappsReadyConnectionRequest), "dappsReadyConnection");
 
 // src/event/connections/ExposeDappRequest.ts
 var ExposeDappRequestEvent = "exposeDappRequest";
 var exposeDappConnectionRequest = {
-  publishableEvents: [ExposeDappRequestEvent],
+  publishableEvents: [
+    ExposeDappRequestEvent
+  ],
   type: "PubSub"
 };
-var exposeDappRequestConnection = () => new EventBusPubSubConnection(exposeDappConnectionRequest);
+var exposeDappRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(exposeDappConnectionRequest), "exposeDappRequestConnection");
 
 // src/event/connections/OsPubSubNetworkReady.ts
 var OsPubSubNetworkReadyEvent = "osPubSubNetworkReady";
 var osPubSubNetworkConnectionRequest = {
-  publishableEvents: [OsPubSubNetworkReadyEvent],
+  publishableEvents: [
+    OsPubSubNetworkReadyEvent
+  ],
   type: "PubSub"
 };
-var osPubSubNetworkReadyConnection = () => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest);
+var osPubSubNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest), "osPubSubNetworkReadyConnection");
 
 // src/event/connections/OsSettingsReady.ts
 var OsSettingsReadyEvent = "osSettingsReady";
 var osSettingsConnectionRequest = {
-  publishableEvents: [OsSettingsReadyEvent],
+  publishableEvents: [
+    OsSettingsReadyEvent
+  ],
   type: "PubSub"
 };
-var osSettingsReadyConnection = () => new EventBusPubSubConnection(osSettingsConnectionRequest);
+var osSettingsReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osSettingsConnectionRequest), "osSettingsReadyConnection");
 
 // src/event/connections/OsXyoPublicReady.ts
 var OsXyoPublicNetworkReadyEvent = "osXyoPublicNetworkReady";
 var osXyoPublicNetworkConnectionRequest = {
-  publishableEvents: [OsXyoPublicNetworkReadyEvent],
+  publishableEvents: [
+    OsXyoPublicNetworkReadyEvent
+  ],
   type: "PubSub"
 };
-var osXyoPublicNetworkReadyConnection = () => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest);
+var osXyoPublicNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest), "osXyoPublicNetworkReadyConnection");
 
 // src/XyOsDapp.ts
 import { assertEx as assertEx14 } from "@xylabs/assert";
@@ -1657,6 +1836,9 @@ import { BaseEmitter as BaseEmitter2 } from "@xyo-network/module-event-emitter";
 import { ModuleFactoryLocator as ModuleFactoryLocator3 } from "@xyo-network/module-factory-locator";
 import { Mutex as Mutex2 } from "async-mutex";
 var XyOsContextBase = class extends BaseEmitter2 {
+  static {
+    __name(this, "XyOsContextBase");
+  }
   _bootMutex = new Mutex2();
   _platformLocator;
   _root;
@@ -1740,10 +1922,15 @@ var XyOsContextBase = class extends BaseEmitter2 {
 
 // src/XyOsDapp.ts
 var XyOsDapp = class extends XyOsContextBase {
+  static {
+    __name(this, "XyOsDapp");
+  }
   dapp;
   constructor(params) {
     super(params);
-    this.dapp = { ...params.dapp };
+    this.dapp = {
+      ...params.dapp
+    };
   }
   get eventBus() {
     return this.parent.eventBus;
@@ -1755,12 +1942,12 @@ var XyOsDapp = class extends XyOsContextBase {
     return this.parent.exposedNodeOuter;
   }
   /**
-   * @deprecated Dapps should not have access to the bios. This is done for the
-   * settings dapp, but should be refactored out. Bios could possibly be an
-   * optional property of the parent context passed in for dapps that require
-   * elevated permissions.
-   * ^^^ I believe we may want this here in that is a dApp requests access to the bios it will optionally be there
-   */
+  * @deprecated Dapps should not have access to the bios. This is done for the
+  * settings dapp, but should be refactored out. Bios could possibly be an
+  * optional property of the parent context passed in for dapps that require
+  * elevated permissions.
+  * ^^^ I believe we may want this here in that is a dApp requests access to the bios it will optionally be there
+  */
   get kernel() {
     return assertEx14(this.parent.kernel, () => "Missing kernel");
   }
@@ -1779,15 +1966,17 @@ var XyOsDapp = class extends XyOsContextBase {
       assertEx14(this._root === void 0, () => "Dapp already booted");
       const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator4()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator4();
       console.log("XyOsDapp:boot:finalLocator", finalLocator);
-      const dappNodesWrapper = new ManifestWrapper({ ...this.manifest, schema: DappPackageManifestPayloadSchema2 }, wallet, finalLocator);
+      const dappNodesWrapper = new ManifestWrapper({
+        ...this.manifest,
+        schema: DappPackageManifestPayloadSchema2
+      }, wallet, finalLocator);
       const dappNodes = await dappNodesWrapper.loadNodes();
       const dappManifestWallet = await wallet.derivePath("99999");
       dapp_window_manifest_default.nodes[0].config.name = this.dapp.name + "Root";
-      const wrapper = new ManifestWrapper(
-        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema2 },
-        dappManifestWallet,
-        finalLocator
-      );
+      const wrapper = new ManifestWrapper({
+        ...dapp_window_manifest_default,
+        schema: DappPackageManifestPayloadSchema2
+      }, dappManifestWallet, finalLocator);
       const node = await wrapper.loadNodeFromIndex(0);
       for (const dappNode of dappNodes) {
         await node.register(dappNode);
@@ -1809,12 +1998,7 @@ import semver from "semver";
 
 // src/classes/system/Queries.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema8 } from "@xyo-network/diviner-payload-model";
-import {
-  DappConfigSchema,
-  DappIconSchema,
-  DappWidgetConfigSchema,
-  UnregisteredDappAccessSchema
-} from "@xyo-network/os-model";
+import { DappConfigSchema, DappIconSchema, DappWidgetConfigSchema, UnregisteredDappAccessSchema } from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 var SystemDappQueries = {
   async getDappAccess(diviner, name, version) {
@@ -1822,10 +2006,14 @@ var SystemDappQueries = {
       order: "desc",
       registeringDappId: name,
       schema: PayloadDivinerQuerySchema8,
-      schemas: [UnregisteredDappAccessSchema],
+      schemas: [
+        UnregisteredDappAccessSchema
+      ],
       version
     };
-    return await diviner.divine([accessQuery]);
+    return await diviner.divine([
+      accessQuery
+    ]);
   },
   async getLatestConfig(diviner, name) {
     const configQuery = {
@@ -1833,9 +2021,13 @@ var SystemDappQueries = {
       name,
       order: "desc",
       schema: PayloadDivinerQuerySchema8,
-      schemas: [DappConfigSchema]
+      schemas: [
+        DappConfigSchema
+      ]
     };
-    const [dappConfig] = await diviner.divine([configQuery]);
+    const [dappConfig] = await diviner.divine([
+      configQuery
+    ]);
     return dappConfig;
   },
   async getLatestIcon(diviner, name, version) {
@@ -1843,10 +2035,14 @@ var SystemDappQueries = {
       name,
       order: "desc",
       schema: PayloadDivinerQuerySchema8,
-      schemas: [DappIconSchema],
+      schemas: [
+        DappIconSchema
+      ],
       version
     };
-    const [dappIcon] = await diviner.divine([iconQuery]);
+    const [dappIcon] = await diviner.divine([
+      iconQuery
+    ]);
     return dappIcon;
   },
   async getWidgetConfigs(diviner, name, version) {
@@ -1854,10 +2050,14 @@ var SystemDappQueries = {
       dappId: name,
       order: "desc",
       schema: PayloadDivinerQuerySchema8,
-      schemas: [DappWidgetConfigSchema],
+      schemas: [
+        DappWidgetConfigSchema
+      ],
       version
     };
-    const widgetConfigs = await diviner.divine([widgetConfigQuery]);
+    const widgetConfigs = await diviner.divine([
+      widgetConfigQuery
+    ]);
     const uniqueConfigs = {};
     for (const widgetConfig of widgetConfigs) {
       const hash = await PayloadBuilder6.dataHash(widgetConfig);
@@ -1869,25 +2069,28 @@ var SystemDappQueries = {
 
 // src/classes/system/ManageSystemDapps.ts
 var ManageSystemDapps = class extends OsCallerBase {
+  static {
+    __name(this, "ManageSystemDapps");
+  }
+  defaultSystemNames;
+  defaultSystemDapps;
+  defaultSystemDappParams;
+  locator;
+  developmentMode;
+  onErrorCallbacks;
   constructor(context, defaultSystemNames, defaultSystemDapps, defaultSystemDappParams, locator, developmentMode) {
-    super(context);
-    this.defaultSystemNames = defaultSystemNames;
-    this.defaultSystemDapps = defaultSystemDapps;
-    this.defaultSystemDappParams = defaultSystemDappParams;
-    this.locator = locator;
-    this.developmentMode = developmentMode;
+    super(context), this.defaultSystemNames = defaultSystemNames, this.defaultSystemDapps = defaultSystemDapps, this.defaultSystemDappParams = defaultSystemDappParams, this.locator = locator, this.developmentMode = developmentMode, this.onErrorCallbacks = [];
   }
-  onErrorCallbacks = [];
   /**
-   * Add a callback to listen for errors throwing during system dapp registration
-   * @param  {ErrorListener} errorListener
-   */
+  * Add a callback to listen for errors throwing during system dapp registration
+  * @param  {ErrorListener} errorListener
+  */
   addErrorListener(errorListener) {
     this.onErrorCallbacks.push(errorListener);
   }
   /**
-   * Installs the dapps into the OS and builds the appropriate DappSet
-   */
+  * Installs the dapps into the OS and builds the appropriate DappSet
+  */
   async install() {
     await this.insertPayloads();
     return await this.latestSets();
@@ -1911,9 +2114,13 @@ var ManageSystemDapps = class extends OsCallerBase {
           console.error(`${systemDappPayload.version} does not appear to be a valid semver value`, e);
           continue;
         }
-        const [existing] = await archivist.get([await PayloadBuilder7.dataHash(systemDappPayload)]);
+        const [existing] = await archivist.get([
+          await PayloadBuilder7.dataHash(systemDappPayload)
+        ]);
         if (existing) continue;
-        await archivist.insert([systemDappPayload]);
+        await archivist.insert([
+          systemDappPayload
+        ]);
       }
       return true;
     } catch (e) {
@@ -1968,11 +2175,7 @@ var ManageSystemDapps = class extends OsCallerBase {
 
 // src/classes/registration/DappRegistry.ts
 import { HDWallet as HDWallet4 } from "@xyo-network/account";
-import {
-  DappRegisteredSchema,
-  DappRegisteredState,
-  isRegisteredDappAccess as isRegisteredDappAccess2
-} from "@xyo-network/os-model";
+import { DappRegisteredSchema, DappRegisteredState, isRegisteredDappAccess as isRegisteredDappAccess2 } from "@xyo-network/os-model";
 
 // src/classes/registration/ValidateDappAccessDiviner/Config.ts
 import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
@@ -1984,14 +2187,14 @@ var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registra
 import { HDWallet as HDWallet3 } from "@xyo-network/account";
 import { AbstractDiviner } from "@xyo-network/diviner-abstract";
 import { ManifestWrapper as ManifestWrapper2, PackageManifestPayloadSchema } from "@xyo-network/manifest";
-import {
-  isDappPackageManifestPayload,
-  isUnregisteredDappAccess,
-  RegisteredDappAccessSchema as RegisteredDappAccessSchema3
-} from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { isDappPackageManifestPayload, isUnregisteredDappAccess, RegisteredDappAccessSchema as RegisteredDappAccessSchema3 } from "@xyo-network/os-model";
 var ValidateDappAccessDiviner = class extends AbstractDiviner {
-  static configSchemas = [ValidateDappAccessDivinerConfigSchema];
+  static {
+    __name(this, "ValidateDappAccessDiviner");
+  }
+  static configSchemas = [
+    ValidateDappAccessDivinerConfigSchema
+  ];
   async divineHandler(payloads) {
     const dappManifest = payloads?.filter(isDappPackageManifestPayload);
     const accessors = payloads?.filter(isUnregisteredDappAccess);
@@ -2017,48 +2220,49 @@ var ValidateDappAccessDiviner = class extends AbstractDiviner {
           const interfaceChildren = await getNodeChildren(dappAccessInterface.manifest, dappParams);
           const valid = compareChildren(interfaceChildren, dappChildren);
           if (valid) {
-            const payload = await PayloadBuilder8.build({
+            const payload = {
               ...access,
               schema: RegisteredDappAccessSchema3,
               timestamp: Date.now()
-            });
+            };
             registeredAccessors.push(payload);
           } else {
-            const failedRegistration = await PayloadBuilder8.build({
+            const failedRegistration = {
               accessor: access,
               errorMessage: "Invalid dapp access interface",
               schema: FailedAccessorSchema
-            });
+            };
             failedAccessors.push(failedRegistration);
           }
         }
       } catch (e) {
-        failedAccessors.push(
-          await PayloadBuilder8.build({
-            accessor: access,
-            errorMessage: e.message,
-            schema: FailedAccessorSchema
-          })
-        );
+        failedAccessors.push({
+          accessor: access,
+          errorMessage: e.message,
+          schema: FailedAccessorSchema
+        });
       }
     }
-    return [...registeredAccessors, ...failedAccessors];
+    return [
+      ...registeredAccessors,
+      ...failedAccessors
+    ];
   }
 };
-var compareChildren = (interfaceChildren, dappChildren) => {
+var compareChildren = /* @__PURE__ */ __name((interfaceChildren, dappChildren) => {
   return interfaceChildren.every((interfaceChild) => Object.values(interfaceChild).every((interfaceChildName) => dappChildren.some((dappChild) => Object.values(dappChild).includes(interfaceChildName))));
-};
-var dappPackageManifestToPackageManifest = (dappPackageManifest) => {
+}, "compareChildren");
+var dappPackageManifestToPackageManifest = /* @__PURE__ */ __name((dappPackageManifest) => {
   return {
     ...dappPackageManifest,
     schema: PackageManifestPayloadSchema
   };
-};
-var getChildrenFromNode = async (node) => {
+}, "dappPackageManifestToPackageManifest");
+var getChildrenFromNode = /* @__PURE__ */ __name(async (node) => {
   const nodeManifest = (await node.state())?.[0];
   return nodeManifest.status?.children;
-};
-var getNodeChildren = async (manifestToTest, dappParams) => {
+}, "getChildrenFromNode");
+var getNodeChildren = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
   const testNodes = await getNodeToTest(manifestToTest, dappParams);
   const children = [];
   for (const node of testNodes) {
@@ -2068,35 +2272,32 @@ var getNodeChildren = async (manifestToTest, dappParams) => {
     }
   }
   return children;
-};
-var getNodeToTest = async (manifestToTest, dappParams) => {
+}, "getNodeChildren");
+var getNodeToTest = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
   const dappManifestWrapper = new ManifestWrapper2(manifestToTest, await HDWallet3.random(), dappParams.locator);
   return await dappManifestWrapper.loadNodes();
-};
+}, "getNodeToTest");
 
 // src/classes/registration/DappRegistry.ts
 var DappRegistry = class {
+  static {
+    __name(this, "DappRegistry");
+  }
+  dappSeedPhraseRepository;
+  dappRegistry;
   constructor(dappSeedPhraseRepository) {
     this.dappSeedPhraseRepository = dappSeedPhraseRepository;
+    this.dappRegistry = /* @__PURE__ */ new Map();
   }
-  dappRegistry = /* @__PURE__ */ new Map();
   /**
-   * Register a Dapp with window manager and if successful, return its id
-   *
-   * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
-   * @returns {RegisteredDapp} dapp with registration fields
-   **/
+  * Register a Dapp with window manager and if successful, return its id
+  *
+  * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
+  * @returns {RegisteredDapp} dapp with registration fields
+  **/
   async registerDapp(dapp) {
     if (dapp) {
-      const {
-        exposedModuleIds,
-        manifest,
-        modes,
-        name,
-        version,
-        params,
-        widgetConfigs
-      } = this.extractDappProperties(dapp);
+      const { exposedModuleIds, manifest, modes, name, version, params, widgetConfigs } = this.extractDappProperties(dapp);
       try {
         const walletId = await this.dappSeedPhraseRepository.findOrCreate(name);
         const registeredAccessors = await this.validateDappAccessPayloads(manifest, dapp.accessors, params);
@@ -2131,27 +2332,16 @@ var DappRegistry = class {
     }
   }
   /**
-   * Unregister a dapp so it can no longer be launched
-   *
-   * @param dappId
-   */
+  * Unregister a dapp so it can no longer be launched
+  *
+  * @param dappId
+  */
   unregisterDapp(dappId) {
     this.dappRegistry.delete(dappId);
   }
   extractDappProperties(dapp) {
-    const {
-      params,
-      config,
-      widgetConfigs
-    } = dapp;
-    const {
-      exposedModuleIds,
-      manifest,
-      modes,
-      name,
-      sources,
-      version
-    } = config;
+    const { params, config, widgetConfigs } = dapp;
+    const { exposedModuleIds, manifest, modes, name, sources, version } = config;
     return {
       exposedModuleIds,
       manifest,
@@ -2166,10 +2356,15 @@ var DappRegistry = class {
   async validateDappAccessPayloads(manifest, accessors = [], params) {
     const validateDappAccess = await ValidateDappAccessDiviner.create({
       account: await HDWallet4.random(),
-      config: { schema: ValidateDappAccessDivinerConfigSchema },
+      config: {
+        schema: ValidateDappAccessDivinerConfigSchema
+      },
       dappParams: params
     });
-    const payloads = await validateDappAccess.divine([manifest, ...accessors]);
+    const payloads = await validateDappAccess.divine([
+      manifest,
+      ...accessors
+    ]);
     const failedAccessors = payloads.filter(isFailedAccessor);
     const registeredAccessors = payloads.filter(isRegisteredDappAccess2);
     if (failedAccessors.length > 0) {
@@ -2181,6 +2376,26 @@ var DappRegistry = class {
 
 // src/classes/registration/DappRegistrationService.ts
 var DappRegistrationService = class {
+  static {
+    __name(this, "DappRegistrationService");
+  }
+  context;
+  params;
+  locator;
+  developmentMode;
+  // Dapps that have been built with their own context
+  builtDapps;
+  dappRegistry;
+  dappSeedPhraseRepository;
+  manageSystemDapps;
+  // Dapps that have been registered with dappAccessRequests
+  registeredAccessDappSets;
+  // Dapps that have been registered with the dapp registry
+  registeredDappSets;
+  // Dapps that have been registered with exposeDappRequests
+  registeredExposedDappSets;
+  dappAccessRequestConnection;
+  exposeDappRequestConnection;
   constructor(context, params = {
     dappNames: [],
     dappParams: {},
@@ -2190,34 +2405,23 @@ var DappRegistrationService = class {
     this.params = params;
     this.locator = locator;
     this.developmentMode = developmentMode;
-    this.manageSystemDapps = new ManageSystemDapps(
-      context,
-      this.params?.dappNames ?? [],
-      this.params?.dappPayloads ?? [],
-      this.params?.dappParams ?? {},
-      this.locator,
-      this.developmentMode
-    );
+    this.builtDapps = {};
+    this.registeredAccessDappSets = /* @__PURE__ */ new Set();
+    this.registeredDappSets = /* @__PURE__ */ new Set();
+    this.registeredExposedDappSets = /* @__PURE__ */ new Set();
+    this.dappAccessRequestConnection = dappAccessRequestConnection();
+    this.exposeDappRequestConnection = exposeDappRequestConnection();
+    this.manageSystemDapps = new ManageSystemDapps(context, this.params?.dappNames ?? [], this.params?.dappPayloads ?? [], this.params?.dappParams ?? {}, this.locator, this.developmentMode);
     this.dappSeedPhraseRepository = new DappSeedPhraseRepository(context, this.params?.dappNames ?? []);
     this.dappRegistry = new DappRegistry(this.dappSeedPhraseRepository);
     this.addConnectionRequests();
   }
-  // Dapps that have been built with their own context
-  builtDapps = {};
-  dappRegistry;
-  dappSeedPhraseRepository;
-  manageSystemDapps;
-  // Dapps that have been registered with dappAccessRequests
-  registeredAccessDappSets = /* @__PURE__ */ new Set();
-  // Dapps that have been registered with the dapp registry
-  registeredDappSets = /* @__PURE__ */ new Set();
-  // Dapps that have been registered with exposeDappRequests
-  registeredExposedDappSets = /* @__PURE__ */ new Set();
-  dappAccessRequestConnection = dappAccessRequestConnection();
-  exposeDappRequestConnection = exposeDappRequestConnection();
   async buildDapp(manifest, dappId = NameTransforms.slug(manifest.nodes[0]?.config.name), name = NameTransforms.moduleName(manifest.nodes[0]?.config.name)) {
     const dapp = new XyOsDapp({
-      dapp: { id: dappId, name },
+      dapp: {
+        id: dappId,
+        name
+      },
       locator: this.locator,
       manifest,
       parent: this.context,
@@ -2230,37 +2434,43 @@ var DappRegistrationService = class {
     return this.params?.dappParams[dappId];
   }
   async start() {
-    const systemDapps = await this.context.monitor(async () => await this.manageSystemDapps.install(), { name: "Install System dApps" });
+    const systemDapps = await this.context.monitor(async () => await this.manageSystemDapps.install(), {
+      name: "Install System dApps"
+    });
     const activeDapps = systemDapps.filter(({ dapp }) => dapp.icon.active === true);
-    const results = await Promise.allSettled(
-      activeDapps.map(async (dappSet) => {
-        const { dapp } = dappSet;
-        const registeredDapp = await this.dappRegistry.registerDapp(dapp);
-        const result = { dapp: registeredDapp, dappIcon: dapp.icon };
-        const forgetHandlers = async () => {
-          try {
-            await this.postRegistrationHandlers(result);
-          } catch (e) {
-            console.error("Error in post registration handlers", e);
-          }
-        };
-        forget2(forgetHandlers());
-        return result;
-      })
-    );
+    const results = await Promise.allSettled(activeDapps.map(async (dappSet) => {
+      const { dapp } = dappSet;
+      const registeredDapp = await this.dappRegistry.registerDapp(dapp);
+      const result = {
+        dapp: registeredDapp,
+        dappIcon: dapp.icon
+      };
+      const forgetHandlers = /* @__PURE__ */ __name(async () => {
+        try {
+          await this.postRegistrationHandlers(result);
+        } catch (e) {
+          console.error("Error in post registration handlers", e);
+        }
+      }, "forgetHandlers");
+      forget2(forgetHandlers());
+      return result;
+    }));
     const failed = results.filter(rejected).map((result) => result.reason);
     const succeeded = results.filter(fulfilled).map((result) => result.value);
     for (const registeredDapp of succeeded) this.registeredDappSets.add(registeredDapp);
-    return { failed, succeeded };
+    return {
+      failed,
+      succeeded
+    };
   }
   addConnectionRequests() {
     this.context.eventBus.addConnection(this.dappAccessRequestConnection);
     this.context.eventBus.addConnection(this.exposeDappRequestConnection);
   }
   /**
-   * A method to get the user property from context and eventually modify it before handing it to a dapp
-   * i.e. curating user-approved signers
-   */
+  * A method to get the user property from context and eventually modify it before handing it to a dapp
+  * i.e. curating user-approved signers
+  */
   getUser() {
     return this.context.user;
   }
@@ -2268,17 +2478,19 @@ var DappRegistrationService = class {
     if (registeredDapp.dapp) {
       if (isRegisteredDappExposedDappSet(registeredDapp)) {
         this.registeredExposedDappSets.add(registeredDapp);
-        const exposeIntent = DappIntentCaller.buildIntent(
-          DappIntentCaller.OsDappName,
-          DappIntentTypes2.Launch,
-          registeredDapp.dapp.config.name,
-          DappMode3.Exposed
-        );
-        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, { payloads: [registeredDapp.dapp.config, exposeIntent] });
+        const exposeIntent = DappIntentCaller.buildIntent(DappIntentCaller.OsDappName, DappIntentTypes2.Launch, registeredDapp.dapp.config.name, DappMode3.Exposed);
+        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, {
+          payloads: [
+            registeredDapp.dapp.config,
+            exposeIntent
+          ]
+        });
       }
       if (isRegisteredDappAccessDappSet2(registeredDapp)) {
         this.registeredAccessDappSets.add(registeredDapp);
-        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, { payloads: registeredDapp.dapp.accessors });
+        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, {
+          payloads: registeredDapp.dapp.accessors
+        });
       }
     }
   }
@@ -2294,6 +2506,10 @@ import { asDivinerInstance as asDivinerInstance4 } from "@xyo-network/diviner-mo
 var OsSettingsArchivistModuleName = "OsSettingsNode:OsSettingsArchivist";
 var OsSettingsArchivistPayloadDivinerModuleName = "OsSettingsNode:OsSettingsArchivistPayloadDiviner";
 var OsSettingsCallerBase = class {
+  static {
+    __name(this, "OsSettingsCallerBase");
+  }
+  context;
   constructor(context) {
     this.context = context;
   }
@@ -2302,10 +2518,7 @@ var OsSettingsCallerBase = class {
     return asArchivistInstance5(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`);
   }
   async getOsSettingsPayloadDiviner() {
-    const mod = assertEx15(
-      await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName),
-      () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx15(await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName), () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance4(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`);
   }
 };
@@ -2314,31 +2527,38 @@ var OsSettingsCallerBase = class {
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema9 } from "@xyo-network/diviner-payload-model";
 import { OsBadgeSchema } from "@xyo-network/os-model";
 var OsBadgeQueries = {
-  getBadge: async (achievement, diviner) => {
+  getBadge: /* @__PURE__ */ __name(async (achievement, diviner) => {
     const query = {
       achievement,
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema9,
-      schemas: [OsBadgeSchema]
+      schemas: [
+        OsBadgeSchema
+      ]
     };
-    return await diviner.divine([query]);
-  }
+    return await diviner.divine([
+      query
+    ]);
+  }, "getBadge")
 };
 
 // src/classes/settings/badge/Caller.ts
 var OsBadgeCaller = class extends OsSettingsCallerBase {
+  static {
+    __name(this, "OsBadgeCaller");
+  }
   /**
-   * @param  {ValidOsAchievements} achievement
-   */
+  * @param  {ValidOsAchievements} achievement
+  */
   async getBadge(achievement) {
     const diviner = await this.getOsSettingsPayloadDiviner();
     const results = await OsBadgeQueries.getBadge(achievement, diviner);
     return results[0] ?? null;
   }
   /**
-   * @param  {ValidOsAchievements} achievement
-   */
+  * @param  {ValidOsAchievements} achievement
+  */
   async saveBadge(achievement) {
     const badge = {
       achievement,
@@ -2346,7 +2566,9 @@ var OsBadgeCaller = class extends OsSettingsCallerBase {
       timestamp: Date.now()
     };
     const archivist = await this.getOsSettingsArchivist();
-    return await archivist.insert([badge]);
+    return await archivist.insert([
+      badge
+    ]);
   }
 };
 
@@ -2354,7 +2576,12 @@ var OsBadgeCaller = class extends OsSettingsCallerBase {
 import { assertEx as assertEx16 } from "@xylabs/assert";
 import { isBadgeWithMeta } from "@xyo-network/os-model";
 var OsBadgeResource = class extends OsSettingsCallerBase {
-  static views = ["savedSeedPhrase"];
+  static {
+    __name(this, "OsBadgeResource");
+  }
+  static views = [
+    "savedSeedPhrase"
+  ];
   _savedSeedPhrase;
   constructor(xyOsContext) {
     super(xyOsContext);
@@ -2363,23 +2590,27 @@ var OsBadgeResource = class extends OsSettingsCallerBase {
     return assertEx16(this._savedSeedPhrase, () => "Saved seed phrase listener not set");
   }
   get subscriptions() {
-    return { savedSeedPhrase: (cb) => this.savedSeedPhrase.subscribe(cb) };
+    return {
+      savedSeedPhrase: /* @__PURE__ */ __name((cb) => this.savedSeedPhrase.subscribe(cb), "savedSeedPhrase")
+    };
   }
   get views() {
-    return { savedSeedPhrase: () => this.savedSeedPhrase.latest };
+    return {
+      savedSeedPhrase: /* @__PURE__ */ __name(() => this.savedSeedPhrase.latest, "savedSeedPhrase")
+    };
   }
   cleanupListeners() {
     this.savedSeedPhrase.cleanupListeners();
   }
   /**
-   * start listeners
-   **/
+  * start listeners
+  **/
   async start() {
     const diviner = await this.getOsSettingsPayloadDiviner();
     const archivist = await this.getOsSettingsArchivist();
     this._savedSeedPhrase = await PayloadStore.create({
       archivist,
-      getLatest: async () => await OsBadgeQueries.getBadge("savedSeedPhrase", diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await OsBadgeQueries.getBadge("savedSeedPhrase", diviner), "getLatest"),
       idFunction: isBadgeWithMeta
     });
   }
@@ -2391,11 +2622,11 @@ import { isEqual } from "@xylabs/lodash";
 
 // src/utils/buildWalletSeedPhrasePayload.ts
 import { WalletSeedPhraseSchema } from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 var language = "english";
 var standard = "bip-39";
 var userWalletLabel = "userWallet";
-var buildWalletSeedPhrasePayload = async (mnemonic, $label) => {
+var buildWalletSeedPhrasePayload = /* @__PURE__ */ __name(async (mnemonic, $label) => {
   const fields = {
     mnemonic: {
       language,
@@ -2403,17 +2634,25 @@ var buildWalletSeedPhrasePayload = async (mnemonic, $label) => {
       standard
     }
   };
-  const meta = { $label, $timestamp: Date.now() };
-  const payload = new PayloadBuilder9({ schema: WalletSeedPhraseSchema }).fields(fields).meta(meta).build();
-  const rootHash = await PayloadBuilder9.hash(payload);
-  return { payload, rootHash };
-};
-var buildUserWalletSeedPhrasePayload = (mnemonic) => {
+  const meta = {
+    $label,
+    $timestamp: Date.now()
+  };
+  const payload = new PayloadBuilder8({
+    schema: WalletSeedPhraseSchema
+  }).fields(fields).meta(meta).build();
+  const rootHash = await PayloadBuilder8.hash(payload);
+  return {
+    payload,
+    rootHash
+  };
+}, "buildWalletSeedPhrasePayload");
+var buildUserWalletSeedPhrasePayload = /* @__PURE__ */ __name((mnemonic) => {
   return buildWalletSeedPhrasePayload(mnemonic, userWalletLabel);
-};
+}, "buildUserWalletSeedPhrasePayload");
 
 // src/utils/getApiDomain.ts
-var getApiDomain = (scope, apiDomain) => {
+var getApiDomain = /* @__PURE__ */ __name((scope, apiDomain) => {
   if (apiDomain !== void 0) {
     return apiDomain;
   }
@@ -2424,24 +2663,21 @@ var getApiDomain = (scope, apiDomain) => {
     return "https://beta.archivist.xyo.network";
   }
   return "https://archivist.xyo.network";
-};
+}, "getApiDomain");
 
 // src/utils/renameObjKey.ts
-var renameObjKey = (oldObj, oldKey, newKey) => {
+var renameObjKey = /* @__PURE__ */ __name((oldObj, oldKey, newKey) => {
   const oldObjKeys = Object.keys(oldObj);
-  const newObj = oldObjKeys.reduce(
-    (acc, val) => {
-      if (val === oldKey) {
-        acc[newKey] = oldObj[oldKey];
-      } else {
-        acc[val] = oldObj[val];
-      }
-      return acc;
-    },
-    {}
-  );
+  const newObj = oldObjKeys.reduce((acc, val) => {
+    if (val === oldKey) {
+      acc[newKey] = oldObj[oldKey];
+    } else {
+      acc[val] = oldObj[val];
+    }
+    return acc;
+  }, {});
   return newObj;
-};
+}, "renameObjKey");
 
 // src/classes/settings/SettingsQueries.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema10 } from "@xyo-network/diviner-payload-model";
@@ -2453,57 +2689,78 @@ var OsSettingsQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema10,
-      schemas: [WalletSeedPhraseSchema2]
+      schemas: [
+        WalletSeedPhraseSchema2
+      ]
     };
-    const results = await diviner.divine([query]);
+    const results = await diviner.divine([
+      query
+    ]);
     const wallet = results.find((payload) => payload.$label === "userWallet");
-    return wallet ? [wallet] : NO_RESULTS2;
+    return wallet ? [
+      wallet
+    ] : NO_RESULTS2;
   },
   async getNodeBackground(diviner) {
     const query = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema10,
-      schemas: [NodeBackgroundSchema]
+      schemas: [
+        NodeBackgroundSchema
+      ]
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   },
   async getWallets(diviner) {
     const query = {
       order: "desc",
       schema: PayloadDivinerQuerySchema10,
-      schemas: [WalletSeedPhraseSchema2]
+      schemas: [
+        WalletSeedPhraseSchema2
+      ]
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   }
 };
 
 // src/classes/settings/Caller.ts
 var OsSettingsCaller = class extends OsSettingsCallerBase {
+  static {
+    __name(this, "OsSettingsCaller");
+  }
   constructor(context) {
     super(context);
   }
   /**
-   * Add a node background to the settings
-   * @param  {NodeBackground} payload
-   */
+  * Add a node background to the settings
+  * @param  {NodeBackground} payload
+  */
   async addNodeBackground(payload) {
     const archivist = await this.getOsSettingsArchivist();
-    await archivist.insert([payload]);
+    await archivist.insert([
+      payload
+    ]);
   }
   /**
-   * Add a wallet seed phrase to the settings
-   * @param  {WalletSeedPhrase} payload
-   */
+  * Add a wallet seed phrase to the settings
+  * @param  {WalletSeedPhrase} payload
+  */
   async addWalletSeedPhrase(payload) {
     const archivist = await this.getOsSettingsArchivist();
-    await archivist.insert([payload]);
+    await archivist.insert([
+      payload
+    ]);
     const phrase = payload.mnemonic.mnemonic.join(" ");
     await this.context.kernel?.bios?.seedPhraseStore.set("user", phrase);
   }
   /**
-   * Get the latest node background
-   */
+  * Get the latest node background
+  */
   async getLatestNodeBackground() {
     const diviner = await this.getOsSettingsPayloadDiviner();
     const [result] = await OsSettingsQueries.getNodeBackground(diviner);
@@ -2530,6 +2787,9 @@ var OsSettingsCaller = class extends OsSettingsCallerBase {
 import { assertEx as assertEx18 } from "@xylabs/assert";
 import { isNodeBackground, isWalletSeedPhrase } from "@xyo-network/os-model";
 var OsSettingsResource = class extends OsSettingsCallerBase {
+  static {
+    __name(this, "OsSettingsResource");
+  }
   _latestUserWalletListener;
   _nodeBackgroundListener;
   _walletsListener;
@@ -2544,16 +2804,16 @@ var OsSettingsResource = class extends OsSettingsCallerBase {
   }
   get subscriptions() {
     return {
-      latestUserWallet: (cb) => this.walletsListener.subscribe(cb),
-      nodeBackground: (cb) => this.nodeBackgroundListener.subscribe(cb),
-      wallets: (cb) => this.walletsListener.subscribe(cb)
+      latestUserWallet: /* @__PURE__ */ __name((cb) => this.walletsListener.subscribe(cb), "latestUserWallet"),
+      nodeBackground: /* @__PURE__ */ __name((cb) => this.nodeBackgroundListener.subscribe(cb), "nodeBackground"),
+      wallets: /* @__PURE__ */ __name((cb) => this.walletsListener.subscribe(cb), "wallets")
     };
   }
   get views() {
     return {
-      latestUserWallet: () => this.latestUserWalletListener.latest,
-      nodeBackground: () => this.nodeBackgroundListener.latest,
-      wallets: () => this.walletsListener.latest
+      latestUserWallet: /* @__PURE__ */ __name(() => this.latestUserWalletListener.latest, "latestUserWallet"),
+      nodeBackground: /* @__PURE__ */ __name(() => this.nodeBackgroundListener.latest, "nodeBackground"),
+      wallets: /* @__PURE__ */ __name(() => this.walletsListener.latest, "wallets")
     };
   }
   get walletsListener() {
@@ -2564,24 +2824,24 @@ var OsSettingsResource = class extends OsSettingsCallerBase {
     this.latestUserWalletListener.cleanupListeners();
   }
   /**
-   * start listeners
-   */
+  * start listeners
+  */
   async start() {
     const archivist = await this.getOsSettingsArchivist();
     const diviner = await this.getOsSettingsPayloadDiviner();
     this._walletsListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await OsSettingsQueries.getWallets(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await OsSettingsQueries.getWallets(diviner), "getLatest"),
       idFunction: isWalletSeedPhrase
     });
     this._latestUserWalletListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await OsSettingsQueries.getLatestUserWallet(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await OsSettingsQueries.getLatestUserWallet(diviner), "getLatest"),
       idFunction: isWalletSeedPhrase
     });
     this._nodeBackgroundListener = await PayloadStore.create({
       archivist,
-      getLatest: async () => await OsSettingsQueries.getNodeBackground(diviner),
+      getLatest: /* @__PURE__ */ __name(async () => await OsSettingsQueries.getNodeBackground(diviner), "getLatest"),
       idFunction: isNodeBackground
     });
   }
@@ -2591,6 +2851,9 @@ var OsSettingsResource = class extends OsSettingsCallerBase {
 import { assertEx as assertEx19 } from "@xylabs/assert";
 import { HDWallet as HDWallet5 } from "@xyo-network/account";
 var Signers = class {
+  static {
+    __name(this, "Signers");
+  }
   _paths;
   _signerAccounts;
   _walletStore;
@@ -2641,26 +2904,32 @@ import { IndexedDbPayloadDiviner } from "@xyo-network/diviner-payload-indexeddb"
 import { ManifestWrapper as ManifestWrapper3 } from "@xyo-network/manifest-wrapper";
 import { ModuleFactoryLocator as ModuleFactoryLocator6 } from "@xyo-network/module-factory-locator";
 var OS_NODE_PATH = "1'";
-var getDefaultOsNodeLocator = () => {
+var getDefaultOsNodeLocator = /* @__PURE__ */ __name(() => {
   const locator = new ModuleFactoryLocator6();
-  locator.register(IndexedDbArchivist, { "network.xyo.archivist.persistence.scope": "device" });
-  locator.register(IndexedDbPayloadDiviner, { "network.xyo.archivist.persistence.scope": "device" });
+  locator.register(IndexedDbArchivist, {
+    "network.xyo.archivist.persistence.scope": "device"
+  });
+  locator.register(IndexedDbPayloadDiviner, {
+    "network.xyo.archivist.persistence.scope": "device"
+  });
   return locator;
-};
-var loadOsNode = async (osWallet, locator) => {
+}, "getDefaultOsNodeLocator");
+var loadOsNode = /* @__PURE__ */ __name(async (osWallet, locator) => {
   try {
     const osNodeWallet = await osWallet.derivePath(OS_NODE_PATH);
     const osNodeLocator = locator ?? getDefaultOsNodeLocator();
     const manifestWrapper = new ManifestWrapper3(os_node_manifest_default, osNodeWallet, osNodeLocator);
     const osNode = (await manifestWrapper.loadNodes())[0];
-    return [osNode];
+    return [
+      osNode
+    ];
   } catch (e) {
     const error = e;
     console.error(`Error creating os node: ${error.message}`);
     console.error(`Error creating os node: ${error.stack}`);
     throw new Error(`Error creating os node: ${error.message}`);
   }
-};
+}, "loadOsNode");
 
 // src/stack/Base.ts
 import { assertEx as assertEx20 } from "@xylabs/assert";
@@ -2669,6 +2938,9 @@ import { BaseEmitter as BaseEmitter3 } from "@xyo-network/module-event-emitter";
 import { isModuleInstance } from "@xyo-network/module-model";
 import { asAttachableNodeInstance } from "@xyo-network/node-model";
 var StackBase = class extends BaseEmitter3 {
+  static {
+    __name(this, "StackBase");
+  }
   // flag to check that all adapters are initialized
   initialized = false;
   // adapters to initialize into the stack
@@ -2703,57 +2975,57 @@ var StackBase = class extends BaseEmitter3 {
   initialize() {
     this.assignStack();
     for (const adapter of this.adapterSet) {
-      const driverReadyListener = async ({ node }) => await this.handleDriverReady(node);
+      const driverReadyListener = /* @__PURE__ */ __name(async ({ node }) => await this.handleDriverReady(node), "driverReadyListener");
       adapter.on("driverReady", driverReadyListener);
       this.listeners.push({
         adapter,
         eventName: "driverReady",
         listener: driverReadyListener
       });
-      const driverErrorListener = async ({ error }) => {
+      const driverErrorListener = /* @__PURE__ */ __name(async ({ error }) => {
         console.error(`Error updating ${this.stackNodeModuleId} stack node`, error);
-        await this.emit("driverError", { error });
-      };
+        await this.emit("driverError", {
+          error
+        });
+      }, "driverErrorListener");
       adapter.on("driverError", driverErrorListener);
       this.listeners.push({
         adapter,
         eventName: "driverError",
         listener: driverErrorListener
       });
-      const startAdapter = async () => await adapter.start();
+      const startAdapter = /* @__PURE__ */ __name(async () => await adapter.start(), "startAdapter");
       forget3(startAdapter());
     }
   }
   /**
-   * Stops the stack
-   */
+  * Stops the stack
+  */
   stop() {
-    for (const {
-      eventName,
-      listener,
-      adapter
-    } of this.listeners) {
+    for (const { eventName, listener, adapter } of this.listeners) {
       adapter.off(eventName, listener);
     }
   }
   /**
-   * Adds a node to the stack. Idempotent to avoid adding the
-   * same node multiple times
-   * @param node The node to add to the stack
-   * @returns
-   */
+  * Adds a node to the stack. Idempotent to avoid adding the
+  * same node multiple times
+  * @param node The node to add to the stack
+  * @returns
+  */
   async addNodeToStackNode(node) {
     const stackNode = await this.getStackNode();
-    const existingModule = await stackNode.resolve(node.address, { direction: "down" });
+    const existingModule = await stackNode.resolve(node.address, {
+      direction: "down"
+    });
     if (isModuleInstance(existingModule)) return;
     await stackNode.register?.(node);
     await stackNode.attach?.(node.address, true);
   }
   assignStack() {
-    const assign = async () => {
+    const assign = /* @__PURE__ */ __name(async () => {
       const stackNode = await this.getStackNode();
       this._stack = stackNode;
-    };
+    }, "assign");
     forget3(assign());
   }
   async getStackNode() {
@@ -2762,25 +3034,34 @@ var StackBase = class extends BaseEmitter3 {
   }
   async handleDriverReady(node) {
     try {
-      await this.emit("driverReady", { node });
+      await this.emit("driverReady", {
+        node
+      });
       await this.addNodeToStackNode(node);
       await this.updateInitializationState(node);
     } catch (error) {
       console.error(`Error updating ${this.stackNodeModuleId} stack node`, node.id, error);
-      await this.emit("stackError", { error });
+      await this.emit("stackError", {
+        error
+      });
     }
   }
   async updateInitializationState(node) {
     this.initializedNodes.push(node);
     this.initialized = this.adapterSet.every((n) => n.initialized);
     if (this.initialized) {
-      await this.emit("initialized", { stack: await this.getStackNode() });
+      await this.emit("initialized", {
+        stack: await this.getStackNode()
+      });
     }
   }
 };
 
 // src/stack/Manager.ts
 var StackManager = class {
+  static {
+    __name(this, "StackManager");
+  }
   initializedStacksMap = /* @__PURE__ */ new Map();
   stackMap;
   constructor(stackMap) {
@@ -2822,27 +3103,30 @@ import { BaseEmitter as BaseEmitter4 } from "@xyo-network/module-event-emitter";
 import { asAttachableNodeInstance as asAttachableNodeInstance2 } from "@xyo-network/node-model";
 import { v4 as uuid3 } from "uuid";
 var NodeAdapterBase = class extends BaseEmitter4 {
+  static {
+    __name(this, "NodeAdapterBase");
+  }
+  kernel;
+  driverName;
+  initialized;
+  _id;
   constructor(kernel, driverName) {
-    super({});
-    this.kernel = kernel;
-    this.driverName = driverName;
+    super({}), this.kernel = kernel, this.driverName = driverName, this.initialized = false, this._id = "";
     this._id = uuid3();
   }
-  initialized = false;
-  _id = "";
   get id() {
     return assertEx21(this._id, () => "NodeAdapterBase id not initialized");
   }
   async start() {
     try {
-      const moduleAttachedInsertListener = ({ payloads }) => {
+      const moduleAttachedInsertListener = /* @__PURE__ */ __name(({ payloads }) => {
         const moduleAttachedEvent = this.findModuleEventPayloads(payloads);
         for (const payload of moduleAttachedEvent) {
           if (payload.name === this.driverName) {
             this.validateAndReturnDriver();
           }
         }
-      };
+      }, "moduleAttachedInsertListener");
       const eventsArchivist = await this.getEventsArchivist();
       const weakRefInsertListener = new WeakRef(moduleAttachedInsertListener);
       const insertListenerRef = weakRefInsertListener.deref();
@@ -2851,7 +3135,9 @@ var NodeAdapterBase = class extends BaseEmitter4 {
       if (node) return node;
       this.initialized = false;
     } catch (error) {
-      await this.emit("driverError", { error });
+      await this.emit("driverError", {
+        error
+      });
     }
   }
   findModuleEventPayloads(payloads) {
@@ -2869,7 +3155,9 @@ var NodeAdapterBase = class extends BaseEmitter4 {
     if (mod) {
       const node = asAttachableNodeInstance2(mod, () => `${mod.id} is not a node`);
       this.initialized = true;
-      const emit = async () => await this.emit("driverReady", { node });
+      const emit = /* @__PURE__ */ __name(async () => await this.emit("driverReady", {
+        node
+      }), "emit");
       forget4(emit());
       return node;
     }
@@ -2878,6 +3166,9 @@ var NodeAdapterBase = class extends BaseEmitter4 {
 
 // src/adapter/Network.ts
 var NetworkAdapter = class extends NodeAdapterBase {
+  static {
+    __name(this, "NetworkAdapter");
+  }
   _connection;
   constructor(kernel, driverName) {
     super(kernel, driverName);
@@ -2898,6 +3189,9 @@ var NetworkAdapter = class extends NodeAdapterBase {
 
 // src/adapter/Settings.ts
 var SettingsAdapter = class extends NodeAdapterBase {
+  static {
+    __name(this, "SettingsAdapter");
+  }
   _settings = void 0;
   constructor(kernel, driverName) {
     super(kernel, driverName);
@@ -2917,26 +3211,31 @@ var SettingsAdapter = class extends NodeAdapterBase {
 };
 
 // src/adapters/OsPubSubBridgeNetwork.ts
-var OsPubSubBridgeNetworkAdapters = (kernel) => [
+var OsPubSubBridgeNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
   new NetworkAdapter(kernel, PubSubBridgeNodeNodeName),
   new NetworkAdapter(kernel, ExposedNodeOuterNodeName)
-];
+], "OsPubSubBridgeNetworkAdapters");
 
 // src/adapters/OsSettings.ts
 import { OsSettingsNodeName } from "@xyo-network/os-model";
-var OsSettingsAdapters = (kernel) => [new SettingsAdapter(kernel, OsSettingsNodeName)];
+var OsSettingsAdapters = /* @__PURE__ */ __name((kernel) => [
+  new SettingsAdapter(kernel, OsSettingsNodeName)
+], "OsSettingsAdapters");
 
 // src/adapters/OsXyoPublicNetwork.ts
 import { XyoPublicNodeName } from "@xyo-network/os-model";
-var OsXyoPublicNetworkAdapters = (kernel) => [
+var OsXyoPublicNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
   new NetworkAdapter(kernel, XyoPublicNodeName)
-];
+], "OsXyoPublicNetworkAdapters");
 
 // src/stack/OsPubSubNetworkStack.ts
 import { assertEx as assertEx22 } from "@xylabs/assert";
 import { asAttachableNodeInstance as asAttachableNodeInstance3, asNodeInstance as asNodeInstance2 } from "@xyo-network/node-model";
 import { ExposedNodeOuterNodeName as ExposedNodeOuterNodeName2, PubSubBridgeNodeNodeName as PubSubBridgeNodeNodeName2 } from "@xyo-network/os-model";
 var OsPubSubNetworkStack = class extends StackBase {
+  static {
+    __name(this, "OsPubSubNetworkStack");
+  }
   _exposedNode;
   _exposedNodeOuter;
   busConnection = osPubSubNetworkReadyConnection();
@@ -2979,13 +3278,15 @@ var OsPubSubNetworkStack = class extends StackBase {
     super.stop();
     this._exposedNode = void 0;
     this._exposedNodeOuter = void 0;
-    if (this.busConnection._id)
-      this.context.eventBus.removeConnection(this.busConnection.id);
+    if (this.busConnection._id) this.context.eventBus.removeConnection(this.busConnection.id);
   }
 };
 
 // src/stack/OsSettingsStack.ts
 var OsSettingsStack = class extends StackBase {
+  static {
+    __name(this, "OsSettingsStack");
+  }
   busConnection = osSettingsReadyConnection();
   constructor(context, adapters) {
     super(context, adapters, "OsSettingsStackNode");
@@ -3003,6 +3304,9 @@ var OsSettingsStack = class extends StackBase {
 // src/stack/XyoPublicNetworkStack.ts
 import { XyoPublicNodeName as XyoPublicNodeName2 } from "@xyo-network/os-model";
 var XyoPublicNetworkStack = class extends StackBase {
+  static {
+    __name(this, "XyoPublicNetworkStack");
+  }
   busConnection = osXyoPublicNetworkReadyConnection();
   constructor(context, adapters) {
     super(context, adapters, "OsXyoPublicNetworkStackNode");
@@ -3041,6 +3345,9 @@ var OsStackMap = {
 
 // src/XyOs.ts
 var XyOs = class _XyOs extends XyOsContextBase {
+  static {
+    __name(this, "XyOs");
+  }
   _exposedNode;
   _exposedNodeOuter;
   _kernel;
@@ -3048,16 +3355,9 @@ var XyOs = class _XyOs extends XyOsContextBase {
   dappRegistrationService;
   signers;
   stackManager;
-  constructor({
-    logger = console,
-    eventBus = new EventBus(),
-    kernel = new Kernel({ logger }),
-    locator = new ModuleFactoryLocator7(),
-    dappsConfiguration,
-    developmentMode,
-    stackMap = OsStackMap,
-    ...params
-  } = {}) {
+  constructor({ logger = console, eventBus = new EventBus(), kernel = new Kernel({
+    logger
+  }), locator = new ModuleFactoryLocator7(), dappsConfiguration, developmentMode, stackMap = OsStackMap, ...params } = {}) {
     super({
       eventBus,
       kernel,
@@ -3095,14 +3395,19 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return this.stackManager.stacks;
   }
   get user() {
-    return { signers: this.signers?.getWalletKindSigner("user") };
+    return {
+      signers: this.signers?.getWalletKindSigner("user")
+    };
   }
   static async monitor(fn, eventConfig) {
     const { name, additionalProperties } = eventConfig;
     const monitor = this.monitoring;
     monitor?.startTimer(name);
     const result = await fn();
-    monitor?.stopTimer({ additionalProperties, name });
+    monitor?.stopTimer({
+      additionalProperties,
+      name
+    });
     return result;
   }
   async boot(wallet, locator = new ModuleFactoryLocator7()) {
@@ -3111,13 +3416,18 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return await this._bootMutex.runExclusive(async () => {
       await this.eventBus.start();
       if (this.kernel?.status === "created") {
-        await this.kernel.boot(await boot(), { locator: fullLocator, kernelDrivers: [] });
+        await this.kernel.boot(await boot(), {
+          locator: fullLocator,
+          kernelDrivers: []
+        });
       }
       if (this.kernel?.status !== "booted") {
         throw new Error("Kernel not booted");
       }
       assertEx23(this._root === void 0, () => "XyOs already booted");
-      const [root] = await _XyOs.monitor(async () => await loadOsNode(wallet, fullLocator), { name: "Load XyOs" });
+      const [root] = await _XyOs.monitor(async () => await loadOsNode(wallet, fullLocator), {
+        name: "Load XyOs"
+      });
       this._root = root;
       this.stackManager.initialize(this);
       if (this.signers) await this.signers.initialize();
@@ -3149,25 +3459,30 @@ var XyOs = class _XyOs extends XyOsContextBase {
 // src/classes/cache/RunningDappCache.ts
 var findOrCreateMutex = new Mutex3();
 var RunningDappCache = class _RunningDappCache {
+  static {
+    __name(this, "RunningDappCache");
+  }
   static _cache = {};
   static async findOrCreate(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork) {
     const dappId = dapp.config.name;
-    return await XyOs.monitor(
-      async () => await findOrCreateMutex.runExclusive(async () => {
-        const existingWindowDappSet = _RunningDappCache.get(dappId);
-        if (existingWindowDappSet) {
-          console.debug("[DEBUG]", `RunningDappCache, using existing node for ${dappId}`);
-          const existingDappContext = assertEx24(existingWindowDappSet.context, () => "No context found in existing dapp node");
-          await DappContextCreator.primeDappArchivist(existingDappContext, xyOs, dappId);
-          return existingWindowDappSet;
-        }
-        console.debug("[DEBUG]", "RunningDappCache:creating", dappId);
-        const windowDappSet = await createDappContext(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork);
-        _RunningDappCache.set(dappId, windowDappSet);
-        return windowDappSet;
-      }),
-      { additionalProperties: { dappId }, name: "Loading dApp" }
-    );
+    return await XyOs.monitor(async () => await findOrCreateMutex.runExclusive(async () => {
+      const existingWindowDappSet = _RunningDappCache.get(dappId);
+      if (existingWindowDappSet) {
+        console.debug("[DEBUG]", `RunningDappCache, using existing node for ${dappId}`);
+        const existingDappContext = assertEx24(existingWindowDappSet.context, () => "No context found in existing dapp node");
+        await DappContextCreator.primeDappArchivist(existingDappContext, xyOs, dappId);
+        return existingWindowDappSet;
+      }
+      console.debug("[DEBUG]", "RunningDappCache:creating", dappId);
+      const windowDappSet = await createDappContext(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork);
+      _RunningDappCache.set(dappId, windowDappSet);
+      return windowDappSet;
+    }), {
+      additionalProperties: {
+        dappId
+      },
+      name: "Loading dApp"
+    });
   }
   static get(key) {
     return this._cache[key];
@@ -3182,6 +3497,12 @@ var RunningDappCache = class _RunningDappCache {
 
 // src/access-interfaces/registered-names/helpers/AccessNodeQueries.ts
 var AccessNodeQueries = class {
+  static {
+    __name(this, "AccessNodeQueries");
+  }
+  xyOsContext;
+  accessRequest;
+  registeredDappAccess;
   constructor(xyOsContext, accessRequest, registeredDappAccess) {
     this.xyOsContext = xyOsContext;
     this.accessRequest = accessRequest;
@@ -3218,10 +3539,7 @@ var AccessNodeQueries = class {
     await archivist.insert(payloads);
   }
   async resolveArchivistFromAccessNode() {
-    const archivist = assertEx25(
-      await this.nameServiceNamesAccessNode.resolve("PublicXnsArchivist"),
-      () => "Unable to find archivist at PublicXnsArchivist"
-    );
+    const archivist = assertEx25(await this.nameServiceNamesAccessNode.resolve("PublicXnsArchivist"), () => "Unable to find archivist at PublicXnsArchivist");
     return asArchivistInstance7(archivist, () => "PublicXnsArchivist is not an archivist");
   }
 };
@@ -3234,28 +3552,32 @@ var XnsArchivistPayloadDivinerModuleName = "XnsArchivistPayloadDiviner";
 var XnsArchivistModuleName = "XnsArchivist";
 var XnsRegistrationsArchivistModuleName = "XnsRegistrationsArchivist";
 var AbstractXnsCaller = class {
+  static {
+    __name(this, "AbstractXnsCaller");
+  }
+  context;
   constructor(context) {
     this.context = context;
   }
   /**
-   * Get the XnsArchivist
-   */
+  * Get the XnsArchivist
+  */
   async getXnsArchivist(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistModuleName}` : XnsArchivistModuleName;
     const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
     return asArchivistInstance8(mod, () => `${fullyQualifiedPath} is not an archivist`);
   }
   /**
-   * Get the XnsArchivistPayloadDiviner
-   */
+  * Get the XnsArchivistPayloadDiviner
+  */
   async getXnsArchivistPayloadDiviner(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistPayloadDivinerModuleName}` : XnsArchivistPayloadDivinerModuleName;
     const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
     return asDivinerInstance5(mod, () => `${fullyQualifiedPath} is not an diviner`);
   }
   /**
-   * Get the XnsRegistrationsArchivist
-   */
+  * Get the XnsRegistrationsArchivist
+  */
   async getXnsRegistrationsArchivist(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsRegistrationsArchivistModuleName}` : XnsRegistrationsArchivistModuleName;
     const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
@@ -3271,35 +3593,46 @@ import { isTemporalIndexingDivinerResultIndex } from "@xyo-network/diviner-tempo
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema11 } from "@xyo-network/diviner-payload-model";
 import { TemporalIndexingDivinerResultIndexSchema } from "@xyo-network/diviner-temporal-indexing-model";
 var XnsRegistrationsResourceQueries = {
-  getAllRegistrations: async (diviner) => {
+  getAllRegistrations: /* @__PURE__ */ __name(async (diviner) => {
     const query = {
       limit: 100,
       order: "desc",
       schema: PayloadDivinerQuerySchema11,
-      schemas: [TemporalIndexingDivinerResultIndexSchema]
+      schemas: [
+        TemporalIndexingDivinerResultIndexSchema
+      ]
     };
-    return await diviner.divine([query]);
-  },
-  getRecentRegistrations: async (archivist) => {
+    return await diviner.divine([
+      query
+    ]);
+  }, "getAllRegistrations"),
+  getRecentRegistrations: /* @__PURE__ */ __name(async (archivist) => {
     return (await archivist.all()).reverse();
-  }
+  }, "getRecentRegistrations")
 };
 
 // src/access-interfaces/registered-names/helpers/resource/RegistrationsResource.ts
 var XnsRegistrationsResource = class extends AbstractXnsCaller {
-  constructor(context, pathPrefix) {
-    super(context);
-    this.pathPrefix = pathPrefix;
+  static {
+    __name(this, "XnsRegistrationsResource");
   }
+  pathPrefix;
   _allRegistrations;
+  constructor(context, pathPrefix) {
+    super(context), this.pathPrefix = pathPrefix;
+  }
   get allRegistrations() {
     return assertEx27(this._allRegistrations);
   }
   get subscriptions() {
-    return { allRegistrations: (cb) => this.allRegistrations.subscribe(cb) };
+    return {
+      allRegistrations: /* @__PURE__ */ __name((cb) => this.allRegistrations.subscribe(cb), "allRegistrations")
+    };
   }
   get views() {
-    return { allRegistrations: () => this.allRegistrations.getSnapshot() };
+    return {
+      allRegistrations: /* @__PURE__ */ __name(() => this.allRegistrations.getSnapshot(), "allRegistrations")
+    };
   }
   cleanupListeners() {
     this.allRegistrations.cleanupListeners();
@@ -3309,7 +3642,7 @@ var XnsRegistrationsResource = class extends AbstractXnsCaller {
     const xnsArchivist = await this.getXnsArchivist(this.pathPrefix);
     this._allRegistrations = await PayloadStore.create({
       archivist: xnsArchivist,
-      getLatest: async () => await XnsRegistrationsResourceQueries.getAllRegistrations(xnsArchivistPayloadDiviner),
+      getLatest: /* @__PURE__ */ __name(async () => await XnsRegistrationsResourceQueries.getAllRegistrations(xnsArchivistPayloadDiviner), "getLatest"),
       idFunction: isTemporalIndexingDivinerResultIndex
     });
   }
@@ -3317,15 +3650,24 @@ var XnsRegistrationsResource = class extends AbstractXnsCaller {
 
 // src/access-interfaces/ValidDappAccessInterfaces.ts
 import { RegisteredNames, RegisteredNamesInterface } from "@xyo-network/os-model";
-var ValidDappAccessInterfaces = { [RegisteredNames]: RegisteredNamesInterface };
+var ValidDappAccessInterfaces = {
+  [RegisteredNames]: RegisteredNamesInterface
+};
 
 // src/helpers/monitor/XyOsMonitor.ts
 var DEFAULT_MONITORING_EVENT_NAME = "System Task Duration";
 globalThis.getXyOsGlobal = globalThis.getXyOsGlobal ?? (() => {
-  return { tracking: { trackEvent: (_event, _properties) => void 0 } };
+  return {
+    tracking: {
+      trackEvent: /* @__PURE__ */ __name((_event, _properties) => void 0, "trackEvent")
+    }
+  };
 });
 var xyOsGlobal = globalThis.getXyOsGlobal();
 var XyOsMonitor = class _XyOsMonitor {
+  static {
+    __name(this, "XyOsMonitor");
+  }
   static trackEvent = xyOsGlobal.tracking.trackEvent;
   performanceTimers = /* @__PURE__ */ new Map();
   startTimer(name) {
@@ -3352,21 +3694,24 @@ var XyOsMonitor = class _XyOsMonitor {
 };
 
 // src/profileModuleEvents.ts
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
 var DISPLAY_EVENT_COUNT_FREQUENCY = 100;
 var profileData = {};
-var profileModuleEvents = (mod) => {
+var profileModuleEvents = /* @__PURE__ */ __name((mod) => {
   const modRef = new WeakRef(mod);
   mod.onAny(async (eventName, args) => {
     const mod2 = modRef.deref();
     if (mod2) {
-      const data = profileData[mod2.address] ?? { allEventCount: 0, eventCounts: {} };
+      const data = profileData[mod2.address] ?? {
+        allEventCount: 0,
+        eventCounts: {}
+      };
       profileData[mod2.address] = data;
       data.allEventCount += 1;
       data.eventCounts[eventName] = (data.eventCounts[eventName] ?? 0) + 1;
       if (eventName === "querySendStarted") {
         const { query, payloads = [] } = args;
-        const pairs = await PayloadBuilder10.dataHashPairs(payloads);
+        const pairs = await PayloadBuilder9.dataHashPairs(payloads);
         const foundPair = pairs.find(([, hash]) => hash === query.query);
         if (foundPair) {
           const [payload] = foundPair;
@@ -3383,13 +3728,17 @@ var profileModuleEvents = (mod) => {
       }
     }
   });
-};
+}, "profileModuleEvents");
 
 // src/PubSubBridgeCaller.ts
 import { assertEx as assertEx28 } from "@xylabs/assert";
 import { asBridgeInstance } from "@xyo-network/bridge-model";
 import { BridgedPubSubModuleName } from "@xyo-network/os-model";
 var PubSubBridgeCaller = class {
+  static {
+    __name(this, "PubSubBridgeCaller");
+  }
+  node;
   constructor(node) {
     this.node = node;
   }