@xyo-network/os-runtime 7.4.0 → 7.4.2

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

@@ -0,0 +1,2044 @@
+// src/scripts/xyos/index.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/scripts/xyos/command/config.ts
+var commandConfig = (argv) => {
+  return argv.command("config [action] <target>", "Create an xyos project", (yargs2) => {
+    return yargs2.positional("action", {
+      choices: ["create", "validate", "display"],
+      description: "Action to take on config",
+      type: "string"
+    }).positional("target", {
+      description: "Location of config file",
+      type: "string"
+    });
+  }, async ({ action, target }) => {
+    console.log(`Taking action [${action}] on manifest at ${target}`);
+    return await Promise.resolve();
+  });
+};
+
+// src/scripts/xyos/lib/createFromTemplate.ts
+var createFromTemplate = async ({ target, template }) => {
+  console.log("Creating from template", template, "at", target);
+  return await Promise.resolve();
+};
+
+// src/scripts/xyos/lib/headless.ts
+import fs from "node:fs";
+import { boot as boot2 } from "@xyo-network/bios";
+import { Kernel as Kernel2 } from "@xyo-network/kernel";
+import { HDWallet as HDWallet5 } from "@xyo-network/sdk-js";
+import chalk from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+import tk from "terminal-kit";
+
+// src/XyOs.ts
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { boot } from "@xyo-network/bios";
+import { Kernel } from "@xyo-network/kernel";
+import { ModuleFactoryLocator as ModuleFactoryLocator6 } from "@xyo-network/sdk-js";
+
+// src/event/bus/Connection.ts
+import { assertEx, BaseEmitter } from "@xylabs/sdk-js";
+var EventBusConnection = class extends BaseEmitter {
+  _id;
+  description;
+  type;
+  constructor(request) {
+    super({});
+    this.description = request.description;
+    this.type = request.type;
+  }
+  get id() {
+    return assertEx(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 assertEx2,
+  findAs,
+  forget
+} from "@xylabs/sdk-js";
+import { asArchivistInstance } from "@xyo-network/archivist";
+import {
+  asOptionalEventBusEvent,
+  isPubSubConnections
+} from "@xyo-network/os-model";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { asSchema } from "@xyo-network/payload-model";
+import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/sdk-js";
+import { Mutex } from "async-mutex";
+import { v4 as uuid } 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 asArchivistInstance(
+      assertEx2(this._archivist, () => "Archivist not found.  Did you forget to call start()?"),
+      "not a valid archivist instance",
+      { required: true }
+    );
+  }
+  addConnection(connection) {
+    const id = uuid();
+    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 = findAs(payloads, asOptionalEventBusEvent);
+        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: asSchema("network.xyo.event.bus.event", true) };
+        const eventPayloads = payloads ?? [];
+        event.sources = await PayloadBuilder.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/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/lib/initializeXns.ts
+import { asDivinerInstance } from "@xyo-network/diviner-model";
+import { ResolveHelper } from "@xyo-network/module";
+import { NameRegistrarTransformer } from "@xyo-network/module-resolver";
+var initializeXns = async (xnsNode) => {
+  if (ResolveHelper.transformers.length === 0) {
+    const registrarDiviner = asDivinerInstance(await xnsNode?.resolve("AddressRecords:AddressRecordIndexDiviner"));
+    if (registrarDiviner) {
+      const transformer = new NameRegistrarTransformer(registrarDiviner, "xyo");
+      ResolveHelper.transformers = [transformer];
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/lib/NameTransforms.ts
+var NameTransforms = class _NameTransforms {
+  value;
+  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/loadOsNode.ts
+import { IndexedDbArchivist } from "@xyo-network/archivist-indexeddb";
+import { IndexedDbPayloadDiviner } from "@xyo-network/diviner-payload-indexeddb";
+import { ManifestWrapper, ModuleFactoryLocator } from "@xyo-network/sdk-js";
+
+// 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-2025-01-13",
+              labels: {
+                "network.xyo.archivist.persistence.scope": "device"
+              },
+              storeName: "payloads",
+              parents: {
+                read: [
+                  "Archivist"
+                ]
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "3'",
+              name: "DappsArchivist",
+              dbName: "DappsArchivist-2025-01-13",
+              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.generic.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "4'",
+              dbName: "IntentArchivist-2025-01-13",
+              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.generic.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/loadOsNode.ts
+var OS_NODE_PATH = "1'";
+var getDefaultOsNodeLocator = () => {
+  const locator = new ModuleFactoryLocator();
+  locator.register(IndexedDbArchivist.factory(), { "network.xyo.archivist.persistence.scope": "device" });
+  locator.register(IndexedDbPayloadDiviner.factory(), { "network.xyo.archivist.persistence.scope": "device" });
+  return locator;
+};
+var loadOsNode = async (osWallet, locator) => {
+  try {
+    const osNodeWallet = await osWallet.derivePath(OS_NODE_PATH);
+    const osNodeLocator = locator ?? getDefaultOsNodeLocator();
+    const manifestWrapper = new ManifestWrapper(os_node_manifest_default, osNodeWallet, osNodeLocator);
+    const osNode = (await manifestWrapper.loadNodes())[0];
+    return [osNode];
+  } 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}`, { cause: e });
+  }
+};
+
+// src/registration/DappRegistrationService.ts
+import {
+  forget as forget2,
+  fulfilled,
+  rejected
+} from "@xylabs/sdk-js";
+import {
+  DappIntentTypes,
+  DappMode as DappMode2,
+  isRegisteredDappAccessDappSet,
+  isRegisteredDappExposedDappSet
+} from "@xyo-network/os-model";
+import { ModuleFactoryLocator as ModuleFactoryLocator5 } from "@xyo-network/sdk-js";
+
+// src/intent/Caller.ts
+import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
+import { DappIntentSchema, DappMode } from "@xyo-network/os-model";
+
+// src/DappCallerBase.ts
+import { assertEx as assertEx3, toSafeJsonString } from "@xylabs/sdk-js";
+import { asArchivistInstance as asArchivistInstance2 } from "@xyo-network/archivist-model";
+import { asDivinerInstance as asDivinerInstance2 } from "@xyo-network/diviner-model";
+var DappArchivistModuleName = "DappArchivist";
+var IntentArchivistModuleName = "IntentArchivist";
+var IntentArchivistPayloadDivinerModuleName = "IntentArchivistPayloadDiviner";
+var DappArchivistPayloadDivinerModuleName = "DappArchivistPayloadDiviner";
+var DappCallerBase = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Get the DappArchivist
+   */
+  async getDappArchivist() {
+    const mod = assertEx3(
+      await this.context.root.resolve(DappArchivistModuleName),
+      () => `${DappArchivistModuleName} not found [${toSafeJsonString(this.context.root.publicChildren())}]`
+    );
+    return asArchivistInstance2(mod, () => `${DappArchivistModuleName} is not an archivist`, { required: true });
+  }
+  /**
+   * Get the DappArchivistPayloadDiviner
+   */
+  async getDappArchivistPayloadDiviner() {
+    const mod = assertEx3(
+      await this.context.root.resolve(DappArchivistPayloadDivinerModuleName),
+      () => `${DappArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
+  }
+  /**
+   * Get the IntentArchivist
+   */
+  async getDappIntentArchivist() {
+    const mod = assertEx3(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`);
+    return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`, { required: true });
+  }
+  // Get the IntentArchivistPayloadDiviner
+  async getDappIntentArchivistPayloadDiviner() {
+    const mod = assertEx3(
+      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
+      () => `${IntentArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
+  }
+};
+
+// src/intent/Caller.ts
+var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
+  static OsDappName = "XyOs";
+  constructor(context) {
+    super(context);
+  }
+  /**
+   * Build a new intent
+   * @param sourceDappId
+   * @param intent
+   * @param targetDappId
+   * @param targetMode
+   * @param params?
+   * @returns DappIntent
+   */
+  static buildIntent(sourceDappId, intent, targetDappId, targetMode = DappMode.Window, params) {
+    return {
+      intent,
+      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: PayloadDivinerQuerySchema,
+      sourceDappId: dappName
+    };
+    return await diviner.divine([query]);
+  }
+};
+
+// src/system/ManageSystemDapps.ts
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import semver from "semver";
+
+// src/OsCallerBase.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { asArchivistInstance as asArchivistInstance3 } from "@xyo-network/archivist-model";
+import { asDivinerInstance as asDivinerInstance3 } from "@xyo-network/diviner-model";
+var DappsArchivistModuleName = "DappsArchivist";
+var DappsArchivistDevelopmentModuleName = `${DappsArchivistModuleName}Development`;
+var DappsArchivistPayloadDivinerModuleName = "DappsArchivistPayloadDiviner";
+var DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`;
+var RegisteredDappInterfacesArchivistModuleName = "RegisteredDappInterfacesArchivist";
+var OsCallerBase = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  // Get the dapps archivist
+  async getDappsArchivist() {
+    const mod = assertEx4(await this.context.root.resolve(DappsArchivistModuleName), () => `${DappsArchivistModuleName} not found`);
+    return asArchivistInstance3(mod, () => `${DappsArchivistModuleName} is not an archivist`, { required: true });
+  }
+  // Get the dapps archivist development
+  async getDappsArchivistDevelopment() {
+    const mod = assertEx4(
+      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
+      () => `${DappsArchivistDevelopmentModuleName} not found`
+    );
+    return asArchivistInstance3(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`, { required: true });
+  }
+  // Get the dapps archivist payload diviner
+  async getDappsArchivistPayloadDiviner() {
+    const mod = assertEx4(
+      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
+      () => `${DappsArchivistPayloadDivinerModuleName} not found`
+    );
+    return asDivinerInstance3(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`, { required: true });
+  }
+  // Get the dapps archivist payload diviner development
+  async getDappsArchivistPayloadDivinerDevelopment() {
+    const mod = assertEx4(
+      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
+      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`
+    );
+    return asDivinerInstance3(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`, { required: true });
+  }
+  // Get the registered dapp interfaces archivist
+  async getRegisteredDappInterfacesArchivist() {
+    const mod = assertEx4(
+      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
+      () => `${RegisteredDappInterfacesArchivistModuleName} not found`
+    );
+    return asArchivistInstance3(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`, { required: true });
+  }
+};
+
+// src/system/Queries.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema2 } from "@xyo-network/diviner-payload-model";
+import {
+  DappConfigSchema,
+  DappIconSchema,
+  DappWidgetConfigSchema,
+  UnregisteredDappAccessSchema
+} from "@xyo-network/os-model";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+var SystemDappQueries = {
+  async getDappAccess(diviner, name, version) {
+    const accessQuery = {
+      order: "desc",
+      registeringDappId: name,
+      schema: PayloadDivinerQuerySchema2,
+      schemas: [UnregisteredDappAccessSchema],
+      version
+    };
+    return await diviner.divine([accessQuery]);
+  },
+  async getLatestConfig(diviner, name) {
+    const configQuery = {
+      limit: 1,
+      name,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema2,
+      schemas: [DappConfigSchema]
+    };
+    const [dappConfig] = await diviner.divine([configQuery]);
+    return dappConfig;
+  },
+  async getLatestIcon(diviner, name, version) {
+    const iconQuery = {
+      name,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema2,
+      schemas: [DappIconSchema],
+      version
+    };
+    const [dappIcon] = await diviner.divine([iconQuery]);
+    return dappIcon;
+  },
+  async getWidgetConfigs(diviner, name, version) {
+    const widgetConfigQuery = {
+      dappId: name,
+      order: "desc",
+      schema: PayloadDivinerQuerySchema2,
+      schemas: [DappWidgetConfigSchema],
+      version
+    };
+    const widgetConfigs = await diviner.divine([widgetConfigQuery]);
+    const uniqueConfigs = {};
+    for (const widgetConfig of widgetConfigs) {
+      const hash = await PayloadBuilder2.dataHash(widgetConfig);
+      uniqueConfigs[widgetConfig.mode ?? hash] = widgetConfig;
+    }
+    return Object.values(uniqueConfigs);
+  }
+};
+
+// src/system/ManageSystemDapps.ts
+var ManageSystemDapps = class extends OsCallerBase {
+  defaultSystemDappParams;
+  defaultSystemDapps;
+  defaultSystemNames;
+  developmentMode;
+  locator;
+  onErrorCallbacks = [];
+  constructor(context, defaultSystemNames, defaultSystemDapps, defaultSystemDappParams, locator, developmentMode) {
+    super(context);
+    this.defaultSystemNames = defaultSystemNames;
+    this.defaultSystemDapps = defaultSystemDapps;
+    this.defaultSystemDappParams = defaultSystemDappParams;
+    this.locator = locator;
+    this.developmentMode = developmentMode;
+  }
+  /**
+   * Add a callback to listen for errors throwing during system dapp registration
+   * @param errorListener
+   */
+  addErrorListener(errorListener) {
+    this.onErrorCallbacks.push(errorListener);
+  }
+  /**
+   * Installs the dapps into the OS and builds the appropriate DappSet
+   */
+  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 PayloadBuilder3.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/wallet/DappSeedPhraseRepository.ts
+import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema3 } from "@xyo-network/diviner-payload-model";
+import { DappWalletSeedPhraseSchema } from "@xyo-network/os-model";
+import { HDWallet } from "@xyo-network/sdk-js";
+import { v4 as uuid2 } from "uuid";
+var DappSeedPhraseRepository = class extends OsCallerBase {
+  allowedNames;
+  // record of all dapps that have requested a seed phrase with the OS
+  dappIdRepository = /* @__PURE__ */ new Map();
+  // record of all walletIds that have been issued to registered dapps
+  walletIdRepository = /* @__PURE__ */ new Map();
+  constructor(xyOs, allowedNames) {
+    super(xyOs);
+    this.allowedNames = allowedNames;
+  }
+  async add(dappId) {
+    const archivist = await this.getDappsArchivist();
+    const seedPhrase = this.newPhrase();
+    const walletId = uuid2();
+    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}`, { cause: e });
+      }
+    } 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: PayloadDivinerQuerySchema3,
+      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: PayloadDivinerQuerySchema3,
+      schemas: [DappWalletSeedPhraseSchema],
+      walletId
+    };
+    const results = await diviner.divine([query]);
+    return results.length > 0 ? results[0] : void 0;
+  }
+  newPhrase() {
+    return HDWallet.generateMnemonic();
+  }
+};
+
+// src/XyOsDapp.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { DappPackageManifestPayloadSchema } from "@xyo-network/os-model";
+import {
+  ManifestWrapper as ManifestWrapper2,
+  ModuleFactoryLocator as ModuleFactoryLocator3
+} from "@xyo-network/sdk-js";
+
+// 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.generic.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest.package.dapp"
+};
+
+// src/XyOsBase.ts
+import { assertEx as assertEx5, BaseEmitter as BaseEmitter2 } from "@xylabs/sdk-js";
+import { ModuleFactoryLocator as ModuleFactoryLocator2 } from "@xyo-network/sdk-js";
+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 assertEx5(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 assertEx5(this.params.manifest, () => "Missing manifest");
+  }
+  get platformLocator() {
+    this._platformLocator = this._platformLocator ?? this.params.platformLocator ?? new ModuleFactoryLocator2();
+    return this._platformLocator;
+  }
+  get possibleRoot() {
+    return this._root;
+  }
+  get root() {
+    return assertEx5(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 assertEx6(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);
+      assertEx6(this._root === void 0, () => "Dapp already booted");
+      const finalLocator = locator ? (this.params.locator ?? new ModuleFactoryLocator3()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator3();
+      console.log("XyOsDapp:boot:finalLocator", finalLocator);
+      const dappNodesWrapper = new ManifestWrapper2({ ...this.manifest, schema: DappPackageManifestPayloadSchema }, wallet, finalLocator);
+      const dappNodes = await dappNodesWrapper.loadNodes();
+      const manifest = dapp_window_manifest_default;
+      const dappManifestWallet = await wallet.derivePath("99999");
+      manifest.nodes[0].config.name = this.dapp.name + "Root";
+      const wrapper = new ManifestWrapper2(
+        { ...manifest, schema: DappPackageManifestPayloadSchema },
+        dappManifestWallet,
+        finalLocator
+      );
+      const node = await wrapper.loadNodeFromIndex(0);
+      for (const dappNode of dappNodes) {
+        await node.register(dappNode);
+        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/registration/DappRegistry.ts
+import {
+  DappRegisteredSchema,
+  DappRegisteredState,
+  isRegisteredDappAccess
+} from "@xyo-network/os-model";
+import { HDWallet as HDWallet3 } from "@xyo-network/sdk-js";
+
+// src/registration/ValidateDappAccessDiviner/Config.ts
+import { asSchema as asSchema2, isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var FailedAccessorSchema = asSchema2("network.xyo.os.failed.accessor.registration", true);
+var isFailedAccessor = isPayloadOfSchemaType(FailedAccessorSchema);
+var ValidateDappAccessDivinerConfigSchema = asSchema2("network.xyo.os.dapp.access.registration.validate", true);
+
+// src/registration/ValidateDappAccessDiviner/Diviner.ts
+import { AbstractDiviner } from "@xyo-network/diviner-abstract";
+import {
+  isDappPackageManifestPayload,
+  isUnregisteredDappAccess,
+  RegisteredDappAccessSchema
+} from "@xyo-network/os-model";
+import {
+  HDWallet as HDWallet2,
+  ManifestWrapper as ManifestWrapper3,
+  ModuleFactoryLocator as ModuleFactoryLocator4,
+  PackageManifestPayloadSchema
+} from "@xyo-network/sdk-js";
+
+// src/models/access/ValidDappAccessInterfaces.ts
+import { RegisteredNames, RegisteredNamesInterface } from "@xyo-network/os-model";
+var ValidDappAccessInterfaces = { [RegisteredNames]: RegisteredNamesInterface };
+
+// src/registration/ValidateDappAccessDiviner/Diviner.ts
+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.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 = {
+              ...access,
+              schema: RegisteredDappAccessSchema,
+              timestamp: Date.now()
+            };
+            registeredAccessors.push(payload);
+          } else {
+            const failedRegistration = {
+              accessor: access,
+              errorMessage: "Invalid dapp access interface",
+              schema: FailedAccessorSchema
+            };
+            failedAccessors.push(failedRegistration);
+          }
+        }
+      } catch (e) {
+        failedAccessors.push(
+          {
+            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 ManifestWrapper3(manifestToTest, await HDWallet2.random(), dappParams.locator ?? new ModuleFactoryLocator4());
+  return await dappManifestWrapper.loadNodes();
+};
+
+// src/registration/DappRegistry.ts
+var DappRegistry = class {
+  dappRegistry = /* @__PURE__ */ new Map();
+  dappSeedPhraseRepository;
+  constructor(dappSeedPhraseRepository) {
+    this.dappSeedPhraseRepository = dappSeedPhraseRepository;
+  }
+  /**
+   * Register a Dapp with window manager and if successful, return its id
+   * @param dapp Manifest and UI of the Dapp to register
+   * @returns dapp with registration fields
+   */
+  async registerDapp(dapp) {
+    if (dapp) {
+      const {
+        exposedModuleIds,
+        manifest,
+        modes,
+        name,
+        version,
+        params,
+        widgetConfigs
+      } = this.extractDappProperties(dapp);
+      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 HDWallet3.random(),
+      config: { schema: ValidateDappAccessDivinerConfigSchema },
+      dappParams: params
+    });
+    const payloads = await validateDappAccess.divine([manifest, ...accessors]);
+    const failedAccessors = payloads.filter(isFailedAccessor);
+    const registeredAccessors = payloads.filter(isRegisteredDappAccess);
+    if (failedAccessors.length > 0) {
+      console.error("Failed to register all dapp accessors", failedAccessors);
+    }
+    return registeredAccessors;
+  }
+};
+
+// src/registration/DappRegistrationService.ts
+var DappRegistrationService = class {
+  // 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();
+  context;
+  dappAccessRequestConnection = dappAccessRequestConnection();
+  developmentMode;
+  exposeDappRequestConnection = exposeDappRequestConnection();
+  locator;
+  params;
+  constructor(context, params, locator = new ModuleFactoryLocator5(), developmentMode) {
+    this.context = context;
+    this.params = params ?? {
+      dappNames: [],
+      dappParams: {},
+      dappPayloads: []
+    };
+    this.locator = locator;
+    this.developmentMode = developmentMode;
+    this.manageSystemDapps = new ManageSystemDapps(
+      context,
+      this.params?.dappNames ?? [],
+      this.params?.dappPayloads ?? [],
+      this.params?.dappParams ?? {},
+      this.locator,
+      this.developmentMode
+    );
+    this.dappSeedPhraseRepository = new DappSeedPhraseRepository(context, this.params?.dappNames ?? []);
+    this.dappRegistry = new DappRegistry(this.dappSeedPhraseRepository);
+    this.addConnectionRequests();
+  }
+  async buildDapp(manifest, dappId = NameTransforms.slug(manifest.nodes[0]?.config.name), name = NameTransforms.moduleName(manifest.nodes[0]?.config.name)) {
+    const dapp = new XyOsDapp({
+      dapp: { id: dappId, name },
+      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) => {
+      const reason = result.reason;
+      return reason instanceof Error ? reason.message : String(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,
+          DappIntentTypes.Launch,
+          registeredDapp.dapp.config.name,
+          DappMode2.Exposed
+        );
+        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, { payloads: [registeredDapp.dapp.config, exposeIntent] });
+      }
+      if (isRegisteredDappAccessDappSet(registeredDapp)) {
+        this.registeredAccessDappSets.add(registeredDapp);
+        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, { payloads: registeredDapp.dapp.accessors });
+      }
+    }
+  }
+};
+
+// src/signer/Signers.ts
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { HDWallet as HDWallet4 } from "@xyo-network/sdk-js";
+var Signers = class {
+  _paths;
+  _signerAccounts;
+  _walletStore;
+  constructor(paths, walletStore) {
+    this._paths = paths;
+    this._walletStore = walletStore;
+    this._signerAccounts = /* @__PURE__ */ new Map();
+  }
+  get paths() {
+    return assertEx7(this._paths, () => "Paths not initialized");
+  }
+  get signerAccounts() {
+    return assertEx7(this._signerAccounts, () => "Signer accounts not initialized");
+  }
+  get walletStore() {
+    return assertEx7(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) {
+    assertEx7(signerName, () => "Name not found in signer paths");
+    assertEx7(path, () => "Path not found in signer paths");
+    const phrase = assertEx7(await this.walletStore.get(walletKindName), () => `Wallet not found: ${walletKindName}`);
+    if (path) {
+      const signerMap = this.signerAccounts.get(walletKindName) ?? /* @__PURE__ */ new Map();
+      const wallet = await HDWallet4.fromPhrase(phrase);
+      const derivedWallet = await wallet.derivePath(path);
+      signerMap.set(signerName, derivedWallet);
+      this.signerAccounts.set(walletKindName, signerMap);
+    }
+  }
+};
+
+// src/stack/Base.ts
+import {
+  assertEx as assertEx8,
+  BaseEmitter as BaseEmitter3,
+  forget as forget3
+} from "@xylabs/sdk-js";
+import { isModuleInstance } from "@xyo-network/module-model";
+import { asAttachableNodeInstance } from "@xyo-network/node-model";
+var StackBase = class extends BaseEmitter3 {
+  // 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(assertEx8(this.context.kernel, () => "Kernel access required"));
+    this._stackNodeModuleId = stackNodeModuleId;
+  }
+  get adapterSet() {
+    return assertEx8(this._adapterSet, () => `${this.stackNodeModuleId} adapters not initialized`);
+  }
+  get context() {
+    return assertEx8(this._context, () => `${this.stackNodeModuleId} stack context not initialized`);
+  }
+  get stack() {
+    return assertEx8(this._stack, () => `${this.stackNodeModuleId} stack node not initialized`);
+  }
+  get stackNodeModuleId() {
+    return assertEx8(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 = assertEx8(await this.context.root.resolve(this.stackNodeModuleId), () => `${this.stackNodeModuleId} not found`);
+    return asAttachableNodeInstance(mod, () => `${this.stackNodeModuleId} not a NodeInstance`, { required: true });
+  }
+  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 assertEx9,
+  BaseEmitter as BaseEmitter4,
+  forget as forget4
+} from "@xylabs/sdk-js";
+import { asArchivistInstance as asArchivistInstance4 } from "@xyo-network/archivist";
+import { asAttachableNodeInstance as asAttachableNodeInstance2 } from "@xyo-network/node-model";
+import {
+  asSchema as asSchema3
+} from "@xyo-network/payload-model";
+import { v4 as uuid3 } from "uuid";
+var NodeAdapterBase = class extends BaseEmitter4 {
+  initialized = false;
+  _id = "";
+  driverName;
+  kernel;
+  constructor(kernel, driverName) {
+    super({});
+    this._id = uuid3();
+    this.kernel = kernel;
+    this.driverName = driverName;
+  }
+  get id() {
+    return assertEx9(this._id, () => "NodeAdapterBase id not initialized");
+  }
+  async start() {
+    try {
+      const moduleAttachedInsertListener = ({ 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 === asSchema3("network.xyo.kernel.module.event", true);
+    });
+  }
+  async getEventsArchivist() {
+    const mod = assertEx9(await (await this.kernel.getNode()).resolve("KernelNode:ModuleEvents"), () => "KernelNode:ModuleEvents not found");
+    return asArchivistInstance4(mod, () => `${mod.id} is not an archivist`, { required: true });
+  }
+  validateAndReturnDriver() {
+    const mod = this.kernel.initialized[this.driverName];
+    if (mod) {
+      const node = asAttachableNodeInstance2(mod, () => `${mod.id} is not a node`, { required: true });
+      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 assertEx10 } from "@xylabs/sdk-js";
+import { asAttachableNodeInstance as asAttachableNodeInstance3, asNodeInstance } from "@xyo-network/node-model";
+import { ExposedNodeOuterNodeName as ExposedNodeOuterNodeName2, PubSubBridgeNodeNodeName as PubSubBridgeNodeNodeName2 } from "@xyo-network/os-model";
+var OsPubSubNetworkStack = class extends StackBase {
+  _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 = assertEx10(await node.resolve("NsHttpBridge"), () => "HttpBridge not found");
+        const xnsNode = asNodeInstance(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 = assertEx10(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 ModuleFactoryLocator6(),
+    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 assertEx11(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 assertEx11(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 ModuleFactoryLocator6()) {
+    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");
+      }
+      assertEx11(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 assertEx11(this.stackManager.getStack(stackName), () => `Stack not found: ${stackName}`);
+  }
+  async monitor(fn, eventConfig) {
+    return await _XyOs.monitor(fn, eventConfig);
+  }
+  shutdown() {
+    assertEx11(this._root !== void 0, () => "XyOs not booted");
+    this._root = void 0;
+    this.stackManager.stop();
+  }
+};
+
+// src/scripts/xyos/lib/headless.ts
+var { terminal } = tk;
+var terminate = () => {
+  terminal.grabInput(false);
+  setTimeout(function() {
+    process.exit(0);
+  }, 100);
+};
+var headless = async ({
+  manifest,
+  config,
+  kernelDrivers
+} = {}) => {
+  console.log(chalk.green("Starting Headless xyOS..."));
+  const configExplorer = cosmiconfig("xyos", { cache: true, loaders: { ".ts": TypeScriptLoader() } });
+  const configResult = await (config ? configExplorer.load(config) : configExplorer.search());
+  const xyosConfig = configResult?.config ?? {};
+  const manifestToLoad = manifest ?? (typeof xyosConfig.manifest === "string" ? xyosConfig.manifest : void 0);
+  const manifestObject = manifestToLoad ? JSON.parse(fs.readFileSync(manifestToLoad, "utf8")) : typeof xyosConfig.manifest === "object" ? xyosConfig.manifest : void 0;
+  const osWallet = await HDWallet5.random();
+  const kernel = new Kernel2({ logColor: "cyan", logger: console });
+  await kernel.boot(await boot2(), { kernelDrivers });
+  const xyOs = new XyOs({
+    kernel,
+    stackMap: {},
+    manifest: manifestObject,
+    developmentMode: xyosConfig.developmentMode
+  });
+  await xyOs.boot(osWallet);
+  console.log(chalk.green("Started Headless xyOS..."));
+  terminal.grabInput({ mouse: "button" });
+  terminal.on("key", function(name) {
+    console.log("'key' event:", name);
+    if (name === "CTRL_C") {
+      terminate();
+    }
+  });
+};
+
+// src/scripts/xyos/command/create.ts
+var commandCreate = (argv) => {
+  return argv.command("create [template] <target>", "Create an xyos project", (yargs2) => {
+    return yargs2.positional("template", {
+      choices: ["react", "headless", "dapp", "diviner", "witness"],
+      description: "Template to use",
+      type: "string"
+    }).positional("target", {
+      description: "Location into which to create the template project",
+      type: "string"
+    });
+  }, async ({ template, target }) => {
+    console.log(`Using template ${template} at location ${target}`);
+    return await createFromTemplate({ target, template });
+  });
+};
+
+// src/scripts/xyos/command/manifest.ts
+var commandManifest = (argv) => {
+  return argv.command("manifest [action] <target>", "Create an xyos project", (yargs2) => {
+    return yargs2.positional("action", {
+      choices: ["create", "validate", "display"],
+      description: "Action to take on manifest",
+      type: "string"
+    }).positional("target", {
+      description: "Location of manifest file",
+      type: "string"
+    });
+  }, async ({ action, target }) => {
+    console.log(`Taking action [${action}] on manifest at ${target}`);
+    return await Promise.resolve();
+  });
+};
+
+// src/scripts/xyos/command/start.ts
+var commandStart = (argv) => {
+  return argv.command("start", "Start xyOS in headless mode", (yargs2) => {
+    return yargs2.option("config", {
+      alias: "c",
+      description: "Config file to use",
+      type: "string"
+    }).option("manifest", {
+      alias: "m",
+      description: "Manifest file to use",
+      type: "string"
+    }).option("kernelDriver", {
+      alias: "k",
+      description: "Kernel driver to load",
+      type: "string"
+    });
+  }, async ({
+    config,
+    manifest,
+    kernelDriver
+  }) => {
+    if (config) {
+      console.log(`Using config: ${config}`);
+    }
+    if (config) {
+      console.log(`Using manifest: ${manifest}`);
+    }
+    await headless({
+      manifest,
+      config,
+      kernelDrivers: kernelDriver ? [kernelDriver] : []
+    });
+  });
+};
+
+// src/scripts/xyos/index.ts
+commandManifest(
+  commandConfig(
+    commandCreate(
+      commandStart(
+        yargs(
+          hideBin(
+            process.argv
+          )
+        )
+      )
+    )
+  )
+).usage("Usage: $0 <command> [options]").scriptName("xyos").demandCommand(1).parse().catch(
+  console.error
+);
+//# sourceMappingURL=index.mjs.map