@xyo-network/os-runtime 7.0.0 → 7.1.0

package/dist/node/index.mjs

@@ -1,6 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/access/Caller.ts
 import { assertEx as assertEx16 } from "@xylabs/assert";
 import { ModuleFactoryLocator as ModuleFactoryLocator9 } from "@xyo-network/module-factory-locator";
@@ -18,9 +15,6 @@ var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
 var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
 var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
 var OsCallerBase = class {
-  static {
-    __name(this, "OsCallerBase");
-  }
   context;
   constructor(context) {
     this.context = context;
@@ -28,37 +22,39 @@ var OsCallerBase = class {
   // Get the dapps archivist
   async getDappsArchivist() {
     const mod = assertEx(await this.context.root.resolve(DappsArchivistModuleName), () => `${DappsArchivistModuleName} not found`);
-    return asArchivistInstance(mod, () => `${DappsArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance(mod, () => `${DappsArchivistModuleName} is not an archivist`, { required: true });
   }
   // Get the dapps archivist development
   async getDappsArchivistDevelopment() {
-    const mod = assertEx(await this.context.root.resolve(DappsArchivistDevelopmentModuleName), () => `${DappsArchivistDevelopmentModuleName} not found`);
-    return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`, {
-      required: true
-    });
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
+      () => `${DappsArchivistDevelopmentModuleName} not found`
+    );
+    return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`, { required: true });
   }
   // Get the dapps archivist payload diviner
   async getDappsArchivistPayloadDiviner() {
-    const mod = assertEx(await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName), () => `${DappsArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
+      () => `${DappsArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
   }
   // Get the dapps archivist payload diviner development
   async getDappsArchivistPayloadDivinerDevelopment() {
-    const mod = assertEx(await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName), () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`);
-    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
+      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`
+    );
+    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`, { required: true });
   }
   // Get the registered dapp interfaces archivist
   async getRegisteredDappInterfacesArchivist() {
-    const mod = assertEx(await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName), () => `${RegisteredDappInterfacesArchivistModuleName} not found`);
-    return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    const mod = assertEx(
+      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
+      () => `${RegisteredDappInterfacesArchivistModuleName} not found`
+    );
+    return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`, { required: true });
   }
 };
 
@@ -77,16 +73,14 @@ import { DappWalletSeedPhraseSchema } from "@xyo-network/os-model";
 import { HDWallet } from "@xyo-network/wallet";
 import { v4 as uuid } from "uuid";
 var DappSeedPhraseRepository = class extends OsCallerBase {
-  static {
-    __name(this, "DappSeedPhraseRepository");
-  }
   allowedNames;
   // record of all dapps that have requested a seed phrase with the OS
   dappIdRepository = /* @__PURE__ */ new Map();
   // record of all walletIds that have been issued to registered dapps
   walletIdRepository = /* @__PURE__ */ new Map();
   constructor(xyOs, allowedNames) {
-    super(xyOs), this.allowedNames = allowedNames;
+    super(xyOs);
+    this.allowedNames = allowedNames;
   }
   async add(dappId) {
     const archivist = await this.getDappsArchivist();
@@ -98,9 +92,7 @@ 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;
@@ -132,13 +124,9 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema,
-      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) {
@@ -147,14 +135,10 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema,
-      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() {
@@ -179,54 +163,50 @@ 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 = assertEx2(await this.context.root.resolve(DappArchivistModuleName), () => `${DappArchivistModuleName} not found [${toSafeJsonString(this.context.root.publicChildren())}]`);
-    return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    const mod = assertEx2(
+      await this.context.root.resolve(DappArchivistModuleName),
+      () => `${DappArchivistModuleName} not found [${toSafeJsonString(this.context.root.publicChildren())}]`
+    );
+    return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`, { required: true });
   }
   /**
-  * Get the DappArchivistPayloadDiviner
-  */
+   * Get the DappArchivistPayloadDiviner
+   */
   async getDappArchivistPayloadDiviner() {
-    const mod = assertEx2(await this.context.root.resolve(DappArchivistPayloadDivinerModuleName), () => `${DappArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx2(
+      await this.context.root.resolve(DappArchivistPayloadDivinerModuleName),
+      () => `${DappArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
   }
   /**
-  * Get the IntentArchivist
-  */
+   * Get the IntentArchivist
+   */
   async getDappIntentArchivist() {
     const mod = assertEx2(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`);
-    return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`, { required: true });
   }
   // Get the IntentArchivistPayloadDiviner
   async getDappIntentArchivistPayloadDiviner() {
-    const mod = assertEx2(await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName), () => `${IntentArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx2(
+      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
+      () => `${IntentArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
   }
 };
 
 // src/manifest/manifestReplacementTokens.ts
 import { getXnsDomain } from "@xyo-network/kernel";
-var manifestReplacementTokens = /* @__PURE__ */ __name((xnsNodeUrl, xnsNetwork) => ({
-  "[REPLACE_WITH_NS_NODE_URL]": getXnsDomain(xnsNodeUrl, xnsNetwork)
-}), "manifestReplacementTokens");
+var manifestReplacementTokens = (xnsNodeUrl, xnsNetwork) => ({ "[REPLACE_WITH_NS_NODE_URL]": getXnsDomain(xnsNodeUrl, xnsNetwork) });
 
 // src/manifest/os-node.manifest.json
 var os_node_manifest_default = {
@@ -366,13 +346,10 @@ var os_node_manifest_default = {
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 
 // src/classes/lib/Insertable.ts
-var createInsertable = /* @__PURE__ */ __name((insertable, ...params) => new insertable(...params), "createInsertable");
+var createInsertable = (insertable, ...params) => new insertable(...params);
 
 // src/dapp/context/creator/DefaultPayloads/DappAccessPayloads.ts
 var DappAccessPayloads = class {
-  static {
-    __name(this, "DappAccessPayloads");
-  }
   context;
   constructor(context, _dappName) {
     this.context = context;
@@ -387,12 +364,9 @@ var DappAccessPayloads = class {
 // src/dapp/context/creator/DefaultPayloads/NodeInfoPayload.ts
 import { NodeOsInfoSchema } from "@xyo-network/os-model";
 var NodeInfoPayload = class {
-  static {
-    __name(this, "NodeInfoPayload");
-  }
   _context;
-  constructor(_context, _dappName) {
-    this._context = _context;
+  constructor(context, _dappName) {
+    this._context = context;
   }
   async payloads() {
     const exposedNode = this._context.exposedNode;
@@ -406,30 +380,22 @@ var NodeInfoPayload = class {
       publicAddress: exposedNode?.address ?? "",
       schema: NodeOsInfoSchema
     };
-    return [
-      nodeOsInfo
-    ];
+    return [nodeOsInfo];
   }
 };
 
 // src/dapp/context/creator/DefaultPayloads/DefaultPayloads.ts
 var DefaultPayloads = class {
-  static {
-    __name(this, "DefaultPayloads");
-  }
   dappArchivist;
-  xyOs;
   dappName;
+  xyOs;
   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);
@@ -437,31 +403,19 @@ var DefaultPayloads = class {
       insertPayloads.push(...payloads);
     }
     for (const payload of insertPayloads) {
-      const [existing] = await this.dappArchivist.get([
-        await PayloadBuilder.dataHash(payload)
-      ]);
+      const [existing] = await this.dappArchivist.get([await PayloadBuilder.dataHash(payload)]);
       if (existing) continue;
-      await this.dappArchivist.insert([
-        payload
-      ]);
+      await this.dappArchivist.insert([payload]);
     }
   }
 };
 
 // src/dapp/context/creator/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;
+  dappWindowNode;
   externalPermissions;
   constructor(context, dappWindowNode, dappName, externalPermissions) {
     this.context = context;
@@ -499,17 +453,14 @@ var ExternalModulePermissions = class {
 
 // src/dapp/context/creator/Creator.ts
 var DappContextCreator = class _DappContextCreator {
-  static {
-    __name(this, "DappContextCreator");
-  }
-  targetDappManifestParams;
-  dappId;
+  // 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";
   context;
-  rootWallet;
+  dappId;
   externalPermissions;
+  rootWallet;
   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";
+  targetDappManifestParams;
   constructor(targetDappManifestParams, dappId, context, rootWallet, externalPermissions, sharedLocator) {
     this.targetDappManifestParams = targetDappManifestParams;
     this.dappId = dappId;
@@ -519,8 +470,18 @@ var DappContextCreator = class _DappContextCreator {
     this.sharedLocator = sharedLocator;
   }
   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);
@@ -555,10 +516,7 @@ 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);
@@ -579,15 +537,13 @@ var DappContextCreator = class _DappContextCreator {
 };
 
 // src/dapp/context/creator/createDappContext.ts
-var GenericPayloadDivinerTags = {
-  "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
-};
-var resolveLocator = /* @__PURE__ */ __name((existingLocator) => {
+var GenericPayloadDivinerTags = { "network.xyo.generic.payload.diviner": "GenericPayloadDiviner" };
+var resolveLocator = (existingLocator) => {
   const locator = existingLocator ?? new ModuleFactoryLocator2();
   locator.register(GenericPayloadDiviner.factory(), GenericPayloadDivinerTags);
   return locator;
-}, "resolveLocator");
-var createDappContext = /* @__PURE__ */ __name(async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwork) => {
+};
+var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwork) => {
   console.log("createNodes");
   try {
     const dappSeedPhraseRepository = new DappSeedPhraseRepository(context, allowedNames);
@@ -600,10 +556,7 @@ var createDappContext = /* @__PURE__ */ __name(async (dapp, context, allowedName
     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
@@ -620,7 +573,7 @@ var createDappContext = /* @__PURE__ */ __name(async (dapp, context, allowedName
     console.error(`Error creating dappWindow node: ${error.stack}`);
     throw new Error(`Error creating dappWindow node: ${error.message}`);
   }
-}, "createDappContext");
+};
 
 // src/XyOs.ts
 import { assertEx as assertEx14 } from "@xylabs/assert";
@@ -632,9 +585,6 @@ import { ModuleFactoryLocator as ModuleFactoryLocator8 } from "@xyo-network/modu
 import { assertEx as assertEx4 } from "@xylabs/assert";
 import { BaseEmitter } from "@xylabs/events";
 var EventBusConnection = class extends BaseEmitter {
-  static {
-    __name(this, "EventBusConnection");
-  }
   _id;
   description;
   type;
@@ -657,14 +607,14 @@ import { assertEx as assertEx5 } from "@xylabs/assert";
 import { forget } from "@xylabs/forget";
 import { asArchivistInstance as asArchivistInstance4 } from "@xyo-network/archivist";
 import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-import { asOptionalEventBusEvent, isPubSubConnections } from "@xyo-network/os-model";
+import {
+  asOptionalEventBusEvent,
+  isPubSubConnections
+} from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder2 } 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
@@ -673,9 +623,11 @@ var EventBus = class {
   publisherCallbacks = {};
   startMutex = new Mutex();
   get archivist() {
-    return asArchivistInstance4(assertEx5(this._archivist, () => "Archivist not found.  Did you forget to call start()?"), "not a valid archivist instance", {
-      required: true
-    });
+    return asArchivistInstance4(
+      assertEx5(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
+      "not a valid archivist instance",
+      { required: true }
+    );
   }
   addConnection(connection) {
     const id = uuid2();
@@ -704,12 +656,7 @@ 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 = findAs(payloads, asOptionalEventBusEvent);
         if (!eventBusEvent) return;
@@ -719,9 +666,7 @@ var EventBus = class {
             for (const [eventName, callback] of connection.subscribableEvents.entries()) {
               if (eventName !== eventBusEvent.name) continue;
               if (callback) {
-                const forgettable = /* @__PURE__ */ __name(async () => await callback({
-                  payloads
-                }), "forgettable");
+                const forgettable = async () => await callback({ payloads });
                 forget(forgettable());
               }
             }
@@ -733,22 +678,16 @@ var EventBus = class {
   }
   handlePublisherAdd(connection) {
     for (const eventName of connection.publishableEvents ?? []) {
-      const connectionPublisherCallback = /* @__PURE__ */ __name(async ({ payloads }) => {
-        const event = {
-          name: eventName,
-          schema: "network.xyo.event.bus.event"
-        };
+      const connectionPublisherCallback = async ({ payloads }) => {
+        const event = { name: eventName, schema: "network.xyo.event.bus.event" };
         const eventPayloads = payloads ?? [];
         event.sources = await PayloadBuilder2.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;
@@ -765,9 +704,6 @@ var EventBus = class {
 
 // src/event/bus/PubSubConnection.ts
 var EventBusPubSubConnection = class extends EventBusConnection {
-  static {
-    __name(this, "EventBusPubSubConnection");
-  }
   publishableEvents;
   subscribableEvents;
   constructor(request) {
@@ -783,79 +719,65 @@ var EventBusPubSubConnection = class extends EventBusConnection {
 // src/event/connections/DappAccessRequest.ts
 var DappAccessRequestEvent = "dappAccessRequest";
 var dappAccessRequestConnectionRequest = {
-  publishableEvents: [
-    DappAccessRequestEvent
-  ],
+  publishableEvents: [DappAccessRequestEvent],
   type: "PubSub"
 };
-var dappAccessRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(dappAccessRequestConnectionRequest), "dappAccessRequestConnection");
+var dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest);
 
 // src/event/connections/DappsReady.ts
 var dappsReadyConnectionRequest = {
-  publishableEvents: [
-    "dappsReady"
-  ],
+  publishableEvents: ["dappsReady"],
   type: "PubSub"
 };
-var dappsReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(dappsReadyConnectionRequest), "dappsReadyConnection");
+var dappsReadyConnection = () => new EventBusPubSubConnection(dappsReadyConnectionRequest);
 
 // src/event/connections/ExposeDappRequest.ts
 var ExposeDappRequestEvent = "exposeDappRequest";
 var exposeDappConnectionRequest = {
-  publishableEvents: [
-    ExposeDappRequestEvent
-  ],
+  publishableEvents: [ExposeDappRequestEvent],
   type: "PubSub"
 };
-var exposeDappRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(exposeDappConnectionRequest), "exposeDappRequestConnection");
+var exposeDappRequestConnection = () => new EventBusPubSubConnection(exposeDappConnectionRequest);
 
 // src/event/connections/OsPubSubNetworkReady.ts
 var OsPubSubNetworkReadyEvent = "osPubSubNetworkReady";
 var osPubSubNetworkConnectionRequest = {
-  publishableEvents: [
-    OsPubSubNetworkReadyEvent
-  ],
+  publishableEvents: [OsPubSubNetworkReadyEvent],
   type: "PubSub"
 };
-var osPubSubNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest), "osPubSubNetworkReadyConnection");
+var osPubSubNetworkReadyConnection = () => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest);
 
 // src/event/connections/OsSettingsReady.ts
 var OsSettingsReadyEvent = "osSettingsReady";
 var osSettingsConnectionRequest = {
-  publishableEvents: [
-    OsSettingsReadyEvent
-  ],
+  publishableEvents: [OsSettingsReadyEvent],
   type: "PubSub"
 };
-var osSettingsReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osSettingsConnectionRequest), "osSettingsReadyConnection");
+var osSettingsReadyConnection = () => new EventBusPubSubConnection(osSettingsConnectionRequest);
 
 // src/event/connections/OsXyoPublicReady.ts
 var OsXyoPublicNetworkReadyEvent = "osXyoPublicNetworkReady";
 var osXyoPublicNetworkConnectionRequest = {
-  publishableEvents: [
-    OsXyoPublicNetworkReadyEvent
-  ],
+  publishableEvents: [OsXyoPublicNetworkReadyEvent],
   type: "PubSub"
 };
-var osXyoPublicNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest), "osXyoPublicNetworkReadyConnection");
+var osXyoPublicNetworkReadyConnection = () => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest);
 
 // src/lib/initializeXns.ts
 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 = /* @__PURE__ */ __name(async (xnsNode) => {
+var initializeXns = 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/isEqual.ts
 import { isObject } from "@xylabs/object";
@@ -888,26 +810,25 @@ function isEqual(a, b) {
   }
   return false;
 }
-__name(isEqual, "isEqual");
 
 // src/lib/isPayload.ts
 import { AsObjectFactory } from "@xylabs/object";
-var isObject2 = /* @__PURE__ */ __name((x) => {
+var isObject2 = (x) => {
   return typeof x === "object" && !Array.isArray(x);
-}, "isObject");
-var isAnyPayload = /* @__PURE__ */ __name((obj) => {
+};
+var isAnyPayload = (obj) => {
   if (isObject2(obj)) {
     return typeof obj.schema === "string";
   }
   return false;
-}, "isAnyPayload");
-var isPayload = /* @__PURE__ */ __name((schema) => (obj) => {
+};
+var isPayload = (schema) => (obj) => {
   if (isAnyPayload(obj)) {
     return schema.includes(obj.schema);
   }
   return false;
-}, "isPayload");
-var asPayload = /* @__PURE__ */ __name((schema) => AsObjectFactory.create(isPayload(schema)), "asPayload");
+};
+var asPayload = (schema) => AsObjectFactory.create(isPayload(schema));
 
 // src/lib/ModuleNames.ts
 var DevelopArchivist = "DevelopArchivist";
@@ -915,15 +836,9 @@ 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",
@@ -943,9 +858,6 @@ var ModuleOffsetPaths = {
 
 // src/lib/NameTransforms.ts
 var NameTransforms = class _NameTransforms {
-  static {
-    __name(this, "NameTransforms");
-  }
   value;
   constructor(value) {
     this.value = value;
@@ -972,11 +884,8 @@ var NameTransforms = class _NameTransforms {
 
 // src/lib/PayloadStore.ts
 var PayloadStore = class {
-  static {
-    __name(this, "PayloadStore");
-  }
-  archivist;
   latest = [];
+  archivist;
   deleteListeners = [];
   insertListeners = [];
   listeners = [];
@@ -984,22 +893,26 @@ var PayloadStore = class {
     this.archivist = archivist;
   }
   /**
-  * 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 = /* @__PURE__ */ __name(async ({ payloads }) => {
+    const insertListener = async ({ payloads }) => {
       if (payloads.some(idFunction)) {
         const latest = await getLatest();
         if (isEqual(latest, instance.latest)) return;
         instance.latest = latest;
         instance.emitChange();
       }
-    }, "insertListener");
-    const deleteListener = /* @__PURE__ */ __name(async () => {
+    };
+    const deleteListener = async () => {
       instance.latest = await getLatest();
       instance.emitChange();
-    }, "deleteListener");
+    };
     const weakRefInsertListener = new WeakRef(insertListener);
     const weakRefDeleteListener = new WeakRef(deleteListener);
     const insertListenerRef = weakRefInsertListener.deref();
@@ -1012,8 +925,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");
@@ -1021,16 +934,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 () => {
@@ -1053,23 +966,20 @@ var PayloadStore = class {
 
 // src/lib/tokenPlacesSplit.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
-var tokenPlacesSplit = /* @__PURE__ */ __name((value, places) => {
+var tokenPlacesSplit = (value, places) => {
   assertEx6(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
-  ];
-}, "tokenPlacesSplit");
-var tokenPlacesSplitString = /* @__PURE__ */ __name((value, places) => {
+  return [wholeValue, remainder];
+};
+var tokenPlacesSplitString = (value, places) => {
   if (value === void 0) {
     return "-";
   }
   const [wholeValue, remainder] = tokenPlacesSplit(value, places);
   return `${wholeValue}.${remainder.toString().padStart(Math.abs(places), "0")}`;
-}, "tokenPlacesSplitString");
+};
 
 // src/loadOsNode.ts
 import { IndexedDbArchivist } from "@xyo-network/archivist-indexeddb";
@@ -1077,59 +987,55 @@ import { IndexedDbPayloadDiviner } from "@xyo-network/diviner-payload-indexeddb"
 import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
 import { ModuleFactoryLocator as ModuleFactoryLocator3 } from "@xyo-network/module-factory-locator";
 var OS_NODE_PATH = "1'";
-var getDefaultOsNodeLocator = /* @__PURE__ */ __name(() => {
+var getDefaultOsNodeLocator = () => {
   const locator = new ModuleFactoryLocator3();
-  locator.register(IndexedDbArchivist.factory(), {
-    "network.xyo.archivist.persistence.scope": "device"
-  });
-  locator.register(IndexedDbPayloadDiviner.factory(), {
-    "network.xyo.archivist.persistence.scope": "device"
-  });
+  locator.register(IndexedDbArchivist.factory(), { "network.xyo.archivist.persistence.scope": "device" });
+  locator.register(IndexedDbPayloadDiviner.factory(), { "network.xyo.archivist.persistence.scope": "device" });
   return locator;
-}, "getDefaultOsNodeLocator");
-var loadOsNode = /* @__PURE__ */ __name(async (osWallet, locator) => {
+};
+var loadOsNode = async (osWallet, locator) => {
   try {
     const osNodeWallet = await osWallet.derivePath(OS_NODE_PATH);
     const osNodeLocator = locator ?? getDefaultOsNodeLocator();
     const manifestWrapper = new ManifestWrapper(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/registration/DappRegistrationService.ts
 import { forget as forget2 } from "@xylabs/forget";
 import { fulfilled, rejected } from "@xylabs/promise";
 import { ModuleFactoryLocator as ModuleFactoryLocator7 } from "@xyo-network/module-factory-locator";
-import { DappIntentTypes, DappMode as DappMode2, isRegisteredDappAccessDappSet, isRegisteredDappExposedDappSet } from "@xyo-network/os-model";
+import {
+  DappIntentTypes,
+  DappMode as DappMode2,
+  isRegisteredDappAccessDappSet,
+  isRegisteredDappExposedDappSet
+} from "@xyo-network/os-model";
 
 // src/intent/Caller.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema2 } 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,
@@ -1145,9 +1051,7 @@ 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() {
@@ -1168,9 +1072,7 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
       schema: PayloadDivinerQuerySchema2,
       sourceDappId: dappName
     };
-    return await diviner.divine([
-      query
-    ]);
+    return await diviner.divine([query]);
   }
 };
 
@@ -1179,9 +1081,6 @@ 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) {
@@ -1195,14 +1094,14 @@ var DappIntentResource = class extends DappCallerBase {
   }
   get subscriptions() {
     return {
-      allDappIntents: /* @__PURE__ */ __name((cb) => this.allDappIntents.subscribe(cb), "allDappIntents"),
-      latestDappIntent: /* @__PURE__ */ __name((cb) => this.latestDappIntent.subscribe(cb), "latestDappIntent")
+      allDappIntents: (cb) => this.allDappIntents.subscribe(cb),
+      latestDappIntent: (cb) => this.latestDappIntent.subscribe(cb)
     };
   }
   get views() {
     return {
-      allDappIntents: /* @__PURE__ */ __name(() => this.allDappIntents.getSnapshot(), "allDappIntents"),
-      latestDappIntent: /* @__PURE__ */ __name(() => this.latestDappIntent.getSnapshot(), "latestDappIntent")
+      allDappIntents: () => this.allDappIntents.getSnapshot(),
+      latestDappIntent: () => this.latestDappIntent.getSnapshot()
     };
   }
   cleanupListeners() {
@@ -1213,18 +1112,16 @@ var DappIntentResource = class extends DappCallerBase {
     const archivist = await this.getDappIntentArchivist();
     this._allDappIntents = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await archivist.all(), "getLatest"),
+      getLatest: async () => await archivist.all(),
       idFunction: isDappIntent
     });
     this._latestDappIntent = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => {
+      getLatest: 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
     });
   }
@@ -1236,7 +1133,12 @@ import semver from "semver";
 
 // src/system/Queries.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema3 } 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 PayloadBuilder3 } from "@xyo-network/payload-builder";
 var SystemDappQueries = {
   async getDappAccess(diviner, name, version) {
@@ -1244,14 +1146,10 @@ var SystemDappQueries = {
       order: "desc",
       registeringDappId: name,
       schema: PayloadDivinerQuerySchema3,
-      schemas: [
-        UnregisteredDappAccessSchema
-      ],
+      schemas: [UnregisteredDappAccessSchema],
       version
     };
-    return await diviner.divine([
-      accessQuery
-    ]);
+    return await diviner.divine([accessQuery]);
   },
   async getLatestConfig(diviner, name) {
     const configQuery = {
@@ -1259,13 +1157,9 @@ var SystemDappQueries = {
       name,
       order: "desc",
       schema: PayloadDivinerQuerySchema3,
-      schemas: [
-        DappConfigSchema
-      ]
+      schemas: [DappConfigSchema]
     };
-    const [dappConfig] = await diviner.divine([
-      configQuery
-    ]);
+    const [dappConfig] = await diviner.divine([configQuery]);
     return dappConfig;
   },
   async getLatestIcon(diviner, name, version) {
@@ -1273,14 +1167,10 @@ var SystemDappQueries = {
       name,
       order: "desc",
       schema: PayloadDivinerQuerySchema3,
-      schemas: [
-        DappIconSchema
-      ],
+      schemas: [DappIconSchema],
       version
     };
-    const [dappIcon] = await diviner.divine([
-      iconQuery
-    ]);
+    const [dappIcon] = await diviner.divine([iconQuery]);
     return dappIcon;
   },
   async getWidgetConfigs(diviner, name, version) {
@@ -1288,14 +1178,10 @@ var SystemDappQueries = {
       dappId: name,
       order: "desc",
       schema: PayloadDivinerQuerySchema3,
-      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 PayloadBuilder3.dataHash(widgetConfig);
@@ -1307,28 +1193,30 @@ var SystemDappQueries = {
 
 // src/system/ManageSystemDapps.ts
 var ManageSystemDapps = class extends OsCallerBase {
-  static {
-    __name(this, "ManageSystemDapps");
-  }
-  defaultSystemNames;
-  defaultSystemDapps;
   defaultSystemDappParams;
-  locator;
+  defaultSystemDapps;
+  defaultSystemNames;
   developmentMode;
+  locator;
   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;
   }
   /**
-  * 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();
@@ -1352,13 +1240,9 @@ 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 PayloadBuilder4.dataHash(systemDappPayload)
-        ]);
+        const [existing] = await archivist.get([await PayloadBuilder4.dataHash(systemDappPayload)]);
         if (existing) continue;
-        await archivist.insert([
-          systemDappPayload
-        ]);
+        await archivist.insert([systemDappPayload]);
       }
       return true;
     } catch (e) {
@@ -1461,9 +1345,6 @@ import { BaseEmitter as BaseEmitter2 } from "@xylabs/events";
 import { ModuleFactoryLocator as ModuleFactoryLocator4 } 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;
@@ -1547,15 +1428,10 @@ 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;
@@ -1567,12 +1443,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 assertEx9(this.parent.kernel, () => "Missing kernel");
   }
@@ -1591,17 +1467,15 @@ var XyOsDapp = class extends XyOsContextBase {
       assertEx9(this._root === void 0, () => "Dapp already booted");
       const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator5()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator5();
       console.log("XyOsDapp:boot:finalLocator", finalLocator);
-      const dappNodesWrapper = new ManifestWrapper2({
-        ...this.manifest,
-        schema: DappPackageManifestPayloadSchema2
-      }, wallet, finalLocator);
+      const dappNodesWrapper = new ManifestWrapper2({ ...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 ManifestWrapper2({
-        ...dapp_window_manifest_default,
-        schema: DappPackageManifestPayloadSchema2
-      }, dappManifestWallet, finalLocator);
+      const wrapper = new ManifestWrapper2(
+        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema2 },
+        dappManifestWallet,
+        finalLocator
+      );
       const node = await wrapper.loadNodeFromIndex(0);
       for (const dappNode of dappNodes) {
         await node.register(dappNode);
@@ -1618,7 +1492,11 @@ var XyOsDapp = class extends XyOsContextBase {
 };
 
 // src/registration/DappRegistry.ts
-import { DappRegisteredSchema, DappRegisteredState, isRegisteredDappAccess } from "@xyo-network/os-model";
+import {
+  DappRegisteredSchema,
+  DappRegisteredState,
+  isRegisteredDappAccess
+} from "@xyo-network/os-model";
 import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
 
 // src/registration/ValidateDappAccessDiviner/Config.ts
@@ -1631,23 +1509,20 @@ var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registra
 import { AbstractDiviner } from "@xyo-network/diviner-abstract";
 import { ManifestWrapper as ManifestWrapper3, PackageManifestPayloadSchema } from "@xyo-network/manifest";
 import { ModuleFactoryLocator as ModuleFactoryLocator6 } from "@xyo-network/module-factory-locator";
-import { isDappPackageManifestPayload, isUnregisteredDappAccess, RegisteredDappAccessSchema } from "@xyo-network/os-model";
+import {
+  isDappPackageManifestPayload,
+  isUnregisteredDappAccess,
+  RegisteredDappAccessSchema
+} from "@xyo-network/os-model";
 import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
 
 // src/models/access/ValidDappAccessInterfaces.ts
 import { RegisteredNames, RegisteredNamesInterface } from "@xyo-network/os-model";
-var ValidDappAccessInterfaces = {
-  [RegisteredNames]: RegisteredNamesInterface
-};
+var ValidDappAccessInterfaces = { [RegisteredNames]: RegisteredNamesInterface };
 
 // src/registration/ValidateDappAccessDiviner/Diviner.ts
 var ValidateDappAccessDiviner = class extends AbstractDiviner {
-  static {
-    __name(this, "ValidateDappAccessDiviner");
-  }
-  static configSchemas = [
-    ValidateDappAccessDivinerConfigSchema
-  ];
+  static configSchemas = [ValidateDappAccessDivinerConfigSchema];
   async divineHandler(payloads) {
     const dappManifest = payloads?.filter(isDappPackageManifestPayload);
     const accessors = payloads?.filter(isUnregisteredDappAccess);
@@ -1689,33 +1564,32 @@ var ValidateDappAccessDiviner = class extends AbstractDiviner {
           }
         }
       } catch (e) {
-        failedAccessors.push({
-          accessor: access,
-          errorMessage: e.message,
-          schema: FailedAccessorSchema
-        });
+        failedAccessors.push(
+          {
+            accessor: access,
+            errorMessage: e.message,
+            schema: FailedAccessorSchema
+          }
+        );
       }
     }
-    return [
-      ...registeredAccessors,
-      ...failedAccessors
-    ];
+    return [...registeredAccessors, ...failedAccessors];
   }
 };
-var compareChildren = /* @__PURE__ */ __name((interfaceChildren, dappChildren) => {
+var compareChildren = (interfaceChildren, dappChildren) => {
   return interfaceChildren.every((interfaceChild) => Object.values(interfaceChild).every((interfaceChildName) => dappChildren.some((dappChild) => Object.values(dappChild).includes(interfaceChildName))));
-}, "compareChildren");
-var dappPackageManifestToPackageManifest = /* @__PURE__ */ __name((dappPackageManifest) => {
+};
+var dappPackageManifestToPackageManifest = (dappPackageManifest) => {
   return {
     ...dappPackageManifest,
     schema: PackageManifestPayloadSchema
   };
-}, "dappPackageManifestToPackageManifest");
-var getChildrenFromNode = /* @__PURE__ */ __name(async (node) => {
+};
+var getChildrenFromNode = async (node) => {
   const nodeManifest = (await node.state())?.[0];
   return nodeManifest.status?.children;
-}, "getChildrenFromNode");
-var getNodeChildren = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
+};
+var getNodeChildren = async (manifestToTest, dappParams) => {
   const testNodes = await getNodeToTest(manifestToTest, dappParams);
   const children = [];
   for (const node of testNodes) {
@@ -1725,31 +1599,36 @@ var getNodeChildren = /* @__PURE__ */ __name(async (manifestToTest, dappParams)
     }
   }
   return children;
-}, "getNodeChildren");
-var getNodeToTest = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
+};
+var getNodeToTest = async (manifestToTest, dappParams) => {
   const dappManifestWrapper = new ManifestWrapper3(manifestToTest, await HDWallet3.random(), dappParams.locator ?? new ModuleFactoryLocator6());
   return await dappManifestWrapper.loadNodes();
-}, "getNodeToTest");
+};
 
 // src/registration/DappRegistry.ts
 var DappRegistry = class {
-  static {
-    __name(this, "DappRegistry");
-  }
-  dappSeedPhraseRepository;
   dappRegistry = /* @__PURE__ */ new Map();
+  dappSeedPhraseRepository;
   constructor(dappSeedPhraseRepository) {
     this.dappSeedPhraseRepository = dappSeedPhraseRepository;
   }
   /**
-  * 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);
@@ -1784,16 +1663,27 @@ 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,
@@ -1808,15 +1698,10 @@ 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(isRegisteredDappAccess);
     if (failedAccessors.length > 0) {
@@ -1828,13 +1713,6 @@ var DappRegistry = class {
 
 // src/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;
@@ -1846,28 +1724,36 @@ var DappRegistrationService = class {
   registeredDappSets = /* @__PURE__ */ new Set();
   // Dapps that have been registered with exposeDappRequests
   registeredExposedDappSets = /* @__PURE__ */ new Set();
+  context;
   dappAccessRequestConnection = dappAccessRequestConnection();
+  developmentMode;
   exposeDappRequestConnection = exposeDappRequestConnection();
-  constructor(context, params = {
-    dappNames: [],
-    dappParams: {},
-    dappPayloads: []
-  }, locator = new ModuleFactoryLocator7(), developmentMode) {
+  locator;
+  params;
+  constructor(context, params, locator = new ModuleFactoryLocator7(), developmentMode) {
     this.context = context;
-    this.params = params;
+    this.params = params ?? {
+      dappNames: [],
+      dappParams: {},
+      dappPayloads: []
+    };
     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.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();
   }
   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,
@@ -1880,43 +1766,37 @@ 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 = /* @__PURE__ */ __name(async () => {
-        try {
-          await this.postRegistrationHandlers(result);
-        } catch (e) {
-          console.error("Error in post registration handlers", e);
-        }
-      }, "forgetHandlers");
-      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 = async () => {
+          try {
+            await this.postRegistrationHandlers(result);
+          } catch (e) {
+            console.error("Error in post registration handlers", e);
+          }
+        };
+        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;
   }
@@ -1924,19 +1804,17 @@ var DappRegistrationService = class {
     if (registeredDapp.dapp) {
       if (isRegisteredDappExposedDappSet(registeredDapp)) {
         this.registeredExposedDappSets.add(registeredDapp);
-        const exposeIntent = DappIntentCaller.buildIntent(DappIntentCaller.OsDappName, DappIntentTypes.Launch, registeredDapp.dapp.config.name, DappMode2.Exposed);
-        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, {
-          payloads: [
-            registeredDapp.dapp.config,
-            exposeIntent
-          ]
-        });
+        const exposeIntent = DappIntentCaller.buildIntent(
+          DappIntentCaller.OsDappName,
+          DappIntentTypes.Launch,
+          registeredDapp.dapp.config.name,
+          DappMode2.Exposed
+        );
+        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, { payloads: [registeredDapp.dapp.config, exposeIntent] });
       }
       if (isRegisteredDappAccessDappSet(registeredDapp)) {
         this.registeredAccessDappSets.add(registeredDapp);
-        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, {
-          payloads: registeredDapp.dapp.accessors
-        });
+        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, { payloads: registeredDapp.dapp.accessors });
       }
     }
   }
@@ -1946,9 +1824,6 @@ var DappRegistrationService = class {
 import { assertEx as assertEx10 } from "@xylabs/assert";
 import { HDWallet as HDWallet5 } from "@xyo-network/wallet";
 var Signers = class {
-  static {
-    __name(this, "Signers");
-  }
   _paths;
   _signerAccounts;
   _walletStore;
@@ -2000,9 +1875,6 @@ import { forget as forget3 } from "@xylabs/forget";
 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
@@ -2037,95 +1909,84 @@ var StackBase = class extends BaseEmitter3 {
   initialize() {
     this.assignStack();
     for (const adapter of this.adapterSet) {
-      const driverReadyListener = /* @__PURE__ */ __name(async ({ node }) => await this.handleDriverReady(node), "driverReadyListener");
+      const driverReadyListener = async ({ node }) => await this.handleDriverReady(node);
       adapter.on("driverReady", driverReadyListener);
       this.listeners.push({
         adapter,
         eventName: "driverReady",
         listener: driverReadyListener
       });
-      const driverErrorListener = /* @__PURE__ */ __name(async ({ error }) => {
+      const driverErrorListener = async ({ error }) => {
         console.error(`Error updating ${this.stackNodeModuleId} stack node`, error);
-        await this.emit("driverError", {
-          error
-        });
-      }, "driverErrorListener");
+        await this.emit("driverError", { error });
+      };
       adapter.on("driverError", driverErrorListener);
       this.listeners.push({
         adapter,
         eventName: "driverError",
         listener: driverErrorListener
       });
-      const startAdapter = /* @__PURE__ */ __name(async () => await adapter.start(), "startAdapter");
+      const startAdapter = async () => await adapter.start();
       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 = /* @__PURE__ */ __name(async () => {
+    const assign = async () => {
       const stackNode = await this.getStackNode();
       this._stack = stackNode;
-    }, "assign");
+    };
     forget3(assign());
   }
   async getStackNode() {
     const mod = assertEx11(await this.context.root.resolve(this.stackNodeModuleId), () => `${this.stackNodeModuleId} not found`);
-    return asAttachableNodeInstance(mod, () => `${this.stackNodeModuleId} not a NodeInstance`, {
-      required: true
-    });
+    return asAttachableNodeInstance(mod, () => `${this.stackNodeModuleId} not a NodeInstance`, { required: true });
   }
   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) {
@@ -2167,30 +2028,29 @@ import { asArchivistInstance as asArchivistInstance5 } from "@xyo-network/archiv
 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 = false;
   _id = "";
+  driverName;
+  kernel;
   constructor(kernel, driverName) {
-    super({}), this.kernel = kernel, this.driverName = driverName;
+    super({});
     this._id = uuid3();
+    this.kernel = kernel;
+    this.driverName = driverName;
   }
   get id() {
     return assertEx12(this._id, () => "NodeAdapterBase id not initialized");
   }
   async start() {
     try {
-      const moduleAttachedInsertListener = /* @__PURE__ */ __name(({ payloads }) => {
+      const moduleAttachedInsertListener = ({ 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();
@@ -2199,9 +2059,7 @@ 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) {
@@ -2212,20 +2070,14 @@ var NodeAdapterBase = class extends BaseEmitter4 {
   }
   async getEventsArchivist() {
     const mod = assertEx12(await (await this.kernel.getNode()).resolve("KernelNode:ModuleEvents"), () => "KernelNode:ModuleEvents not found");
-    return asArchivistInstance5(mod, () => `${mod.id} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance5(mod, () => `${mod.id} is not an archivist`, { required: true });
   }
   validateAndReturnDriver() {
     const mod = this.kernel.initialized[this.driverName];
     if (mod) {
-      const node = asAttachableNodeInstance2(mod, () => `${mod.id} is not a node`, {
-        required: true
-      });
+      const node = asAttachableNodeInstance2(mod, () => `${mod.id} is not a node`, { required: true });
       this.initialized = true;
-      const emit = /* @__PURE__ */ __name(async () => await this.emit("driverReady", {
-        node
-      }), "emit");
+      const emit = async () => await this.emit("driverReady", { node });
       forget4(emit());
       return node;
     }
@@ -2234,9 +2086,6 @@ 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);
@@ -2257,9 +2106,6 @@ 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);
@@ -2279,31 +2125,26 @@ var SettingsAdapter = class extends NodeAdapterBase {
 };
 
 // src/adapters/OsPubSubBridgeNetwork.ts
-var OsPubSubBridgeNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
+var OsPubSubBridgeNetworkAdapters = (kernel) => [
   new NetworkAdapter(kernel, PubSubBridgeNodeNodeName),
   new NetworkAdapter(kernel, ExposedNodeOuterNodeName)
-], "OsPubSubBridgeNetworkAdapters");
+];
 
 // src/adapters/OsSettings.ts
 import { OsSettingsNodeName } from "@xyo-network/os-model";
-var OsSettingsAdapters = /* @__PURE__ */ __name((kernel) => [
-  new SettingsAdapter(kernel, OsSettingsNodeName)
-], "OsSettingsAdapters");
+var OsSettingsAdapters = (kernel) => [new SettingsAdapter(kernel, OsSettingsNodeName)];
 
 // src/adapters/OsXyoPublicNetwork.ts
 import { XyoPublicNodeName } from "@xyo-network/os-model";
-var OsXyoPublicNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
+var OsXyoPublicNetworkAdapters = (kernel) => [
   new NetworkAdapter(kernel, XyoPublicNodeName)
-], "OsXyoPublicNetworkAdapters");
+];
 
 // src/stack/OsPubSubNetworkStack.ts
 import { assertEx as assertEx13 } from "@xylabs/assert";
 import { asAttachableNodeInstance as asAttachableNodeInstance3, asNodeInstance } 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();
@@ -2346,15 +2187,13 @@ 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");
@@ -2372,9 +2211,6 @@ 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");
@@ -2413,9 +2249,6 @@ var OsStackMap = {
 
 // src/XyOs.ts
 var XyOs = class _XyOs extends XyOsContextBase {
-  static {
-    __name(this, "XyOs");
-  }
   _exposedNode;
   _exposedNodeOuter;
   _kernel;
@@ -2423,9 +2256,16 @@ var XyOs = class _XyOs extends XyOsContextBase {
   dappRegistrationService;
   signers;
   stackManager;
-  constructor({ logger = console, eventBus = new EventBus(), kernel = new Kernel({
-    logger
-  }), locator = new ModuleFactoryLocator8(), dappsConfiguration, developmentMode, stackMap = OsStackMap, ...params } = {}) {
+  constructor({
+    logger = console,
+    eventBus = new EventBus(),
+    kernel = new Kernel({ logger }),
+    locator = new ModuleFactoryLocator8(),
+    dappsConfiguration,
+    developmentMode,
+    stackMap = OsStackMap,
+    ...params
+  } = {}) {
     super({
       eventBus,
       kernel,
@@ -2463,19 +2303,14 @@ 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 ModuleFactoryLocator8()) {
@@ -2484,18 +2319,13 @@ 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");
       }
       assertEx14(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();
@@ -2527,30 +2357,25 @@ var XyOs = class _XyOs extends XyOsContextBase {
 // src/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 = assertEx15(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 = assertEx15(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];
@@ -2565,9 +2390,6 @@ var RunningDappCache = class _RunningDappCache {
 
 // src/access/RunningAccessDappCache.ts
 var RunningDappAccessCache = class {
-  static {
-    __name(this, "RunningDappAccessCache");
-  }
   static _cache = {};
   static get(key) {
     return this._cache[key];
@@ -2582,16 +2404,18 @@ var RunningDappAccessCache = class {
 
 // src/access/Caller.ts
 var DappAccessCaller = class extends OsCallerBase {
-  static {
-    __name(this, "DappAccessCaller");
-  }
-  registeredDapps;
   allowedNames;
-  xnsNodeUrl;
-  xnsNetwork;
   platformLocator;
+  registeredDapps;
+  xnsNetwork;
+  xnsNodeUrl;
   constructor(context, registeredDapps, allowedNames, xnsNodeUrl, xnsNetwork, platformLocator = new ModuleFactoryLocator9()) {
-    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(isRegisteredDappAccessDappSet2);
@@ -2611,21 +2435,15 @@ var DappAccessCaller = class extends OsCallerBase {
   async cacheAccessNode(dappAccessor, context) {
     const accessNodeId = dappAccessor.rootModuleId;
     const accessNodeModule = assertEx16(await context.root.resolve(accessNodeId), () => "Access Node Module not found");
-    const accessNode = asNodeInstance2(accessNodeModule, () => "Access Node Module is not a NodeInstance", {
-      required: true
-    });
+    const accessNode = asNodeInstance2(accessNodeModule, () => "Access Node Module is not a NodeInstance", { required: true });
     RunningDappAccessCache.set(dappAccessor.registeringDappId, accessNode);
   }
   async saveRegisteredDappInterfaces(registeredDappAccess) {
     const archivist = await this.getRegisteredDappInterfacesArchivist();
     const hash = await PayloadBuilder5.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`);
   }
 };
@@ -2634,9 +2452,6 @@ var DappAccessCaller = class extends OsCallerBase {
 import { assertEx as assertEx17 } from "@xylabs/assert";
 import { asArchivistInstance as asArchivistInstance6 } from "@xyo-network/archivist-model";
 var AccessNodeQueries = class {
-  static {
-    __name(this, "AccessNodeQueries");
-  }
   xyOsContext;
   accessRequest;
   registeredDappAccess;
@@ -2664,9 +2479,7 @@ var AccessNodeQueries = class {
   async getArchivistFromDappNode() {
     const archivistPath = this.accessRequest?.destinationArchivist || "DappArchivist";
     const mod = assertEx17(await this.xyOsContext.root.resolve(archivistPath), () => `Unable to find archivist at ${archivistPath}`);
-    return asArchivistInstance6(mod, () => `Module at ${archivistPath} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance6(mod, () => `Module at ${archivistPath} is not an archivist`, { required: true });
   }
   async getPayloadsFromAccessNode() {
     const archivistFromAccessNode = await this.resolveArchivistFromAccessNode();
@@ -2678,10 +2491,11 @@ var AccessNodeQueries = class {
     await archivist.insert(payloads);
   }
   async resolveArchivistFromAccessNode() {
-    const archivist = assertEx17(await this.nameServiceNamesAccessNode.resolve("PublicXnsArchivist"), () => "Unable to find archivist at PublicXnsArchivist");
-    return asArchivistInstance6(archivist, () => "PublicXnsArchivist is not an archivist", {
-      required: true
-    });
+    const archivist = assertEx17(
+      await this.nameServiceNamesAccessNode.resolve("PublicXnsArchivist"),
+      () => "Unable to find archivist at PublicXnsArchivist"
+    );
+    return asArchivistInstance6(archivist, () => "PublicXnsArchivist is not an archivist", { required: true });
   }
 };
 
@@ -2693,42 +2507,33 @@ 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 = assertEx18(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
-    return asArchivistInstance7(mod, () => `${fullyQualifiedPath} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance7(mod, () => `${fullyQualifiedPath} is not an archivist`, { required: true });
   }
   /**
-  * Get the XnsArchivistPayloadDiviner
-  */
+   * Get the XnsArchivistPayloadDiviner
+   */
   async getXnsArchivistPayloadDiviner(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistPayloadDivinerModuleName}` : XnsArchivistPayloadDivinerModuleName;
     const mod = assertEx18(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
-    return asDivinerInstance4(mod, () => `${fullyQualifiedPath} is not an diviner`, {
-      required: true
-    });
+    return asDivinerInstance4(mod, () => `${fullyQualifiedPath} is not an diviner`, { required: true });
   }
   /**
-  * Get the XnsRegistrationsArchivist
-  */
+   * Get the XnsRegistrationsArchivist
+   */
   async getXnsRegistrationsArchivist(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsRegistrationsArchivistModuleName}` : XnsRegistrationsArchivistModuleName;
     const mod = assertEx18(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
-    return asArchivistInstance7(mod, () => `${fullyQualifiedPath} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance7(mod, () => `${fullyQualifiedPath} is not an archivist`, { required: true });
   }
 };
 
@@ -2740,46 +2545,36 @@ import { isTemporalIndexingDivinerResultIndex } from "@xyo-network/diviner-tempo
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema4 } from "@xyo-network/diviner-payload-model";
 import { TemporalIndexingDivinerResultIndexSchema } from "@xyo-network/diviner-temporal-indexing-model";
 var XnsRegistrationsResourceQueries = {
-  getAllRegistrations: /* @__PURE__ */ __name(async (diviner) => {
+  getAllRegistrations: async (diviner) => {
     const query = {
       limit: 100,
       order: "desc",
       schema: PayloadDivinerQuerySchema4,
-      schemas: [
-        TemporalIndexingDivinerResultIndexSchema
-      ]
+      schemas: [TemporalIndexingDivinerResultIndexSchema]
     };
-    return await diviner.divine([
-      query
-    ]);
-  }, "getAllRegistrations"),
-  getRecentRegistrations: /* @__PURE__ */ __name(async (archivist) => {
+    return await diviner.divine([query]);
+  },
+  getRecentRegistrations: async (archivist) => {
     return (await archivist.all()).toReversed();
-  }, "getRecentRegistrations")
+  }
 };
 
 // src/access/interfaces/registered-names/helpers/resource/RegistrationsResource.ts
 var XnsRegistrationsResource = class extends AbstractXnsCaller {
-  static {
-    __name(this, "XnsRegistrationsResource");
-  }
-  pathPrefix;
   _allRegistrations;
+  pathPrefix;
   constructor(context, pathPrefix) {
-    super(context), this.pathPrefix = pathPrefix;
+    super(context);
+    this.pathPrefix = pathPrefix;
   }
   get allRegistrations() {
     return assertEx19(this._allRegistrations);
   }
   get subscriptions() {
-    return {
-      allRegistrations: /* @__PURE__ */ __name((cb) => this.allRegistrations.subscribe(cb), "allRegistrations")
-    };
+    return { allRegistrations: (cb) => this.allRegistrations.subscribe(cb) };
   }
   get views() {
-    return {
-      allRegistrations: /* @__PURE__ */ __name(() => this.allRegistrations.getSnapshot(), "allRegistrations")
-    };
+    return { allRegistrations: () => this.allRegistrations.getSnapshot() };
   }
   cleanupListeners() {
     this.allRegistrations.cleanupListeners();
@@ -2789,7 +2584,7 @@ var XnsRegistrationsResource = class extends AbstractXnsCaller {
     const xnsArchivist = await this.getXnsArchivist(this.pathPrefix);
     this._allRegistrations = await PayloadStore.create({
       archivist: xnsArchivist,
-      getLatest: /* @__PURE__ */ __name(async () => await XnsRegistrationsResourceQueries.getAllRegistrations(xnsArchivistPayloadDiviner), "getLatest"),
+      getLatest: async () => await XnsRegistrationsResourceQueries.getAllRegistrations(xnsArchivistPayloadDiviner),
       idFunction: isTemporalIndexingDivinerResultIndex
     });
   }
@@ -2804,13 +2599,9 @@ var DappAccessRequestQueries = {
     const query = {
       limit: 1,
       schema: PayloadDivinerQuerySchema5,
-      schemas: [
-        DappAccessRequestSchema
-      ]
+      schemas: [DappAccessRequestSchema]
     };
-    const results = await diviner.divine([
-      query
-    ]);
+    const results = await diviner.divine([query]);
     if (results.length === 0) {
       return noResults;
     }
@@ -2820,13 +2611,9 @@ var DappAccessRequestQueries = {
     const query = {
       limit: 1,
       schema: PayloadDivinerQuerySchema5,
-      schemas: [
-        RegisteredDappAccessSchema2
-      ]
+      schemas: [RegisteredDappAccessSchema2]
     };
-    const results = await diviner.divine([
-      query
-    ]);
+    const results = await diviner.divine([query]);
     if (results.length === 0) {
       return noResults;
     }
@@ -2838,9 +2625,6 @@ var DappAccessRequestQueries = {
 import { assertEx as assertEx20 } from "@xylabs/assert";
 import { isDappAccessRequestWithMeta, isRegisteredDappAccess as isRegisteredDappAccess2 } from "@xyo-network/os-model";
 var DappAccessRequestResource = class extends DappCallerBase {
-  static {
-    __name(this, "DappAccessRequestResource");
-  }
   _accessRequestListener;
   _registeredInterfacesListener;
   constructor(context) {
@@ -2854,14 +2638,14 @@ var DappAccessRequestResource = class extends DappCallerBase {
   }
   get subscriptions() {
     return {
-      accessRequests: /* @__PURE__ */ __name((cb) => this.accessRequestListener.subscribe(cb), "accessRequests"),
-      registeredInterfaces: /* @__PURE__ */ __name((cb) => this.registeredInterfacesListener.subscribe(cb), "registeredInterfaces")
+      accessRequests: (cb) => this.accessRequestListener.subscribe(cb),
+      registeredInterfaces: (cb) => this.registeredInterfacesListener.subscribe(cb)
     };
   }
   get views() {
     return {
-      accessRequests: /* @__PURE__ */ __name(() => this.accessRequestListener.getSnapshot(), "accessRequests"),
-      registeredInterfaces: /* @__PURE__ */ __name(() => this.registeredInterfacesListener.getSnapshot(), "registeredInterfaces")
+      accessRequests: () => this.accessRequestListener.getSnapshot(),
+      registeredInterfaces: () => this.registeredInterfacesListener.getSnapshot()
     };
   }
   cleanupListeners() {
@@ -2873,12 +2657,12 @@ var DappAccessRequestResource = class extends DappCallerBase {
     const diviner = await this.getDappArchivistPayloadDiviner();
     this._accessRequestListener = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappAccessRequestQueries.getAccessRequests(diviner), "getLatest"),
+      getLatest: async () => await DappAccessRequestQueries.getAccessRequests(diviner),
       idFunction: isDappAccessRequestWithMeta
     });
     this._registeredInterfacesListener = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappAccessRequestQueries.getRegisteredInterfaces(diviner), "getLatest"),
+      getLatest: async () => await DappAccessRequestQueries.getRegisteredInterfaces(diviner),
       idFunction: isRegisteredDappAccess2
     });
   }
@@ -2887,7 +2671,13 @@ var DappAccessRequestResource = class extends DappCallerBase {
 // src/Caller.ts
 import { assertEx as assertEx21 } from "@xylabs/assert";
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema7 } from "@xyo-network/diviner-payload-model";
-import { DappAccessRequestSchema as DappAccessRequestSchema2, DappInjectableParamsSchema as DappInjectableParamsSchema2, DappIntentTypes as DappIntentTypes2, DappMode as DappMode3, RegisteredDappAccessSchema as RegisteredDappAccessSchema3 } from "@xyo-network/os-model";
+import {
+  DappAccessRequestSchema as DappAccessRequestSchema2,
+  DappInjectableParamsSchema as DappInjectableParamsSchema2,
+  DappIntentTypes as DappIntentTypes2,
+  DappMode as DappMode3,
+  RegisteredDappAccessSchema as RegisteredDappAccessSchema3
+} from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 
 // src/DefaultsQueries.ts
@@ -2899,43 +2689,32 @@ var DappDefaultsResourceQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema6,
-      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: PayloadDivinerQuerySchema6,
-      schemas: [
-        NodeOsInfoSchema2
-      ]
+      schemas: [NodeOsInfoSchema2]
     };
-    return await diviner.divine([
-      query
-    ]);
+    return await diviner.divine([query]);
   }
 };
 
 // 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) {
@@ -2943,23 +2722,19 @@ var DappCaller = class extends DappCallerBase {
     } else {
       for (const payload of payloads) {
         const hash = await PayloadBuilder6.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,
@@ -2972,51 +2747,43 @@ 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: PayloadDivinerQuerySchema7,
-      schemas: [
-        RegisteredDappAccessSchema3
-      ]
+      schemas: [RegisteredDappAccessSchema3]
     };
-    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: PayloadDivinerQuerySchema7,
-      schemas: [
-        RegisteredDappAccessSchema3
-      ]
+      schemas: [RegisteredDappAccessSchema3]
     };
-    const [payload] = assertEx21(await diviner.divine([
-      query
-    ]), () => "Unable to find registered dapp access");
+    const [payload] = assertEx21(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) {
@@ -3026,56 +2793,48 @@ 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 = DappIntentTypes2.Launch, mode = DappMode3.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 = {};
@@ -3089,9 +2848,7 @@ var DappCaller = class extends DappCallerBase {
       source: "route",
       timestamp: Date.now()
     };
-    await dappArchivist.insert([
-      payload
-    ]);
+    await dappArchivist.insert([payload]);
   }
 };
 
@@ -3099,9 +2856,6 @@ var DappCaller = class extends DappCallerBase {
 import { assertEx as assertEx22 } from "@xylabs/assert";
 import { isDappInjectableParams, isNodeOsInfo } from "@xyo-network/os-model";
 var DappDefaultsResource = class extends DappCallerBase {
-  static {
-    __name(this, "DappDefaultsResource");
-  }
   _dappInjectableParamsFromRouteListener;
   _nodeOsInfoListener;
   constructor(context) {
@@ -3115,14 +2869,14 @@ var DappDefaultsResource = class extends DappCallerBase {
   }
   get subscriptions() {
     return {
-      dappInjectableParamsFromRoute: /* @__PURE__ */ __name((cb) => this.dappInjectableParamsFromRouteListener.subscribe(cb), "dappInjectableParamsFromRoute"),
-      nodeOsInfo: /* @__PURE__ */ __name((cb) => this.nodeOsInfoListener.subscribe(cb), "nodeOsInfo")
+      dappInjectableParamsFromRoute: (cb) => this.dappInjectableParamsFromRouteListener.subscribe(cb),
+      nodeOsInfo: (cb) => this.nodeOsInfoListener.subscribe(cb)
     };
   }
   get views() {
     return {
-      dappInjectableParamsFromRoute: /* @__PURE__ */ __name(() => this.dappInjectableParamsFromRouteListener.getSnapshot(), "dappInjectableParamsFromRoute"),
-      nodeOsInfo: /* @__PURE__ */ __name(() => this.nodeOsInfoListener.getSnapshot(), "nodeOsInfo")
+      dappInjectableParamsFromRoute: () => this.dappInjectableParamsFromRouteListener.getSnapshot(),
+      nodeOsInfo: () => this.nodeOsInfoListener.getSnapshot()
     };
   }
   cleanupListeners() {
@@ -3133,12 +2887,12 @@ var DappDefaultsResource = class extends DappCallerBase {
     const diviner = await this.getDappArchivistPayloadDiviner();
     this._nodeOsInfoListener = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner), "getLatest"),
+      getLatest: async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner),
       idFunction: isNodeOsInfo
     });
     this._dappInjectableParamsFromRouteListener = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner), "getLatest"),
+      getLatest: async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner),
       idFunction: isDappInjectableParams
     });
   }
@@ -3146,27 +2900,25 @@ var DappDefaultsResource = class extends DappCallerBase {
 
 // src/classes/menu/Caller.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema8 } 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 PayloadBuilder7 } from "@xyo-network/payload-builder";
 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 PayloadBuilder7.dataHash(payload);
-      const [existing] = await dappArchivist.get([
-        hash
-      ]);
+      const [existing] = await dappArchivist.get([hash]);
       if (!existing || force) {
         await dappArchivist.insert(payloads);
       }
@@ -3178,21 +2930,17 @@ var DappMenuCaller = class extends DappCaller {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema8,
-      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 = {
@@ -3200,9 +2948,7 @@ var DappMenuCaller = class extends DappCaller {
       schema: DappNavItemSelectionSchema,
       timestamp: Date.now()
     };
-    await dappArchivist.insert([
-      payload
-    ]);
+    await dappArchivist.insert([payload]);
     if (injectableParamsPath) {
       const injectableParams = {
         params: {},
@@ -3211,9 +2957,7 @@ var DappMenuCaller = class extends DappCaller {
         source: "route",
         timestamp: Date.now()
       };
-      await dappArchivist.insert([
-        injectableParams
-      ]);
+      await dappArchivist.insert([injectableParams]);
     }
   }
 };
@@ -3224,7 +2968,11 @@ import { isDappNavItemSelection, isDappNavMenuConfig } from "@xyo-network/os-mod
 
 // src/classes/menu/Queries.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema9 } 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) {
@@ -3232,25 +2980,17 @@ var DappMenuQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema9,
-      schemas: [
-        DappNavMenuConfigSchema
-      ]
+      schemas: [DappNavMenuConfigSchema]
     };
-    return await diviner.divine([
-      query
-    ]);
+    return await diviner.divine([query]);
   },
   async getMenuItems(diviner) {
     const query = {
       order: "desc",
       schema: PayloadDivinerQuerySchema9,
-      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) {
@@ -3258,35 +2998,24 @@ var DappMenuQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema9,
-      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: PayloadDivinerQuerySchema9,
-      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;
@@ -3309,55 +3038,55 @@ var DappMenuResource = class extends DappCaller {
   /** subscribe to latest set of payloads */
   get subscriptions() {
     return {
-      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")
+      menuConfigs: (cb) => this.menuConfigListener.subscribe(cb),
+      menuItemSelections: (cb) => this.menuItemSelectionListener.subscribe(cb),
+      menuItems: (cb) => this.menuItemListener.subscribe(cb),
+      menuItemsVisible: (cb) => this.menuItemVisibleListener.subscribe(cb)
     };
   }
   /**
-  * Return the latest menu payloads from the repository
-  */
+   * Return the latest menu payloads from the repository
+   */
   get views() {
     return {
-      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")
+      menuConfigs: () => this.menuConfigListener.getSnapshot(),
+      menuItemSelections: () => this.menuItemSelectionListener.getSnapshot(),
+      menuItems: () => this.menuItemListener.getSnapshot(),
+      menuItemsVisible: () => this.menuItemVisibleListener.getSnapshot()
     };
   }
   /**
-  * 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: /* @__PURE__ */ __name(async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner), "getLatest"),
+      getLatest: async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner),
       idFunction: isDappNavMenuConfig
     });
     this._menuItemListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner), "getLatest"),
+      getLatest: async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner),
       idFunction: isDappNavMenuConfig
     });
     this._menuItemVisibleListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner), "getLatest"),
+      getLatest: async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner),
       idFunction: isDappNavMenuConfig
     });
     this._menuItemSelectionListener = await PayloadStore.create({
       archivist: dappArchivist,
-      getLatest: /* @__PURE__ */ __name(async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner), "getLatest"),
+      getLatest: async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner),
       idFunction: isDappNavItemSelection
     });
   }
@@ -3373,24 +3102,20 @@ import { asDivinerInstance as asDivinerInstance5 } 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;
   }
   async getOsSettingsArchivist() {
     const mod = assertEx24(await this.context.root.resolve(OsSettingsArchivistModuleName), () => `${OsSettingsArchivistModuleName} not found`);
-    return asArchivistInstance8(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance8(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`, { required: true });
   }
   async getOsSettingsPayloadDiviner() {
-    const mod = assertEx24(await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName), () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance5(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx24(
+      await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName),
+      () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance5(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
   }
 };
 
@@ -3398,38 +3123,31 @@ var OsSettingsCallerBase = class {
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema10 } from "@xyo-network/diviner-payload-model";
 import { OsBadgeSchema } from "@xyo-network/os-model";
 var OsBadgeQueries = {
-  getBadge: /* @__PURE__ */ __name(async (achievement, diviner) => {
+  getBadge: async (achievement, diviner) => {
     const query = {
       achievement,
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema10,
-      schemas: [
-        OsBadgeSchema
-      ]
+      schemas: [OsBadgeSchema]
     };
-    return await diviner.divine([
-      query
-    ]);
-  }, "getBadge")
+    return await diviner.divine([query]);
+  }
 };
 
 // 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,
@@ -3437,9 +3155,7 @@ var OsBadgeCaller = class extends OsSettingsCallerBase {
       timestamp: Date.now()
     };
     const archivist = await this.getOsSettingsArchivist();
-    return await archivist.insert([
-      badge
-    ]);
+    return await archivist.insert([badge]);
   }
 };
 
@@ -3447,12 +3163,7 @@ var OsBadgeCaller = class extends OsSettingsCallerBase {
 import { assertEx as assertEx25 } from "@xylabs/assert";
 import { isBadgeWithMeta } from "@xyo-network/os-model";
 var OsBadgeResource = class extends OsSettingsCallerBase {
-  static {
-    __name(this, "OsBadgeResource");
-  }
-  static views = [
-    "savedSeedPhrase"
-  ];
+  static views = ["savedSeedPhrase"];
   _savedSeedPhrase;
   constructor(xyOsContext) {
     super(xyOsContext);
@@ -3461,27 +3172,23 @@ var OsBadgeResource = class extends OsSettingsCallerBase {
     return assertEx25(this._savedSeedPhrase, () => "Saved seed phrase listener not set");
   }
   get subscriptions() {
-    return {
-      savedSeedPhrase: /* @__PURE__ */ __name((cb) => this.savedSeedPhrase.subscribe(cb), "savedSeedPhrase")
-    };
+    return { savedSeedPhrase: (cb) => this.savedSeedPhrase.subscribe(cb) };
   }
   get views() {
-    return {
-      savedSeedPhrase: /* @__PURE__ */ __name(() => this.savedSeedPhrase.latest, "savedSeedPhrase")
-    };
+    return { savedSeedPhrase: () => this.savedSeedPhrase.latest };
   }
   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: /* @__PURE__ */ __name(async () => await OsBadgeQueries.getBadge("savedSeedPhrase", diviner), "getLatest"),
+      getLatest: async () => await OsBadgeQueries.getBadge("savedSeedPhrase", diviner),
       idFunction: isBadgeWithMeta
     });
   }
@@ -3496,7 +3203,7 @@ import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder"
 var language = "english";
 var standard = "bip-39";
 var userWalletLabel = "userWallet";
-var buildWalletSeedPhrasePayload = /* @__PURE__ */ __name(async (mnemonic, $label) => {
+var buildWalletSeedPhrasePayload = async (mnemonic, $label) => {
   const fields = {
     mnemonic: {
       language,
@@ -3506,21 +3213,16 @@ var buildWalletSeedPhrasePayload = /* @__PURE__ */ __name(async (mnemonic, $labe
     $label,
     $timestamp: Date.now()
   };
-  const payload = new PayloadBuilder8({
-    schema: WalletSeedPhraseSchema
-  }).fields(fields).build();
+  const payload = new PayloadBuilder8({ schema: WalletSeedPhraseSchema }).fields(fields).build();
   const rootHash = await PayloadBuilder8.hash(payload);
-  return {
-    payload,
-    rootHash
-  };
-}, "buildWalletSeedPhrasePayload");
-var buildUserWalletSeedPhrasePayload = /* @__PURE__ */ __name((mnemonic) => {
+  return { payload, rootHash };
+};
+var buildUserWalletSeedPhrasePayload = (mnemonic) => {
   return buildWalletSeedPhrasePayload(mnemonic, userWalletLabel);
-}, "buildUserWalletSeedPhrasePayload");
+};
 
 // src/utils/getApiDomain.ts
-var getApiDomain = /* @__PURE__ */ __name((scope, apiDomain) => {
+var getApiDomain = (scope, apiDomain) => {
   if (apiDomain !== void 0) {
     return apiDomain;
   }
@@ -3531,21 +3233,24 @@ var getApiDomain = /* @__PURE__ */ __name((scope, apiDomain) => {
     return "https://beta.archivist.xyo.network";
   }
   return "https://archivist.xyo.network";
-}, "getApiDomain");
+};
 
 // src/utils/renameObjKey.ts
-var renameObjKey = /* @__PURE__ */ __name((oldObj, oldKey, newKey) => {
+var renameObjKey = (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 PayloadDivinerQuerySchema11 } from "@xyo-network/diviner-payload-model";
@@ -3558,17 +3263,11 @@ var OsSettingsQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema11,
-      schemas: [
-        WalletSeedPhraseSchema2
-      ]
+      schemas: [WalletSeedPhraseSchema2]
     };
-    const results = await diviner.divine([
-      query
-    ]);
+    const results = await diviner.divine([query]);
     const wallet = results.find((payload) => payload.$label === "userWallet");
-    if (wallet) return [
-      wallet
-    ];
+    if (wallet) return [wallet];
     const legacyWallet = results.find((payload) => payload.$meta.label === "userWallet");
     if (legacyWallet && archivist) {
       const legacyMeta = legacyWallet.$meta;
@@ -3577,15 +3276,9 @@ var OsSettingsQueries = {
         $label: legacyMeta.label,
         $timestamp: legacyMeta.$timestamp
       };
-      const payload = new PayloadBuilder9({
-        schema: WalletSeedPhraseSchema2
-      }).fields(newWalletPayloadFields).build();
-      await archivist.insert([
-        payload
-      ]);
-      return [
-        payload
-      ];
+      const payload = new PayloadBuilder9({ schema: WalletSeedPhraseSchema2 }).fields(newWalletPayloadFields).build();
+      await archivist.insert([payload]);
+      return [payload];
     }
     return NO_RESULTS2;
   },
@@ -3594,61 +3287,46 @@ var OsSettingsQueries = {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema11,
-      schemas: [
-        NodeBackgroundSchema
-      ]
+      schemas: [NodeBackgroundSchema]
     };
-    return await diviner.divine([
-      query
-    ]);
+    return await diviner.divine([query]);
   },
   async getWallets(diviner) {
     const query = {
       order: "desc",
       schema: PayloadDivinerQuerySchema11,
-      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);
@@ -3676,9 +3354,6 @@ var OsSettingsCaller = class extends OsSettingsCallerBase {
 import { assertEx as assertEx27 } from "@xylabs/assert";
 import { isNodeBackground, isWalletSeedPhrase } from "@xyo-network/os-model";
 var OsSettingsResource = class extends OsSettingsCallerBase {
-  static {
-    __name(this, "OsSettingsResource");
-  }
   _latestUserWalletListener;
   _nodeBackgroundListener;
   _walletsListener;
@@ -3693,16 +3368,16 @@ var OsSettingsResource = class extends OsSettingsCallerBase {
   }
   get subscriptions() {
     return {
-      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")
+      latestUserWallet: (cb) => this.walletsListener.subscribe(cb),
+      nodeBackground: (cb) => this.nodeBackgroundListener.subscribe(cb),
+      wallets: (cb) => this.walletsListener.subscribe(cb)
     };
   }
   get views() {
     return {
-      latestUserWallet: /* @__PURE__ */ __name(() => this.latestUserWalletListener.latest, "latestUserWallet"),
-      nodeBackground: /* @__PURE__ */ __name(() => this.nodeBackgroundListener.latest, "nodeBackground"),
-      wallets: /* @__PURE__ */ __name(() => this.walletsListener.latest, "wallets")
+      latestUserWallet: () => this.latestUserWalletListener.latest,
+      nodeBackground: () => this.nodeBackgroundListener.latest,
+      wallets: () => this.walletsListener.latest
     };
   }
   get walletsListener() {
@@ -3713,24 +3388,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: /* @__PURE__ */ __name(async () => await OsSettingsQueries.getWallets(diviner), "getLatest"),
+      getLatest: async () => await OsSettingsQueries.getWallets(diviner),
       idFunction: isWalletSeedPhrase
     });
     this._latestUserWalletListener = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await OsSettingsQueries.getLatestUserWallet(diviner), "getLatest"),
+      getLatest: async () => await OsSettingsQueries.getLatestUserWallet(diviner),
       idFunction: isWalletSeedPhrase
     });
     this._nodeBackgroundListener = await PayloadStore.create({
       archivist,
-      getLatest: /* @__PURE__ */ __name(async () => await OsSettingsQueries.getNodeBackground(diviner), "getLatest"),
+      getLatest: async () => await OsSettingsQueries.getNodeBackground(diviner),
       idFunction: isNodeBackground
     });
   }
@@ -3739,17 +3414,10 @@ var OsSettingsResource = class extends OsSettingsCallerBase {
 // src/helpers/monitor/XyOsMonitor.ts
 var DEFAULT_MONITORING_EVENT_NAME = "System Task Duration";
 globalThis.getXyOsGlobal = globalThis.getXyOsGlobal ?? (() => {
-  return {
-    tracking: {
-      trackEvent: /* @__PURE__ */ __name((_event, _properties) => void {}, "trackEvent")
-    }
-  };
+  return { tracking: { trackEvent: (_event, _properties) => void {} } };
 });
 var xyOsGlobal = globalThis.getXyOsGlobal();
 var XyOsMonitor = class _XyOsMonitor {
-  static {
-    __name(this, "XyOsMonitor");
-  }
   static trackEvent = xyOsGlobal.tracking.trackEvent;
   performanceTimers = /* @__PURE__ */ new Map();
   startTimer(name) {
@@ -3778,9 +3446,6 @@ var XyOsMonitor = class _XyOsMonitor {
 // src/initializer/DappInitializer.ts
 import { assertEx as assertEx28 } from "@xylabs/assert";
 var DappInitializer = class {
-  static {
-    __name(this, "DappInitializer");
-  }
   _config;
   constructor(config) {
     this._config = config;
@@ -3793,14 +3458,17 @@ var DappInitializer = class {
     return await this.initializeDappContext(dappWithWalletId);
   }
   async initializeDappContext(dappWithWalletId) {
-    const { allowedNames, xnsNetwork, xnsNodeUrl, xyOs } = this.config;
+    const {
+      allowedNames,
+      xnsNetwork,
+      xnsNodeUrl,
+      xyOs
+    } = this.config;
     return await RunningDappCache.findOrCreate(dappWithWalletId, xyOs, allowedNames ?? [], xnsNodeUrl, xnsNetwork);
   }
   async installDappWallet() {
     const { xyOs, dapp } = this.config;
-    const dappSeedPhraseRepository = new DappSeedPhraseRepository(xyOs, [
-      dapp.config.name
-    ]);
+    const dappSeedPhraseRepository = new DappSeedPhraseRepository(xyOs, [dapp.config.name]);
     const walletId = await dappSeedPhraseRepository.findOrCreate(dapp.config.name);
     return {
       ...dapp,
@@ -3816,15 +3484,12 @@ var DappInitializer = class {
 import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
 var DISPLAY_EVENT_COUNT_FREQUENCY = 100;
 var profileData = {};
-var profileModuleEvents = /* @__PURE__ */ __name((mod) => {
+var profileModuleEvents = (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;
@@ -3847,16 +3512,13 @@ var profileModuleEvents = /* @__PURE__ */ __name((mod) => {
       }
     }
   });
-}, "profileModuleEvents");
+};
 
 // src/PubSubBridgeCaller.ts
 import { assertEx as assertEx29 } 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;
@@ -3876,9 +3538,7 @@ var PubSubBridgeCaller = class {
   }
   async getPubSubBridge() {
     const mod = assertEx29(await this.node.resolve(BridgedPubSubModuleName), () => `${BridgedPubSubModuleName} not found`);
-    return asBridgeInstance(mod, () => `${BridgedPubSubModuleName} is not a bridge`, {
-      required: true
-    });
+    return asBridgeInstance(mod, () => `${BridgedPubSubModuleName} is not a bridge`, { required: true });
   }
 };
 export {