@xyo-network/os-runtime 4.3.0 → 5.0.0

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

@@ -1,2138 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/scripts/xyos/index.ts
-import { default as yargs } from "yargs";
-import { hideBin } from "yargs/helpers";
-
-// src/scripts/xyos/command/config.ts
-var commandConfig = /* @__PURE__ */ __name((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();
-  });
-}, "commandConfig");
-
-// src/scripts/xyos/lib/createFromTemplate.ts
-var createFromTemplate = /* @__PURE__ */ __name(async ({ target, template }) => {
-  console.log("Creating from template", template, "at", target);
-  return await Promise.resolve();
-}, "createFromTemplate");
-
-// src/scripts/xyos/lib/headless.ts
-import fs from "node:fs";
-import { HDWallet as HDWallet5 } from "@xyo-network/account";
-import { boot as boot2 } from "@xyo-network/bios";
-import { Kernel as Kernel2 } from "@xyo-network/kernel";
-import chalk from "chalk";
-import { cosmiconfig } from "cosmiconfig";
-import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
-import { default as tk } from "terminal-kit";
-
-// src/XyOs.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
-import { boot } from "@xyo-network/bios";
-import { Kernel } from "@xyo-network/kernel";
-import { ModuleFactoryLocator as ModuleFactoryLocator5 } from "@xyo-network/module-factory-locator";
-
-// src/wallet/DappSeedPhraseRepository.ts
-import { HDWallet } from "@xyo-network/account";
-import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
-import { DappWalletSeedPhraseSchema } from "@xyo-network/os-model";
-import { v4 as uuid } from "uuid";
-
-// 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 {
-  static {
-    __name(this, "OsCallerBase");
-  }
-  context;
-  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/wallet/DappSeedPhraseRepository.ts
-var DappSeedPhraseRepository = class extends OsCallerBase {
-  static {
-    __name(this, "DappSeedPhraseRepository");
-  }
-  allowedNames;
-  // record of all dapps that have requested a seed phrase with the OS
-  dappIdRepository;
-  // record of all walletIds that have been issued to registered dapps
-  walletIdRepository;
-  constructor(xyOs, allowedNames) {
-    super(xyOs), this.allowedNames = allowedNames, this.dappIdRepository = /* @__PURE__ */ new Map(), this.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: PayloadDivinerQuerySchema,
-      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: PayloadDivinerQuerySchema,
-      schemas: [
-        DappWalletSeedPhraseSchema
-      ],
-      walletId
-    };
-    const results = await diviner.divine([
-      query
-    ]);
-    return results.length > 0 ? results[0] : void 0;
-  }
-  newPhrase() {
-    return HDWallet.generateMnemonic();
-  }
-};
-
-// src/DappCallerBase.ts
-import { assertEx as assertEx2 } 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 {
-  static {
-    __name(this, "DappCallerBase");
-  }
-  context;
-  constructor(context) {
-    this.context = context;
-  }
-  /**
-  * Get the DappArchivist
-  */
-  async getDappArchivist() {
-    const mod = assertEx2(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 = assertEx2(await this.context.root.resolve(DappArchivistPayloadDivinerModuleName), () => `${DappArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance2(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`);
-  }
-  /**
-  * Get the IntentArchivist
-  */
-  async getDappIntentArchivist() {
-    const mod = assertEx2(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`);
-    return asArchivistInstance2(mod, () => `${IntentArchivistModuleName} is not an archivist`);
-  }
-  // Get the IntentArchivistPayloadDiviner
-  async getDappIntentArchivistPayloadDiviner() {
-    const mod = assertEx2(await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName), () => `${IntentArchivistPayloadDivinerModuleName} not found`);
-    return asDivinerInstance2(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`);
-  }
-};
-
-// 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/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 = /* @__PURE__ */ __name(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;
-}, "initializeXns");
-
-// src/lib/NameTransforms.ts
-var NameTransforms = class _NameTransforms {
-  static {
-    __name(this, "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/intent/Caller.ts
-import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema2 } from "@xyo-network/diviner-payload-model";
-import { DappIntentSchema, DappMode } from "@xyo-network/os-model";
-var DappIntentCaller = class _DappIntentCaller extends DappCallerBase {
-  static {
-    __name(this, "DappIntentCaller");
-  }
-  static OsDappName = "XyOs";
-  constructor(context) {
-    super(context);
-  }
-  /**
-  * Build a new intent
-  * @param  {DappId} sourceDappId
-  * @param  {DappIntentTypes} intent
-  * @param  {DappId} targetDappId
-  * @param  {DappMode} targetMode
-  * @param  {DappIntent['params']} params?
-  * @returns DappIntent
-  */
-  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: PayloadDivinerQuerySchema2,
-      sourceDappId: dappName
-    };
-    return await diviner.divine([
-      query
-    ]);
-  }
-};
-
-// src/classes/registration/DappRegistrationService.ts
-import { forget as forget2 } from "@xylabs/forget";
-import { fulfilled, rejected } from "@xylabs/promise";
-import { ModuleFactoryLocator as ModuleFactoryLocator3 } from "@xyo-network/module-factory-locator";
-import { DappIntentTypes, DappMode as DappMode2, isRegisteredDappAccessDappSet, isRegisteredDappExposedDappSet } from "@xyo-network/os-model";
-
-// src/event/bus/Connection.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { BaseEmitter } from "@xyo-network/module-event-emitter";
-var EventBusConnection = class extends BaseEmitter {
-  static {
-    __name(this, "EventBusConnection");
-  }
-  _id;
-  description;
-  type;
-  constructor(request) {
-    super({});
-    this.description = request.description;
-    this.type = request.type;
-  }
-  get id() {
-    return assertEx3(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 assertEx4 } from "@xylabs/assert";
-import { forget } from "@xylabs/forget";
-import { asArchivistInstance as asArchivistInstance3, MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist";
-import { isEventBusEvent, isPubSubConnections } from "@xyo-network/os-model";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { Mutex } from "async-mutex";
-import { v4 as uuid2 } from "uuid";
-var EventBus = class {
-  static {
-    __name(this, "EventBus");
-  }
-  // 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 asArchivistInstance3(assertEx4(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 = /* @__PURE__ */ __name(async () => await callback({
-                  payloads
-                }), "forgettable");
-                forget(forgettable());
-              }
-            }
-          }
-        }
-      });
-      return this;
-    });
-  }
-  handlePublisherAdd(connection) {
-    for (const eventName of connection.publishableEvents ?? []) {
-      const connectionPublisherCallback = /* @__PURE__ */ __name(async ({ payloads }) => {
-        const event = {
-          name: eventName,
-          schema: "network.xyo.event.bus.event"
-        };
-        const 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);
-        }
-      }, "connectionPublisherCallback");
-      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 {
-  static {
-    __name(this, "EventBusPubSubConnection");
-  }
-  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 = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(dappAccessRequestConnectionRequest), "dappAccessRequestConnection");
-
-// src/event/connections/ExposeDappRequest.ts
-var ExposeDappRequestEvent = "exposeDappRequest";
-var exposeDappConnectionRequest = {
-  publishableEvents: [
-    ExposeDappRequestEvent
-  ],
-  type: "PubSub"
-};
-var exposeDappRequestConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(exposeDappConnectionRequest), "exposeDappRequestConnection");
-
-// src/event/connections/OsPubSubNetworkReady.ts
-var OsPubSubNetworkReadyEvent = "osPubSubNetworkReady";
-var osPubSubNetworkConnectionRequest = {
-  publishableEvents: [
-    OsPubSubNetworkReadyEvent
-  ],
-  type: "PubSub"
-};
-var osPubSubNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest), "osPubSubNetworkReadyConnection");
-
-// src/event/connections/OsSettingsReady.ts
-var OsSettingsReadyEvent = "osSettingsReady";
-var osSettingsConnectionRequest = {
-  publishableEvents: [
-    OsSettingsReadyEvent
-  ],
-  type: "PubSub"
-};
-var osSettingsReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osSettingsConnectionRequest), "osSettingsReadyConnection");
-
-// src/event/connections/OsXyoPublicReady.ts
-var OsXyoPublicNetworkReadyEvent = "osXyoPublicNetworkReady";
-var osXyoPublicNetworkConnectionRequest = {
-  publishableEvents: [
-    OsXyoPublicNetworkReadyEvent
-  ],
-  type: "PubSub"
-};
-var osXyoPublicNetworkReadyConnection = /* @__PURE__ */ __name(() => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest), "osXyoPublicNetworkReadyConnection");
-
-// src/XyOsDapp.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
-import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
-import { ModuleFactoryLocator as ModuleFactoryLocator2 } from "@xyo-network/module-factory-locator";
-import { DappPackageManifestPayloadSchema } from "@xyo-network/os-model";
-
-// src/manifests/dapp-window.manifest.json
-var dapp_window_manifest_default = {
-  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/compilations/dapp-package-manifest-schema.json",
-  nodes: [
-    {
-      config: {
-        accountPath: "0'",
-        name: "Dapp",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [],
-        public: [
-          {
-            config: {
-              accountPath: "0'/0'",
-              name: "DappArchivist",
-              schema: "network.xyo.archivist.memory.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "0'/1'",
-              archivist: "DappArchivist",
-              labels: {
-                "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
-              },
-              name: "DappArchivistPayloadDiviner",
-              schema: "network.xyo.diviner.payload.generic.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  schema: "network.xyo.manifest.package.dapp"
-};
-
-// src/XyOsBase.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
-import { BaseEmitter as BaseEmitter2 } from "@xyo-network/module-event-emitter";
-import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
-import { Mutex as Mutex2 } from "async-mutex";
-var XyOsContextBase = class extends BaseEmitter2 {
-  static {
-    __name(this, "XyOsContextBase");
-  }
-  _bootMutex = new Mutex2();
-  _platformLocator;
-  _root;
-  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 ModuleFactoryLocator();
-    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 {
-  static {
-    __name(this, "XyOsDapp");
-  }
-  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 ModuleFactoryLocator2()).merge(locator) : this.params.locator ?? new ModuleFactoryLocator2();
-      console.log("XyOsDapp:boot:finalLocator", finalLocator);
-      const dappNodesWrapper = new ManifestWrapper({
-        ...this.manifest,
-        schema: DappPackageManifestPayloadSchema
-      }, wallet, finalLocator);
-      const dappNodes = await dappNodesWrapper.loadNodes();
-      const dappManifestWallet = await wallet.derivePath("99999");
-      dapp_window_manifest_default.nodes[0].config.name = this.dapp.name + "Root";
-      const wrapper = new ManifestWrapper({
-        ...dapp_window_manifest_default,
-        schema: DappPackageManifestPayloadSchema
-      }, dappManifestWallet, finalLocator);
-      const node = await wrapper.loadNodeFromIndex(0);
-      for (const dappNode of dappNodes) {
-        await node.register(dappNode);
-        await node.attach(dappNode.address, true);
-      }
-      this._root = node;
-      console.log("XyOsDapp:boot:finish", wallet.address, this.dapp.id);
-      return this;
-    });
-  }
-  getStack(stackName) {
-    return this.parent.getStack(stackName);
-  }
-};
-
-// src/classes/system/ManageSystemDapps.ts
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import semver from "semver";
-
-// src/classes/system/Queries.ts
-import { PayloadDivinerQuerySchema as PayloadDivinerQuerySchema3 } 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: PayloadDivinerQuerySchema3,
-      schemas: [
-        UnregisteredDappAccessSchema
-      ],
-      version
-    };
-    return await diviner.divine([
-      accessQuery
-    ]);
-  },
-  async getLatestConfig(diviner, name) {
-    const configQuery = {
-      limit: 1,
-      name,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema3,
-      schemas: [
-        DappConfigSchema
-      ]
-    };
-    const [dappConfig] = await diviner.divine([
-      configQuery
-    ]);
-    return dappConfig;
-  },
-  async getLatestIcon(diviner, name, version) {
-    const iconQuery = {
-      name,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema3,
-      schemas: [
-        DappIconSchema
-      ],
-      version
-    };
-    const [dappIcon] = await diviner.divine([
-      iconQuery
-    ]);
-    return dappIcon;
-  },
-  async getWidgetConfigs(diviner, name, version) {
-    const widgetConfigQuery = {
-      dappId: name,
-      order: "desc",
-      schema: PayloadDivinerQuerySchema3,
-      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/classes/system/ManageSystemDapps.ts
-var ManageSystemDapps = class extends OsCallerBase {
-  static {
-    __name(this, "ManageSystemDapps");
-  }
-  defaultSystemNames;
-  defaultSystemDapps;
-  defaultSystemDappParams;
-  locator;
-  developmentMode;
-  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, this.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 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/classes/registration/DappRegistry.ts
-import { HDWallet as HDWallet3 } from "@xyo-network/account";
-import { DappRegisteredSchema, DappRegisteredState, isRegisteredDappAccess } from "@xyo-network/os-model";
-
-// src/classes/registration/ValidateDappAccessDiviner/Config.ts
-import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
-var FailedAccessorSchema = "network.xyo.os.failed.accessor.registration";
-var isFailedAccessor = isPayloadOfSchemaType(FailedAccessorSchema);
-var ValidateDappAccessDivinerConfigSchema = "network.xyo.os.dapp.access.registration.validate";
-
-// src/classes/registration/ValidateDappAccessDiviner/Diviner.ts
-import { HDWallet as HDWallet2 } from "@xyo-network/account";
-import { AbstractDiviner } from "@xyo-network/diviner-abstract";
-import { ManifestWrapper as ManifestWrapper2, PackageManifestPayloadSchema } from "@xyo-network/manifest";
-import { isDappPackageManifestPayload, isUnregisteredDappAccess, RegisteredDappAccessSchema } from "@xyo-network/os-model";
-
-// src/access-interfaces/ValidDappAccessInterfaces.ts
-import { RegisteredNames, RegisteredNamesInterface } from "@xyo-network/os-model";
-var ValidDappAccessInterfaces = {
-  [RegisteredNames]: RegisteredNamesInterface
-};
-
-// src/classes/registration/ValidateDappAccessDiviner/Diviner.ts
-var ValidateDappAccessDiviner = class extends AbstractDiviner {
-  static {
-    __name(this, "ValidateDappAccessDiviner");
-  }
-  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 = {
-              ...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 = /* @__PURE__ */ __name((interfaceChildren, dappChildren) => {
-  return interfaceChildren.every((interfaceChild) => Object.values(interfaceChild).every((interfaceChildName) => dappChildren.some((dappChild) => Object.values(dappChild).includes(interfaceChildName))));
-}, "compareChildren");
-var dappPackageManifestToPackageManifest = /* @__PURE__ */ __name((dappPackageManifest) => {
-  return {
-    ...dappPackageManifest,
-    schema: PackageManifestPayloadSchema
-  };
-}, "dappPackageManifestToPackageManifest");
-var getChildrenFromNode = /* @__PURE__ */ __name(async (node) => {
-  const nodeManifest = (await node.state())?.[0];
-  return nodeManifest.status?.children;
-}, "getChildrenFromNode");
-var getNodeChildren = /* @__PURE__ */ __name(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;
-}, "getNodeChildren");
-var getNodeToTest = /* @__PURE__ */ __name(async (manifestToTest, dappParams) => {
-  const dappManifestWrapper = new ManifestWrapper2(manifestToTest, await HDWallet2.random(), dappParams.locator);
-  return await dappManifestWrapper.loadNodes();
-}, "getNodeToTest");
-
-// src/classes/registration/DappRegistry.ts
-var DappRegistry = class {
-  static {
-    __name(this, "DappRegistry");
-  }
-  dappSeedPhraseRepository;
-  dappRegistry;
-  constructor(dappSeedPhraseRepository) {
-    this.dappSeedPhraseRepository = dappSeedPhraseRepository;
-    this.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 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/classes/registration/DappRegistrationService.ts
-var DappRegistrationService = class {
-  static {
-    __name(this, "DappRegistrationService");
-  }
-  context;
-  params;
-  locator;
-  developmentMode;
-  // Dapps that have been built with their own context
-  builtDapps;
-  dappRegistry;
-  dappSeedPhraseRepository;
-  manageSystemDapps;
-  // Dapps that have been registered with dappAccessRequests
-  registeredAccessDappSets;
-  // Dapps that have been registered with the dapp registry
-  registeredDappSets;
-  // Dapps that have been registered with exposeDappRequests
-  registeredExposedDappSets;
-  dappAccessRequestConnection;
-  exposeDappRequestConnection;
-  constructor(context, params = {
-    dappNames: [],
-    dappParams: {},
-    dappPayloads: []
-  }, locator = new ModuleFactoryLocator3(), developmentMode) {
-    this.context = context;
-    this.params = params;
-    this.locator = locator;
-    this.developmentMode = developmentMode;
-    this.builtDapps = {};
-    this.registeredAccessDappSets = /* @__PURE__ */ new Set();
-    this.registeredDappSets = /* @__PURE__ */ new Set();
-    this.registeredExposedDappSets = /* @__PURE__ */ new Set();
-    this.dappAccessRequestConnection = dappAccessRequestConnection();
-    this.exposeDappRequestConnection = exposeDappRequestConnection();
-    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 = /* @__PURE__ */ __name(async () => {
-        try {
-          await this.postRegistrationHandlers(result);
-        } catch (e) {
-          console.error("Error in post registration handlers", e);
-        }
-      }, "forgetHandlers");
-      forget2(forgetHandlers());
-      return result;
-    }));
-    const failed = results.filter(rejected).map((result) => result.reason);
-    const succeeded = results.filter(fulfilled).map((result) => result.value);
-    for (const registeredDapp of succeeded) this.registeredDappSets.add(registeredDapp);
-    return {
-      failed,
-      succeeded
-    };
-  }
-  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/classes/signer/Signers.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
-import { HDWallet as HDWallet4 } from "@xyo-network/account";
-var Signers = class {
-  static {
-    __name(this, "Signers");
-  }
-  _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/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 ModuleFactoryLocator4 } from "@xyo-network/module-factory-locator";
-var OS_NODE_PATH = "1'";
-var getDefaultOsNodeLocator = /* @__PURE__ */ __name(() => {
-  const locator = new ModuleFactoryLocator4();
-  locator.register(IndexedDbArchivist, {
-    "network.xyo.archivist.persistence.scope": "device"
-  });
-  locator.register(IndexedDbPayloadDiviner, {
-    "network.xyo.archivist.persistence.scope": "device"
-  });
-  return locator;
-}, "getDefaultOsNodeLocator");
-var loadOsNode = /* @__PURE__ */ __name(async (osWallet, locator) => {
-  try {
-    const osNodeWallet = await osWallet.derivePath(OS_NODE_PATH);
-    const osNodeLocator = locator ?? getDefaultOsNodeLocator();
-    const manifestWrapper = new 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}`);
-  }
-}, "loadOsNode");
-
-// src/stack/Base.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
-import { forget as forget3 } from "@xylabs/forget";
-import { BaseEmitter as BaseEmitter3 } from "@xyo-network/module-event-emitter";
-import { isModuleInstance } from "@xyo-network/module-model";
-import { asAttachableNodeInstance } from "@xyo-network/node-model";
-var StackBase = class extends BaseEmitter3 {
-  static {
-    __name(this, "StackBase");
-  }
-  // flag to check that all adapters are initialized
-  initialized = false;
-  // adapters to initialize into the stack
-  _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 = /* @__PURE__ */ __name(async ({ node }) => await this.handleDriverReady(node), "driverReadyListener");
-      adapter.on("driverReady", driverReadyListener);
-      this.listeners.push({
-        adapter,
-        eventName: "driverReady",
-        listener: driverReadyListener
-      });
-      const driverErrorListener = /* @__PURE__ */ __name(async ({ error }) => {
-        console.error(`Error updating ${this.stackNodeModuleId} stack node`, error);
-        await this.emit("driverError", {
-          error
-        });
-      }, "driverErrorListener");
-      adapter.on("driverError", driverErrorListener);
-      this.listeners.push({
-        adapter,
-        eventName: "driverError",
-        listener: driverErrorListener
-      });
-      const startAdapter = /* @__PURE__ */ __name(async () => await adapter.start(), "startAdapter");
-      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 = /* @__PURE__ */ __name(async () => {
-      const stackNode = await this.getStackNode();
-      this._stack = stackNode;
-    }, "assign");
-    forget3(assign());
-  }
-  async getStackNode() {
-    const mod = assertEx8(await this.context.root.resolve(this.stackNodeModuleId), () => `${this.stackNodeModuleId} not found`);
-    return asAttachableNodeInstance(mod, () => `${this.stackNodeModuleId} not a NodeInstance`);
-  }
-  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 {
-  static {
-    __name(this, "StackManager");
-  }
-  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 } from "@xylabs/assert";
-import { forget as forget4 } from "@xylabs/forget";
-import { asArchivistInstance as asArchivistInstance4 } from "@xyo-network/archivist";
-import { BaseEmitter as BaseEmitter4 } from "@xyo-network/module-event-emitter";
-import { asAttachableNodeInstance as asAttachableNodeInstance2 } from "@xyo-network/node-model";
-import { v4 as uuid3 } from "uuid";
-var NodeAdapterBase = class extends BaseEmitter4 {
-  static {
-    __name(this, "NodeAdapterBase");
-  }
-  kernel;
-  driverName;
-  initialized;
-  _id;
-  constructor(kernel, driverName) {
-    super({}), this.kernel = kernel, this.driverName = driverName, this.initialized = false, this._id = "";
-    this._id = uuid3();
-  }
-  get id() {
-    return assertEx9(this._id, () => "NodeAdapterBase id not initialized");
-  }
-  async start() {
-    try {
-      const moduleAttachedInsertListener = /* @__PURE__ */ __name(({ payloads }) => {
-        const moduleAttachedEvent = this.findModuleEventPayloads(payloads);
-        for (const payload of moduleAttachedEvent) {
-          if (payload.name === this.driverName) {
-            this.validateAndReturnDriver();
-          }
-        }
-      }, "moduleAttachedInsertListener");
-      const eventsArchivist = await this.getEventsArchivist();
-      const weakRefInsertListener = new WeakRef(moduleAttachedInsertListener);
-      const insertListenerRef = weakRefInsertListener.deref();
-      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 = assertEx9(await (await this.kernel.getNode()).resolve("KernelNode:ModuleEvents"), () => "KernelNode:ModuleEvents not found");
-    return asArchivistInstance4(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 = /* @__PURE__ */ __name(async () => await this.emit("driverReady", {
-        node
-      }), "emit");
-      forget4(emit());
-      return node;
-    }
-  }
-};
-
-// src/adapter/Network.ts
-var NetworkAdapter = class extends NodeAdapterBase {
-  static {
-    __name(this, "NetworkAdapter");
-  }
-  _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 {
-  static {
-    __name(this, "SettingsAdapter");
-  }
-  _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 = /* @__PURE__ */ __name((kernel) => [
-  new NetworkAdapter(kernel, PubSubBridgeNodeNodeName),
-  new NetworkAdapter(kernel, ExposedNodeOuterNodeName)
-], "OsPubSubBridgeNetworkAdapters");
-
-// src/adapters/OsSettings.ts
-import { OsSettingsNodeName } from "@xyo-network/os-model";
-var OsSettingsAdapters = /* @__PURE__ */ __name((kernel) => [
-  new SettingsAdapter(kernel, OsSettingsNodeName)
-], "OsSettingsAdapters");
-
-// src/adapters/OsXyoPublicNetwork.ts
-import { XyoPublicNodeName } from "@xyo-network/os-model";
-var OsXyoPublicNetworkAdapters = /* @__PURE__ */ __name((kernel) => [
-  new NetworkAdapter(kernel, XyoPublicNodeName)
-], "OsXyoPublicNetworkAdapters");
-
-// src/stack/OsPubSubNetworkStack.ts
-import { assertEx as assertEx10 } from "@xylabs/assert";
-import { asAttachableNodeInstance as asAttachableNodeInstance3, asNodeInstance } from "@xyo-network/node-model";
-import { ExposedNodeOuterNodeName as ExposedNodeOuterNodeName2, PubSubBridgeNodeNodeName as PubSubBridgeNodeNodeName2 } from "@xyo-network/os-model";
-var OsPubSubNetworkStack = class extends StackBase {
-  static {
-    __name(this, "OsPubSubNetworkStack");
-  }
-  _exposedNode;
-  _exposedNodeOuter;
-  busConnection = osPubSubNetworkReadyConnection();
-  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 {
-  static {
-    __name(this, "OsSettingsStack");
-  }
-  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 {
-  static {
-    __name(this, "XyoPublicNetworkStack");
-  }
-  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 {
-  static {
-    __name(this, "XyOs");
-  }
-  _exposedNode;
-  _exposedNodeOuter;
-  _kernel;
-  _locator;
-  dappRegistrationService;
-  signers;
-  stackManager;
-  constructor({ logger = console, eventBus = new EventBus(), kernel = new Kernel({
-    logger
-  }), locator = new ModuleFactoryLocator5(), 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 ModuleFactoryLocator5()) {
-    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 = /* @__PURE__ */ __name(() => {
-  terminal.grabInput(false);
-  setTimeout(function() {
-    process.exit(0);
-  }, 100);
-}, "terminate");
-var headless = /* @__PURE__ */ __name(async ({ manifest, config, kernelDrivers } = {}) => {
-  console.log(chalk.green("Starting Headless xyOS..."));
-  const configExplorer = cosmiconfig("xyos", {
-    cache: true,
-    loaders: {
-      ".ts": TypeScriptLoader()
-    }
-  });
-  const 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();
-    }
-  });
-}, "headless");
-
-// src/scripts/xyos/command/create.ts
-var commandCreate = /* @__PURE__ */ __name((argv) => {
-  return argv.command("create [template] <target>", "Create an xyos project", (yargs2) => {
-    return yargs2.positional("template", {
-      choices: [
-        "react",
-        "headless",
-        "dapp",
-        "diviner",
-        "witness"
-      ],
-      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
-    });
-  });
-}, "commandCreate");
-
-// src/scripts/xyos/command/manifest.ts
-var commandManifest = /* @__PURE__ */ __name((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();
-  });
-}, "commandManifest");
-
-// src/scripts/xyos/command/start.ts
-var commandStart = /* @__PURE__ */ __name((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
-      ] : []
-    });
-  });
-}, "commandStart");
-
-// src/scripts/xyos/index.ts
-commandManifest(commandConfig(commandCreate(commandStart(yargs(hideBin(process.argv)))))).usage("Usage: $0 <command> [options]").scriptName("xyos").demandCommand(1).parse().catch(console.error);
-//# sourceMappingURL=index.mjs.map