@xyo-network/os-react-runtime 7.4.0 → 7.4.2

package/dist/browser/index.mjs

@@ -0,0 +1,4701 @@
+// src/helpers/BridgeActivityHelper.ts
+import { assertEx, BaseEmitter } from "@xylabs/sdk-js";
+import { GenericPayloadDivinerConfigSchema } from "@xyo-network/diviner-payload-generic";
+import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
+var BridgeActivityHelper = class extends BaseEmitter {
+  get archivist() {
+    return assertEx(this.params.archivist.deref(), () => "Archivist is missing");
+  }
+  get diviner() {
+    const result = assertEx(this.params.diviner.deref(), () => "Diviner is missing");
+    assertEx(result.config.schema === GenericPayloadDivinerConfigSchema, () => "Diviner is not a generic payload diviner");
+    return result;
+  }
+  next(options) {
+    return this.archivist.next(options);
+  }
+  nextByAddress(address, options) {
+    const query = {
+      address,
+      ...options,
+      schema: PayloadDivinerQuerySchema
+    };
+    return this.diviner.divine([query]);
+  }
+};
+
+// src/helpers/BrowserLocator.ts
+import { IndexedDbArchivist } from "@xyo-network/archivist-indexeddb";
+import { IndexedDbBoundWitnessDiviner } from "@xyo-network/diviner-boundwitness-indexeddb";
+import { GenericPayloadDiviner } from "@xyo-network/diviner-payload-generic";
+import { IndexedDbPayloadDiviner } from "@xyo-network/diviner-payload-indexeddb";
+import { asSchema } from "@xyo-network/payload-model";
+import { ModuleFactoryLocator } from "@xyo-network/sdk-js";
+var GenericPayloadDivinerTags = { "network.xyo.generic.payload.diviner": "GenericPayloadDiviner" };
+var BrowserLocator = new ModuleFactoryLocator();
+BrowserLocator.register(GenericPayloadDiviner.factory(), GenericPayloadDivinerTags);
+BrowserLocator.register(IndexedDbArchivist.factory(), { "network.xyo.archivist.persistence.scope": "device" }, asSchema("network.xyo.archivist.config", true));
+BrowserLocator.register(IndexedDbPayloadDiviner.factory(), { "network.xyo.archivist.persistence.scope": "device" }, asSchema("network.xyo.diviner.payload.config", true));
+BrowserLocator.register(
+  IndexedDbBoundWitnessDiviner.factory(),
+  { "network.xyo.archivist.persistence.scope": "device" },
+  asSchema("network.xyo.diviner.boundwitness.config", true)
+);
+BrowserLocator.freeze();
+
+// src/helpers/monitor/XyOsBrowserMonitor.ts
+import { XyOsMonitor } from "@xyo-network/os-runtime";
+var XyOsBrowserMonitor = class extends XyOsMonitor {
+  connection() {
+    try {
+      if (globalThis !== void 0) {
+        return "connection" in globalThis.navigator ? globalThis.navigator.connection : void 0;
+      }
+    } catch {
+      return;
+    }
+  }
+};
+
+// src/img/backgrounds/index.ts
+import candyDarkImport from "./candy-dark@3x-N2S7K4QB.webp";
+import candyLightImport from "./candy-light@3x-WKECMFRP.webp";
+import candyAppleDarkImport from "./candyApple-dark@3x-HGSPETPR.webp";
+import candyAppleLightImport from "./candyApple-light@3x-OWA5XNTF.webp";
+import mossDarkImport from "./moss-dark@3x-HV35CF34.webp";
+import mossLightImport from "./moss-light@3x-UH4AJQR5.webp";
+import oceanDarkImport from "./ocean-dark@3x-LDW7E4ZL.webp";
+import oceanLightImport from "./ocean-light@3x-FP7M2MO7.webp";
+import peachYogurtDarkImport from "./peachYogurt-dark@3x-UWHJTY5O.webp";
+import peachYogurtLightImport from "./peachYogurt-light@3x-X7Y7NU2Y.webp";
+import sherbetDarkImport from "./sherbet-dark@3x-UAIXX4RP.webp";
+import sherbetLightImport from "./sherbet-light@3x-2Q2EFFWE.webp";
+import springDarkImport from "./spring-dark@3x-XU3GBWBF.webp";
+import springLightImport from "./spring-light@3x-EFV3QMVY.webp";
+import sunsetDarkImport from "./sunset-dark@3x-F25FUK74.webp";
+import sunsetLightImport from "./sunset-light@3x-B5T3EVGS.webp";
+import xyoDarkImport from "./xyo-dark@3x-N62LIF7V.webp";
+import xyoLightImport from "./xyo-light@3x-5S6CF5P4.webp";
+var candyDark = candyDarkImport;
+var candyLight = candyLightImport;
+var candyAppleDark = candyAppleDarkImport;
+var candyAppleLight = candyAppleLightImport;
+var mossDark = mossDarkImport;
+var mossLight = mossLightImport;
+var oceanDark = oceanDarkImport;
+var oceanLight = oceanLightImport;
+var peachYogurtDark = peachYogurtDarkImport;
+var peachYogurtLight = peachYogurtLightImport;
+var sherbetDark = sherbetDarkImport;
+var sherbetLight = sherbetLightImport;
+var springDark = springDarkImport;
+var springLight = springLightImport;
+var sunsetDark = sunsetDarkImport;
+var sunsetLight = sunsetLightImport;
+var xyoDark = xyoDarkImport;
+var xyoLight = xyoLightImport;
+
+// src/helpers/NodePalettes.ts
+var OsPalettes = {
+  candy: {
+    darkModeWallpaper: candyDark,
+    lightModeWallpaper: candyLight,
+    nameCode: "candy",
+    readableName: "Candy"
+  },
+  candyApple: {
+    darkModeWallpaper: candyAppleDark,
+    lightModeWallpaper: candyAppleLight,
+    nameCode: "candyApple",
+    readableName: "Candy Apple"
+  },
+  moss: {
+    darkModeWallpaper: mossDark,
+    lightModeWallpaper: mossLight,
+    nameCode: "moss",
+    readableName: "Moss"
+  },
+  ocean: {
+    darkModeWallpaper: oceanDark,
+    lightModeWallpaper: oceanLight,
+    nameCode: "ocean",
+    readableName: "Ocean"
+  },
+  peachYogurt: {
+    darkModeWallpaper: peachYogurtDark,
+    lightModeWallpaper: peachYogurtLight,
+    nameCode: "peachYogurt",
+    readableName: "Peach Yogurt"
+  },
+  sherbet: {
+    darkModeWallpaper: sherbetDark,
+    lightModeWallpaper: sherbetLight,
+    nameCode: "sherbet",
+    readableName: "Sherbet"
+  },
+  spring: {
+    darkModeWallpaper: springDark,
+    lightModeWallpaper: springLight,
+    nameCode: "spring",
+    readableName: "Spring"
+  },
+  sunset: {
+    darkModeWallpaper: sunsetDark,
+    lightModeWallpaper: sunsetLight,
+    nameCode: "sunset",
+    readableName: "Sunset"
+  },
+  xyo: {
+    darkModeWallpaper: xyoDark,
+    lightModeWallpaper: xyoLight,
+    nameCode: "xyo",
+    readableName: "XYO"
+  }
+};
+var getNodePaletteByNameCode = (nameCode) => {
+  const castNameCode = nameCode;
+  return OsPalettes[castNameCode];
+};
+
+// src/helpers/widget/Caller.tsx
+import {
+  assertEx as assertEx2,
+  fulfilled,
+  rejected
+} from "@xylabs/sdk-js";
+import { WidgetTraySchema } from "@xyo-network/os-model";
+import { OsCallerBase } from "@xyo-network/os-runtime";
+import { jsx } from "react/jsx-runtime";
+var WidgetCaller = class extends OsCallerBase {
+  _registeredDappSets;
+  _widgetTrayLayout;
+  constructor(context, _registeredDappSets, _widgetTrayLayout) {
+    super(context);
+    this._registeredDappSets = _registeredDappSets;
+    this._widgetTrayLayout = _widgetTrayLayout;
+  }
+  get dappsAsObject() {
+    const acc = {};
+    for (const dapp of this.registeredDappSets) {
+      acc[dapp.dapp.config.name] = dapp;
+    }
+    return acc;
+  }
+  get registeredDappSets() {
+    return assertEx2(this._registeredDappSets, () => "Registered Dapp Sets not available");
+  }
+  get widgetTrayLayout() {
+    return assertEx2(this._widgetTrayLayout, () => "Widget Tray Layout not available");
+  }
+  async buildWidgetComponents() {
+    const widgetTray = this.widgetTrayFromLayout(this.widgetTrayLayout);
+    const results = await Promise.allSettled(
+      widgetTray.widgetConfigs.map(async (config2) => {
+        const Param = this.dappsAsObject[config2.dappId].dapp.params.modes[config2.mode ?? config2.dappId]?.component;
+        let payload;
+        if (config2.configHash) {
+          const archivist = await this.getDappsArchivist();
+          const foundConfig = assertEx2((await archivist.get([config2.configHash]))?.[0], () => `Config - ${config2.configHash} not found`);
+          payload = foundConfig;
+        }
+        return Param ? /* @__PURE__ */ jsx(Param, { payload }, config2.configHash ?? config2.dappId) : void 0;
+      })
+    );
+    const successfulResults = results.filter(fulfilled).map((result) => result.value);
+    const failedResults = results.filter(rejected).map((result) => {
+      return result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+    });
+    return [successfulResults, failedResults];
+  }
+  // build a new widget config from the base provided by the dapp
+  // and pass the config hash from the widgetLayout to the new widgetConfig
+  buildWidgetConfig(widgetConfigToBuild, configHash) {
+    const clonedWidgetConfig = this.cloneWidgetConfig(widgetConfigToBuild);
+    return {
+      ...clonedWidgetConfig,
+      configHash
+    };
+  }
+  cloneWidgetConfig(widgetConfig) {
+    return structuredClone(widgetConfig);
+  }
+  widgetTrayFromLayout(widgetLayout) {
+    const targetWidgetConfigs = [];
+    const { layout, label: trayLabel } = widgetLayout;
+    for (const dappWidgetLayout of layout) {
+      const {
+        dappId,
+        mode,
+        configHash
+      } = dappWidgetLayout;
+      const dappSet = this.registeredDappSets.find((dappSet2) => dappSet2.dapp.config.name === dappId);
+      if (!dappSet) {
+        console.error("unable to find registered dapp set for", dappId);
+        continue;
+      }
+      const widgetConfigToBuild = dappSet.dapp.widgetConfigs.find((config3) => config3.mode ? config3.mode === mode : mode === config3.dappId);
+      if (!widgetConfigToBuild) {
+        console.error("unable to find widget config for", mode);
+        continue;
+      }
+      const config2 = this.buildWidgetConfig(widgetConfigToBuild, configHash);
+      targetWidgetConfigs.push(config2);
+    }
+    return {
+      label: trayLabel ?? "Widget Tray",
+      position: "bottom",
+      schema: WidgetTraySchema,
+      widgetConfigs: targetWidgetConfigs
+    };
+  }
+};
+
+// src/modules/access-requests/NameServiceRegistrationHooks.ts
+import { usePromise } from "@xylabs/react-promise";
+import { XnsRegistrationsResource } from "@xyo-network/os-runtime";
+
+// src/modules/XyOsUi/contexts/XyOsUiContext.ts
+import { createContext, use } from "react";
+var XyOsUiContext = createContext(void 0);
+var useXyOsUiContext = () => {
+  return use(XyOsUiContext);
+};
+var XyOsUiContextProvider = XyOsUiContext.Provider;
+
+// src/modules/XyOsUi/lib/XyOsUi.ts
+import { forget } from "@xylabs/sdk-js";
+import { dappsReadyConnection, XyOs } from "@xyo-network/os-runtime";
+import { ModuleFactoryLocator as ModuleFactoryLocator2 } from "@xyo-network/sdk-js";
+var XyOsUi = class extends XyOs {
+  dappRegistrationResults = { failed: [], succeeded: [] };
+  dappsReadyConnection = dappsReadyConnection();
+  constructor(params) {
+    super(params);
+    this.eventBus.addConnection(this.dappsReadyConnection);
+  }
+  static get monitoring() {
+    return new XyOsBrowserMonitor();
+  }
+  static get xyOsUiGlobal() {
+    return XyOs.xyOsGlobal;
+  }
+  static hideSplash() {
+    this.xyOsUiGlobal.splashScreen.hideSplash();
+    this.xyOsUiGlobal.splashScreen.onComplete();
+    this.setSplashStatus("complete");
+  }
+  static setSplashStatus(status) {
+    const statusText = this.xyOsUiGlobal.splashScreen._LOADING_MESSAGES[status];
+    this.xyOsUiGlobal.splashScreen.setStatusText(statusText);
+  }
+  async boot(wallet, locator = new ModuleFactoryLocator2()) {
+    await super.boot(wallet, locator);
+    const registerLazy = async () => {
+      this.dappRegistrationResults = await this.dappRegistrationService.start();
+      await this.dappsReadyConnection.emit("dappsReady", {});
+    };
+    forget(registerLazy());
+    return this;
+  }
+};
+
+// src/modules/resource/ResourceHooks.ts
+var ResourceHooks = class {
+  buildResource;
+  buildViews;
+  constructor(buildResource, buildViews) {
+    this.buildResource = buildResource;
+    this.buildViews = buildViews;
+  }
+  resourceViewsFromContext = (context, pathPrefix) => {
+    const [resource, resourceError] = this.buildResource(context, pathPrefix);
+    const views = this.buildViews(resource);
+    return {
+      ...views,
+      resource,
+      resourceError
+    };
+  };
+  useBuildResourceFromProvidedNode = (pathPrefix) => {
+    const xyOs = useXyOsUiContext();
+    return this.buildResource(xyOs, pathPrefix);
+  };
+  useResourceViewsFromProvidedNode = (pathPrefix) => {
+    const [resource, resourceError] = this.useBuildResourceFromProvidedNode(pathPrefix);
+    const views = this.buildViews(resource);
+    return {
+      ...views,
+      resource,
+      resourceError
+    };
+  };
+};
+
+// src/modules/resource/useCleanup.ts
+import { useEffect } from "react";
+var useCleanUpResource = (resource) => {
+  useEffect(() => {
+    return () => {
+      resource?.cleanupListeners();
+    };
+  }, [resource]);
+};
+
+// src/modules/resource/useSyncExternalPayloadStore.ts
+import { useMemo, useSyncExternalStore } from "react";
+var useSyncExternalPayloadStore = (viewName, repository) => {
+  const { getSnapShot, subscribe } = useMemo(() => {
+    const subscriber = repository?.subscriptions[viewName];
+    const snapshot = repository?.views[viewName];
+    if (snapshot && subscriber) {
+      return {
+        // since useExternalStore calls its methods in it's own lambda function, we lose the `this` context of the calling class.
+        // bind each method to its appropriate object so the `this` calls work as expected.
+        getSnapShot: snapshot,
+        subscribe: subscriber.bind(repository)
+      };
+    }
+    return {
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      getSnapShot: () => void 0,
+      subscribe: () => () => {
+      }
+    };
+  }, [repository, viewName]);
+  return useSyncExternalStore(subscribe, getSnapShot);
+};
+
+// src/modules/access-requests/NameServiceRegistrationHooks.ts
+var useBuildNameServiceRegistrationsResource = (context, pathPrefix) => {
+  const result = usePromise(async () => {
+    if (context) {
+      const xnsRegistrationsResource = new XnsRegistrationsResource(context, pathPrefix);
+      await xnsRegistrationsResource.start();
+      return xnsRegistrationsResource;
+    }
+  }, [context, pathPrefix]);
+  useCleanUpResource(result[0]);
+  return result;
+};
+var useBuildNameServiceRegistrationsResourceViews = (resource) => {
+  const allRegistrations = useSyncExternalPayloadStore("allRegistrations", resource);
+  return {
+    allRegistrations,
+    resource
+  };
+};
+var NameServiceRegistrationHooks = new ResourceHooks(
+  useBuildNameServiceRegistrationsResource,
+  useBuildNameServiceRegistrationsResourceViews
+);
+
+// src/modules/access-requests/useBuildDappAccessRequestResource.ts
+import { usePromise as usePromise2 } from "@xylabs/react-promise";
+import { DappAccessRequestResource } from "@xyo-network/os-runtime";
+var useBuildDappAccessRequestResource = (context) => {
+  const resource = usePromise2(async () => {
+    if (context) {
+      const resource2 = new DappAccessRequestResource(context);
+      await resource2.start();
+      return resource2;
+    }
+  }, [context]);
+  useCleanUpResource(resource[0]);
+  return resource;
+};
+var useDappAccessRequestResourceViews = (resource) => {
+  const accessRequests = useSyncExternalPayloadStore("accessRequests", resource);
+  const registeredInterfaces = useSyncExternalPayloadStore("registeredInterfaces", resource);
+  return {
+    accessRequests,
+    registeredInterfaces,
+    resource
+  };
+};
+var DappAccessRequestResourceHooks = new ResourceHooks(
+  useBuildDappAccessRequestResource,
+  useDappAccessRequestResourceViews
+);
+
+// src/modules/bios/hooks/useBios.ts
+import { usePromise as usePromise3 } from "@xylabs/react-promise";
+import { boot } from "@xyo-network/bios-browser";
+import { useEffect as useEffect2 } from "react";
+var biosBoot;
+var useBios = () => {
+  const [biosExternalInterface, biosError] = usePromise3(async () => {
+    if (biosBoot !== void 0) return await biosBoot;
+    biosBoot = boot();
+    return await biosBoot;
+  }, []);
+  useEffect2(() => {
+    if (biosError) throw biosError;
+  }, [biosError]);
+  return biosExternalInterface;
+};
+
+// src/modules/bios/hooks/useKernel.ts
+import { usePromise as usePromise4 } from "@xylabs/react-promise";
+import { Kernel } from "@xyo-network/kernel";
+import { useEffect as useEffect3 } from "react";
+var kernelBoot;
+var useKernel = (locator, params) => {
+  const bios = useBios();
+  const [kernelExternalInterface, kernelError] = usePromise4(async () => {
+    if (kernelBoot !== void 0) return await kernelBoot;
+    if (bios) {
+      kernelBoot = (async function() {
+        const kernel = new Kernel();
+        await kernel.boot(bios, { locator, ...params });
+        return kernel;
+      })();
+      return await kernelBoot;
+    }
+  }, [bios]);
+  useEffect3(() => {
+    if (kernelError) throw kernelError;
+  }, [kernelError]);
+  return kernelExternalInterface;
+};
+
+// src/modules/Dapp/Alert/RenderErrorWithSupportLink.tsx
+import { ButtonEx } from "@xylabs/react-button";
+import { ErrorAlert } from "@xylabs/react-error";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ErrorRenderWithSupport = ({
+  supportHref = "",
+  supportTo,
+  supportLinkText = "Support",
+  error,
+  onCancel,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx2(
+    ErrorAlert,
+    {
+      action: supportTo ? /* @__PURE__ */ jsx2(ButtonEx, { target: "_blank", to: supportTo, color: "inherit", size: "small", children: supportLinkText }) : /* @__PURE__ */ jsx2(ButtonEx, { target: "_blank", href: supportHref, color: "inherit", size: "small", children: supportLinkText }),
+      error,
+      onCancel,
+      ...props
+    }
+  );
+};
+var ErrorRenderWithSupportDefault = (props) => {
+  return /* @__PURE__ */ jsx2(ErrorRenderWithSupport, { supportHref: "https://discord.com/channels/935586624392298547/1228436997375393885", ...props });
+};
+
+// src/modules/Dapp/Container.tsx
+import { memo, useMemo as useMemo14 } from "react";
+
+// src/modules/os/hooks/useDappContextCreator.ts
+import { useAsyncEffect } from "@xylabs/react-async-effect";
+import { DappIntentTypes } from "@xyo-network/os-model";
+import { DappContextCreator, RunningDappCache } from "@xyo-network/os-runtime";
+import {
+  useCallback,
+  useEffect as useEffect4,
+  useRef,
+  useState
+} from "react";
+var useDappContextCreator = (xnsNodeUrl, xnsNetwork, dapp, currentIntent, allowedNames, createOnMount = false) => {
+  const context = useXyOsUiContext();
+  const [windowDappNodeSet, setWindowDappNodeSet] = useState({ context: void 0, dappWallet: void 0 });
+  const [dappWindowNodeError, setDappWindowNodeError] = useState();
+  const targetedDapp = !!(dapp && context && currentIntent?.targetDappId === dapp?.config.name);
+  const windowDappNodeSetRef = useRef(windowDappNodeSet);
+  useEffect4(() => {
+    windowDappNodeSetRef.current = windowDappNodeSet;
+  }, [windowDappNodeSet]);
+  const createNode = useCallback(async () => {
+    if (targetedDapp) {
+      try {
+        const windowDappNodeSet2 = await RunningDappCache.findOrCreate(dapp, context, allowedNames ?? [], xnsNodeUrl, xnsNetwork);
+        setWindowDappNodeSet(windowDappNodeSet2);
+      } catch (e) {
+        setDappWindowNodeError(e);
+      }
+    }
+  }, [dapp, currentIntent, context, allowedNames]);
+  useEffect4(() => {
+    if (createOnMount) {
+      void (async () => {
+        await createNode();
+      })();
+    }
+  }, [createOnMount, createNode]);
+  useAsyncEffect(
+    async () => {
+      if (targetedDapp) {
+        switch (currentIntent?.intent) {
+          case DappIntentTypes.Launch: {
+            await createNode();
+            break;
+          }
+          case DappIntentTypes.Close: {
+            if (windowDappNodeSetRef.current.context) {
+              await DappContextCreator.resetDappArchivist(windowDappNodeSetRef.current.context);
+              setWindowDappNodeSet({ context: null, dappWallet: void 0 });
+            }
+            break;
+          }
+          case DappIntentTypes.Minimize:
+        }
+      }
+    },
+    [createNode, currentIntent]
+  );
+  return {
+    ...windowDappNodeSet,
+    nodeCreateError: dappWindowNodeError
+  };
+};
+
+// src/modules/os/hooks/useDappRegistrationResults.ts
+import { EventBusPubSubConnection } from "@xyo-network/os-runtime";
+import { useEffect as useEffect5, useState as useState2 } from "react";
+var useDappRegistrationResults = () => {
+  const context = useXyOsUiContext();
+  const [registeredDappSetResults, setRegisteredDappSetResults] = useState2();
+  useEffect5(() => {
+    const listener = () => {
+      setRegisteredDappSetResults(context?.dappRegistrationResults);
+    };
+    const dappsReadyConnectionRequest = {
+      subscribableEvents: /* @__PURE__ */ new Map([["dappsReady", listener]]),
+      type: "PubSub"
+    };
+    const dappsReadyConnection2 = new EventBusPubSubConnection(dappsReadyConnectionRequest);
+    let initialResultsTimeoutId;
+    if (context) {
+      context.eventBus.addConnection(dappsReadyConnection2);
+      initialResultsTimeoutId = setTimeout(() => setRegisteredDappSetResults(context.dappRegistrationResults), 0);
+    }
+    return () => {
+      if (initialResultsTimeoutId !== void 0) clearTimeout(initialResultsTimeoutId);
+      if (context && dappsReadyConnection2.id) context.eventBus.removeConnection(dappsReadyConnection2.id);
+    };
+  }, [context]);
+  return registeredDappSetResults;
+};
+
+// src/modules/os/hooks/useDappRegistry.ts
+import { DappRegistry } from "@xyo-network/os-runtime";
+import { useMemo as useMemo3 } from "react";
+
+// src/modules/os/hooks/useDappSeedPhraseRepository.ts
+import { DappSeedPhraseRepository } from "@xyo-network/os-runtime";
+import { useMemo as useMemo2 } from "react";
+var _dappWalletRepository;
+var getOrCreateDappSeedPhraseRepository = (context, allowedNames) => {
+  _dappWalletRepository ??= new DappSeedPhraseRepository(context, allowedNames);
+  return _dappWalletRepository;
+};
+var useDappSeedPhraseRepository = (allowedNames) => {
+  const context = useXyOsUiContext();
+  return useMemo2(() => {
+    return context ? getOrCreateDappSeedPhraseRepository(context, allowedNames) : void 0;
+  }, [context, allowedNames]);
+};
+
+// src/modules/os/hooks/useDappRegistry.ts
+var _dappRegistry;
+var getOrCreateDappRegistry = (repository) => {
+  _dappRegistry ??= new DappRegistry(repository);
+  return _dappRegistry;
+};
+var useDappRegistry = (allowedNames) => {
+  const dappSeedPhraseRepository = useDappSeedPhraseRepository(allowedNames);
+  return useMemo3(() => {
+    return dappSeedPhraseRepository ? getOrCreateDappRegistry(dappSeedPhraseRepository) : void 0;
+  }, [dappSeedPhraseRepository]);
+};
+
+// src/modules/os/hooks/useOsSettingsCaller.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { OsSettingsCaller, OsSettingsReadyEvent } from "@xyo-network/os-runtime";
+import { useMemo as useMemo4 } from "react";
+
+// src/modules/stack/useStackReady.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { EventBusPubSubConnection as EventBusPubSubConnection2 } from "@xyo-network/os-runtime";
+import { useEffect as useEffect6, useState as useState3 } from "react";
+var useStackReady = (stackReadyEvent, stackName, context) => {
+  const providedContext = useXyOsUiContext();
+  const [stackReady, setStackReady] = useState3({ ready: false });
+  useEffect6(() => {
+    const derivedContext = context ?? providedContext;
+    const listener = () => {
+      if (!derivedContext) throw new Error("no context found");
+      const stack = assertEx3(derivedContext.getStack(stackName).stack, () => `${stackName} missing stack`);
+      setStackReady({ ready: true, stack });
+    };
+    const stackReadyReadyConnectionRequest = {
+      subscribableEvents: /* @__PURE__ */ new Map([[stackReadyEvent, listener]]),
+      type: "PubSub"
+    };
+    const stackReadyReadyConnection = new EventBusPubSubConnection2(stackReadyReadyConnectionRequest);
+    let initialReadyTimeoutId;
+    if (derivedContext) {
+      derivedContext.eventBus.addConnection(stackReadyReadyConnection);
+      const stack = derivedContext.getStack(stackName);
+      if (stack.initialized) {
+        initialReadyTimeoutId = setTimeout(() => setStackReady({ ready: true, stack: stack.stack }), 0);
+      }
+    }
+    return () => {
+      if (initialReadyTimeoutId !== void 0) clearTimeout(initialReadyTimeoutId);
+      const derivedContext2 = context ?? providedContext;
+      if (derivedContext2 && stackReadyReadyConnection._id) {
+        derivedContext2.eventBus.removeConnection(stackReadyReadyConnection.id);
+      }
+    };
+  }, [context, providedContext, stackName, stackReadyEvent]);
+  return stackReady;
+};
+
+// src/modules/os/hooks/useOsSettingsCaller.ts
+var useOsSettingsCaller = (context) => {
+  const providedContext = useXyOsUiContext();
+  const { ready } = useStackReady(OsSettingsReadyEvent, "osSettingsStack", providedContext);
+  return useMemo4(() => {
+    if (providedContext || context || ready) {
+      const derivedNode = assertEx4(context ?? providedContext, () => "no node was found in context or passed as argument");
+      return new OsSettingsCaller(derivedNode);
+    }
+  }, [context, providedContext]);
+};
+
+// src/modules/os/hooks/usePhraseFile.ts
+import { usePromise as usePromise5 } from "@xylabs/react-promise";
+import { buildUserWalletSeedPhrasePayload } from "@xyo-network/os-runtime";
+import { useMemo as useMemo5 } from "react";
+var usePhraseFile = (phrase) => {
+  const [payloadAndRootHash] = usePromise5(async () => phrase ? await buildUserWalletSeedPhrasePayload(phrase) : void 0, [phrase]);
+  const filename = useMemo5(() => `xyo-phrase-${payloadAndRootHash?.rootHash}.json`, [payloadAndRootHash?.rootHash]);
+  const { phraseFile, phraseFileError } = useMemo5(() => {
+    const payload = payloadAndRootHash?.payload;
+    if (payload) {
+      try {
+        const data = new Blob([JSON.stringify(payload, null, 2)], { type: "text/plain" });
+        return { phraseFile: globalThis.URL.createObjectURL(data) };
+      } catch (e) {
+        return { phraseFileError: e };
+      }
+    } else {
+      return {};
+    }
+  }, [payloadAndRootHash]);
+  return {
+    filename,
+    payload: payloadAndRootHash?.payload,
+    phraseFile,
+    phraseFileError
+  };
+};
+
+// src/modules/os/hooks/useTabs.ts
+import { useLocation, useNavigate } from "react-router-dom";
+var useTabs = () => {
+  const location2 = useLocation();
+  const navigate = useNavigate();
+  const rootFolder = location2.pathname.split("/")[1];
+  const tab = rootFolder?.length > 0 ? rootFolder : "node";
+  const setTab = (tab2) => {
+    void navigate(`/${tab2}`);
+  };
+  return [tab, setTab];
+};
+
+// src/modules/os/hooks/useWidgetDapps.ts
+import { usePromise as usePromise6 } from "@xylabs/react-promise";
+var useWidgetDapps = (registeredDapps, widgetTrayLayout) => {
+  const context = useXyOsUiContext();
+  return usePromise6(async () => {
+    if (registeredDapps && registeredDapps.length > 0 && context && widgetTrayLayout) {
+      const caller = new WidgetCaller(context, registeredDapps, widgetTrayLayout);
+      return await caller.buildWidgetComponents();
+    }
+  }, [context, registeredDapps, widgetTrayLayout]);
+};
+
+// src/modules/Dapp/Button/hooks/useLaunchPoint.tsx
+import { useLayoutEffect, useState as useState5 } from "react";
+
+// src/utils/DappInstallTypeFilters.ts
+import {
+  isInstalledDappSet,
+  isPreInstalledDappSet,
+  isUnInstalledDappSet
+} from "@xyo-network/os-model";
+var DappInstallTypeFilters = {
+  installed(registeredDappSets) {
+    return registeredDappSets && registeredDappSets?.length > 0 ? registeredDappSets?.filter(isInstalledDappSet).toSorted((a2, b) => a2.dapp.config.name.toUpperCase() < b.dapp.config.name.toUpperCase() ? -1 : 1) : void 0;
+  },
+  preInstalled(registeredDappSets) {
+    return registeredDappSets && registeredDappSets?.length > 0 ? registeredDappSets?.filter(isPreInstalledDappSet).toSorted((a2, b) => a2.dapp.config.name.toUpperCase() < b.dapp.config.name.toUpperCase() ? -1 : 1) : void 0;
+  },
+  uninstalled(registeredDappSets) {
+    return registeredDappSets && registeredDappSets?.length > 0 ? registeredDappSets.filter(isUnInstalledDappSet).toSorted((a2, b) => a2.dapp.config.name.toUpperCase() < b.dapp.config.name.toUpperCase() ? -1 : 1) : void 0;
+  }
+};
+
+// src/utils/getApiDomain.ts
+var getApiDomain = (localHost, apiDomain) => {
+  if (apiDomain !== void 0) {
+    return apiDomain;
+  }
+  if (localHost) {
+    return "http://localhost:8080";
+  }
+  if (location.hostname.startsWith("beta")) {
+    return "https://beta.archivist.xyo.network";
+  }
+  return "https://archivist.xyo.network";
+};
+
+// src/utils/useOnWindowResize.tsx
+import { useEffect as useEffect7, useState as useState4 } from "react";
+var useOnWindowResize = () => {
+  const [resized, setResized] = useState4();
+  useEffect7(() => {
+    const onResize = (event) => {
+      setResized(event);
+    };
+    globalThis.addEventListener("resize", onResize, false);
+    return () => {
+      globalThis.removeEventListener("resize", onResize);
+    };
+  }, []);
+  return resized;
+};
+
+// src/modules/Dapp/Button/hooks/useLaunchPoint.tsx
+var useLaunchPoint = (spanRef) => {
+  const [coordinates, setCoordinates] = useState5({ left: 0, top: 0 });
+  const resized = useOnWindowResize();
+  useLayoutEffect(() => {
+    const rect = spanRef.current?.getBoundingClientRect() ?? null;
+    if (rect) {
+      const {
+        width,
+        height,
+        left,
+        top
+      } = rect;
+      setCoordinates({
+        left: left + width / 2,
+        top: top + height / 2
+      });
+    }
+  }, [spanRef, resized]);
+  return coordinates;
+};
+
+// src/modules/Dapp/Button/IconEx.tsx
+import { Circle } from "@mui/icons-material";
+import { FlexCol } from "@xylabs/react-flexbox";
+import { DappIntentTypes as DappIntentTypes6 } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller2, XyOsMonitor as XyOsMonitor2 } from "@xyo-network/os-runtime";
+import { useRef as useRef2 } from "react";
+
+// src/modules/intent/DappIntentResourceHooks.ts
+import { usePromise as usePromise7 } from "@xylabs/react-promise";
+import { DappIntentResource } from "@xyo-network/os-runtime";
+var useBuildIntentResource = (context) => {
+  const resource = usePromise7(async () => {
+    if (context) {
+      const resource2 = new DappIntentResource(context);
+      await resource2.start();
+      return resource2;
+    }
+  }, [context]);
+  useCleanUpResource(resource[0]);
+  return resource;
+};
+var useIntentResourceViews = (resource) => {
+  const allDappIntents = useSyncExternalPayloadStore("allDappIntents", resource);
+  const latestDappIntent = useSyncExternalPayloadStore("latestDappIntent", resource);
+  return {
+    allDappIntents,
+    latestDappIntent,
+    resource
+  };
+};
+var DappIntentResourceHooks = new ResourceHooks(useBuildIntentResource, useIntentResourceViews);
+
+// src/modules/intent/useClearIntents.ts
+import { useAsyncEffect as useAsyncEffect2 } from "@xylabs/react-async-effect";
+import { useWeakArchivistFromNode } from "@xyo-network/react-archivist";
+var useClearIntents = () => {
+  const [intentArchivist] = useWeakArchivistFromNode("IntentArchivist");
+  useAsyncEffect2(
+    async () => {
+      const intentArchivistInstance = intentArchivist?.deref();
+      if (intentArchivistInstance) await intentArchivistInstance.clear?.();
+    },
+    [intentArchivist]
+  );
+};
+
+// src/modules/intent/useDappIntentCaller.ts
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { DappIntentCaller } from "@xyo-network/os-runtime";
+import { useMemo as useMemo6 } from "react";
+var useDappIntentCaller = (xyOsContext) => {
+  const xyOs = useXyOsUiContext();
+  return useMemo6(() => {
+    if (xyOsContext || xyOs) {
+      const context = assertEx5(xyOsContext ?? xyOs, () => "no node was found in context or passed as argument");
+      return new DappIntentCaller(context);
+    }
+  }, [xyOsContext, xyOs]);
+};
+
+// src/modules/intent/useDappIntentListener.ts
+import { filterAs } from "@xylabs/sdk-js";
+import {
+  asOptionalDappIntent,
+  DappIntentTypes as DappIntentTypes2,
+  DappMode
+} from "@xyo-network/os-model";
+import { useWeakArchivistFromNode as useWeakArchivistFromNode2 } from "@xyo-network/react-archivist";
+import { useEffect as useEffect8, useState as useState6 } from "react";
+var useDappIntentListener = (dappName, targetMode = DappMode.Window) => {
+  const [dappIntentType, setDappIntentType] = useState6(DappIntentTypes2.Close);
+  const [intentPayload, setIntentPayload] = useState6();
+  const [intentArchivist] = useWeakArchivistFromNode2("IntentArchivist");
+  useEffect8(() => {
+    const listener = ({ payloads }) => {
+      const filteredPayloads = filterAs(payloads, asOptionalDappIntent);
+      for (const payload of filteredPayloads) {
+        const allDapps = dappName === null && payload.targetMode === targetMode;
+        const targetDapps = dappName === payload.targetDappId && payload.targetMode === targetMode;
+        if (allDapps || targetDapps) {
+          setIntentPayload(payload);
+          switch (payload.intent) {
+            case DappIntentTypes2.Close: {
+              setDappIntentType(DappIntentTypes2.Close);
+              break;
+            }
+            case DappIntentTypes2.Launch: {
+              setDappIntentType(DappIntentTypes2.Launch);
+              break;
+            }
+            case DappIntentTypes2.Minimize: {
+              setDappIntentType(DappIntentTypes2.Minimize);
+              break;
+            }
+            default: {
+              console.warn("Unrecognized DappIntentType:", payload);
+            }
+          }
+        }
+      }
+    };
+    intentArchivist?.deref()?.on("inserted", listener);
+    return () => {
+      intentArchivist?.deref()?.off("inserted", listener);
+    };
+  }, [dappName, intentArchivist, targetMode]);
+  return { dappIntentType, intentPayload };
+};
+
+// src/modules/intent/useDappIntentListener2.ts
+import { DappIntentTypes as DappIntentTypes3, DappMode as DappMode2 } from "@xyo-network/os-model";
+import { useEffect as useEffect9, useState as useState7 } from "react";
+var useDappIntentListener2 = (dappName, sourceMode = DappMode2.Window) => {
+  const { latestDappIntent } = DappIntentResourceHooks.useResourceViewsFromProvidedNode();
+  const [dappIntentType, setDappIntentType] = useState7(DappIntentTypes3.Close);
+  useEffect9(() => {
+    if (sourceMode !== DappMode2.Window) {
+      console.warn("Intent sent from unrecognized mode", sourceMode);
+      return;
+    }
+    let nextIntent;
+    for (const payload of latestDappIntent ?? []) {
+      if (payload.targetDappId === dappName) {
+        switch (payload.intent) {
+          case DappIntentTypes3.Close: {
+            nextIntent = DappIntentTypes3.Close;
+            break;
+          }
+          case DappIntentTypes3.Launch: {
+            nextIntent = DappIntentTypes3.Launch;
+            break;
+          }
+          case DappIntentTypes3.Minimize: {
+            nextIntent = DappIntentTypes3.Minimize;
+            break;
+          }
+          default: {
+            console.warn("Unrecognized DappIntentType:", payload);
+          }
+        }
+      }
+    }
+    if (nextIntent !== void 0) {
+      const timeoutId = setTimeout(() => setDappIntentType(nextIntent), 0);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [dappName, latestDappIntent, sourceMode]);
+  return dappIntentType;
+};
+
+// src/modules/intent/useNavigateIntent.ts
+import { DappIntentTypes as DappIntentTypes4 } from "@xyo-network/os-model";
+import { NameTransforms } from "@xyo-network/os-runtime";
+import { useCallback as useCallback2 } from "react";
+import { useNavigate as useNavigate2, useParams } from "react-router-dom";
+var rootRoute = "/";
+var useNavigateIntent = () => {
+  const navigate = useNavigate2();
+  const { dappName: dappNameParam } = useParams();
+  const updateRouteParam = useCallback2(
+    (dappIntent, { skipNavigate } = {}) => {
+      if (dappIntent?.targetDappId) {
+        const {
+          targetDappId: dappName,
+          intent: intentType,
+          params: intentParams
+        } = dappIntent;
+        const slug = new NameTransforms(dappName).slug();
+        switch (intentType) {
+          case DappIntentTypes4.Launch: {
+            const dappNameDeSlugged = dappNameParam ? new NameTransforms(dappNameParam).deSlug() : null;
+            if (dappNameDeSlugged !== dappName) {
+              const slugFromRoot = `${rootRoute}${slug}${intentParams ? `/${intentParams}` : ""}`;
+              if (!skipNavigate) void navigate(slugFromRoot);
+            }
+            break;
+          }
+          case DappIntentTypes4.Minimize: {
+            if (!skipNavigate) void navigate(rootRoute);
+            break;
+          }
+          case DappIntentTypes4.Close: {
+            if (!skipNavigate) void navigate(rootRoute);
+            break;
+          }
+        }
+      }
+    },
+    [dappNameParam, navigate]
+  );
+  return updateRouteParam;
+};
+
+// src/modules/intent/useSendDappIntent.ts
+import { useWeakArchivistFromNode as useWeakArchivistFromNode3 } from "@xyo-network/react-archivist";
+import { useCallback as useCallback3 } from "react";
+var useSendDappIntent = () => {
+  const [intentArchivist] = useWeakArchivistFromNode3("IntentArchivist");
+  const navigate = useNavigateIntent();
+  const sendIntent = useCallback3(
+    async (dappIntent, options = {}) => {
+      const intentArchivistInstance = intentArchivist?.deref();
+      if (!intentArchivistInstance) {
+        console.error("unable to find IntentArchivist");
+        return;
+      }
+      if (dappIntent) {
+        try {
+          await intentArchivistInstance.insert([dappIntent]);
+        } catch (e) {
+          console.error("error sending intent to archivist", e);
+        }
+        navigate(dappIntent, options);
+      } else {
+        console.warn("tried to send intent but intent payload");
+      }
+    },
+    // Disabling because navigate changes references and causes additional renders
+    [intentArchivist]
+  );
+  return intentArchivist ? sendIntent : null;
+};
+
+// src/modules/Dapp/lib/DefaultIconSize.ts
+var DEFAULT_ICON_SIZE = 84;
+
+// src/modules/Dapp/lib/deriveDappState.ts
+import { DappIntentTypes as DappIntentTypes5 } from "@xyo-network/os-model";
+var deriveDappState = (intent) => {
+  const minimized = intent?.intent === DappIntentTypes5.Minimize;
+  const active = intent?.intent === DappIntentTypes5.Launch;
+  const closed = intent?.intent === DappIntentTypes5.Close;
+  return {
+    active,
+    closed,
+    minimized
+  };
+};
+
+// src/modules/Dapp/RenderHtml.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var RenderHtml = ({ htmlString }) => {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      style: { height: 64, width: 64 },
+      dangerouslySetInnerHTML: { __html: htmlString }
+    }
+  );
+};
+
+// src/modules/Dapp/Button/LaunchFrame.tsx
+import { useTheme } from "@mui/material";
+import {
+  animated,
+  config,
+  useSpring
+} from "@react-spring/web";
+import { useMemo as useMemo7 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var DappLaunchFrame = ({
+  bgColor,
+  children,
+  id,
+  launchLeft,
+  open,
+  launchTop,
+  ref
+}) => {
+  const theme = useTheme();
+  const frameOpenSpringConfig = useMemo7(
+    () => ({
+      config: config.stiff,
+      from: { height: "0%", width: "0%" },
+      to: {
+        height: open ? "100dvh" : "0%",
+        left: open ? 0 : launchLeft,
+        top: open ? 0 : launchTop,
+        width: open ? "100vw" : "0%"
+      }
+    }),
+    [launchLeft, launchTop, open]
+  );
+  const {
+    height,
+    width,
+    ...frameProps
+  } = useSpring(frameOpenSpringConfig);
+  const { transform, ...scaleProps } = useSpring({
+    config: config.stiff,
+    from: { transform: "scale(0)" },
+    to: { transform: open ? "scale(1)" : "scale(0)" }
+  });
+  return /* @__PURE__ */ jsx4("div", { id, ref, children: /* @__PURE__ */ jsx4(
+    animated.div,
+    {
+      id: "dapp-launch-frame-transition-width-height",
+      style: {
+        ...frameProps,
+        height,
+        overflow: "hidden",
+        position: "fixed",
+        width,
+        // Set to one above the mui app bar
+        zIndex: 1101
+      },
+      children: /* @__PURE__ */ jsx4(
+        animated.div,
+        {
+          id: "dapp-launch-frame-transition-scale",
+          style: {
+            ...scaleProps,
+            alignItems: "start",
+            background: bgColor ?? theme.vars?.palette.background.default,
+            display: "flex",
+            height: "100%",
+            justifyContent: "start",
+            transform,
+            width: "100%"
+          },
+          children
+        }
+      )
+    }
+  ) });
+};
+
+// src/modules/Dapp/Button/lib/decomposeProps.tsx
+var decomposeProps = (dappIcon, props) => {
+  const { color, windowId: id } = dappIcon ?? {};
+  const DappIconSize = DEFAULT_ICON_SIZE * 0.8;
+  const { sx, ...nonSxProps } = props ?? {};
+  return {
+    DappIconSize,
+    color,
+    id,
+    nonSxProps,
+    sx
+  };
+};
+
+// src/modules/Dapp/Button/StyledComponents.tsx
+import { styled } from "@mui/material";
+import { ButtonEx as ButtonEx2 } from "@xylabs/react-button";
+import { alphaCss } from "@xylabs/react-theme";
+import { TypographyEx } from "@xyo-network/react-shared";
+var borderRadiusFactor = 1.5;
+var StyledDappIconButtonEx = styled(ButtonEx2, {
+  name: "DappIconButton",
+  shouldForwardProp: (prop) => !["iconBgBaseColor"].includes(prop)
+})(({ theme }) => {
+  return {
+    // :before hack in place since css transitions not supported in css
+    "&:before": {
+      WebkitBackdropFilter: "blur(20px)",
+      backdropFilter: "blur(20px)",
+      backgroundColor: alphaCss(theme.vars?.palette.background.paper ?? "#fff", 0.5),
+      borderRadius: theme.spacing(borderRadiusFactor),
+      content: "''",
+      inset: 0,
+      opacity: 0,
+      position: "absolute",
+      transition: "transform 0.15s linear, opacity 0.15s linear",
+      zIndex: "-1"
+    },
+    "&:hover": { transform: "translateY(-2px)" },
+    "&:hover:before": { opacity: 1 },
+    "WebkitBackdropFilter": "blur(20px)",
+    "backdropFilter": "blur(20px)",
+    "backgroundColor": alphaCss(theme.vars?.palette.background.paper ?? "#fff", 0.5),
+    "borderRadius": theme.spacing(borderRadiusFactor),
+    "color": theme.vars?.palette.text.primary,
+    "position": "relative",
+    "transition": "transform 0.15s linear"
+  };
+});
+var StyledDappName = styled(TypographyEx, { name: "StyledDappName" })(({ theme }) => ({
+  // WebkitBoxOrient: 'vertical',
+  WebkitLineClamp: 2,
+  color: theme.vars?.palette.text.primary,
+  flexWrap: "wrap",
+  fontWeight: 700,
+  letterSpacing: "-0.5px",
+  lineClamp: 2,
+  textAlign: "center",
+  textOverflow: "ellipsis",
+  textShadow: `1px 1px 3px ${alphaCss(theme.vars?.palette.common.black ?? "#000", 0.3)}`,
+  whiteSpace: "initial",
+  wordWrap: "break-word"
+}));
+var StyledDefaultDappIcon = styled(TypographyEx, { name: "StyledDappName" })(() => ({ lineHeight: 1 }));
+
+// src/modules/Dapp/Button/IconEx.tsx
+import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+var DappIconButton = ({
+  children,
+  dappIcon,
+  dappIconSvg,
+  dappName,
+  dappState,
+  ...props
+}) => {
+  const {
+    DappIconSize,
+    color,
+    nonSxProps,
+    sx
+  } = decomposeProps(dappIcon, props);
+  const iconSize = DEFAULT_ICON_SIZE;
+  const { active, minimized } = dappState ?? {};
+  const sendIntent = useSendDappIntent();
+  const iconButtonRef = useRef2(null);
+  const { left: launchLeft, top: launchTop } = useLaunchPoint(iconButtonRef);
+  const MiddleEllipsisFunction = (str) => {
+    if (str && str.length > 25) {
+      return str.slice(0, 15) + "..." + str.slice(-7, str.length - 7 + str.length);
+    }
+    return str;
+  };
+  const onClickIcon = async () => {
+    XyOsMonitor2.trackEvent("Launch dApp", { "Dapp Name": `${dappName}` });
+    await sendIntent?.(DappIntentCaller2.buildIntent(DappIntentCaller2.OsDappName, DappIntentTypes6.Launch, dappName));
+  };
+  return /* @__PURE__ */ jsxs(FlexCol, { sx: { alignItems: "stretch", justifyContent: "stretch" }, children: [
+    /* @__PURE__ */ jsx5(DappLaunchFrame, { id: "dapp-launch-frame", open: !!active, launchLeft, launchTop, children }),
+    /* @__PURE__ */ jsxs(
+      "span",
+      {
+        style: { cursor: "pointer" },
+        onClick: onClickIcon,
+        children: [
+          /* @__PURE__ */ jsx5(
+            StyledDappIconButtonEx,
+            {
+              iconBgBaseColor: color,
+              ref: iconButtonRef,
+              sx: {
+                height: iconSize,
+                mb: 0.75,
+                width: iconSize,
+                ...sx
+              },
+              ...nonSxProps,
+              children: dappIconSvg ? /* @__PURE__ */ jsx5(RenderHtml, { htmlString: dappIconSvg }) : /* @__PURE__ */ jsx5(StyledDefaultDappIcon, { sx: { fontSize: DappIconSize }, children: dappIcon?.name.at(0) })
+            }
+          ),
+          /* @__PURE__ */ jsxs(FlexCol, { sx: { gap: 0.25 }, children: [
+            /* @__PURE__ */ jsx5(StyledDappName, { variant: "body2", sx: { maxWidth: iconSize }, children: MiddleEllipsisFunction(dappIcon?.name) }),
+            /* @__PURE__ */ jsx5(
+              Circle,
+              {
+                sx: {
+                  height: 8,
+                  opacity: minimized ? 1 : 0,
+                  transition: "opacity .5s"
+                }
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+
+// src/modules/Dapp/modules/access-interface/components/Dialog.tsx
+import { ArrowForward } from "@mui/icons-material";
+import {
+  Alert,
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogTitle,
+  Typography
+} from "@mui/material";
+import { ErrorRender } from "@xylabs/react-error";
+import { FlexCol as FlexCol2, FlexRow } from "@xylabs/react-flexbox";
+import { RegisteredNames } from "@xyo-network/os-model";
+import { AccessNodeQueries } from "@xyo-network/os-runtime";
+import { useState as useState8 } from "react";
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var DappAccessDialog = ({
+  accessRequest,
+  children,
+  dappNode,
+  registeredDappAccess,
+  ...props
+}) => {
+  const [error, setError] = useState8();
+  const [noPayloadsInserted, setNoPayloadsInserted] = useState8(false);
+  const onClose = () => {
+    setNoPayloadsInserted(false);
+    props.onClose?.({}, "escapeKeyDown");
+  };
+  const handleAllow = () => {
+    if (accessRequest && registeredDappAccess && dappNode) {
+      try {
+        switch (registeredDappAccess.name) {
+          case RegisteredNames: {
+            const accessNodeQueries = new AccessNodeQueries(dappNode, accessRequest, registeredDappAccess);
+            accessNodeQueries.run().then((payloads) => {
+              if (payloads.length === 0) {
+                setNoPayloadsInserted(true);
+              } else {
+                onClose();
+              }
+              return;
+            }).catch((e) => {
+              setError(e);
+            });
+            break;
+          }
+          default: {
+            const message = `no helper for interface ${registeredDappAccess.name} found`;
+            console.error(message);
+            setError(new Error(message));
+          }
+        }
+      } catch (e) {
+        console.error(e);
+        setError(e);
+      }
+    } else {
+      setError(new Error("No registered dapp access or dappNode found"));
+    }
+  };
+  return /* @__PURE__ */ jsxs2(Dialog, { ...props, children: [
+    /* @__PURE__ */ jsx6(DialogTitle, { children: "Message from XYO OS" }),
+    /* @__PURE__ */ jsxs2(
+      DialogContent,
+      {
+        dividers: true,
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: 3
+        },
+        children: [
+          /* @__PURE__ */ jsx6(ErrorRender, { error, scope: "DappAccessDialog" }),
+          /* @__PURE__ */ jsxs2(FlexCol2, { sx: { gap: 1 }, children: [
+            /* @__PURE__ */ jsx6(Typography, { variant: "subtitle2", children: "dApp to dApp Access Request" }),
+            /* @__PURE__ */ jsxs2(FlexRow, { sx: { gap: 1 }, children: [
+              /* @__PURE__ */ jsxs2(Typography, { sx: { fontSize: 16 }, children: [
+                /* @__PURE__ */ jsx6("strong", { children: accessRequest?.requestingDappId }),
+                "\xA0"
+              ] }),
+              /* @__PURE__ */ jsx6(ArrowForward, {}),
+              /* @__PURE__ */ jsx6(Typography, { sx: { fontSize: 16 }, children: /* @__PURE__ */ jsx6("strong", { children: registeredDappAccess?.registeringDappId }) })
+            ] })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      DialogContent,
+      {
+        dividers: true,
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: 3
+        },
+        children: [
+          /* @__PURE__ */ jsx6(FlexCol2, { sx: { gap: 1 }, children: /* @__PURE__ */ jsxs2(Typography, { children: [
+            /* @__PURE__ */ jsx6("strong", { children: accessRequest?.requestingDappId }),
+            " ",
+            "dApp would like to access your",
+            /* @__PURE__ */ jsx6("strong", { children: registeredDappAccess?.name }),
+            " ",
+            "from",
+            " ",
+            /* @__PURE__ */ jsx6("strong", { children: registeredDappAccess?.registeringDappId }),
+            " ",
+            "dApp"
+          ] }) }),
+          noPayloadsInserted ? /* @__PURE__ */ jsxs2(Alert, { severity: "warning", children: [
+            registeredDappAccess?.name,
+            " ",
+            "Access Request did not find payloads to insert"
+          ] }) : null
+        ]
+      }
+    ),
+    children ? /* @__PURE__ */ jsx6(DialogContent, { dividers: true, children }) : null,
+    /* @__PURE__ */ jsxs2(DialogActions, { children: [
+      /* @__PURE__ */ jsx6(Button, { variant: "outlined", onClick: onClose, children: "Cancel" }),
+      /* @__PURE__ */ jsx6(Button, { variant: "contained", onClick: handleAllow, children: "Allow" })
+    ] })
+  ] });
+};
+
+// src/modules/Dapp/modules/access-interface/components/Flexbox.tsx
+import { ErrorRender as ErrorRender2 } from "@xylabs/react-error";
+
+// src/modules/Dapp/modules/access-interface/hooks/useDialogState.tsx
+import { usePromise as usePromise8 } from "@xylabs/react-promise";
+import { isRegisteredDappAccess, RegisteredNames as RegisteredNames2 } from "@xyo-network/os-model";
+import { useState as useState9 } from "react";
+
+// src/modules/Dapp/useDappCaller.ts
+import { DappCaller } from "@xyo-network/os-runtime";
+import { useMemo as useMemo8 } from "react";
+var useDappCaller = (context) => {
+  const xyOs = useXyOsUiContext();
+  return useMemo8(() => {
+    const resolvedContext = context ?? xyOs;
+    if (resolvedContext) {
+      return new DappCaller(resolvedContext);
+    }
+  }, [context, xyOs]);
+};
+
+// src/modules/Dapp/modules/access-interface/hooks/useDialogState.tsx
+var useDialogState = (context) => {
+  const dappCaller = useDappCaller();
+  const { accessRequests } = DappAccessRequestResourceHooks.resourceViewsFromContext(context);
+  const [openAccessDialog, setOpenAccessDialog] = useState9(false);
+  const [registeredInterface, setRegisteredInterface] = useState9();
+  const [, allowAccessDialogError] = usePromise8(async () => {
+    const accessRequest = accessRequests?.[0];
+    if (accessRequest && context && dappCaller) {
+      setOpenAccessDialog(true);
+      const payload = await dappCaller.getRegisteredDappAccessByName(RegisteredNames2);
+      setRegisteredInterface(isRegisteredDappAccess(payload) ? payload : void 0);
+    }
+  }, [accessRequests, dappCaller, context]);
+  return {
+    accessRequests,
+    allowAccessDialogError,
+    openAccessDialog,
+    registeredInterface,
+    setOpenAccessDialog
+  };
+};
+
+// src/modules/Dapp/modules/access-interface/components/Flexbox.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var DappAccessFlexbox = ({ context }) => {
+  const {
+    accessRequests,
+    allowAccessDialogError,
+    openAccessDialog,
+    registeredInterface,
+    setOpenAccessDialog
+  } = useDialogState(context);
+  return /* @__PURE__ */ jsx7(
+    DappAccessDialog,
+    {
+      accessRequest: accessRequests?.[0],
+      dappNode: context,
+      open: openAccessDialog,
+      onClose: () => setOpenAccessDialog(false),
+      registeredDappAccess: registeredInterface,
+      children: allowAccessDialogError ? /* @__PURE__ */ jsx7(ErrorRender2, { error: allowAccessDialogError, scope: "DappAccessFlexbox" }) : null
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/AppBar.tsx
+import {
+  BugReport,
+  CloseRounded,
+  RemoveRounded
+} from "@mui/icons-material";
+import {
+  AppBar,
+  Box,
+  Divider,
+  IconButton,
+  Toolbar,
+  Tooltip,
+  Typography as Typography2
+} from "@mui/material";
+import { FlexGrowRow } from "@xylabs/react-flexbox";
+import { ColorSchemeButton } from "@xylabs/react-theme";
+import { DappIntentTypes as DappIntentTypes9 } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller5 } from "@xyo-network/os-runtime";
+
+// src/modules/Dapp/Debug/Dialog.tsx
+import {
+  Dialog as Dialog2,
+  DialogActions as DialogActions2,
+  DialogContent as DialogContent2
+} from "@mui/material";
+import { ButtonEx as ButtonEx3 } from "@xylabs/react-button";
+import { FlexCol as FlexCol3 } from "@xylabs/react-flexbox";
+import { NodeProvider } from "@xyo-network/react-node";
+import { lazy, Suspense } from "react";
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+var Debug = lazy(() => import(
+  /* webpackChunkName: "Debug" */
+  "@xyo-network/os-react-debug"
+));
+var LazyDebug = () => /* @__PURE__ */ jsxs3(Suspense, { fallback: /* @__PURE__ */ jsx8(FlexCol3, {}), children: [
+  /* @__PURE__ */ jsx8(FlexCol3, {}),
+  /* @__PURE__ */ jsx8(Debug, { sx: { height: "100%" } })
+] });
+var DebugDialog = ({
+  closeDebug,
+  debugOpen,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs3(Dialog2, { open: debugOpen, onClose: closeDebug, fullScreen: true, ...props, children: [
+    /* @__PURE__ */ jsx8(DialogContent2, { children: /* @__PURE__ */ jsx8(LazyDebug, {}) }),
+    /* @__PURE__ */ jsx8(DialogActions2, { children: /* @__PURE__ */ jsx8(ButtonEx3, { variant: "outlined", onClick: closeDebug, children: "Close" }) })
+  ] });
+};
+var DebugDialogWithNode = ({
+  closeDebug,
+  debugOpen,
+  context,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx8(NodeProvider, { node: context?.root, children: /* @__PURE__ */ jsx8(DebugDialog, { closeDebug, debugOpen, ...props }) });
+};
+
+// src/modules/Dapp/modules/Window/hooks/lib/DappPathHelpers.ts
+import { NameTransforms as NameTransforms2 } from "@xyo-network/os-runtime";
+var DappPathHelpers = {
+  // update the url based off the path
+  deriveDestinationPath(path, defaultPath, dappName) {
+    const rootPath = `/${new NameTransforms2(dappName ?? "").slug()}`;
+    const nestedPath = `${rootPath}/${path}`;
+    return path === defaultPath ? rootPath : nestedPath;
+  },
+  // derive the path for the nav selection
+  derivePathForNavSelection(newPath, currentPath, defaultPath) {
+    let derivedPath;
+    if (newPath === void 0 && defaultPath) {
+      derivedPath = defaultPath;
+    }
+    if (newPath && currentPath !== newPath) {
+      derivedPath = newPath;
+    }
+    return derivedPath;
+  },
+  // detect duplicate nav selections
+  detectDuplicateSelections(lastSavedPath, path, defaultPath) {
+    const selectedDefaultPathAgain = path === defaultPath && lastSavedPath === "";
+    const pathIsUnchanged = lastSavedPath === path;
+    return selectedDefaultPathAgain || pathIsUnchanged;
+  }
+};
+
+// src/modules/Dapp/modules/Window/hooks/lib/detectCustomer.ts
+var CustomerParams = [
+  { key: "utm_source", value: "coin" },
+  {
+    key: "receipt",
+    matches: "*",
+    value: "receiptHash"
+  }
+];
+var detectCustomer = () => {
+  return CustomerParams.find((customerParamSet) => {
+    const searchParams = new URLSearchParams(globalThis.location.search);
+    const searchParamValue = searchParams.get(customerParamSet.key);
+    if (searchParams.has(customerParamSet.key) && customerParamSet.matches === "*") {
+      return true;
+    }
+    return searchParamValue && searchParamValue === customerParamSet.value;
+  });
+};
+
+// src/modules/Dapp/modules/Window/hooks/menu/useAddDappMenuItems.ts
+import { usePromise as usePromise10 } from "@xylabs/react-promise";
+
+// src/modules/Dapp/modules/Window/hooks/menu/useBuildDappMenuResource.ts
+import { usePromise as usePromise9 } from "@xylabs/react-promise";
+import { DappMenuResource } from "@xyo-network/os-runtime";
+var useBuildDappMenuResource = (xyOsContext) => {
+  const resource = usePromise9(async () => {
+    if (xyOsContext) {
+      const resource2 = new DappMenuResource(xyOsContext);
+      await resource2.start();
+      return resource2;
+    }
+  }, [xyOsContext]);
+  useCleanUpResource(resource[0]);
+  return resource;
+};
+var useMenuResourceViews = (resource) => {
+  const menuItemSelections = useSyncExternalPayloadStore("menuItemSelections", resource);
+  const menuConfigs = useSyncExternalPayloadStore("menuConfigs", resource);
+  const menuItems = useSyncExternalPayloadStore("menuItems", resource);
+  const menuItemsVisible = useSyncExternalPayloadStore("menuItemsVisible", resource);
+  return {
+    menuConfigs,
+    menuItemSelections,
+    menuItems,
+    menuItemsVisible,
+    resource
+  };
+};
+var DappMenuResourceHooks = new ResourceHooks(useBuildDappMenuResource, useMenuResourceViews);
+
+// src/modules/Dapp/modules/Window/hooks/menu/useDappMenuCaller.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { DappMenuCaller } from "@xyo-network/os-runtime";
+import { useMemo as useMemo9 } from "react";
+var useDappMenuCaller = (context, { ignoreProvidedNode } = {}) => {
+  const xyOs = useXyOsUiContext();
+  return useMemo9(() => {
+    const resolvedProvidedNode = ignoreProvidedNode ? null : xyOs;
+    if (context || resolvedProvidedNode) {
+      const finalContext = assertEx6(context ?? xyOs, () => "no node was found in context or passed as argument");
+      return new DappMenuCaller(finalContext);
+    }
+  }, [ignoreProvidedNode, context, xyOs]);
+};
+
+// src/modules/Dapp/modules/Window/hooks/menu/useAddDappMenuItems.ts
+var useAddDappMenuItems = (payloads) => {
+  const xyOs = useXyOsUiContext();
+  const {
+    menuItemSelections,
+    menuConfigs,
+    resourceError
+  } = DappMenuResourceHooks.resourceViewsFromContext(xyOs);
+  const dappMenuCaller = useDappMenuCaller();
+  const [, addMenuItemsError] = usePromise10(async () => {
+    await dappMenuCaller?.add(payloads);
+  }, [payloads, dappMenuCaller]);
+  return {
+    addMenuItemsError,
+    menuConfig: menuConfigs?.[0],
+    path: menuItemSelections?.[0],
+    error: resourceError
+  };
+};
+
+// src/modules/Dapp/modules/Window/hooks/menu/useDappMenu.ts
+import {
+  useEffect as useEffect10,
+  useRef as useRef3,
+  useState as useState10
+} from "react";
+import { useNavigate as useNavigate3, useParams as useParams2 } from "react-router-dom";
+
+// src/modules/Dapp/modules/Window/hooks/menu/useDappMenuDependencies.ts
+import { useMemo as useMemo10 } from "react";
+var useDappMenuDependencies = (context) => {
+  const {
+    menuConfigs,
+    menuItemSelections,
+    menuItemsVisible,
+    resourceError
+  } = DappMenuResourceHooks.resourceViewsFromContext(context);
+  const defaultPath = useMemo10(() => menuConfigs?.[0]?.defaultPath, [menuConfigs]);
+  const menuSelection = menuItemSelections?.[0]?.path;
+  return {
+    defaultPath,
+    menuConfigs,
+    menuItemsVisible,
+    menuSelection,
+    resourceError
+  };
+};
+
+// src/modules/Dapp/modules/Window/hooks/menu/useDappMenu.ts
+var useDappMenu = (context, dappName) => {
+  const [error, setError] = useState10();
+  const params = useParams2();
+  const navigate = useNavigate3();
+  const {
+    defaultPath,
+    menuConfigs,
+    menuItemsVisible,
+    menuSelection,
+    resourceError
+  } = useDappMenuDependencies(context);
+  const activePath = menuSelection ?? defaultPath;
+  const currentPathRef = useRef3(void 0);
+  useEffect10(() => {
+    if (params && currentPathRef.current === void 0) {
+      currentPathRef.current = params.path ?? "";
+    }
+  }, []);
+  useEffect10(() => {
+    if (context === null) {
+      currentPathRef.current = void 0;
+    }
+  }, [context]);
+  useEffect10(() => {
+    if (menuSelection) {
+      currentPathRef.current = menuSelection;
+    }
+  }, [menuSelection]);
+  useEffect10(() => {
+    if (resourceError) {
+      const timeoutId = setTimeout(() => setError(resourceError), 0);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [resourceError]);
+  const onPathChange = (path) => {
+    const pathIsInUnchanged = DappPathHelpers.detectDuplicateSelections(currentPathRef.current, path, defaultPath);
+    if (pathIsInUnchanged) return;
+    const destinationPath = DappPathHelpers.deriveDestinationPath(path, defaultPath, dappName);
+    void navigate(destinationPath);
+    currentPathRef.current = path;
+  };
+  return {
+    activePath,
+    error,
+    menuConfig: menuConfigs?.[0],
+    menuItems: menuItemsVisible,
+    onPathChange
+  };
+};
+
+// src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappInjectableParamsFromRoute.tsx
+import { usePromise as usePromise11 } from "@xylabs/react-promise";
+import { assertEx as assertEx7, findAs } from "@xylabs/sdk-js";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { asOptionalDappInjectableParams } from "@xyo-network/os-model";
+import { DappCaller as DappCaller2 } from "@xyo-network/os-runtime";
+import { useNavigate as useNavigate4, useSearchParams } from "react-router-dom";
+var useManageDappInjectableParamsFromRoute = (context) => {
+  const [queryParams] = useSearchParams();
+  const navigate = useNavigate4();
+  const [, callerError] = usePromise11(async () => {
+    if (context && queryParams) {
+      const dappCaller = new DappCaller2(context);
+      const pathname = globalThis.location.pathname;
+      await dappCaller.setDappInjectableRouteParams(queryParams, pathname);
+    }
+  }, [context, queryParams]);
+  const [, listenerError] = usePromise11(async () => {
+    let archivist;
+    const listener = ({ payloads }) => {
+      const injectableParams = findAs(payloads, asOptionalDappInjectableParams);
+      if (injectableParams && context) {
+        const pathname = globalThis.location.pathname;
+        if (pathname !== injectableParams.path) {
+          void navigate(injectableParams.path);
+        }
+      }
+    };
+    try {
+      if (context) {
+        const mod = assertEx7(await context?.root.resolve("DappArchivist"), () => "DappArchivist not found");
+        archivist = asArchivistInstance(mod, () => "DappArchivist not is not an Archivist", { required: true });
+        archivist.on("inserted", listener);
+      }
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+    return () => {
+      archivist?.off("inserted", listener);
+    };
+  }, [context]);
+  return [callerError, listenerError];
+};
+
+// src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappIntentRequest.tsx
+import { useAtomicPromise, usePromise as usePromise12 } from "@xylabs/react-promise";
+import { findAs as findAs2 } from "@xylabs/sdk-js";
+import { asOptionalDappIntent as asOptionalDappIntent2, DappIntentTypes as DappIntentTypes7 } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller3 } from "@xyo-network/os-runtime";
+import { useEffect as useEffect11, useState as useState11 } from "react";
+var useManageDappIntentRequest = (context, dappId) => {
+  const dappCaller = useDappCaller(context);
+  const sendIntent = useSendDappIntent();
+  const [intentPayload, setIntentPayload] = useState11();
+  const [handleIntentError, setHandleIntentError] = useState11();
+  const [dappArchivist, setDappArchivist] = useState11();
+  usePromise12(async () => {
+    if (context && dappCaller) {
+      const archivist = await dappCaller.getDappArchivist();
+      if (archivist) setDappArchivist(archivist);
+    }
+  }, [context, dappCaller]);
+  useAtomicPromise(
+    "manageDappIntent",
+    async () => {
+      if (context && intentPayload?.targetDappId && dappId && sendIntent) {
+        try {
+          const minimizeIntent = DappIntentCaller3.buildIntent(DappIntentCaller3.OsDappName, DappIntentTypes7.Minimize, dappId);
+          await sendIntent(minimizeIntent);
+          await sendIntent(intentPayload);
+        } catch (e) {
+          console.error(e);
+          setHandleIntentError(e);
+        }
+        setIntentPayload(void 0);
+      }
+    },
+    [context, dappId, intentPayload, sendIntent]
+  );
+  useEffect11(() => {
+    const listener = ({ payloads }) => {
+      if (context) {
+        const intentPayload2 = findAs2(payloads, asOptionalDappIntent2);
+        if (intentPayload2) {
+          setIntentPayload(intentPayload2);
+        }
+      }
+    };
+    dappArchivist?.off("inserted", listener);
+    if (dappArchivist && context) {
+      dappArchivist.on("inserted", listener);
+    }
+    return () => {
+      dappArchivist?.off("inserted", listener);
+    };
+  }, [context, dappArchivist]);
+  return handleIntentError;
+};
+
+// src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappPathFromRoute.tsx
+import { usePromise as usePromise13 } from "@xylabs/react-promise";
+import {
+  useCallback as useCallback4,
+  useEffect as useEffect12,
+  useRef as useRef4
+} from "react";
+import { useNavigate as useNavigate5, useParams as useParams3 } from "react-router-dom";
+var useManageDappPathFromRoute = (context, dappName) => {
+  const params = useParams3();
+  const { path: pathParam } = params;
+  const dappMenuCaller = useDappMenuCaller(context, { ignoreProvidedNode: true });
+  const { menuSelection, defaultPath } = useDappMenuDependencies(context);
+  const navigate = useNavigate5();
+  const currentPathRef = useRef4(void 0);
+  const updateMenuArchivist = useCallback4(
+    async (pathParam2) => {
+      currentPathRef.current = pathParam2;
+      if (context && dappMenuCaller) {
+        const currentPath = await dappMenuCaller?.currentNavSelection();
+        const updatedPath = DappPathHelpers.derivePathForNavSelection(pathParam2, currentPath?.[0]?.path, defaultPath);
+        if (updatedPath) {
+          await dappMenuCaller.makeNavItemSelection(updatedPath);
+        }
+      }
+    },
+    [dappMenuCaller, context, defaultPath]
+  );
+  useEffect12(() => {
+    if (context && menuSelection) {
+      const pathIsInUnchanged = DappPathHelpers.detectDuplicateSelections(currentPathRef.current ?? "", menuSelection, defaultPath);
+      if (pathIsInUnchanged) return;
+      const destinationPath = DappPathHelpers.deriveDestinationPath(menuSelection, defaultPath, dappName);
+      void navigate(destinationPath);
+      currentPathRef.current = menuSelection === defaultPath ? void 0 : menuSelection;
+    }
+  }, [dappName, context, defaultPath, menuSelection]);
+  const [, updateErrors] = usePromise13(async () => {
+    if (context && pathParam !== currentPathRef.current) {
+      await updateMenuArchivist(pathParam);
+      currentPathRef.current = pathParam;
+    }
+  }, [context, pathParam, updateMenuArchivist]);
+  return updateErrors;
+};
+
+// src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappStateFromRoute.tsx
+import { usePromise as usePromise14 } from "@xylabs/react-promise";
+import { DappIntentTypes as DappIntentTypes8 } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller4, NameTransforms as NameTransforms3 } from "@xyo-network/os-runtime";
+import { useRef as useRef5 } from "react";
+import { useParams as useParams4 } from "react-router-dom";
+var useManageDappStateFromRoute = (intentPayload) => {
+  const params = useParams4();
+  const { dappName: dappNameParam } = params;
+  const sendIntent = useSendDappIntent();
+  const intentCaller = useDappIntentCaller();
+  const dappNameParamRef = useRef5(void 0);
+  const intentRef = useRef5(void 0);
+  usePromise14(async () => {
+    const launched = intentPayload?.intent === DappIntentTypes8.Launch;
+    const dappNameParamRemoved = !!dappNameParamRef.current && dappNameParam === void 0;
+    if (launched && dappNameParamRemoved && sendIntent) {
+      const closeIntent = DappIntentCaller4.buildIntent(DappIntentCaller4.OsDappName, DappIntentTypes8.Close);
+      await sendIntent(closeIntent);
+    }
+    dappNameParamRef.current = dappNameParam;
+  }, [dappNameParam, intentPayload, sendIntent]);
+  usePromise14(async () => {
+    if (dappNameParam && sendIntent && intentCaller) {
+      const dappNameParamDeSlugged = new NameTransforms3(dappNameParam).deSlug();
+      const autoLaunchNeeded = intentRef.current === void 0 && dappNameParam;
+      if (autoLaunchNeeded) {
+        const launchIntent = DappIntentCaller4.buildIntent(DappIntentCaller4.OsDappName, DappIntentTypes8.Launch, dappNameParamDeSlugged);
+        await sendIntent(launchIntent);
+        intentRef.current = launchIntent;
+        return;
+      }
+    }
+  }, [dappNameParam, sendIntent, intentCaller, intentPayload?.intent]);
+};
+
+// src/modules/Dapp/modules/Window/hooks/useDebugClick.ts
+import {
+  useCallback as useCallback5,
+  useEffect as useEffect13,
+  useRef as useRef6,
+  useState as useState12
+} from "react";
+import { useNavigate as useNavigate6, useSearchParams as useSearchParams2 } from "react-router-dom";
+var useDebugClick = () => {
+  const [params, setParams] = useSearchParams2();
+  const [debugOpen, setDebugOpen] = useState12(false);
+  const openFromClick = useRef6(false);
+  const closeFromClick = useRef6(false);
+  const initialized = useRef6(false);
+  const navigate = useNavigate6();
+  const openDebug = useCallback5(() => {
+    openFromClick.current = true;
+    closeFromClick.current = false;
+    setParams((params2) => {
+      params2.set("debug", "true");
+      return new URLSearchParams(params2);
+    });
+    setDebugOpen(true);
+  }, [setParams]);
+  const closeDebug = useCallback5(() => {
+    openFromClick.current = false;
+    closeFromClick.current = true;
+    initialized.current = false;
+    void navigate(-1);
+    setDebugOpen(false);
+  }, [navigate]);
+  useEffect13(() => {
+    const initialOpen = openFromClick.current && !closeFromClick.current && params.has("debug");
+    const backButtonClicked = openFromClick.current && !closeFromClick.current && !params.has("debug");
+    if (initialOpen) {
+      if (initialized.current === false) {
+        initialized.current = true;
+      }
+    } else if (backButtonClicked) {
+      initialized.current = false;
+      closeDebug();
+    }
+  }, [params, closeDebug]);
+  return {
+    closeDebug,
+    debugOpen,
+    openDebug
+  };
+};
+
+// src/modules/Dapp/modules/Window/hooks/useDecomposeDapp.tsx
+import { useMemo as useMemo11 } from "react";
+
+// src/modules/Dapp/modules/Window/NodeManifest.tsx
+import { usePromise as usePromise15 } from "@xylabs/react-promise";
+import { useProvidedNode } from "@xyo-network/react-node";
+import { Fragment, jsx as jsx9 } from "react/jsx-runtime";
+var NodeManifest = () => {
+  const [node] = useProvidedNode();
+  const [nodeManifest] = usePromise15(async () => await node?.manifest(3), [node]);
+  return /* @__PURE__ */ jsx9(Fragment, { children: node ? /* @__PURE__ */ jsx9("pre", { children: JSON.stringify(nodeManifest, null, 2) }) : null });
+};
+
+// src/modules/Dapp/modules/Window/hooks/useDecomposeDapp.tsx
+var useDecomposeDapp = (dapp) => {
+  const DappComponent = useMemo11(() => dapp?.params.modes?.window?.component ?? NodeManifest, []);
+  const name = dapp?.config.name;
+  const version = dapp?.config.version;
+  const scrollable = dapp?.params.modes?.window?.scrollable ?? true;
+  return {
+    DappComponent,
+    dapp,
+    name,
+    scrollable,
+    version
+  };
+};
+
+// src/modules/Dapp/modules/Window/hooks/useExposedNode.ts
+var useExposedNode = () => {
+  const xyOS = useXyOsUiContext();
+  return xyOS?.exposedNode;
+};
+
+// src/modules/Dapp/modules/Window/hooks/useSkipLoadingScreen.tsx
+import { useMemo as useMemo12 } from "react";
+import { useSearchParams as useSearchParams3 } from "react-router-dom";
+var PARAMS_TO_TARGET = ["username", "utm_source"];
+var useSkipLoadingScreen = () => {
+  const [params] = useSearchParams3();
+  const customer = detectCustomer();
+  return useMemo12(() => {
+    const hasTargetParams = PARAMS_TO_TARGET.some((param) => params.has(param));
+    const isCustomer = !!customer;
+    return hasTargetParams || isCustomer;
+  }, [customer, params]);
+};
+
+// src/modules/Dapp/modules/Window/hooks/useSyncOsRegisteredAccessInterfaces.tsx
+import { usePromise as usePromise16 } from "@xylabs/react-promise";
+import { useWeakArchivistFromNode as useWeakArchivistFromNode4 } from "@xyo-network/react-archivist";
+var useSyncOsRegisteredAccessInterfaces = (context) => {
+  const [registeredInterfacesArchivist] = useWeakArchivistFromNode4("RegisteredDappInterfacesArchivist");
+  const dappCaller = useDappCaller(context);
+  usePromise16(async () => {
+    const listener = async ({ payloads }) => {
+      if (context && dappCaller) {
+        await dappCaller.addPayloadsToDappArchivist(payloads);
+      }
+    };
+    if (context && dappCaller) {
+      const registeredInterfaces = await registeredInterfacesArchivist?.deref()?.all();
+      if (registeredInterfaces) {
+        await dappCaller.addPayloadsToDappArchivist(registeredInterfaces);
+      }
+      registeredInterfacesArchivist?.deref()?.on("inserted", listener);
+    }
+    return () => {
+      registeredInterfacesArchivist?.deref()?.off("inserted", listener);
+    };
+  }, [dappCaller, context, registeredInterfacesArchivist]);
+};
+
+// src/modules/Dapp/modules/Window/AppBar.tsx
+import { jsx as jsx10, jsxs as jsxs4 } from "react/jsx-runtime";
+var EmptyDappBarForPadding = (props) => {
+  return /* @__PURE__ */ jsx10(
+    AppBar,
+    {
+      color: "primary",
+      sx: { flexDirection: "row" },
+      component: "div",
+      position: "fixed",
+      ...props
+    }
+  );
+};
+var DappBar = ({
+  title,
+  context,
+  name,
+  ...props
+}) => {
+  const sendIntent = useSendDappIntent();
+  const {
+    closeDebug,
+    debugOpen,
+    openDebug
+  } = useDebugClick();
+  return /* @__PURE__ */ jsxs4(
+    AppBar,
+    {
+      elevation: 0,
+      color: "transparent",
+      sx: { backgroundColor: "transparent", flexDirection: "row" },
+      component: "div",
+      position: "sticky",
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx10(
+          Toolbar,
+          {
+            disableGutters: true,
+            sx: { paddingX: 2 },
+            children: /* @__PURE__ */ jsx10(Typography2, { noWrap: true, variant: "h6", sx: { letterSpacing: "-1px" }, children: title })
+          }
+        ),
+        /* @__PURE__ */ jsx10(FlexGrowRow, {}),
+        /* @__PURE__ */ jsxs4(
+          Toolbar,
+          {
+            disableGutters: true,
+            sx: { paddingX: 2 },
+            children: [
+              /* @__PURE__ */ jsx10(
+                IconButton,
+                {
+                  onClick: openDebug,
+                  sx: { display: { md: "none", xs: "flex" } },
+                  children: /* @__PURE__ */ jsx10(BugReport, {})
+                }
+              ),
+              /* @__PURE__ */ jsx10(
+                Tooltip,
+                {
+                  title: "Toggle Light/Dark Mode",
+                  sx: { display: { md: "none", xs: "flex" } },
+                  children: /* @__PURE__ */ jsx10(Box, { children: /* @__PURE__ */ jsx10(ColorSchemeButton, {}) })
+                }
+              ),
+              /* @__PURE__ */ jsx10(
+                Divider,
+                {
+                  orientation: "vertical",
+                  flexItem: true,
+                  sx: {
+                    display: { md: "none", xs: "flex" },
+                    m: 1
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx10(Tooltip, { title: "Minimize", children: /* @__PURE__ */ jsx10(
+                IconButton,
+                {
+                  onClick: async () => await sendIntent?.(DappIntentCaller5.buildIntent(DappIntentCaller5.OsDappName, DappIntentTypes9.Minimize, name)),
+                  children: /* @__PURE__ */ jsx10(RemoveRounded, { htmlColor: "inherit" })
+                }
+              ) }),
+              /* @__PURE__ */ jsx10(Tooltip, { title: "Close", children: /* @__PURE__ */ jsx10(
+                IconButton,
+                {
+                  onClick: async () => await sendIntent?.(DappIntentCaller5.buildIntent(DappIntentCaller5.OsDappName, DappIntentTypes9.Close, name)),
+                  children: /* @__PURE__ */ jsx10(CloseRounded, { htmlColor: "inherit" })
+                }
+              ) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx10(DebugDialogWithNode, { closeDebug, debugOpen, context })
+      ]
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/Chrome.tsx
+import { useMediaQuery } from "@mui/material";
+import {
+  FlexCol as FlexCol4,
+  FlexGrowCol,
+  FlexRow as FlexRow2
+} from "@xylabs/react-flexbox";
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
+var mergeSx = (base, override) => {
+  if (override === void 0) return base;
+  const overrideArr = Array.isArray(override) ? override : [override];
+  return [base, ...overrideArr];
+};
+var DappChromeSmall = ({
+  appBar,
+  children,
+  screenMenu,
+  splashScreen,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs5(FlexCol4, { id: "dapp-chrome-container-small", ...props, sx: mergeSx({ alignItems: "stretch" }, sx), children: [
+    splashScreen,
+    /* @__PURE__ */ jsxs5(
+      FlexGrowCol,
+      {
+        id: "dapp-chrome-small",
+        sx: {
+          alignItems: "stretch",
+          justifyContent: "start",
+          background: (theme) => theme.vars?.palette.background.default
+        },
+        children: [
+          appBar,
+          /* @__PURE__ */ jsx11(
+            FlexGrowCol,
+            {
+              sx: { overflowY: "auto", alignItems: "stretch" },
+              children
+            }
+          ),
+          screenMenu
+        ]
+      }
+    )
+  ] });
+};
+var DappChromeLarge = ({
+  appBar,
+  children,
+  screenMenu,
+  splashScreen,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs5(FlexRow2, { id: "dapp-chrome-container-large", ...props, sx: mergeSx({ alignItems: "stretch" }, sx), children: [
+    splashScreen,
+    screenMenu,
+    /* @__PURE__ */ jsxs5(
+      FlexGrowCol,
+      {
+        id: "dapp-chrome-large",
+        sx: {
+          alignItems: "stretch",
+          justifyContent: "start",
+          background: (theme) => theme.vars?.palette.background.default
+        },
+        children: [
+          appBar,
+          /* @__PURE__ */ jsx11(
+            FlexGrowCol,
+            {
+              sx: {
+                overflowY: "auto",
+                alignItems: "stretch",
+                justifyContent: "flex-start"
+              },
+              children
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+var DappChrome = ({
+  largeScreenMenu,
+  smallScreenMenu,
+  ...props
+}) => {
+  const isMedium = useMediaQuery((theme) => theme.breakpoints.up("md"));
+  return isMedium ? /* @__PURE__ */ jsx11(DappChromeLarge, { screenMenu: largeScreenMenu, ...props }) : /* @__PURE__ */ jsx11(DappChromeSmall, { screenMenu: smallScreenMenu, ...props });
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/DefaultComingSoon.tsx
+import {
+  Card as Card2,
+  CardContent as CardContent2,
+  Chip,
+  Container,
+  Divider as Divider2,
+  Typography as Typography4,
+  useTheme as useTheme4
+} from "@mui/material";
+import { FlexGrowCol as FlexGrowCol3, FlexRow as FlexRow5 } from "@xylabs/react-flexbox";
+import { alphaCss as alphaCss2 } from "@xylabs/react-theme";
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/InstallButtonSection.tsx
+import { ButtonEx as ButtonEx4 } from "@xylabs/react-button";
+import { FlexRow as FlexRow3 } from "@xylabs/react-flexbox";
+import { jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
+var InstallButtonSection = ({
+  installLink = "",
+  notificationLink = "https://xyo.network/newsletter",
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs6(
+    FlexRow3,
+    {
+      sx: {
+        width: "100%",
+        gap: 1,
+        alignItems: "flex-start",
+        flexDirection: { md: "row", xs: "column" }
+      },
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx12(ButtonEx4, { fullWidth: true, variant: "contained", disabled: true, href: installLink, children: "Install" }),
+        /* @__PURE__ */ jsx12(ButtonEx4, { fullWidth: true, variant: "outlined", href: notificationLink, target: "_blank", children: "Get Notified When Available" })
+      ]
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/SummarySection.tsx
+import { VerifiedRounded } from "@mui/icons-material";
+import {
+  Card,
+  CardContent,
+  Typography as Typography3,
+  useTheme as useTheme3
+} from "@mui/material";
+import {
+  FlexGrowCol as FlexGrowCol2,
+  FlexGrowRow as FlexGrowRow3,
+  FlexRow as FlexRow4
+} from "@xylabs/react-flexbox";
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/DeveloperLinkSection.tsx
+import { useTheme as useTheme2 } from "@mui/material";
+import { FlexGrowRow as FlexGrowRow2 } from "@xylabs/react-flexbox";
+import { LinkEx } from "@xylabs/react-link";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var DeveloperLinkSection = ({ developerLink = "https://xylabs.com", ...props }) => {
+  const theme = useTheme2();
+  return /* @__PURE__ */ jsx13(
+    FlexGrowRow2,
+    {
+      sx: {
+        gap: 1,
+        alignItems: "flex-start",
+        flexDirection: { md: "row", xs: "column" }
+      },
+      ...props,
+      children: /* @__PURE__ */ jsx13(LinkEx, { color: theme.vars?.palette.info.main, href: developerLink, target: "_blank", children: developerLink })
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/SummarySection.tsx
+import { jsx as jsx14, jsxs as jsxs7 } from "react/jsx-runtime";
+var SummarySection = ({
+  name,
+  dappIconSvg,
+  version = "1.0",
+  developerLink = "https://xylabs.com"
+}) => {
+  const theme = useTheme3();
+  return /* @__PURE__ */ jsx14(Card, { sx: { width: "100%" }, children: /* @__PURE__ */ jsx14(CardContent, { children: /* @__PURE__ */ jsx14(
+    FlexRow4,
+    {
+      sx: {
+        gap: 3,
+        alignItems: "flex-start",
+        flexDirection: "column",
+        width: "100%"
+      },
+      children: /* @__PURE__ */ jsxs7(
+        FlexGrowRow3,
+        {
+          sx: { gap: { md: 2, xs: 1 }, alignItems: "flex-start" },
+          children: [
+            /* @__PURE__ */ jsx14(Card, { elevation: 0, variant: "outlined", children: /* @__PURE__ */ jsx14(CardContent, { children: dappIconSvg ? /* @__PURE__ */ jsx14(RenderHtml, { htmlString: dappIconSvg }) : null }) }),
+            /* @__PURE__ */ jsxs7(FlexGrowCol2, { sx: { alignItems: "flex-start" }, children: [
+              /* @__PURE__ */ jsxs7(FlexGrowCol2, { sx: { alignItems: "flex-start" }, children: [
+                /* @__PURE__ */ jsx14(
+                  Typography3,
+                  {
+                    sx: {
+                      fontSize: { md: theme.typography.h1.fontSize, xs: theme.typography.h5.fontSize },
+                      fontWeight: theme.typography.fontWeightBold
+                    },
+                    children: name
+                  }
+                ),
+                /* @__PURE__ */ jsxs7(Typography3, { gutterBottom: true, variant: "subtitle2", children: [
+                  "Version:",
+                  " ",
+                  version
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs7(
+                FlexGrowRow3,
+                {
+                  sx: {
+                    gap: 0.5,
+                    alignItems: "center",
+                    justifyContent: "center"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx14(VerifiedRounded, { color: "success", fontSize: "small" }),
+                    /* @__PURE__ */ jsx14(Typography3, { variant: "body1", color: theme.vars?.palette.success.main, children: "XY Labs" })
+                  ]
+                }
+              ),
+              developerLink ? /* @__PURE__ */ jsx14(DeveloperLinkSection, { developerLink }) : null
+            ] })
+          ]
+        }
+      )
+    }
+  ) }) });
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/DefaultComingSoon.tsx
+import { jsx as jsx15, jsxs as jsxs8 } from "react/jsx-runtime";
+var defaultDescription = ["Description coming soon!"];
+var DefaultComingSoon = ({
+  children,
+  desc = defaultDescription,
+  developerLink = "https://xylabs.com",
+  name,
+  dappIconSvg,
+  version
+}) => {
+  const theme = useTheme4();
+  return /* @__PURE__ */ jsxs8(
+    Container,
+    {
+      maxWidth: "md",
+      sx: {
+        minHeight: "100%",
+        overflow: "auto",
+        paddingTop: 2,
+        width: "100%"
+      },
+      children: [
+        version ? null : /* @__PURE__ */ jsx15(FlexRow5, { sx: { width: "100%", paddingBottom: 2 }, children: /* @__PURE__ */ jsx15(
+          Chip,
+          {
+            label: "This app is not yet publicly available on xyOS",
+            sx: {
+              backgroundColor: alphaCss2(theme.vars?.palette.info.main ?? "#000", 0.2),
+              color: theme.vars?.palette.info.main,
+              width: "100%"
+            }
+          }
+        ) }),
+        /* @__PURE__ */ jsx15(
+          FlexGrowCol3,
+          {
+            sx: {
+              width: "100%",
+              alignItems: "flex-start",
+              minHeight: "100%"
+            },
+            children: /* @__PURE__ */ jsxs8(
+              FlexGrowCol3,
+              {
+                sx: {
+                  width: "100%",
+                  alignItems: "stretch",
+                  justifyContent: "flex-start",
+                  gap: 2
+                },
+                children: [
+                  /* @__PURE__ */ jsx15(SummarySection, { dappIconSvg, name, version, developerLink }),
+                  /* @__PURE__ */ jsx15(InstallButtonSection, {}),
+                  /* @__PURE__ */ jsx15(Divider2, { flexItem: true }),
+                  /* @__PURE__ */ jsx15(Card2, { children: /* @__PURE__ */ jsx15(CardContent2, { children: /* @__PURE__ */ jsxs8(FlexGrowCol3, { sx: { justifyContent: "flex-start", alignItems: "flex-start" }, children: [
+                    /* @__PURE__ */ jsxs8(Typography4, { variant: "h6", gutterBottom: true, children: [
+                      "Learn more about",
+                      " ",
+                      name
+                    ] }),
+                    desc?.map((paragraph, index) => {
+                      return /* @__PURE__ */ jsx15(Typography4, { gutterBottom: true, sx: { paddingBottom: 1 }, variant: "body1", children: paragraph }, index);
+                    })
+                  ] }) }) }),
+                  children
+                ]
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/components/menu/BottomNavigation.tsx
+import {
+  BottomNavigation,
+  BottomNavigationAction,
+  Paper,
+  styled as styled2
+} from "@mui/material";
+import { useIsDark } from "@xylabs/react-theme";
+import { useEffect as useEffect14, useState as useState13 } from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var DappBottomNavigation = ({
+  activePath,
+  menuConfig,
+  menuItems,
+  onPathChange,
+  ...props
+}) => {
+  const [activeIndex, setActiveIndex] = useState13(0);
+  useEffect14(() => {
+    if (menuConfig?.defaultPath && menuItems && activePath) {
+      const nextIndex = menuItems.findIndex((item) => activePath === item.path);
+      const timeoutId = setTimeout(() => setActiveIndex(nextIndex), 0);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [activePath, menuConfig, menuItems]);
+  return /* @__PURE__ */ jsx16(Paper, { elevation: 3, children: /* @__PURE__ */ jsx16(
+    BottomNavigation,
+    {
+      value: activeIndex,
+      onChange: (_, value) => {
+        setActiveIndex(value);
+        const to2 = menuItems?.[value].path;
+        if (to2) onPathChange?.(to2);
+      },
+      showLabels: true,
+      ...props,
+      children: menuItems?.map(({ svgIcon: icon, primaryText }, index) => {
+        return /* @__PURE__ */ jsx16(
+          StyledBottomNavigationAction,
+          {
+            className: "bottom-nav-action",
+            label: primaryText,
+            icon: /* @__PURE__ */ jsx16(
+              "span",
+              {
+                ref: (ref) => {
+                  if (ref) {
+                    ref.innerHTML = icon ?? "";
+                  }
+                }
+              }
+            )
+          },
+          index
+        );
+      })
+    }
+  ) });
+};
+var StyledBottomNavigationAction = styled2(BottomNavigationAction, { name: "StyledBottomNavigationAction" })(({ theme }) => {
+  const darkMode = useIsDark();
+  return { "&.Mui-selected": { color: darkMode ? theme.vars?.palette.primary.main : theme.vars?.palette.secondary.main } };
+});
+
+// src/modules/Dapp/modules/Window/components/menu/Drawer.tsx
+import {
+  alpha,
+  Drawer,
+  List,
+  ListItem,
+  ListItemIcon,
+  ListItemText,
+  Tooltip as Tooltip3,
+  Typography as Typography6,
+  useTheme as useTheme6
+} from "@mui/material";
+import {
+  FlexCol as FlexCol6,
+  FlexGrowRow as FlexGrowRow4,
+  FlexRow as FlexRow7
+} from "@xylabs/react-flexbox";
+import {
+  alphaCss as alphaCss3,
+  darkenCss,
+  useIsDark as useIsDark2
+} from "@xylabs/react-theme";
+import { XyOsMonitor as XyOsMonitor3 } from "@xyo-network/os-runtime";
+import { useEffect as useEffect15, useState as useState15 } from "react";
+
+// src/modules/Dapp/modules/Window/components/menu/BottomMenuArea.tsx
+import {
+  BugReport as BugReport2,
+  KeyboardArrowDownRounded,
+  KeyboardArrowUpRounded
+} from "@mui/icons-material";
+import {
+  Card as Card3,
+  Collapse,
+  Divider as Divider3,
+  IconButton as IconButton2,
+  Stack,
+  Toolbar as Toolbar2,
+  Tooltip as Tooltip2,
+  Typography as Typography5,
+  useTheme as useTheme5
+} from "@mui/material";
+import { RotationAnimation } from "@xylabs/react-animation";
+import { FlexCol as FlexCol5, FlexRow as FlexRow6 } from "@xylabs/react-flexbox";
+import { LinkEx as LinkEx2 } from "@xylabs/react-link";
+import { ColorSchemeButton as ColorSchemeButton2 } from "@xylabs/react-theme";
+import { useState as useState14 } from "react";
+
+// src/modules/Dapp/modules/Window/components/menu/img/xyoOS-Icon-White.svg
+var xyoOS_Icon_White_default = '<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 900 900"><defs><style>.cls-1{fill:#a8a8a8;opacity:.21;}.cls-1,.cls-2{stroke-width:0px;}.cls-2{fill:#fff;}</style></defs><path class="cls-1" d="M864.29,297.43c-2.44-6.58-9.76-9.94-16.34-7.5l-143.74,53.26L533.2,21.88c-1.85-3.48-5.21-5.9-9.09-6.56-3.89-.66-7.85.51-10.75,3.18l-267.76,246.55-118-97.86c-5.4-4.48-13.42-3.73-17.9,1.67-4.48,5.4-3.73,13.42,1.67,17.9l118,97.86L36.62,593.37c-2.09,3.34-2.5,7.46-1.14,11.15s4.37,6.54,8.13,7.72l347.4,108.61-25.75,151.12c-1.18,6.92,3.48,13.49,10.4,14.67.24.04.47.07.7.1,6.66.76,12.82-3.81,13.96-10.5l25.75-151.12,363.77,12.56c3.94.14,7.71-1.56,10.22-4.59,2.51-3.03,3.48-7.06,2.62-10.9l-79.64-355.16,143.75-53.26c6.58-2.44,9.94-9.75,7.5-16.34ZM518.49,48.34l156.33,293.75-401.12-68.35,244.79-225.4ZM674.37,367.8l-264.69,319.16-144.06-388.81,408.75,69.65ZM66.9,592.88l176.22-282.26,141.37,381.56-317.59-99.29ZM431.72,700.22l259.75-313.21,72.81,324.69-332.56-11.48Z"/><path class="cls-2" d="M865.04,302.64c.01-.2.02-.4.03-.6,0-.33,0-.66-.03-.99-.01-.2-.02-.39-.04-.58-.04-.35-.1-.71-.17-1.06-.03-.16-.05-.32-.09-.48-.12-.5-.26-1.01-.45-1.5-.18-.49-.4-.97-.64-1.43-.08-.15-.17-.29-.25-.43-.17-.31-.35-.61-.55-.9-.12-.17-.24-.33-.37-.49-.19-.25-.39-.5-.6-.74-.14-.16-.29-.32-.45-.47-.22-.22-.45-.44-.68-.65-.1-.08-.18-.18-.27-.26L530.1,18.07c-.34-.28-.7-.53-1.07-.77-.09-.06-.17-.13-.26-.19-.62-.39-1.26-.7-1.92-.98-.18-.07-.36-.14-.54-.21-.71-.26-1.43-.47-2.16-.6,0,0-.01,0-.02,0,0,0,0,0-.01,0-.67-.11-1.35-.15-2.03-.16-.37,0-.73,0-1.09.03-.23.02-.46.06-.7.09-.86.11-1.69.31-2.5.59-.07.03-.15.04-.23.07l-.32.12c-.2.08-.4.13-.59.22L115.08,165.06c-.11.04-.22.1-.33.15-.3.12-.59.25-.88.39-.19.1-.38.19-.57.3-.27.15-.54.32-.81.5-.17.12-.35.22-.52.35-.27.2-.53.42-.79.64-.14.12-.28.23-.41.35-.35.33-.68.68-1,1.05-.04.05-.08.1-.12.14-.32.38-.6.78-.87,1.2-.09.14-.16.29-.25.43-.18.31-.36.62-.51.94-.08.17-.15.35-.23.53-.13.31-.25.62-.36.93-.06.19-.12.38-.17.57-.09.33-.17.65-.23.98-.02.11-.06.22-.08.33l-72.09,423.12c-.07.43-.11.87-.13,1.3,0,.11-.03.22-.03.33-.03.73.02,1.44.12,2.16.02.19.06.38.09.57.13.74.31,1.48.57,2.19,0,0,0,0,0,0,0,.02.01.03.02.04.2.53.43,1.04.7,1.53.12.22.26.42.38.63.17.28.33.56.52.82.17.23.35.44.54.66.18.22.36.44.56.65.2.21.42.4.63.6.16.14.29.3.46.43l330.39,274c.08.07.17.12.25.18.32.25.65.49.99.71.15.09.29.19.44.28.44.26.9.5,1.37.7.04.02.08.04.12.06.51.21,1.03.39,1.56.53.17.05.35.08.53.12.24.06.47.12.71.16.23.04.46.07.69.1.47.05.95.08,1.42.08.15,0,.3-.02.45-.02.32-.01.65-.02.97-.06.18-.02.36-.06.54-.08.29-.04.58-.09.86-.15.19-.04.38-.1.56-.15.28-.08.55-.16.82-.25.08-.03.15-.04.23-.07l402.48-149.13s.06-.03.09-.04c.39-.15.76-.32,1.13-.51.12-.06.24-.1.35-.16.44-.24.88-.51,1.29-.8.03-.02.06-.04.09-.06.55-.39,1.07-.85,1.56-1.34.83-.82,1.54-1.76,2.11-2.78.09-.17.19-.33.27-.5.32-.64.61-1.3.82-2,.03-.11.05-.22.08-.33.12-.42.23-.84.3-1.27l72.09-423.12c.02-.11.02-.22.03-.33.05-.34.08-.67.1-1.01ZM771.44,701.13l-101.05-83.8,158.61-254.06-57.56,337.86ZM121.2,242.67l65.53,292.26-123.1,45.61,57.57-337.87ZM656.65,591.33l-141.37-381.56,317.59,99.3-176.22,282.26ZM508.76,181.1l22.05-129.41,263.81,218.79-285.86-89.37ZM483.7,176.83l-299.33-10.33L505.75,47.42l-22.05,129.41ZM208.31,514.94l-72.81-324.69,332.56,11.48-259.75,313.21ZM490.1,214.98l144.06,388.81-382.98-65.25-25.77-4.39L490.1,214.98ZM246.9,563.6l379.17,64.6-244.79,225.4-156.33-293.74,21.95,3.74ZM654.16,636.9l101.05,83.8-321.38,119.08,220.33-202.88ZM72.47,604.37l123.1-45.61,140.72,264.4-84.17-69.81-179.65-148.98Z"/></svg>';
+
+// src/modules/Dapp/modules/Window/components/menu/img/index.ts
+var XyoOSLogoWhite = xyoOS_Icon_White_default;
+
+// src/modules/Dapp/modules/Window/components/menu/SocialData.tsx
+import {
+  Facebook,
+  Instagram,
+  LinkedIn,
+  Reddit,
+  StorefrontRounded,
+  Telegram,
+  X,
+  YouTube
+} from "@mui/icons-material";
+import { FaDiscord } from "react-icons/fa";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var socialLinksData = [
+  {
+    icon: /* @__PURE__ */ jsx17(Facebook, { style: { fontSize: "24px" } }),
+    link: "https://www.facebook.com/OfficialXYO"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(X, { style: { fontSize: "24px" } }),
+    link: "https://twitter.com/OfficialXYO"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(Instagram, { style: { fontSize: "24px" } }),
+    link: "https://www.instagram.com/officialxyo/"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(Telegram, { style: { fontSize: "24px" } }),
+    link: "https://t.me/xyonetwork"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(Reddit, { style: { fontSize: "24px" } }),
+    link: "https://www.reddit.com/r/XYONetwork/"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(YouTube, { style: { fontSize: "24px" } }),
+    link: "https://www.youtube.com/channel/UCyZDqb9pgntVHJVt1pxXtsw"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(LinkedIn, { style: { fontSize: "24px" } }),
+    link: "https://www.linkedin.com/company/officialxyo/"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(FaDiscord, { style: { fontSize: "24px" } }),
+    link: "https://discord.gg/officialxyo"
+  },
+  {
+    icon: /* @__PURE__ */ jsx17(StorefrontRounded, { style: { fontSize: "24px" } }),
+    link: "https://shop.xyo.network"
+  }
+];
+
+// src/modules/Dapp/modules/Window/components/menu/BottomMenuArea.tsx
+import { jsx as jsx18, jsxs as jsxs9 } from "react/jsx-runtime";
+var BottomMenuArea = ({ openDebug, backgroundColor }) => {
+  const theme = useTheme5();
+  const [expanded, setExpanded] = useState14(false);
+  const handleExpandClick = () => {
+    setExpanded(!expanded);
+  };
+  return /* @__PURE__ */ jsxs9(
+    Card3,
+    {
+      sx: {
+        position: "relative",
+        borderTopLeftRadius: "10px",
+        borderTopRightRadius: "10px",
+        borderBottomLeftRadius: "0px",
+        borderBottomRightRadius: "0px",
+        backgroundColor,
+        overflow: "hidden"
+      },
+      elevation: 4,
+      children: [
+        /* @__PURE__ */ jsx18(FlexCol5, { sx: { paddingY: 1, alignItems: "stretch" }, children: /* @__PURE__ */ jsxs9(
+          Stack,
+          {
+            onClick: handleExpandClick,
+            sx: {
+              paddingX: 2,
+              justifyContent: "space-between",
+              flexDirection: "row",
+              gap: 0.5,
+              textTransform: "none",
+              cursor: "pointer"
+            },
+            children: [
+              /* @__PURE__ */ jsx18(Typography5, { gutterBottom: false, children: "More" }),
+              expanded ? /* @__PURE__ */ jsx18(KeyboardArrowUpRounded, { sx: { color: "#fff" } }) : /* @__PURE__ */ jsx18(KeyboardArrowDownRounded, { sx: { color: "#fff" } })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsxs9(Collapse, { in: expanded, timeout: "auto", unmountOnExit: true, sx: { paddingBottom: 3, color: "#fff" }, children: [
+          /* @__PURE__ */ jsx18(Divider3, { flexItem: true }),
+          /* @__PURE__ */ jsxs9(FlexCol5, { sx: { alignItems: "center" }, children: [
+            /* @__PURE__ */ jsxs9(Toolbar2, { sx: { paddingX: 1.5 }, children: [
+              /* @__PURE__ */ jsx18(Tooltip2, { title: "Debug Node View", children: /* @__PURE__ */ jsx18(IconButton2, { onClick: openDebug, sx: { color: "#fff" }, children: /* @__PURE__ */ jsx18(BugReport2, {}) }) }),
+              /* @__PURE__ */ jsx18(Tooltip2, { title: "Toggle Light/Dark Mode", children: /* @__PURE__ */ jsx18("span", { children: /* @__PURE__ */ jsx18(ColorSchemeButton2, {}) }) })
+            ] }),
+            /* @__PURE__ */ jsx18(FlexRow6, { sx: { flexWrap: "wrap" }, children: socialLinksData.map((social) => /* @__PURE__ */ jsx18(RotationAnimation, { rotation: 20, children: /* @__PURE__ */ jsx18(
+              IconButton2,
+              {
+                sx: { color: "#fff" },
+                href: social.link,
+                target: "_blank",
+                children: social.icon
+              }
+            ) }, social.link)) }),
+            /* @__PURE__ */ jsxs9(
+              FlexRow6,
+              {
+                sx: {
+                  padding: 1,
+                  justifyContent: "center",
+                  gap: 0.5
+                },
+                children: [
+                  /* @__PURE__ */ jsx18(Typography5, { variant: "body2", color: theme.vars?.palette.text.primary, children: "Powered By" }),
+                  /* @__PURE__ */ jsx18(
+                    "img",
+                    {
+                      style: { color: theme.vars?.palette.text.primary, fill: theme.vars?.palette.text.primary },
+                      src: XyoOSLogoWhite,
+                      width: "auto",
+                      height: "20px"
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx18(Typography5, { variant: "caption", color: theme.vars?.palette.text.primary, children: "Copyright \xA9 2024 XY Labs, Inc." }),
+            /* @__PURE__ */ jsxs9(Stack, { sx: { gap: 0.5, flexDirection: "row" }, children: [
+              /* @__PURE__ */ jsx18(LinkEx2, { color: "inherit", target: "_blank", href: "https://xylabs.com/privacy/", children: /* @__PURE__ */ jsx18(Typography5, { variant: "caption", children: "Privacy" }) }),
+              " ",
+              "\u2022",
+              " ",
+              /* @__PURE__ */ jsx18(LinkEx2, { color: "inherit", target: "_blank", href: "https://xylabs.com/terms/", children: /* @__PURE__ */ jsx18(Typography5, { variant: "caption", children: "Terms" }) }),
+              " ",
+              "\u2022",
+              " ",
+              /* @__PURE__ */ jsx18(LinkEx2, { color: "inherit", target: "_blank", href: "https://xyo.network/", children: /* @__PURE__ */ jsx18(Typography5, { variant: "caption", children: "XYO Website" }) })
+            ] })
+          ] })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/components/menu/StyledListItems.tsx
+import { ListItemButton, styled as styled3 } from "@mui/material";
+var StyledMenuIconWrapSpan = styled3("span", { name: "StyledMenuIconWrapSpan" })(() => ({
+  alignItems: "center",
+  display: "inline-flex",
+  flexDirection: "column"
+}));
+var StyledListItemButton = styled3(ListItemButton, { name: "StyledListItemButton", shouldForwardProp: (prop) => prop !== "active" })(({ theme, active }) => {
+  const activeOrHoverColor = theme.vars?.palette.primary.main;
+  return {
+    "position": "relative",
+    "padding": "8px 16px",
+    "borderRadius": "12px",
+    "transition": "background-color 0.3s ease",
+    "&:hover": {
+      backgroundColor: "transparent",
+      borderRadius: "12px"
+    },
+    "&::before": {
+      content: '""',
+      position: "absolute",
+      left: 0,
+      top: 0,
+      bottom: 0,
+      width: "6px",
+      backgroundColor: active ? activeOrHoverColor : "transparent",
+      borderRadius: "0 4px 4px 0",
+      transition: "background-color 0.3s ease"
+    }
+  };
+});
+
+// src/modules/Dapp/modules/Window/components/menu/Drawer.tsx
+import { jsx as jsx19, jsxs as jsxs10 } from "react/jsx-runtime";
+var DappMenuDrawer = ({
+  activePath,
+  context,
+  iconSvg,
+  name,
+  menuConfig,
+  menuItems,
+  onPathChange,
+  version,
+  ...props
+}) => {
+  const [path, setPath] = useState15("");
+  const darkMode = useIsDark2();
+  const theme = useTheme6();
+  const drawerColor = darkMode ? theme.vars?.palette.background.paper : darkenCss(theme.vars?.palette.primary.main ?? "#fff", 0.5);
+  const activeColor = theme.vars?.palette.primary.light;
+  useEffect15(() => {
+    if (menuConfig?.defaultPath && menuItems && activePath) {
+      const newPath = menuItems.find((item) => activePath === item.path)?.path ?? "";
+      const timeoutId = setTimeout(() => setPath(newPath), 0);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [activePath, menuConfig, menuItems]);
+  const handleChange = (to2) => {
+    XyOsMonitor3.trackEvent("Visit dApp Page", { Page: to2 });
+    setPath(to2);
+    onPathChange?.(to2);
+  };
+  const {
+    closeDebug,
+    debugOpen,
+    openDebug
+  } = useDebugClick();
+  return /* @__PURE__ */ jsx19(
+    Drawer,
+    {
+      variant: "permanent",
+      anchor: "left",
+      slotProps: {
+        paper: {
+          sx: {
+            position: "static",
+            backgroundColor: drawerColor,
+            borderRight: "none"
+          }
+        }
+      },
+      sx: { width: "280px" },
+      ...props,
+      children: /* @__PURE__ */ jsxs10(
+        FlexCol6,
+        {
+          sx: {
+            alignItems: "stretch",
+            justifyContent: "space-between",
+            height: "100dvh"
+          },
+          children: [
+            /* @__PURE__ */ jsxs10(
+              FlexCol6,
+              {
+                sx: {
+                  alignItems: "stretch",
+                  justifyContent: "flex-start",
+                  flexGrow: 1,
+                  overflow: "auto"
+                },
+                children: [
+                  /* @__PURE__ */ jsx19(Tooltip3, { title: version, children: /* @__PURE__ */ jsxs10(
+                    FlexGrowRow4,
+                    {
+                      id: "dapp-name-and-icon",
+                      sx: {
+                        padding: 2,
+                        justifyContent: "flex-start",
+                        gap: 1,
+                        cursor: "pointer",
+                        flexGrow: 0
+                      },
+                      children: [
+                        iconSvg ? RenderHtml({ htmlString: iconSvg }) : null,
+                        /* @__PURE__ */ jsx19(Typography6, { noWrap: true, variant: "h6", sx: { letterSpacing: "-1px" }, children: name })
+                      ]
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx19(DebugDialogWithNode, { closeDebug, debugOpen, context }),
+                  /* @__PURE__ */ jsx19(List, { sx: { p: 0, overflow: "auto" }, children: menuItems?.map(({
+                    svgIcon: icon,
+                    primaryText,
+                    path: pathFromPayload
+                  }) => /* @__PURE__ */ jsx19(
+                    ListItem,
+                    {
+                      disablePadding: true,
+                      sx: { paddingBottom: 1 },
+                      children: /* @__PURE__ */ jsx19(
+                        StyledListItemButton,
+                        {
+                          onClick: () => handleChange(pathFromPayload),
+                          active: pathFromPayload === path,
+                          disableRipple: true,
+                          disableTouchRipple: true,
+                          children: /* @__PURE__ */ jsxs10(
+                            FlexRow7,
+                            {
+                              sx: {
+                                "flexGrow": 1,
+                                "paddingX": 2,
+                                "paddingY": 0.5,
+                                "&:hover": { backgroundColor: alpha("#ffffff", 0.05) },
+                                "borderRadius": "10px"
+                              },
+                              children: [
+                                /* @__PURE__ */ jsx19(
+                                  ListItemIcon,
+                                  {
+                                    sx: { color: pathFromPayload === path ? activeColor : alpha("#fff", 0.3), justifyContent: "center" },
+                                    children: /* @__PURE__ */ jsx19(
+                                      StyledMenuIconWrapSpan,
+                                      {
+                                        ref: (ref) => {
+                                          if (ref !== null) {
+                                            ref.innerHTML = icon ?? "";
+                                          }
+                                        }
+                                      }
+                                    )
+                                  }
+                                ),
+                                /* @__PURE__ */ jsx19(
+                                  ListItemText,
+                                  {
+                                    slotProps: {
+                                      primary: {
+                                        sx: {
+                                          fontWeight: path === pathFromPayload ? "bold" : "inherit",
+                                          color: pathFromPayload === path ? "inherit" : alphaCss3(theme.vars?.palette.text.primary ?? "#000", 0.5)
+                                        }
+                                      }
+                                    },
+                                    primary: primaryText,
+                                    style: { opacity: pathFromPayload === path ? 1 : 0.5 }
+                                  }
+                                )
+                              ]
+                            }
+                          )
+                        }
+                      )
+                    },
+                    primaryText
+                  )) })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx19(BottomMenuArea, { openDebug, backgroundColor: theme.vars?.palette.primary.dark ?? "#000" })
+          ]
+        }
+      )
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/DappWindow.tsx
+import { Snackbar } from "@mui/material";
+import { ErrorBoundary, ErrorRender as ErrorRender3 } from "@xylabs/react-error";
+import { useMemo as useMemo13 } from "react";
+
+// src/modules/Dapp/modules/Window/MetaTags.tsx
+import { NameTransforms as NameTransforms4 } from "@xyo-network/os-runtime";
+import { jsxs as jsxs11 } from "react/jsx-runtime";
+var DappMetaTags = ({
+  active,
+  activePath,
+  dappName
+}) => {
+  return active ? /* @__PURE__ */ jsxs11("title", { children: [
+    activePath ? `${new NameTransforms4(activePath).deSlug()} | ` : "",
+    " ",
+    dappName,
+    " ",
+    "dApp"
+  ] }) : null;
+};
+
+// src/modules/Dapp/modules/Window/DappWindow.tsx
+import { jsx as jsx20, jsxs as jsxs12 } from "react/jsx-runtime";
+var DappWindow = ({
+  children,
+  context,
+  dapp,
+  dappMenuProperties,
+  dappState
+}) => {
+  const { name } = dapp?.config ?? {};
+  const { active } = dappState ?? {};
+  useSyncOsRegisteredAccessInterfaces(context);
+  const routingError = useManageDappPathFromRoute(context, name);
+  const injectableErrors = useManageDappInjectableParamsFromRoute(context);
+  const resolvedErrors = useMemo13(() => [...injectableErrors, routingError].filter(Boolean), [injectableErrors, routingError]);
+  return /* @__PURE__ */ jsxs12(ErrorBoundary, { children: [
+    /* @__PURE__ */ jsx20(DappMetaTags, { active, activePath: dappMenuProperties?.activePath, dappName: name }),
+    resolvedErrors.map((error) => /* @__PURE__ */ jsx20(
+      Snackbar,
+      {
+        open: !!error,
+        message: /* @__PURE__ */ jsx20(ErrorRender3, { error, scope: "DappWindow" })
+      },
+      error?.message
+    )),
+    children
+  ] });
+};
+
+// src/modules/Dapp/modules/Window/Rendered.tsx
+import { ErrorRender as ErrorRender4 } from "@xylabs/react-error";
+import { FlexCol as FlexCol9 } from "@xylabs/react-flexbox";
+import { NameTransforms as NameTransforms5 } from "@xyo-network/os-runtime";
+import { NodeProvider as NodeProvider2 } from "@xyo-network/react-node";
+import { WalletProvider } from "@xyo-network/react-wallet";
+import React12 from "react";
+
+// src/modules/Dapp/modules/Window/LoadingFlexbox.tsx
+import {
+  Fade,
+  styled as styled4,
+  Typography as Typography7
+} from "@mui/material";
+import { FlexCol as FlexCol8 } from "@xylabs/react-flexbox";
+import { useEffect as useEffect16, useState as useState17 } from "react";
+
+// src/modules/LoadingOsLogo/LoadingOsLogo.tsx
+import { FlexCol as FlexCol7 } from "@xylabs/react-flexbox";
+import { useState as useState16 } from "react";
+
+// src/modules/LoadingOsLogo/img/xyoOS-Icon.svg
+var xyoOS_Icon_default = '<?xml version="1.0" encoding="UTF-8"?><svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 900 900"><defs><style>.cls-1{fill:url(#linear-gradient);}.cls-1,.cls-2{stroke-width:0px;}.cls-2{fill:#a8a8a8;opacity:.21;}</style><linearGradient id="linear-gradient" x1="34.7" y1="450.98" x2="865.07" y2="450.98" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#579fd6"/><stop offset=".52" stop-color="#eb407a"/><stop offset="1" stop-color="#f27046"/></linearGradient></defs><path class="cls-2" d="M864.29,297.43c-2.44-6.58-9.76-9.94-16.34-7.5l-143.74,53.26L533.2,21.88c-1.85-3.48-5.21-5.9-9.09-6.56-3.89-.66-7.85.51-10.75,3.18l-267.76,246.55-118-97.86c-5.4-4.48-13.42-3.73-17.9,1.67-4.48,5.4-3.73,13.42,1.67,17.9l118,97.86L36.62,593.37c-2.09,3.34-2.5,7.46-1.14,11.15s4.37,6.54,8.13,7.72l347.4,108.61-25.75,151.12c-1.18,6.92,3.48,13.49,10.4,14.67.24.04.47.07.7.1,6.66.76,12.82-3.81,13.96-10.5l25.75-151.12,363.77,12.56c3.94.14,7.71-1.56,10.22-4.59,2.51-3.03,3.48-7.06,2.62-10.9l-79.64-355.16,143.75-53.26c6.58-2.44,9.94-9.75,7.5-16.34ZM518.49,48.34l156.33,293.75-401.12-68.35,244.79-225.4ZM674.37,367.8l-264.69,319.16-144.06-388.81,408.75,69.65ZM66.9,592.88l176.22-282.26,141.37,381.56-317.59-99.29ZM431.72,700.22l259.75-313.21,72.81,324.69-332.56-11.48Z"/><path class="cls-1" d="M865.04,302.64c.01-.2.02-.4.03-.6,0-.33,0-.66-.03-.99-.01-.2-.02-.39-.04-.58-.04-.35-.1-.71-.17-1.06-.03-.16-.05-.32-.09-.48-.12-.5-.26-1.01-.45-1.5-.18-.49-.4-.97-.64-1.43-.08-.15-.17-.29-.25-.43-.17-.31-.35-.61-.55-.9-.12-.17-.24-.33-.37-.49-.19-.25-.39-.5-.6-.74-.14-.16-.29-.32-.45-.47-.22-.22-.45-.44-.68-.65-.1-.08-.18-.18-.27-.26L530.1,18.07c-.34-.28-.7-.53-1.07-.77-.09-.06-.17-.13-.26-.19-.62-.39-1.26-.7-1.92-.98-.18-.07-.36-.14-.54-.21-.71-.26-1.43-.47-2.16-.6,0,0-.01,0-.02,0,0,0,0,0-.01,0-.67-.11-1.35-.15-2.03-.16-.37,0-.73,0-1.09.03-.23.02-.46.06-.7.09-.86.11-1.69.31-2.5.59-.07.03-.15.04-.23.07l-.32.12c-.2.08-.4.13-.59.22L115.08,165.06c-.11.04-.22.1-.33.15-.3.12-.59.25-.88.39-.19.1-.38.19-.57.3-.27.15-.54.32-.81.5-.17.12-.35.22-.52.35-.27.2-.53.42-.79.64-.14.12-.28.23-.41.35-.35.33-.68.68-1,1.05-.04.05-.08.1-.12.14-.32.38-.6.78-.87,1.2-.09.14-.16.29-.25.43-.18.31-.36.62-.51.94-.08.17-.15.35-.23.53-.13.31-.25.62-.36.93-.06.19-.12.38-.17.57-.09.33-.17.65-.23.98-.02.11-.06.22-.08.33l-72.09,423.12c-.07.43-.11.87-.13,1.3,0,.11-.03.22-.03.33-.03.73.02,1.44.12,2.16.02.19.06.38.09.57.13.74.31,1.48.57,2.19,0,0,0,0,0,0,0,.02.01.03.02.04.2.53.43,1.04.7,1.53.12.22.26.42.38.63.17.28.33.56.52.82.17.23.35.44.54.66.18.22.36.44.56.65.2.21.42.4.63.6.16.14.29.3.46.43l330.39,274c.08.07.17.12.25.18.32.25.65.49.99.71.15.09.29.19.44.28.44.26.9.5,1.37.7.04.02.08.04.12.06.51.21,1.03.39,1.56.53.17.05.35.08.53.12.24.06.47.12.71.16.23.04.46.07.69.1.47.05.95.08,1.42.08.15,0,.3-.02.45-.02.32-.01.65-.02.97-.06.18-.02.36-.06.54-.08.29-.04.58-.09.86-.15.19-.04.38-.1.56-.15.28-.08.55-.16.82-.25.08-.03.15-.04.23-.07l402.48-149.13s.06-.03.09-.04c.39-.15.76-.32,1.13-.51.12-.06.24-.1.35-.16.44-.24.88-.51,1.29-.8.03-.02.06-.04.09-.06.55-.39,1.07-.85,1.56-1.34.83-.82,1.54-1.76,2.11-2.78.09-.17.19-.33.27-.5.32-.64.61-1.3.82-2,.03-.11.05-.22.08-.33.12-.42.23-.84.3-1.27l72.09-423.12c.02-.11.02-.22.03-.33.05-.34.08-.67.1-1.01ZM771.44,701.13l-101.05-83.8,158.61-254.06-57.56,337.86ZM121.2,242.67l65.53,292.26-123.1,45.61,57.57-337.87ZM656.65,591.33l-141.37-381.56,317.59,99.3-176.22,282.26ZM508.76,181.1l22.05-129.41,263.81,218.79-285.86-89.37ZM483.7,176.83l-299.33-10.33L505.75,47.42l-22.05,129.41ZM208.31,514.94l-72.81-324.69,332.56,11.48-259.75,313.21ZM490.1,214.98l144.06,388.81-382.98-65.25-25.77-4.39L490.1,214.98ZM246.9,563.6l379.17,64.6-244.79,225.4-156.33-293.74,21.95,3.74ZM654.16,636.9l101.05,83.8-321.38,119.08,220.33-202.88ZM72.47,604.37l123.1-45.61,140.72,264.4-84.17-69.81-179.65-148.98Z"/></svg>';
+
+// src/modules/LoadingOsLogo/img/index.ts
+var XyoOSIcon = xyoOS_Icon_default;
+
+// src/modules/LoadingOsLogo/LoadingOsLogo.tsx
+import { jsx as jsx21 } from "react/jsx-runtime";
+var LoadingOsLogo = ({
+  widthInPixels,
+  busy,
+  spinsPerSecond = 0.5,
+  ...props
+}) => {
+  const [imageLoaded, setImageLoaded] = useState16(false);
+  if (!imageLoaded) {
+    const img = new Image();
+    img.addEventListener("load", () => setImageLoaded(true));
+    img.src = XyoOSIcon;
+  }
+  return imageLoaded ? /* @__PURE__ */ jsx21(
+    FlexCol7,
+    {
+      sx: {
+        "@keyframes fadeOut": {
+          "0%": { opacity: 1 },
+          "100%": { opacity: 0.1 },
+          "35%": { opacity: 1 }
+        },
+        "animation": busy ? "fadeOut linear" : void 0,
+        "animationDuration": "1500ms",
+        "animationFillMode": "both"
+      },
+      ...props,
+      children: /* @__PURE__ */ jsx21(
+        FlexCol7,
+        {
+          sx: {
+            "@keyframes spin": {
+              "0%": { transform: "rotate(360deg)" },
+              "100%": { transform: "rotate(0deg)" }
+            },
+            "animation": busy ? `spin ${1 / spinsPerSecond}s linear infinite` : void 0,
+            "animationDirection": "reverse"
+          },
+          ...props,
+          children: /* @__PURE__ */ jsx21("img", { src: XyoOSIcon, height: widthInPixels ?? 22 })
+        }
+      )
+    }
+  ) : null;
+};
+
+// src/modules/Dapp/modules/Window/Trail.tsx
+import { a, useTrail } from "@react-spring/web";
+import React10 from "react";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var TextTrail = ({ open, children }) => {
+  const items = React10.Children.toArray(children);
+  const trail = useTrail(items.length, {
+    config: {
+      friction: 200,
+      mass: 5,
+      tension: 2e3
+    },
+    from: {
+      height: "auto",
+      opacity: 0,
+      y: 20
+    },
+    height: "auto",
+    opacity: open ? 1 : 0,
+    y: open ? 0 : 60
+  });
+  return /* @__PURE__ */ jsx22("div", { children: trail.map(({ height, ...style }, index) => /* @__PURE__ */ jsx22(a.div, { style, children: /* @__PURE__ */ jsx22(a.div, { style: { height }, children: items[index] }) }, index)) });
+};
+
+// src/modules/Dapp/modules/Window/LoadingFlexbox.tsx
+import { jsx as jsx23, jsxs as jsxs13 } from "react/jsx-runtime";
+var DappLoadingFlexbox = ({
+  minimize,
+  open,
+  name,
+  ...props
+}) => {
+  const [fadeIn, setFadeIn] = useState17(!open);
+  const [trail, setTrail] = useState17(false);
+  const skipLoadingScreen = useSkipLoadingScreen();
+  useEffect16(() => {
+    if (open) {
+      if (skipLoadingScreen) {
+        const immediateTimeout = setTimeout(() => setFadeIn(false), 0);
+        return () => clearTimeout(immediateTimeout);
+      }
+      const fadeInTimeout = setTimeout(() => {
+        setFadeIn(false);
+      }, 2e3);
+      let trailTimeout = setTimeout(() => {
+        setTrail(true);
+        trailTimeout = setTimeout(() => {
+          setTrail(false);
+        }, 4e3);
+      }, 300);
+      return () => {
+        clearTimeout(fadeInTimeout);
+        clearTimeout(trailTimeout);
+      };
+    }
+    if (!minimize) {
+      const resetTimeout = setTimeout(() => setFadeIn(true), 0);
+      return () => clearTimeout(resetTimeout);
+    }
+  }, [minimize, open, skipLoadingScreen]);
+  return /* @__PURE__ */ jsx23(Fade, { in: fadeIn, unmountOnExit: true, children: /* @__PURE__ */ jsxs13(StyledSplashContainer, { ...props, children: [
+    /* @__PURE__ */ jsx23(LoadingOsLogo, { widthInPixels: 100, busy: true, sx: { position: "absolute" } }),
+    /* @__PURE__ */ jsxs13(TextTrail, { open: trail, sx: { flexDirection: "row" }, children: [
+      /* @__PURE__ */ jsx23(
+        Typography7,
+        {
+          sx: { textAlign: "center", fontSize: { md: "3em", xs: "2em" } },
+          children: "Loading"
+        }
+      ),
+      /* @__PURE__ */ jsx23(
+        Typography7,
+        {
+          sx: { textAlign: "center", fontSize: { md: "3em", xs: "2em" } },
+          children: name
+        }
+      ),
+      /* @__PURE__ */ jsx23(
+        Typography7,
+        {
+          sx: { textAlign: "center", fontSize: { md: "3em", xs: "2em" } },
+          children: "dApp"
+        }
+      )
+    ] })
+  ] }) });
+};
+var StyledSplashContainer = styled4(FlexCol8, { name: "StyledSplashContainer" })(({ theme }) => {
+  return {
+    background: theme.vars?.palette.background.default,
+    color: theme.vars?.palette.text.primary,
+    gap: theme.spacing(1),
+    height: "100%",
+    left: 0,
+    position: "absolute",
+    top: 0,
+    width: "100%",
+    zIndex: 999
+  };
+});
+
+// src/modules/Dapp/modules/Window/Rendered.tsx
+import { Fragment as Fragment2, jsx as jsx24, jsxs as jsxs14 } from "react/jsx-runtime";
+var DappRendered = ({
+  context,
+  dapp,
+  dappMenuProperties,
+  dappState,
+  dappWallet,
+  errors
+}) => {
+  const {
+    DappComponent: dappComponent,
+    name,
+    scrollable = true,
+    version
+  } = useDecomposeDapp(dapp);
+  const { active, minimized } = dappState ?? {};
+  const hasErrors = errors && errors.length > 0;
+  return /* @__PURE__ */ jsxs14(
+    DappChrome,
+    {
+      appBar: /* @__PURE__ */ jsx24(
+        DappBar,
+        {
+          context,
+          name,
+          version,
+          title: dappMenuProperties?.activePath ? new NameTransforms5(dappMenuProperties.activePath).deSlug() : ""
+        }
+      ),
+      sx: { height: "100dvh", width: "100dvw" },
+      largeScreenMenu: active && /* @__PURE__ */ jsx24(
+        DappMenuDrawer,
+        {
+          context,
+          name,
+          version,
+          ...dappMenuProperties
+        }
+      ),
+      smallScreenMenu: active && /* @__PURE__ */ jsx24(
+        DappBottomNavigation,
+        {
+          ...dappMenuProperties,
+          sx: { display: dappMenuProperties?.menuConfig ? "flex" : "none" }
+        }
+      ),
+      splashScreen: hasErrors ? null : /* @__PURE__ */ jsx24(DappLoadingFlexbox, { minimize: !!minimized, name, open: !!active }),
+      children: [
+        hasErrors ? /* @__PURE__ */ jsx24(FlexCol9, { sx: { padding: 2 }, children: errors?.map((error) => /* @__PURE__ */ jsx24(ErrorRender4, { error, scope: "DappWindow" }, error?.message)) }) : null,
+        /* @__PURE__ */ jsx24(WalletProvider, { rootWallet: dappWallet, children: context === null ? null : /* @__PURE__ */ jsx24(XyOsUiContextProvider, { value: context, children: /* @__PURE__ */ jsx24(NodeProvider2, { node: context?.root, children: active ? /* @__PURE__ */ jsxs14(Fragment2, { children: [
+          /* @__PURE__ */ jsx24(
+            FlexCol9,
+            {
+              sx: {
+                position: "absolute",
+                top: 0,
+                left: 0,
+                right: 0,
+                bottom: 0,
+                alignItems: "stretch",
+                justifyContent: "stretch",
+                overflowY: scrollable ? "auto" : "hidden"
+              },
+              children: React12.createElement(dappComponent, { name: dapp?.config.name })
+            }
+          ),
+          /* @__PURE__ */ jsx24(DappAccessFlexbox, { context })
+        ] }) : null }) }) })
+      ]
+    }
+  );
+};
+
+// src/modules/Dapp/Container.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+var DappContainer = ({
+  currentIntent,
+  dappSet,
+  xnsNodeUrl,
+  xnsNetwork
+}) => {
+  const { dapp, dappIcon } = dappSet;
+  const {
+    dappWallet,
+    context,
+    nodeCreateError
+  } = useDappContextCreator(xnsNodeUrl, xnsNetwork, dapp, currentIntent);
+  const dappState = useMemo14(() => {
+    if (currentIntent?.targetDappId === dapp.config.name) {
+      return deriveDappState(currentIntent);
+    }
+  }, [currentIntent, dapp]);
+  const { error: menuError, ...dappMenuProperties } = useDappMenu(context, dapp?.config.name);
+  const errors = useMemo14(() => [nodeCreateError, menuError].filter(Boolean), [nodeCreateError]);
+  const dappWindowProps = useMemo14(() => ({
+    context,
+    dapp,
+    dappMenuProperties,
+    dappState,
+    dappWallet,
+    errors
+  }), [context, dapp, dappMenuProperties, dappState, dappWallet, errors]);
+  return /* @__PURE__ */ jsx25(
+    DappIconButton,
+    {
+      dappIcon,
+      dappIconSvg: dapp.params.iconSvg,
+      dappName: dapp?.config.name,
+      dappState,
+      children: /* @__PURE__ */ jsx25(DappWindow, { ...dappWindowProps, children: /* @__PURE__ */ jsx25(
+        DappRendered,
+        {
+          ...dappWindowProps
+        }
+      ) })
+    }
+  );
+};
+var DappContainerMemo = memo(DappContainer);
+
+// src/modules/Dapp/ContainerFlexbox.tsx
+import { Container as Container2 } from "@mui/material";
+import { FlexCol as FlexCol10 } from "@xylabs/react-flexbox";
+import { jsx as jsx26 } from "react/jsx-runtime";
+var ContainerFlexbox = ({
+  children,
+  containerProps,
+  scrollable = true,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx26(
+    FlexCol10,
+    {
+      id: "container-flexbox",
+      sx: {
+        alignItems: "center",
+        justifyContent: "start",
+        width: "100%",
+        pt: 2,
+        gap: 2,
+        overflow: scrollable ? "auto" : "unset"
+      },
+      ...props,
+      children: /* @__PURE__ */ jsx26(Container2, { ...containerProps, children })
+    }
+  );
+};
+
+// src/modules/Dapp/Page/DappPage.tsx
+import { Container as Container3, Typography as Typography9 } from "@mui/material";
+import { ThrownErrorBoundary } from "@xylabs/react-error";
+import { FlexCol as FlexCol12 } from "@xylabs/react-flexbox";
+
+// src/modules/network/components/LoadingIndicator.tsx
+import { SignalCellularAltOutlined } from "@mui/icons-material";
+import { Tooltip as Tooltip4, useTheme as useTheme7 } from "@mui/material";
+import { useIsDark as useIsDark3 } from "@xylabs/react-theme";
+
+// src/modules/network/hooks/useOsNetwork.tsx
+import { OsPubSubNetworkReadyEvent } from "@xyo-network/os-runtime";
+import { useMemo as useMemo15 } from "react";
+
+// src/modules/network/hooks/lib/createNetworkState.ts
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+var defaultNetworkState = {
+  connected: false,
+  error: void 0,
+  networkReady: false
+};
+var createNetworkState = (stackReady) => {
+  const { ready, stack } = stackReady ?? {};
+  if (ready) {
+    const foundStack = assertEx8(stack, () => "stack said it was ready but no stack found");
+    return {
+      connected: true,
+      error: void 0,
+      networkReady: true,
+      stack: foundStack
+    };
+  } else {
+    return defaultNetworkState;
+  }
+};
+
+// src/modules/network/hooks/useOsNetwork.tsx
+var useOsNetwork = () => {
+  const context = useXyOsUiContext();
+  const stackReady = useStackReady(OsPubSubNetworkReadyEvent, "osPubSubNetworkStack", context);
+  const networkState = useMemo15(() => {
+    return createNetworkState(stackReady);
+  }, [context, stackReady]);
+  return networkState;
+};
+
+// src/modules/network/hooks/useXyoPublicNetwork.tsx
+import { OsXyoPublicNetworkReadyEvent } from "@xyo-network/os-runtime";
+import { useMemo as useMemo16 } from "react";
+var useXyoPublicNetwork = () => {
+  const context = useXyOsUiContext();
+  const stackReady = useStackReady(OsXyoPublicNetworkReadyEvent, "xyoPublicNetworkStack", context);
+  const networkState = useMemo16(() => {
+    return createNetworkState(stackReady);
+  }, [context, stackReady]);
+  return networkState;
+};
+
+// src/modules/network/components/StyledLoadingIndicator.tsx
+import { styled as styled5 } from "@mui/material";
+var StyledNetworkLoadingIndicator = styled5("div", { name: "StyledNetworkLoadingIndicator" })(({ theme }) => ({
+  "&": {
+    "--Loader-color": "#fff",
+    "--Loader-offset": theme.spacing(0.1667),
+    "--Loader-size": theme.spacing(1.5),
+    "--Loader-timing": "ease-in-out",
+    "alignItems": "center",
+    "display": "flex",
+    "justifyContent": "center",
+    "marginBottom": "calc(var(--Loader-size) / 2)",
+    "marginTop": "calc(var(--Loader-size) / 2)",
+    "minHeight": "var(--Loader-size)",
+    "minWidth": "var(--Loader-size)",
+    "position": "relative",
+    "width": "100%"
+  },
+  "&:after": {
+    animationName: "pulsB",
+    boxShadow: "0 0 0 0 var(--Loader-color)",
+    paddingBottom: "calc(100% - var(--Loader-offset) * 2)",
+    width: "calc(100% - var(--Loader-offset) * 2)"
+  },
+  "&:before": {
+    animationName: "pulsA",
+    boxShadow: "inset 0 0 0 var(--Loader-offset) var(--Loader-color)",
+    paddingBottom: "100%",
+    width: "100%"
+  },
+  "&:before, &:after": {
+    animationDuration: "1.8s",
+    animationIterationCount: "infinite",
+    animationTimingFunction: "var(--Loader-timing)",
+    borderRadius: "50%",
+    content: '""',
+    filter: "drop-shadow(0 0 var(--Loader-offset)/2.25 rgba(var(--Loader-color), 0.75))",
+    position: "absolute"
+  },
+  "@keyframes pulsA": {
+    "0%": { boxShadow: "inset 0 0 0 var(--Loader-offset) var(--Loader-color)" },
+    "50%, 100%": { boxShadow: "inset 0 0 0 0 var(--Loader-color)" }
+  },
+  "@keyframes pulsB": {
+    "0%, 50%": { boxShadow: "0 0 0 0 var(--Loader-color)" },
+    "100%": { boxShadow: "0 0 0 var(--Loader-offset) var(--Loader-color)" }
+  }
+}));
+
+// src/modules/network/components/LoadingIndicator.tsx
+import { jsx as jsx27 } from "react/jsx-runtime";
+var WaitingForNetwork = () => /* @__PURE__ */ jsx27(Tooltip4, { title: "Waiting for Network initialization", children: /* @__PURE__ */ jsx27(StyledNetworkLoadingIndicator, {}) });
+var NetworkLoadingIndicator = ({ highContrast }) => {
+  const darkMode = useIsDark3();
+  const theme = useTheme7();
+  const { networkReady } = useOsNetwork();
+  const highContrastSuccessColor = darkMode ? theme.vars?.palette.success.dark : theme.vars?.palette.success.main;
+  const successColor = highContrast ? highContrastSuccessColor : theme.vars?.palette.success.main;
+  const highContrastErrorColor = darkMode ? theme.vars?.palette.success.dark : theme.vars?.palette.error.main;
+  const errorColor = highContrast ? highContrastErrorColor : theme.vars?.palette.error.main;
+  if (!networkReady) {
+    return /* @__PURE__ */ jsx27(WaitingForNetwork, {});
+  }
+  const connectionReady = true;
+  return connectionReady ? /* @__PURE__ */ jsx27(Tooltip4, { title: "Connected to Network", children: /* @__PURE__ */ jsx27(SignalCellularAltOutlined, { sx: { color: successColor } }) }) : /* @__PURE__ */ jsx27(Tooltip4, { title: "Error Connecting to Network", children: /* @__PURE__ */ jsx27(SignalCellularAltOutlined, { sx: { color: errorColor } }) });
+};
+
+// src/modules/network/components/NetworkButton.tsx
+import { NotInterested } from "@mui/icons-material";
+import { Button as Button2 } from "@mui/material";
+import { Fragment as Fragment3, jsx as jsx28, jsxs as jsxs15 } from "react/jsx-runtime";
+var NetworkButton = ({
+  disabled,
+  startIcon,
+  ...props
+}) => {
+  const { networkReady } = useOsNetwork();
+  return /* @__PURE__ */ jsx28(
+    Button2,
+    {
+      disabled: disabled === true || !networkReady,
+      startIcon: /* @__PURE__ */ jsxs15(Fragment3, { children: [
+        startIcon,
+        networkReady === false ? /* @__PURE__ */ jsx28(NotInterested, {}) : null
+      ] }),
+      ...props
+    }
+  );
+};
+
+// src/modules/network/components/NetworkReady.tsx
+import { Typography as Typography8 } from "@mui/material";
+import { FlexCol as FlexCol11 } from "@xylabs/react-flexbox";
+import { Fragment as Fragment4, jsx as jsx29, jsxs as jsxs16 } from "react/jsx-runtime";
+var NetworkReadyFlexBox = ({
+  children,
+  skipCheck,
+  ...props
+}) => {
+  const { networkReady } = useOsNetwork();
+  return /* @__PURE__ */ jsx29(Fragment4, { children: networkReady || skipCheck ? children : /* @__PURE__ */ jsxs16(FlexCol11, { sx: { height: "100%" }, ...props, children: [
+    /* @__PURE__ */ jsx29(LoadingOsLogo, { widthInPixels: 100, busy: true }),
+    /* @__PURE__ */ jsx29(Typography8, { sx: { fontFamily: "monospace" }, children: "Loading XYO Name Service..." })
+  ] }) });
+};
+
+// src/modules/Dapp/Page/DappPage.tsx
+import { jsx as jsx30, jsxs as jsxs17 } from "react/jsx-runtime";
+var DappTitle = ({
+  subtitle,
+  title,
+  ...props
+}) => {
+  return title ? /* @__PURE__ */ jsxs17(FlexCol12, { sx: { alignItems: "flex-start", gap: 1 }, ...props, children: [
+    /* @__PURE__ */ jsx30(Typography9, { variant: "h3", children: /* @__PURE__ */ jsx30("b", { children: title }) }),
+    /* @__PURE__ */ jsx30(Typography9, { gutterBottom: true, variant: "subtitle2", children: subtitle })
+  ] }) : null;
+};
+var InnerDappPage = ({
+  noScroll,
+  children,
+  subtitle,
+  title,
+  sx,
+  titleProps,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs17(
+    FlexCol12,
+    {
+      id: "innerPage",
+      sx: {
+        margin: 2,
+        gap: noScroll ? 0 : 2,
+        alignItems: "stretch",
+        justifyContent: "flex-start",
+        ...sx
+      },
+      ...props,
+      children: [
+        title ? /* @__PURE__ */ jsx30(DappTitle, { subtitle, title, ...titleProps }) : null,
+        children
+      ]
+    }
+  );
+};
+var DappPage = ({
+  checkNetwork,
+  noScroll,
+  subtitle,
+  title,
+  container,
+  rollbar,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx30(
+    ThrownErrorBoundary,
+    {
+      errorComponent: (error, boundaryName) => /* @__PURE__ */ jsx30(ErrorRenderWithSupportDefault, { scope: boundaryName, error }),
+      rollbar,
+      scope: "DappPage",
+      children: /* @__PURE__ */ jsx30(NetworkReadyFlexBox, { skipCheck: !checkNetwork, children: container ? /* @__PURE__ */ jsx30(Container3, { disableGutters: true, maxWidth: container === true ? "md" : container, children: noScroll ? /* @__PURE__ */ jsx30(
+        FlexCol12,
+        {
+          sx: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+          },
+          children: /* @__PURE__ */ jsx30(InnerDappPage, { noScroll, title, subtitle, ...props, sx: { flexGrow: 1 } })
+        }
+      ) : /* @__PURE__ */ jsx30(
+        FlexCol12,
+        {
+          sx: {
+            width: "100%",
+            height: "100%",
+            alignItems: "stretch"
+          },
+          children: /* @__PURE__ */ jsx30(InnerDappPage, { noScroll, title, subtitle, ...props, sx: { flexGrow: 1 } })
+        }
+      ) }) : noScroll ? /* @__PURE__ */ jsx30(
+        InnerDappPage,
+        {
+          sx: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            flexGrow: 1
+          },
+          noScroll,
+          title,
+          subtitle,
+          ...props
+        }
+      ) : /* @__PURE__ */ jsx30(InnerDappPage, { noScroll, title, subtitle, ...props, sx: { flexGrow: 1 } }) })
+    }
+  );
+};
+
+// src/modules/Dapp/Page/DappPathSwitcher.tsx
+import { animated as animated2, useTransition } from "@react-spring/web";
+import { ErrorRender as ErrorRender5 } from "@xylabs/react-error";
+import { Fragment as Fragment5, jsx as jsx31 } from "react/jsx-runtime";
+var resolveActiveComponent = (activePathRef, pathToComponent) => {
+  const activeIndex = pathToComponent?.findIndex(({ path: componentPath }) => activePathRef === componentPath);
+  const activeItem = pathToComponent && activeIndex !== -1 && activeIndex !== void 0 ? pathToComponent[activeIndex] : void 0;
+  return activeItem ? activeItem.component : /* @__PURE__ */ jsx31(ErrorRender5, { error: new Error(`No component found for path: ${activePathRef}`), scope: "DappPathSwitcher" });
+};
+var DappPathSwitcher = ({ activePath, pathToComponent }) => {
+  const transitions = useTransition(activePath, {
+    enter: { opacity: 1, transform: "translate3d(0, 0, 0)" },
+    from: { opacity: 0, transform: "translate3d(100vw, 0, 0)" },
+    leave: { opacity: 0, transform: "translate3d(0, 0, 0)" }
+  });
+  const possibleZIndex = pathToComponent?.findIndex((item) => item.path === activePath);
+  const zIndex = possibleZIndex !== -1 && possibleZIndex !== void 0 ? possibleZIndex : 1;
+  return /* @__PURE__ */ jsx31(Fragment5, { children: transitions((transitionProps, activePathRef) => /* @__PURE__ */ jsx31(
+    animated2.div,
+    {
+      style: {
+        ...transitionProps,
+        alignItems: "stretch",
+        bottom: 0,
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "stretch",
+        left: 0,
+        overflowX: "hidden",
+        overflowY: "auto",
+        position: "absolute",
+        right: 0,
+        top: 0,
+        zIndex
+      },
+      children: resolveActiveComponent(activePathRef, pathToComponent)
+    }
+  )) });
+};
+
+// src/modules/Dapp/Page/Row.tsx
+import {
+  Divider as Divider4,
+  Fade as Fade2,
+  styled as styled6
+} from "@mui/material";
+import { useMemo as useMemo17 } from "react";
+
+// src/modules/Dapp/Page/DividerChip.tsx
+import { Chip as Chip2, CircularProgress } from "@mui/material";
+import { jsx as jsx32 } from "react/jsx-runtime";
+var DividerChip = ({ registeredDapps, ...props }) => {
+  return /* @__PURE__ */ jsx32(
+    Chip2,
+    {
+      avatar: registeredDapps === void 0 ? /* @__PURE__ */ jsx32("span", { children: /* @__PURE__ */ jsx32(
+        CircularProgress,
+        {
+          size: "small",
+          sx: { display: "inline" }
+        }
+      ) }) : void 0,
+      label: `${registeredDapps?.length ? "" : "Loading "}Beta dApps`,
+      size: "small",
+      sx: { gap: 0.5 },
+      ...props
+    }
+  );
+};
+
+// src/modules/Dapp/Page/Row.tsx
+import { Fragment as Fragment6, jsx as jsx33, jsxs as jsxs18 } from "react/jsx-runtime";
+var DappsRow = ({
+  chipLabel,
+  currentIntent,
+  installType,
+  registeredDappsSet,
+  xnsNetwork,
+  xnsNodeUrl
+}) => {
+  const filteredRegisteredDappSets = useMemo17(() => DappInstallTypeFilters[installType](registeredDappsSet), [installType, registeredDappsSet]);
+  return /* @__PURE__ */ jsxs18(Fragment6, { children: [
+    /* @__PURE__ */ jsx33(
+      Divider4,
+      {
+        variant: "middle",
+        sx: { marginY: 3 },
+        flexItem: true,
+        children: /* @__PURE__ */ jsx33(
+          DividerChip,
+          {
+            label: `${filteredRegisteredDappSets === void 0 ? "Loading " : ""}${chipLabel}`,
+            registeredDapps: filteredRegisteredDappSets
+          }
+        )
+      }
+    ),
+    filteredRegisteredDappSets?.length ? /* @__PURE__ */ jsx33(Fade2, { in: !!filteredRegisteredDappSets?.length, timeout: 1e3, children: /* @__PURE__ */ jsx33(StyledGridContainer, { children: filteredRegisteredDappSets?.map(
+      (dappSet) => /* @__PURE__ */ jsx33(
+        DappContainerMemo,
+        {
+          currentIntent,
+          dappSet,
+          xnsNodeUrl,
+          xnsNetwork
+        },
+        dappSet.dapp.config.name
+      )
+    ) }) }) : null
+  ] });
+};
+var StyledGridContainer = styled6("div", { name: "StyledGridContainer" })(({ theme }) => ({
+  display: "grid",
+  gridGap: theme.spacing(2),
+  gridTemplateColumns: `repeat(auto-fit, ${theme.spacing(8)})`,
+  justifyContent: "center",
+  justifyItems: "center",
+  paddingTop: theme.spacing(1),
+  width: "100%"
+}));
+
+// src/modules/dapps/accounts/components/AnimatedComponents/GenericAnimations/ShiftAnimation.tsx
+import { animated as animated3, useSpring as useSpring2 } from "@react-spring/web";
+import { useEffect as useEffect17, useState as useState18 } from "react";
+import { jsx as jsx34 } from "react/jsx-runtime";
+var MovementData = {
+  down: [
+    {
+      FromYMovement: 0,
+      ToYMovement: -3
+    },
+    {
+      FromYMovement: -3,
+      ToYMovement: 0
+    }
+  ],
+  jump: [
+    {
+      FromYMovement: 0,
+      ToYMovement: -3
+    },
+    {
+      FromYMovement: -3,
+      ToYMovement: 0
+    }
+  ],
+  left: [
+    {
+      FromXMovement: 0,
+      ToXMovement: -3
+    },
+    {
+      FromXMovement: -3,
+      ToXMovement: 0
+    }
+  ],
+  right: [
+    {
+      FromXMovement: 0,
+      ToXMovement: -3
+    },
+    {
+      FromXMovement: -3,
+      ToXMovement: 0
+    }
+  ],
+  up: [
+    {
+      FromYMovement: 0,
+      ToYMovement: -3
+    },
+    {
+      FromYMovement: -3,
+      ToYMovement: 0
+    }
+  ],
+  wiggle: [
+    {
+      FromXMovement: 0,
+      ToXMovement: -3
+    },
+    {
+      FromXMovement: -3,
+      ToXMovement: 0
+    }
+  ]
+};
+var ShiftAnimation = ({
+  startAnimation = false,
+  animationDirection,
+  children
+}) => {
+  const [isShifted, setIsShifted] = useState18(startAnimation);
+  const anim = useSpring2({
+    backfaceVisibility: "hidden",
+    config: {
+      friction: 10,
+      tension: 300
+    },
+    from: {
+      x: startAnimation ? MovementData[animationDirection][1].FromXMovement : 0,
+      y: startAnimation ? MovementData[animationDirection][1].FromYMovement : 0
+    },
+    reset: true,
+    to: {
+      x: startAnimation ? MovementData[animationDirection][0].FromXMovement : 0,
+      y: startAnimation ? MovementData[animationDirection][0].FromYMovement : 0
+    }
+  });
+  useEffect17(() => {
+    if (!isShifted) {
+      return;
+    }
+    const timeoutId = globalThis.setTimeout(() => {
+      setIsShifted(false);
+    }, 5);
+    return () => {
+      globalThis.clearTimeout(timeoutId);
+    };
+  }, [isShifted]);
+  return /* @__PURE__ */ jsx34(animated3.div, { style: anim, children });
+};
+
+// src/modules/dapps/accounts/components/AnimatedComponents/IconAnimations/TwoToneBulletPoint.tsx
+import { FiberManualRecordRounded } from "@mui/icons-material";
+import { Box as Box2, useTheme as useTheme8 } from "@mui/material";
+import { alphaCss as alphaCss4 } from "@xylabs/react-theme";
+import { jsx as jsx35 } from "react/jsx-runtime";
+var TwoToneBulletPoint = (props) => {
+  const theme = useTheme8();
+  return /* @__PURE__ */ jsx35(Box2, { ...props, children: /* @__PURE__ */ jsx35(
+    FiberManualRecordRounded,
+    {
+      fontSize: "small",
+      sx: {
+        "&:hover": { padding: 0.2 },
+        "backgroundColor": alphaCss4(theme.vars?.palette.secondary.main ?? "#000", 0.2),
+        "borderRadius": 2,
+        "padding": 0.4
+      },
+      color: "primary"
+    }
+  ) });
+};
+
+// src/modules/dapps/accounts/components/AnimatedComponents/IconAnimations/TwoToneBulletPointList.tsx
+import { FlexCol as FlexCol13, FlexGrowRow as FlexGrowRow5 } from "@xylabs/react-flexbox";
+import { jsx as jsx36, jsxs as jsxs19 } from "react/jsx-runtime";
+var TwoToneBulletPointList = ({ list }) => {
+  return /* @__PURE__ */ jsx36(FlexCol13, { sx: { alignItems: "flex-start", gap: 1 }, children: list.map((item, index) => {
+    return /* @__PURE__ */ jsxs19(
+      FlexGrowRow5,
+      {
+        sx: {
+          alignItems: "flex-start",
+          justifyContent: "flex-start",
+          gap: 1
+        },
+        children: [
+          /* @__PURE__ */ jsx36(TwoToneBulletPoint, { sx: { marginTop: "4px" } }),
+          item
+        ]
+      },
+      index + "bulletPointList"
+    );
+  }) });
+};
+
+// src/modules/dapps/accounts/components/InputFields/CoinbaseEmail.tsx
+import { FormControl, TextField } from "@mui/material";
+import { LabeledTextFieldWrapper } from "@xyo-network/react-shared";
+import { useState as useState19 } from "react";
+import { jsx as jsx37 } from "react/jsx-runtime";
+var CoinbaseEmailInput = ({ existingEmail, ...props }) => {
+  const [email, setEmail] = useState19(existingEmail);
+  const [valid, setValid] = useState19();
+  const handleBlur = (event) => {
+    setValid(!!event.target.value);
+  };
+  const handleChange = (event) => {
+    const emailFromEvent = event.target.value;
+    setValid(!!emailFromEvent);
+    setEmail(emailFromEvent);
+  };
+  return /* @__PURE__ */ jsx37(FormControl, { fullWidth: true, children: /* @__PURE__ */ jsx37(LabeledTextFieldWrapper, { label: "Primary Cryptowallet", children: /* @__PURE__ */ jsx37(
+    TextField,
+    {
+      fullWidth: true,
+      variant: "filled",
+      error: valid === false,
+      hiddenLabel: true,
+      onBlur: handleBlur,
+      value: email,
+      onChange: handleChange,
+      size: "small",
+      ...props
+    }
+  ) }) });
+};
+
+// src/modules/dapps/accounts/components/InputFields/PrimaryCryptowallet.tsx
+import { FormControl as FormControl2, TextField as TextField2 } from "@mui/material";
+import { LabeledTextFieldWrapper as LabeledTextFieldWrapper2 } from "@xyo-network/react-shared";
+import { useState as useState20 } from "react";
+import { jsx as jsx38 } from "react/jsx-runtime";
+var PrimaryCryptoWalletInput = ({ existingPrimaryCryptoWallet, ...props }) => {
+  const [primaryWallet, setPrimaryWallet] = useState20(existingPrimaryCryptoWallet);
+  const [valid, setValid] = useState20();
+  const handleBlur = (event) => {
+    setValid(!!event.target.value);
+  };
+  const handleChange = (event) => {
+    const nameFromEvent = event.target.value;
+    setValid(!!nameFromEvent);
+    setPrimaryWallet(nameFromEvent);
+  };
+  return /* @__PURE__ */ jsx38(FormControl2, { fullWidth: true, children: /* @__PURE__ */ jsx38(LabeledTextFieldWrapper2, { label: "Primary Cryptowallet", children: /* @__PURE__ */ jsx38(
+    TextField2,
+    {
+      fullWidth: true,
+      variant: "filled",
+      error: valid === false,
+      hiddenLabel: true,
+      onBlur: handleBlur,
+      value: primaryWallet,
+      onChange: handleChange,
+      size: "small",
+      required: true,
+      ...props
+    }
+  ) }) });
+};
+
+// src/modules/dapps/accounts/components/InputFields/SecondaryCryptowallet.tsx
+import { FormControl as FormControl3, TextField as TextField3 } from "@mui/material";
+import { LabeledTextFieldWrapper as LabeledTextFieldWrapper3 } from "@xyo-network/react-shared";
+import { useState as useState21 } from "react";
+import { jsx as jsx39 } from "react/jsx-runtime";
+var SecondaryCryptoWalletInput = ({ existingSecondaryCryptoWallet, ...props }) => {
+  const [secondaryWallet, setSecondaryWallet] = useState21(existingSecondaryCryptoWallet);
+  const [valid, setValid] = useState21();
+  const handleBlur = (event) => {
+    setValid(!!event.target.value);
+  };
+  const handleChange = (event) => {
+    const walletFromEvent = event.target.value;
+    setValid(!!walletFromEvent);
+    setSecondaryWallet(walletFromEvent);
+  };
+  return /* @__PURE__ */ jsx39(FormControl3, { fullWidth: true, children: /* @__PURE__ */ jsx39(LabeledTextFieldWrapper3, { label: "Secondary Cryptowallet", children: /* @__PURE__ */ jsx39(
+    TextField3,
+    {
+      variant: "filled",
+      fullWidth: true,
+      error: valid === false,
+      hiddenLabel: true,
+      onBlur: handleBlur,
+      value: secondaryWallet,
+      onChange: handleChange,
+      size: "small",
+      required: true,
+      ...props
+    }
+  ) }) });
+};
+
+// src/modules/dapps/accounts/components/PaymentMethods.tsx
+import { Grid } from "@mui/material";
+import { FormGroupCreditCardProvider } from "@xyo-network/react-form-credit-card";
+
+// src/modules/dapps/accounts/components/AccountCard.tsx
+import {
+  Card as Card4,
+  CardContent as CardContent3,
+  Divider as Divider5,
+  Typography as Typography10
+} from "@mui/material";
+import { FlexGrowCol as FlexGrowCol4, FlexGrowRow as FlexGrowRow6 } from "@xylabs/react-flexbox";
+import { jsx as jsx40, jsxs as jsxs20 } from "react/jsx-runtime";
+var AccountCard = ({ items, ...props }) => {
+  return /* @__PURE__ */ jsx40(Card4, { ...props, children: /* @__PURE__ */ jsx40(CardContent3, { children: /* @__PURE__ */ jsx40(FlexGrowCol4, { sx: { width: "100%", gap: 2 }, children: items.map((item, index) => {
+    return /* @__PURE__ */ jsxs20(
+      FlexGrowCol4,
+      {
+        sx: {
+          gap: 2,
+          width: "100%",
+          alignItems: "stretch"
+        },
+        children: [
+          /* @__PURE__ */ jsxs20(
+            FlexGrowRow6,
+            {
+              sx: {
+                alignItems: "stretch",
+                flexDirection: { md: "row", xs: "column" },
+                justifyContent: "space-between",
+                gap: 2
+              },
+              children: [
+                /* @__PURE__ */ jsxs20(
+                  FlexGrowCol4,
+                  {
+                    sx: {
+                      alignItems: "flex-start",
+                      width: "100%",
+                      maxWidth: { md: "40%", xs: "100%" }
+                    },
+                    children: [
+                      /* @__PURE__ */ jsx40(Typography10, { variant: "h5", gutterBottom: true, children: item.title }),
+                      /* @__PURE__ */ jsx40(Typography10, { variant: "body1", gutterBottom: true, children: item.desc })
+                    ]
+                  }
+                ),
+                item?.component
+              ]
+            }
+          ),
+          items.length === 1 || index === items.length - 1 ? null : /* @__PURE__ */ jsx40(Divider5, { flexItem: true })
+        ]
+      },
+      index
+    );
+  }) }) }) });
+};
+
+// src/modules/dapps/accounts/components/PaymentMethods.tsx
+import { jsx as jsx41 } from "react/jsx-runtime";
+var PaymentMethods = () => {
+  return /* @__PURE__ */ jsx41(DappPage, { title: "Payment Methods", children: /* @__PURE__ */ jsx41(Grid, { container: true, spacing: 3, children: /* @__PURE__ */ jsx41(Grid, { size: { xs: 12 }, children: /* @__PURE__ */ jsx41(
+    AccountCard,
+    {
+      sx: { height: "100%" },
+      items: [
+        {
+          // TODO - needs a default implementation
+          component: /* @__PURE__ */ jsx41(FormGroupCreditCardProvider, { children: "null" }),
+          desc: "Save a credit card to your node to complete credit payments seamlessly.",
+          title: "Credit Card"
+        },
+        {
+          component: /* @__PURE__ */ jsx41(CoinbaseEmailInput, {}),
+          desc: "Use your Coinbase Account receive payments easily.",
+          title: "Coinbase Email"
+        },
+        {
+          component: /* @__PURE__ */ jsx41(PrimaryCryptoWalletInput, {}),
+          desc: "This is the primary crypto wallet on your node.",
+          title: "Primary Crypto Wallet"
+        },
+        {
+          component: /* @__PURE__ */ jsx41(SecondaryCryptoWalletInput, {}),
+          desc: "This is the secondary crypto wallet on your node.",
+          title: "Secondary Crypto Wallet"
+        }
+      ]
+    }
+  ) }) }) });
+};
+
+// src/modules/dapps/accounts/hooks/useAccountArchivist.ts
+import { useWeakArchivistFromNode as useWeakArchivistFromNode5 } from "@xyo-network/react-archivist";
+var useAccountArchivist = () => {
+  return useWeakArchivistFromNode5("AccountArchivist");
+};
+
+// src/modules/dapps/accounts/models/CreditCardInput.ts
+import { asSchema as asSchema2, isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var CreditCardInputSchema = asSchema2("network.xyo.credit.card.input", true);
+var isCreditCardInput = isPayloadOfSchemaType(CreditCardInputSchema);
+
+// src/modules/dapps/name-service/DomainIcon.tsx
+import { createSvgIcon } from "@mui/material";
+import { jsx as jsx42, jsxs as jsxs21 } from "react/jsx-runtime";
+var XnsDomainIcon = createSvgIcon(
+  /* @__PURE__ */ jsxs21("svg", { id: "Layer_1", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 400 400", children: [
+    /* @__PURE__ */ jsx42("path", { fill: "currentColor", d: "M0,314.34V85.34h43.89l99.55,152.67V85.34h43.89v229h-43.89L43.89,161.68v152.67H0Z" }),
+    /* @__PURE__ */ jsx42("path", { fill: "currentColor", d: "M298.99,319.12c-16.96,0-32.26-3-45.88-8.99-13.62-5.99-24.81-14.58-33.56-25.76-8.75-11.18-14.29-24.52-16.62-40l45.17-6.68c3.18,13.15,9.75,23.27,19.72,30.37,9.96,7.1,21.31,10.65,34.03,10.65,7.1,0,14-1.11,20.67-3.34,6.68-2.23,12.17-5.51,16.46-9.86,4.29-4.35,6.44-9.7,6.44-16.06,0-2.33-.35-4.59-1.03-6.76-.69-2.17-1.83-4.21-3.42-6.12-1.59-1.91-3.84-3.71-6.76-5.41-2.92-1.69-6.6-3.23-11.05-4.61l-59.48-17.49c-4.45-1.27-9.62-3.07-15.5-5.41-5.88-2.33-11.58-5.67-17.1-10.02-5.51-4.35-10.1-10.1-13.76-17.26-3.66-7.16-5.49-16.19-5.49-27.11,0-15.37,3.87-28.15,11.61-38.33,7.74-10.18,18.08-17.76,31.01-22.74,12.93-4.98,27.25-7.42,42.94-7.32,15.8.21,29.9,2.92,42.3,8.11,12.4,5.2,22.79,12.75,31.17,22.66,8.37,9.92,14.42,22.03,18.13,36.34l-46.76,7.95c-1.7-7.42-4.83-13.68-9.38-18.77-4.56-5.09-9.99-8.96-16.3-11.61-6.31-2.65-12.91-4.08-19.8-4.29-6.79-.21-13.17.72-19.16,2.78-5.99,2.07-10.87,5.06-14.63,8.99-3.76,3.92-5.65,8.59-5.65,14,0,4.98,1.54,9.04,4.61,12.17,3.07,3.13,6.94,5.65,11.61,7.55,4.66,1.91,9.44,3.5,14.31,4.77l39.76,10.81c5.94,1.59,12.51,3.68,19.72,6.28,7.21,2.6,14.13,6.2,20.75,10.81,6.62,4.61,12.09,10.68,16.38,18.21,4.29,7.53,6.44,17.07,6.44,28.63,0,12.3-2.57,23.03-7.71,32.2-5.14,9.17-12.06,16.75-20.75,22.74-8.69,5.99-18.53,10.47-29.5,13.44-10.97,2.97-22.29,4.45-33.95,4.45Z" }),
+    /* @__PURE__ */ jsx42("circle", { fill: "#3898e7", cx: "372.52", cy: "291.63", r: "27.48" })
+  ] }),
+  "XNSDomain"
+);
+
+// src/modules/dapps/table/head/components/Head.tsx
+import { InfoOutlined } from "@mui/icons-material";
+import {
+  TableCell,
+  TableHead,
+  Tooltip as Tooltip5
+} from "@mui/material";
+
+// src/modules/dapps/table/head/hooks/useVisibleColumns.tsx
+import { useMediaQuery as useMediaQuery2 } from "@mui/material";
+import { useMemo as useMemo18 } from "react";
+var useVisibleColumns = (tableHeadCells) => {
+  const isMedium = useMediaQuery2((theme) => theme.breakpoints.down("lg"));
+  const VisibleTableCells = useMemo18(() => {
+    return isMedium ? tableHeadCells.filter((cell) => cell.showOnMobile) : tableHeadCells;
+  }, [isMedium, tableHeadCells]);
+  return [VisibleTableCells, isMedium];
+};
+
+// src/modules/dapps/table/head/components/StyledTableRowHeader.tsx
+import { styled as styled7, TableRow } from "@mui/material";
+var StyledTableRowHeader = styled7(
+  TableRow,
+  { name: "StyledTableRowHeader" }
+)(({ theme }) => ({ "& .MuiTableCell-root": { backgroundColor: theme.vars?.palette.background.paper } }));
+
+// src/modules/dapps/table/head/components/Head.tsx
+import { jsx as jsx43, jsxs as jsxs22 } from "react/jsx-runtime";
+var TableHeadEx = ({ payloads, ...props }) => {
+  const [VisibleTableCells] = useVisibleColumns(payloads);
+  return /* @__PURE__ */ jsx43(TableHead, { ...props, children: /* @__PURE__ */ jsx43(StyledTableRowHeader, { children: VisibleTableCells.map((headCell) => /* @__PURE__ */ jsx43(
+    TableCell,
+    {
+      align: headCell.align ?? "left",
+      padding: headCell.disablePadding ? "none" : "normal",
+      width: headCell.width ?? "auto",
+      children: headCell.tooltip ? /* @__PURE__ */ jsxs22(
+        "span",
+        {
+          style: {
+            alignItems: "center",
+            display: "inline-flex",
+            gap: "4px"
+          },
+          children: [
+            headCell.label,
+            /* @__PURE__ */ jsx43(Tooltip5, { title: headCell.tooltip, children: /* @__PURE__ */ jsx43(InfoOutlined, { sx: { fontSize: "16px" } }) })
+          ]
+        }
+      ) : headCell.label
+    },
+    headCell.id
+  )) }) });
+};
+
+// src/modules/dapps/table/head/Payload.ts
+import { isPayloadOfSchemaType as isPayloadOfSchemaType2 } from "@xyo-network/payload-model";
+
+// src/modules/dapps/table/head/Schema.ts
+import { asSchema as asSchema3 } from "@xyo-network/payload-model";
+var TableHeadCellSchema = asSchema3("network.xyo.table.cell.head", true);
+
+// src/modules/dapps/table/head/Payload.ts
+var isTableHeadCell = isPayloadOfSchemaType2(TableHeadCellSchema);
+
+// src/modules/dapps/table/NextIteratorFlexbox.tsx
+import { ArrowCircleLeftOutlined, ArrowCircleRightOutlined } from "@mui/icons-material";
+import { IconButton as IconButton3, LinearProgress } from "@mui/material";
+import { FlexRow as FlexRow8 } from "@xylabs/react-flexbox";
+import { jsx as jsx44, jsxs as jsxs23 } from "react/jsx-runtime";
+var NextIteratorFlexbox = ({
+  next: changePage,
+  loading,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs23(FlexRow8, { sx: { justifyContent: "space-between", gap: 2 }, ...props, children: [
+    /* @__PURE__ */ jsx44(
+      LinearProgress,
+      {
+        sx: {
+          display: "flex",
+          flexGrow: 1,
+          visibility: loading ? "visible" : "hidden"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs23(FlexRow8, { children: [
+      /* @__PURE__ */ jsx44(IconButton3, { onClick: () => changePage("asc"), children: /* @__PURE__ */ jsx44(ArrowCircleLeftOutlined, {}) }),
+      /* @__PURE__ */ jsx44(IconButton3, { onClick: () => changePage("desc"), children: /* @__PURE__ */ jsx44(ArrowCircleRightOutlined, {}) })
+    ] })
+  ] });
+};
+
+// src/modules/widgets/WidgetCard.tsx
+import {
+  ArrowForwardRounded,
+  HistoryRounded,
+  RefreshRounded
+} from "@mui/icons-material";
+import {
+  Box as Box3,
+  CardContent as CardContent4,
+  IconButton as IconButton4,
+  Tooltip as Tooltip6,
+  Typography as Typography11,
+  useTheme as useTheme9
+} from "@mui/material";
+import { ButtonEx as ButtonEx5 } from "@xylabs/react-button";
+import {
+  FlexCol as FlexCol14,
+  FlexGrowRow as FlexGrowRow7,
+  FlexRow as FlexRow9
+} from "@xylabs/react-flexbox";
+import { alphaCss as alphaCss5 } from "@xylabs/react-theme";
+import { CardEx } from "@xyo-network/react-card";
+import { DateTime } from "luxon";
+import { jsx as jsx45, jsxs as jsxs24 } from "react/jsx-runtime";
+var WidgetCard = ({
+  widgetName,
+  widgetContent,
+  widgetPath,
+  timeOfData = 1715875087,
+  ...props
+}) => {
+  const theme = useTheme9();
+  const formatTimeOfData = () => {
+    const timeNow = DateTime.now().toSeconds();
+    const secondsSinceDataRefreshed = timeNow - timeOfData;
+    const getYearsAndMonths = () => {
+      const years = Math.floor(secondsSinceDataRefreshed / 31536e3);
+      const months = Math.ceil((secondsSinceDataRefreshed - years * 31536e3) / 2628288);
+      if (months === 12) {
+        return `${years + 1} Years Ago`;
+      } else if (years > 1 && months > 1) {
+        return `${years} Years, ${months} Months Ago`;
+      } else if (years === 1 && months > 1) {
+        return `${years} Year, ${months} Months Ago`;
+      } else if (years > 1 && months === 1) {
+        return `${years} Years, ${months} Month Ago`;
+      } else if (years === 1 && months === 1) {
+        return `${years} Year, ${months} Month Ago`;
+      } else {
+        return `About ${years} Years Ago`;
+      }
+    };
+    if (secondsSinceDataRefreshed < 60) {
+      return "Less than 1 Minute Ago";
+    } else if (secondsSinceDataRefreshed < 3600) {
+      return `${DateTime.fromSeconds(secondsSinceDataRefreshed).toFormat("m")} Minutes Ago`;
+    } else if (secondsSinceDataRefreshed < 86400) {
+      return `${Math.ceil(secondsSinceDataRefreshed / 3600)} Hours Ago`;
+    } else if (secondsSinceDataRefreshed < 2628288) {
+      return `${Math.ceil(secondsSinceDataRefreshed / 86400)} Days Ago`;
+    } else if (secondsSinceDataRefreshed < 31536e3) {
+      return `${Math.ceil(secondsSinceDataRefreshed / 2628288)} Months Ago`;
+    } else {
+      return getYearsAndMonths();
+    }
+  };
+  return /* @__PURE__ */ jsx45(
+    CardEx,
+    {
+      ...props,
+      sx: {
+        backgroundColor: alphaCss5(theme.vars?.palette.background.paper ?? "#000", 0.4),
+        display: "flex",
+        height: "300px",
+        width: "300px"
+      },
+      children: /* @__PURE__ */ jsx45(CardContent4, { sx: { height: "100%", padding: 1 }, children: /* @__PURE__ */ jsxs24(
+        FlexCol14,
+        {
+          sx: {
+            alignItems: "stretch",
+            height: "100%",
+            justifyContent: "space-between"
+          },
+          children: [
+            /* @__PURE__ */ jsxs24(FlexCol14, { sx: { alignItems: "stretch" }, children: [
+              /* @__PURE__ */ jsxs24(FlexGrowRow7, { sx: { justifyContent: "space-between", alignItems: "center" }, children: [
+                /* @__PURE__ */ jsx45(Typography11, { variant: "h6", sx: { color: theme.vars?.palette.text.primary, fontWeight: theme.typography.fontWeightMedium }, children: widgetName }),
+                /* @__PURE__ */ jsx45(IconButton4, { children: /* @__PURE__ */ jsx45(RefreshRounded, {}) })
+              ] }),
+              /* @__PURE__ */ jsx45(Box3, { sx: { paddingY: 2 }, children: widgetContent })
+            ] }),
+            /* @__PURE__ */ jsxs24(FlexRow9, { sx: { justifyContent: "space-between", alignItems: "center" }, children: [
+              /* @__PURE__ */ jsx45(Tooltip6, { title: DateTime.fromSeconds(timeOfData).toFormat("DD ttt"), children: /* @__PURE__ */ jsxs24(
+                FlexRow9,
+                {
+                  sx: { gap: 0.5, opacity: 0.5 },
+                  children: [
+                    /* @__PURE__ */ jsx45(HistoryRounded, { fontSize: "small", color: "inherit" }),
+                    /* @__PURE__ */ jsx45(Typography11, { variant: "body2", children: formatTimeOfData() })
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsx45(ButtonEx5, { size: "small", to: widgetPath, children: /* @__PURE__ */ jsx45(ArrowForwardRounded, { fontSize: "small" }) })
+            ] })
+          ]
+        }
+      ) })
+    }
+  );
+};
+
+// src/modules/widgets/WidgetCardExamples.tsx
+import { Stack as Stack2 } from "@mui/material";
+import { useIsDark as useIsDark4 } from "@xylabs/react-theme";
+
+// src/modules/widgets/StackOfWidgets.tsx
+import { Box as Box4, useTheme as useTheme11 } from "@mui/material";
+import {
+  animated as animated4,
+  to as interpolate,
+  useSprings
+} from "@react-spring/web";
+import { alphaCss as alphaCss8 } from "@xylabs/react-theme";
+import { useState as useState22 } from "react";
+import { useDrag } from "react-use-gesture";
+
+// src/modules/widgets/Types/BarGraph/HorizontalBarGraph.tsx
+import { Typography as Typography12 } from "@mui/material";
+import { FlexCol as FlexCol15, FlexGrowRow as FlexGrowRow8 } from "@xylabs/react-flexbox";
+
+// src/modules/widgets/Types/BarGraph/StyledLinearProgress.tsx
+import { LinearProgress as LinearProgress2, styled as styled8 } from "@mui/material";
+import { alphaCss as alphaCss6 } from "@xylabs/react-theme";
+var StyledLinearProgress = styled8(LinearProgress2, { name: "StyledLinearProgress" })(({ theme }) => ({
+  "& .MuiLinearProgress-bar": { borderRadius: theme.shape.borderRadius },
+  "MozBoxSizing": "border-box",
+  "WebkitBoxSizing": "border-box",
+  "background": "transparent",
+  "borderBottom": `1px solid ${alphaCss6(theme.vars?.palette.text.secondary ?? "#000", 0.3)}`,
+  "boxSizing": "border-box",
+  "height": theme.spacing(0.25)
+}));
+
+// src/modules/widgets/Types/BarGraph/HorizontalBarGraph.tsx
+import { jsx as jsx46, jsxs as jsxs25 } from "react/jsx-runtime";
+var sampleData = [
+  { name: "United States", value: 134 },
+  { name: "South Africa", value: 400 },
+  { name: "Canada", value: 382 },
+  { name: "Philippines", value: 423 },
+  { name: "Denmark", value: 123 },
+  { name: "Greece", value: 321 },
+  { name: "Japan", value: 421 }
+];
+var HorizontalBarGraph = ({ items = sampleData, ...props }) => {
+  const itemsSortedByValue = items.toSorted(function(a2, b) {
+    const keyA = a2.value, keyB = b.value;
+    if (keyA > keyB) return -1;
+    if (keyA < keyB) return 1;
+    return 0;
+  });
+  console.log(itemsSortedByValue);
+  const topValue = itemsSortedByValue[0].value;
+  return /* @__PURE__ */ jsx46(FlexCol15, { sx: { alignItems: "stretch", gap: 0.5 }, ...props, children: items.slice(0, 5).map((item, index) => /* @__PURE__ */ jsxs25(FlexCol15, { sx: { alignItems: "stretch" }, children: [
+    /* @__PURE__ */ jsxs25(FlexGrowRow8, { sx: { justifyContent: "space-between" }, children: [
+      /* @__PURE__ */ jsx46(Typography12, { variant: "caption", noWrap: true, sx: { maxWidth: "50%" }, children: item.name }),
+      /* @__PURE__ */ jsx46(Typography12, { variant: "caption", sx: { maxWidth: "50%" }, children: item.value })
+    ] }),
+    /* @__PURE__ */ jsx46(StyledLinearProgress, { color: "primary", value: item.value / (topValue * 1.25) * 100, variant: "determinate" })
+  ] }, index)) });
+};
+
+// src/modules/widgets/Types/DataColumns/TwoColTwoStat.tsx
+import { Typography as Typography13, useTheme as useTheme10 } from "@mui/material";
+import { FlexCol as FlexCol16, FlexGrowRow as FlexGrowRow9 } from "@xylabs/react-flexbox";
+import { useEffect as useEffect18 } from "react";
+import { jsx as jsx47, jsxs as jsxs26 } from "react/jsx-runtime";
+var MAX_LENGTH = 2;
+var validateProps = (props) => {
+  if (props.length > MAX_LENGTH) {
+    throw new Error(`The length of items for the Two Column Two Stat widget should not exceed ${MAX_LENGTH}`);
+  }
+};
+var TwoColTwoStat = ({ items, ...props }) => {
+  const theme = useTheme10();
+  useEffect18(() => {
+    validateProps(items);
+  }, [items]);
+  return /* @__PURE__ */ jsx47(FlexGrowRow9, { sx: { gap: 2 }, ...props, children: items.map((item, index) => /* @__PURE__ */ jsxs26(FlexCol16, { sx: { flexGrow: 1, alignItems: "start" }, children: [
+    /* @__PURE__ */ jsx47(Typography13, { variant: "h2", sx: { fontWeight: theme.typography.fontWeightMedium }, children: item.rawInsightValue }),
+    /* @__PURE__ */ jsx47(Typography13, { variant: "body2", children: item.subtitle })
+  ] }, `stat-${index}-${item.unit}`)) });
+};
+
+// src/modules/widgets/Types/Examples/BarGraph.tsx
+import { jsx as jsx48 } from "react/jsx-runtime";
+var ExampleBarGraphWidget = () => {
+  return /* @__PURE__ */ jsx48(WidgetCard, { widgetContent: /* @__PURE__ */ jsx48(HorizontalBarGraph, {}), widgetName: "Friend Locations", timeOfData: 1715713478, widgetPath: "/profile" });
+};
+
+// src/modules/widgets/Types/Tables/BooleanTable.tsx
+import { CircleRounded } from "@mui/icons-material";
+import {
+  Paper as Paper2,
+  styled as styled9,
+  TableRow as TableRow2,
+  Typography as Typography14
+} from "@mui/material";
+import {
+  FlexCol as FlexCol17,
+  FlexGrowRow as FlexGrowRow10,
+  FlexRow as FlexRow10
+} from "@xylabs/react-flexbox";
+import { alphaCss as alphaCss7 } from "@xylabs/react-theme";
+import { jsx as jsx49, jsxs as jsxs27 } from "react/jsx-runtime";
+var sampleData2 = [
+  { name: "@arietrouw", value: true },
+  { name: "@officialxyo", value: false },
+  { name: "0x187623121928634124", value: true },
+  { name: "@coinwithus", value: true },
+  { name: "0x871218376123894321", value: true }
+];
+var StyledLightTableRow = styled9(Paper2, { name: "StyledLightTableRow" })(({ theme }) => ({
+  backgroundColor: "transparent",
+  padding: theme.spacing(0.75)
+}));
+var StyledTableColumnTitle = styled9(Typography14, { name: "StyledTableColumnTitle" })(({ theme }) => ({
+  color: theme.vars?.palette.text.secondary,
+  fontWeight: theme.typography.fontWeightBold,
+  textTransform: "uppercase"
+}));
+var DefaultTrueOutput = styled9(CircleRounded, { name: "DefaultTrueOutput" })(({ theme }) => ({
+  fill: theme.vars?.palette.success.main,
+  fontSize: "10px"
+}));
+var DefaultFalseOutput = styled9(CircleRounded, { name: "DefaultFalseOutput" })(({ theme }) => ({
+  fill: alphaCss7(theme.vars?.palette.text.disabled ?? "#111", 0.5),
+  fontSize: "10px"
+}));
+var defaultTrueOutput = /* @__PURE__ */ jsx49(DefaultTrueOutput, {});
+var defaultFalseOutput = /* @__PURE__ */ jsx49(DefaultFalseOutput, {});
+var BooleanTable = ({
+  items = sampleData2,
+  tableHeaders,
+  trueOutput = defaultTrueOutput,
+  falseOutput = defaultFalseOutput,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs27(FlexCol17, { sx: { alignItems: "stretch" }, ...props, children: [
+    /* @__PURE__ */ jsx49(FlexRow10, { sx: { paddingBottom: 0.5, justifyContent: "space-between" }, children: tableHeaders.map((name) => /* @__PURE__ */ jsx49(StyledTableColumnTitle, { variant: "caption", children: name }, name)) }),
+    /* @__PURE__ */ jsx49(FlexCol17, { sx: { alignItems: "stretch", gap: 0.25 }, children: items.slice(0, 4).map((item, index) => /* @__PURE__ */ jsx49(TableRow2, { children: /* @__PURE__ */ jsxs27(FlexGrowRow10, { sx: { flexGrow: 1, justifyContent: "space-between" }, children: [
+      /* @__PURE__ */ jsx49(Typography14, { variant: "caption", noWrap: true, sx: { maxWidth: "70%" }, children: item.name }),
+      item.value ? trueOutput : falseOutput
+    ] }) }, index)) })
+  ] });
+};
+
+// src/modules/widgets/Types/Examples/BooleanTable.tsx
+import { jsx as jsx50 } from "react/jsx-runtime";
+var ExampleBooleanTableWidget = () => {
+  return /* @__PURE__ */ jsx50(
+    WidgetCard,
+    {
+      widgetContent: /* @__PURE__ */ jsx50(
+        BooleanTable,
+        {
+          items: [
+            { name: "@arietrouw", value: true },
+            { name: "@officialxyo", value: false },
+            { name: "0x187623121928634124", value: true },
+            { name: "@coinwithus", value: true },
+            { name: "0x871218376123894321", value: true }
+          ],
+          tableHeaders: ["Id", "Online"]
+        }
+      ),
+      widgetName: "Friends",
+      timeOfData: 1715875797,
+      widgetPath: "/profile"
+    }
+  );
+};
+
+// src/modules/widgets/Types/Examples/TwoColTwoStat.tsx
+import { jsx as jsx51 } from "react/jsx-runtime";
+var ExampleTwoColTwoStatWidget = () => {
+  return /* @__PURE__ */ jsx51(
+    WidgetCard,
+    {
+      widgetContent: /* @__PURE__ */ jsx51(
+        TwoColTwoStat,
+        {
+          items: [
+            {
+              rawInsightValue: 218,
+              subtitle: "Inbound Access Requests",
+              uiInsightValue: 218,
+              unit: "requests"
+            },
+            {
+              rawInsightValue: 18,
+              subtitle: "Outbound Access Requests",
+              uiInsightValue: 18,
+              unit: "requests"
+            }
+          ]
+        }
+      ),
+      widgetName: "Network Activity",
+      timeOfData: 1642637397,
+      widgetPath: "/network"
+    }
+  );
+};
+
+// src/modules/widgets/StackOfWidgets.tsx
+import { Fragment as Fragment7, jsx as jsx52 } from "react/jsx-runtime";
+var cards = [
+  /* @__PURE__ */ jsx52(ExampleBarGraphWidget, {}, "bar-graph"),
+  /* @__PURE__ */ jsx52(ExampleBooleanTableWidget, {}, "boolean-table"),
+  /* @__PURE__ */ jsx52(ExampleTwoColTwoStatWidget, {}, "two-column")
+];
+var to = (i) => ({
+  delay: i * 100,
+  rot: -10 + Math.random() * 15,
+  scale: 1,
+  x: 0,
+  y: i * -4
+});
+var from = (_i) => ({
+  rot: 0,
+  scale: 1.5,
+  x: 0,
+  y: -1e3
+});
+var trans = (r, s) => `perspective(1500px)  rotateY(${r / 10}deg) scale(${s})`;
+function Deck() {
+  const [gone] = useState22(() => /* @__PURE__ */ new Set());
+  const theme = useTheme11();
+  const [props, api] = useSprings(cards.length, (i) => ({
+    ...to(i),
+    from: from(i)
+  }));
+  const bind = useDrag(({
+    args: [index],
+    down,
+    movement: [mx],
+    direction: [xDir],
+    velocity
+  }) => {
+    const trigger = velocity > 0.2;
+    const dir = xDir < 0 ? -1 : 1;
+    if (!down && trigger) gone.add(index);
+    api.start((i) => {
+      if (index !== i) return;
+      const isGone = gone.has(index);
+      const x = isGone ? (200 + globalThis.innerWidth) * dir : down ? mx : 0;
+      const rot = mx / 100 + (isGone ? dir * 10 * velocity : 0);
+      const scale = down ? 1.1 : 1;
+      return {
+        config: {
+          friction: 50,
+          tension: down ? 800 : isGone ? 200 : 500
+        },
+        delay: void 0,
+        rot,
+        scale,
+        x
+      };
+    });
+    if (!down && gone.size === cards.length)
+      setTimeout(() => {
+        gone.clear();
+        api.start((i) => to(i));
+      }, 600);
+  });
+  return /* @__PURE__ */ jsx52(Fragment7, { children: props.map(({
+    x,
+    y,
+    rot,
+    scale
+  }, i) => /* @__PURE__ */ jsx52(
+    animated4.div,
+    {
+      style: {
+        alignItems: "center",
+        display: "flex",
+        height: "300px",
+        justifyContent: "center",
+        position: "absolute",
+        touchAction: "none",
+        width: "300px",
+        willChange: "transform",
+        x,
+        y
+      },
+      children: /* @__PURE__ */ jsx52(
+        animated4.div,
+        {
+          ...bind(i),
+          style: {
+            // WebkitBackdropFilter: 'blur(10px)',
+            // backdropFilter: 'blur(10px)',
+            backgroundColor: alphaCss8(theme.vars?.palette.background.paper ?? "#000", 0.2),
+            backgroundPosition: "center center",
+            backgroundRepeat: "no-repeat",
+            backgroundSize: "auto 85%",
+            borderRadius: " 10px",
+            boxShadow: theme.shadows[7],
+            height: "85vh",
+            maxHeight: "300px",
+            maxWidth: "300px",
+            transform: interpolate([rot, scale], trans),
+            width: "45vh",
+            willChange: "transform"
+          },
+          children: cards[i]
+        }
+      )
+    },
+    i
+  )) });
+}
+var StackOfWidgets = () => {
+  return /* @__PURE__ */ jsx52(
+    Box4,
+    {
+      sx: {
+        alignItems: "center",
+        cursor: "pointer",
+        display: "flex",
+        height: "300px",
+        justifyContent: "center",
+        width: "300px"
+      },
+      children: /* @__PURE__ */ jsx52(Deck, {})
+    }
+  );
+};
+
+// src/modules/widgets/WidgetCardExamples.tsx
+import { jsx as jsx53, jsxs as jsxs28 } from "react/jsx-runtime";
+var WidgetCardExamples = () => {
+  const darkMode = useIsDark4();
+  return /* @__PURE__ */ jsx53(
+    DappPage,
+    {
+      sx: { backgroundImage: darkMode ? `url(${xyoDark})` : `url(${xyoLight})`, backgroundSize: "cover" },
+      container: "xl",
+      title: "Example Widget Cards",
+      children: /* @__PURE__ */ jsxs28(
+        Stack2,
+        {
+          sx: {
+            gap: 2,
+            flexDirection: "row",
+            flexWrap: "wrap"
+          },
+          children: [
+            /* @__PURE__ */ jsx53(ExampleTwoColTwoStatWidget, {}),
+            /* @__PURE__ */ jsx53(ExampleBarGraphWidget, {}),
+            /* @__PURE__ */ jsx53(ExampleBooleanTableWidget, {}),
+            /* @__PURE__ */ jsx53(StackOfWidgets, {})
+          ]
+        }
+      )
+    }
+  );
+};
+
+// src/settings/Theme/ThemeProvider.tsx
+import { ThemeProvider } from "@mui/material";
+import { XyosTheme } from "@xylabs/react-theme";
+import { useMemo as useMemo19 } from "react";
+import { jsx as jsx54 } from "react/jsx-runtime";
+var AppOsThemeProvider = ({ children }) => {
+  const initialValue = useMemo19(() => {
+    const validValues = ["light", "dark"];
+    const savedValue = localStorage.getItem("mui-mode");
+    if (savedValue && validValues.includes(savedValue)) return savedValue;
+    return "system";
+  }, []);
+  return /* @__PURE__ */ jsx54(ThemeProvider, { theme: XyosTheme, defaultMode: initialValue, children });
+};
+export {
+  AppOsThemeProvider,
+  BridgeActivityHelper,
+  BrowserLocator,
+  CoinbaseEmailInput,
+  ContainerFlexbox,
+  CreditCardInputSchema,
+  CustomerParams,
+  DappAccessDialog,
+  DappAccessFlexbox,
+  DappAccessRequestResourceHooks,
+  DappBar,
+  DappBottomNavigation,
+  DappChrome,
+  DappChromeLarge,
+  DappContainer,
+  DappContainerMemo,
+  DappInstallTypeFilters,
+  DappIntentResourceHooks,
+  DappMenuDrawer,
+  DappMenuResourceHooks,
+  DappPage,
+  DappPathHelpers,
+  DappPathSwitcher,
+  DappRendered,
+  DappTitle,
+  DappWindow,
+  DappsRow,
+  DebugDialog,
+  DebugDialogWithNode,
+  DefaultComingSoon,
+  EmptyDappBarForPadding,
+  ErrorRenderWithSupport,
+  ErrorRenderWithSupportDefault,
+  GenericPayloadDivinerTags,
+  LazyDebug,
+  LoadingOsLogo,
+  NameServiceRegistrationHooks,
+  NetworkButton,
+  NetworkLoadingIndicator,
+  NetworkReadyFlexBox,
+  NextIteratorFlexbox,
+  OsPalettes,
+  PaymentMethods,
+  PrimaryCryptoWalletInput,
+  RenderHtml,
+  ResourceHooks,
+  SecondaryCryptoWalletInput,
+  ShiftAnimation,
+  StyledGridContainer,
+  StyledListItemButton,
+  StyledMenuIconWrapSpan,
+  TableHeadCellSchema,
+  TableHeadEx,
+  TwoToneBulletPoint,
+  TwoToneBulletPointList,
+  WidgetCaller,
+  WidgetCard,
+  WidgetCardExamples,
+  XnsDomainIcon,
+  XyOsBrowserMonitor,
+  XyOsUi,
+  XyOsUiContext,
+  XyOsUiContextProvider,
+  detectCustomer,
+  getApiDomain,
+  getNodePaletteByNameCode,
+  isCreditCardInput,
+  isTableHeadCell,
+  useAccountArchivist,
+  useAddDappMenuItems,
+  useBios,
+  useBuildDappAccessRequestResource,
+  useBuildDappMenuResource,
+  useBuildIntentResource,
+  useBuildNameServiceRegistrationsResource,
+  useBuildNameServiceRegistrationsResourceViews,
+  useCleanUpResource,
+  useClearIntents,
+  useDappAccessRequestResourceViews,
+  useDappCaller,
+  useDappContextCreator,
+  useDappIntentCaller,
+  useDappIntentListener,
+  useDappIntentListener2,
+  useDappMenu,
+  useDappMenuCaller,
+  useDappMenuDependencies,
+  useDappRegistrationResults,
+  useDappRegistry,
+  useDappSeedPhraseRepository,
+  useDebugClick,
+  useDecomposeDapp,
+  useDialogState,
+  useExposedNode,
+  useIntentResourceViews,
+  useKernel,
+  useManageDappInjectableParamsFromRoute,
+  useManageDappIntentRequest,
+  useManageDappPathFromRoute,
+  useManageDappStateFromRoute,
+  useMenuResourceViews,
+  useNavigateIntent,
+  useOnWindowResize,
+  useOsNetwork,
+  useOsSettingsCaller,
+  usePhraseFile,
+  useSendDappIntent,
+  useSkipLoadingScreen,
+  useStackReady,
+  useSyncExternalPayloadStore,
+  useSyncOsRegisteredAccessInterfaces,
+  useTabs,
+  useVisibleColumns,
+  useWidgetDapps,
+  useXyOsUiContext,
+  useXyoPublicNetwork
+};
+//# sourceMappingURL=index.mjs.map