@xyo-network/os-runtime 3.0.6 → 3.0.7

package/dist/neutral/index.d.ts

@@ -1081,6 +1081,7 @@ declare class EventBus implements EventBusInterface {
     private _archivist;
     private connections;
     private publisherCallbacks;
+    private startMutex;
     get archivist(): _xyo_network_archivist_model.ArchivistInstance<_xylabs_object.BaseParamsFields & {
         account?: _xyo_network_account.AccountInstance | "random";
         addToResolvers?: boolean;
@@ -1104,7 +1105,7 @@ declare class EventBus implements EventBusInterface {
     } & _xyo_network_payload_model.PayloadFields>;
     addConnection(connection: EventBusConnectionInterface): EventBusPubSubConnectionInterface<string, _xyo_network_os_model.SubscribableEventListeners, _xyo_network_os_model.PublisherEventListenerEventData>;
     removeConnection(connectionId: string): void;
-    start(storeName?: string): Promise<void>;
+    start(storeName?: string): Promise<this>;
     private handlePublisherAdd;
     private handlePublisherRemove;
 }
@@ -1561,7 +1562,7 @@ interface XyOsParams<TManifest extends PackageManifest = PackageManifest> extend
 declare class XyOs extends XyOsContextBase<XyOsParams> implements XyOsContext {
     protected _exposedNode: NodeInstance | undefined;
     protected _exposedNodeOuter: NodeInstance | undefined;
-    protected _kernel: KernelExternal | undefined;
+    protected _kernel: KernelExternal;
     protected _locator: ModuleFactoryLocator;
     protected dappRegistrationService: DappRegistrationService;
     private stackManager;

package/dist/neutral/index.mjs

@@ -18,10 +18,11 @@ var RunningDappAccessCache = class {
 
 // src/classes/cache/RunningDappCache.ts
 import { assertEx as assertEx19 } from "@xylabs/assert";
-import { Mutex as Mutex2 } from "async-mutex";
+import { Mutex as Mutex3 } from "async-mutex";
 
 // src/XyOs.ts
 import { assertEx as assertEx12 } 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";
 
@@ -72,6 +73,7 @@ import {
   isPubSubConnections
 } from "@xyo-network/os-model";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { Mutex } from "async-mutex";
 import { v4 as uuid } from "uuid";
 var EventBus = class {
   // Internal Archivist to store event data
@@ -80,6 +82,7 @@ var EventBus = class {
   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()?"),
@@ -108,27 +111,34 @@ var EventBus = class {
     delete this.connections[connectionId];
   }
   async start(storeName = "EventBusArchivist") {
-    this._archivist = await MemoryArchivist.create({
-      config: {
-        name: storeName,
-        schema: MemoryArchivistConfigSchema
+    return await this.startMutex.runExclusive(async () => {
+      if (this._archivist) {
+        console.warn("EventBus already started");
+        return this;
       }
-    });
-    this.archivist.on("inserted", ({ payloads }) => {
-      const eventBusEvent = payloads.find(isEventBusEvent);
-      if (!eventBusEvent) return;
-      for (const connectionId in this.connections) {
-        const connection = this.connections[connectionId];
-        if (isPubSubConnections(connection) && connection.subscribableEvents) {
-          for (const [eventName, callback] of connection.subscribableEvents.entries()) {
-            if (eventName !== eventBusEvent.name) continue;
-            if (callback) {
-              const forgettable = async () => await callback({ payloads });
-              forget(forgettable());
+      this._archivist = await MemoryArchivist.create({
+        config: {
+          name: storeName,
+          schema: MemoryArchivistConfigSchema
+        }
+      });
+      this.archivist.on("inserted", ({ payloads }) => {
+        const eventBusEvent = payloads.find(isEventBusEvent);
+        if (!eventBusEvent) return;
+        for (const connectionId in this.connections) {
+          const connection = this.connections[connectionId];
+          if (isPubSubConnections(connection) && connection.subscribableEvents) {
+            for (const [eventName, callback] of connection.subscribableEvents.entries()) {
+              if (eventName !== eventBusEvent.name) continue;
+              if (callback) {
+                const forgettable = async () => await callback({ payloads });
+                forget(forgettable());
+              }
             }
           }
         }
-      }
+      });
+      return this;
     });
   }
   handlePublisherAdd(connection) {
@@ -748,9 +758,9 @@ var dapp_window_manifest_default = {
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { BaseEmitter as BaseEmitter2 } from "@xyo-network/module-abstract";
 import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
-import { Mutex } from "async-mutex";
+import { Mutex as Mutex2 } from "async-mutex";
 var XyOsContextBase = class extends BaseEmitter2 {
-  _bootMutex = new Mutex();
+  _bootMutex = new Mutex2();
   _platformLocator;
   _root;
   get bios() {
@@ -1999,6 +2009,13 @@ var XyOs = class _XyOs extends XyOsContextBase {
     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 });
+      }
+      if (this.kernel?.status !== "booted") {
+        throw new Error("Kernel not booted");
+      }
       assertEx12(this._root === void 0, () => "XyOs already booted");
       const [root] = await _XyOs.monitor(async () => await loadOsNode(wallet, fullLocator), { name: "Load XyOs" });
       this._root = root;
@@ -2637,7 +2654,7 @@ var createDappContext = async (dapp, context, allowedNames, xnsNodeUrl, xnsNetwo
 };
 
 // src/classes/cache/RunningDappCache.ts
-var findOrCreateMutex = new Mutex2();
+var findOrCreateMutex = new Mutex3();
 var RunningDappCache = class _RunningDappCache {
   static _cache = {};
   static async findOrCreate(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork) {