@xyo-network/os-runtime 7.2.0 → 7.2.1

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

@@ -1,12 +1,19 @@
+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 = (argv) => {
+var commandConfig = /* @__PURE__ */ __name((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", {
@@ -17,13 +24,13 @@ var commandConfig = (argv) => {
     console.log(`Taking action [${action}] on manifest at ${target}`);
     return await Promise.resolve();
   });
-};
+}, "commandConfig");
 
 // 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 "fs";
@@ -36,15 +43,17 @@ import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
 import tk from "terminal-kit";
 
 // src/XyOs.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
 import { boot } from "@xyo-network/bios";
 import { Kernel } from "@xyo-network/kernel";
 import { ModuleFactoryLocator as ModuleFactoryLocator6 } from "@xyo-network/module-factory-locator";
 
 // src/event/bus/Connection.ts
-import { assertEx } from "@xylabs/assert";
-import { BaseEmitter } from "@xylabs/events";
+import { assertEx, BaseEmitter } from "@xylabs/sdk-js";
 var EventBusConnection = class extends BaseEmitter {
+  static {
+    __name(this, "EventBusConnection");
+  }
   _id;
   description;
   type;
@@ -62,19 +71,18 @@ var EventBusConnection = class extends BaseEmitter {
 };
 
 // src/event/bus/EventBus.ts
-import { findAs } from "@xylabs/array";
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { forget } from "@xylabs/forget";
+import { assertEx as assertEx2, findAs, forget } from "@xylabs/sdk-js";
 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 { asSchema } from "@xyo-network/payload-model";
 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
@@ -83,11 +91,9 @@ 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();
@@ -116,7 +122,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 = findAs(payloads, asOptionalEventBusEvent);
         if (!eventBusEvent) return;
@@ -126,7 +137,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());
               }
             }
@@ -138,16 +151,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: asSchema("network.xyo.event.bus.event", true)
+        };
         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;
@@ -164,6 +183,9 @@ var EventBus = class {
 
 // src/event/bus/PubSubConnection.ts
 var EventBusPubSubConnection = class extends EventBusConnection {
+  static {
+    __name(this, "EventBusPubSubConnection");
+  }
   publishableEvents;
   subscribableEvents;
   constructor(request) {
@@ -179,61 +201,76 @@ 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/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 = async (xnsNode) => {
+var initializeXns = /* @__PURE__ */ __name(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;
@@ -400,45 +437,44 @@ var os_node_manifest_default = {
 
 // src/loadOsNode.ts
 var OS_NODE_PATH = "1'";
-var getDefaultOsNodeLocator = () => {
+var getDefaultOsNodeLocator = /* @__PURE__ */ __name(() => {
   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;
-};
-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 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 { forget as forget2, fulfilled, rejected } from "@xylabs/sdk-js";
 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";
 import { DappIntentSchema, DappMode } from "@xyo-network/os-model";
 
 // src/DappCallerBase.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { toSafeJsonString } from "@xylabs/object";
+import { assertEx as assertEx3, toSafeJsonString } from "@xylabs/sdk-js";
 import { asArchivistInstance as asArchivistInstance2 } from "@xyo-network/archivist-model";
 import { asDivinerInstance as asDivinerInstance2 } from "@xyo-network/diviner-model";
 var DappArchivistModuleName = "DappArchivist";
@@ -446,62 +482,67 @@ 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 sourceDappId
+  * @param intent
+  * @param targetDappId
+  * @param targetMode
+  * @param params?
+  * @returns DappIntent
+  */
   static buildIntent(sourceDappId, intent, targetDappId, targetMode = DappMode.Window, params) {
     return {
       intent,
@@ -517,7 +558,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() {
@@ -538,7 +581,9 @@ var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
       schema: PayloadDivinerQuerySchema,
       sourceDappId: dappName
     };
-    return await diviner.divine([query]);
+    return await diviner.divine([
+      query
+    ]);
   }
 };
 
@@ -547,7 +592,7 @@ import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder"
 import semver from "semver";
 
 // src/OsCallerBase.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { asArchivistInstance as asArchivistInstance3 } from "@xyo-network/archivist-model";
 import { asDivinerInstance as asDivinerInstance3 } from "@xyo-network/diviner-model";
 var DappsArchivistModuleName = "DappsArchivist";
@@ -556,6 +601,9 @@ var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
 var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
 var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
 var OsCallerBase = class {
+  static {
+    __name(this, "OsCallerBase");
+  }
   context;
   constructor(context) {
     this.context = context;
@@ -563,50 +611,43 @@ 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) {
@@ -614,10 +655,14 @@ 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 = {
@@ -625,9 +670,13 @@ 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) {
@@ -635,10 +684,14 @@ 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) {
@@ -646,10 +699,14 @@ 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);
@@ -661,6 +718,9 @@ var SystemDappQueries = {
 
 // src/system/ManageSystemDapps.ts
 var ManageSystemDapps = class extends OsCallerBase {
+  static {
+    __name(this, "ManageSystemDapps");
+  }
   defaultSystemDappParams;
   defaultSystemDapps;
   defaultSystemNames;
@@ -676,15 +736,15 @@ var ManageSystemDapps = class extends OsCallerBase {
     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
+  */
   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();
@@ -708,9 +768,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) {
@@ -769,6 +833,9 @@ 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();
@@ -788,7 +855,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;
@@ -820,9 +889,13 @@ 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) {
@@ -831,10 +904,14 @@ 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() {
@@ -843,7 +920,7 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
 };
 
 // src/XyOsDapp.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 import { ManifestWrapper as ManifestWrapper2 } from "@xyo-network/manifest-wrapper";
 import { ModuleFactoryLocator as ModuleFactoryLocator3 } from "@xyo-network/module-factory-locator";
 import { DappPackageManifestPayloadSchema } from "@xyo-network/os-model";
@@ -887,11 +964,13 @@ var dapp_window_manifest_default = {
 };
 
 // src/XyOsBase.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
-import { BaseEmitter as BaseEmitter2 } from "@xylabs/events";
+import { assertEx as assertEx5, BaseEmitter as BaseEmitter2 } from "@xylabs/sdk-js";
 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;
@@ -975,10 +1054,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;
@@ -990,12 +1074,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");
   }
@@ -1014,15 +1098,18 @@ 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 manifest = dapp_window_manifest_default;
       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
-      );
+      manifest.nodes[0].config.name = this.dapp.name + "Root";
+      const wrapper = new ManifestWrapper2({
+        ...manifest,
+        schema: DappPackageManifestPayloadSchema
+      }, dappManifestWallet, finalLocator);
       const node = await wrapper.loadNodeFromIndex(0);
       for (const dappNode of dappNodes) {
         await node.register(dappNode);
@@ -1039,37 +1126,36 @@ 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
-import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
-var FailedAccessorSchema = "network.xyo.os.failed.accessor.registration";
+import { asSchema as asSchema2, isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var FailedAccessorSchema = asSchema2("network.xyo.os.failed.accessor.registration", true);
 var isFailedAccessor = isPayloadOfSchemaType(FailedAccessorSchema);
-var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registration.validate";
+var ValidateDappAccessDivinerConfigSchema = asSchema2("network.xyo.os.dapp.access.registration.validate", true);
 
 // src/registration/ValidateDappAccessDiviner/Diviner.ts
 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 configSchemas = [ValidateDappAccessDivinerConfigSchema];
+  static {
+    __name(this, "ValidateDappAccessDiviner");
+  }
+  static configSchemas = [
+    ValidateDappAccessDivinerConfigSchema
+  ];
   async divineHandler(payloads) {
     const dappManifest = payloads?.filter(isDappPackageManifestPayload);
     const accessors = payloads?.filter(isUnregisteredDappAccess);
@@ -1111,32 +1197,33 @@ 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 = (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) {
@@ -1146,36 +1233,30 @@ var getNodeChildren = async (manifestToTest, dappParams) => {
     }
   }
   return children;
-};
-var getNodeToTest = async (manifestToTest, dappParams) => {
+}, "getNodeChildren");
+var getNodeToTest = /* @__PURE__ */ __name(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");
+  }
   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 dapp Manifest and UI of the Dapp to register
+  * @returns 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);
@@ -1210,27 +1291,15 @@ 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,
@@ -1245,10 +1314,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) {
@@ -1260,6 +1334,9 @@ var DappRegistry = class {
 
 // src/registration/DappRegistrationService.ts
 var DappRegistrationService = class {
+  static {
+    __name(this, "DappRegistrationService");
+  }
   // Dapps that have been built with their own context
   builtDapps = {};
   dappRegistry;
@@ -1286,21 +1363,17 @@ var DappRegistrationService = class {
     };
     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,
@@ -1313,37 +1386,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;
   }
@@ -1351,26 +1430,31 @@ 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
+        });
       }
     }
   }
 };
 
 // src/signer/Signers.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
 var Signers = class {
+  static {
+    __name(this, "Signers");
+  }
   _paths;
   _signerAccounts;
   _walletStore;
@@ -1416,12 +1500,13 @@ var Signers = class {
 };
 
 // src/stack/Base.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
-import { BaseEmitter as BaseEmitter3 } from "@xylabs/events";
-import { forget as forget3 } from "@xylabs/forget";
+import { assertEx as assertEx8, BaseEmitter as BaseEmitter3, forget as forget3 } from "@xylabs/sdk-js";
 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
@@ -1438,7 +1523,7 @@ var StackBase = class extends BaseEmitter3 {
   constructor(context, adapterSet, stackNodeModuleId) {
     super({});
     this._context = context;
-    this._adapterSet = adapterSet(assertEx8(this.context.kernel, "Kernel access required"));
+    this._adapterSet = adapterSet(assertEx8(this.context.kernel, () => "Kernel access required"));
     this._stackNodeModuleId = stackNodeModuleId;
   }
   get adapterSet() {
@@ -1456,84 +1541,95 @@ 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() {
     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) {
@@ -1568,13 +1664,15 @@ var StackManager = class {
 import { ExposedNodeOuterNodeName, PubSubBridgeNodeNodeName } from "@xyo-network/os-model";
 
 // src/adapter/Base.ts
-import { assertEx as assertEx9 } from "@xylabs/assert";
-import { BaseEmitter as BaseEmitter4 } from "@xylabs/events";
-import { forget as forget4 } from "@xylabs/forget";
+import { assertEx as assertEx9, BaseEmitter as BaseEmitter4, forget as forget4 } from "@xylabs/sdk-js";
 import { asArchivistInstance as asArchivistInstance4 } from "@xyo-network/archivist";
 import { asAttachableNodeInstance as asAttachableNodeInstance2 } from "@xyo-network/node-model";
+import { asSchema as asSchema3 } from "@xyo-network/payload-model";
 import { v4 as uuid3 } from "uuid";
 var NodeAdapterBase = class extends BaseEmitter4 {
+  static {
+    __name(this, "NodeAdapterBase");
+  }
   initialized = false;
   _id = "";
   driverName;
@@ -1590,14 +1688,14 @@ var NodeAdapterBase = class extends BaseEmitter4 {
   }
   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();
@@ -1606,25 +1704,33 @@ 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) {
     return payloads.filter((payload) => {
       const payloadToTest = payload;
-      return payloadToTest.event === "driverReady" && payloadToTest.schema === "network.xyo.kernel.module.event";
+      return payloadToTest.event === "driverReady" && payloadToTest.schema === asSchema3("network.xyo.kernel.module.event", true);
     });
   }
   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 = async () => await this.emit("driverReady", { node });
+      const emit = /* @__PURE__ */ __name(async () => await this.emit("driverReady", {
+        node
+      }), "emit");
       forget4(emit());
       return node;
     }
@@ -1633,6 +1739,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);
@@ -1653,6 +1762,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);
@@ -1672,26 +1784,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 { assertEx as assertEx10 } from "@xylabs/sdk-js";
 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();
@@ -1734,13 +1851,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");
@@ -1758,6 +1877,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");
@@ -1796,6 +1918,9 @@ var OsStackMap = {
 
 // src/XyOs.ts
 var XyOs = class _XyOs extends XyOsContextBase {
+  static {
+    __name(this, "XyOs");
+  }
   _exposedNode;
   _exposedNodeOuter;
   _kernel;
@@ -1803,16 +1928,9 @@ 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,
@@ -1850,14 +1968,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 ModuleFactoryLocator6()) {
@@ -1866,13 +1989,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();
@@ -1903,26 +2031,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: {},
@@ -1931,20 +2065,28 @@ 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");
 
 // src/scripts/xyos/command/create.ts
-var commandCreate = (argv) => {
+var commandCreate = /* @__PURE__ */ __name((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", {
@@ -1953,15 +2095,22 @@ var commandCreate = (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 = (argv) => {
+var commandManifest = /* @__PURE__ */ __name((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", {
@@ -1972,10 +2121,10 @@ var commandManifest = (argv) => {
     console.log(`Taking action [${action}] on manifest at ${target}`);
     return await Promise.resolve();
   });
-};
+}, "commandManifest");
 
 // src/scripts/xyos/command/start.ts
-var commandStart = (argv) => {
+var commandStart = /* @__PURE__ */ __name((argv) => {
   return argv.command("start", "Start xyOS in headless mode", (yargs2) => {
     return yargs2.option("config", {
       alias: "c",
@@ -1990,11 +2139,7 @@ var commandStart = (argv) => {
       description: "Kernel driver to load",
       type: "string"
     });
-  }, async ({
-    config,
-    manifest,
-    kernelDriver
-  }) => {
+  }, async ({ config, manifest, kernelDriver }) => {
     if (config) {
       console.log(`Using config: ${config}`);
     }
@@ -2004,25 +2149,13 @@ var commandStart = (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