@xyo-network/os-runtime 3.0.18 → 3.1.1

package/dist/node/index.mjs

@@ -0,0 +1,3520 @@
+// src/access-interfaces/registered-names/helpers/AccessNodeQueries.ts
+import { assertEx as assertEx25 } from "@xylabs/assert";
+import { asArchivistInstance as asArchivistInstance7 } from "@xyo-network/archivist-model";
+
+// src/classes/cache/RunningAccessDappCache.ts
+var RunningDappAccessCache = class {
+  static _cache = {};
+  static get(key) {
+    return this._cache[key];
+  }
+  static has(key) {
+    return key ? !!this._cache[key] : false;
+  }
+  static set(key, value) {
+    this._cache[key] = value;
+  }
+};
+
+// src/classes/cache/RunningDappCache.ts
+import { assertEx as assertEx24 } from "@xylabs/assert";
+import { Mutex as Mutex3 } from "async-mutex";
+
+// src/XyOs.ts
+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";
+
+// src/classes/dapp/access/Caller.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
+import { asNodeInstance } from "@xyo-network/node-model";
+import { isRegisteredDappAccessDappSet } from "@xyo-network/os-model";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+
+// src/OsCallerBase.ts
+import { assertEx } from "@xylabs/assert";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { asDivinerInstance } from "@xyo-network/diviner-model";
+var DappsArchivistModuleName = "DappsArchivist";
+var DappsArchivistDevelopmentModuleName = `${DappsArchivistModuleName}Development`;
+var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
+var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
+var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
+var OsCallerBase = class {
+  constructor(context) {
+    this.context = context;
+  }
+  // Get the dapps archivist
+  async getDappsArchivist() {
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistModuleName), () => `${DappsArchivistModuleName} not found`);
+    return asArchivistInstance(mod, () => `${DappsArchivistModuleName} is not an archivist`);
+  }
+  // Get the dapps archivist development
+  async getDappsArchivistDevelopment() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
+      () => `${DappsArchivistDevelopmentModuleName} not found`
+    );
+    return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`);
+  }
+  // Get the dapps archivist payload diviner
+  async getDappsArchivistPayloadDiviner() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
+      () => `${DappsArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`);
+  }
+  // Get the dapps archivist payload diviner development
+  async getDappsArchivistPayloadDivinerDevelopment() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
+      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`
+    );
+    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`);
+  }
+  // Get the registered dapp interfaces archivist
+  async getRegisteredDappInterfacesArchivist() {
+    const mod = assertEx(
+      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
+      () => `${RegisteredDappInterfacesArchivistModuleName} not found`
+    );
+    return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`);
+  }
+};
+
+// src/classes/dapp/access/Caller.ts
+var DappAccessCaller = class extends OsCallerBase {
+  constructor(context, registeredDapps, allowedNames, xnsNodeUrl, xnsNetwork, platformLocator = new ModuleFactoryLocator()) {
+    super(context);
+    this.registeredDapps = registeredDapps;
+    this.allowedNames = allowedNames;
+    this.xnsNodeUrl = xnsNodeUrl;
+    this.xnsNetwork = xnsNetwork;
+    this.platformLocator = platformLocator;
+  }
+  async start() {
+    const registeredDappAccessDappSets = this.registeredDapps.filter(isRegisteredDappAccessDappSet);
+    for (const registeredDappSet of registeredDappAccessDappSets) {
+      const context = await this.buildRunningDappCache(registeredDappSet, this.allowedNames);
+      for (const dappAccessor of registeredDappSet.dapp.accessors) {
+        await this.cacheAccessNode(dappAccessor, context);
+        await this.saveRegisteredDappInterfaces(dappAccessor);
+      }
+    }
+  }
+  async buildRunningDappCache(registeredDappSet, allowedNames) {
+    const { context } = await RunningDappCache.findOrCreate(registeredDappSet.dapp, this.context, allowedNames, this.xnsNodeUrl, this.xnsNetwork);
+    if (!context) throw new Error("Dapp context not found");
+    return context;
+  }
+  async cacheAccessNode(dappAccessor, context) {
+    const accessNodeId = dappAccessor.rootModuleId;
+    const accessNodeModule = assertEx2(await context.root.resolve(accessNodeId), () => "Access Node Module not found");
+    const accessNode = asNodeInstance(accessNodeModule, () => "Access Node Module is not a NodeInstance");
+    RunningDappAccessCache.set(dappAccessor.registeringDappId, accessNode);
+  }
+  async saveRegisteredDappInterfaces(registeredDappAccess) {
+    const archivist = await this.getRegisteredDappInterfacesArchivist();
+    const hash = await PayloadBuilder.dataHash(registeredDappAccess);
+    const [existing] = await archivist.get([hash]);
+    if (existing) return;
+    await archivist.insert([registeredDappAccess]);
+    console.debug("[DEBUG] -", `Registered ${registeredDappAccess.registeringDappId} with ${registeredDappAccess.name} interface`);
+  }
+};
+
+// src/classes/dapp/access/Queries.ts
+import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
+import { DappAccessRequestSchema, RegisteredDappAccessSchema } from "@xyo-network/os-model";
+var noResults = [];
+var DappAccessRequestQueries = {
+  async getAccessRequests(diviner) {
+    const query = {
+      limit: 1,
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappAccessRequestSchema]
+    };
+    const results = await diviner.divine([query]);
+    if (results.length === 0) {
+      return noResults;
+    }
+    return results;
+  },
+  async getRegisteredInterfaces(diviner) {
+    const query = {
+      limit: 1,
+      schema: PayloadDivinerQuerySchema,
+      schemas: [RegisteredDappAccessSchema]
+    };
+    const results = await diviner.divine([query]);
+    if (results.length === 0) {
+      return noResults;
+    }
+    return results;
+  }
+};
+
+// src/classes/dapp/access/Resource.ts
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { isDappAccessRequestWithMeta, isRegisteredDappAccess } from "@xyo-network/os-model";
+
+// src/DappCallerBase.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { toJsonString } from "@xylabs/object";
+import { asArchivistInstance as asArchivistInstance2 } from "@xyo-network/archivist-model";
+import { asDivinerInstance as asDivinerInstance2 } from "@xyo-network/diviner-model";
+var DappArchivistModuleName = "DappArchivist";
+var IntentArchivistModuleName = "IntentArchivist";
+var IntentArchivistPayloadDivinerModuleName = "IntentArchivistPayloadDiviner";
+var DappArchivistPayloadDivinerModuleName = "DappArchivistPayloadDiviner";
+var DappCallerBase = class {
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Get the DappArchivist
+   */
+  async getDappArchivist() {
+    const mod = assertEx3(
+      await this.context.root.resolve(DappArchivistModuleName),
+      () => `${DappArchivistModuleName} not found [${toJsonString(this.context.root.publicChildren())}]`
+    );
+    return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`);
+  }
+  /**
+   * Get the DappArchivistPayloadDiviner
+   */
+  async getDappArchivistPayloadDiviner() {
+    const mod = assertEx3(
+      await this.context.root.resolve(DappArchivistPayloadDivinerModuleName),
+      () => `${DappArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`);
+  }
+  /**
+   * Get the IntentArchivist
+   */
+  async getDappIntentArchivist() {
+    const mod = assertEx3(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`);
+    return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`);
+  }
+  // Get the IntentArchivistPayloadDiviner
+  async getDappIntentArchivistPayloadDiviner() {
+    const mod = assertEx3(
+      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
+      () => `${IntentArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`);
+  }
+};
+
+// src/lib/initializeXns.ts
+import { asDivinerInstance as asDivinerInstance3 } from "@xyo-network/diviner-model";
+import { ResolveHelper } from "@xyo-network/module-model";
+import { NameRegistrarTransformer } from "@xyo-network/module-resolver";
+var initializeXns = async (xnsNode) => {
+  if (ResolveHelper.transformers.length === 0) {
+    const registrarDiviner = asDivinerInstance3(await xnsNode?.resolve("AddressRecords:AddressRecordIndexDiviner"));
+    if (registrarDiviner) {
+      const transformer = new NameRegistrarTransformer(registrarDiviner, "xyo");
+      ResolveHelper.transformers = [transformer];
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/lib/isPayload.ts
+import { AsObjectFactory } from "@xylabs/object";
+var isObject = (x) => {
+  return typeof x === "object" && !Array.isArray(x);
+};
+var isAnyPayload = (obj) => {
+  if (isObject(obj)) {
+    return typeof obj.schema === "string";
+  }
+  return false;
+};
+var isPayload = (schema) => (obj) => {
+  if (isAnyPayload(obj)) {
+    return schema.includes(obj.schema);
+  }
+  return false;
+};
+var asPayload = (schema) => AsObjectFactory.create(isPayload(schema));
+
+// src/lib/ModuleNames.ts
+var DevelopArchivist = "DevelopArchivist";
+var NodeSentinel = "NodeSentinel";
+
+// src/lib/ModuleAccountPaths.ts
+var RemoteNodeArchivistOffsetPaths = {
+  Kerplunk: { [DevelopArchivist]: "118" },
+  Local: { [DevelopArchivist]: "115" },
+  Main: { [DevelopArchivist]: "121" }
+};
+var ModuleOffsetPaths = {
+  IdWitness: "1",
+  DomainWitness: "2",
+  LocationWitness: "3",
+  SchemaWitness: "4",
+  CryptoCardsGameWitness: "5",
+  CryptoCardsMoveWitness: "6",
+  EthereumGasEtherchainV2Witness: "7",
+  CoingeckoCryptoMarketWitness: "8",
+  UniswapCryptoMarketWitness: "9",
+  EthereumGasEtherscanWitness: "10",
+  [NodeSentinel]: "11",
+  [DevelopArchivist]: "12",
+  BowserSystemInfoPluginWitness: "13"
+};
+
+// src/lib/NameTransforms.ts
+var NameTransforms = class _NameTransforms {
+  constructor(value) {
+    this.value = value;
+  }
+  static deSlug(value) {
+    return value.replaceAll("-", " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  static moduleName(value) {
+    return value.replaceAll(" ", "");
+  }
+  static slug(value) {
+    return value.replaceAll(" ", "-").toLocaleLowerCase();
+  }
+  deSlug() {
+    return _NameTransforms.deSlug(this.value);
+  }
+  moduleName() {
+    return _NameTransforms.moduleName(this.value);
+  }
+  slug() {
+    return _NameTransforms.slug(this.value);
+  }
+};
+
+// src/lib/PayloadStore.ts
+var PayloadStore = class {
+  constructor(archivist) {
+    this.archivist = archivist;
+  }
+  latest = [];
+  deleteListeners = [];
+  insertListeners = [];
+  listeners = [];
+  /**
+   * Initialize listeners on the archivist that update class member variables when new payloads are inserted
+   */
+  static async create({
+    archivist,
+    getLatest,
+    idFunction
+  }) {
+    const instance = new this(archivist);
+    const insertListener = async ({ payloads }) => {
+      if (payloads.some(idFunction)) {
+        instance.latest = await getLatest();
+        instance.emitChange();
+      }
+    };
+    const deleteListener = async () => {
+      instance.latest = await getLatest();
+      instance.emitChange();
+    };
+    const weakRefInsertListener = new WeakRef(insertListener);
+    const weakRefDeleteListener = new WeakRef(deleteListener);
+    const insertListenerRef = weakRefInsertListener.deref();
+    const deleteListenerRef = weakRefDeleteListener.deref();
+    if (insertListenerRef) instance.archivist.on("inserted", insertListenerRef);
+    if (deleteListenerRef) instance.archivist.on("deleted", deleteListenerRef);
+    instance.insertListeners.push(weakRefInsertListener);
+    instance.deleteListeners.push(weakRefDeleteListener);
+    instance.latest = await getLatest();
+    return instance;
+  }
+  /**
+   * Remove all listeners and reset their class members
+   */
+  cleanupListeners() {
+    this.removeListeners(this.insertListeners, "inserted");
+    this.removeListeners(this.deleteListeners, "deleted");
+    this.insertListeners = [];
+    this.deleteListeners = [];
+  }
+  /**
+   * Get the current value of the store
+   */
+  getSnapshot() {
+    return this.latest;
+  }
+  /**
+   * Add a call back function that is invoked when new Payloads are inserted
+   *
+   * @param  {PayloadListener} onStoreChange
+   */
+  subscribe(onStoreChange) {
+    this.listeners.push(onStoreChange);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== onStoreChange);
+    };
+  }
+  emitChange() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  removeListeners(listeners, eventName) {
+    for (const listener of listeners) {
+      const listenerRef = listener.deref();
+      if (listenerRef) this.archivist.off(eventName, listenerRef);
+    }
+  }
+};
+
+// src/lib/tokenPlacesSplit.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+var tokenPlacesSplit = (value, places) => {
+  assertEx4(places >= 0, () => "Places has to be >= 0");
+  const factor = BigInt(10 ** Math.abs(places));
+  const remainder = value % factor;
+  const wholeValue = value / factor;
+  return [wholeValue, remainder];
+};
+var tokenPlacesSplitString = (value, places) => {
+  if (value === void 0) {
+    return "-";
+  }
+  const [wholeValue, remainder] = tokenPlacesSplit(value, places);
+  return `${wholeValue}.${remainder.toString().padStart(Math.abs(places), "0")}`;
+};
+
+// src/classes/dapp/access/Resource.ts
+var DappAccessRequestResource = class extends DappCallerBase {
+  _accessRequestListener;
+  _registeredInterfacesListener;
+  constructor(context) {
+    super(context);
+  }
+  get accessRequestListener() {
+    return assertEx5(this._accessRequestListener, () => "accessRequests note found");
+  }
+  get registeredInterfacesListener() {
+    return assertEx5(this._registeredInterfacesListener, () => "registeredInterfaces note found");
+  }
+  get subscriptions() {
+    return {
+      accessRequests: (cb) => this.accessRequestListener.subscribe(cb),
+      registeredInterfaces: (cb) => this.registeredInterfacesListener.subscribe(cb)
+    };
+  }
+  get views() {
+    return {
+      accessRequests: () => this.accessRequestListener.getSnapshot(),
+      registeredInterfaces: () => this.registeredInterfacesListener.getSnapshot()
+    };
+  }
+  cleanupListeners() {
+    this.accessRequestListener.cleanupListeners();
+  }
+  // Start the resource
+  async start() {
+    const archivist = await this.getDappArchivist();
+    const diviner = await this.getDappArchivistPayloadDiviner();
+    this._accessRequestListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await DappAccessRequestQueries.getAccessRequests(diviner),
+      idFunction: isDappAccessRequestWithMeta
+    });
+    this._registeredInterfacesListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await DappAccessRequestQueries.getRegisteredInterfaces(diviner),
+      idFunction: isRegisteredDappAccess
+    });
+  }
+};
+
+// src/classes/dapp/DefaultsResource.ts
+import { assertEx as assertEx6 } from "@xylabs/assert";
+import { isDappInjectableParams, isNodeOsInfo } from "@xyo-network/os-model";
+
+// src/DefaultsQueries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema2 } from "@xyo-network/diviner-payload-model";
+import { DappInjectableParamsSchema, NodeOsInfoSchema } from "@xyo-network/os-model";
+var DappDefaultsResourceQueries = {
+  async getDappInjectableParamsFromRoute(diviner) {
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema2,
+      schemas: [DappInjectableParamsSchema],
+      source: "route"
+    };
+    return await diviner.divine([query]);
+  },
+  async getNodeOsInfo(diviner) {
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema2,
+      schemas: [NodeOsInfoSchema]
+    };
+    return await diviner.divine([query]);
+  }
+};
+
+// src/classes/dapp/DefaultsResource.ts
+var DappDefaultsResource = class extends DappCallerBase {
+  _dappInjectableParamsFromRouteListener;
+  _nodeOsInfoListener;
+  constructor(context) {
+    super(context);
+  }
+  get dappInjectableParamsFromRouteListener() {
+    return assertEx6(this._dappInjectableParamsFromRouteListener, () => "DappInjectableParams not found");
+  }
+  get nodeOsInfoListener() {
+    return assertEx6(this._nodeOsInfoListener, () => "NodeOsInfo not found");
+  }
+  get subscriptions() {
+    return {
+      dappInjectableParamsFromRoute: (cb) => this.dappInjectableParamsFromRouteListener.subscribe(cb),
+      nodeOsInfo: (cb) => this.nodeOsInfoListener.subscribe(cb)
+    };
+  }
+  get views() {
+    return {
+      dappInjectableParamsFromRoute: () => this.dappInjectableParamsFromRouteListener.getSnapshot(),
+      nodeOsInfo: () => this.nodeOsInfoListener.getSnapshot()
+    };
+  }
+  cleanupListeners() {
+    this.nodeOsInfoListener.cleanupListeners();
+  }
+  async start() {
+    const archivist = await this.getDappArchivist();
+    const diviner = await this.getDappArchivistPayloadDiviner();
+    this._nodeOsInfoListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner),
+      idFunction: isNodeOsInfo
+    });
+    this._dappInjectableParamsFromRouteListener = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner),
+      idFunction: isDappInjectableParams
+    });
+  }
+};
+
+// src/classes/lib/Insertable.ts
+var createInsertable = (insertable, ...params) => new insertable(...params);
+
+// src/classes/menu/Caller.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema5 } from "@xyo-network/diviner-payload-model";
+import {
+  DappInjectableParamsSchema as DappInjectableParamsSchema3,
+  DappNavItemSelectionSchema
+} from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+
+// src/Caller.ts
+import { assertEx as assertEx8 } from "@xylabs/assert";
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema4 } from "@xyo-network/diviner-payload-model";
+import {
+  DappAccessRequestSchema as DappAccessRequestSchema2,
+  DappInjectableParamsSchema as DappInjectableParamsSchema2,
+  DappIntentTypes,
+  DappMode as DappMode2,
+  RegisteredDappAccessSchema as RegisteredDappAccessSchema2
+} from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+
+// src/intent/Caller.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema3 } from "@xyo-network/diviner-payload-model";
+import { DappIntentSchema, DappMode } from "@xyo-network/os-model";
+var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
+  static OsDappName = "XyOs";
+  constructor(context) {
+    super(context);
+  }
+  /**
+   * Build a new intent
+   * @param  {DappId} sourceDappId
+   * @param  {DappIntentTypes} intent
+   * @param  {DappId} targetDappId
+   * @param  {DappMode} targetMode
+   * @param  {DappIntent['params']} params?
+   * @returns DappIntent
+   */
+  static buildIntent(sourceDappId, intent, targetDappId, targetMode = DappMode.Window, params) {
+    return {
+      intent,
+      params: params || "",
+      schema: DappIntentSchema,
+      sourceDappId,
+      targetDappId,
+      targetMode: targetMode || DappMode.Window,
+      timestamp: Date.now()
+    };
+  }
+  // Add a new intent
+  async addIntent(id, intent, mode) {
+    const intentArchivist = await this.getDappIntentArchivist();
+    const newIntent = _DappIntentCaller.buildIntent(id, intent, mode);
+    await intentArchivist.insert([newIntent]);
+  }
+  // Get all intents
+  async allIntents() {
+    const archivist = await this.getDappIntentArchivist();
+    return await archivist.all();
+  }
+  // Get the latest intent saved to the archivist
+  async latestIntent() {
+    const archivist = await this.getDappIntentArchivist();
+    return (await archivist.all()).at(-1);
+  }
+  // Get the latest intent for a dapp
+  async latestIntentForDappName(dappName) {
+    const diviner = await this.getDappIntentArchivistPayloadDiviner();
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema3,
+      sourceDappId: dappName
+    };
+    return await diviner.divine([query]);
+  }
+};
+
+// src/intent/Resource.ts
+import { assertEx as assertEx7 } from "@xylabs/assert";
+import { isDappIntent } from "@xyo-network/os-model";
+var NO_RESULTS = [];
+var DappIntentResource = class extends DappCallerBase {
+  _allDappIntents;
+  _latestDappIntent;
+  constructor(context) {
+    super(context);
+  }
+  get allDappIntents() {
+    return assertEx7(this._allDappIntents, () => "allDappIntents not set");
+  }
+  get latestDappIntent() {
+    return assertEx7(this._latestDappIntent, () => "latestDappIntent not set");
+  }
+  get subscriptions() {
+    return {
+      allDappIntents: (cb) => this.allDappIntents.subscribe(cb),
+      latestDappIntent: (cb) => this.latestDappIntent.subscribe(cb)
+    };
+  }
+  get views() {
+    return {
+      allDappIntents: () => this.allDappIntents.getSnapshot(),
+      latestDappIntent: () => this.latestDappIntent.getSnapshot()
+    };
+  }
+  cleanupListeners() {
+    this.latestDappIntent.cleanupListeners();
+    this.allDappIntents.cleanupListeners();
+  }
+  async start() {
+    const archivist = await this.getDappIntentArchivist();
+    this._allDappIntents = await PayloadStore.create({
+      archivist,
+      getLatest: async () => await archivist.all(),
+      idFunction: isDappIntent
+    });
+    this._latestDappIntent = await PayloadStore.create({
+      archivist,
+      getLatest: async () => {
+        const all = await archivist.all();
+        const result = all.length > 0 ? [all.at(-1)] : NO_RESULTS;
+        return result;
+      },
+      idFunction: isDappIntent
+    });
+  }
+};
+
+// src/Caller.ts
+var DappCaller = class extends DappCallerBase {
+  constructor(context) {
+    super(context);
+  }
+  /**
+   * Add payloads to the dapp archivist
+   * @param  {Payload[]} payloads
+   * @param  {Boolean} force
+   */
+  async addPayloadsToDappArchivist(payloads = [], force = false) {
+    const dappArchivist = await this.getDappArchivist();
+    if (force) {
+      await dappArchivist.insert(payloads);
+    } else {
+      for (const payload of payloads) {
+        const hash = await PayloadBuilder2.dataHash(payload);
+        const [existing] = await dappArchivist.get([hash]);
+        if (existing) continue;
+        await dappArchivist.insert([payload]);
+      }
+    }
+  }
+  /**
+   * Build Access Request
+   * @param  {DappAccessRequest['mode']} mode
+   * @param  {Hash} registeredDappAccessHash
+   * @param  {string} requestingDappId
+   * @param  {string | undefined} destinationArchivist
+   */
+  buildAccessRequest(mode, registeredDappAccessHash, requestingDappId, destinationArchivist) {
+    const accessRequest = {
+      destinationArchivist,
+      mode,
+      registeredDappAccessHash,
+      requestingDappId,
+      schema: DappAccessRequestSchema2,
+      timestamp: Date.now()
+    };
+    return accessRequest;
+  }
+  /**
+   * Get all available dapp access requests
+   */
+  async getDappAccessPayloads() {
+    const diviner = await this.getDappArchivistPayloadDiviner();
+    const query = {
+      order: "desc",
+      schema: PayloadDivinerQuerySchema4,
+      schemas: [RegisteredDappAccessSchema2]
+    };
+    return diviner.divine([query]);
+  }
+  /**
+   * Get the most recent dapp injectable params
+   * @returns Promise
+   */
+  async getDappInjectableParams() {
+    const diviner = await this.getDappArchivistPayloadDiviner();
+    return await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner);
+  }
+  /**
+   * Get the most recent dapp intent
+   * @param  {string} name
+   */
+  async getRegisteredDappAccessByName(name) {
+    const diviner = await this.getDappArchivistPayloadDiviner();
+    const query = {
+      limit: 1,
+      name,
+      schema: PayloadDivinerQuerySchema4,
+      schemas: [RegisteredDappAccessSchema2]
+    };
+    const [payload] = assertEx8(await diviner.divine([query]), () => "Unable to find registered dapp access");
+    return payload;
+  }
+  /**
+   * Get the user wallet
+   */
+  getUserAccount(dappName) {
+    const account = this.context.user.signers?.get(dappName);
+    if (account) {
+      return account;
+    } else {
+      throw new Error("Unable to find user wallet");
+    }
+  }
+  /**
+   * Get all wallets for the user
+   */
+  getUserAccountsAll() {
+    return [...this.context.user.signers?.values() ?? []];
+  }
+  /**
+   * Make Dapp Access Request
+   * @param {string} requestingDappId
+   * @param {string} registeredDappAccessHash
+   * @param {string} mode
+   * @param {string} destinationArchivist
+   */
+  async makeDappAccessRequest(requestingDappId, registeredDappAccessHash, mode, destinationArchivist) {
+    const archivist = await this.getDappArchivist();
+    const registeredDappAccessPayload = await archivist.get([registeredDappAccessHash]);
+    if (!registeredDappAccessPayload) {
+      throw new Error("No registered dapp access found");
+    }
+    const accessRequest = this.buildAccessRequest(mode, registeredDappAccessHash, requestingDappId, destinationArchivist);
+    await archivist.insert([accessRequest]);
+  }
+  /**
+   * Make Dapp Intent Request
+   * @param  {DappId} sourceDappId
+   * @param  {DappId} targetDappId
+   * @param  {DappIntentTypes=DappIntentTypes.Launch} intent
+   * @param  {DappIntent['params']} mode
+   */
+  async makeDappIntentRequest(sourceDappId, targetDappId, intent = DappIntentTypes.Launch, mode = DappMode2.Window, params) {
+    if (!sourceDappId) {
+      throw new Error("No source dapp id provided, dApps must declare a sourceDappId");
+    }
+    const archivist = await this.getDappArchivist();
+    const dappIntent = DappIntentCaller.buildIntent(sourceDappId, intent, targetDappId, mode, params);
+    return await archivist.insert([dappIntent]);
+  }
+  /**
+   * Set the dapp injectable params
+   *
+   * @param  {URLSearchParams} searchParams
+   * @param  {string} pathname
+   */
+  async setDappInjectableRouteParams(searchParams = new URLSearchParams(), pathname) {
+    const dappArchivist = await this.getDappArchivist();
+    const params = {};
+    for (const [key, value] of searchParams.entries()) {
+      params[key] = value;
+    }
+    const payload = {
+      params,
+      path: pathname,
+      schema: DappInjectableParamsSchema2,
+      source: "route",
+      timestamp: Date.now()
+    };
+    await dappArchivist.insert([payload]);
+  }
+};
+
+// src/classes/menu/Caller.ts
+var DappMenuCaller = class extends DappCaller {
+  constructor(context) {
+    super(context);
+  }
+  /**
+   * Add new Payloads to the dappArchivist if they haven't already
+   *
+   * @param  {Payload[]} payloads
+   */
+  async add(payloads, force = false) {
+    const dappArchivist = await this.getDappArchivist();
+    for (const payload of payloads) {
+      const hash = await PayloadBuilder3.dataHash(payload);
+      const [existing] = await dappArchivist.get([hash]);
+      if (!existing || force) {
+        await dappArchivist.insert(payloads);
+      }
+    }
+  }
+  async currentNavSelection() {
+    const diviner = await this.getDappArchivistPayloadDiviner();
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema5,
+      schemas: [DappNavItemSelectionSchema]
+    };
+    return await diviner.divine([query]);
+  }
+  /*
+   * Indicate to the system that a nav item was selected
+   *
+   * @param  {string} path
+   * @params {string} injectableParamsPath
+   * @returns Promise
+   */
+  async makeNavItemSelection(path, injectableParamsPath) {
+    const dappArchivist = await this.getDappArchivist();
+    const payload = {
+      path,
+      schema: DappNavItemSelectionSchema,
+      timestamp: Date.now()
+    };
+    await dappArchivist.insert([payload]);
+    if (injectableParamsPath) {
+      const injectableParams = {
+        params: {},
+        path: injectableParamsPath,
+        schema: DappInjectableParamsSchema3,
+        source: "route",
+        timestamp: Date.now()
+      };
+      await dappArchivist.insert([injectableParams]);
+    }
+  }
+};
+
+// src/classes/menu/Resource.ts
+import { assertEx as assertEx9 } from "@xylabs/assert";
+import { isDappNavItemSelection, isDappNavMenuConfig } from "@xyo-network/os-model";
+
+// src/classes/menu/Queries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema6 } from "@xyo-network/diviner-payload-model";
+import {
+  DappNavItemSchema,
+  DappNavItemSelectionSchema as DappNavItemSelectionSchema2,
+  DappNavMenuConfigSchema
+} from "@xyo-network/os-model";
+var NO_ITEMS = [];
+var DappMenuQueries = {
+  async getMenuConfigs(diviner) {
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema6,
+      schemas: [DappNavMenuConfigSchema]
+    };
+    return await diviner.divine([query]);
+  },
+  async getMenuItems(diviner) {
+    const query = {
+      order: "desc",
+      schema: PayloadDivinerQuerySchema6,
+      schemas: [DappNavItemSchema]
+    };
+    const results = await diviner.divine([query]);
+    return results.length > 0 ? results : NO_ITEMS;
+  },
+  async getNavItemSelections(diviner) {
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema6,
+      schemas: [DappNavItemSelectionSchema2]
+    };
+    const results = await diviner.divine([query]);
+    return results.length > 0 ? results : NO_ITEMS;
+  },
+  async getVisibleMenuItems(diviner) {
+    const query = {
+      order: "desc",
+      schema: PayloadDivinerQuerySchema6,
+      schemas: [DappNavItemSchema]
+    };
+    const results = await diviner.divine([query]);
+    return results.filter((menuItem) => menuItem.hidden !== true).sort((a, b) => (a.weight ?? 0) > (b.weight ?? 0) ? 1 : -1);
+  }
+};
+
+// src/classes/menu/Resource.ts
+var DappMenuResource = class extends DappCaller {
+  _menuConfigListener;
+  _menuItemListener;
+  _menuItemSelectionListener;
+  _menuItemVisibleListener;
+  constructor(xyOsContext) {
+    super(xyOsContext);
+  }
+  get menuConfigListener() {
+    return assertEx9(this._menuConfigListener, () => "menuConfigListener note found");
+  }
+  get menuItemListener() {
+    return assertEx9(this._menuItemListener, () => "menuItemListener note found");
+  }
+  get menuItemSelectionListener() {
+    return assertEx9(this._menuItemSelectionListener, () => "menuItemSelectionListener note found");
+  }
+  get menuItemVisibleListener() {
+    return assertEx9(this._menuItemVisibleListener, () => "menuItemVisibleListener note found");
+  }
+  /** subscribe to latest set of payloads */
+  get subscriptions() {
+    return {
+      menuConfigs: (cb) => this.menuConfigListener.subscribe(cb),
+      menuItemSelections: (cb) => this.menuItemSelectionListener.subscribe(cb),
+      menuItems: (cb) => this.menuItemListener.subscribe(cb),
+      menuItemsVisible: (cb) => this.menuItemVisibleListener.subscribe(cb)
+    };
+  }
+  /**
+   * Return the latest menu payloads from the repository
+   */
+  get views() {
+    return {
+      menuConfigs: () => this.menuConfigListener.getSnapshot(),
+      menuItemSelections: () => this.menuItemSelectionListener.getSnapshot(),
+      menuItems: () => this.menuItemListener.getSnapshot(),
+      menuItemsVisible: () => this.menuItemVisibleListener.getSnapshot()
+    };
+  }
+  /**
+   * Remove all listeners and reset their class members
+   */
+  cleanupListeners() {
+    this.menuConfigListener.cleanupListeners();
+    this.menuItemListener.cleanupListeners();
+    this.menuItemSelectionListener.cleanupListeners();
+  }
+  /**
+   * Start the resource
+   */
+  async start() {
+    const dappArchivist = await this.getDappArchivist();
+    const dappArchivistPayloadDiviner = await this.getDappArchivistPayloadDiviner();
+    this._menuConfigListener = await PayloadStore.create({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner),
+      idFunction: isDappNavMenuConfig
+    });
+    this._menuItemListener = await PayloadStore.create({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner),
+      idFunction: isDappNavMenuConfig
+    });
+    this._menuItemVisibleListener = await PayloadStore.create({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner),
+      idFunction: isDappNavMenuConfig
+    });
+    this._menuItemSelectionListener = await PayloadStore.create({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner),
+      idFunction: isDappNavItemSelection
+    });
+  }
+};
+
+// src/classes/node/createDappContext.ts
+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";
+
+// src/wallet/DappSeedPhraseRepository.ts
+import { HDWallet } from "@xyo-network/account";
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema7 } from "@xyo-network/diviner-payload-model";
+import { DappWalletSeedPhraseSchema } from "@xyo-network/os-model";
+import { v4 as uuid } from "uuid";
+var DappSeedPhraseRepository = class extends OsCallerBase {
+  constructor(xyOs, allowedNames) {
+    super(xyOs);
+    this.allowedNames = allowedNames;
+  }
+  // record of all dapps that have requested a seed phrase with the OS
+  dappIdRepository = /* @__PURE__ */ new Map();
+  // record of all walletIds that have been issued to registered dapps
+  walletIdRepository = /* @__PURE__ */ new Map();
+  async add(dappId) {
+    const archivist = await this.getDappsArchivist();
+    const seedPhrase = this.newPhrase();
+    const walletId = uuid();
+    const payload = {
+      dappId,
+      schema: DappWalletSeedPhraseSchema,
+      seedPhrase,
+      walletId
+    };
+    await archivist.insert([payload]);
+    this.dappIdRepository.set(dappId, payload);
+    this.walletIdRepository.set(walletId, payload);
+    return walletId;
+  }
+  async findOrCreate(dappName) {
+    if (this.allowedNames.includes(dappName)) {
+      const existingPayload = await this.checkDappId(dappName);
+      if (existingPayload) return existingPayload.walletId;
+      try {
+        await this.add(dappName);
+        const existingPayload2 = await this.checkDappId(dappName);
+        if (existingPayload2) return existingPayload2.walletId;
+        throw new Error(`failed to add seed phrase: ${dappName}`);
+      } catch (e) {
+        console.error(e);
+        throw new Error(`failed to add seed phrase: ${dappName}`);
+      }
+    } else {
+      throw new Error(`${dappName} is not allowed to register a seed phase. NOTE: this is a safeguard till 3rd party dApps can be validated`);
+    }
+  }
+  async request(walletId) {
+    return (await this.checkWalletId(walletId))?.seedPhrase;
+  }
+  async checkDappId(dappId) {
+    const diviner = await this.getDappsArchivistPayloadDiviner();
+    const query = {
+      dappId,
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema7,
+      schemas: [DappWalletSeedPhraseSchema]
+    };
+    const results = await diviner.divine([query]);
+    return results.length > 0 ? results[0] : void 0;
+  }
+  async checkWalletId(walletId) {
+    const diviner = await this.getDappsArchivistPayloadDiviner();
+    const query = {
+      limit: 1,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema7,
+      schemas: [DappWalletSeedPhraseSchema],
+      walletId
+    };
+    const results = await diviner.divine([query]);
+    return results.length > 0 ? results[0] : void 0;
+  }
+  newPhrase() {
+    return HDWallet.generateMnemonic();
+  }
+};
+
+// src/classes/node/Creator.ts
+import { assertEx as assertEx10 } from "@xylabs/assert";
+import { asArchivistInstance as asArchivistInstance3 } from "@xyo-network/archivist-model";
+import { replaceManifestTokens } from "@xyo-network/kernel";
+import { DappPackageManifestPayloadSchema } from "@xyo-network/manifest";
+
+// src/manifest/manifestReplacementTokens.ts
+import { getXnsDomain } from "@xyo-network/kernel";
+var manifestReplacementTokens = (xnsNodeUrl, xnsNetwork) => ({ "[REPLACE_WITH_NS_NODE_URL]": getXnsDomain(xnsNodeUrl, xnsNetwork) });
+
+// src/manifest/os-node.manifest.json
+var os_node_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: "OsNode",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: [
+          {
+            config: {
+              accountPath: "1'",
+              name: "OSArchivist",
+              dbName: "OSArchivist",
+              labels: {
+                "network.xyo.archivist.persistence.scope": "device"
+              },
+              storeName: "payloads",
+              parents: {
+                read: [
+                  "Archivist"
+                ]
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "3'",
+              name: "DappsArchivist",
+              dbName: "DappsArchivist",
+              labels: {
+                "network.xyo.archivist.persistence.scope": "device"
+              },
+              storeName: "payloads",
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              archivist: "DappsArchivist",
+              dbVersion: 1,
+              name: "DappsArchivistPayloadDiviner",
+              labels: {
+                "network.xyo.archivist.persistence.scope": "device"
+              },
+              schema: "network.xyo.diviner.payload.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "4'",
+              dbName: "IntentArchivist",
+              name: "IntentArchivist",
+              storeName: "payloads",
+              labels: {
+                "network.xyo.archivist.persistence.scope": "device"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "7",
+              archivist: "IntentArchivist",
+              dbVersion: 1,
+              name: "IntentArchivistPayloadDiviner",
+              labels: {
+                "network.xyo.archivist.persistence.scope": "device"
+              },
+              schema: "network.xyo.diviner.payload.config",
+              storeName: "payloads"
+            }
+          },
+          {
+            config: {
+              accountPath: "8",
+              name: "RegisteredDappInterfacesArchivist",
+              schema: "network.xyo.archivist.memory.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "9'",
+              name: "DappsArchivistDevelopment",
+              parents: {
+                write: [
+                  "DappsArchivist"
+                ]
+              },
+              schema: "network.xyo.archivist.memory.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "10",
+              archivist: "DappsArchivistDevelopment",
+              dbVersion: 1,
+              name: "DappsArchivistPayloadDivinerDevelopment",
+              labels: {
+                "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
+              },
+              schema: "network.xyo.diviner.payload.generic.config"
+            }
+          },
+          {
+            config: {
+              name: "OsPubSubNetworkStackNode",
+              schema: "network.xyo.node.config"
+            }
+          },
+          {
+            config: {
+              name: "OsSettingsStackNode",
+              schema: "network.xyo.node.config"
+            }
+          },
+          {
+            config: {
+              name: "OsXyoPublicNetworkStackNode",
+              schema: "network.xyo.node.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest.package.dapp"
+};
+
+// src/classes/node/DefaultPayloads/DefaultPayloads.ts
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+
+// src/classes/node/DefaultPayloads/DappAccessPayloads.ts
+var DappAccessPayloads = class {
+  constructor(context, _dappName) {
+    this.context = context;
+  }
+  async payloads() {
+    const osCaller = new OsCallerBase(this.context);
+    const archivist = await osCaller.getRegisteredDappInterfacesArchivist();
+    return await archivist.all();
+  }
+};
+
+// src/classes/node/DefaultPayloads/NodeInfoPayload.ts
+import { NodeOsInfoSchema as NodeOsInfoSchema2 } from "@xyo-network/os-model";
+var NodeInfoPayload = class {
+  constructor(_context, _dappName) {
+    this._context = _context;
+  }
+  async payloads() {
+    const exposedNode = this._context.exposedNode;
+    if (exposedNode) {
+      console.debug("[DEBUG]", "Found Exposed Node Address", exposedNode?.address);
+    } else {
+      console.error("exposedNode not found");
+    }
+    await Promise.resolve();
+    const nodeOsInfo = {
+      publicAddress: exposedNode?.address ?? "",
+      schema: NodeOsInfoSchema2
+    };
+    return [nodeOsInfo];
+  }
+};
+
+// 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/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 permit() {
+    for (const permission of this.externalPermissions ?? []) {
+      await this.permitExternalModule(permission);
+    }
+  }
+  getExternalModuleName(permission) {
+    return permission.name;
+  }
+  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`);
+    }
+  }
+  async registerAndAttachModule(mod) {
+    if (mod) {
+      await this.dappWindowNode.register?.(mod);
+      await this.dappWindowNode.attach(mod.address, true);
+    }
+  }
+  async resolveExternalModule(id) {
+    return await this.context.root.resolve(id);
+  }
+};
+
+// 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;
+  }
+  // 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;
+  }
+  // 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();
+  }
+  // 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();
+  }
+  static parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork) {
+    const { external, ...manifestWithoutExternals } = payload;
+    const manifestPayloadRaw = {
+      ...manifestWithoutExternals,
+      schema: DappPackageManifestPayloadSchema
+    };
+    console.log("DappContextCreator:parseDappPackageManifestPayload", xnsNodeUrl, xnsNetwork);
+    const manifestPayload = replaceManifestTokens(manifestPayloadRaw, manifestReplacementTokens(xnsNodeUrl, xnsNetwork));
+    return { external, manifestPayload };
+  }
+  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/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 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/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;
+  }
+  get id() {
+    return assertEx11(this._id, () => "Connection ID not set.  Did you forget to call buildConnection()?");
+  }
+  buildConnection(id) {
+    this._id = id;
+  }
+};
+
+// 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"
+    );
+  }
+  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;
+  }
+  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];
+  }
+  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;
+    });
+  }
+  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;
+    }
+  }
+  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 assertEx14 } from "@xylabs/assert";
+import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
+import { ModuleFactoryLocator as ModuleFactoryLocator4 } from "@xyo-network/module-factory-locator";
+import { DappPackageManifestPayloadSchema as DappPackageManifestPayloadSchema2 } 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 eventBus() {
+    return assertEx13(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 assertEx13(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 assertEx13(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 assertEx14(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);
+      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: DappPackageManifestPayloadSchema2 }, wallet, finalLocator);
+      const dappNodes = await dappNodesWrapper.loadNodes();
+      const dappManifestWallet = await wallet.derivePath("99999");
+      dapp_window_manifest_default.nodes[0].config.name = this.dapp.name + "Root";
+      const wrapper = new ManifestWrapper(
+        { ...dapp_window_manifest_default, schema: DappPackageManifestPayloadSchema2 },
+        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);
+      return this;
+    });
+  }
+  getStack(stackName) {
+    return this.parent.getStack(stackName);
+  }
+};
+
+// src/classes/system/ManageSystemDapps.ts
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import semver from "semver";
+
+// src/classes/system/Queries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema8 } from "@xyo-network/diviner-payload-model";
+import {
+  DappConfigSchema,
+  DappIconSchema,
+  DappWidgetConfigSchema,
+  UnregisteredDappAccessSchema
+} from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+var SystemDappQueries = {
+  async getDappAccess(diviner, name, version) {
+    const accessQuery = {
+      order: "desc",
+      registeringDappId: name,
+      schema: PayloadDivinerQuerySchema8,
+      schemas: [UnregisteredDappAccessSchema],
+      version
+    };
+    return await diviner.divine([accessQuery]);
+  },
+  async getLatestConfig(diviner, name) {
+    const configQuery = {
+      limit: 1,
+      name,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema8,
+      schemas: [DappConfigSchema]
+    };
+    const [dappConfig] = await diviner.divine([configQuery]);
+    return dappConfig;
+  },
+  async getLatestIcon(diviner, name, version) {
+    const iconQuery = {
+      name,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema8,
+      schemas: [DappIconSchema],
+      version
+    };
+    const [dappIcon] = await diviner.divine([iconQuery]);
+    return dappIcon;
+  },
+  async getWidgetConfigs(diviner, name, version) {
+    const widgetConfigQuery = {
+      dappId: name,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema8,
+      schemas: [DappWidgetConfigSchema],
+      version
+    };
+    const widgetConfigs = await diviner.divine([widgetConfigQuery]);
+    const uniqueConfigs = {};
+    for (const widgetConfig of widgetConfigs) {
+      const hash = await PayloadBuilder6.dataHash(widgetConfig);
+      uniqueConfigs[widgetConfig.mode ?? hash] = widgetConfig;
+    }
+    return Object.values(uniqueConfigs);
+  }
+};
+
+// src/classes/system/ManageSystemDapps.ts
+var ManageSystemDapps = class extends OsCallerBase {
+  constructor(context, defaultSystemNames, defaultSystemDapps, defaultSystemDappParams, locator, developmentMode) {
+    super(context);
+    this.defaultSystemNames = defaultSystemNames;
+    this.defaultSystemDapps = defaultSystemDapps;
+    this.defaultSystemDappParams = defaultSystemDappParams;
+    this.locator = locator;
+    this.developmentMode = developmentMode;
+  }
+  onErrorCallbacks = [];
+  /**
+   * Add a callback to listen for errors throwing during system dapp registration
+   * @param  {ErrorListener} errorListener
+   */
+  addErrorListener(errorListener) {
+    this.onErrorCallbacks.push(errorListener);
+  }
+  /**
+   * Installs the dapps into the OS and builds the appropriate DappSet
+   */
+  async install() {
+    await this.insertPayloads();
+    return await this.latestSets();
+  }
+  async freshInstall(archivist) {
+    await archivist.insert(this.defaultSystemDapps);
+  }
+  async insertPayloads() {
+    const archivist = this.developmentMode ? await this.getDappsArchivistDevelopment() : await this.getDappsArchivist();
+    try {
+      const allPayloads = await archivist.all();
+      if (allPayloads.length === 0) {
+        await this.freshInstall(archivist);
+        return true;
+      }
+      for (const systemDappPayload of this.defaultSystemDapps) {
+        try {
+          const validSemver = semver.valid(systemDappPayload.version);
+          if (!validSemver) throw new Error("semver is a valid type (string) but was not able to be parsed");
+        } catch (e) {
+          console.error(`${systemDappPayload.version} does not appear to be a valid semver value`, e);
+          continue;
+        }
+        const [existing] = await archivist.get([await PayloadBuilder7.dataHash(systemDappPayload)]);
+        if (existing) continue;
+        await archivist.insert([systemDappPayload]);
+      }
+      return true;
+    } catch (e) {
+      console.error("error installing system dapps");
+      throw e;
+    }
+  }
+  async latestSets() {
+    const diviner = this.developmentMode ? await this.getDappsArchivistPayloadDivinerDevelopment() : await this.getDappsArchivistPayloadDiviner();
+    const dappSets = [];
+    const failedPayloads = [];
+    for (const name of this.defaultSystemNames) {
+      try {
+        const dappConfig = await SystemDappQueries.getLatestConfig(diviner, name);
+        if (!dappConfig) {
+          console.error(`No config found for dapp ${name}`);
+          continue;
+        }
+        const dappIcon = await SystemDappQueries.getLatestIcon(diviner, name, dappConfig.version);
+        if (!dappIcon) {
+          console.error(`No icon found for dapp ${dappConfig.name}`);
+          failedPayloads.push(dappConfig);
+          continue;
+        }
+        const dappAccess = await SystemDappQueries.getDappAccess(diviner, name, dappConfig.version);
+        const dappParams = this.defaultSystemDappParams[dappConfig.name];
+        if (!dappParams) {
+          console.error(`No params found for dapp ${dappConfig.name}.  Did you forget to add it to OsDappParams?`);
+          failedPayloads.push(dappConfig);
+          continue;
+        }
+        const dappWidgetConfigs = await SystemDappQueries.getWidgetConfigs(diviner, name, dappConfig.version);
+        dappSets.push({
+          dapp: {
+            accessors: dappAccess,
+            config: dappConfig,
+            icon: dappIcon,
+            params: dappParams,
+            widgetConfigs: dappWidgetConfigs
+          }
+        });
+      } catch {
+        console.error(`Failed to build dapp ${name}`);
+      }
+    }
+    if (failedPayloads.length > 0) {
+      for (const cb of this.onErrorCallbacks) cb(failedPayloads);
+    }
+    return dappSets;
+  }
+};
+
+// src/classes/registration/DappRegistry.ts
+import { HDWallet as HDWallet4 } from "@xyo-network/account";
+import {
+  DappRegisteredSchema,
+  DappRegisteredState,
+  isRegisteredDappAccess as isRegisteredDappAccess2
+} from "@xyo-network/os-model";
+
+// src/classes/registration/ValidateDappAccessDiviner/Config.ts
+import { isPayloadOfSchemaTypeWithMeta } from "@xyo-network/payload-model";
+var FailedAccessorSchema = "network.xyo.os.failed.accessor.registration";
+var isFailedAccessor = isPayloadOfSchemaTypeWithMeta(FailedAccessorSchema);
+var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registration.validate";
+
+// src/classes/registration/ValidateDappAccessDiviner/Diviner.ts
+import { HDWallet as HDWallet3 } from "@xyo-network/account";
+import { AbstractDiviner } from "@xyo-network/diviner-abstract";
+import { ManifestWrapper as ManifestWrapper2, PackageManifestPayloadSchema } from "@xyo-network/manifest";
+import {
+  isDappPackageManifestPayload,
+  isUnregisteredDappAccess,
+  RegisteredDappAccessSchema as RegisteredDappAccessSchema3
+} from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+var ValidateDappAccessDiviner = class extends AbstractDiviner {
+  static configSchemas = [ValidateDappAccessDivinerConfigSchema];
+  async divineHandler(payloads) {
+    const dappManifest = payloads?.filter(isDappPackageManifestPayload);
+    const accessors = payloads?.filter(isUnregisteredDappAccess);
+    const dappParams = this.params.dappParams;
+    if (dappManifest.length > 1) {
+      throw new Error("Only one dapp manifest payload is allowed");
+    }
+    if (!dappManifest || dappManifest.length === 0 || accessors?.length === 0) {
+      return [];
+    }
+    const registeredAccessors = [];
+    const failedAccessors = [];
+    for (const access of accessors) {
+      try {
+        if (access) {
+          const dappAccessInterface = ValidDappAccessInterfaces[access.name];
+          if (!dappAccessInterface) {
+            console.warn("Invalid dapp access interface", access.name);
+            continue;
+          }
+          const dappManifestToTest = dappPackageManifestToPackageManifest(dappManifest[0]);
+          const dappChildren = await getNodeChildren(dappManifestToTest, dappParams);
+          const interfaceChildren = await getNodeChildren(dappAccessInterface.manifest, dappParams);
+          const valid = compareChildren(interfaceChildren, dappChildren);
+          if (valid) {
+            const payload = await PayloadBuilder8.build({
+              ...access,
+              schema: RegisteredDappAccessSchema3,
+              timestamp: Date.now()
+            });
+            registeredAccessors.push(payload);
+          } else {
+            const failedRegistration = await PayloadBuilder8.build({
+              accessor: access,
+              errorMessage: "Invalid dapp access interface",
+              schema: FailedAccessorSchema
+            });
+            failedAccessors.push(failedRegistration);
+          }
+        }
+      } catch (e) {
+        failedAccessors.push(
+          await PayloadBuilder8.build({
+            accessor: access,
+            errorMessage: e.message,
+            schema: FailedAccessorSchema
+          })
+        );
+      }
+    }
+    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: PackageManifestPayloadSchema
+  };
+};
+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 });
+      }
+    }
+  }
+};
+
+// 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`);
+  }
+};
+
+// 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]);
+  }
+};
+
+// 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/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();
+  }
+  /**
+   * 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
+    });
+  }
+};
+
+// 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);
+  }
+  /**
+   * Add a node background to the settings
+   * @param  {WithMeta<NodeBackground>} payload
+   */
+  async addNodeBackground(payload) {
+    const archivist = await this.getOsSettingsArchivist();
+    await archivist.insert([payload]);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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 storedSeedPhrasePayload;
+  }
+};
+
+// 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);
+  }
+  get latestUserWalletListener() {
+    return assertEx18(this._latestUserWalletListener, () => "Latest user wallet listener not set");
+  }
+  get nodeBackgroundListener() {
+    return assertEx18(this._nodeBackgroundListener, () => "Node background listener not set");
+  }
+  get subscriptions() {
+    return {
+      latestUserWallet: (cb) => this.walletsListener.subscribe(cb),
+      nodeBackground: (cb) => this.nodeBackgroundListener.subscribe(cb),
+      wallets: (cb) => this.walletsListener.subscribe(cb)
+    };
+  }
+  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();
+  }
+  /**
+   * 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
+    });
+  }
+};
+
+// src/classes/signer/Signers.ts
+import { assertEx as assertEx19 } from "@xylabs/assert";
+import { HDWallet as HDWallet5 } from "@xyo-network/account";
+var Signers = class {
+  _paths;
+  _signerAccounts;
+  _walletStore;
+  constructor(paths, walletStore) {
+    this._paths = paths;
+    this._walletStore = walletStore;
+    this._signerAccounts = /* @__PURE__ */ new Map();
+  }
+  get paths() {
+    return assertEx19(this._paths, () => "Paths not initialized");
+  }
+  get signerAccounts() {
+    return assertEx19(this._signerAccounts, () => "Signer accounts not initialized");
+  }
+  get walletStore() {
+    return assertEx19(this._walletStore, () => "Wallet store not initialized");
+  }
+  getSigner(walletKind, signer) {
+    return this.signerAccounts.get(walletKind)?.get(signer);
+  }
+  getWalletKindSigner(walletKind) {
+    return this.signerAccounts.get(walletKind);
+  }
+  async initialize() {
+    for (const [walletKindName, signerPaths] of this.paths) {
+      for (const [signerName, walletPath] of signerPaths.entries()) {
+        await this.initializeSigners(walletKindName, signerName, walletPath);
+      }
+    }
+  }
+  async initializeSigners(walletKindName, signerName, path) {
+    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 HDWallet5.fromPhrase(phrase);
+      const derivedWallet = await wallet.derivePath(path);
+      signerMap.set(signerName, derivedWallet);
+      this.signerAccounts.set(walletKindName, signerMap);
+    }
+  }
+};
+
+// src/loadOsNode.ts
+import { IndexedDbArchivist } from "@xyo-network/archivist-indexeddb";
+import { IndexedDbPayloadDiviner } from "@xyo-network/diviner-payload-indexeddb";
+import { ManifestWrapper as ManifestWrapper3 } from "@xyo-network/manifest-wrapper";
+import { ModuleFactoryLocator as ModuleFactoryLocator6 } from "@xyo-network/module-factory-locator";
+var OS_NODE_PATH = "1'";
+var getDefaultOsNodeLocator = () => {
+  const locator = new ModuleFactoryLocator6();
+  locator.register(IndexedDbArchivist, { "network.xyo.archivist.persistence.scope": "device" });
+  locator.register(IndexedDbPayloadDiviner, { "network.xyo.archivist.persistence.scope": "device" });
+  return locator;
+};
+var loadOsNode = async (osWallet, locator) => {
+  try {
+    const osNodeWallet = await osWallet.derivePath(OS_NODE_PATH);
+    const osNodeLocator = locator ?? getDefaultOsNodeLocator();
+    const manifestWrapper = new ManifestWrapper3(os_node_manifest_default, osNodeWallet, osNodeLocator);
+    const osNode = (await manifestWrapper.loadNodes())[0];
+    return [osNode];
+  } catch (e) {
+    const error = e;
+    console.error(`Error creating os node: ${error.message}`);
+    console.error(`Error creating os node: ${error.stack}`);
+    throw new Error(`Error creating os node: ${error.message}`);
+  }
+};
+
+// src/stack/Base.ts
+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";
+import { asAttachableNodeInstance } from "@xyo-network/node-model";
+var StackBase = class extends BaseEmitter3 {
+  // flag to check that all adapters are initialized
+  initialized = false;
+  // adapters to initialize into the stack
+  _adapterSet;
+  _context;
+  // stack node
+  _stack;
+  // stack node module identifier for the stack
+  _stackNodeModuleId;
+  // list of initialized nodes
+  initializedNodes = [];
+  // list of listeners - lister type not important since its only recalled to stop listening
+  listeners = [];
+  constructor(context, adapterSet, stackNodeModuleId) {
+    super({});
+    this._context = context;
+    this._adapterSet = adapterSet(assertEx20(this.context.kernel, "Kernel access required"));
+    this._stackNodeModuleId = stackNodeModuleId;
+  }
+  get adapterSet() {
+    return assertEx20(this._adapterSet, () => `${this.stackNodeModuleId} adapters not initialized`);
+  }
+  get context() {
+    return assertEx20(this._context, () => `${this.stackNodeModuleId} stack context not initialized`);
+  }
+  get stack() {
+    return assertEx20(this._stack, () => `${this.stackNodeModuleId} stack node not initialized`);
+  }
+  get stackNodeModuleId() {
+    return assertEx20(this._stackNodeModuleId, () => "Stack node module identifier not initialized");
+  }
+  initialize() {
+    this.assignStack();
+    for (const adapter of this.adapterSet) {
+      const driverReadyListener = async ({ node }) => await this.handleDriverReady(node);
+      adapter.on("driverReady", driverReadyListener);
+      this.listeners.push({
+        adapter,
+        eventName: "driverReady",
+        listener: driverReadyListener
+      });
+      const driverErrorListener = async ({ error }) => {
+        console.error(`Error updating ${this.stackNodeModuleId} stack node`, error);
+        await this.emit("driverError", { error });
+      };
+      adapter.on("driverError", driverErrorListener);
+      this.listeners.push({
+        adapter,
+        eventName: "driverError",
+        listener: driverErrorListener
+      });
+      const startAdapter = async () => await adapter.start();
+      forget3(startAdapter());
+    }
+  }
+  /**
+   * Stops the stack
+   */
+  stop() {
+    for (const {
+      eventName,
+      listener,
+      adapter
+    } of this.listeners) {
+      adapter.off(eventName, listener);
+    }
+  }
+  /**
+   * Adds a node to the stack. Idempotent to avoid adding the
+   * same node multiple times
+   * @param node The node to add to the stack
+   * @returns
+   */
+  async addNodeToStackNode(node) {
+    const stackNode = await this.getStackNode();
+    const existingModule = await stackNode.resolve(node.address, { direction: "down" });
+    if (isModuleInstance(existingModule)) return;
+    await stackNode.register?.(node);
+    await stackNode.attach?.(node.address, true);
+  }
+  assignStack() {
+    const assign = async () => {
+      const stackNode = await this.getStackNode();
+      this._stack = stackNode;
+    };
+    forget3(assign());
+  }
+  async getStackNode() {
+    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) {
+    try {
+      await this.emit("driverReady", { node });
+      await this.addNodeToStackNode(node);
+      await this.updateInitializationState(node);
+    } catch (error) {
+      console.error(`Error updating ${this.stackNodeModuleId} stack node`, node.id, error);
+      await this.emit("stackError", { error });
+    }
+  }
+  async updateInitializationState(node) {
+    this.initializedNodes.push(node);
+    this.initialized = this.adapterSet.every((n) => n.initialized);
+    if (this.initialized) {
+      await this.emit("initialized", { stack: await this.getStackNode() });
+    }
+  }
+};
+
+// src/stack/Manager.ts
+var StackManager = class {
+  initializedStacksMap = /* @__PURE__ */ new Map();
+  stackMap;
+  constructor(stackMap) {
+    this.stackMap = stackMap;
+  }
+  get stacks() {
+    return Object.keys(this.initializedStacksMap);
+  }
+  get initializedStacks() {
+    return this.initializedStacksMap;
+  }
+  getStack(key) {
+    return this.initializedStacksMap.get(key);
+  }
+  initialize(context) {
+    for (const [key, stackSet] of Object.entries(this.stackMap)) {
+      console.log("stack-initialize", key);
+      const { stack: Stack, adapters: stackNodeModuleId } = stackSet;
+      const initializedStack = new Stack(context, stackNodeModuleId);
+      initializedStack.initialize();
+      this.initializedStacks.set(key, initializedStack);
+    }
+  }
+  stop() {
+    for (const stack of this.initializedStacks.values()) {
+      stack.stop();
+    }
+  }
+};
+
+// src/adapters/OsPubSubBridgeNetwork.ts
+import { ExposedNodeOuterNodeName, PubSubBridgeNodeNodeName } from "@xyo-network/os-model";
+
+// src/adapter/Base.ts
+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";
+import { asAttachableNodeInstance as asAttachableNodeInstance2 } from "@xyo-network/node-model";
+import { v4 as uuid3 } from "uuid";
+var NodeAdapterBase = class extends BaseEmitter4 {
+  constructor(kernel, driverName) {
+    super({});
+    this.kernel = kernel;
+    this.driverName = driverName;
+    this._id = uuid3();
+  }
+  initialized = false;
+  _id = "";
+  get id() {
+    return assertEx21(this._id, () => "NodeAdapterBase id not initialized");
+  }
+  async start() {
+    try {
+      const moduleAttachedInsertListener = ({ payloads }) => {
+        const moduleAttachedEvent = this.findModuleEventPayloads(payloads);
+        for (const payload of moduleAttachedEvent) {
+          if (payload.name === this.driverName) {
+            this.validateAndReturnDriver();
+          }
+        }
+      };
+      const eventsArchivist = await this.getEventsArchivist();
+      const weakRefInsertListener = new WeakRef(moduleAttachedInsertListener);
+      const insertListenerRef = weakRefInsertListener.deref();
+      if (insertListenerRef) eventsArchivist.on("inserted", insertListenerRef);
+      const node = this.validateAndReturnDriver();
+      if (node) return node;
+      this.initialized = false;
+    } catch (error) {
+      await this.emit("driverError", { error });
+    }
+  }
+  findModuleEventPayloads(payloads) {
+    return payloads.filter((payload) => {
+      const payloadToTest = payload;
+      return payloadToTest.event === "driverReady" && payloadToTest.schema === "network.xyo.kernel.module.event";
+    });
+  }
+  async getEventsArchivist() {
+    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() {
+    const mod = this.kernel.initialized[this.driverName];
+    if (mod) {
+      const node = asAttachableNodeInstance2(mod, () => `${mod.id} is not a node`);
+      this.initialized = true;
+      const emit = async () => await this.emit("driverReady", { node });
+      forget4(emit());
+      return node;
+    }
+  }
+};
+
+// src/adapter/Network.ts
+var NetworkAdapter = class extends NodeAdapterBase {
+  _connection;
+  constructor(kernel, driverName) {
+    super(kernel, driverName);
+    this.on("driverReady", ({ node }) => {
+      this._connection = node;
+    });
+  }
+  get connection() {
+    return this._connection;
+  }
+  get hasConnection() {
+    return !!this.connection;
+  }
+  removeConnection() {
+    this._connection = void 0;
+  }
+};
+
+// src/adapter/Settings.ts
+var SettingsAdapter = class extends NodeAdapterBase {
+  _settings = void 0;
+  constructor(kernel, driverName) {
+    super(kernel, driverName);
+    this.on("driverReady", ({ node }) => {
+      this._settings = node;
+    });
+  }
+  get hasSettings() {
+    return !!this.settings;
+  }
+  get settings() {
+    return this._settings;
+  }
+  removeSettings() {
+    this._settings = void 0;
+  }
+};
+
+// src/adapters/OsPubSubBridgeNetwork.ts
+var OsPubSubBridgeNetworkAdapters = (kernel) => [
+  new NetworkAdapter(kernel, PubSubBridgeNodeNodeName),
+  new NetworkAdapter(kernel, ExposedNodeOuterNodeName)
+];
+
+// src/adapters/OsSettings.ts
+import { OsSettingsNodeName } from "@xyo-network/os-model";
+var OsSettingsAdapters = (kernel) => [new SettingsAdapter(kernel, OsSettingsNodeName)];
+
+// src/adapters/OsXyoPublicNetwork.ts
+import { XyoPublicNodeName } from "@xyo-network/os-model";
+var OsXyoPublicNetworkAdapters = (kernel) => [
+  new NetworkAdapter(kernel, XyoPublicNodeName)
+];
+
+// src/stack/OsPubSubNetworkStack.ts
+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 {
+  _exposedNode;
+  _exposedNodeOuter;
+  busConnection = osPubSubNetworkReadyConnection();
+  constructor(context, adapters) {
+    super(context, adapters, "OsPubSubNetworkStackNode");
+  }
+  get exposedNode() {
+    return this._exposedNode;
+  }
+  get exposedNodeOuter() {
+    return this._exposedNodeOuter;
+  }
+  initialize() {
+    super.initialize();
+    this.context.eventBus.addConnection(this.busConnection);
+    this.on("initialized", () => this.busConnection.emit(OsPubSubNetworkReadyEvent, {}));
+    super.on("driverReady", async ({ node }) => {
+      if (node.id === PubSubBridgeNodeNodeName2) {
+        const httpBridge = assertEx22(await node.resolve("NsHttpBridge"), () => "HttpBridge not found");
+        const xnsNode = asNodeInstance2(await httpBridge.resolve("XNS"));
+        if (xnsNode) {
+          const initializedXns = await initializeXns(xnsNode);
+          console.log(`Xns: ${initializedXns}`);
+        } else {
+          console.log("Xns: Failed to contact Xns Node");
+        }
+      }
+    });
+    super.on("driverReady", async ({ node }) => {
+      if (node.id === ExposedNodeOuterNodeName2) {
+        this._exposedNodeOuter = node;
+        const mod = assertEx22(await node.resolve("ExposedNode"), () => "ExposedNode not found");
+        const exposedNode = asAttachableNodeInstance3(mod, () => "ExposedNode is not a node");
+        this._exposedNode = exposedNode;
+      }
+    });
+    super.on("driverError", (error) => console.error("Unable to assign exposed node(s) to context", error));
+  }
+  stop() {
+    super.stop();
+    this._exposedNode = void 0;
+    this._exposedNodeOuter = void 0;
+    if (this.busConnection._id)
+      this.context.eventBus.removeConnection(this.busConnection.id);
+  }
+};
+
+// src/stack/OsSettingsStack.ts
+var OsSettingsStack = class extends StackBase {
+  busConnection = osSettingsReadyConnection();
+  constructor(context, adapters) {
+    super(context, adapters, "OsSettingsStackNode");
+  }
+  initialize() {
+    super.initialize();
+    this.context.eventBus.addConnection(this.busConnection);
+    this.on("initialized", () => this.busConnection.emit(OsSettingsReadyEvent, {}));
+  }
+  stop() {
+    super.stop();
+  }
+};
+
+// src/stack/XyoPublicNetworkStack.ts
+import { XyoPublicNodeName as XyoPublicNodeName2 } from "@xyo-network/os-model";
+var XyoPublicNetworkStack = class extends StackBase {
+  busConnection = osXyoPublicNetworkReadyConnection();
+  constructor(context, adapters) {
+    super(context, adapters, "OsXyoPublicNetworkStackNode");
+  }
+  initialize() {
+    super.initialize();
+    this.context.eventBus.addConnection(this.busConnection);
+    this.on("initialized", () => this.busConnection.emit(OsXyoPublicNetworkReadyEvent, {}));
+    this.on("driverReady", ({ node }) => {
+      if (node.id === XyoPublicNodeName2) {
+        console.log("XyoPublicNode ready");
+      }
+    });
+    this.on("driverError", (error) => console.error("Error loading driver", error));
+  }
+  stop() {
+    super.stop();
+  }
+};
+
+// src/stack/Map.ts
+var OsStackMap = {
+  osPubSubNetworkStack: {
+    stack: OsPubSubNetworkStack,
+    adapters: OsPubSubBridgeNetworkAdapters
+  },
+  xyoPublicNetworkStack: {
+    stack: XyoPublicNetworkStack,
+    adapters: OsXyoPublicNetworkAdapters
+  },
+  osSettingsStack: {
+    stack: OsSettingsStack,
+    adapters: OsSettingsAdapters
+  }
+};
+
+// src/XyOs.ts
+var XyOs = class _XyOs extends XyOsContextBase {
+  _exposedNode;
+  _exposedNodeOuter;
+  _kernel;
+  _locator;
+  dappRegistrationService;
+  signers;
+  stackManager;
+  constructor({
+    logger = console,
+    eventBus = new EventBus(),
+    kernel = new Kernel({ logger }),
+    locator = new ModuleFactoryLocator7(),
+    dappsConfiguration,
+    developmentMode,
+    stackMap = OsStackMap,
+    ...params
+  } = {}) {
+    super({
+      eventBus,
+      kernel,
+      locator,
+      ...params
+    });
+    this._locator = locator;
+    this._kernel = kernel;
+    this.stackManager = new StackManager(stackMap);
+    this.dappRegistrationService = new DappRegistrationService(this, dappsConfiguration, this.locator, developmentMode);
+    if (this.signerPaths && this.kernel?.bios?.seedPhraseStore) this.signers = new Signers(this.signerPaths, this.kernel?.bios?.seedPhraseStore);
+  }
+  static get monitoring() {
+    return;
+  }
+  static get xyOsGlobal() {
+    return getXyOsGlobal();
+  }
+  get bios() {
+    return assertEx23(this.params.kernel?.bios, () => "Missing bios");
+  }
+  get exposedNode() {
+    return this.stackManager.getStack("osPubSubNetworkStack")?.exposedNode;
+  }
+  get exposedNodeOuter() {
+    return this.stackManager.getStack("osPubSubNetworkStack")?.exposedNodeOuter;
+  }
+  get kernel() {
+    return assertEx23(this.params.kernel, () => "Missing kernel");
+  }
+  get locator() {
+    return this._locator;
+  }
+  get stacks() {
+    return this.stackManager.stacks;
+  }
+  get user() {
+    return { signers: this.signers?.getWalletKindSigner("user") };
+  }
+  static async monitor(fn, eventConfig) {
+    const { name, additionalProperties } = eventConfig;
+    const monitor = this.monitoring;
+    monitor?.startTimer(name);
+    const result = await fn();
+    monitor?.stopTimer({ additionalProperties, name });
+    return result;
+  }
+  async boot(wallet, locator = new ModuleFactoryLocator7()) {
+    console.warn("XyOs:boot", wallet.address);
+    const fullLocator = this._locator.merge(locator);
+    return await this._bootMutex.runExclusive(async () => {
+      await this.eventBus.start();
+      if (this.kernel?.status === "created") {
+        await this.kernel.boot(await boot(), { locator: fullLocator, kernelDrivers: [] });
+      }
+      if (this.kernel?.status !== "booted") {
+        throw new Error("Kernel not 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);
+      if (this.signers) await this.signers.initialize();
+      return this;
+    });
+  }
+  buildDapp(manifest, dappId = NameTransforms.slug(manifest.nodes[0]?.config.name), name = NameTransforms.moduleName(manifest.nodes[0]?.config.name)) {
+    return this.dappRegistrationService.buildDapp(manifest, dappId, name);
+  }
+  dappByName(dappId) {
+    return this.dappRegistrationService.builtDapps[dappId];
+  }
+  getDappParams(dappId) {
+    return this.dappRegistrationService.getParamsForRegisteredDapp(dappId);
+  }
+  getStack(stackName) {
+    return assertEx23(this.stackManager.getStack(stackName), () => `Stack not found: ${stackName}`);
+  }
+  async monitor(fn, eventConfig) {
+    return await _XyOs.monitor(fn, eventConfig);
+  }
+  shutdown() {
+    assertEx23(this._root !== void 0, () => "XyOs not booted");
+    this._root = void 0;
+    this.stackManager.stop();
+  }
+};
+
+// src/classes/cache/RunningDappCache.ts
+var findOrCreateMutex = new Mutex3();
+var RunningDappCache = class _RunningDappCache {
+  static _cache = {};
+  static async findOrCreate(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork) {
+    const dappId = dapp.config.name;
+    return await XyOs.monitor(
+      async () => await findOrCreateMutex.runExclusive(async () => {
+        const existingWindowDappSet = _RunningDappCache.get(dappId);
+        if (existingWindowDappSet) {
+          console.debug("[DEBUG]", `RunningDappCache, using existing node for ${dappId}`);
+          const existingDappContext = assertEx24(existingWindowDappSet.context, () => "No context found in existing dapp node");
+          await DappContextCreator.primeDappArchivist(existingDappContext, xyOs, dappId);
+          return existingWindowDappSet;
+        }
+        console.debug("[DEBUG]", "RunningDappCache:creating", dappId);
+        const windowDappSet = await createDappContext(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork);
+        _RunningDappCache.set(dappId, windowDappSet);
+        return windowDappSet;
+      }),
+      { additionalProperties: { dappId }, name: "Loading dApp" }
+    );
+  }
+  static get(key) {
+    return this._cache[key];
+  }
+  static has(key) {
+    return key ? !!this._cache[key] : false;
+  }
+  static set(key, value) {
+    this._cache[key] = value;
+  }
+};
+
+// src/access-interfaces/registered-names/helpers/AccessNodeQueries.ts
+var AccessNodeQueries = class {
+  constructor(xyOsContext, accessRequest, registeredDappAccess) {
+    this.xyOsContext = xyOsContext;
+    this.accessRequest = accessRequest;
+    this.registeredDappAccess = registeredDappAccess;
+  }
+  get nameServiceNamesAccessNode() {
+    return assertEx25(RunningDappAccessCache.get(this.registeredDappAccess.registeringDappId), () => "No access node found");
+  }
+  // Refresh the archivist in the dapp
+  async refresh() {
+    const archivist = await this.getArchivistFromDappNode();
+    await archivist.clear();
+    await this.run();
+    console.log("refreshed");
+  }
+  // Run the access node queries
+  async run() {
+    const payloads = await this.getPayloadsFromAccessNode();
+    await this.insertAccessNodePayloadsIntoDappNodeArchivist(payloads);
+    return payloads;
+  }
+  async getArchivistFromDappNode() {
+    const archivistPath = this.accessRequest?.destinationArchivist || "DappArchivist";
+    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() {
+    const archivistFromAccessNode = await this.resolveArchivistFromAccessNode();
+    return await archivistFromAccessNode.all();
+  }
+  async insertAccessNodePayloadsIntoDappNodeArchivist(payloads) {
+    const archivist = await this.getArchivistFromDappNode();
+    await archivist.clear();
+    await archivist.insert(payloads);
+  }
+  async resolveArchivistFromAccessNode() {
+    const archivist = assertEx25(
+      await this.nameServiceNamesAccessNode.resolve("PublicXnsArchivist"),
+      () => "Unable to find archivist at PublicXnsArchivist"
+    );
+    return asArchivistInstance7(archivist, () => "PublicXnsArchivist is not an archivist");
+  }
+};
+
+// src/access-interfaces/registered-names/helpers/resource/AbstractXnsCaller.ts
+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";
+var XnsArchivistModuleName = "XnsArchivist";
+var XnsRegistrationsArchivistModuleName = "XnsRegistrationsArchivist";
+var AbstractXnsCaller = class {
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Get the XnsArchivist
+   */
+  async getXnsArchivist(pathPrefix) {
+    const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistModuleName}` : XnsArchivistModuleName;
+    const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
+    return asArchivistInstance8(mod, () => `${fullyQualifiedPath} is not an archivist`);
+  }
+  /**
+   * Get the XnsArchivistPayloadDiviner
+   */
+  async getXnsArchivistPayloadDiviner(pathPrefix) {
+    const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistPayloadDivinerModuleName}` : XnsArchivistPayloadDivinerModuleName;
+    const mod = assertEx26(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`);
+    return asDivinerInstance5(mod, () => `${fullyQualifiedPath} is not an diviner`);
+  }
+  /**
+   * Get the XnsRegistrationsArchivist
+   */
+  async getXnsRegistrationsArchivist(pathPrefix) {
+    const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsRegistrationsArchivistModuleName}` : XnsRegistrationsArchivistModuleName;
+    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 assertEx27 } from "@xylabs/assert";
+import { isTemporalIndexingDivinerResultIndex } from "@xyo-network/diviner-temporal-indexing-model";
+
+// src/access-interfaces/registered-names/helpers/resource/RegistrationsResourceQueries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema11 } from "@xyo-network/diviner-payload-model";
+import { TemporalIndexingDivinerResultIndexSchema } from "@xyo-network/diviner-temporal-indexing-model";
+var XnsRegistrationsResourceQueries = {
+  getAllRegistrations: async (diviner) => {
+    const query = {
+      limit: 100,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema11,
+      schemas: [TemporalIndexingDivinerResultIndexSchema]
+    };
+    return await diviner.divine([query]);
+  },
+  getRecentRegistrations: async (archivist) => {
+    return (await archivist.all()).reverse();
+  }
+};
+
+// src/access-interfaces/registered-names/helpers/resource/RegistrationsResource.ts
+var XnsRegistrationsResource = class extends AbstractXnsCaller {
+  constructor(context, pathPrefix) {
+    super(context);
+    this.pathPrefix = pathPrefix;
+  }
+  _allRegistrations;
+  get allRegistrations() {
+    return assertEx27(this._allRegistrations);
+  }
+  get subscriptions() {
+    return { allRegistrations: (cb) => this.allRegistrations.subscribe(cb) };
+  }
+  get views() {
+    return { allRegistrations: () => this.allRegistrations.getSnapshot() };
+  }
+  cleanupListeners() {
+    this.allRegistrations.cleanupListeners();
+  }
+  async start() {
+    const xnsArchivistPayloadDiviner = await this.getXnsArchivistPayloadDiviner(this.pathPrefix);
+    const xnsArchivist = await this.getXnsArchivist(this.pathPrefix);
+    this._allRegistrations = await PayloadStore.create({
+      archivist: xnsArchivist,
+      getLatest: async () => await XnsRegistrationsResourceQueries.getAllRegistrations(xnsArchivistPayloadDiviner),
+      idFunction: isTemporalIndexingDivinerResultIndex
+    });
+  }
+};
+
+// src/access-interfaces/ValidDappAccessInterfaces.ts
+import { RegisteredNames, RegisteredNamesInterface } from "@xyo-network/os-model";
+var ValidDappAccessInterfaces = { [RegisteredNames]: RegisteredNamesInterface };
+
+// src/helpers/monitor/XyOsMonitor.ts
+var DEFAULT_MONITORING_EVENT_NAME = "System Task Duration";
+globalThis.getXyOsGlobal = globalThis.getXyOsGlobal ?? (() => {
+  return { tracking: { trackEvent: (_event, _properties) => void 0 } };
+});
+var xyOsGlobal = globalThis.getXyOsGlobal();
+var XyOsMonitor = class _XyOsMonitor {
+  static trackEvent = xyOsGlobal.tracking.trackEvent;
+  performanceTimers = /* @__PURE__ */ new Map();
+  startTimer(name) {
+    this.performanceTimers.set(name, performance.now());
+  }
+  stopTimer(eventConfig) {
+    const { additionalProperties, name } = eventConfig;
+    const start = this.performanceTimers.get(name);
+    if (start) {
+      const end = performance.now();
+      const duration = end - start;
+      this.performanceTimers.delete(name);
+      const connection = this.connection();
+      _XyOsMonitor.trackEvent(DEFAULT_MONITORING_EVENT_NAME, {
+        downloadSpeedMbps: connection?.downlink,
+        duration: duration.toString(),
+        effectiveConnectionSpeed: connection?.effectiveType,
+        name,
+        roundTripTime: connection?.rtt,
+        ...additionalProperties
+      });
+    }
+  }
+};
+
+// src/profileModuleEvents.ts
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+var DISPLAY_EVENT_COUNT_FREQUENCY = 100;
+var profileData = {};
+var profileModuleEvents = (mod) => {
+  const modRef = new WeakRef(mod);
+  mod.onAny(async (eventName, args) => {
+    const mod2 = modRef.deref();
+    if (mod2) {
+      const data = profileData[mod2.address] ?? { allEventCount: 0, eventCounts: {} };
+      profileData[mod2.address] = data;
+      data.allEventCount += 1;
+      data.eventCounts[eventName] = (data.eventCounts[eventName] ?? 0) + 1;
+      if (eventName === "querySendStarted") {
+        const { query, payloads = [] } = args;
+        const pairs = await PayloadBuilder10.dataHashPairs(payloads);
+        const foundPair = pairs.find(([, hash]) => hash === query.query);
+        if (foundPair) {
+          const [payload] = foundPair;
+          console.log(`querySendStarted: ${payload.schema}`);
+        }
+      }
+      if (eventName === "querySendFinished") {
+        const { query } = args;
+        console.log(`querySendFinished: ${query.query}`);
+      }
+      if (data.allEventCount % DISPLAY_EVENT_COUNT_FREQUENCY === 0) {
+        console.log(`[PROFILE] - ${mod2.id} Event Counts:`);
+        console.log(data.eventCounts);
+      }
+    }
+  });
+};
+
+// src/PubSubBridgeCaller.ts
+import { assertEx as assertEx28 } from "@xylabs/assert";
+import { asBridgeInstance } from "@xyo-network/bridge-model";
+import { BridgedPubSubModuleName } from "@xyo-network/os-model";
+var PubSubBridgeCaller = class {
+  constructor(node) {
+    this.node = node;
+  }
+  async exposeAddresses(addresses, options) {
+    const pubSubBridge = await this.getPubSubBridge();
+    for (const address of addresses) {
+      console.log(`Exposing: ${address}`);
+      await pubSubBridge.expose(address, options);
+    }
+  }
+  async unExposeAddresses(addresses) {
+    const pubSubBridge = await this.getPubSubBridge();
+    for (const address of addresses) {
+      await pubSubBridge.unexpose?.(address);
+    }
+  }
+  async getPubSubBridge() {
+    const mod = assertEx28(await this.node.resolve(BridgedPubSubModuleName), () => `${BridgedPubSubModuleName} not found`);
+    return asBridgeInstance(mod, () => `${BridgedPubSubModuleName} is not a bridge`);
+  }
+};
+export {
+  AbstractXnsCaller,
+  AccessNodeQueries,
+  DappAccessCaller,
+  DappAccessRequestEvent,
+  DappAccessRequestQueries,
+  DappAccessRequestResource,
+  DappArchivistModuleName,
+  DappArchivistPayloadDivinerModuleName,
+  DappCaller,
+  DappCallerBase,
+  DappContextCreator,
+  DappDefaultsResource,
+  DappDefaultsResourceQueries,
+  DappIntentCaller,
+  DappIntentResource,
+  DappMenuCaller,
+  DappMenuResource,
+  DappRegistrationService,
+  DappRegistry,
+  DappSeedPhraseRepository,
+  DappsArchivistDevelopmentModuleName,
+  DappsArchivistModuleName,
+  DappsArchivistPayloadDevelopmentDivinerModuleName,
+  DappsArchivistPayloadDivinerModuleName,
+  DevelopArchivist,
+  EventBus,
+  EventBusConnection,
+  EventBusPubSubConnection,
+  ExposeDappRequestEvent,
+  ExternalModulePermissions,
+  IntentArchivistModuleName,
+  IntentArchivistPayloadDivinerModuleName,
+  ManageSystemDapps,
+  ModuleOffsetPaths,
+  NameTransforms,
+  NetworkAdapter,
+  NodeSentinel,
+  OsBadgeCaller,
+  OsBadgeResource,
+  OsCallerBase,
+  OsPubSubBridgeNetworkAdapters,
+  OsPubSubNetworkReadyEvent,
+  OsPubSubNetworkStack,
+  OsSettingsAdapters,
+  OsSettingsCaller,
+  OsSettingsCallerBase,
+  OsSettingsQueries,
+  OsSettingsReadyEvent,
+  OsSettingsResource,
+  OsSettingsStack,
+  OsStackMap,
+  OsXyoPublicNetworkAdapters,
+  OsXyoPublicNetworkReadyEvent,
+  PayloadStore,
+  PubSubBridgeCaller,
+  RegisteredDappInterfacesArchivistModuleName,
+  RemoteNodeArchivistOffsetPaths,
+  RunningDappAccessCache,
+  RunningDappCache,
+  SettingsAdapter,
+  Signers,
+  StackBase,
+  StackManager,
+  ValidDappAccessInterfaces,
+  XnsArchivistModuleName,
+  XnsArchivistPayloadDivinerModuleName,
+  XnsRegistrationsArchivistModuleName,
+  XnsRegistrationsResource,
+  XnsRegistrationsResourceQueries,
+  XyOs,
+  XyOsContextBase,
+  XyOsDapp,
+  XyOsMonitor,
+  XyoPublicNetworkStack,
+  asPayload,
+  buildUserWalletSeedPhrasePayload,
+  buildWalletSeedPhrasePayload,
+  createDappContext,
+  createInsertable,
+  dappAccessRequestConnection,
+  dappsReadyConnection,
+  exposeDappRequestConnection,
+  getApiDomain,
+  initializeXns,
+  isAnyPayload,
+  isObject,
+  isPayload,
+  loadOsNode,
+  manifestReplacementTokens,
+  os_node_manifest_default as osNodeManifest,
+  osPubSubNetworkReadyConnection,
+  osSettingsReadyConnection,
+  osXyoPublicNetworkReadyConnection,
+  profileData,
+  profileModuleEvents,
+  renameObjKey,
+  tokenPlacesSplit,
+  tokenPlacesSplitString,
+  userWalletLabel
+};
+//# sourceMappingURL=index.mjs.map