@xyo-network/os-runtime 4.1.1 → 4.1.2

package/dist/node/scripts/xyos/lib/index.mjs

@@ -1,8 +1,11 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/scripts/xyos/lib/createFromTemplate.ts
-var createFromTemplate = async ({ target, template }) => {
+var createFromTemplate = /* @__PURE__ */ __name(async ({ target, template }) => {
   console.log("Creating from template", template, "at", target);
   return await Promise.resolve();
-};
+}, "createFromTemplate");
 
 // src/scripts/xyos/lib/headless.ts
 import fs from "node:fs";
@@ -36,6 +39,10 @@ var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
 var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
 var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
 var OsCallerBase = class {
+  static {
+    __name(this, "OsCallerBase");
+  }
+  context;
   constructor(context) {
     this.context = context;
   }
@@ -46,48 +53,39 @@ var OsCallerBase = class {
   }
   // Get the dapps archivist development
   async getDappsArchivistDevelopment() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
-      () => `${DappsArchivistDevelopmentModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistDevelopmentModuleName), () => `${DappsArchivistDevelopmentModuleName} not found`);
     return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`);
   }
   // Get the dapps archivist payload diviner
   async getDappsArchivistPayloadDiviner() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
-      () => `${DappsArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName), () => `${DappsArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`);
   }
   // Get the dapps archivist payload diviner development
   async getDappsArchivistPayloadDivinerDevelopment() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
-      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName), () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`);
     return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`);
   }
   // Get the registered dapp interfaces archivist
   async getRegisteredDappInterfacesArchivist() {
-    const mod = assertEx(
-      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
-      () => `${RegisteredDappInterfacesArchivistModuleName} not found`
-    );
+    const mod = assertEx(await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName), () => `${RegisteredDappInterfacesArchivistModuleName} not found`);
     return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`);
   }
 };
 
 // src/wallet/DappSeedPhraseRepository.ts
 var DappSeedPhraseRepository = class extends OsCallerBase {
-  constructor(xyOs, allowedNames) {
-    super(xyOs);
-    this.allowedNames = allowedNames;
+  static {
+    __name(this, "DappSeedPhraseRepository");
   }
+  allowedNames;
   // record of all dapps that have requested a seed phrase with the OS
-  dappIdRepository = /* @__PURE__ */ new Map();
+  dappIdRepository;
   // record of all walletIds that have been issued to registered dapps
-  walletIdRepository = /* @__PURE__ */ new Map();
+  walletIdRepository;
+  constructor(xyOs, allowedNames) {
+    super(xyOs), this.allowedNames = allowedNames, this.dappIdRepository = /* @__PURE__ */ new Map(), this.walletIdRepository = /* @__PURE__ */ new Map();
+  }
   async add(dappId) {
     const archivist = await this.getDappsArchivist();
     const seedPhrase = this.newPhrase();
@@ -98,7 +96,9 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       seedPhrase,
       walletId
     };
-    await archivist.insert([payload]);
+    await archivist.insert([
+      payload
+    ]);
     this.dappIdRepository.set(dappId, payload);
     this.walletIdRepository.set(walletId, payload);
     return walletId;
@@ -130,9 +130,13 @@ 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) {
@@ -141,10 +145,14 @@ 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() {
@@ -162,42 +170,37 @@ var IntentArchivistModuleName = "IntentArchivist";
 var IntentArchivistPayloadDivinerModuleName = "IntentArchivistPayloadDiviner";
 var DappArchivistPayloadDivinerModuleName = "DappArchivistPayloadDiviner";
 var DappCallerBase = class {
+  static {
+    __name(this, "DappCallerBase");
+  }
+  context;
   constructor(context) {
     this.context = context;
   }
   /**
-   * Get the DappArchivist
-   */
+  * Get the DappArchivist
+  */
   async getDappArchivist() {
-    const mod = assertEx2(
-      await this.context.root.resolve(DappArchivistModuleName),
-      () => `${DappArchivistModuleName} not found [${toJsonString(this.context.root.publicChildren())}]`
-    );
+    const mod = assertEx2(await this.context.root.resolve(DappArchivistModuleName), () => `${DappArchivistModuleName} not found [${toJsonString(this.context.root.publicChildren())}]`);
     return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`);
   }
   /**
-   * Get the DappArchivistPayloadDiviner
-   */
+  * Get the DappArchivistPayloadDiviner
+  */
   async getDappArchivistPayloadDiviner() {
-    const mod = assertEx2(
-      await this.context.root.resolve(DappArchivistPayloadDivinerModuleName),
-      () => `${DappArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx2(await this.context.root.resolve(DappArchivistPayloadDivinerModuleName), () => `${DappArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`);
   }
   /**
-   * Get the IntentArchivist
-   */
+  * Get the IntentArchivist
+  */
   async getDappIntentArchivist() {
     const mod = assertEx2(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`);
     return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`);
   }
   // Get the IntentArchivistPayloadDiviner
   async getDappIntentArchivistPayloadDiviner() {
-    const mod = assertEx2(
-      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
-      () => `${IntentArchivistPayloadDivinerModuleName} not found`
-    );
+    const mod = assertEx2(await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName), () => `${IntentArchivistPayloadDivinerModuleName} not found`);
     return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`);
   }
 };
@@ -340,20 +343,26 @@ var os_node_manifest_default = {
 import { asDivinerInstance as asDivinerInstance3 } from "@xyo-network/diviner-model";
 import { ResolveHelper } from "@xyo-network/module-model";
 import { NameRegistrarTransformer } from "@xyo-network/module-resolver";
-var initializeXns = async (xnsNode) => {
+var initializeXns = /* @__PURE__ */ __name(async (xnsNode) => {
   if (ResolveHelper.transformers.length === 0) {
     const registrarDiviner = asDivinerInstance3(await xnsNode?.resolve("AddressRecords:AddressRecordIndexDiviner"));
     if (registrarDiviner) {
       const transformer = new NameRegistrarTransformer(registrarDiviner, "xyo");
-      ResolveHelper.transformers = [transformer];
+      ResolveHelper.transformers = [
+        transformer
+      ];
       return true;
     }
   }
   return false;
-};
+}, "initializeXns");
 
 // src/lib/NameTransforms.ts
 var NameTransforms = class _NameTransforms {
+  static {
+    __name(this, "NameTransforms");
+  }
+  value;
   constructor(value) {
     this.value = value;
   }
@@ -381,19 +390,22 @@ var NameTransforms = class _NameTransforms {
 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,
@@ -409,7 +421,9 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
   async addIntent(id, intent, mode) {
     const intentArchivist = await this.getDappIntentArchivist();
     const newIntent = _DappIntentCaller.buildIntent(id, intent, mode);
-    await intentArchivist.insert([newIntent]);
+    await intentArchivist.insert([
+      newIntent
+    ]);
   }
   // Get all intents
   async allIntents() {
@@ -430,7 +444,9 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
       schema: PayloadDivinerQuerySchema2,
       sourceDappId: dappName
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   }
 };
 
@@ -438,17 +454,15 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
 import { forget as forget2 } from "@xylabs/forget";
 import { fulfilled, rejected } from "@xylabs/promise";
 import { ModuleFactoryLocator as ModuleFactoryLocator3 } 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/event/bus/Connection.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { BaseEmitter } from "@xyo-network/module-event-emitter";
 var EventBusConnection = class extends BaseEmitter {
+  static {
+    __name(this, "EventBusConnection");
+  }
   _id;
   description;
   type;
@@ -468,19 +482,15 @@ var EventBusConnection = class extends BaseEmitter {
 // src/event/bus/EventBus.ts
 import { assertEx as assertEx4 } from "@xylabs/assert";
 import { forget } from "@xylabs/forget";
-import {
-  asArchivistInstance as asArchivistInstance3,
-  MemoryArchivist,
-  MemoryArchivistConfigSchema
-} from "@xyo-network/archivist";
-import {
-  isEventBusEvent,
-  isPubSubConnections
-} from "@xyo-network/os-model";
+import { asArchivistInstance as asArchivistInstance3, MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist";
+import { isEventBusEvent, isPubSubConnections } from "@xyo-network/os-model";
 import { PayloadBuilder } 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
@@ -489,10 +499,7 @@ var EventBus = class {
   publisherCallbacks = {};
   startMutex = new Mutex();
   get archivist() {
-    return asArchivistInstance3(
-      assertEx4(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
-      "not a valid archivist instance"
-    );
+    return asArchivistInstance3(assertEx4(this._archivist, () => "Archivist not found.  Did you forget to call start()?"), "not a valid archivist instance");
   }
   addConnection(connection) {
     const id = uuid2();
@@ -521,7 +528,12 @@ var EventBus = class {
         console.warn("EventBus already started");
         return this;
       }
-      this._archivist = await MemoryArchivist.create({ config: { name: storeName, schema: MemoryArchivistConfigSchema } });
+      this._archivist = await MemoryArchivist.create({
+        config: {
+          name: storeName,
+          schema: MemoryArchivistConfigSchema
+        }
+      });
       this.archivist.on("inserted", ({ payloads }) => {
         const eventBusEvent = payloads.find(isEventBusEvent);
         if (!eventBusEvent) return;
@@ -531,7 +543,9 @@ var EventBus = class {
             for (const [eventName, callback] of connection.subscribableEvents.entries()) {
               if (eventName !== eventBusEvent.name) continue;
               if (callback) {
-                const forgettable = async () => await callback({ payloads });
+                const forgettable = /* @__PURE__ */ __name(async () => await callback({
+                  payloads
+                }), "forgettable");
                 forget(forgettable());
               }
             }
@@ -543,16 +557,22 @@ var EventBus = class {
   }
   handlePublisherAdd(connection) {
     for (const eventName of connection.publishableEvents ?? []) {
-      const connectionPublisherCallback = async ({ payloads }) => {
-        const event = { name: eventName, schema: "network.xyo.event.bus.event" };
+      const connectionPublisherCallback = /* @__PURE__ */ __name(async ({ payloads }) => {
+        const event = {
+          name: eventName,
+          schema: "network.xyo.event.bus.event"
+        };
         const eventPayloads = payloads ?? [];
         event.sources = await PayloadBuilder.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;
@@ -569,6 +589,9 @@ var EventBus = class {
 
 // src/event/bus/PubSubConnection.ts
 var EventBusPubSubConnection = class extends EventBusConnection {
+  static {
+    __name(this, "EventBusPubSubConnection");
+  }
   publishableEvents;
   subscribableEvents;
   constructor(request) {
@@ -584,42 +607,52 @@ var EventBusPubSubConnection = class extends EventBusConnection {
 // src/event/connections/DappAccessRequest.ts
 var DappAccessRequestEvent = "dappAccessRequest";
 var dappAccessRequestConnectionRequest = {
-  publishableEvents: [DappAccessRequestEvent],
+  publishableEvents: [
+    DappAccessRequestEvent
+  ],
   type: "PubSub"
 };
-var dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest);
+var dappAccessRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(dappAccessRequestConnectionRequest), "dappAccessRequestConnection");
 
 // src/event/connections/ExposeDappRequest.ts
 var ExposeDappRequestEvent = "exposeDappRequest";
 var exposeDappConnectionRequest = {
-  publishableEvents: [ExposeDappRequestEvent],
+  publishableEvents: [
+    ExposeDappRequestEvent
+  ],
   type: "PubSub"
 };
-var exposeDappRequestConnection = () => new EventBusPubSubConnection(exposeDappConnectionRequest);
+var exposeDappRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(exposeDappConnectionRequest), "exposeDappRequestConnection");
 
 // src/event/connections/OsPubSubNetworkReady.ts
 var OsPubSubNetworkReadyEvent = "osPubSubNetworkReady";
 var osPubSubNetworkConnectionRequest = {
-  publishableEvents: [OsPubSubNetworkReadyEvent],
+  publishableEvents: [
+    OsPubSubNetworkReadyEvent
+  ],
   type: "PubSub"
 };
-var osPubSubNetworkReadyConnection = () => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest);
+var osPubSubNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest), "osPubSubNetworkReadyConnection");
 
 // src/event/connections/OsSettingsReady.ts
 var OsSettingsReadyEvent = "osSettingsReady";
 var osSettingsConnectionRequest = {
-  publishableEvents: [OsSettingsReadyEvent],
+  publishableEvents: [
+    OsSettingsReadyEvent
+  ],
   type: "PubSub"
 };
-var osSettingsReadyConnection = () => new EventBusPubSubConnection(osSettingsConnectionRequest);
+var osSettingsReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osSettingsConnectionRequest), "osSettingsReadyConnection");
 
 // src/event/connections/OsXyoPublicReady.ts
 var OsXyoPublicNetworkReadyEvent = "osXyoPublicNetworkReady";
 var osXyoPublicNetworkConnectionRequest = {
-  publishableEvents: [OsXyoPublicNetworkReadyEvent],
+  publishableEvents: [
+    OsXyoPublicNetworkReadyEvent
+  ],
   type: "PubSub"
 };
-var osXyoPublicNetworkReadyConnection = () => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest);
+var osXyoPublicNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest), "osXyoPublicNetworkReadyConnection");
 
 // src/XyOsDapp.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
@@ -671,6 +704,9 @@ import { BaseEmitter as BaseEmitter2 } from "@xyo-network/module-event-emitter";
 import { ModuleFactoryLocator } 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;
@@ -754,10 +790,15 @@ var XyOsContextBase = class extends BaseEmitter2 {
 
 // src/XyOsDapp.ts
 var XyOsDapp = class extends XyOsContextBase {
+  static {
+    __name(this, "XyOsDapp");
+  }
   dapp;
   constructor(params) {
     super(params);
-    this.dapp = { ...params.dapp };
+    this.dapp = {
+      ...params.dapp
+    };
   }
   get eventBus() {
     return this.parent.eventBus;
@@ -769,12 +810,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 assertEx6(this.parent.kernel, () => "Missing kernel");
   }
@@ -793,15 +834,17 @@ var XyOsDapp = class extends XyOsContextBase {
       assertEx6(this._root === void 0, () => "Dapp already booted");
       const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator2()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator2();
       console.log("XyOsDapp:boot:finalLocator", finalLocator);
-      const dappNodesWrapper = new ManifestWrapper({ ...this.manifest, schema: DappPackageManifestPayloadSchema }, wallet, finalLocator);
+      const dappNodesWrapper = new ManifestWrapper({
+        ...this.manifest,
+        schema: DappPackageManifestPayloadSchema
+      }, wallet, finalLocator);
       const dappNodes = await dappNodesWrapper.loadNodes();
       const dappManifestWallet = await wallet.derivePath("99999");
       dapp_window_manifest_default.nodes[0].config.name = this.dapp.name + "Root";
-      const wrapper = new ManifestWrapper(
-        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema },
-        dappManifestWallet,
-        finalLocator
-      );
+      const wrapper = new ManifestWrapper({
+        ...dapp_window_manifest_default,
+        schema: DappPackageManifestPayloadSchema
+      }, dappManifestWallet, finalLocator);
       const node = await wrapper.loadNodeFromIndex(0);
       for (const dappNode of dappNodes) {
         await node.register(dappNode);
@@ -823,12 +866,7 @@ import semver from "semver";
 
 // src/classes/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 PayloadBuilder2 } from "@xyo-network/payload-builder";
 var SystemDappQueries = {
   async getDappAccess(diviner, name, version) {
@@ -836,10 +874,14 @@ 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 = {
@@ -847,9 +889,13 @@ 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) {
@@ -857,10 +903,14 @@ 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) {
@@ -868,10 +918,14 @@ 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 PayloadBuilder2.dataHash(widgetConfig);
@@ -883,25 +937,28 @@ var SystemDappQueries = {
 
 // src/classes/system/ManageSystemDapps.ts
 var ManageSystemDapps = class extends OsCallerBase {
+  static {
+    __name(this, "ManageSystemDapps");
+  }
+  defaultSystemNames;
+  defaultSystemDapps;
+  defaultSystemDappParams;
+  locator;
+  developmentMode;
+  onErrorCallbacks;
   constructor(context, defaultSystemNames, defaultSystemDapps, defaultSystemDappParams, locator, developmentMode) {
-    super(context);
-    this.defaultSystemNames = defaultSystemNames;
-    this.defaultSystemDapps = defaultSystemDapps;
-    this.defaultSystemDappParams = defaultSystemDappParams;
-    this.locator = locator;
-    this.developmentMode = developmentMode;
+    super(context), this.defaultSystemNames = defaultSystemNames, this.defaultSystemDapps = defaultSystemDapps, this.defaultSystemDappParams = defaultSystemDappParams, this.locator = locator, this.developmentMode = developmentMode, this.onErrorCallbacks = [];
   }
-  onErrorCallbacks = [];
   /**
-   * Add a callback to listen for errors throwing during system dapp registration
-   * @param  {ErrorListener} errorListener
-   */
+  * Add a callback to listen for errors throwing during system dapp registration
+  * @param  {ErrorListener} errorListener
+  */
   addErrorListener(errorListener) {
     this.onErrorCallbacks.push(errorListener);
   }
   /**
-   * Installs the dapps into the OS and builds the appropriate DappSet
-   */
+  * Installs the dapps into the OS and builds the appropriate DappSet
+  */
   async install() {
     await this.insertPayloads();
     return await this.latestSets();
@@ -925,9 +982,13 @@ var ManageSystemDapps = class extends OsCallerBase {
           console.error(`${systemDappPayload.version} does not appear to be a valid semver value`, e);
           continue;
         }
-        const [existing] = await archivist.get([await PayloadBuilder3.dataHash(systemDappPayload)]);
+        const [existing] = await archivist.get([
+          await PayloadBuilder3.dataHash(systemDappPayload)
+        ]);
         if (existing) continue;
-        await archivist.insert([systemDappPayload]);
+        await archivist.insert([
+          systemDappPayload
+        ]);
       }
       return true;
     } catch (e) {
@@ -982,11 +1043,7 @@ var ManageSystemDapps = class extends OsCallerBase {
 
 // src/classes/registration/DappRegistry.ts
 import { HDWallet as HDWallet3 } from "@xyo-network/account";
-import {
-  DappRegisteredSchema,
-  DappRegisteredState,
-  isRegisteredDappAccess
-} from "@xyo-network/os-model";
+import { DappRegisteredSchema, DappRegisteredState, isRegisteredDappAccess } from "@xyo-network/os-model";
 
 // src/classes/registration/ValidateDappAccessDiviner/Config.ts
 import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
@@ -998,20 +1055,22 @@ var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registra
 import { HDWallet as HDWallet2 } from "@xyo-network/account";
 import { AbstractDiviner } from "@xyo-network/diviner-abstract";
 import { ManifestWrapper as ManifestWrapper2, PackageManifestPayloadSchema } from "@xyo-network/manifest";
-import {
-  isDappPackageManifestPayload,
-  isUnregisteredDappAccess,
-  RegisteredDappAccessSchema
-} from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { isDappPackageManifestPayload, isUnregisteredDappAccess, RegisteredDappAccessSchema } from "@xyo-network/os-model";
 
 // src/access-interfaces/ValidDappAccessInterfaces.ts
 import { RegisteredNames, RegisteredNamesInterface } from "@xyo-network/os-model";
-var ValidDappAccessInterfaces = { [RegisteredNames]: RegisteredNamesInterface };
+var ValidDappAccessInterfaces = {
+  [RegisteredNames]: RegisteredNamesInterface
+};
 
 // src/classes/registration/ValidateDappAccessDiviner/Diviner.ts
 var ValidateDappAccessDiviner = class extends AbstractDiviner {
-  static configSchemas = [ValidateDappAccessDivinerConfigSchema];
+  static {
+    __name(this, "ValidateDappAccessDiviner");
+  }
+  static configSchemas = [
+    ValidateDappAccessDivinerConfigSchema
+  ];
   async divineHandler(payloads) {
     const dappManifest = payloads?.filter(isDappPackageManifestPayload);
     const accessors = payloads?.filter(isUnregisteredDappAccess);
@@ -1037,48 +1096,49 @@ var ValidateDappAccessDiviner = class extends AbstractDiviner {
           const interfaceChildren = await getNodeChildren(dappAccessInterface.manifest, dappParams);
           const valid = compareChildren(interfaceChildren, dappChildren);
           if (valid) {
-            const payload = await PayloadBuilder4.build({
+            const payload = {
               ...access,
               schema: RegisteredDappAccessSchema,
               timestamp: Date.now()
-            });
+            };
             registeredAccessors.push(payload);
           } else {
-            const failedRegistration = await PayloadBuilder4.build({
+            const failedRegistration = {
               accessor: access,
               errorMessage: "Invalid dapp access interface",
               schema: FailedAccessorSchema
-            });
+            };
             failedAccessors.push(failedRegistration);
           }
         }
       } catch (e) {
-        failedAccessors.push(
-          await PayloadBuilder4.build({
-            accessor: access,
-            errorMessage: e.message,
-            schema: FailedAccessorSchema
-          })
-        );
+        failedAccessors.push({
+          accessor: access,
+          errorMessage: e.message,
+          schema: FailedAccessorSchema
+        });
       }
     }
-    return [...registeredAccessors, ...failedAccessors];
+    return [
+      ...registeredAccessors,
+      ...failedAccessors
+    ];
   }
 };
-var compareChildren = (interfaceChildren, dappChildren) => {
+var compareChildren = /* @__PURE__ */ __name((interfaceChildren, dappChildren) => {
   return interfaceChildren.every((interfaceChild) => Object.values(interfaceChild).every((interfaceChildName) => dappChildren.some((dappChild) => Object.values(dappChild).includes(interfaceChildName))));
-};
-var dappPackageManifestToPackageManifest = (dappPackageManifest) => {
+}, "compareChildren");
+var dappPackageManifestToPackageManifest = /* @__PURE__ */ __name((dappPackageManifest) => {
   return {
     ...dappPackageManifest,
     schema: PackageManifestPayloadSchema
   };
-};
-var getChildrenFromNode = async (node) => {
+}, "dappPackageManifestToPackageManifest");
+var getChildrenFromNode = /* @__PURE__ */ __name(async (node) => {
   const nodeManifest = (await node.state())?.[0];
   return nodeManifest.status?.children;
-};
-var getNodeChildren = async (manifestToTest, dappParams) => {
+}, "getChildrenFromNode");
+var getNodeChildren = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
   const testNodes = await getNodeToTest(manifestToTest, dappParams);
   const children = [];
   for (const node of testNodes) {
@@ -1088,35 +1148,32 @@ var getNodeChildren = async (manifestToTest, dappParams) => {
     }
   }
   return children;
-};
-var getNodeToTest = async (manifestToTest, dappParams) => {
+}, "getNodeChildren");
+var getNodeToTest = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
   const dappManifestWrapper = new ManifestWrapper2(manifestToTest, await HDWallet2.random(), dappParams.locator);
   return await dappManifestWrapper.loadNodes();
-};
+}, "getNodeToTest");
 
 // src/classes/registration/DappRegistry.ts
 var DappRegistry = class {
+  static {
+    __name(this, "DappRegistry");
+  }
+  dappSeedPhraseRepository;
+  dappRegistry;
   constructor(dappSeedPhraseRepository) {
     this.dappSeedPhraseRepository = dappSeedPhraseRepository;
+    this.dappRegistry = /* @__PURE__ */ new Map();
   }
-  dappRegistry = /* @__PURE__ */ new Map();
   /**
-   * Register a Dapp with window manager and if successful, return its id
-   *
-   * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
-   * @returns {RegisteredDapp} dapp with registration fields
-   **/
+  * Register a Dapp with window manager and if successful, return its id
+  *
+  * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
+  * @returns {RegisteredDapp} dapp with registration fields
+  **/
   async registerDapp(dapp) {
     if (dapp) {
-      const {
-        exposedModuleIds,
-        manifest,
-        modes,
-        name,
-        version,
-        params,
-        widgetConfigs
-      } = this.extractDappProperties(dapp);
+      const { exposedModuleIds, manifest, modes, name, version, params, widgetConfigs } = this.extractDappProperties(dapp);
       try {
         const walletId = await this.dappSeedPhraseRepository.findOrCreate(name);
         const registeredAccessors = await this.validateDappAccessPayloads(manifest, dapp.accessors, params);
@@ -1151,27 +1208,16 @@ var DappRegistry = class {
     }
   }
   /**
-   * Unregister a dapp so it can no longer be launched
-   *
-   * @param dappId
-   */
+  * Unregister a dapp so it can no longer be launched
+  *
+  * @param dappId
+  */
   unregisterDapp(dappId) {
     this.dappRegistry.delete(dappId);
   }
   extractDappProperties(dapp) {
-    const {
-      params,
-      config,
-      widgetConfigs
-    } = dapp;
-    const {
-      exposedModuleIds,
-      manifest,
-      modes,
-      name,
-      sources,
-      version
-    } = config;
+    const { params, config, widgetConfigs } = dapp;
+    const { exposedModuleIds, manifest, modes, name, sources, version } = config;
     return {
       exposedModuleIds,
       manifest,
@@ -1186,10 +1232,15 @@ var DappRegistry = class {
   async validateDappAccessPayloads(manifest, accessors = [], params) {
     const validateDappAccess = await ValidateDappAccessDiviner.create({
       account: await HDWallet3.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) {
@@ -1201,6 +1252,26 @@ var DappRegistry = class {
 
 // src/classes/registration/DappRegistrationService.ts
 var DappRegistrationService = class {
+  static {
+    __name(this, "DappRegistrationService");
+  }
+  context;
+  params;
+  locator;
+  developmentMode;
+  // Dapps that have been built with their own context
+  builtDapps;
+  dappRegistry;
+  dappSeedPhraseRepository;
+  manageSystemDapps;
+  // Dapps that have been registered with dappAccessRequests
+  registeredAccessDappSets;
+  // Dapps that have been registered with the dapp registry
+  registeredDappSets;
+  // Dapps that have been registered with exposeDappRequests
+  registeredExposedDappSets;
+  dappAccessRequestConnection;
+  exposeDappRequestConnection;
   constructor(context, params = {
     dappNames: [],
     dappParams: {},
@@ -1210,34 +1281,23 @@ var DappRegistrationService = class {
     this.params = params;
     this.locator = locator;
     this.developmentMode = developmentMode;
-    this.manageSystemDapps = new ManageSystemDapps(
-      context,
-      this.params?.dappNames ?? [],
-      this.params?.dappPayloads ?? [],
-      this.params?.dappParams ?? {},
-      this.locator,
-      this.developmentMode
-    );
+    this.builtDapps = {};
+    this.registeredAccessDappSets = /* @__PURE__ */ new Set();
+    this.registeredDappSets = /* @__PURE__ */ new Set();
+    this.registeredExposedDappSets = /* @__PURE__ */ new Set();
+    this.dappAccessRequestConnection = dappAccessRequestConnection();
+    this.exposeDappRequestConnection = exposeDappRequestConnection();
+    this.manageSystemDapps = new ManageSystemDapps(context, this.params?.dappNames ?? [], this.params?.dappPayloads ?? [], this.params?.dappParams ?? {}, this.locator, this.developmentMode);
     this.dappSeedPhraseRepository = new DappSeedPhraseRepository(context, this.params?.dappNames ?? []);
     this.dappRegistry = new DappRegistry(this.dappSeedPhraseRepository);
     this.addConnectionRequests();
   }
-  // Dapps that have been built with their own context
-  builtDapps = {};
-  dappRegistry;
-  dappSeedPhraseRepository;
-  manageSystemDapps;
-  // Dapps that have been registered with dappAccessRequests
-  registeredAccessDappSets = /* @__PURE__ */ new Set();
-  // Dapps that have been registered with the dapp registry
-  registeredDappSets = /* @__PURE__ */ new Set();
-  // Dapps that have been registered with exposeDappRequests
-  registeredExposedDappSets = /* @__PURE__ */ new Set();
-  dappAccessRequestConnection = dappAccessRequestConnection();
-  exposeDappRequestConnection = exposeDappRequestConnection();
   async buildDapp(manifest, dappId = NameTransforms.slug(manifest.nodes[0]?.config.name), name = NameTransforms.moduleName(manifest.nodes[0]?.config.name)) {
     const dapp = new XyOsDapp({
-      dapp: { id: dappId, name },
+      dapp: {
+        id: dappId,
+        name
+      },
       locator: this.locator,
       manifest,
       parent: this.context,
@@ -1250,37 +1310,43 @@ var DappRegistrationService = class {
     return this.params?.dappParams[dappId];
   }
   async start() {
-    const systemDapps = await this.context.monitor(async () => await this.manageSystemDapps.install(), { name: "Install System dApps" });
+    const systemDapps = await this.context.monitor(async () => await this.manageSystemDapps.install(), {
+      name: "Install System dApps"
+    });
     const activeDapps = systemDapps.filter(({ dapp }) => dapp.icon.active === true);
-    const results = await Promise.allSettled(
-      activeDapps.map(async (dappSet) => {
-        const { dapp } = dappSet;
-        const registeredDapp = await this.dappRegistry.registerDapp(dapp);
-        const result = { dapp: registeredDapp, dappIcon: dapp.icon };
-        const forgetHandlers = async () => {
-          try {
-            await this.postRegistrationHandlers(result);
-          } catch (e) {
-            console.error("Error in post registration handlers", e);
-          }
-        };
-        forget2(forgetHandlers());
-        return result;
-      })
-    );
+    const results = await Promise.allSettled(activeDapps.map(async (dappSet) => {
+      const { dapp } = dappSet;
+      const registeredDapp = await this.dappRegistry.registerDapp(dapp);
+      const result = {
+        dapp: registeredDapp,
+        dappIcon: dapp.icon
+      };
+      const forgetHandlers = /* @__PURE__ */ __name(async () => {
+        try {
+          await this.postRegistrationHandlers(result);
+        } catch (e) {
+          console.error("Error in post registration handlers", e);
+        }
+      }, "forgetHandlers");
+      forget2(forgetHandlers());
+      return result;
+    }));
     const failed = results.filter(rejected).map((result) => result.reason);
     const succeeded = results.filter(fulfilled).map((result) => result.value);
     for (const registeredDapp of succeeded) this.registeredDappSets.add(registeredDapp);
-    return { failed, succeeded };
+    return {
+      failed,
+      succeeded
+    };
   }
   addConnectionRequests() {
     this.context.eventBus.addConnection(this.dappAccessRequestConnection);
     this.context.eventBus.addConnection(this.exposeDappRequestConnection);
   }
   /**
-   * A method to get the user property from context and eventually modify it before handing it to a dapp
-   * i.e. curating user-approved signers
-   */
+  * A method to get the user property from context and eventually modify it before handing it to a dapp
+  * i.e. curating user-approved signers
+  */
   getUser() {
     return this.context.user;
   }
@@ -1288,17 +1354,19 @@ 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
+        });
       }
     }
   }
@@ -1308,6 +1376,9 @@ var DappRegistrationService = class {
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { HDWallet as HDWallet4 } from "@xyo-network/account";
 var Signers = class {
+  static {
+    __name(this, "Signers");
+  }
   _paths;
   _signerAccounts;
   _walletStore;
@@ -1358,26 +1429,32 @@ import { IndexedDbPayloadDiviner } from "@xyo-network/diviner-payload-indexeddb"
 import { ManifestWrapper as ManifestWrapper3 } from "@xyo-network/manifest-wrapper";
 import { ModuleFactoryLocator as ModuleFactoryLocator4 } from "@xyo-network/module-factory-locator";
 var OS_NODE_PATH = "1'";
-var getDefaultOsNodeLocator = () => {
+var getDefaultOsNodeLocator = /* @__PURE__ */ __name(() => {
   const locator = new ModuleFactoryLocator4();
-  locator.register(IndexedDbArchivist, { "network.xyo.archivist.persistence.scope": "device" });
-  locator.register(IndexedDbPayloadDiviner, { "network.xyo.archivist.persistence.scope": "device" });
+  locator.register(IndexedDbArchivist, {
+    "network.xyo.archivist.persistence.scope": "device"
+  });
+  locator.register(IndexedDbPayloadDiviner, {
+    "network.xyo.archivist.persistence.scope": "device"
+  });
   return locator;
-};
-var loadOsNode = async (osWallet, locator) => {
+}, "getDefaultOsNodeLocator");
+var loadOsNode = /* @__PURE__ */ __name(async (osWallet, locator) => {
   try {
     const osNodeWallet = await osWallet.derivePath(OS_NODE_PATH);
     const osNodeLocator = locator ?? getDefaultOsNodeLocator();
     const manifestWrapper = new ManifestWrapper3(os_node_manifest_default, osNodeWallet, osNodeLocator);
     const osNode = (await manifestWrapper.loadNodes())[0];
-    return [osNode];
+    return [
+      osNode
+    ];
   } catch (e) {
     const error = e;
     console.error(`Error creating os node: ${error.message}`);
     console.error(`Error creating os node: ${error.stack}`);
     throw new Error(`Error creating os node: ${error.message}`);
   }
-};
+}, "loadOsNode");
 
 // src/stack/Base.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
@@ -1386,6 +1463,9 @@ import { BaseEmitter as BaseEmitter3 } from "@xyo-network/module-event-emitter";
 import { isModuleInstance } from "@xyo-network/module-model";
 import { asAttachableNodeInstance } from "@xyo-network/node-model";
 var StackBase = class extends BaseEmitter3 {
+  static {
+    __name(this, "StackBase");
+  }
   // flag to check that all adapters are initialized
   initialized = false;
   // adapters to initialize into the stack
@@ -1420,57 +1500,57 @@ var StackBase = class extends BaseEmitter3 {
   initialize() {
     this.assignStack();
     for (const adapter of this.adapterSet) {
-      const driverReadyListener = async ({ node }) => await this.handleDriverReady(node);
+      const driverReadyListener = /* @__PURE__ */ __name(async ({ node }) => await this.handleDriverReady(node), "driverReadyListener");
       adapter.on("driverReady", driverReadyListener);
       this.listeners.push({
         adapter,
         eventName: "driverReady",
         listener: driverReadyListener
       });
-      const driverErrorListener = async ({ error }) => {
+      const driverErrorListener = /* @__PURE__ */ __name(async ({ error }) => {
         console.error(`Error updating ${this.stackNodeModuleId} stack node`, error);
-        await this.emit("driverError", { error });
-      };
+        await this.emit("driverError", {
+          error
+        });
+      }, "driverErrorListener");
       adapter.on("driverError", driverErrorListener);
       this.listeners.push({
         adapter,
         eventName: "driverError",
         listener: driverErrorListener
       });
-      const startAdapter = async () => await adapter.start();
+      const startAdapter = /* @__PURE__ */ __name(async () => await adapter.start(), "startAdapter");
       forget3(startAdapter());
     }
   }
   /**
-   * Stops the stack
-   */
+  * Stops the stack
+  */
   stop() {
-    for (const {
-      eventName,
-      listener,
-      adapter
-    } of this.listeners) {
+    for (const { eventName, listener, adapter } of this.listeners) {
       adapter.off(eventName, listener);
     }
   }
   /**
-   * Adds a node to the stack. Idempotent to avoid adding the
-   * same node multiple times
-   * @param node The node to add to the stack
-   * @returns
-   */
+  * Adds a node to the stack. Idempotent to avoid adding the
+  * same node multiple times
+  * @param node The node to add to the stack
+  * @returns
+  */
   async addNodeToStackNode(node) {
     const stackNode = await this.getStackNode();
-    const existingModule = await stackNode.resolve(node.address, { direction: "down" });
+    const existingModule = await stackNode.resolve(node.address, {
+      direction: "down"
+    });
     if (isModuleInstance(existingModule)) return;
     await stackNode.register?.(node);
     await stackNode.attach?.(node.address, true);
   }
   assignStack() {
-    const assign = async () => {
+    const assign = /* @__PURE__ */ __name(async () => {
       const stackNode = await this.getStackNode();
       this._stack = stackNode;
-    };
+    }, "assign");
     forget3(assign());
   }
   async getStackNode() {
@@ -1479,25 +1559,34 @@ var StackBase = class extends BaseEmitter3 {
   }
   async handleDriverReady(node) {
     try {
-      await this.emit("driverReady", { node });
+      await this.emit("driverReady", {
+        node
+      });
       await this.addNodeToStackNode(node);
       await this.updateInitializationState(node);
     } catch (error) {
       console.error(`Error updating ${this.stackNodeModuleId} stack node`, node.id, error);
-      await this.emit("stackError", { error });
+      await this.emit("stackError", {
+        error
+      });
     }
   }
   async updateInitializationState(node) {
     this.initializedNodes.push(node);
     this.initialized = this.adapterSet.every((n) => n.initialized);
     if (this.initialized) {
-      await this.emit("initialized", { stack: await this.getStackNode() });
+      await this.emit("initialized", {
+        stack: await this.getStackNode()
+      });
     }
   }
 };
 
 // src/stack/Manager.ts
 var StackManager = class {
+  static {
+    __name(this, "StackManager");
+  }
   initializedStacksMap = /* @__PURE__ */ new Map();
   stackMap;
   constructor(stackMap) {
@@ -1539,27 +1628,30 @@ import { BaseEmitter as BaseEmitter4 } from "@xyo-network/module-event-emitter";
 import { asAttachableNodeInstance as asAttachableNodeInstance2 } from "@xyo-network/node-model";
 import { v4 as uuid3 } from "uuid";
 var NodeAdapterBase = class extends BaseEmitter4 {
+  static {
+    __name(this, "NodeAdapterBase");
+  }
+  kernel;
+  driverName;
+  initialized;
+  _id;
   constructor(kernel, driverName) {
-    super({});
-    this.kernel = kernel;
-    this.driverName = driverName;
+    super({}), this.kernel = kernel, this.driverName = driverName, this.initialized = false, this._id = "";
     this._id = uuid3();
   }
-  initialized = false;
-  _id = "";
   get id() {
     return assertEx9(this._id, () => "NodeAdapterBase id not initialized");
   }
   async start() {
     try {
-      const moduleAttachedInsertListener = ({ payloads }) => {
+      const moduleAttachedInsertListener = /* @__PURE__ */ __name(({ payloads }) => {
         const moduleAttachedEvent = this.findModuleEventPayloads(payloads);
         for (const payload of moduleAttachedEvent) {
           if (payload.name === this.driverName) {
             this.validateAndReturnDriver();
           }
         }
-      };
+      }, "moduleAttachedInsertListener");
       const eventsArchivist = await this.getEventsArchivist();
       const weakRefInsertListener = new WeakRef(moduleAttachedInsertListener);
       const insertListenerRef = weakRefInsertListener.deref();
@@ -1568,7 +1660,9 @@ var NodeAdapterBase = class extends BaseEmitter4 {
       if (node) return node;
       this.initialized = false;
     } catch (error) {
-      await this.emit("driverError", { error });
+      await this.emit("driverError", {
+        error
+      });
     }
   }
   findModuleEventPayloads(payloads) {
@@ -1586,7 +1680,9 @@ var NodeAdapterBase = class extends BaseEmitter4 {
     if (mod) {
       const node = asAttachableNodeInstance2(mod, () => `${mod.id} is not a node`);
       this.initialized = true;
-      const emit = async () => await this.emit("driverReady", { node });
+      const emit = /* @__PURE__ */ __name(async () => await this.emit("driverReady", {
+        node
+      }), "emit");
       forget4(emit());
       return node;
     }
@@ -1595,6 +1691,9 @@ var NodeAdapterBase = class extends BaseEmitter4 {
 
 // src/adapter/Network.ts
 var NetworkAdapter = class extends NodeAdapterBase {
+  static {
+    __name(this, "NetworkAdapter");
+  }
   _connection;
   constructor(kernel, driverName) {
     super(kernel, driverName);
@@ -1615,6 +1714,9 @@ var NetworkAdapter = class extends NodeAdapterBase {
 
 // src/adapter/Settings.ts
 var SettingsAdapter = class extends NodeAdapterBase {
+  static {
+    __name(this, "SettingsAdapter");
+  }
   _settings = void 0;
   constructor(kernel, driverName) {
     super(kernel, driverName);
@@ -1634,26 +1736,31 @@ var SettingsAdapter = class extends NodeAdapterBase {
 };
 
 // src/adapters/OsPubSubBridgeNetwork.ts
-var OsPubSubBridgeNetworkAdapters = (kernel) => [
+var OsPubSubBridgeNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
   new NetworkAdapter(kernel, PubSubBridgeNodeNodeName),
   new NetworkAdapter(kernel, ExposedNodeOuterNodeName)
-];
+], "OsPubSubBridgeNetworkAdapters");
 
 // src/adapters/OsSettings.ts
 import { OsSettingsNodeName } from "@xyo-network/os-model";
-var OsSettingsAdapters = (kernel) => [new SettingsAdapter(kernel, OsSettingsNodeName)];
+var OsSettingsAdapters = /* @__PURE__ */ __name((kernel) => [
+  new SettingsAdapter(kernel, OsSettingsNodeName)
+], "OsSettingsAdapters");
 
 // src/adapters/OsXyoPublicNetwork.ts
 import { XyoPublicNodeName } from "@xyo-network/os-model";
-var OsXyoPublicNetworkAdapters = (kernel) => [
+var OsXyoPublicNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
   new NetworkAdapter(kernel, XyoPublicNodeName)
-];
+], "OsXyoPublicNetworkAdapters");
 
 // src/stack/OsPubSubNetworkStack.ts
 import { assertEx as assertEx10 } 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();
@@ -1696,13 +1803,15 @@ var OsPubSubNetworkStack = class extends StackBase {
     super.stop();
     this._exposedNode = void 0;
     this._exposedNodeOuter = void 0;
-    if (this.busConnection._id)
-      this.context.eventBus.removeConnection(this.busConnection.id);
+    if (this.busConnection._id) this.context.eventBus.removeConnection(this.busConnection.id);
   }
 };
 
 // src/stack/OsSettingsStack.ts
 var OsSettingsStack = class extends StackBase {
+  static {
+    __name(this, "OsSettingsStack");
+  }
   busConnection = osSettingsReadyConnection();
   constructor(context, adapters) {
     super(context, adapters, "OsSettingsStackNode");
@@ -1720,6 +1829,9 @@ var OsSettingsStack = class extends StackBase {
 // src/stack/XyoPublicNetworkStack.ts
 import { XyoPublicNodeName as XyoPublicNodeName2 } from "@xyo-network/os-model";
 var XyoPublicNetworkStack = class extends StackBase {
+  static {
+    __name(this, "XyoPublicNetworkStack");
+  }
   busConnection = osXyoPublicNetworkReadyConnection();
   constructor(context, adapters) {
     super(context, adapters, "OsXyoPublicNetworkStackNode");
@@ -1758,6 +1870,9 @@ var OsStackMap = {
 
 // src/XyOs.ts
 var XyOs = class _XyOs extends XyOsContextBase {
+  static {
+    __name(this, "XyOs");
+  }
   _exposedNode;
   _exposedNodeOuter;
   _kernel;
@@ -1765,16 +1880,9 @@ var XyOs = class _XyOs extends XyOsContextBase {
   dappRegistrationService;
   signers;
   stackManager;
-  constructor({
-    logger = console,
-    eventBus = new EventBus(),
-    kernel = new Kernel({ logger }),
-    locator = new ModuleFactoryLocator5(),
-    dappsConfiguration,
-    developmentMode,
-    stackMap = OsStackMap,
-    ...params
-  } = {}) {
+  constructor({ logger = console, eventBus = new EventBus(), kernel = new Kernel({
+    logger
+  }), locator = new ModuleFactoryLocator5(), dappsConfiguration, developmentMode, stackMap = OsStackMap, ...params } = {}) {
     super({
       eventBus,
       kernel,
@@ -1812,14 +1920,19 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return this.stackManager.stacks;
   }
   get user() {
-    return { signers: this.signers?.getWalletKindSigner("user") };
+    return {
+      signers: this.signers?.getWalletKindSigner("user")
+    };
   }
   static async monitor(fn, eventConfig) {
     const { name, additionalProperties } = eventConfig;
     const monitor = this.monitoring;
     monitor?.startTimer(name);
     const result = await fn();
-    monitor?.stopTimer({ additionalProperties, name });
+    monitor?.stopTimer({
+      additionalProperties,
+      name
+    });
     return result;
   }
   async boot(wallet, locator = new ModuleFactoryLocator5()) {
@@ -1828,13 +1941,18 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return await this._bootMutex.runExclusive(async () => {
       await this.eventBus.start();
       if (this.kernel?.status === "created") {
-        await this.kernel.boot(await boot(), { locator: fullLocator, kernelDrivers: [] });
+        await this.kernel.boot(await boot(), {
+          locator: fullLocator,
+          kernelDrivers: []
+        });
       }
       if (this.kernel?.status !== "booted") {
         throw new Error("Kernel not booted");
       }
       assertEx11(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();
@@ -1865,26 +1983,32 @@ var XyOs = class _XyOs extends XyOsContextBase {
 
 // src/scripts/xyos/lib/headless.ts
 var { terminal } = tk;
-var terminate = () => {
+var terminate = /* @__PURE__ */ __name(() => {
   terminal.grabInput(false);
   setTimeout(function() {
     process.exit(0);
   }, 100);
-};
-var headless = async ({
-  manifest,
-  config,
-  kernelDrivers
-} = {}) => {
+}, "terminate");
+var headless = /* @__PURE__ */ __name(async ({ manifest, config, kernelDrivers } = {}) => {
   console.log(chalk.green("Starting Headless xyOS..."));
-  const configExplorer = cosmiconfig("xyos", { cache: true, loaders: { ".ts": TypeScriptLoader() } });
+  const configExplorer = cosmiconfig("xyos", {
+    cache: true,
+    loaders: {
+      ".ts": TypeScriptLoader()
+    }
+  });
   const configResult = await (config ? configExplorer.load(config) : configExplorer.search());
   const xyosConfig = configResult?.config ?? {};
   const manifestToLoad = manifest ?? (typeof xyosConfig.manifest === "string" ? xyosConfig.manifest : void 0);
   const manifestObject = manifestToLoad ? JSON.parse(fs.readFileSync(manifestToLoad, "utf8")) : typeof xyosConfig.manifest === "object" ? xyosConfig.manifest : void 0;
   const osWallet = await HDWallet5.random();
-  const kernel = new Kernel2({ logColor: "cyan", logger: console });
-  await kernel.boot(await boot2(), { kernelDrivers });
+  const kernel = new Kernel2({
+    logColor: "cyan",
+    logger: console
+  });
+  await kernel.boot(await boot2(), {
+    kernelDrivers
+  });
   const xyOs = new XyOs({
     kernel,
     stackMap: {},
@@ -1893,14 +2017,16 @@ var headless = async ({
   });
   await xyOs.boot(osWallet);
   console.log(chalk.green("Started Headless xyOS..."));
-  terminal.grabInput({ mouse: "button" });
+  terminal.grabInput({
+    mouse: "button"
+  });
   terminal.on("key", function(name) {
     console.log("'key' event:", name);
     if (name === "CTRL_C") {
       terminate();
     }
   });
-};
+}, "headless");
 export {
   createFromTemplate,
   headless