@xyo-network/os-runtime 3.0.14 → 3.0.16

package/dist/neutral/index.mjs

@@ -1,5 +1,5 @@
 // src/access-interfaces/registered-names/helpers/AccessNodeQueries.ts
-import { assertEx as assertEx26 } from "@xylabs/assert";
+import { assertEx as assertEx25 } from "@xylabs/assert";
 import { asArchivistInstance as asArchivistInstance7 } from "@xyo-network/archivist-model";
 
 // src/classes/cache/RunningAccessDappCache.ts
@@ -17,11 +17,11 @@ var RunningDappAccessCache = class {
 };
 
 // src/classes/cache/RunningDappCache.ts
-import { assertEx as assertEx25 } from "@xylabs/assert";
+import { assertEx as assertEx24 } from "@xylabs/assert";
 import { Mutex as Mutex3 } from "async-mutex";
 
 // src/XyOs.ts
-import { assertEx as assertEx24 } from "@xylabs/assert";
+import { assertEx as assertEx23 } from "@xylabs/assert";
 import { boot } from "@xyo-network/bios";
 import { Kernel } from "@xyo-network/kernel";
 import { ModuleFactoryLocator as ModuleFactoryLocator7 } from "@xyo-network/module-factory-locator";
@@ -524,15 +524,13 @@ import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder"
 
 // src/Caller.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
-import { Account } from "@xyo-network/account";
 import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema4 } from "@xyo-network/diviner-payload-model";
 import {
   DappAccessRequestSchema as DappAccessRequestSchema2,
   DappInjectableParamsSchema as DappInjectableParamsSchema2,
   DappIntentTypes,
   DappMode as DappMode2,
-  RegisteredDappAccessSchema as RegisteredDappAccessSchema2,
-  SigningKeySchema
+  RegisteredDappAccessSchema as RegisteredDappAccessSchema2
 } from "@xyo-network/os-model";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 
@@ -723,25 +721,9 @@ var DappCaller = class extends DappCallerBase {
   /**
    * Get the user wallet
    */
-  async getUserAccount(dappName, useSigners) {
-    const diviner = await this.getDappArchivistPayloadDiviner();
-    const query = {
-      dappName,
-      limit: 1,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema4,
-      schemas: [SigningKeySchema]
-    };
-    const [payload] = assertEx8(await diviner.divine([query]), () => "Unable to find user wallet");
-    if (payload) {
-      console.log("*** old implementation address", await Account.fromPrivateKey(payload.privateKey));
-      if (!useSigners) return await Account.fromPrivateKey(payload.privateKey);
-    } else {
-      throw new Error("Unable to find user wallet");
-    }
-    const account = this.context.user.signers?.get("Name Service");
+  getUserAccount(dappName) {
+    const account = this.context.user.signers?.get(dappName);
     if (account) {
-      console.log("*** new implementation address", account);
       return account;
     } else {
       throw new Error("Unable to find user wallet");
@@ -750,19 +732,8 @@ var DappCaller = class extends DappCallerBase {
   /**
    * Get all wallets for the user
    */
-  async getUserAccountsAll() {
-    const diviner = await this.getDappArchivistPayloadDiviner();
-    const query = {
-      order: "desc",
-      schema: PayloadDivinerQuerySchema4,
-      schemas: [SigningKeySchema]
-    };
-    const payloads = assertEx8(await diviner.divine([query]), () => "Unable to find user wallet");
-    if (payloads?.length) {
-      return payloads;
-    } else {
-      throw new Error("Unable to find user wallet");
-    }
+  getUserAccountsAll() {
+    return [...this.context.user.signers?.values() ?? []];
   }
   /**
    * Make Dapp Access Request
@@ -1007,7 +978,7 @@ var DappMenuResource = class extends DappCaller {
 };
 
 // src/classes/node/createDappContext.ts
-import { HDWallet as HDWallet3 } from "@xyo-network/account";
+import { HDWallet as HDWallet2 } from "@xyo-network/account";
 import { GenericPayloadDiviner } from "@xyo-network/diviner-payload-generic";
 import { ModuleFactoryLocator as ModuleFactoryLocator2 } from "@xyo-network/module-factory-locator";
 
@@ -1090,8 +1061,8 @@ var DappSeedPhraseRepository = class extends OsCallerBase {
 };
 
 // src/classes/node/Creator.ts
-import { assertEx as assertEx15 } from "@xylabs/assert";
-import { asArchivistInstance as asArchivistInstance4 } from "@xyo-network/archivist-model";
+import { assertEx as assertEx10 } from "@xylabs/assert";
+import { asArchivistInstance as asArchivistInstance3 } from "@xyo-network/archivist-model";
 import { PackageManifestPayloadSchema } from "@xyo-network/manifest";
 
 // src/manifest/ManifestReplaceableTokens.ts
@@ -1240,7 +1211,7 @@ var os_node_manifest_default = {
 };
 
 // src/classes/node/DefaultPayloads/DefaultPayloads.ts
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 
 // src/classes/node/DefaultPayloads/DappAccessPayloads.ts
 var DappAccessPayloads = class {
@@ -1276,917 +1247,559 @@ var NodeInfoPayload = class {
   }
 };
 
-// src/classes/node/DefaultPayloads/SigningKeyPayloads.ts
-import { assertEx as assertEx14 } from "@xylabs/assert";
-import { hexFrom } from "@xylabs/hex";
-import { HDWallet as HDWallet2 } from "@xyo-network/account";
-import { mnemonicArrayToString, SigningKeySchema as SigningKeySchema2 } from "@xyo-network/os-model";
-import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
-
-// src/classes/settings/badge/Caller.ts
-import { OsBadgeSchema as OsBadgeSchema2 } from "@xyo-network/os-model";
+// src/classes/node/DefaultPayloads/DefaultPayloads.ts
+var DefaultPayloads = class {
+  constructor(dappArchivist, xyOs, dappName) {
+    this.dappArchivist = dappArchivist;
+    this.xyOs = xyOs;
+    this.dappName = dappName;
+  }
+  async insert() {
+    const insertables = [NodeInfoPayload, DappAccessPayloads];
+    const insertPayloads = [];
+    for (const insertable of insertables) {
+      const classInstance = createInsertable(insertable, this.xyOs, this.dappName);
+      const payloads = await classInstance.payloads();
+      insertPayloads.push(...payloads);
+    }
+    for (const payload of insertPayloads) {
+      const [existing] = await this.dappArchivist.get([await PayloadBuilder4.dataHash(payload)]);
+      if (existing) continue;
+      await this.dappArchivist.insert([payload]);
+    }
+  }
+};
 
-// src/classes/settings/CallerBase.ts
-import { assertEx as assertEx10 } from "@xylabs/assert";
-import { asArchivistInstance as asArchivistInstance3 } from "@xyo-network/archivist-model";
-import { asDivinerInstance as asDivinerInstance4 } from "@xyo-network/diviner-model";
-var OsSettingsArchivistModuleName = "OsSettingsNode:OsSettingsArchivist";
-var OsSettingsArchivistPayloadDivinerModuleName = "OsSettingsNode:OsSettingsArchivistPayloadDiviner";
-var OsSettingsCallerBase = class {
-  constructor(context) {
+// src/classes/node/ExternalModulePermissions/ExternalModulePermissions.ts
+var ALLOWED_MODULES_FROM_PARENT = ["IntentArchivist", "OsSettingsNode", "OsPubSubNetworkStackNode", "OsXyoPublicNetworkStackNode"];
+var ExternalModulePermissions = class {
+  constructor(context, dappWindowNode, dappName, externalPermissions) {
     this.context = context;
+    this.dappWindowNode = dappWindowNode;
+    this.dappName = dappName;
+    this.externalPermissions = externalPermissions;
   }
-  async getOsSettingsArchivist() {
-    const mod = assertEx10(await this.context.root.resolve(OsSettingsArchivistModuleName), () => `${OsSettingsArchivistModuleName} not found`);
-    return asArchivistInstance3(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`);
+  async permit() {
+    for (const permission of this.externalPermissions ?? []) {
+      await this.permitExternalModule(permission);
+    }
   }
-  async getOsSettingsPayloadDiviner() {
-    const mod = assertEx10(
-      await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName),
-      () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`
-    );
-    return asDivinerInstance4(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`);
+  getExternalModuleName(permission) {
+    return permission.name;
   }
-};
-
-// src/classes/settings/badge/Queries.ts
-import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema8 } from "@xyo-network/diviner-payload-model";
-import { OsBadgeSchema } from "@xyo-network/os-model";
-var OsBadgeQueries = {
-  getBadge: async (achievement, diviner) => {
-    const query = {
-      achievement,
-      limit: 1,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema8,
-      schemas: [OsBadgeSchema]
-    };
-    return await diviner.divine([query]);
+  async permitExternalModule(externalPermission) {
+    const externalModuleName = this.getExternalModuleName(externalPermission);
+    if (ALLOWED_MODULES_FROM_PARENT.includes(externalModuleName)) {
+      const mod = await this.resolveExternalModule(externalModuleName);
+      await this.registerAndAttachModule(mod);
+    } else {
+      console.warn(`${this.dappName} requested ${externalModuleName} but it was not fulfilled`);
+    }
   }
-};
-
-// src/classes/settings/badge/Caller.ts
-var OsBadgeCaller = class extends OsSettingsCallerBase {
-  /**
-   * @param  {ValidOsAchievements} achievement
-   */
-  async getBadge(achievement) {
-    const diviner = await this.getOsSettingsPayloadDiviner();
-    const results = await OsBadgeQueries.getBadge(achievement, diviner);
-    return results[0] ?? null;
+  async registerAndAttachModule(mod) {
+    if (mod) {
+      await this.dappWindowNode.register?.(mod);
+      await this.dappWindowNode.attach(mod.address, true);
+    }
   }
-  /**
-   * @param  {ValidOsAchievements} achievement
-   */
-  async saveBadge(achievement) {
-    const badge = {
-      achievement,
-      schema: OsBadgeSchema2,
-      timestamp: Date.now()
-    };
-    const archivist = await this.getOsSettingsArchivist();
-    return await archivist.insert([badge]);
+  async resolveExternalModule(id) {
+    return await this.context.root.resolve(id);
   }
 };
 
-// src/classes/settings/badge/Resource.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
-import { isBadgeWithMeta } from "@xyo-network/os-model";
-var OsBadgeResource = class extends OsSettingsCallerBase {
-  static views = ["savedSeedPhrase"];
-  _savedSeedPhrase;
-  constructor(xyOsContext) {
-    super(xyOsContext);
+// src/classes/node/Creator.ts
+var DappContextCreator = class _DappContextCreator {
+  constructor(targetDappManifestParams, dappId, context, rootWallet, externalPermissions, sharedLocator) {
+    this.targetDappManifestParams = targetDappManifestParams;
+    this.dappId = dappId;
+    this.context = context;
+    this.rootWallet = rootWallet;
+    this.externalPermissions = externalPermissions;
+    this.sharedLocator = sharedLocator;
   }
-  get savedSeedPhrase() {
-    return assertEx11(this._savedSeedPhrase, () => "Saved seed phrase listener not set");
+  // Designated offset path for the wallet used by windowed dapps. In the future, other offsets could be used for other dapp modes
+  static DAPP_WINDOW_WALLET_PATH = "1";
+  static async create(params, xnsNodeUrl, xnsNetwork) {
+    const {
+      config,
+      locator,
+      context,
+      wallet
+    } = params;
+    const {
+      payload,
+      dappName,
+      publicChildren,
+      privateChildren
+    } = config;
+    const { external, manifestPayload } = this.parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork);
+    console.debug("[DEBUG] dApp manifest", manifestPayload);
+    const dappWallet = await wallet.derivePath(_DappContextCreator.DAPP_WINDOW_WALLET_PATH);
+    const targetDappManifestParams = [manifestPayload, dappWallet, locator, publicChildren, privateChildren];
+    const instance = new this(targetDappManifestParams, dappName, context, wallet, external?.modules, locator);
+    return instance;
   }
-  get subscriptions() {
-    return { savedSeedPhrase: (cb) => this.savedSeedPhrase.subscribe(cb) };
+  // Add default payloads to the archivist shared between the os and the dapp
+  static async primeDappArchivist(dappContext, osContext, dappName) {
+    const dappCaller = new DappCallerBase(dappContext);
+    const dappArchivist = await dappCaller.getDappArchivist();
+    const defaultPayloads = new DefaultPayloads(dappArchivist, osContext, dappName);
+    await defaultPayloads.insert();
   }
-  get views() {
-    return { savedSeedPhrase: () => this.savedSeedPhrase.latest };
+  // Reset the dapp archivist to remove all payloads
+  static async resetDappArchivist(context) {
+    const dappModule = await context.root.resolve("DappArchivist");
+    const dappArchivist = assertEx10(asArchivistInstance3(dappModule), () => "resetDappArchivist: DappArchivist not found");
+    await dappArchivist.clear();
   }
-  cleanupListeners() {
-    this.savedSeedPhrase.cleanupListeners();
+  static parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork) {
+    const { external, ...manifestWithoutExternals } = payload;
+    const manifestPayloadRaw = {
+      ...manifestWithoutExternals,
+      schema: PackageManifestPayloadSchema
+    };
+    const manifestPayload = ReplaceManifestTokens(manifestPayloadRaw, xnsNodeUrl, xnsNetwork);
+    return { external, manifestPayload };
   }
-  /**
-   * start listeners
-   **/
-  async start() {
-    const diviner = await this.getOsSettingsPayloadDiviner();
-    const archivist = await this.getOsSettingsArchivist();
-    this._savedSeedPhrase = await PayloadStore.create({
-      archivist,
-      getLatest: async () => await OsBadgeQueries.getBadge("savedSeedPhrase", diviner),
-      idFunction: isBadgeWithMeta
-    });
+  async loadDappContext(context) {
+    console.log("DappNodesCreator:loadDappContext", this.dappId);
+    const dapp = await context.dappByName(this.dappId) ?? await (async () => {
+      const dapp2 = await context.buildDapp(this.targetDappManifestParams[0], this.dappId);
+      await dapp2.boot(this.rootWallet, this.sharedLocator);
+      return dapp2;
+    })();
+    await this.handleExternalModulePermissions(dapp.root);
+    await _DappContextCreator.primeDappArchivist(dapp, this.context, this.dappId);
+    return dapp;
+  }
+  // try to satisfy the external permissions requested by a dapp
+  async handleExternalModulePermissions(dappWindowNode) {
+    const externalModulePermissions = new ExternalModulePermissions(this.context, dappWindowNode, this.dappId, this.externalPermissions);
+    await externalModulePermissions.permit();
   }
 };
 
-// src/classes/settings/Caller.ts
-import { assertEx as assertEx12 } from "@xylabs/assert";
-import { isEqual } from "@xylabs/lodash";
-
-// src/utils/buildWalletSeedPhrasePayload.ts
-import { WalletSeedPhraseSchema } from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-var language = "english";
-var standard = "bip-39";
-var userWalletLabel = "userWallet";
-var buildWalletSeedPhrasePayload = async (mnemonic, label) => {
-  const fields = {
-    mnemonic: {
-      language,
-      mnemonic: mnemonic.split(" "),
-      standard
-    }
-  };
-  const meta = { label, timestamp: Date.now() };
-  const builder = new PayloadBuilder4({
-    fields,
-    meta,
-    schema: WalletSeedPhraseSchema
-  });
-  const payload = await builder.build();
-  const rootHash = await PayloadBuilder4.hash(payload);
-  return { payload, rootHash };
+// src/classes/node/createDappContext.ts
+var GenericPayloadDivinerTags = { "network.xyo.generic.payload.diviner": "GenericPayloadDiviner" };
+var resolveLocator = (existingLocator) => {
+  const locator = existingLocator ?? new ModuleFactoryLocator2();
+  locator.register(GenericPayloadDiviner, GenericPayloadDivinerTags);
+  return locator;
 };
-var buildUserWalletSeedPhrasePayload = (mnemonic) => {
-  return buildWalletSeedPhrasePayload(mnemonic, userWalletLabel);
+var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwork) => {
+  console.log("createNodes");
+  try {
+    const dappSeedPhraseRepository = new DappSeedPhraseRepository(context, allowedNames);
+    const seedPhrase = await dappSeedPhraseRepository.request(dapp.config.walletId);
+    if (!seedPhrase) {
+      throw new Error(`unable to find seed phrase for walletId: ${JSON.stringify(dapp.config, null, 2)}`);
+    }
+    const wallet = await HDWallet2.fromPhrase(seedPhrase);
+    const dappName = dapp.config.name;
+    const { config: dappConfig, params: dappParams } = dapp;
+    const locator = resolveLocator((dappParams.locator ?? new ModuleFactoryLocator2()).merge(context.platformLocator));
+    const params = {
+      config: { dappName, payload: dappConfig.manifest },
+      context,
+      locator,
+      wallet
+    };
+    const dappContextCreator = await DappContextCreator.create(params, xnsNodeUrl, xnsNetwork);
+    const dappContext = await dappContextCreator.loadDappContext(context);
+    return {
+      context: dappContext,
+      dappWallet: wallet
+    };
+  } catch (e) {
+    const error = e;
+    console.error(`Error creating dappWindow node: ${error.message}`);
+    console.error(`Error creating dappWindow node: ${error.stack}`);
+    throw new Error(`Error creating dappWindow node: ${error.message}`);
+  }
 };
 
-// src/utils/getApiDomain.ts
-var getApiDomain = (scope, apiDomain) => {
-  if (apiDomain !== void 0) {
-    return apiDomain;
+// src/classes/registration/DappRegistrationService.ts
+import { forget as forget2 } from "@xylabs/forget";
+import { fulfilled, rejected } from "@xylabs/promise";
+import { ModuleFactoryLocator as ModuleFactoryLocator5 } from "@xyo-network/module-factory-locator";
+import {
+  DappIntentTypes as DappIntentTypes2,
+  DappMode as DappMode3,
+  isRegisteredDappAccessDappSet as isRegisteredDappAccessDappSet2,
+  isRegisteredDappExposedDappSet
+} from "@xyo-network/os-model";
+
+// src/event/bus/Connection.ts
+import { assertEx as assertEx11 } from "@xylabs/assert";
+import { BaseEmitter } from "@xyo-network/module-abstract";
+var EventBusConnection = class extends BaseEmitter {
+  _id;
+  description;
+  type;
+  constructor(request) {
+    super({});
+    this.description = request.description;
+    this.type = request.type;
   }
-  if (scope === "localhost") {
-    return "http://localhost:8080";
+  get id() {
+    return assertEx11(this._id, () => "Connection ID not set.  Did you forget to call buildConnection()?");
   }
-  if (scope === "beta") {
-    return "https://beta.archivist.xyo.network";
+  buildConnection(id) {
+    this._id = id;
   }
-  return "https://archivist.xyo.network";
 };
 
-// src/utils/renameObjKey.ts
-var renameObjKey = (oldObj, oldKey, newKey) => {
-  const oldObjKeys = Object.keys(oldObj);
-  const newObj = oldObjKeys.reduce(
-    (acc, val) => {
-      if (val === oldKey) {
-        acc[newKey] = oldObj[oldKey];
-      } else {
-        acc[val] = oldObj[val];
-      }
-      return acc;
-    },
-    {}
-  );
-  return newObj;
-};
-
-// src/classes/settings/SettingsQueries.ts
-import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema9 } from "@xyo-network/diviner-payload-model";
-import { NodeBackgroundSchema, WalletSeedPhraseSchema as WalletSeedPhraseSchema2 } from "@xyo-network/os-model";
-var NO_RESULTS2 = [];
-var OsSettingsQueries = {
-  async getLatestUserWallet(diviner) {
-    const query = {
-      limit: 1,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema9,
-      schemas: [WalletSeedPhraseSchema2]
-    };
-    const results = await diviner.divine([query]);
-    const wallet = results.find((payload) => payload.$meta.label === "userWallet");
-    return wallet ? [wallet] : NO_RESULTS2;
-  },
-  async getNodeBackground(diviner) {
-    const query = {
-      limit: 1,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema9,
-      schemas: [NodeBackgroundSchema]
-    };
-    return await diviner.divine([query]);
-  },
-  async getWallets(diviner) {
-    const query = {
-      order: "desc",
-      schema: PayloadDivinerQuerySchema9,
-      schemas: [WalletSeedPhraseSchema2]
-    };
-    return await diviner.divine([query]);
+// src/event/bus/EventBus.ts
+import { assertEx as assertEx12 } from "@xylabs/assert";
+import { forget } from "@xylabs/forget";
+import {
+  asArchivistInstance as asArchivistInstance4,
+  MemoryArchivist,
+  MemoryArchivistConfigSchema
+} from "@xyo-network/archivist";
+import {
+  isEventBusEvent,
+  isPubSubConnections
+} from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { Mutex } from "async-mutex";
+import { v4 as uuid2 } from "uuid";
+var EventBus = class {
+  // Internal Archivist to store event data
+  _archivist;
+  // Store all connections
+  connections = {};
+  // Store all publisher callbacks for later removal
+  publisherCallbacks = {};
+  startMutex = new Mutex();
+  get archivist() {
+    return asArchivistInstance4(
+      assertEx12(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
+      "not a valid archivist instance"
+    );
   }
-};
-
-// src/classes/settings/Caller.ts
-var OsSettingsCaller = class extends OsSettingsCallerBase {
-  constructor(context) {
-    super(context);
+  addConnection(connection) {
+    const id = uuid2();
+    this.connections[id] = connection;
+    connection.buildConnection(id);
+    if (isPubSubConnections(connection)) {
+      this.handlePublisherAdd(connection);
+    } else {
+      throw new Error("Unsupported connection type. Must be PubSub");
+    }
+    return connection;
   }
-  /**
-   * Add a node background to the settings
-   * @param  {WithMeta<NodeBackground>} payload
-   */
-  async addNodeBackground(payload) {
-    const archivist = await this.getOsSettingsArchivist();
-    await archivist.insert([payload]);
+  removeConnection(connectionId) {
+    const connection = this.connections[connectionId];
+    if (!connection) {
+      throw new Error("Connection not found " + connectionId);
+    }
+    if (connection && isPubSubConnections(connection)) {
+      this.handlePublisherRemove(connection);
+    }
+    delete this.connections[connectionId];
   }
-  /**
-   * Add a wallet seed phrase to the settings
-   * @param  {WalletSeedPhrase} payload
-   */
-  async addWalletSeedPhrase(payload) {
-    const archivist = await this.getOsSettingsArchivist();
-    await archivist.insert([payload]);
-    const phrase = payload.mnemonic.mnemonic.join(" ");
-    await this.context.kernel?.bios?.seedPhraseStore.set("user", phrase);
+  async start(storeName = "EventBusArchivist") {
+    return await this.startMutex.runExclusive(async () => {
+      if (this._archivist) {
+        console.warn("EventBus already started");
+        return this;
+      }
+      this._archivist = await MemoryArchivist.create({ config: { name: storeName, schema: MemoryArchivistConfigSchema } });
+      this.archivist.on("inserted", ({ payloads }) => {
+        const eventBusEvent = payloads.find(isEventBusEvent);
+        if (!eventBusEvent) return;
+        for (const connectionId in this.connections) {
+          const connection = this.connections[connectionId];
+          if (isPubSubConnections(connection) && connection.subscribableEvents) {
+            for (const [eventName, callback] of connection.subscribableEvents.entries()) {
+              if (eventName !== eventBusEvent.name) continue;
+              if (callback) {
+                const forgettable = async () => await callback({ payloads });
+                forget(forgettable());
+              }
+            }
+          }
+        }
+      });
+      return this;
+    });
   }
-  /**
-   * Get the latest node background
-   */
-  async getLatestNodeBackground() {
-    const diviner = await this.getOsSettingsPayloadDiviner();
-    const [result] = await OsSettingsQueries.getNodeBackground(diviner);
-    return result ?? null;
+  handlePublisherAdd(connection) {
+    for (const eventName of connection.publishableEvents ?? []) {
+      const connectionPublisherCallback = async ({ payloads }) => {
+        const event = { name: eventName, schema: "network.xyo.event.bus.event" };
+        const eventPayloads = payloads ?? [];
+        event.sources = await PayloadBuilder5.dataHashes(eventPayloads);
+        try {
+          await this.archivist.insert([event, ...payloads ?? []]);
+        } catch (e) {
+          console.error("Error inserting event into archivist", e);
+        }
+      };
+      connection.on(eventName, connectionPublisherCallback);
+      const callbackId = connection.id + eventName;
+      this.publisherCallbacks[callbackId] = connectionPublisherCallback;
+    }
   }
-  async getLatestUserWallet() {
-    const diviner = await this.getOsSettingsPayloadDiviner();
-    const storedSeedPhrasePayload = (await OsSettingsQueries.getLatestUserWallet(diviner)).pop();
-    const biosWalletSeedPhrase = assertEx12(await this.context.kernel?.bios?.seedPhraseStore.get("user"), () => "No user seed phrase found from BIOS");
-    const biosWalletSeedPhraseParts = biosWalletSeedPhrase.split(" ");
-    if (!storedSeedPhrasePayload?.mnemonic?.mnemonic) {
-      const { payload: biosSeedPhrasePayload } = await buildUserWalletSeedPhrasePayload(biosWalletSeedPhrase);
-      await this.addWalletSeedPhrase(biosSeedPhrasePayload);
-      return biosSeedPhrasePayload;
-    } else if (!isEqual(storedSeedPhrasePayload.mnemonic.mnemonic, biosWalletSeedPhraseParts)) {
-      const updatedBiosSeedPhrase = storedSeedPhrasePayload.mnemonic.mnemonic.join(" ");
-      await this.context.kernel?.bios?.seedPhraseStore.set("user", updatedBiosSeedPhrase);
+  handlePublisherRemove(connection) {
+    for (const [, event] of connection.publishableEvents?.entries() ?? []) {
+      const id = connection.id + event;
+      const callback = this.publisherCallbacks[id];
+      if (callback) connection.off(event, callback);
     }
-    return storedSeedPhrasePayload;
   }
 };
 
-// src/classes/settings/Resource.ts
-import { assertEx as assertEx13 } from "@xylabs/assert";
-import { isNodeBackground, isWalletSeedPhrase } from "@xyo-network/os-model";
-var OsSettingsResource = class extends OsSettingsCallerBase {
-  _latestUserWalletListener;
-  _nodeBackgroundListener;
-  _walletsListener;
-  constructor(context) {
-    super(context);
-  }
-  get latestUserWalletListener() {
-    return assertEx13(this._latestUserWalletListener, () => "Latest user wallet listener not set");
-  }
-  get nodeBackgroundListener() {
-    return assertEx13(this._nodeBackgroundListener, () => "Node background listener not set");
+// src/event/bus/PubSubConnection.ts
+var EventBusPubSubConnection = class extends EventBusConnection {
+  publishableEvents;
+  subscribableEvents;
+  constructor(request) {
+    super(request);
+    if (request.type !== "PubSub") {
+      throw new Error("Invalid connection type. Must be PubSub");
+    }
+    this.publishableEvents = request.publishableEvents;
+    this.subscribableEvents = request.subscribableEvents;
   }
-  get subscriptions() {
-    return {
-      latestUserWallet: (cb) => this.walletsListener.subscribe(cb),
-      nodeBackground: (cb) => this.nodeBackgroundListener.subscribe(cb),
-      wallets: (cb) => this.walletsListener.subscribe(cb)
-    };
+};
+
+// src/event/connections/DappAccessRequest.ts
+var DappAccessRequestEvent = "dappAccessRequest";
+var dappAccessRequestConnectionRequest = {
+  publishableEvents: [DappAccessRequestEvent],
+  type: "PubSub"
+};
+var dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest);
+
+// src/event/connections/DappsReady.ts
+var dappsReadyConnectionRequest = {
+  publishableEvents: ["dappsReady"],
+  type: "PubSub"
+};
+var dappsReadyConnection = () => new EventBusPubSubConnection(dappsReadyConnectionRequest);
+
+// src/event/connections/ExposeDappRequest.ts
+var ExposeDappRequestEvent = "exposeDappRequest";
+var exposeDappConnectionRequest = {
+  publishableEvents: [ExposeDappRequestEvent],
+  type: "PubSub"
+};
+var exposeDappRequestConnection = () => new EventBusPubSubConnection(exposeDappConnectionRequest);
+
+// src/event/connections/OsPubSubNetworkReady.ts
+var OsPubSubNetworkReadyEvent = "osPubSubNetworkReady";
+var osPubSubNetworkConnectionRequest = {
+  publishableEvents: [OsPubSubNetworkReadyEvent],
+  type: "PubSub"
+};
+var osPubSubNetworkReadyConnection = () => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest);
+
+// src/event/connections/OsSettingsReady.ts
+var OsSettingsReadyEvent = "osSettingsReady";
+var osSettingsConnectionRequest = {
+  publishableEvents: [OsSettingsReadyEvent],
+  type: "PubSub"
+};
+var osSettingsReadyConnection = () => new EventBusPubSubConnection(osSettingsConnectionRequest);
+
+// src/event/connections/OsXyoPublicReady.ts
+var OsXyoPublicNetworkReadyEvent = "osXyoPublicNetworkReady";
+var osXyoPublicNetworkConnectionRequest = {
+  publishableEvents: [OsXyoPublicNetworkReadyEvent],
+  type: "PubSub"
+};
+var osXyoPublicNetworkReadyConnection = () => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest);
+
+// src/XyOsDapp.ts
+import { assertEx as assertEx14 } from "@xylabs/assert";
+import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
+import { ModuleFactoryLocator as ModuleFactoryLocator4 } from "@xyo-network/module-factory-locator";
+import { DappPackageManifestPayloadSchema } from "@xyo-network/os-model";
+
+// src/manifests/dapp-window.manifest.json
+var dapp_window_manifest_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/compilations/dapp-package-manifest-schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "0'",
+        name: "Dapp",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: [
+          {
+            config: {
+              accountPath: "0'/0'",
+              name: "DappArchivist",
+              schema: "network.xyo.archivist.memory.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "0'/1'",
+              archivist: "DappArchivist",
+              labels: {
+                "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
+              },
+              name: "DappArchivistPayloadDiviner",
+              schema: "network.xyo.diviner.payload.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest.package.dapp"
+};
+
+// src/XyOsBase.ts
+import { assertEx as assertEx13 } from "@xylabs/assert";
+import { BaseEmitter as BaseEmitter2 } from "@xyo-network/module-abstract";
+import { ModuleFactoryLocator as ModuleFactoryLocator3 } from "@xyo-network/module-factory-locator";
+import { Mutex as Mutex2 } from "async-mutex";
+var XyOsContextBase = class extends BaseEmitter2 {
+  _bootMutex = new Mutex2();
+  _platformLocator;
+  _root;
+  get bios() {
+    return this.kernel?.bios;
   }
-  get views() {
-    return {
-      latestUserWallet: () => this.latestUserWalletListener.latest,
-      nodeBackground: () => this.nodeBackgroundListener.latest,
-      wallets: () => this.walletsListener.latest
-    };
+  get eventBus() {
+    return assertEx13(this.params.eventBus, () => "Missing event bus");
   }
-  get walletsListener() {
-    return assertEx13(this._walletsListener, () => "Wallets listener not set");
+  get exposedNode() {
+    throw new Error("Method not implemented. [exposedNode]");
   }
-  cleanupListeners() {
-    this.walletsListener.cleanupListeners();
-    this.latestUserWalletListener.cleanupListeners();
+  get exposedNodeOuter() {
+    throw new Error("Method not implemented. [exposedNodeOuter]");
   }
-  /**
-   * start listeners
-   */
-  async start() {
-    const archivist = await this.getOsSettingsArchivist();
-    const diviner = await this.getOsSettingsPayloadDiviner();
-    this._walletsListener = await PayloadStore.create({
-      archivist,
-      getLatest: async () => await OsSettingsQueries.getWallets(diviner),
-      idFunction: isWalletSeedPhrase
-    });
-    this._latestUserWalletListener = await PayloadStore.create({
-      archivist,
-      getLatest: async () => await OsSettingsQueries.getLatestUserWallet(diviner),
-      idFunction: isWalletSeedPhrase
-    });
-    this._nodeBackgroundListener = await PayloadStore.create({
-      archivist,
-      getLatest: async () => await OsSettingsQueries.getNodeBackground(diviner),
-      idFunction: isNodeBackground
-    });
+  get installedDapps() {
+    return [];
   }
-};
-
-// src/classes/node/DefaultPayloads/SigningKeyPayloads.ts
-var DappsWithAdditionalPayloads = /* @__PURE__ */ new Set(["Profile"]);
-var DefaultName = "Name Service";
-var DEFAULT_DAPP_ACCOUNT_PATHS = { [DefaultName]: "1'/1" };
-var ADDITIONAL_DAPP_ACCOUNT_PATHS = { ["Profile"]: { [DefaultName]: DEFAULT_DAPP_ACCOUNT_PATHS[DefaultName] } };
-var SigningKeyPayloads = class {
-  constructor(context, dappName) {
-    this.context = context;
-    this.dappName = dappName;
+  get kernel() {
+    return void 0;
   }
-  async payloads() {
-    const wallet = await this.resolveUserWallet();
-    const defaultDappAccountSigningKeyPayloads = await this.signingKeyPayload(wallet, this.dappName, DEFAULT_DAPP_ACCOUNT_PATHS[this.dappName]);
-    const additionalDappAccountSigningKeyPayloads = [];
-    for (const [dappName, accountPaths] of Object.entries(ADDITIONAL_DAPP_ACCOUNT_PATHS)) {
-      if (dappName !== this.dappName || !DappsWithAdditionalPayloads.has(dappName)) continue;
-      for (const additionalDappAccountName of Object.keys(accountPaths)) {
-        const signingKeyPayload = await this.signingKeyPayload(wallet, additionalDappAccountName, accountPaths[additionalDappAccountName]);
-        additionalDappAccountSigningKeyPayloads.push(signingKeyPayload);
-      }
-    }
-    return [...additionalDappAccountSigningKeyPayloads, defaultDappAccountSigningKeyPayloads].filter(isAnyPayload2);
+  get manifest() {
+    return assertEx13(this.params.manifest, () => "Missing manifest");
   }
-  async resolveUserWallet() {
-    const settingsCaller = new OsSettingsCaller(this.context);
-    const latestWallet = await settingsCaller.getLatestUserWallet();
-    const phrase = mnemonicArrayToString(latestWallet.mnemonic.mnemonic);
-    const assertedPhrase = assertEx14(phrase, () => "No phrase found in latest wallet");
-    return await HDWallet2.fromPhrase(assertedPhrase);
+  get platformLocator() {
+    this._platformLocator = this._platformLocator ?? this.params.platformLocator ?? new ModuleFactoryLocator3();
+    return this._platformLocator;
   }
-  async signingKeyPayload(wallet, name, path) {
-    if (path) {
-      const subAccount = await wallet.derivePath(path);
-      const privateKey = hexFrom(subAccount.privateKey, { prefix: false });
-      return {
-        dappName: name,
-        privateKey,
-        schema: SigningKeySchema2
-      };
-    }
+  get possibleRoot() {
+    return this._root;
   }
-};
-
-// src/classes/node/DefaultPayloads/DefaultPayloads.ts
-var DefaultPayloads = class {
-  constructor(dappArchivist, xyOs, dappName) {
-    this.dappArchivist = dappArchivist;
-    this.xyOs = xyOs;
-    this.dappName = dappName;
+  get root() {
+    return assertEx13(this._root, () => "XyOs root not set (probably not yet booted)");
   }
-  async insert() {
-    const insertables = [NodeInfoPayload, SigningKeyPayloads, DappAccessPayloads];
-    const insertPayloads = [];
-    for (const insertable of insertables) {
-      const classInstance = createInsertable(insertable, this.xyOs, this.dappName);
-      const payloads = await classInstance.payloads();
-      insertPayloads.push(...payloads);
-    }
-    for (const payload of insertPayloads) {
-      const [existing] = await this.dappArchivist.get([await PayloadBuilder5.dataHash(payload)]);
-      if (existing) continue;
-      await this.dappArchivist.insert([payload]);
-    }
+  get runningDapps() {
+    return [];
   }
-};
-
-// src/classes/node/ExternalModulePermissions/ExternalModulePermissions.ts
-var ALLOWED_MODULES_FROM_PARENT = ["IntentArchivist", "OsSettingsNode", "OsPubSubNetworkStackNode", "OsXyoPublicNetworkStackNode"];
-var ExternalModulePermissions = class {
-  constructor(context, dappWindowNode, dappName, externalPermissions) {
-    this.context = context;
-    this.dappWindowNode = dappWindowNode;
-    this.dappName = dappName;
-    this.externalPermissions = externalPermissions;
+  get signerPaths() {
+    return this.params.signerPaths;
   }
-  async permit() {
-    for (const permission of this.externalPermissions ?? []) {
-      await this.permitExternalModule(permission);
-    }
+  get state() {
+    return this._root ? "running" : "stopped";
   }
-  getExternalModuleName(permission) {
-    return permission.name;
+  get user() {
+    throw new Error("Method not implemented. [user]");
   }
-  async permitExternalModule(externalPermission) {
-    const externalModuleName = this.getExternalModuleName(externalPermission);
-    if (ALLOWED_MODULES_FROM_PARENT.includes(externalModuleName)) {
-      const mod = await this.resolveExternalModule(externalModuleName);
-      await this.registerAndAttachModule(mod);
-    } else {
-      console.warn(`${this.dappName} requested ${externalModuleName} but it was not fulfilled`);
-    }
+  boot(_wallet, _locator) {
+    throw new Error("Method not implemented. [boot]");
   }
-  async registerAndAttachModule(mod) {
-    if (mod) {
-      await this.dappWindowNode.register?.(mod);
-      await this.dappWindowNode.attach(mod.address, true);
-    }
+  buildDapp(_manifest, _dappId) {
+    throw new Error("Method not implemented. [buildDapp]");
   }
-  async resolveExternalModule(id) {
-    return await this.context.root.resolve(id);
+  dappByName(_dappId) {
+    throw new Error("Method not implemented. [runningDapp]");
   }
-};
-
-// src/classes/node/Creator.ts
-var DappContextCreator = class _DappContextCreator {
-  constructor(targetDappManifestParams, dappId, context, rootWallet, externalPermissions, sharedLocator) {
-    this.targetDappManifestParams = targetDappManifestParams;
-    this.dappId = dappId;
-    this.context = context;
-    this.rootWallet = rootWallet;
-    this.externalPermissions = externalPermissions;
-    this.sharedLocator = sharedLocator;
+  getDappParams(_dappId) {
+    throw new Error("Method not implemented. [getDappParams]");
   }
-  // Designated offset path for the wallet used by windowed dapps. In the future, other offsets could be used for other dapp modes
-  static DAPP_WINDOW_WALLET_PATH = "1";
-  static async create(params, xnsNodeUrl, xnsNetwork) {
-    const {
-      config,
-      locator,
-      context,
-      wallet
-    } = params;
-    const {
-      payload,
-      dappName,
-      publicChildren,
-      privateChildren
-    } = config;
-    const { external, manifestPayload } = this.parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork);
-    console.debug("[DEBUG] dApp manifest", manifestPayload);
-    const dappWallet = await wallet.derivePath(_DappContextCreator.DAPP_WINDOW_WALLET_PATH);
-    const targetDappManifestParams = [manifestPayload, dappWallet, locator, publicChildren, privateChildren];
-    const instance = new this(targetDappManifestParams, dappName, context, wallet, external?.modules, locator);
-    return instance;
+  getStack(_stackName) {
+    throw new Error("Method not implemented. [getStack]");
   }
-  // Add default payloads to the archivist shared between the os and the dapp
-  static async primeDappArchivist(dappContext, osContext, dappName) {
-    const dappCaller = new DappCallerBase(dappContext);
-    const dappArchivist = await dappCaller.getDappArchivist();
-    const defaultPayloads = new DefaultPayloads(dappArchivist, osContext, dappName);
-    await defaultPayloads.insert();
+  installDapp(_dappId) {
+    throw new Error("Method not implemented. [installDapp]");
   }
-  // Reset the dapp archivist to remove all payloads
-  static async resetDappArchivist(context) {
-    const dappModule = await context.root.resolve("DappArchivist");
-    const dappArchivist = assertEx15(asArchivistInstance4(dappModule), () => "resetDappArchivist: DappArchivist not found");
-    await dappArchivist.clear();
+  monitor(_fn, _eventConfig) {
+    throw new Error("Method not implemented. [monitor]");
   }
-  static parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork) {
-    const { external, ...manifestWithoutExternals } = payload;
-    const manifestPayloadRaw = {
-      ...manifestWithoutExternals,
-      schema: PackageManifestPayloadSchema
-    };
-    const manifestPayload = ReplaceManifestTokens(manifestPayloadRaw, xnsNodeUrl, xnsNetwork);
-    return { external, manifestPayload };
+  shutdown() {
+    throw new Error("Method not implemented. [shutdown]");
   }
-  async loadDappContext(context) {
-    console.log("DappNodesCreator:loadDappContext", this.dappId);
-    const dapp = await context.dappByName(this.dappId) ?? await (async () => {
-      const dapp2 = await context.buildDapp(this.targetDappManifestParams[0], this.dappId);
-      await dapp2.boot(this.rootWallet, this.sharedLocator);
-      return dapp2;
-    })();
-    await this.handleExternalModulePermissions(dapp.root);
-    await _DappContextCreator.primeDappArchivist(dapp, this.context, this.dappId);
-    return dapp;
+  startDapp(_dappId) {
+    throw new Error("Method not implemented. [startDapp]");
   }
-  // try to satisfy the external permissions requested by a dapp
-  async handleExternalModulePermissions(dappWindowNode) {
-    const externalModulePermissions = new ExternalModulePermissions(this.context, dappWindowNode, this.dappId, this.externalPermissions);
-    await externalModulePermissions.permit();
+  stopDapp(_dappId) {
+    throw new Error("Method not implemented. [stopDapp]");
   }
-};
-
-// src/classes/node/createDappContext.ts
-var GenericPayloadDivinerTags = { "network.xyo.generic.payload.diviner": "GenericPayloadDiviner" };
-var resolveLocator = (existingLocator) => {
-  const locator = existingLocator ?? new ModuleFactoryLocator2();
-  locator.register(GenericPayloadDiviner, GenericPayloadDivinerTags);
-  return locator;
-};
-var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwork) => {
-  console.log("createNodes");
-  try {
-    const dappSeedPhraseRepository = new DappSeedPhraseRepository(context, allowedNames);
-    const seedPhrase = await dappSeedPhraseRepository.request(dapp.config.walletId);
-    if (!seedPhrase) {
-      throw new Error(`unable to find seed phrase for walletId: ${JSON.stringify(dapp.config, null, 2)}`);
-    }
-    const wallet = await HDWallet3.fromPhrase(seedPhrase);
-    const dappName = dapp.config.name;
-    const { config: dappConfig, params: dappParams } = dapp;
-    const locator = resolveLocator((dappParams.locator ?? new ModuleFactoryLocator2()).merge(context.platformLocator));
-    const params = {
-      config: { dappName, payload: dappConfig.manifest },
-      context,
-      locator,
-      wallet
-    };
-    const dappContextCreator = await DappContextCreator.create(params, xnsNodeUrl, xnsNetwork);
-    const dappContext = await dappContextCreator.loadDappContext(context);
-    return {
-      context: dappContext,
-      dappWallet: wallet
-    };
-  } catch (e) {
-    const error = e;
-    console.error(`Error creating dappWindow node: ${error.message}`);
-    console.error(`Error creating dappWindow node: ${error.stack}`);
-    throw new Error(`Error creating dappWindow node: ${error.message}`);
+  uninstallDapp(_dappId) {
+    throw new Error("Method not implemented. [uninstallDapp]");
   }
 };
 
-// src/classes/registration/DappRegistrationService.ts
-import { forget as forget2 } from "@xylabs/forget";
-import { fulfilled, rejected } from "@xylabs/promise";
-import { ModuleFactoryLocator as ModuleFactoryLocator5 } from "@xyo-network/module-factory-locator";
-import {
-  DappIntentTypes as DappIntentTypes2,
-  DappMode as DappMode3,
-  isRegisteredDappAccessDappSet as isRegisteredDappAccessDappSet2,
-  isRegisteredDappExposedDappSet
-} from "@xyo-network/os-model";
-
-// src/event/bus/Connection.ts
-import { assertEx as assertEx16 } from "@xylabs/assert";
-import { BaseEmitter } from "@xyo-network/module-abstract";
-var EventBusConnection = class extends BaseEmitter {
-  _id;
-  description;
-  type;
-  constructor(request) {
-    super({});
-    this.description = request.description;
-    this.type = request.type;
+// src/XyOsDapp.ts
+var XyOsDapp = class extends XyOsContextBase {
+  dapp;
+  constructor(params) {
+    super(params);
+    this.dapp = { ...params.dapp };
   }
-  get id() {
-    return assertEx16(this._id, () => "Connection ID not set.  Did you forget to call buildConnection()?");
+  get eventBus() {
+    return this.parent.eventBus;
   }
-  buildConnection(id) {
-    this._id = id;
+  get exposedNode() {
+    return this.parent.exposedNode;
   }
-};
-
-// src/event/bus/EventBus.ts
-import { assertEx as assertEx17 } from "@xylabs/assert";
-import { forget } from "@xylabs/forget";
-import {
-  asArchivistInstance as asArchivistInstance5,
-  MemoryArchivist,
-  MemoryArchivistConfigSchema
-} from "@xyo-network/archivist";
-import {
-  isEventBusEvent,
-  isPubSubConnections
-} from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
-import { Mutex } from "async-mutex";
-import { v4 as uuid2 } from "uuid";
-var EventBus = class {
-  // Internal Archivist to store event data
-  _archivist;
-  // Store all connections
-  connections = {};
-  // Store all publisher callbacks for later removal
-  publisherCallbacks = {};
-  startMutex = new Mutex();
-  get archivist() {
-    return asArchivistInstance5(
-      assertEx17(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
-      "not a valid archivist instance"
-    );
+  get exposedNodeOuter() {
+    return this.parent.exposedNodeOuter;
   }
-  addConnection(connection) {
-    const id = uuid2();
-    this.connections[id] = connection;
-    connection.buildConnection(id);
-    if (isPubSubConnections(connection)) {
-      this.handlePublisherAdd(connection);
-    } else {
-      throw new Error("Unsupported connection type. Must be PubSub");
-    }
-    return connection;
+  /**
+   * @deprecated Dapps should not have access to the bios. This is done for the
+   * settings dapp, but should be refactored out. Bios could possibly be an
+   * optional property of the parent context passed in for dapps that require
+   * elevated permissions.
+   * ^^^ I believe we may want this here in that is a dApp requests access to the bios it will optionally be there
+   */
+  get kernel() {
+    return assertEx14(this.parent.kernel, () => "Missing kernel");
   }
-  removeConnection(connectionId) {
-    const connection = this.connections[connectionId];
-    if (!connection) {
-      throw new Error("Connection not found " + connectionId);
-    }
-    if (connection && isPubSubConnections(connection)) {
-      this.handlePublisherRemove(connection);
-    }
-    delete this.connections[connectionId];
+  get parent() {
+    return this.params.parent;
   }
-  async start(storeName = "EventBusArchivist") {
-    return await this.startMutex.runExclusive(async () => {
-      if (this._archivist) {
-        console.warn("EventBus already started");
-        return this;
+  get stacks() {
+    return [];
+  }
+  get user() {
+    return this.params.user;
+  }
+  async boot(wallet, locator) {
+    return await this._bootMutex.runExclusive(async () => {
+      console.log("XyOsDapp:boot:start", wallet.address, this.dapp.id);
+      assertEx14(this._root === void 0, () => "Dapp already booted");
+      const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator4()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator4();
+      console.log("XyOsDapp:boot:finalLocator", finalLocator);
+      const dappNodesWrapper = new ManifestWrapper({ ...this.manifest, schema: DappPackageManifestPayloadSchema }, wallet, finalLocator);
+      const dappNodes = await dappNodesWrapper.loadNodes();
+      const dappManifestWallet = await wallet.derivePath("99999");
+      dapp_window_manifest_default.nodes[0].config.name = this.dapp.name + "Root";
+      const wrapper = new ManifestWrapper(
+        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema },
+        dappManifestWallet,
+        finalLocator
+      );
+      const node = await wrapper.loadNodeFromIndex(0);
+      for (const dappNode of dappNodes) {
+        await node.register(dappNode);
+        await node.attach(dappNode.address, true);
       }
-      this._archivist = await MemoryArchivist.create({ config: { name: storeName, schema: MemoryArchivistConfigSchema } });
-      this.archivist.on("inserted", ({ payloads }) => {
-        const eventBusEvent = payloads.find(isEventBusEvent);
-        if (!eventBusEvent) return;
-        for (const connectionId in this.connections) {
-          const connection = this.connections[connectionId];
-          if (isPubSubConnections(connection) && connection.subscribableEvents) {
-            for (const [eventName, callback] of connection.subscribableEvents.entries()) {
-              if (eventName !== eventBusEvent.name) continue;
-              if (callback) {
-                const forgettable = async () => await callback({ payloads });
-                forget(forgettable());
-              }
-            }
-          }
-        }
-      });
-      return this;
-    });
-  }
-  handlePublisherAdd(connection) {
-    for (const eventName of connection.publishableEvents ?? []) {
-      const connectionPublisherCallback = async ({ payloads }) => {
-        const event = { name: eventName, schema: "network.xyo.event.bus.event" };
-        const eventPayloads = payloads ?? [];
-        event.sources = await PayloadBuilder6.dataHashes(eventPayloads);
-        try {
-          await this.archivist.insert([event, ...payloads ?? []]);
-        } catch (e) {
-          console.error("Error inserting event into archivist", e);
-        }
-      };
-      connection.on(eventName, connectionPublisherCallback);
-      const callbackId = connection.id + eventName;
-      this.publisherCallbacks[callbackId] = connectionPublisherCallback;
-    }
-  }
-  handlePublisherRemove(connection) {
-    for (const [, event] of connection.publishableEvents?.entries() ?? []) {
-      const id = connection.id + event;
-      const callback = this.publisherCallbacks[id];
-      if (callback) connection.off(event, callback);
-    }
-  }
-};
-
-// src/event/bus/PubSubConnection.ts
-var EventBusPubSubConnection = class extends EventBusConnection {
-  publishableEvents;
-  subscribableEvents;
-  constructor(request) {
-    super(request);
-    if (request.type !== "PubSub") {
-      throw new Error("Invalid connection type. Must be PubSub");
-    }
-    this.publishableEvents = request.publishableEvents;
-    this.subscribableEvents = request.subscribableEvents;
-  }
-};
-
-// src/event/connections/DappAccessRequest.ts
-var DappAccessRequestEvent = "dappAccessRequest";
-var dappAccessRequestConnectionRequest = {
-  publishableEvents: [DappAccessRequestEvent],
-  type: "PubSub"
-};
-var dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest);
-
-// src/event/connections/DappsReady.ts
-var dappsReadyConnectionRequest = {
-  publishableEvents: ["dappsReady"],
-  type: "PubSub"
-};
-var dappsReadyConnection = () => new EventBusPubSubConnection(dappsReadyConnectionRequest);
-
-// src/event/connections/ExposeDappRequest.ts
-var ExposeDappRequestEvent = "exposeDappRequest";
-var exposeDappConnectionRequest = {
-  publishableEvents: [ExposeDappRequestEvent],
-  type: "PubSub"
-};
-var exposeDappRequestConnection = () => new EventBusPubSubConnection(exposeDappConnectionRequest);
-
-// src/event/connections/OsPubSubNetworkReady.ts
-var OsPubSubNetworkReadyEvent = "osPubSubNetworkReady";
-var osPubSubNetworkConnectionRequest = {
-  publishableEvents: [OsPubSubNetworkReadyEvent],
-  type: "PubSub"
-};
-var osPubSubNetworkReadyConnection = () => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest);
-
-// src/event/connections/OsSettingsReady.ts
-var OsSettingsReadyEvent = "osSettingsReady";
-var osSettingsConnectionRequest = {
-  publishableEvents: [OsSettingsReadyEvent],
-  type: "PubSub"
-};
-var osSettingsReadyConnection = () => new EventBusPubSubConnection(osSettingsConnectionRequest);
-
-// src/event/connections/OsXyoPublicReady.ts
-var OsXyoPublicNetworkReadyEvent = "osXyoPublicNetworkReady";
-var osXyoPublicNetworkConnectionRequest = {
-  publishableEvents: [OsXyoPublicNetworkReadyEvent],
-  type: "PubSub"
-};
-var osXyoPublicNetworkReadyConnection = () => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest);
-
-// src/XyOsDapp.ts
-import { assertEx as assertEx19 } from "@xylabs/assert";
-import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
-import { ModuleFactoryLocator as ModuleFactoryLocator4 } from "@xyo-network/module-factory-locator";
-import { DappPackageManifestPayloadSchema } from "@xyo-network/os-model";
-
-// src/manifests/dapp-window.manifest.json
-var dapp_window_manifest_default = {
-  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/compilations/dapp-package-manifest-schema.json",
-  nodes: [
-    {
-      config: {
-        accountPath: "0'",
-        name: "Dapp",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [],
-        public: [
-          {
-            config: {
-              accountPath: "0'/0'",
-              name: "DappArchivist",
-              schema: "network.xyo.archivist.memory.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "0'/1'",
-              archivist: "DappArchivist",
-              labels: {
-                "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
-              },
-              name: "DappArchivistPayloadDiviner",
-              schema: "network.xyo.diviner.payload.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  schema: "network.xyo.manifest.package.dapp"
-};
-
-// src/XyOsBase.ts
-import { assertEx as assertEx18 } from "@xylabs/assert";
-import { BaseEmitter as BaseEmitter2 } from "@xyo-network/module-abstract";
-import { ModuleFactoryLocator as ModuleFactoryLocator3 } from "@xyo-network/module-factory-locator";
-import { Mutex as Mutex2 } from "async-mutex";
-var XyOsContextBase = class extends BaseEmitter2 {
-  _bootMutex = new Mutex2();
-  _platformLocator;
-  _root;
-  get bios() {
-    return this.kernel?.bios;
-  }
-  get eventBus() {
-    return assertEx18(this.params.eventBus, () => "Missing event bus");
-  }
-  get exposedNode() {
-    throw new Error("Method not implemented. [exposedNode]");
-  }
-  get exposedNodeOuter() {
-    throw new Error("Method not implemented. [exposedNodeOuter]");
-  }
-  get installedDapps() {
-    return [];
-  }
-  get kernel() {
-    return void 0;
-  }
-  get manifest() {
-    return assertEx18(this.params.manifest, () => "Missing manifest");
-  }
-  get platformLocator() {
-    this._platformLocator = this._platformLocator ?? this.params.platformLocator ?? new ModuleFactoryLocator3();
-    return this._platformLocator;
-  }
-  get possibleRoot() {
-    return this._root;
-  }
-  get root() {
-    return assertEx18(this._root, () => "XyOs root not set (probably not yet booted)");
-  }
-  get runningDapps() {
-    return [];
-  }
-  get signerPaths() {
-    return this.params.signerPaths;
-  }
-  get state() {
-    return this._root ? "running" : "stopped";
-  }
-  get user() {
-    throw new Error("Method not implemented. [user]");
-  }
-  boot(_wallet, _locator) {
-    throw new Error("Method not implemented. [boot]");
-  }
-  buildDapp(_manifest, _dappId) {
-    throw new Error("Method not implemented. [buildDapp]");
-  }
-  dappByName(_dappId) {
-    throw new Error("Method not implemented. [runningDapp]");
-  }
-  getDappParams(_dappId) {
-    throw new Error("Method not implemented. [getDappParams]");
-  }
-  getStack(_stackName) {
-    throw new Error("Method not implemented. [getStack]");
-  }
-  installDapp(_dappId) {
-    throw new Error("Method not implemented. [installDapp]");
-  }
-  monitor(_fn, _eventConfig) {
-    throw new Error("Method not implemented. [monitor]");
-  }
-  shutdown() {
-    throw new Error("Method not implemented. [shutdown]");
-  }
-  startDapp(_dappId) {
-    throw new Error("Method not implemented. [startDapp]");
-  }
-  stopDapp(_dappId) {
-    throw new Error("Method not implemented. [stopDapp]");
-  }
-  uninstallDapp(_dappId) {
-    throw new Error("Method not implemented. [uninstallDapp]");
-  }
-};
-
-// src/XyOsDapp.ts
-var XyOsDapp = class extends XyOsContextBase {
-  dapp;
-  constructor(params) {
-    super(params);
-    this.dapp = { ...params.dapp };
-  }
-  get eventBus() {
-    return this.parent.eventBus;
-  }
-  get exposedNode() {
-    return this.parent.exposedNode;
-  }
-  get exposedNodeOuter() {
-    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
-   */
-  get kernel() {
-    return assertEx19(this.parent.kernel, () => "Missing kernel");
-  }
-  get parent() {
-    return this.params.parent;
-  }
-  get stacks() {
-    return [];
-  }
-  get user() {
-    return this.params.user;
-  }
-  async boot(wallet, locator) {
-    return await this._bootMutex.runExclusive(async () => {
-      console.log("XyOsDapp:boot:start", wallet.address, this.dapp.id);
-      assertEx19(this._root === void 0, () => "Dapp already booted");
-      const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator4()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator4();
-      console.log("XyOsDapp:boot:finalLocator", finalLocator);
-      const dappNodesWrapper = new ManifestWrapper({ ...this.manifest, schema: DappPackageManifestPayloadSchema }, wallet, finalLocator);
-      const dappNodes = await dappNodesWrapper.loadNodes();
-      const dappManifestWallet = await wallet.derivePath("99999");
-      dapp_window_manifest_default.nodes[0].config.name = this.dapp.name + "Root";
-      const wrapper = new ManifestWrapper(
-        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema },
-        dappManifestWallet,
-        finalLocator
-      );
-      const node = await wrapper.loadNodeFromIndex(0);
-      for (const dappNode of dappNodes) {
-        await node.register(dappNode);
-        await node.attach(dappNode.address, true);
-      }
-      this._root = node;
-      console.log("XyOsDapp:boot:finish", wallet.address, this.dapp.id);
+      this._root = node;
+      console.log("XyOsDapp:boot:finish", wallet.address, this.dapp.id);
     });
   }
   getStack(stackName) {
@@ -2195,24 +1808,24 @@ var XyOsDapp = class extends XyOsContextBase {
 };
 
 // src/classes/system/ManageSystemDapps.ts
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import semver from "semver";
 
 // src/classes/system/Queries.ts
-import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema10 } from "@xyo-network/diviner-payload-model";
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema8 } from "@xyo-network/diviner-payload-model";
 import {
   DappConfigSchema,
   DappIconSchema,
   DappWidgetConfigSchema,
   UnregisteredDappAccessSchema
 } from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 var SystemDappQueries = {
   async getDappAccess(diviner, name, version) {
     const accessQuery = {
       order: "desc",
       registeringDappId: name,
-      schema: PayloadDivinerQuerySchema10,
+      schema: PayloadDivinerQuerySchema8,
       schemas: [UnregisteredDappAccessSchema],
       version
     };
@@ -2223,7 +1836,7 @@ var SystemDappQueries = {
       limit: 1,
       name,
       order: "desc",
-      schema: PayloadDivinerQuerySchema10,
+      schema: PayloadDivinerQuerySchema8,
       schemas: [DappConfigSchema]
     };
     const [dappConfig] = await diviner.divine([configQuery]);
@@ -2233,7 +1846,7 @@ var SystemDappQueries = {
     const iconQuery = {
       name,
       order: "desc",
-      schema: PayloadDivinerQuerySchema10,
+      schema: PayloadDivinerQuerySchema8,
       schemas: [DappIconSchema],
       version
     };
@@ -2244,14 +1857,14 @@ var SystemDappQueries = {
     const widgetConfigQuery = {
       dappId: name,
       order: "desc",
-      schema: PayloadDivinerQuerySchema10,
+      schema: PayloadDivinerQuerySchema8,
       schemas: [DappWidgetConfigSchema],
       version
     };
     const widgetConfigs = await diviner.divine([widgetConfigQuery]);
     const uniqueConfigs = {};
     for (const widgetConfig of widgetConfigs) {
-      const hash = await PayloadBuilder7.dataHash(widgetConfig);
+      const hash = await PayloadBuilder6.dataHash(widgetConfig);
       uniqueConfigs[widgetConfig.mode ?? hash] = widgetConfig;
     }
     return Object.values(uniqueConfigs);
@@ -2302,7 +1915,7 @@ 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 PayloadBuilder8.dataHash(systemDappPayload)]);
+        const [existing] = await archivist.get([await PayloadBuilder7.dataHash(systemDappPayload)]);
         if (existing) continue;
         await archivist.insert([systemDappPayload]);
       }
@@ -2358,7 +1971,7 @@ var ManageSystemDapps = class extends OsCallerBase {
 };
 
 // src/classes/registration/DappRegistry.ts
-import { HDWallet as HDWallet5 } from "@xyo-network/account";
+import { HDWallet as HDWallet4 } from "@xyo-network/account";
 import {
   DappRegisteredSchema,
   DappRegisteredState,
@@ -2372,7 +1985,7 @@ var isFailedAccessor = isPayloadOfSchemaTypeWithMeta(FailedAccessorSchema);
 var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registration.validate";
 
 // src/classes/registration/ValidateDappAccessDiviner/Diviner.ts
-import { HDWallet as HDWallet4 } from "@xyo-network/account";
+import { HDWallet as HDWallet3 } from "@xyo-network/account";
 import { AbstractDiviner } from "@xyo-network/diviner-abstract";
 import { ManifestWrapper as ManifestWrapper2, PackageManifestPayloadSchema as PackageManifestPayloadSchema2 } from "@xyo-network/manifest";
 import {
@@ -2380,7 +1993,7 @@ import {
   isUnregisteredDappAccess,
   RegisteredDappAccessSchema as RegisteredDappAccessSchema3
 } from "@xyo-network/os-model";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 var ValidateDappAccessDiviner = class extends AbstractDiviner {
   static configSchemas = [ValidateDappAccessDivinerConfigSchema];
   async divineHandler(payloads) {
@@ -2408,14 +2021,14 @@ var ValidateDappAccessDiviner = class extends AbstractDiviner {
           const interfaceChildren = await getNodeChildren(dappAccessInterface.manifest, dappParams);
           const valid = compareChildren(interfaceChildren, dappChildren);
           if (valid) {
-            const payload = await PayloadBuilder9.build({
+            const payload = await PayloadBuilder8.build({
               ...access,
               schema: RegisteredDappAccessSchema3,
               timestamp: Date.now()
             });
             registeredAccessors.push(payload);
           } else {
-            const failedRegistration = await PayloadBuilder9.build({
+            const failedRegistration = await PayloadBuilder8.build({
               accessor: access,
               errorMessage: "Invalid dapp access interface",
               schema: FailedAccessorSchema
@@ -2425,7 +2038,7 @@ var ValidateDappAccessDiviner = class extends AbstractDiviner {
         }
       } catch (e) {
         failedAccessors.push(
-          await PayloadBuilder9.build({
+          await PayloadBuilder8.build({
             accessor: access,
             errorMessage: e.message,
             schema: FailedAccessorSchema
@@ -2433,251 +2046,559 @@ var ValidateDappAccessDiviner = class extends AbstractDiviner {
         );
       }
     }
-    return [...registeredAccessors, ...failedAccessors];
+    return [...registeredAccessors, ...failedAccessors];
+  }
+};
+var compareChildren = (interfaceChildren, dappChildren) => {
+  return interfaceChildren.every((interfaceChild) => Object.values(interfaceChild).every((interfaceChildName) => dappChildren.some((dappChild) => Object.values(dappChild).includes(interfaceChildName))));
+};
+var dappPackageManifestToPackageManifest = (dappPackageManifest) => {
+  return {
+    ...dappPackageManifest,
+    schema: PackageManifestPayloadSchema2
+  };
+};
+var getChildrenFromNode = async (node) => {
+  const nodeManifest = (await node.state())?.[0];
+  return nodeManifest.status?.children;
+};
+var getNodeChildren = async (manifestToTest, dappParams) => {
+  const testNodes = await getNodeToTest(manifestToTest, dappParams);
+  const children = [];
+  for (const node of testNodes) {
+    const nodeChildren = await getChildrenFromNode(node);
+    if (nodeChildren) {
+      children.push(nodeChildren);
+    }
+  }
+  return children;
+};
+var getNodeToTest = async (manifestToTest, dappParams) => {
+  const dappManifestWrapper = new ManifestWrapper2(manifestToTest, await HDWallet3.random(), dappParams.locator);
+  return await dappManifestWrapper.loadNodes();
+};
+
+// src/classes/registration/DappRegistry.ts
+var DappRegistry = class {
+  constructor(dappSeedPhraseRepository) {
+    this.dappSeedPhraseRepository = dappSeedPhraseRepository;
+  }
+  dappRegistry = /* @__PURE__ */ new Map();
+  /**
+   * Register a Dapp with window manager and if successful, return its id
+   *
+   * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
+   * @returns {RegisteredDapp} dapp with registration fields
+   **/
+  async registerDapp(dapp) {
+    if (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);
+        const registeredDapp = {
+          accessors: registeredAccessors,
+          config: {
+            exposedModuleIds,
+            manifest,
+            modes,
+            name,
+            schema: DappRegisteredSchema,
+            state: DappRegisteredState.Registered,
+            version,
+            // attach the walletId to a registered dapp so it can request it back in the future
+            walletId
+          },
+          params,
+          widgetConfigs
+        };
+        if (this.dappRegistry.get(name)) {
+          console.warn("tried to register two dapps with the same name", name);
+          return null;
+        }
+        this.dappRegistry.set(name, registeredDapp);
+        return registeredDapp;
+      } catch (e) {
+        console.error("Error registeringDapp", e);
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  /**
+   * 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;
+    return {
+      exposedModuleIds,
+      manifest,
+      modes,
+      name,
+      params,
+      sources,
+      version,
+      widgetConfigs
+    };
+  }
+  async validateDappAccessPayloads(manifest, accessors = [], params) {
+    const validateDappAccess = await ValidateDappAccessDiviner.create({
+      account: await HDWallet4.random(),
+      config: { schema: ValidateDappAccessDivinerConfigSchema },
+      dappParams: params
+    });
+    const payloads = await validateDappAccess.divine([manifest, ...accessors]);
+    const failedAccessors = payloads.filter(isFailedAccessor);
+    const registeredAccessors = payloads.filter(isRegisteredDappAccess2);
+    if (failedAccessors.length > 0) {
+      console.error("Failed to register all dapp accessors", failedAccessors);
+    }
+    return registeredAccessors;
+  }
+};
+
+// src/classes/registration/DappRegistrationService.ts
+var DappRegistrationService = class {
+  constructor(context, params = {
+    dappNames: [],
+    dappParams: {},
+    dappPayloads: []
+  }, locator = new ModuleFactoryLocator5(), developmentMode) {
+    this.context = context;
+    this.params = params;
+    this.locator = locator;
+    this.developmentMode = developmentMode;
+    this.manageSystemDapps = new ManageSystemDapps(
+      context,
+      this.params?.dappNames ?? [],
+      this.params?.dappPayloads ?? [],
+      this.params?.dappParams ?? {},
+      this.locator,
+      this.developmentMode
+    );
+    this.dappSeedPhraseRepository = new DappSeedPhraseRepository(context, this.params?.dappNames ?? []);
+    this.dappRegistry = new DappRegistry(this.dappSeedPhraseRepository);
+    this.addConnectionRequests();
+  }
+  // Dapps that have been built with their own context
+  builtDapps = {};
+  dappRegistry;
+  dappSeedPhraseRepository;
+  manageSystemDapps;
+  // Dapps that have been registered with dappAccessRequests
+  registeredAccessDappSets = /* @__PURE__ */ new Set();
+  // Dapps that have been registered with the dapp registry
+  registeredDappSets = /* @__PURE__ */ new Set();
+  // Dapps that have been registered with exposeDappRequests
+  registeredExposedDappSets = /* @__PURE__ */ new Set();
+  dappAccessRequestConnection = dappAccessRequestConnection();
+  exposeDappRequestConnection = exposeDappRequestConnection();
+  async buildDapp(manifest, dappId = NameTransforms.slug(manifest.nodes[0]?.config.name), name = NameTransforms.moduleName(manifest.nodes[0]?.config.name)) {
+    const dapp = new XyOsDapp({
+      dapp: { id: dappId, name },
+      locator: this.locator,
+      manifest,
+      parent: this.context,
+      user: await this.getUser()
+    });
+    this.builtDapps[dappId] = dapp;
+    return dapp;
+  }
+  getParamsForRegisteredDapp(dappId) {
+    return this.params?.dappParams[dappId];
+  }
+  async start() {
+    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 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 };
+  }
+  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
+   */
+  getUser() {
+    return this.context.user;
+  }
+  async postRegistrationHandlers(registeredDapp) {
+    if (registeredDapp.dapp) {
+      if (isRegisteredDappExposedDappSet(registeredDapp)) {
+        this.registeredExposedDappSets.add(registeredDapp);
+        const exposeIntent = DappIntentCaller.buildIntent(
+          DappIntentCaller.OsDappName,
+          DappIntentTypes2.Launch,
+          registeredDapp.dapp.config.name,
+          DappMode3.Exposed
+        );
+        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, { payloads: [registeredDapp.dapp.config, exposeIntent] });
+      }
+      if (isRegisteredDappAccessDappSet2(registeredDapp)) {
+        this.registeredAccessDappSets.add(registeredDapp);
+        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, { payloads: registeredDapp.dapp.accessors });
+      }
+    }
   }
 };
-var compareChildren = (interfaceChildren, dappChildren) => {
-  return interfaceChildren.every((interfaceChild) => Object.values(interfaceChild).every((interfaceChildName) => dappChildren.some((dappChild) => Object.values(dappChild).includes(interfaceChildName))));
-};
-var dappPackageManifestToPackageManifest = (dappPackageManifest) => {
-  return {
-    ...dappPackageManifest,
-    schema: PackageManifestPayloadSchema2
-  };
-};
-var getChildrenFromNode = async (node) => {
-  const nodeManifest = (await node.state())?.[0];
-  return nodeManifest.status?.children;
+
+// src/classes/settings/badge/Caller.ts
+import { OsBadgeSchema as OsBadgeSchema2 } from "@xyo-network/os-model";
+
+// src/classes/settings/CallerBase.ts
+import { assertEx as assertEx15 } from "@xylabs/assert";
+import { asArchivistInstance as asArchivistInstance5 } from "@xyo-network/archivist-model";
+import { asDivinerInstance as asDivinerInstance4 } from "@xyo-network/diviner-model";
+var OsSettingsArchivistModuleName = "OsSettingsNode:OsSettingsArchivist";
+var OsSettingsArchivistPayloadDivinerModuleName = "OsSettingsNode:OsSettingsArchivistPayloadDiviner";
+var OsSettingsCallerBase = class {
+  constructor(context) {
+    this.context = context;
+  }
+  async getOsSettingsArchivist() {
+    const mod = assertEx15(await this.context.root.resolve(OsSettingsArchivistModuleName), () => `${OsSettingsArchivistModuleName} not found`);
+    return asArchivistInstance5(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`);
+  }
+  async getOsSettingsPayloadDiviner() {
+    const mod = assertEx15(
+      await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName),
+      () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance4(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`);
+  }
 };
-var getNodeChildren = async (manifestToTest, dappParams) => {
-  const testNodes = await getNodeToTest(manifestToTest, dappParams);
-  const children = [];
-  for (const node of testNodes) {
-    const nodeChildren = await getChildrenFromNode(node);
-    if (nodeChildren) {
-      children.push(nodeChildren);
-    }
+
+// src/classes/settings/badge/Queries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema9 } from "@xyo-network/diviner-payload-model";
+import { OsBadgeSchema } from "@xyo-network/os-model";
+var OsBadgeQueries = {
+  getBadge: async (achievement, diviner) => {
+    const query = {
+      achievement,
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema9,
+      schemas: [OsBadgeSchema]
+    };
+    return await diviner.divine([query]);
   }
-  return children;
 };
-var getNodeToTest = async (manifestToTest, dappParams) => {
-  const dappManifestWrapper = new ManifestWrapper2(manifestToTest, await HDWallet4.random(), dappParams.locator);
-  return await dappManifestWrapper.loadNodes();
+
+// src/classes/settings/badge/Caller.ts
+var OsBadgeCaller = class extends OsSettingsCallerBase {
+  /**
+   * @param  {ValidOsAchievements} achievement
+   */
+  async getBadge(achievement) {
+    const diviner = await this.getOsSettingsPayloadDiviner();
+    const results = await OsBadgeQueries.getBadge(achievement, diviner);
+    return results[0] ?? null;
+  }
+  /**
+   * @param  {ValidOsAchievements} achievement
+   */
+  async saveBadge(achievement) {
+    const badge = {
+      achievement,
+      schema: OsBadgeSchema2,
+      timestamp: Date.now()
+    };
+    const archivist = await this.getOsSettingsArchivist();
+    return await archivist.insert([badge]);
+  }
 };
 
-// src/classes/registration/DappRegistry.ts
-var DappRegistry = class {
-  constructor(dappSeedPhraseRepository) {
-    this.dappSeedPhraseRepository = dappSeedPhraseRepository;
+// src/classes/settings/badge/Resource.ts
+import { assertEx as assertEx16 } from "@xylabs/assert";
+import { isBadgeWithMeta } from "@xyo-network/os-model";
+var OsBadgeResource = class extends OsSettingsCallerBase {
+  static views = ["savedSeedPhrase"];
+  _savedSeedPhrase;
+  constructor(xyOsContext) {
+    super(xyOsContext);
+  }
+  get savedSeedPhrase() {
+    return assertEx16(this._savedSeedPhrase, () => "Saved seed phrase listener not set");
+  }
+  get subscriptions() {
+    return { savedSeedPhrase: (cb) => this.savedSeedPhrase.subscribe(cb) };
+  }
+  get views() {
+    return { savedSeedPhrase: () => this.savedSeedPhrase.latest };
+  }
+  cleanupListeners() {
+    this.savedSeedPhrase.cleanupListeners();
   }
-  dappRegistry = /* @__PURE__ */ new Map();
   /**
-   * Register a Dapp with window manager and if successful, return its id
-   *
-   * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
-   * @returns {RegisteredDapp} dapp with registration fields
+   * start listeners
    **/
-  async registerDapp(dapp) {
-    if (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);
-        const registeredDapp = {
-          accessors: registeredAccessors,
-          config: {
-            exposedModuleIds,
-            manifest,
-            modes,
-            name,
-            schema: DappRegisteredSchema,
-            state: DappRegisteredState.Registered,
-            version,
-            // attach the walletId to a registered dapp so it can request it back in the future
-            walletId
-          },
-          params,
-          widgetConfigs
-        };
-        if (this.dappRegistry.get(name)) {
-          console.warn("tried to register two dapps with the same name", name);
-          return null;
-        }
-        this.dappRegistry.set(name, registeredDapp);
-        return registeredDapp;
-      } catch (e) {
-        console.error("Error registeringDapp", e);
-        return null;
-      }
-    } else {
-      return null;
+  async start() {
+    const diviner = await this.getOsSettingsPayloadDiviner();
+    const archivist = await this.getOsSettingsArchivist();
+    this._savedSeedPhrase = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await OsBadgeQueries.getBadge("savedSeedPhrase", diviner),
+      idFunction: isBadgeWithMeta
+    });
+  }
+};
+
+// src/classes/settings/Caller.ts
+import { assertEx as assertEx17 } from "@xylabs/assert";
+import { isEqual } from "@xylabs/lodash";
+
+// src/utils/buildWalletSeedPhrasePayload.ts
+import { WalletSeedPhraseSchema } from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+var language = "english";
+var standard = "bip-39";
+var userWalletLabel = "userWallet";
+var buildWalletSeedPhrasePayload = async (mnemonic, label) => {
+  const fields = {
+    mnemonic: {
+      language,
+      mnemonic: mnemonic.split(" "),
+      standard
     }
+  };
+  const meta = { label, timestamp: Date.now() };
+  const builder = new PayloadBuilder9({
+    fields,
+    meta,
+    schema: WalletSeedPhraseSchema
+  });
+  const payload = await builder.build();
+  const rootHash = await PayloadBuilder9.hash(payload);
+  return { payload, rootHash };
+};
+var buildUserWalletSeedPhrasePayload = (mnemonic) => {
+  return buildWalletSeedPhrasePayload(mnemonic, userWalletLabel);
+};
+
+// src/utils/getApiDomain.ts
+var getApiDomain = (scope, apiDomain) => {
+  if (apiDomain !== void 0) {
+    return apiDomain;
+  }
+  if (scope === "localhost") {
+    return "http://localhost:8080";
+  }
+  if (scope === "beta") {
+    return "https://beta.archivist.xyo.network";
+  }
+  return "https://archivist.xyo.network";
+};
+
+// src/utils/renameObjKey.ts
+var renameObjKey = (oldObj, oldKey, newKey) => {
+  const oldObjKeys = Object.keys(oldObj);
+  const newObj = oldObjKeys.reduce(
+    (acc, val) => {
+      if (val === oldKey) {
+        acc[newKey] = oldObj[oldKey];
+      } else {
+        acc[val] = oldObj[val];
+      }
+      return acc;
+    },
+    {}
+  );
+  return newObj;
+};
+
+// src/classes/settings/SettingsQueries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema10 } from "@xyo-network/diviner-payload-model";
+import { NodeBackgroundSchema, WalletSeedPhraseSchema as WalletSeedPhraseSchema2 } from "@xyo-network/os-model";
+var NO_RESULTS2 = [];
+var OsSettingsQueries = {
+  async getLatestUserWallet(diviner) {
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema10,
+      schemas: [WalletSeedPhraseSchema2]
+    };
+    const results = await diviner.divine([query]);
+    const wallet = results.find((payload) => payload.$meta.label === "userWallet");
+    return wallet ? [wallet] : NO_RESULTS2;
+  },
+  async getNodeBackground(diviner) {
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema10,
+      schemas: [NodeBackgroundSchema]
+    };
+    return await diviner.divine([query]);
+  },
+  async getWallets(diviner) {
+    const query = {
+      order: "desc",
+      schema: PayloadDivinerQuerySchema10,
+      schemas: [WalletSeedPhraseSchema2]
+    };
+    return await diviner.divine([query]);
+  }
+};
+
+// src/classes/settings/Caller.ts
+var OsSettingsCaller = class extends OsSettingsCallerBase {
+  constructor(context) {
+    super(context);
   }
   /**
-   * Unregister a dapp so it can no longer be launched
-   *
-   * @param dappId
+   * Add a node background to the settings
+   * @param  {WithMeta<NodeBackground>} payload
    */
-  unregisterDapp(dappId) {
-    this.dappRegistry.delete(dappId);
+  async addNodeBackground(payload) {
+    const archivist = await this.getOsSettingsArchivist();
+    await archivist.insert([payload]);
   }
-  extractDappProperties(dapp) {
-    const {
-      params,
-      config,
-      widgetConfigs
-    } = dapp;
-    const {
-      exposedModuleIds,
-      manifest,
-      modes,
-      name,
-      sources,
-      version
-    } = config;
-    return {
-      exposedModuleIds,
-      manifest,
-      modes,
-      name,
-      params,
-      sources,
-      version,
-      widgetConfigs
-    };
+  /**
+   * Add a wallet seed phrase to the settings
+   * @param  {WalletSeedPhrase} payload
+   */
+  async addWalletSeedPhrase(payload) {
+    const archivist = await this.getOsSettingsArchivist();
+    await archivist.insert([payload]);
+    const phrase = payload.mnemonic.mnemonic.join(" ");
+    await this.context.kernel?.bios?.seedPhraseStore.set("user", phrase);
   }
-  async validateDappAccessPayloads(manifest, accessors = [], params) {
-    const validateDappAccess = await ValidateDappAccessDiviner.create({
-      account: await HDWallet5.random(),
-      config: { schema: ValidateDappAccessDivinerConfigSchema },
-      dappParams: params
-    });
-    const payloads = await validateDappAccess.divine([manifest, ...accessors]);
-    const failedAccessors = payloads.filter(isFailedAccessor);
-    const registeredAccessors = payloads.filter(isRegisteredDappAccess2);
-    if (failedAccessors.length > 0) {
-      console.error("Failed to register all dapp accessors", failedAccessors);
+  /**
+   * Get the latest node background
+   */
+  async getLatestNodeBackground() {
+    const diviner = await this.getOsSettingsPayloadDiviner();
+    const [result] = await OsSettingsQueries.getNodeBackground(diviner);
+    return result ?? null;
+  }
+  async getLatestUserWallet() {
+    const diviner = await this.getOsSettingsPayloadDiviner();
+    const storedSeedPhrasePayload = (await OsSettingsQueries.getLatestUserWallet(diviner)).pop();
+    const biosWalletSeedPhrase = assertEx17(await this.context.kernel?.bios?.seedPhraseStore.get("user"), () => "No user seed phrase found from BIOS");
+    const biosWalletSeedPhraseParts = biosWalletSeedPhrase.split(" ");
+    if (!storedSeedPhrasePayload?.mnemonic?.mnemonic) {
+      const { payload: biosSeedPhrasePayload } = await buildUserWalletSeedPhrasePayload(biosWalletSeedPhrase);
+      await this.addWalletSeedPhrase(biosSeedPhrasePayload);
+      return biosSeedPhrasePayload;
+    } else if (!isEqual(storedSeedPhrasePayload.mnemonic.mnemonic, biosWalletSeedPhraseParts)) {
+      const updatedBiosSeedPhrase = storedSeedPhrasePayload.mnemonic.mnemonic.join(" ");
+      await this.context.kernel?.bios?.seedPhraseStore.set("user", updatedBiosSeedPhrase);
     }
-    return registeredAccessors;
+    return storedSeedPhrasePayload;
   }
 };
 
-// src/classes/registration/DappRegistrationService.ts
-var DappRegistrationService = class {
-  constructor(context, params = {
-    dappNames: [],
-    dappParams: {},
-    dappPayloads: []
-  }, locator = new ModuleFactoryLocator5(), developmentMode) {
-    this.context = context;
-    this.params = params;
-    this.locator = locator;
-    this.developmentMode = developmentMode;
-    this.manageSystemDapps = new ManageSystemDapps(
-      context,
-      this.params?.dappNames ?? [],
-      this.params?.dappPayloads ?? [],
-      this.params?.dappParams ?? {},
-      this.locator,
-      this.developmentMode
-    );
-    this.dappSeedPhraseRepository = new DappSeedPhraseRepository(context, this.params?.dappNames ?? []);
-    this.dappRegistry = new DappRegistry(this.dappSeedPhraseRepository);
-    this.addConnectionRequests();
+// src/classes/settings/Resource.ts
+import { assertEx as assertEx18 } from "@xylabs/assert";
+import { isNodeBackground, isWalletSeedPhrase } from "@xyo-network/os-model";
+var OsSettingsResource = class extends OsSettingsCallerBase {
+  _latestUserWalletListener;
+  _nodeBackgroundListener;
+  _walletsListener;
+  constructor(context) {
+    super(context);
   }
-  // Dapps that have been built with their own context
-  builtDapps = {};
-  dappRegistry;
-  dappSeedPhraseRepository;
-  manageSystemDapps;
-  // Dapps that have been registered with dappAccessRequests
-  registeredAccessDappSets = /* @__PURE__ */ new Set();
-  // Dapps that have been registered with the dapp registry
-  registeredDappSets = /* @__PURE__ */ new Set();
-  // Dapps that have been registered with exposeDappRequests
-  registeredExposedDappSets = /* @__PURE__ */ new Set();
-  dappAccessRequestConnection = dappAccessRequestConnection();
-  exposeDappRequestConnection = exposeDappRequestConnection();
-  async buildDapp(manifest, dappId = NameTransforms.slug(manifest.nodes[0]?.config.name), name = NameTransforms.moduleName(manifest.nodes[0]?.config.name)) {
-    const dapp = new XyOsDapp({
-      dapp: { id: dappId, name },
-      locator: this.locator,
-      manifest,
-      parent: this.context,
-      user: await this.getUser()
-    });
-    this.builtDapps[dappId] = dapp;
-    return dapp;
+  get latestUserWalletListener() {
+    return assertEx18(this._latestUserWalletListener, () => "Latest user wallet listener not set");
   }
-  getParamsForRegisteredDapp(dappId) {
-    return this.params?.dappParams[dappId];
+  get nodeBackgroundListener() {
+    return assertEx18(this._nodeBackgroundListener, () => "Node background listener not set");
   }
-  async start() {
-    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 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 };
+  get subscriptions() {
+    return {
+      latestUserWallet: (cb) => this.walletsListener.subscribe(cb),
+      nodeBackground: (cb) => this.nodeBackgroundListener.subscribe(cb),
+      wallets: (cb) => this.walletsListener.subscribe(cb)
+    };
   }
-  addConnectionRequests() {
-    this.context.eventBus.addConnection(this.dappAccessRequestConnection);
-    this.context.eventBus.addConnection(this.exposeDappRequestConnection);
+  get views() {
+    return {
+      latestUserWallet: () => this.latestUserWalletListener.latest,
+      nodeBackground: () => this.nodeBackgroundListener.latest,
+      wallets: () => this.walletsListener.latest
+    };
+  }
+  get walletsListener() {
+    return assertEx18(this._walletsListener, () => "Wallets listener not set");
+  }
+  cleanupListeners() {
+    this.walletsListener.cleanupListeners();
+    this.latestUserWalletListener.cleanupListeners();
   }
   /**
-   * 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
+   * start listeners
    */
-  getUser() {
-    return this.context.user;
-  }
-  async postRegistrationHandlers(registeredDapp) {
-    if (registeredDapp.dapp) {
-      if (isRegisteredDappExposedDappSet(registeredDapp)) {
-        this.registeredExposedDappSets.add(registeredDapp);
-        const exposeIntent = DappIntentCaller.buildIntent(
-          DappIntentCaller.OsDappName,
-          DappIntentTypes2.Launch,
-          registeredDapp.dapp.config.name,
-          DappMode3.Exposed
-        );
-        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, { payloads: [registeredDapp.dapp.config, exposeIntent] });
-      }
-      if (isRegisteredDappAccessDappSet2(registeredDapp)) {
-        this.registeredAccessDappSets.add(registeredDapp);
-        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, { payloads: registeredDapp.dapp.accessors });
-      }
-    }
+  async start() {
+    const archivist = await this.getOsSettingsArchivist();
+    const diviner = await this.getOsSettingsPayloadDiviner();
+    this._walletsListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await OsSettingsQueries.getWallets(diviner),
+      idFunction: isWalletSeedPhrase
+    });
+    this._latestUserWalletListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await OsSettingsQueries.getLatestUserWallet(diviner),
+      idFunction: isWalletSeedPhrase
+    });
+    this._nodeBackgroundListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await OsSettingsQueries.getNodeBackground(diviner),
+      idFunction: isNodeBackground
+    });
   }
 };
 
 // src/classes/signer/Signers.ts
-import { assertEx as assertEx20 } from "@xylabs/assert";
-import { HDWallet as HDWallet6 } from "@xyo-network/account";
+import { assertEx as assertEx19 } from "@xylabs/assert";
+import { HDWallet as HDWallet5 } from "@xyo-network/account";
 var Signers = class {
   _paths;
   _signerAccounts;
@@ -2688,13 +2609,13 @@ var Signers = class {
     this._signerAccounts = /* @__PURE__ */ new Map();
   }
   get paths() {
-    return assertEx20(this._paths, () => "Paths not initialized");
+    return assertEx19(this._paths, () => "Paths not initialized");
   }
   get signerAccounts() {
-    return assertEx20(this._signerAccounts, () => "Signer accounts not initialized");
+    return assertEx19(this._signerAccounts, () => "Signer accounts not initialized");
   }
   get walletStore() {
-    return assertEx20(this._walletStore, () => "Wallet store not initialized");
+    return assertEx19(this._walletStore, () => "Wallet store not initialized");
   }
   getSigner(walletKind, signer) {
     return this.signerAccounts.get(walletKind)?.get(signer);
@@ -2710,12 +2631,12 @@ var Signers = class {
     }
   }
   async initializeSigners(walletKindName, signerName, path) {
-    assertEx20(signerName, () => "Name not found in signer paths");
-    assertEx20(path, () => "Path not found in signer paths");
-    const phrase = assertEx20(await this.walletStore.get(walletKindName), () => `Wallet not found: ${walletKindName}`);
+    assertEx19(signerName, () => "Name not found in signer paths");
+    assertEx19(path, () => "Path not found in signer paths");
+    const phrase = assertEx19(await this.walletStore.get(walletKindName), () => `Wallet not found: ${walletKindName}`);
     if (path) {
       const signerMap = this.signerAccounts.get(walletKindName) ?? /* @__PURE__ */ new Map();
-      const wallet = await HDWallet6.fromPhrase(phrase);
+      const wallet = await HDWallet5.fromPhrase(phrase);
       const derivedWallet = await wallet.derivePath(path);
       signerMap.set(signerName, derivedWallet);
       this.signerAccounts.set(walletKindName, signerMap);
@@ -2751,7 +2672,7 @@ var loadOsNode = async (osWallet, locator) => {
 };
 
 // src/stack/Base.ts
-import { assertEx as assertEx21 } from "@xylabs/assert";
+import { assertEx as assertEx20 } from "@xylabs/assert";
 import { forget as forget3 } from "@xylabs/forget";
 import { BaseEmitter as BaseEmitter3 } from "@xyo-network/module-abstract";
 import { isModuleInstance } from "@xyo-network/module-model";
@@ -2773,20 +2694,20 @@ var StackBase = class extends BaseEmitter3 {
   constructor(context, adapterSet, stackNodeModuleId) {
     super({});
     this._context = context;
-    this._adapterSet = adapterSet(assertEx21(this.context.kernel, "Kernel access required"));
+    this._adapterSet = adapterSet(assertEx20(this.context.kernel, "Kernel access required"));
     this._stackNodeModuleId = stackNodeModuleId;
   }
   get adapterSet() {
-    return assertEx21(this._adapterSet, () => `${this.stackNodeModuleId} adapters not initialized`);
+    return assertEx20(this._adapterSet, () => `${this.stackNodeModuleId} adapters not initialized`);
   }
   get context() {
-    return assertEx21(this._context, () => `${this.stackNodeModuleId} stack context not initialized`);
+    return assertEx20(this._context, () => `${this.stackNodeModuleId} stack context not initialized`);
   }
   get stack() {
-    return assertEx21(this._stack, () => `${this.stackNodeModuleId} stack node not initialized`);
+    return assertEx20(this._stack, () => `${this.stackNodeModuleId} stack node not initialized`);
   }
   get stackNodeModuleId() {
-    return assertEx21(this._stackNodeModuleId, () => "Stack node module identifier not initialized");
+    return assertEx20(this._stackNodeModuleId, () => "Stack node module identifier not initialized");
   }
   initialize() {
     this.assignStack();
@@ -2845,7 +2766,7 @@ var StackBase = class extends BaseEmitter3 {
     forget3(assign());
   }
   async getStackNode() {
-    const mod = assertEx21(await this.context.root.resolve(this.stackNodeModuleId), () => `${this.stackNodeModuleId} not found`);
+    const mod = assertEx20(await this.context.root.resolve(this.stackNodeModuleId), () => `${this.stackNodeModuleId} not found`);
     return asAttachableNodeInstance(mod, () => `${this.stackNodeModuleId} not a NodeInstance`);
   }
   async handleDriverReady(node) {
@@ -2903,7 +2824,7 @@ var StackManager = class {
 import { ExposedNodeOuterNodeName, PubSubBridgeNodeNodeName } from "@xyo-network/os-model";
 
 // src/adapter/Base.ts
-import { assertEx as assertEx22 } from "@xylabs/assert";
+import { assertEx as assertEx21 } from "@xylabs/assert";
 import { forget as forget4 } from "@xylabs/forget";
 import { asArchivistInstance as asArchivistInstance6 } from "@xyo-network/archivist";
 import { BaseEmitter as BaseEmitter4 } from "@xyo-network/module-abstract";
@@ -2919,7 +2840,7 @@ var NodeAdapterBase = class extends BaseEmitter4 {
   initialized = false;
   _id = "";
   get id() {
-    return assertEx22(this._id, () => "NodeAdapterBase id not initialized");
+    return assertEx21(this._id, () => "NodeAdapterBase id not initialized");
   }
   async start() {
     try {
@@ -2949,7 +2870,7 @@ var NodeAdapterBase = class extends BaseEmitter4 {
     });
   }
   async getEventsArchivist() {
-    const mod = assertEx22(await (await this.kernel.getNode()).resolve("KernelNode:ModuleEvents"), () => "KernelNode:ModuleEvents not found");
+    const mod = assertEx21(await (await this.kernel.getNode()).resolve("KernelNode:ModuleEvents"), () => "KernelNode:ModuleEvents not found");
     return asArchivistInstance6(mod, () => `${mod.id} is not an archivist`);
   }
   validateAndReturnDriver() {
@@ -3021,7 +2942,7 @@ var OsXyoPublicNetworkAdapters = (kernel) => [
 ];
 
 // src/stack/OsPubSubNetworkStack.ts
-import { assertEx as assertEx23 } from "@xylabs/assert";
+import { assertEx as assertEx22 } from "@xylabs/assert";
 import { asAttachableNodeInstance as asAttachableNodeInstance3, asNodeInstance as asNodeInstance2 } from "@xyo-network/node-model";
 import { ExposedNodeOuterNodeName as ExposedNodeOuterNodeName2, PubSubBridgeNodeNodeName as PubSubBridgeNodeNodeName2 } from "@xyo-network/os-model";
 var OsPubSubNetworkStack = class extends StackBase {
@@ -3043,7 +2964,7 @@ var OsPubSubNetworkStack = class extends StackBase {
     this.on("initialized", () => this.busConnection.emit(OsPubSubNetworkReadyEvent, {}));
     super.on("driverReady", async ({ node }) => {
       if (node.id === PubSubBridgeNodeNodeName2) {
-        const httpBridge = assertEx23(await node.resolve("NsHttpBridge"), () => "HttpBridge not found");
+        const httpBridge = assertEx22(await node.resolve("NsHttpBridge"), () => "HttpBridge not found");
         const xnsNode = asNodeInstance2(await httpBridge.resolve("XNS"));
         if (xnsNode) {
           const initializedXns = await initializeXns(xnsNode);
@@ -3056,7 +2977,7 @@ var OsPubSubNetworkStack = class extends StackBase {
     super.on("driverReady", async ({ node }) => {
       if (node.id === ExposedNodeOuterNodeName2) {
         this._exposedNodeOuter = node;
-        const mod = assertEx23(await node.resolve("ExposedNode"), () => "ExposedNode not found");
+        const mod = assertEx22(await node.resolve("ExposedNode"), () => "ExposedNode not found");
         const exposedNode = asAttachableNodeInstance3(mod, () => "ExposedNode is not a node");
         this._exposedNode = exposedNode;
       }
@@ -3164,7 +3085,7 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return getXyOsGlobal();
   }
   get bios() {
-    return assertEx24(this.params.kernel?.bios, () => "Missing bios");
+    return assertEx23(this.params.kernel?.bios, () => "Missing bios");
   }
   get exposedNode() {
     return this.stackManager.getStack("osPubSubNetworkStack")?.exposedNode;
@@ -3173,7 +3094,7 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return this.stackManager.getStack("osPubSubNetworkStack")?.exposedNodeOuter;
   }
   get kernel() {
-    return assertEx24(this.params.kernel, () => "Missing kernel");
+    return assertEx23(this.params.kernel, () => "Missing kernel");
   }
   get locator() {
     return this._locator;
@@ -3203,7 +3124,7 @@ var XyOs = class _XyOs extends XyOsContextBase {
       if (this.kernel?.status !== "booted") {
         throw new Error("Kernel not booted");
       }
-      assertEx24(this._root === void 0, () => "XyOs already booted");
+      assertEx23(this._root === void 0, () => "XyOs already booted");
       const [root] = await _XyOs.monitor(async () => await loadOsNode(wallet, fullLocator), { name: "Load XyOs" });
       this._root = root;
       this.stackManager.initialize(this);
@@ -3220,13 +3141,13 @@ var XyOs = class _XyOs extends XyOsContextBase {
     return this.dappRegistrationService.getParamsForRegisteredDapp(dappId);
   }
   getStack(stackName) {
-    return assertEx24(this.stackManager.getStack(stackName), () => `Stack not found: ${stackName}`);
+    return assertEx23(this.stackManager.getStack(stackName), () => `Stack not found: ${stackName}`);
   }
   async monitor(fn, eventConfig) {
     return await _XyOs.monitor(fn, eventConfig);
   }
   shutdown() {
-    assertEx24(this._root !== void 0, () => "XyOs not booted");
+    assertEx23(this._root !== void 0, () => "XyOs not booted");
     this._root = void 0;
     this.stackManager.stop();
   }
@@ -3243,7 +3164,7 @@ var RunningDappCache = class _RunningDappCache {
         const existingWindowDappSet = _RunningDappCache.get(dappId);
         if (existingWindowDappSet) {
           console.debug("[DEBUG]", `RunningDappCache, using existing node for ${dappId}`);
-          const existingDappContext = assertEx25(existingWindowDappSet.context, () => "No context found in existing dapp node");
+          const existingDappContext = assertEx24(existingWindowDappSet.context, () => "No context found in existing dapp node");
           await DappContextCreator.primeDappArchivist(existingDappContext, xyOs, dappId);
           return existingWindowDappSet;
         }
@@ -3274,7 +3195,7 @@ var AccessNodeQueries = class {
     this.registeredDappAccess = registeredDappAccess;
   }
   get nameServiceNamesAccessNode() {
-    return assertEx26(RunningDappAccessCache.get(this.registeredDappAccess.registeringDappId), () => "No access node found");
+    return assertEx25(RunningDappAccessCache.get(this.registeredDappAccess.registeringDappId), () => "No access node found");
   }
   // Refresh the archivist in the dapp
   async refresh() {
@@ -3290,7 +3211,7 @@ var AccessNodeQueries = class {
   }
   async getArchivistFromDappNode() {
     const archivistPath = this.accessRequest?.destinationArchivist || "DappArchivist";
-    const mod = assertEx26(await this.xyOsContext.root.resolve(archivistPath), () => `Unable to find archivist at ${archivistPath}`);
+    const mod = assertEx25(await this.xyOsContext.root.resolve(archivistPath), () => `Unable to find archivist at ${archivistPath}`);
     return asArchivistInstance7(mod, () => `Module at ${archivistPath} is not an archivist`);
   }
   async getPayloadsFromAccessNode() {
@@ -3303,7 +3224,7 @@ var AccessNodeQueries = class {
     await archivist.insert(payloads);
   }
   async resolveArchivistFromAccessNode() {
-    const archivist = assertEx26(
+    const archivist = assertEx25(
       await this.nameServiceNamesAccessNode.resolve("PublicXnsArchivist"),
       () => "Unable to find archivist at PublicXnsArchivist"
     );
@@ -3312,7 +3233,7 @@ var AccessNodeQueries = class {
 };
 
 // src/access-interfaces/registered-names/helpers/resource/AbstractXnsCaller.ts
-import { assertEx as assertEx27 } from "@xylabs/assert";
+import { assertEx as assertEx26 } from "@xylabs/assert";
 import { asArchivistInstance as asArchivistInstance8 } from "@xyo-network/archivist-model";
 import { asDivinerInstance as asDivinerInstance5 } from "@xyo-network/diviner-model";
 var XnsArchivistPayloadDivinerModuleName = "XnsArchivistPayloadDiviner";
@@ -3327,7 +3248,7 @@ var AbstractXnsCaller = class {
    */
   async getXnsArchivist(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistModuleName}` : XnsArchivistModuleName;
-    const mod = assertEx27(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
+    const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
     return asArchivistInstance8(mod, () => `${fullyQualifiedPath} is not an archivist`);
   }
   /**
@@ -3335,7 +3256,7 @@ var AbstractXnsCaller = class {
    */
   async getXnsArchivistPayloadDiviner(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistPayloadDivinerModuleName}` : XnsArchivistPayloadDivinerModuleName;
-    const mod = assertEx27(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
+    const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
     return asDivinerInstance5(mod, () => `${fullyQualifiedPath} is not an diviner`);
   }
   /**
@@ -3343,13 +3264,13 @@ var AbstractXnsCaller = class {
    */
   async getXnsRegistrationsArchivist(pathPrefix) {
     const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsRegistrationsArchivistModuleName}` : XnsRegistrationsArchivistModuleName;
-    const mod = assertEx27(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
+    const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
     return asArchivistInstance8(mod, () => `${fullyQualifiedPath} is not an archivist`);
   }
 };
 
 // src/access-interfaces/registered-names/helpers/resource/RegistrationsResource.ts
-import { assertEx as assertEx28 } from "@xylabs/assert";
+import { assertEx as assertEx27 } from "@xylabs/assert";
 import { isTemporalIndexingDivinerResultIndex } from "@xyo-network/diviner-temporal-indexing-model";
 
 // src/access-interfaces/registered-names/helpers/resource/RegistrationsResourceQueries.ts
@@ -3378,7 +3299,7 @@ var XnsRegistrationsResource = class extends AbstractXnsCaller {
   }
   _allRegistrations;
   get allRegistrations() {
-    return assertEx28(this._allRegistrations);
+    return assertEx27(this._allRegistrations);
   }
   get subscriptions() {
     return { allRegistrations: (cb) => this.allRegistrations.subscribe(cb) };
@@ -3471,7 +3392,7 @@ var profileModuleEvents = (mod) => {
 };
 
 // src/PubSubBridgeCaller.ts
-import { assertEx as assertEx29 } from "@xylabs/assert";
+import { assertEx as assertEx28 } from "@xylabs/assert";
 import { asBridgeInstance } from "@xyo-network/bridge-model";
 import { BridgedPubSubModuleName } from "@xyo-network/os-model";
 var PubSubBridgeCaller = class {
@@ -3492,7 +3413,7 @@ var PubSubBridgeCaller = class {
     }
   }
   async getPubSubBridge() {
-    const mod = assertEx29(await this.node.resolve(BridgedPubSubModuleName), () => `${BridgedPubSubModuleName} not found`);
+    const mod = assertEx28(await this.node.resolve(BridgedPubSubModuleName), () => `${BridgedPubSubModuleName} not found`);
     return asBridgeInstance(mod, () => `${BridgedPubSubModuleName} is not a bridge`);
   }
 };