@xyo-network/os-runtime 7.0.0 → 7.1.0

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

@@ -1,19 +1,12 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/scripts/xyos/index.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
 // src/scripts/xyos/command/config.ts
-var commandConfig = /* @__PURE__ */ __name((argv) => {
+var commandConfig = (argv) => {
   return argv.command("config [action] <target>", "Create an xyos project", (yargs2) => {
     return yargs2.positional("action", {
-      choices: [
-        "create",
-        "validate",
-        "display"
-      ],
+      choices: ["create", "validate", "display"],
       description: "Action to take on config",
       type: "string"
     }).positional("target", {
@@ -24,13 +17,13 @@ var commandConfig = /* @__PURE__ */ __name((argv) => {
     console.log(`Taking action [${action}] on manifest at ${target}`);
     return await Promise.resolve();
   });
-}, "commandConfig");
+};
 
 // src/scripts/xyos/lib/createFromTemplate.ts
-var createFromTemplate = /* @__PURE__ */ __name(async ({ target, template }) => {
+var createFromTemplate = 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 "fs";
@@ -52,9 +45,6 @@ import { ModuleFactoryLocator as ModuleFactoryLocator6 } from "@xyo-network/modu
 import { assertEx } from "@xylabs/assert";
 import { BaseEmitter } from "@xylabs/events";
 var EventBusConnection = class extends BaseEmitter {
-  static {
-    __name(this, "EventBusConnection");
-  }
   _id;
   description;
   type;
@@ -77,14 +67,14 @@ import { assertEx as assertEx2 } from "@xylabs/assert";
 import { forget } from "@xylabs/forget";
 import { asArchivistInstance } 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 } from "@xyo-network/payload-builder";
 import { Mutex } from "async-mutex";
 import { v4 as uuid } from "uuid";
 var EventBus = class {
-  static {
-    __name(this, "EventBus");
-  }
   // Internal Archivist to store event data
   _archivist;
   // Store all connections
@@ -93,9 +83,11 @@ var EventBus = class {
   publisherCallbacks = {};
   startMutex = new Mutex();
   get archivist() {
-    return asArchivistInstance(assertEx2(this._archivist, () => "Archivist not found.  Did you forget to call start()?"), "not a valid archivist instance", {
-      required: true
-    });
+    return asArchivistInstance(
+      assertEx2(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
+      "not a valid archivist instance",
+      { required: true }
+    );
   }
   addConnection(connection) {
     const id = uuid();
@@ -124,12 +116,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;
@@ -139,9 +126,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());
               }
             }
@@ -153,22 +138,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 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;
@@ -185,9 +164,6 @@ var EventBus = class {
 
 // src/event/bus/PubSubConnection.ts
 var EventBusPubSubConnection = class extends EventBusConnection {
-  static {
-    __name(this, "EventBusPubSubConnection");
-  }
   publishableEvents;
   subscribableEvents;
   constructor(request) {
@@ -203,76 +179,61 @@ 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/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 } 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 = asDivinerInstance(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;
@@ -439,38 +400,37 @@ var os_node_manifest_default = {
 
 // src/loadOsNode.ts
 var OS_NODE_PATH = "1'";
-var getDefaultOsNodeLocator = /* @__PURE__ */ __name(() => {
+var getDefaultOsNodeLocator = () => {
   const locator = new ModuleFactoryLocator();
-  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 ModuleFactoryLocator5 } 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 } from "@xyo-network/diviner-payload-model";
@@ -486,67 +446,62 @@ var IntentArchivistModuleName = "IntentArchivist";
 var IntentArchivistPayloadDivinerModuleName = "IntentArchivistPayloadDiviner";
 var DappArchivistPayloadDivinerModuleName = "DappArchivistPayloadDiviner";
 var DappCallerBase = class {
-  static {
-    __name(this, "DappCallerBase");
-  }
   context;
   constructor(context) {
     this.context = context;
   }
   /**
-  * Get the DappArchivist
-  */
+   * Get the DappArchivist
+   */
   async getDappArchivist() {
-    const mod = assertEx3(await this.context.root.resolve(DappArchivistModuleName), () => `${DappArchivistModuleName} not found [${toSafeJsonString(this.context.root.publicChildren())}]`);
-    return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    const mod = assertEx3(
+      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 = assertEx3(await this.context.root.resolve(DappArchivistPayloadDivinerModuleName), () => `${DappArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx3(
+      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 = assertEx3(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 = assertEx3(await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName), () => `${IntentArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx3(
+      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
+      () => `${IntentArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
   }
 };
 
 // src/intent/Caller.ts
 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,
@@ -562,9 +517,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() {
@@ -585,9 +538,7 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
       schema: PayloadDivinerQuerySchema,
       sourceDappId: dappName
     };
-    return await diviner.divine([
-      query
-    ]);
+    return await diviner.divine([query]);
   }
 };
 
@@ -605,9 +556,6 @@ var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
 var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
 var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
 var OsCallerBase = class {
-  static {
-    __name(this, "OsCallerBase");
-  }
   context;
   constructor(context) {
     this.context = context;
@@ -615,43 +563,50 @@ var OsCallerBase = class {
   // Get the dapps archivist
   async getDappsArchivist() {
     const mod = assertEx4(await this.context.root.resolve(DappsArchivistModuleName), () => `${DappsArchivistModuleName} not found`);
-    return asArchivistInstance3(mod, () => `${DappsArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance3(mod, () => `${DappsArchivistModuleName} is not an archivist`, { required: true });
   }
   // Get the dapps archivist development
   async getDappsArchivistDevelopment() {
-    const mod = assertEx4(await this.context.root.resolve(DappsArchivistDevelopmentModuleName), () => `${DappsArchivistDevelopmentModuleName} not found`);
-    return asArchivistInstance3(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`, {
-      required: true
-    });
+    const mod = assertEx4(
+      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
+      () => `${DappsArchivistDevelopmentModuleName} not found`
+    );
+    return asArchivistInstance3(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`, { required: true });
   }
   // Get the dapps archivist payload diviner
   async getDappsArchivistPayloadDiviner() {
-    const mod = assertEx4(await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName), () => `${DappsArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance3(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx4(
+      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
+      () => `${DappsArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance3(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
   }
   // Get the dapps archivist payload diviner development
   async getDappsArchivistPayloadDivinerDevelopment() {
-    const mod = assertEx4(await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName), () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`);
-    return asDivinerInstance3(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`, {
-      required: true
-    });
+    const mod = assertEx4(
+      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
+      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`
+    );
+    return asDivinerInstance3(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`, { required: true });
   }
   // Get the registered dapp interfaces archivist
   async getRegisteredDappInterfacesArchivist() {
-    const mod = assertEx4(await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName), () => `${RegisteredDappInterfacesArchivistModuleName} not found`);
-    return asArchivistInstance3(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`, {
-      required: true
-    });
+    const mod = assertEx4(
+      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
+      () => `${RegisteredDappInterfacesArchivistModuleName} not found`
+    );
+    return asArchivistInstance3(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`, { required: true });
   }
 };
 
 // src/system/Queries.ts
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema2 } 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) {
@@ -659,14 +614,10 @@ var SystemDappQueries = {
       order: "desc",
       registeringDappId: name,
       schema: PayloadDivinerQuerySchema2,
-      schemas: [
-        UnregisteredDappAccessSchema
-      ],
+      schemas: [UnregisteredDappAccessSchema],
       version
     };
-    return await diviner.divine([
-      accessQuery
-    ]);
+    return await diviner.divine([accessQuery]);
   },
   async getLatestConfig(diviner, name) {
     const configQuery = {
@@ -674,13 +625,9 @@ var SystemDappQueries = {
       name,
       order: "desc",
       schema: PayloadDivinerQuerySchema2,
-      schemas: [
-        DappConfigSchema
-      ]
+      schemas: [DappConfigSchema]
     };
-    const [dappConfig] = await diviner.divine([
-      configQuery
-    ]);
+    const [dappConfig] = await diviner.divine([configQuery]);
     return dappConfig;
   },
   async getLatestIcon(diviner, name, version) {
@@ -688,14 +635,10 @@ var SystemDappQueries = {
       name,
       order: "desc",
       schema: PayloadDivinerQuerySchema2,
-      schemas: [
-        DappIconSchema
-      ],
+      schemas: [DappIconSchema],
       version
     };
-    const [dappIcon] = await diviner.divine([
-      iconQuery
-    ]);
+    const [dappIcon] = await diviner.divine([iconQuery]);
     return dappIcon;
   },
   async getWidgetConfigs(diviner, name, version) {
@@ -703,14 +646,10 @@ var SystemDappQueries = {
       dappId: name,
       order: "desc",
       schema: PayloadDivinerQuerySchema2,
-      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);
@@ -722,28 +661,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();
@@ -767,13 +708,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 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) {
@@ -832,16 +769,14 @@ import { DappWalletSeedPhraseSchema } from "@xyo-network/os-model";
 import { HDWallet } from "@xyo-network/wallet";
 import { v4 as uuid2 } 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();
@@ -853,9 +788,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;
@@ -887,13 +820,9 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema3,
-      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) {
@@ -902,14 +831,10 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
       limit: 1,
       order: "desc",
       schema: PayloadDivinerQuerySchema3,
-      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() {
@@ -967,9 +892,6 @@ import { BaseEmitter as BaseEmitter2 } from "@xylabs/events";
 import { ModuleFactoryLocator as ModuleFactoryLocator2 } 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;
@@ -1053,15 +975,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;
@@ -1073,12 +990,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");
   }
@@ -1097,17 +1014,15 @@ var XyOsDapp = class extends XyOsContextBase {
       assertEx6(this._root === void 0, () => "Dapp already booted");
       const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator3()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator3();
       console.log("XyOsDapp:boot:finalLocator", finalLocator);
-      const dappNodesWrapper = new ManifestWrapper2({
-        ...this.manifest,
-        schema: DappPackageManifestPayloadSchema
-      }, wallet, finalLocator);
+      const dappNodesWrapper = new ManifestWrapper2({ ...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 ManifestWrapper2({
-        ...dapp_window_manifest_default,
-        schema: DappPackageManifestPayloadSchema
-      }, dappManifestWallet, finalLocator);
+      const wrapper = new ManifestWrapper2(
+        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema },
+        dappManifestWallet,
+        finalLocator
+      );
       const node = await wrapper.loadNodeFromIndex(0);
       for (const dappNode of dappNodes) {
         await node.register(dappNode);
@@ -1124,7 +1039,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 HDWallet3 } from "@xyo-network/wallet";
 
 // src/registration/ValidateDappAccessDiviner/Config.ts
@@ -1137,23 +1056,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 ModuleFactoryLocator4 } 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 HDWallet2 } 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);
@@ -1195,33 +1111,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) {
@@ -1231,31 +1146,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 HDWallet2.random(), dappParams.locator ?? new ModuleFactoryLocator4());
   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);
@@ -1290,16 +1210,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,
@@ -1314,15 +1245,10 @@ 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) {
@@ -1334,13 +1260,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;
@@ -1352,28 +1271,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 ModuleFactoryLocator5(), developmentMode) {
+  locator;
+  params;
+  constructor(context, params, locator = new ModuleFactoryLocator5(), 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,
@@ -1386,43 +1313,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;
   }
@@ -1430,19 +1351,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 });
       }
     }
   }
@@ -1452,9 +1371,6 @@ var DappRegistrationService = class {
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
 var Signers = class {
-  static {
-    __name(this, "Signers");
-  }
   _paths;
   _signerAccounts;
   _walletStore;
@@ -1506,9 +1422,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
@@ -1543,95 +1456,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 = assertEx8(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) {
@@ -1673,30 +1575,29 @@ import { asArchivistInstance as asArchivistInstance4 } 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 assertEx9(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();
@@ -1705,9 +1606,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) {
@@ -1718,20 +1617,14 @@ var NodeAdapterBase = class extends BaseEmitter4 {
   }
   async getEventsArchivist() {
     const mod = assertEx9(await (await this.kernel.getNode()).resolve("KernelNode:ModuleEvents"), () => "KernelNode:ModuleEvents not found");
-    return asArchivistInstance4(mod, () => `${mod.id} is not an archivist`, {
-      required: true
-    });
+    return asArchivistInstance4(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;
     }
@@ -1740,9 +1633,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);
@@ -1763,9 +1653,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);
@@ -1785,31 +1672,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 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();
@@ -1852,15 +1734,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");
@@ -1878,9 +1758,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");
@@ -1919,9 +1796,6 @@ var OsStackMap = {
 
 // src/XyOs.ts
 var XyOs = class _XyOs extends XyOsContextBase {
-  static {
-    __name(this, "XyOs");
-  }
   _exposedNode;
   _exposedNodeOuter;
   _kernel;
@@ -1929,9 +1803,16 @@ var XyOs = class _XyOs extends XyOsContextBase {
   dappRegistrationService;
   signers;
   stackManager;
-  constructor({ logger = console, eventBus = new EventBus(), kernel = new Kernel({
-    logger
-  }), locator = new ModuleFactoryLocator6(), dappsConfiguration, developmentMode, stackMap = OsStackMap, ...params } = {}) {
+  constructor({
+    logger = console,
+    eventBus = new EventBus(),
+    kernel = new Kernel({ logger }),
+    locator = new ModuleFactoryLocator6(),
+    dappsConfiguration,
+    developmentMode,
+    stackMap = OsStackMap,
+    ...params
+  } = {}) {
     super({
       eventBus,
       kernel,
@@ -1969,19 +1850,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 ModuleFactoryLocator6()) {
@@ -1990,18 +1866,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");
       }
       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();
@@ -2032,32 +1903,26 @@ var XyOs = class _XyOs extends XyOsContextBase {
 
 // src/scripts/xyos/lib/headless.ts
 var { terminal } = tk;
-var terminate = /* @__PURE__ */ __name(() => {
+var terminate = () => {
   terminal.grabInput(false);
   setTimeout(function() {
     process.exit(0);
   }, 100);
-}, "terminate");
-var headless = /* @__PURE__ */ __name(async ({ manifest, config, kernelDrivers } = {}) => {
+};
+var headless = 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: {},
@@ -2066,28 +1931,20 @@ var headless = /* @__PURE__ */ __name(async ({ manifest, config, kernelDrivers }
   });
   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");
+};
 
 // src/scripts/xyos/command/create.ts
-var commandCreate = /* @__PURE__ */ __name((argv) => {
+var commandCreate = (argv) => {
   return argv.command("create [template] <target>", "Create an xyos project", (yargs2) => {
     return yargs2.positional("template", {
-      choices: [
-        "react",
-        "headless",
-        "dapp",
-        "diviner",
-        "witness"
-      ],
+      choices: ["react", "headless", "dapp", "diviner", "witness"],
       description: "Template to use",
       type: "string"
     }).positional("target", {
@@ -2096,22 +1953,15 @@ var commandCreate = /* @__PURE__ */ __name((argv) => {
     });
   }, async ({ template, target }) => {
     console.log(`Using template ${template} at location ${target}`);
-    return await createFromTemplate({
-      target,
-      template
-    });
+    return await createFromTemplate({ target, template });
   });
-}, "commandCreate");
+};
 
 // src/scripts/xyos/command/manifest.ts
-var commandManifest = /* @__PURE__ */ __name((argv) => {
+var commandManifest = (argv) => {
   return argv.command("manifest [action] <target>", "Create an xyos project", (yargs2) => {
     return yargs2.positional("action", {
-      choices: [
-        "create",
-        "validate",
-        "display"
-      ],
+      choices: ["create", "validate", "display"],
       description: "Action to take on manifest",
       type: "string"
     }).positional("target", {
@@ -2122,10 +1972,10 @@ var commandManifest = /* @__PURE__ */ __name((argv) => {
     console.log(`Taking action [${action}] on manifest at ${target}`);
     return await Promise.resolve();
   });
-}, "commandManifest");
+};
 
 // src/scripts/xyos/command/start.ts
-var commandStart = /* @__PURE__ */ __name((argv) => {
+var commandStart = (argv) => {
   return argv.command("start", "Start xyOS in headless mode", (yargs2) => {
     return yargs2.option("config", {
       alias: "c",
@@ -2140,7 +1990,11 @@ var commandStart = /* @__PURE__ */ __name((argv) => {
       description: "Kernel driver to load",
       type: "string"
     });
-  }, async ({ config, manifest, kernelDriver }) => {
+  }, async ({
+    config,
+    manifest,
+    kernelDriver
+  }) => {
     if (config) {
       console.log(`Using config: ${config}`);
     }
@@ -2150,13 +2004,25 @@ var commandStart = /* @__PURE__ */ __name((argv) => {
     await headless({
       manifest,
       config,
-      kernelDrivers: kernelDriver ? [
-        kernelDriver
-      ] : []
+      kernelDrivers: kernelDriver ? [kernelDriver] : []
     });
   });
-}, "commandStart");
+};
 
 // src/scripts/xyos/index.ts
-commandManifest(commandConfig(commandCreate(commandStart(yargs(hideBin(process.argv)))))).usage("Usage: $0 <command> [options]").scriptName("xyos").demandCommand(1).parse().catch(console.error);
+commandManifest(
+  commandConfig(
+    commandCreate(
+      commandStart(
+        yargs(
+          hideBin(
+            process.argv
+          )
+        )
+      )
+    )
+  )
+).usage("Usage: $0 <command> [options]").scriptName("xyos").demandCommand(1).parse().catch(
+  console.error
+);
 //# sourceMappingURL=index.mjs.map