@xyo-network/os-react-runtime 2.3.0

package/dist/browser/index.mjs

@@ -0,0 +1,4584 @@
+// src/components/alerts/errors/RenderErrorWithSupportLink.tsx
+import { ButtonEx } from "@xylabs/react-button";
+import { ErrorAlert } from "@xyo-network/react-error";
+import { useEffect } from "react";
+import { useLocation } from "react-router-dom";
+import { jsx } from "react/jsx-runtime";
+var ErrorRenderWithSupport = ({
+  supportHref = "",
+  supportTo,
+  supportLinkText = "Support",
+  error,
+  errorContext,
+  onCancel,
+  ...props
+}) => {
+  const location2 = useLocation();
+  useEffect(() => {
+    location2.state = { from: { pathname: window.location.pathname } };
+  }, [location2]);
+  return /* @__PURE__ */ jsx(
+    ErrorAlert,
+    {
+      action: /* @__PURE__ */ jsx(ButtonEx, { target: "_blank", href: supportHref, to: supportTo, color: "inherit", size: "small", children: supportLinkText }),
+      error,
+      errorContext,
+      onCancel,
+      ...props
+    }
+  );
+};
+var ErrorRenderWithSupportDefault = (props) => {
+  return /* @__PURE__ */ jsx(ErrorRenderWithSupport, { supportHref: "https://discord.com/channels/935586624392298547/1228436997375393885", ...props });
+};
+
+// src/components/RenderHtml.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var RenderHtml = ({ htmlString }) => {
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      style: { height: 64, width: 64 },
+      dangerouslySetInnerHTML: { __html: htmlString }
+    }
+  );
+};
+
+// src/components/Widgets/WidgetCard.tsx
+import {
+  ArrowForwardRounded,
+  HistoryRounded,
+  RefreshRounded
+} from "@mui/icons-material";
+import {
+  alpha,
+  Box,
+  CardContent,
+  IconButton,
+  Tooltip,
+  Typography,
+  useTheme
+} from "@mui/material";
+import { ButtonEx as ButtonEx2 } from "@xylabs/react-button";
+import {
+  FlexCol,
+  FlexGrowRow,
+  FlexRow
+} from "@xylabs/react-flexbox";
+import { CardEx } from "@xyo-network/react-card";
+import { DateTime } from "luxon";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var WidgetCard = ({
+  widgetName,
+  widgetContent,
+  widgetPath,
+  timeOfData = 1715875087,
+  ...props
+}) => {
+  const theme = useTheme();
+  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__ */ jsx3(
+    CardEx,
+    {
+      ...props,
+      sx: {
+        backgroundColor: alpha(theme.palette.background.paper, 0.4),
+        display: "flex",
+        height: "300px",
+        width: "300px"
+      },
+      children: /* @__PURE__ */ jsx3(CardContent, { sx: { height: "100%", padding: 1 }, children: /* @__PURE__ */ jsxs(
+        FlexCol,
+        {
+          sx: {
+            alignItems: "stretch",
+            height: "100%",
+            justifyContent: "space-between"
+          },
+          children: [
+            /* @__PURE__ */ jsxs(FlexCol, { alignItems: "stretch", children: [
+              /* @__PURE__ */ jsxs(FlexGrowRow, { justifyContent: "space-between", alignItems: "center", children: [
+                /* @__PURE__ */ jsx3(Typography, { color: theme.palette.text.primary, fontWeight: theme.typography.fontWeightMedium, variant: "h6", children: widgetName }),
+                /* @__PURE__ */ jsx3(IconButton, { children: /* @__PURE__ */ jsx3(RefreshRounded, {}) })
+              ] }),
+              /* @__PURE__ */ jsx3(Box, { paddingY: 2, children: widgetContent })
+            ] }),
+            /* @__PURE__ */ jsxs(FlexRow, { justifyContent: "space-between", alignItems: "center", children: [
+              /* @__PURE__ */ jsx3(Tooltip, { title: DateTime.fromSeconds(timeOfData).toFormat("DD ttt"), children: /* @__PURE__ */ jsxs(
+                FlexRow,
+                {
+                  gap: 0.5,
+                  sx: { opacity: 0.5 },
+                  children: [
+                    /* @__PURE__ */ jsx3(HistoryRounded, { fontSize: "small", color: "inherit" }),
+                    /* @__PURE__ */ jsx3(Typography, { variant: "body2", children: formatTimeOfData() })
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsx3(ButtonEx2, { size: "small", to: widgetPath, children: /* @__PURE__ */ jsx3(ArrowForwardRounded, { fontSize: "small" }) })
+            ] })
+          ]
+        }
+      ) })
+    }
+  );
+};
+
+// src/components/Widgets/WidgetCardExamples.tsx
+import { Stack as Stack2 } from "@mui/material";
+import { useColorSchemeEx as useColorSchemeEx4 } from "@xylabs/react-invertible-theme";
+
+// src/DappPage.tsx
+import { Container as Container3, Typography as Typography9 } from "@mui/material";
+import { FlexCol as FlexCol12 } from "@xylabs/react-flexbox";
+import { ThrownErrorBoundary } from "@xyo-network/react-error";
+
+// src/modules/Dapp/Button/hooks/useLaunchPoint.tsx
+import { useLayoutEffect, useState as useState2 } 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).sort((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).sort((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).sort((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 useEffect2, useState } from "react";
+var useOnWindowResize = () => {
+  const [resized, setResized] = useState();
+  useEffect2(() => {
+    const onResize = (event) => {
+      setResized(event);
+    };
+    window.addEventListener("resize", onResize, false);
+    return () => {
+      window.removeEventListener("resize", onResize);
+    };
+  }, []);
+  return resized;
+};
+
+// src/modules/Dapp/Button/hooks/useLaunchPoint.tsx
+var useLaunchPoint = (spanRef) => {
+  const [coordinates, setCoordinates] = useState2({ 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 as FlexCol2 } from "@xylabs/react-flexbox";
+import { DappIntentTypes as DappIntentTypes5 } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller2, XyOsMonitor as XyOsMonitor2 } from "@xyo-network/os-runtime";
+import { useRef as useRef3 } from "react";
+
+// src/hooks/access-requests/useBuildDappAccessRequestResource.ts
+import { usePromise } from "@xylabs/react-promise";
+import { DappAccessRequestResource } from "@xyo-network/os-runtime";
+
+// src/hooks/ResourceHooks.ts
+var ResourceHooks = class {
+  constructor(buildResource, buildViews) {
+    this.buildResource = buildResource;
+    this.buildViews = buildViews;
+  }
+  useBuildResourceFromProvidedNode = (pathPrefix) => {
+    const xyOs = useXyOsUiContext();
+    return this.buildResource(xyOs, pathPrefix);
+  };
+  useResourceViewsFromContext = (context, pathPrefix) => {
+    const [resource, resourceError] = this.buildResource(context, pathPrefix);
+    const views = this.buildViews(resource);
+    return {
+      ...views,
+      resource,
+      resourceError
+    };
+  };
+  useResourceViewsFromProvidedNode = (pathPrefix) => {
+    const [resource, resourceError] = this.useBuildResourceFromProvidedNode(pathPrefix);
+    const views = this.buildViews(resource);
+    return {
+      ...views,
+      resource,
+      resourceError
+    };
+  };
+};
+
+// src/hooks/useCleanup.tsx
+import { useEffect as useEffect3 } from "react";
+var useCleanUpResource = (resource) => {
+  useEffect3(() => {
+    return () => {
+      resource?.cleanupListeners();
+    };
+  }, [resource]);
+};
+
+// src/hooks/useSyncExternalPayloadStore.tsx
+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/hooks/access-requests/useBuildDappAccessRequestResource.ts
+var useBuildDappAccessRequestResource = (context) => {
+  const resource = usePromise(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/hooks/bios/useBios.ts
+import { usePromise as usePromise2 } from "@xylabs/react-promise";
+import { boot } from "@xyo-network/bios-browser";
+import { useEffect as useEffect4 } from "react";
+var biosBoot;
+var useBios = () => {
+  const [biosExternalInterface, biosError] = usePromise2(async () => {
+    if (biosBoot) return await biosBoot;
+    biosBoot = boot();
+    return await biosBoot;
+  }, []);
+  useEffect4(() => {
+    if (biosError) throw biosError;
+  }, [biosError]);
+  return biosExternalInterface;
+};
+
+// src/hooks/bios/useKernel.ts
+import { usePromise as usePromise3 } from "@xylabs/react-promise";
+import { Kernel } from "@xyo-network/kernel";
+import { useEffect as useEffect5 } from "react";
+var kernelBoot;
+var useKernel = (locator, params) => {
+  const bios = useBios();
+  const [kernelExternalInterface, kernelError] = usePromise3(async () => {
+    if (kernelBoot) return await kernelBoot;
+    if (bios) {
+      kernelBoot = async function() {
+        const kernel = new Kernel();
+        await kernel.boot(bios, { locator, ...params });
+        return kernel;
+      }();
+      return await kernelBoot;
+    }
+  }, [bios]);
+  useEffect5(() => {
+    if (kernelError) throw kernelError;
+  }, [kernelError]);
+  return kernelExternalInterface;
+};
+
+// src/hooks/DappIntentResourceHooks.ts
+import { usePromise as usePromise4 } from "@xylabs/react-promise";
+import { DappIntentResource } from "@xyo-network/os-runtime";
+var useBuildIntentResource = (context) => {
+  const resource = usePromise4(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/hooks/intent/useClearIntents.tsx
+import { useAsyncEffect } from "@xylabs/react-async-effect";
+import { useWeakArchivistFromNode } from "@xyo-network/react-archivist";
+var useClearIntents = () => {
+  const [intentArchivist] = useWeakArchivistFromNode("IntentArchivist");
+  useAsyncEffect(
+    async () => {
+      const intentArchivistInstance = intentArchivist?.deref();
+      if (intentArchivistInstance) await intentArchivistInstance.clear?.();
+    },
+    [intentArchivist]
+  );
+};
+
+// src/hooks/intent/useDappIntentListener.tsx
+import {
+  DappIntentTypes,
+  DappMode,
+  isDappIntentWithMeta
+} from "@xyo-network/os-model";
+import { useWeakArchivistFromNode as useWeakArchivistFromNode2 } from "@xyo-network/react-archivist";
+import { useEffect as useEffect6, useState as useState3 } from "react";
+var useDappIntentListener = (dappName, targetMode = DappMode.Window) => {
+  const [dappIntentType, setDappIntentType] = useState3(DappIntentTypes.Close);
+  const [intentPayload, setIntentPayload] = useState3();
+  const [intentArchivist] = useWeakArchivistFromNode2("IntentArchivist");
+  useEffect6(() => {
+    const listener = ({ payloads }) => {
+      const filteredPayloads = payloads.filter(isDappIntentWithMeta);
+      for (const payload of filteredPayloads) {
+        if (payload.targetDappId === dappName && payload.targetMode === targetMode) {
+          setIntentPayload(payload);
+          switch (payload.intent) {
+            case DappIntentTypes.Close: {
+              setDappIntentType(DappIntentTypes.Close);
+              break;
+            }
+            case DappIntentTypes.Launch: {
+              setDappIntentType(DappIntentTypes.Launch);
+              break;
+            }
+            case DappIntentTypes.Minimize: {
+              setDappIntentType(DappIntentTypes.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/hooks/intent/useDappIntentListener2.tsx
+import { DappIntentTypes as DappIntentTypes2, DappMode as DappMode2 } from "@xyo-network/os-model";
+import { useEffect as useEffect7, useState as useState4 } from "react";
+var useDappIntentListener2 = (dappName, sourceMode = DappMode2.Window) => {
+  const { latestDappIntent } = DappIntentResourceHooks.useResourceViewsFromProvidedNode();
+  const [dappIntentType, setDappIntentType] = useState4(DappIntentTypes2.Close);
+  useEffect7(() => {
+    if (sourceMode === DappMode2.Window) {
+      for (const payload of latestDappIntent ?? []) {
+        if (payload.targetDappId === dappName) {
+          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);
+            }
+          }
+        }
+      }
+    } else {
+      console.warn("Intent sent from unrecognized mode", sourceMode);
+    }
+  }, [dappName, latestDappIntent, sourceMode]);
+  return dappIntentType;
+};
+
+// src/hooks/intent/useNavigateIntent.tsx
+import { DappIntentTypes as DappIntentTypes3 } from "@xyo-network/os-model";
+import { NameTransforms } from "@xyo-network/os-runtime";
+import { useCallback } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+var rootRoute = "/";
+var useNavigateIntent = () => {
+  const navigate = useNavigate();
+  const { dappName: dappNameParam } = useParams();
+  const updateRouteParam = useCallback(
+    (dappIntent, { skipNavigate } = {}) => {
+      if (dappIntent && dappIntent.targetDappId) {
+        const {
+          targetDappId: dappName,
+          intent: intentType,
+          params: intentParams
+        } = dappIntent;
+        const slug = new NameTransforms(dappName).slug();
+        switch (intentType) {
+          case DappIntentTypes3.Launch: {
+            const dappNameDeSlugged = dappNameParam ? new NameTransforms(dappNameParam).deSlug() : null;
+            if (dappNameDeSlugged !== dappName) {
+              const slugFromRoot = `${rootRoute}${slug}${intentParams ? `/${intentParams}` : ""}`;
+              if (!skipNavigate) navigate(slugFromRoot);
+            }
+            break;
+          }
+          case DappIntentTypes3.Minimize: {
+            if (!skipNavigate) navigate(rootRoute);
+            break;
+          }
+          case DappIntentTypes3.Close: {
+            if (!skipNavigate) navigate(rootRoute);
+            break;
+          }
+        }
+      }
+    },
+    [dappNameParam, navigate]
+  );
+  return updateRouteParam;
+};
+
+// src/hooks/intent/useSendDappIntent.tsx
+import { useWeakArchivistFromNode as useWeakArchivistFromNode3 } from "@xyo-network/react-archivist";
+import { useCallback as useCallback2 } from "react";
+var useSendDappIntent = () => {
+  const [intentArchivist] = useWeakArchivistFromNode3("IntentArchivist");
+  const navigate = useNavigateIntent();
+  const sendIntent = useCallback2(
+    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/hooks/menu/useAddDappMenuItems.tsx
+import { usePromise as usePromise6 } from "@xylabs/react-promise";
+
+// src/hooks/menu/useBuildDappMenuResource.ts
+import { usePromise as usePromise5 } from "@xylabs/react-promise";
+import { DappMenuResource } from "@xyo-network/os-runtime";
+var useBuildDappMenuResource = (xyOsContext) => {
+  const resource = usePromise5(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/hooks/menu/useDappMenuCaller.tsx
+import { assertEx } from "@xylabs/assert";
+import { DappMenuCaller } from "@xyo-network/os-runtime";
+import { useMemo as useMemo2 } from "react";
+var useDappMenuCaller = (context, { ignoreProvidedNode } = {}) => {
+  const xyOs = useXyOsUiContext();
+  return useMemo2(() => {
+    const resolvedProvidedNode = ignoreProvidedNode ? null : xyOs;
+    if (context || resolvedProvidedNode) {
+      const finalContext = assertEx(context ?? xyOs, () => "no node was found in context or passed as argument");
+      return new DappMenuCaller(finalContext);
+    }
+  }, [ignoreProvidedNode, context, xyOs]);
+};
+
+// src/hooks/menu/useAddDappMenuItems.tsx
+var useAddDappMenuItems = (payloads) => {
+  const xyOs = useXyOsUiContext();
+  const {
+    menuItemSelections,
+    menuConfigs,
+    resourceError
+  } = DappMenuResourceHooks.useResourceViewsFromContext(xyOs);
+  const dappMenuCaller = useDappMenuCaller();
+  const [, addMenuItemsError] = usePromise6(async () => {
+    await dappMenuCaller?.add(payloads);
+  }, [payloads, dappMenuCaller]);
+  return {
+    addMenuItemsError,
+    menuConfig: menuConfigs?.[0],
+    path: menuItemSelections?.[0],
+    error: resourceError
+  };
+};
+
+// src/hooks/NameServiceRegistrationHooks.ts
+import { usePromise as usePromise7 } from "@xylabs/react-promise";
+import { XnsRegistrationsResource } from "@xyo-network/os-runtime";
+var useBuildNameServiceRegistrationsResource = (context, pathPrefix) => {
+  const result = usePromise7(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/hooks/os/useDappContextCreator.tsx
+import { useAsyncEffect as useAsyncEffect2 } from "@xylabs/react-async-effect";
+import { DappIntentTypes as DappIntentTypes4 } from "@xyo-network/os-model";
+import { DappContextCreator, RunningDappCache } from "@xyo-network/os-runtime";
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect8,
+  useRef,
+  useState as useState5
+} from "react";
+var useDappContextCreator = (xnsNodeUrl, xnsNetwork, dapp, allowedNames, createOnMount = false) => {
+  const context = useXyOsUiContext();
+  const [windowDappNodeSet, setWindowDappNodeSet] = useState5({ context: void 0, dappWallet: void 0 });
+  const [dappWindowNodeError, setDappWindowNodeError] = useState5();
+  const { dappIntentType: intentType } = useDappIntentListener(dapp?.config.name);
+  const windowDappNodeSetRef = useRef(windowDappNodeSet);
+  useEffect8(() => {
+    windowDappNodeSetRef.current = windowDappNodeSet;
+  }, [windowDappNodeSet]);
+  const createNode = useCallback3(async () => {
+    if (dapp && context) {
+      try {
+        const windowDappNodeSet2 = await RunningDappCache.findOrCreate(dapp, context, allowedNames ?? [], xnsNodeUrl, xnsNetwork);
+        setWindowDappNodeSet(windowDappNodeSet2);
+      } catch (e) {
+        setDappWindowNodeError(e);
+      }
+    }
+  }, [dapp, context, allowedNames]);
+  useEffect8(() => {
+    if (createOnMount) {
+      void (async () => {
+        await createNode();
+      })();
+    }
+  }, [createOnMount, createNode]);
+  useAsyncEffect2(
+    async () => {
+      switch (intentType) {
+        case DappIntentTypes4.Launch: {
+          await createNode();
+          break;
+        }
+        case DappIntentTypes4.Close: {
+          if (windowDappNodeSetRef.current.context) {
+            await DappContextCreator.resetDappArchivist(windowDappNodeSetRef.current.context);
+            setWindowDappNodeSet({ context: null, dappWallet: void 0 });
+          }
+          break;
+        }
+        case DappIntentTypes4.Minimize:
+      }
+    },
+    [createNode, intentType]
+  );
+  return {
+    ...windowDappNodeSet,
+    nodeCreateError: dappWindowNodeError
+  };
+};
+
+// src/hooks/os/useDappRegistrationResults.tsx
+import { EventBusPubSubConnection } from "@xyo-network/os-runtime";
+import { useEffect as useEffect9, useState as useState6 } from "react";
+var useDappRegistrationResults = () => {
+  const context = useXyOsUiContext();
+  const [registeredDappSetResults, setRegisteredDappSetResults] = useState6();
+  useEffect9(() => {
+    const listener = () => {
+      setRegisteredDappSetResults(context?.dappRegistrationResults);
+    };
+    const dappsReadyConnectionRequest = {
+      subscribableEvents: /* @__PURE__ */ new Map([["dappsReady", listener]]),
+      type: "PubSub"
+    };
+    const dappsReadyConnection2 = new EventBusPubSubConnection(dappsReadyConnectionRequest);
+    if (context) {
+      context.eventBus.addConnection(dappsReadyConnection2);
+      setRegisteredDappSetResults(context.dappRegistrationResults);
+    }
+    return () => context && dappsReadyConnection2.id ? context.eventBus.removeConnection(dappsReadyConnection2.id) : void 0;
+  }, [context]);
+  return registeredDappSetResults;
+};
+
+// src/hooks/os/useDappRegistry.tsx
+import { DappRegistry } from "@xyo-network/os-runtime";
+import { useMemo as useMemo4 } from "react";
+
+// src/hooks/os/useDappSeedPhraseRepository.tsx
+import { DappSeedPhraseRepository } from "@xyo-network/os-runtime";
+import { useMemo as useMemo3 } from "react";
+var _dappWalletRepository;
+var useDappSeedPhraseRepository = (allowedNames) => {
+  const context = useXyOsUiContext();
+  const dappWalletRepository = useMemo3(() => {
+    if (_dappWalletRepository === void 0 && context) {
+      _dappWalletRepository = new DappSeedPhraseRepository(context, allowedNames);
+    }
+    return _dappWalletRepository;
+  }, [context, allowedNames]);
+  return dappWalletRepository;
+};
+
+// src/hooks/os/useDappRegistry.tsx
+var _dappRegistry;
+var useDappRegistry = (allowedNames) => {
+  const dappSeedPhraseRepository = useDappSeedPhraseRepository(allowedNames);
+  return useMemo4(() => {
+    if (dappSeedPhraseRepository) {
+      if (!_dappRegistry) {
+        _dappRegistry = new DappRegistry(dappSeedPhraseRepository);
+      }
+      return _dappRegistry;
+    }
+  }, [dappSeedPhraseRepository]);
+};
+
+// src/hooks/os/useWidgetDapps.tsx
+import { usePromise as usePromise8 } from "@xylabs/react-promise";
+
+// src/helpers/BridgeActivityHelper.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { GenericPayloadDivinerConfigSchema } from "@xyo-network/diviner-payload-generic";
+import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
+import { BaseEmitter } from "@xyo-network/module-abstract";
+var BridgeActivityHelper = class extends BaseEmitter {
+  get archivist() {
+    return assertEx2(this.params.archivist.deref(), () => "Archivist is missing");
+  }
+  get diviner() {
+    const result = assertEx2(this.params.diviner.deref(), () => "Diviner is missing");
+    assertEx2(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 { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
+var GenericPayloadDivinerTags = { "network.xyo.generic.payload.diviner": "GenericPayloadDiviner" };
+var BrowserLocator = new ModuleFactoryLocator();
+BrowserLocator.register(GenericPayloadDiviner, GenericPayloadDivinerTags);
+BrowserLocator.register(IndexedDbArchivist, { "network.xyo.archivist.persistence.scope": "device" }, "network.xyo.archivist.config");
+BrowserLocator.register(IndexedDbPayloadDiviner, { "network.xyo.archivist.persistence.scope": "device" }, "network.xyo.diviner.payload.config");
+BrowserLocator.register(
+  IndexedDbBoundWitnessDiviner,
+  { "network.xyo.archivist.persistence.scope": "device" },
+  "network.xyo.diviner.boundwitness.config"
+);
+BrowserLocator.freeze();
+
+// src/helpers/monitor/XyOsBrowserMonitor.ts
+import { XyOsMonitor } from "@xyo-network/os-runtime";
+var XyOsBrowserMonitor = class extends XyOsMonitor {
+  connection() {
+    try {
+      if (window !== void 0) {
+        return "connection" in window.navigator ? window.navigator.connection : void 0;
+      }
+    } catch {
+      return;
+    }
+  }
+};
+
+// src/img/backgrounds/index.ts
+import { default as default2 } from "./candy-dark@3x-N2S7K4QB.webp";
+import { default as default3 } from "./candy-light@3x-WKECMFRP.webp";
+import { default as default4 } from "./candyApple-dark@3x-HGSPETPR.webp";
+import { default as default5 } from "./candyApple-light@3x-OWA5XNTF.webp";
+import { default as default6 } from "./moss-dark@3x-HV35CF34.webp";
+import { default as default7 } from "./moss-light@3x-UH4AJQR5.webp";
+import { default as default8 } from "./ocean-dark@3x-LDW7E4ZL.webp";
+import { default as default9 } from "./ocean-light@3x-FP7M2MO7.webp";
+import { default as default10 } from "./peachYogurt-dark@3x-UWHJTY5O.webp";
+import { default as default11 } from "./peachYogurt-light@3x-X7Y7NU2Y.webp";
+import { default as default12 } from "./sherbet-dark@3x-UAIXX4RP.webp";
+import { default as default13 } from "./sherbet-light@3x-2Q2EFFWE.webp";
+import { default as default14 } from "./spring-dark@3x-XU3GBWBF.webp";
+import { default as default15 } from "./spring-light@3x-EFV3QMVY.webp";
+import { default as default16 } from "./sunset-dark@3x-F25FUK74.webp";
+import { default as default17 } from "./sunset-light@3x-B5T3EVGS.webp";
+import { default as default18 } from "./xyo-dark@3x-N62LIF7V.webp";
+import { default as default19 } from "./xyo-light@3x-5S6CF5P4.webp";
+
+// src/helpers/NodePalettes.ts
+var OsPalettes = {
+  candy: {
+    darkModeWallpaper: default2,
+    lightModeWallpaper: default3,
+    nameCode: "candy",
+    readableName: "Candy"
+  },
+  candyApple: {
+    darkModeWallpaper: default4,
+    lightModeWallpaper: default5,
+    nameCode: "candyApple",
+    readableName: "Candy Apple"
+  },
+  moss: {
+    darkModeWallpaper: default6,
+    lightModeWallpaper: default7,
+    nameCode: "moss",
+    readableName: "Moss"
+  },
+  ocean: {
+    darkModeWallpaper: default8,
+    lightModeWallpaper: default9,
+    nameCode: "ocean",
+    readableName: "Ocean"
+  },
+  peachYogurt: {
+    darkModeWallpaper: default10,
+    lightModeWallpaper: default11,
+    nameCode: "peachYogurt",
+    readableName: "Peach Yogurt"
+  },
+  sherbet: {
+    darkModeWallpaper: default12,
+    lightModeWallpaper: default13,
+    nameCode: "sherbet",
+    readableName: "Sherbet"
+  },
+  spring: {
+    darkModeWallpaper: default14,
+    lightModeWallpaper: default15,
+    nameCode: "spring",
+    readableName: "Spring"
+  },
+  sunset: {
+    darkModeWallpaper: default16,
+    lightModeWallpaper: default17,
+    nameCode: "sunset",
+    readableName: "Sunset"
+  },
+  xyo: {
+    darkModeWallpaper: default18,
+    lightModeWallpaper: default19,
+    nameCode: "xyo",
+    readableName: "XYO"
+  }
+};
+var getNodePaletteByNameCode = (nameCode) => {
+  const castNameCode = nameCode;
+  return OsPalettes[castNameCode];
+};
+
+// src/helpers/widget/Caller.tsx
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { cloneDeep } from "@xylabs/lodash";
+import { fulfilled, rejected } from "@xylabs/promise";
+import { WidgetTraySchema } from "@xyo-network/os-model";
+import { OsCallerBase } from "@xyo-network/os-runtime";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WidgetCaller = class extends OsCallerBase {
+  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 assertEx3(this._registeredDappSets, () => "Registered Dapp Sets not available");
+  }
+  get widgetTrayLayout() {
+    return assertEx3(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 = assertEx3((await archivist.get([config2.configHash]))?.[0], () => `Config - ${config2.configHash} not found`);
+          payload = foundConfig;
+        }
+        return Param ? /* @__PURE__ */ jsx4(Param, { payload }) : void 0;
+      })
+    );
+    const successfulResults = results.filter(fulfilled).map((result) => result.value);
+    const failedResults = results.filter(rejected).map((result) => new Error(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 cloneDeep(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/helpers/widgets/UpperWidgetTrayLayout.ts
+import { WidgetTrayLayoutSchema } from "@xyo-network/os-model";
+var UpperWidgetTrayLayout = {
+  label: "Lower Widget Tray Layout",
+  layout: [
+    { dappId: "TimeClock", mode: "FlatClock" },
+    {
+      configHash: "bb0ea5701c20e86d77b1a369f77d17658df62572d54f1f1aafdf15e3c29e3b3b",
+      dappId: "Markets",
+      mode: "PriceWidget"
+    },
+    {
+      configHash: "ea8afca9d4a9b0843035e3722d9f6400058a1eab71996b8e4e20e2449662e2bf",
+      dappId: "Markets",
+      mode: "PriceWidget"
+    }
+  ],
+  schema: WidgetTrayLayoutSchema
+};
+
+// src/hooks/os/useWidgetDapps.tsx
+var useWidgetDapps = (registeredDapps, widgetTrayLayout) => {
+  const context = useXyOsUiContext();
+  return usePromise8(async () => {
+    if (registeredDapps && context && widgetTrayLayout) {
+      const caller = new WidgetCaller(context, registeredDapps, widgetTrayLayout);
+      return await caller.buildWidgetComponents();
+    }
+  }, [context, registeredDapps, widgetTrayLayout]);
+};
+
+// src/hooks/useAccountArchivist.ts
+import { useWeakArchivistFromNode as useWeakArchivistFromNode4 } from "@xyo-network/react-archivist";
+var useAccountArchivist = () => {
+  return useWeakArchivistFromNode4("AccountArchivist");
+};
+
+// src/hooks/useDappCaller.tsx
+import { DappCaller } from "@xyo-network/os-runtime";
+import { useMemo as useMemo5 } from "react";
+var useDappCaller = (context) => {
+  const xyOs = useXyOsUiContext();
+  return useMemo5(() => {
+    const resolvedContext = context ?? xyOs;
+    if (resolvedContext) {
+      return new DappCaller(resolvedContext);
+    }
+  }, [context, xyOs]);
+};
+
+// src/hooks/useDappIntentCaller.tsx
+import { assertEx as assertEx4 } from "@xylabs/assert";
+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 = assertEx4(xyOsContext ?? xyOs, () => "no node was found in context or passed as argument");
+      return new DappIntentCaller(context);
+    }
+  }, [xyOsContext, xyOs]);
+};
+
+// src/hooks/useDebugClick.tsx
+import {
+  useCallback as useCallback4,
+  useEffect as useEffect10,
+  useRef as useRef2,
+  useState as useState7
+} from "react";
+import { useNavigate as useNavigate2, useSearchParams } from "react-router-dom";
+var useDebugClick = () => {
+  const [params, setParams] = useSearchParams();
+  const [debugOpen, setDebugOpen] = useState7(false);
+  const openFromClick = useRef2(false);
+  const closeFromClick = useRef2(false);
+  const initialized = useRef2(false);
+  const navigate = useNavigate2();
+  const openDebug = useCallback4(() => {
+    openFromClick.current = true;
+    closeFromClick.current = false;
+    setParams((params2) => {
+      params2.set("debug", "true");
+      return new URLSearchParams(params2);
+    });
+    setDebugOpen(true);
+  }, [setParams]);
+  const closeDebug = useCallback4(() => {
+    openFromClick.current = false;
+    closeFromClick.current = true;
+    initialized.current = false;
+    navigate(-1);
+    setDebugOpen(false);
+  }, [navigate]);
+  useEffect10(() => {
+    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/hooks/useDetectCustomer.tsx
+var CustomerParams = [
+  { key: "utm_source", value: "coin" },
+  {
+    key: "receipt",
+    matches: "*",
+    value: "receiptHash"
+  }
+];
+var useDetectCustomer = () => {
+  return CustomerParams.find((customerParamSet) => {
+    const searchParams = new URLSearchParams(window.location.search);
+    const searchParamValue = searchParams.get(customerParamSet.key);
+    if (searchParams.has(customerParamSet.key) && customerParamSet.matches === "*") {
+      return true;
+    }
+    return searchParamValue && searchParamValue === customerParamSet.value;
+  });
+};
+
+// src/hooks/useExposedNode.ts
+var useExposedNode = () => {
+  const xyOS = useXyOsUiContext();
+  return xyOS?.exposedNode;
+};
+
+// src/hooks/useOsSettingsCaller.tsx
+import { assertEx as assertEx6 } from "@xylabs/assert";
+import { OsSettingsCaller, OsSettingsReadyEvent } from "@xyo-network/os-runtime";
+import { useMemo as useMemo7 } from "react";
+
+// src/hooks/useStackReady.tsx
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { EventBusPubSubConnection as EventBusPubSubConnection2 } from "@xyo-network/os-runtime";
+import { useEffect as useEffect11, useState as useState8 } from "react";
+var useStackReady = (stackReadyEvent, stackName, context) => {
+  const providedContext = useXyOsUiContext();
+  const [stackReady, setStackReady] = useState8({ ready: false });
+  useEffect11(() => {
+    const derivedContext = context ?? providedContext;
+    const listener = () => {
+      if (!derivedContext) throw new Error("no context found");
+      const stack = assertEx5(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);
+    if (derivedContext) {
+      derivedContext.eventBus.addConnection(stackReadyReadyConnection);
+      const stack = derivedContext.getStack(stackName);
+      if (stack.initialized) setStackReady({ ready: true, stack: stack.stack });
+    }
+    return () => {
+      const derivedContext2 = context ?? providedContext;
+      if (derivedContext2 && stackReadyReadyConnection._id) {
+        derivedContext2.eventBus.removeConnection(stackReadyReadyConnection.id);
+      }
+    };
+  }, [context, providedContext]);
+  return stackReady;
+};
+
+// src/hooks/useOsSettingsCaller.tsx
+var useOsSettingsCaller = (context) => {
+  const providedContext = useXyOsUiContext();
+  const { ready } = useStackReady(OsSettingsReadyEvent, "osSettingsStack", providedContext);
+  return useMemo7(() => {
+    if (providedContext || context || ready) {
+      const derivedNode = assertEx6(context ?? providedContext, () => "no node was found in context or passed as argument");
+      return new OsSettingsCaller(derivedNode);
+    }
+  }, [context, providedContext]);
+};
+
+// src/hooks/usePhraseFile.tsx
+import { usePromise as usePromise9 } from "@xylabs/react-promise";
+import { buildUserWalletSeedPhrasePayload } from "@xyo-network/os-runtime";
+import { useMemo as useMemo8 } from "react";
+var usePhraseFile = (phrase) => {
+  const [payloadAndRootHash] = usePromise9(async () => phrase ? await buildUserWalletSeedPhrasePayload(phrase) : void 0, [phrase]);
+  const filename = useMemo8(() => `xyo-phrase-${payloadAndRootHash?.rootHash}.json`, [payloadAndRootHash?.rootHash]);
+  const { phraseFile, phraseFileError } = useMemo8(() => {
+    const payload = payloadAndRootHash?.payload;
+    if (payload) {
+      try {
+        const data = new Blob([JSON.stringify(payload, null, 2)], { type: "text/plain" });
+        return { phraseFile: window.URL.createObjectURL(data) };
+      } catch (e) {
+        return { phraseFileError: e };
+      }
+    } else {
+      return {};
+    }
+  }, [payloadAndRootHash]);
+  return {
+    filename,
+    payload: payloadAndRootHash?.payload,
+    phraseFile,
+    phraseFileError
+  };
+};
+
+// src/hooks/useTabs.ts
+import { useLocation as useLocation2, useNavigate as useNavigate3 } from "react-router-dom";
+var useTabs = () => {
+  const location2 = useLocation2();
+  const navigate = useNavigate3();
+  const rootFolder = location2.pathname.split("/")[1];
+  const tab = rootFolder?.length > 0 ? rootFolder : "node";
+  const setTab = (tab2) => {
+    navigate(`/${tab2}`);
+  };
+  return [tab, setTab];
+};
+
+// src/modules/Dapp/lib/DefaultIconSize.ts
+var DEFAULT_ICON_SIZE = 84;
+
+// src/modules/Dapp/Button/LaunchFrame.tsx
+import { useTheme as useTheme2 } from "@mui/material";
+import {
+  animated,
+  config,
+  useSpring
+} from "@react-spring/web";
+import { forwardRef, useMemo as useMemo9 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var DappLaunchFrame = forwardRef(({
+  bgColor,
+  children,
+  id,
+  launchLeft,
+  open,
+  launchTop
+}, ref) => {
+  const theme = useTheme2();
+  const frameOpenSpringConfig = useMemo9(
+    () => ({
+      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__ */ jsx5("div", { id, ref, children: /* @__PURE__ */ jsx5(
+    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__ */ jsx5(
+        animated.div,
+        {
+          id: "dapp-launch-frame-transition-scale",
+          style: {
+            ...scaleProps,
+            alignItems: "start",
+            background: bgColor ?? theme.palette.background.default,
+            display: "flex",
+            height: "100%",
+            justifyContent: "start",
+            transform,
+            width: "100%"
+          },
+          children
+        }
+      )
+    }
+  ) });
+});
+DappLaunchFrame.displayName = "DappLaunchFrame";
+
+// 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 { alpha as alpha2, styled } from "@mui/material";
+import { ButtonEx as ButtonEx3 } from "@xylabs/react-button";
+import { TypographyEx } from "@xyo-network/react-shared";
+import { forwardRef as forwardRef2 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var ForwardedRefButtonEx = forwardRef2((props, ref) => {
+  return /* @__PURE__ */ jsx6("span", { ref, children: /* @__PURE__ */ jsx6(ButtonEx3, { ...props }) });
+});
+ForwardedRefButtonEx.displayName = "ForwardedRefButtonEx";
+var borderRadiusFactor = 1.5;
+var StyledDappIconButtonEx = styled(ForwardedRefButtonEx, {
+  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: alpha2(theme.palette.background.paper, 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": alpha2(theme.palette.background.paper, 0.5),
+    "borderRadius": theme.spacing(borderRadiusFactor),
+    "color": theme.palette.text.primary,
+    "position": "relative",
+    "transition": "transform 0.15s linear"
+  };
+});
+var StyledDappName = styled(TypographyEx, { name: "StyledDappName" })(({ theme }) => ({
+  // WebkitBoxOrient: 'vertical',
+  WebkitLineClamp: 2,
+  color: theme.palette.text.primary,
+  flexWrap: "wrap",
+  fontWeight: 700,
+  letterSpacing: "-0.5px",
+  lineClamp: 2,
+  textAlign: "center",
+  textOverflow: "ellipsis",
+  textShadow: `1px 1px 3px ${alpha2(theme.palette.common.black, 0.3)}`,
+  whiteSpace: "initial",
+  wordWrap: "break-word"
+}));
+var StyledDefaultDappIcon = styled(TypographyEx, { name: "StyledDappName" })(() => ({ lineHeight: 1 }));
+
+// src/modules/Dapp/Button/IconEx.tsx
+import { jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
+var DappIconButton = ({
+  children,
+  dappIcon,
+  dappIconSvg,
+  dappName,
+  ...props
+}) => {
+  const {
+    DappIconSize,
+    color,
+    nonSxProps,
+    sx
+  } = decomposeProps(dappIcon, props);
+  const iconSize = DEFAULT_ICON_SIZE;
+  const sendIntent = useSendDappIntent();
+  const { dappIntentType: intentType } = useDappIntentListener(dappName);
+  const iconButtonRef = useRef3(null);
+  const { left: launchLeft, top: launchTop } = useLaunchPoint(iconButtonRef);
+  const minimized = intentType === DappIntentTypes5.Minimize;
+  const MiddleEllipsisFunction = (str) => {
+    if (str && str.length > 25) {
+      console.log(str);
+      console.log(str.slice(0, 15));
+      console.log(str.slice(-10, str.length - 10 + str.length));
+      return str.slice(0, 15) + "..." + str.slice(-7, str.length - 7 + str.length);
+    }
+    return str;
+  };
+  const onClickIcon = () => {
+    XyOsMonitor2.trackEvent("Launch dApp", { "Dapp Name": `${dappName}` });
+    sendIntent?.(DappIntentCaller2.buildIntent(DappIntentCaller2.OsDappName, DappIntentTypes5.Launch, dappName)).catch(console.error);
+  };
+  return /* @__PURE__ */ jsxs2(FlexCol2, { alignItems: "stretch", justifyContent: "stretch", children: [
+    /* @__PURE__ */ jsx7(DappLaunchFrame, { id: "dapp-launch-frame", open: intentType === DappIntentTypes5.Launch, launchLeft, launchTop, children }),
+    /* @__PURE__ */ jsxs2(
+      "span",
+      {
+        style: { cursor: "pointer" },
+        onClick: onClickIcon,
+        children: [
+          /* @__PURE__ */ jsx7(
+            StyledDappIconButtonEx,
+            {
+              iconBgBaseColor: color,
+              ref: iconButtonRef,
+              sx: {
+                height: iconSize,
+                mb: 0.75,
+                width: iconSize,
+                ...sx
+              },
+              ...nonSxProps,
+              children: dappIconSvg ? /* @__PURE__ */ jsx7(RenderHtml, { htmlString: dappIconSvg }) : /* @__PURE__ */ jsx7(StyledDefaultDappIcon, { fontSize: DappIconSize, children: dappIcon?.name.at(0) })
+            }
+          ),
+          /* @__PURE__ */ jsxs2(FlexCol2, { gap: 0.25, children: [
+            /* @__PURE__ */ jsx7(StyledDappName, { variant: "body2", maxWidth: iconSize, children: MiddleEllipsisFunction(dappIcon?.name) }),
+            /* @__PURE__ */ jsx7(
+              Circle,
+              {
+                sx: {
+                  height: 8,
+                  opacity: minimized ? 1 : 0,
+                  transition: "opacity .5s"
+                }
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+
+// src/modules/Dapp/modules/Window/AppBar.tsx
+import {
+  ArrowDropDownCircleOutlined,
+  BugReport,
+  CancelOutlined
+} from "@mui/icons-material";
+import {
+  AppBar,
+  Box as Box2,
+  Divider,
+  IconButton as IconButton2,
+  Toolbar,
+  Tooltip as Tooltip2,
+  Typography as Typography2
+} from "@mui/material";
+import { FlexGrowRow as FlexGrowRow2 } from "@xylabs/react-flexbox";
+import { DarkModeIconButtonForColorScheme } from "@xylabs/react-invertible-theme";
+import { DappIntentTypes as DappIntentTypes6 } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller3 } from "@xyo-network/os-runtime";
+
+// src/modules/Dapp/Debug/Dialog.tsx
+import {
+  Dialog,
+  DialogActions,
+  DialogContent
+} from "@mui/material";
+import { ButtonEx as ButtonEx4 } 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, { height: "100%" })
+] });
+var DebugDialog = ({
+  closeDebug,
+  debugOpen,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs3(Dialog, { open: debugOpen, onClose: closeDebug, fullScreen: true, ...props, children: [
+    /* @__PURE__ */ jsx8(DialogContent, { children: /* @__PURE__ */ jsx8(LazyDebug, {}) }),
+    /* @__PURE__ */ jsx8(DialogActions, { children: /* @__PURE__ */ jsx8(ButtonEx4, { 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/AppBar.tsx
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+var EmptyDappBarForPadding = (props) => {
+  return /* @__PURE__ */ jsx9(
+    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__ */ jsx9(
+          Toolbar,
+          {
+            disableGutters: true,
+            sx: { paddingX: 2 },
+            children: /* @__PURE__ */ jsx9(Typography2, { noWrap: true, variant: "h5", letterSpacing: "-1px", fontWeight: "300", children: title })
+          }
+        ),
+        /* @__PURE__ */ jsx9(FlexGrowRow2, {}),
+        /* @__PURE__ */ jsxs4(
+          Toolbar,
+          {
+            disableGutters: true,
+            sx: { paddingX: 2 },
+            children: [
+              /* @__PURE__ */ jsx9(
+                IconButton2,
+                {
+                  onClick: openDebug,
+                  sx: { display: { md: "none", xs: "flex" } },
+                  children: /* @__PURE__ */ jsx9(BugReport, {})
+                }
+              ),
+              /* @__PURE__ */ jsx9(
+                Tooltip2,
+                {
+                  title: "Toggle Light/Dark Mode",
+                  sx: { display: { md: "none", xs: "flex" } },
+                  children: /* @__PURE__ */ jsx9(Box2, { children: /* @__PURE__ */ jsx9(DarkModeIconButtonForColorScheme, { defaultLightModeColor: "warning" }) })
+                }
+              ),
+              /* @__PURE__ */ jsx9(
+                Divider,
+                {
+                  orientation: "vertical",
+                  flexItem: true,
+                  sx: {
+                    display: { md: "none", xs: "flex" },
+                    m: 1
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx9(Tooltip2, { title: "Minimize", children: /* @__PURE__ */ jsx9(
+                IconButton2,
+                {
+                  onClick: () => {
+                    sendIntent?.(DappIntentCaller3.buildIntent(DappIntentCaller3.OsDappName, DappIntentTypes6.Minimize, name))?.catch(console.error);
+                  },
+                  children: /* @__PURE__ */ jsx9(ArrowDropDownCircleOutlined, { htmlColor: "inherit" })
+                }
+              ) }),
+              /* @__PURE__ */ jsx9(Tooltip2, { title: "Close", children: /* @__PURE__ */ jsx9(
+                IconButton2,
+                {
+                  onClick: () => {
+                    sendIntent?.(DappIntentCaller3.buildIntent(DappIntentCaller3.OsDappName, DappIntentTypes6.Close, name))?.catch(console.error);
+                  },
+                  children: /* @__PURE__ */ jsx9(CancelOutlined, { htmlColor: "inherit" })
+                }
+              ) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx9(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 jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
+var DappChromeSmall = ({
+  appBar,
+  children,
+  screenMenu,
+  splashScreen,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs5(FlexCol4, { alignItems: "stretch", id: "dapp-chrome-container-small", ...props, children: [
+    splashScreen,
+    /* @__PURE__ */ jsxs5(
+      FlexGrowCol,
+      {
+        alignItems: "stretch",
+        id: "dapp-chrome-small",
+        justifyContent: "start",
+        sx: { background: (theme) => theme.palette.background.default },
+        children: [
+          appBar,
+          /* @__PURE__ */ jsx10(
+            FlexGrowCol,
+            {
+              sx: { overflowY: "auto" },
+              alignItems: "stretch",
+              children
+            }
+          ),
+          screenMenu
+        ]
+      }
+    )
+  ] });
+};
+var DappChromeLarge = ({
+  appBar,
+  children,
+  screenMenu,
+  splashScreen,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs5(FlexRow2, { alignItems: "stretch", id: "dapp-chrome-container-large", ...props, children: [
+    splashScreen,
+    screenMenu,
+    /* @__PURE__ */ jsxs5(
+      FlexGrowCol,
+      {
+        alignItems: "stretch",
+        id: "dapp-chrome-large",
+        justifyContent: "start",
+        sx: { background: (theme) => theme.palette.background.default },
+        children: [
+          appBar,
+          /* @__PURE__ */ jsx10(
+            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__ */ jsx10(DappChromeLarge, { screenMenu: largeScreenMenu, ...props }) : /* @__PURE__ */ jsx10(DappChromeSmall, { screenMenu: smallScreenMenu, ...props });
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/DefaultComingSoon.tsx
+import {
+  alpha as alpha3,
+  Card as Card2,
+  CardContent as CardContent3,
+  Chip,
+  Container,
+  Divider as Divider2,
+  Typography as Typography4,
+  useTheme as useTheme5
+} from "@mui/material";
+import { FlexGrowCol as FlexGrowCol3, FlexRow as FlexRow5 } from "@xylabs/react-flexbox";
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/InstallButtonSection.tsx
+import { ButtonEx as ButtonEx5 } from "@xylabs/react-button";
+import { FlexRow as FlexRow3 } from "@xylabs/react-flexbox";
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+var InstallButtonSection = ({
+  installLink = "",
+  notificationLink = "https://xyo.network/newsletter",
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs6(
+    FlexRow3,
+    {
+      width: "100%",
+      gap: 1,
+      sx: {
+        alignItems: "flex-start",
+        flexDirection: { md: "row", xs: "column" }
+      },
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx11(ButtonEx5, { fullWidth: true, variant: "contained", disabled: true, href: installLink, children: "Install" }),
+        /* @__PURE__ */ jsx11(ButtonEx5, { 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 as CardContent2,
+  Typography as Typography3,
+  useTheme as useTheme4
+} from "@mui/material";
+import {
+  FlexGrowCol as FlexGrowCol2,
+  FlexGrowRow as FlexGrowRow4,
+  FlexRow as FlexRow4
+} from "@xylabs/react-flexbox";
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/DeveloperLinkSection.tsx
+import { useTheme as useTheme3 } from "@mui/material";
+import { FlexGrowRow as FlexGrowRow3 } from "@xylabs/react-flexbox";
+import { LinkEx } from "@xylabs/react-link";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var DeveloperLinkSection = ({ developerLink = "https://xylabs.com", ...props }) => {
+  const theme = useTheme3();
+  return /* @__PURE__ */ jsx12(
+    FlexGrowRow3,
+    {
+      gap: 1,
+      sx: {
+        alignItems: "flex-start",
+        flexDirection: { md: "row", xs: "column" }
+      },
+      ...props,
+      children: /* @__PURE__ */ jsx12(LinkEx, { color: theme.palette.info.main, href: developerLink, target: "_blank", children: developerLink })
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/SummarySection.tsx
+import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
+var SummarySection = ({
+  name,
+  dappIconSvg,
+  version = "1.0",
+  developerLink = "https://xylabs.com"
+}) => {
+  const theme = useTheme4();
+  return /* @__PURE__ */ jsx13(Card, { sx: { width: "100%" }, children: /* @__PURE__ */ jsx13(CardContent2, { children: /* @__PURE__ */ jsx13(
+    FlexRow4,
+    {
+      gap: 3,
+      alignItems: "flex-start",
+      sx: { flexDirection: "column", width: "100%" },
+      children: /* @__PURE__ */ jsxs7(
+        FlexGrowRow4,
+        {
+          sx: { gap: { md: 2, xs: 1 } },
+          alignItems: "flex-start",
+          children: [
+            /* @__PURE__ */ jsx13(Card, { elevation: 0, variant: "outlined", children: /* @__PURE__ */ jsx13(CardContent2, { children: dappIconSvg ? /* @__PURE__ */ jsx13(RenderHtml, { htmlString: dappIconSvg }) : null }) }),
+            /* @__PURE__ */ jsxs7(FlexGrowCol2, { alignItems: "flex-start", children: [
+              /* @__PURE__ */ jsxs7(FlexGrowCol2, { alignItems: "flex-start", children: [
+                /* @__PURE__ */ jsx13(
+                  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(FlexGrowRow4, { gap: 0.5, alignItems: "center", justifyContent: "center", children: [
+                /* @__PURE__ */ jsx13(VerifiedRounded, { color: "success", fontSize: "small" }),
+                /* @__PURE__ */ jsx13(Typography3, { variant: "body1", color: theme.palette.success.main, children: "XY Labs" })
+              ] }),
+              developerLink ? /* @__PURE__ */ jsx13(DeveloperLinkSection, { developerLink }) : null
+            ] })
+          ]
+        }
+      )
+    }
+  ) }) });
+};
+
+// src/modules/Dapp/modules/Window/components/DefaultComingSoon/DefaultComingSoon.tsx
+import { jsx as jsx14, 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 = useTheme5();
+  return /* @__PURE__ */ jsxs8(
+    Container,
+    {
+      maxWidth: "md",
+      sx: {
+        minHeight: "100%",
+        overflow: "auto",
+        paddingTop: 2,
+        width: "100%"
+      },
+      children: [
+        version ? null : /* @__PURE__ */ jsx14(FlexRow5, { width: "100%", paddingBottom: 2, children: /* @__PURE__ */ jsx14(
+          Chip,
+          {
+            label: "This app is not yet publicly available on xyOS",
+            sx: {
+              backgroundColor: alpha3(theme.palette.info.main, 0.2),
+              color: theme.palette.info.main,
+              width: "100%"
+            }
+          }
+        ) }),
+        /* @__PURE__ */ jsx14(FlexGrowCol3, { width: "100%", alignItems: "flex-start", minHeight: "100%", children: /* @__PURE__ */ jsxs8(FlexGrowCol3, { width: "100%", alignItems: "stretch", justifyContent: "flex-start", gap: 2, children: [
+          /* @__PURE__ */ jsx14(SummarySection, { dappIconSvg, name, version, developerLink }),
+          /* @__PURE__ */ jsx14(InstallButtonSection, {}),
+          /* @__PURE__ */ jsx14(Divider2, { flexItem: true }),
+          /* @__PURE__ */ jsx14(Card2, { children: /* @__PURE__ */ jsx14(CardContent3, { children: /* @__PURE__ */ jsxs8(FlexGrowCol3, { 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__ */ jsx14(Typography4, { gutterBottom: true, paddingBottom: 1, variant: "body1", children: paragraph }, index);
+            })
+          ] }) }) }),
+          children
+        ] }) })
+      ]
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/DappWindow.tsx
+import { FlexCol as FlexCol9 } from "@xylabs/react-flexbox";
+import { NameTransforms as NameTransforms4 } from "@xyo-network/os-runtime";
+import { ErrorBoundary, ErrorRender as ErrorRender3 } from "@xyo-network/react-error";
+import { NodeProvider as NodeProvider2 } from "@xyo-network/react-node";
+import { WalletProvider } from "@xyo-network/react-wallet";
+import { useMemo as useMemo12 } from "react";
+import { Helmet } from "react-helmet";
+
+// src/modules/XyOsUi/contexts/XyOsUiContext.ts
+import { createContext, useContext } from "react";
+var XyOsUiContext = createContext(void 0);
+var useXyOsUiContext = () => {
+  return useContext(XyOsUiContext);
+};
+var XyOsUiContextProvider = XyOsUiContext.Provider;
+
+// src/modules/XyOsUi/lib/XyOsUi.ts
+import { forget } from "@xylabs/forget";
+import { ModuleFactoryLocator as ModuleFactoryLocator2 } from "@xyo-network/module-factory-locator";
+import { dappsReadyConnection, XyOs } from "@xyo-network/os-runtime";
+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/Dapp/modules/access-interface/components/Dialog.tsx
+import { ArrowForward } from "@mui/icons-material";
+import {
+  Alert,
+  Button,
+  Dialog as Dialog2,
+  DialogActions as DialogActions2,
+  DialogContent as DialogContent2,
+  DialogTitle,
+  Typography as Typography5
+} from "@mui/material";
+import { FlexCol as FlexCol5, FlexRow as FlexRow6 } from "@xylabs/react-flexbox";
+import { RegisteredNames } from "@xyo-network/os-model";
+import { AccessNodeQueries } from "@xyo-network/os-runtime";
+import { ErrorRender } from "@xyo-network/react-error";
+import { useState as useState9 } from "react";
+import { jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
+var DappAccessDialog = ({
+  accessRequest,
+  children,
+  dappNode,
+  registeredDappAccess,
+  ...props
+}) => {
+  const [error, setError] = useState9();
+  const [noPayloadsInserted, setNoPayloadsInserted] = useState9(false);
+  const onClose = () => {
+    setNoPayloadsInserted(false);
+    props.onClose?.({}, "escapeKeyDown");
+  };
+  const handleAllow = async () => {
+    if (accessRequest && registeredDappAccess && dappNode) {
+      try {
+        switch (registeredDappAccess.name) {
+          case RegisteredNames: {
+            const accessNodeQueries = new AccessNodeQueries(dappNode, accessRequest, registeredDappAccess);
+            const payloads = await accessNodeQueries.run();
+            if (payloads.length === 0) {
+              setNoPayloadsInserted(true);
+            } else {
+              onClose();
+            }
+            return;
+          }
+          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__ */ jsxs9(Dialog2, { ...props, children: [
+    /* @__PURE__ */ jsx15(DialogTitle, { children: "Message from XYO OS" }),
+    /* @__PURE__ */ jsxs9(
+      DialogContent2,
+      {
+        dividers: true,
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: 3
+        },
+        children: [
+          /* @__PURE__ */ jsx15(ErrorRender, { error, scope: "DappAccessDialog" }),
+          /* @__PURE__ */ jsxs9(FlexCol5, { gap: 1, children: [
+            /* @__PURE__ */ jsx15(Typography5, { variant: "subtitle2", children: "dApp to dApp Access Request" }),
+            /* @__PURE__ */ jsxs9(FlexRow6, { gap: 1, children: [
+              /* @__PURE__ */ jsxs9(Typography5, { fontSize: 16, children: [
+                /* @__PURE__ */ jsx15("strong", { children: accessRequest?.requestingDappId }),
+                "\xA0"
+              ] }),
+              /* @__PURE__ */ jsx15(ArrowForward, {}),
+              /* @__PURE__ */ jsx15(Typography5, { fontSize: 16, children: /* @__PURE__ */ jsx15("strong", { children: registeredDappAccess?.registeringDappId }) })
+            ] })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs9(
+      DialogContent2,
+      {
+        dividers: true,
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: 3
+        },
+        children: [
+          /* @__PURE__ */ jsx15(FlexCol5, { gap: 1, children: /* @__PURE__ */ jsxs9(Typography5, { children: [
+            /* @__PURE__ */ jsx15("strong", { children: accessRequest?.requestingDappId }),
+            " ",
+            "dApp would like to access your",
+            /* @__PURE__ */ jsx15("strong", { children: registeredDappAccess?.name }),
+            " ",
+            "from",
+            " ",
+            /* @__PURE__ */ jsx15("strong", { children: registeredDappAccess?.registeringDappId }),
+            " ",
+            "dApp"
+          ] }) }),
+          noPayloadsInserted ? /* @__PURE__ */ jsxs9(Alert, { severity: "warning", children: [
+            registeredDappAccess?.name,
+            " ",
+            "Access Request did not find payloads to insert"
+          ] }) : null
+        ]
+      }
+    ),
+    children ? /* @__PURE__ */ jsx15(DialogContent2, { dividers: true, children }) : null,
+    /* @__PURE__ */ jsxs9(DialogActions2, { children: [
+      /* @__PURE__ */ jsx15(Button, { variant: "outlined", onClick: onClose, children: "Cancel" }),
+      /* @__PURE__ */ jsx15(Button, { variant: "contained", onClick: () => {
+        handleAllow().catch(console.error);
+      }, children: "Allow" })
+    ] })
+  ] });
+};
+
+// src/modules/Dapp/modules/access-interface/components/Flexbox.tsx
+import { ErrorRender as ErrorRender2 } from "@xyo-network/react-error";
+
+// src/modules/Dapp/modules/access-interface/hooks/useDialogState.tsx
+import { usePromise as usePromise10 } from "@xylabs/react-promise";
+import { isRegisteredDappAccess, RegisteredNames as RegisteredNames2 } from "@xyo-network/os-model";
+import { useState as useState10 } from "react";
+var useDialogState = (context) => {
+  const dappCaller = useDappCaller();
+  const { accessRequests } = DappAccessRequestResourceHooks.useResourceViewsFromContext(context);
+  const [openAccessDialog, setOpenAccessDialog] = useState10(false);
+  const [registeredInterface, setRegisteredInterface] = useState10();
+  const [, allowAccessDialogError] = usePromise10(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 jsx16 } from "react/jsx-runtime";
+var DappAccessFlexbox = ({ context }) => {
+  const {
+    accessRequests,
+    allowAccessDialogError,
+    openAccessDialog,
+    registeredInterface,
+    setOpenAccessDialog
+  } = useDialogState(context);
+  return /* @__PURE__ */ jsx16(
+    DappAccessDialog,
+    {
+      accessRequest: accessRequests?.[0],
+      dappNode: context,
+      open: openAccessDialog,
+      onClose: () => setOpenAccessDialog(false),
+      registeredDappAccess: registeredInterface,
+      children: allowAccessDialogError ? /* @__PURE__ */ jsx16(ErrorRender2, { error: allowAccessDialogError, scope: "DappAccessFlexbox" }) : null
+    }
+  );
+};
+
+// src/modules/Dapp/modules/Window/hooks/menu/useDappMenu.tsx
+import {
+  useEffect as useEffect12,
+  useRef as useRef4,
+  useState as useState11
+} from "react";
+import { useNavigate as useNavigate4, useParams as useParams2 } from "react-router-dom";
+
+// 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/useDappMenuResourceValues.tsx
+import { useMemo as useMemo10 } from "react";
+var useDappMenuDependencies = (context) => {
+  const {
+    menuConfigs,
+    menuItemSelections,
+    menuItemsVisible,
+    resourceError
+  } = DappMenuResourceHooks.useResourceViewsFromContext(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.tsx
+var useDappMenu = (context, dappName) => {
+  const [error, setError] = useState11();
+  const params = useParams2();
+  const navigate = useNavigate4();
+  const {
+    defaultPath,
+    menuConfigs,
+    menuItemsVisible,
+    menuSelection,
+    resourceError
+  } = useDappMenuDependencies(context);
+  const activePath = menuSelection ?? defaultPath;
+  const currentPathRef = useRef4();
+  useEffect12(() => {
+    if (params && currentPathRef.current === void 0) {
+      currentPathRef.current = params.path ?? "";
+    }
+  }, []);
+  useEffect12(() => {
+    if (context === null) {
+      currentPathRef.current = void 0;
+    }
+  }, [context]);
+  useEffect12(() => {
+    if (menuSelection) {
+      currentPathRef.current = menuSelection;
+    }
+  }, [menuSelection]);
+  useEffect12(() => {
+    if (resourceError) setError(resourceError);
+  }, [resourceError]);
+  const onPathChange = (path) => {
+    const pathIsInUnchanged = DappPathHelpers.detectDuplicateSelections(currentPathRef.current, path, defaultPath);
+    if (pathIsInUnchanged) return;
+    const destinationPath = DappPathHelpers.deriveDestinationPath(path, defaultPath, dappName);
+    navigate(destinationPath);
+    currentPathRef.current = path;
+  };
+  return {
+    activePath,
+    error,
+    menuConfig: menuConfigs?.[0],
+    menuItemsVisible,
+    onPathChange
+  };
+};
+
+// src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappInjectableParamsFromRoute.tsx
+import { assertEx as assertEx7 } from "@xylabs/assert";
+import { usePromise as usePromise11 } from "@xylabs/react-promise";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { isDappInjectableParams } from "@xyo-network/os-model";
+import { DappCaller as DappCaller2 } from "@xyo-network/os-runtime";
+import {
+  useNavigate as useNavigate5,
+  useParams as useParams3,
+  useSearchParams as useSearchParams2
+} from "react-router-dom";
+var useManageDappInjectableParamsFromRoute = (context) => {
+  const [queryParams] = useSearchParams2();
+  const params = useParams3();
+  const navigate = useNavigate5();
+  const [, callerError] = usePromise11(async () => {
+    if (context && (params || queryParams)) {
+      const dappCaller = new DappCaller2(context);
+      const pathname = window.location.pathname;
+      await dappCaller.setDappInjectableRouteParams(queryParams, pathname);
+    }
+  }, [context, queryParams, params]);
+  const [, listenerError] = usePromise11(async () => {
+    let archivist;
+    const listener = ({ payloads }) => {
+      const injectableParams = payloads.find(isDappInjectableParams);
+      if (injectableParams && context) {
+        const pathname = window.location.pathname;
+        if (pathname !== injectableParams.path) {
+          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");
+        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 { DappIntentTypes as DappIntentTypes7, isDappIntent } from "@xyo-network/os-model";
+import { DappIntentCaller as DappIntentCaller4 } from "@xyo-network/os-runtime";
+import { useEffect as useEffect13, useState as useState12 } from "react";
+var useManageDappIntentRequest = (context, dappId) => {
+  const dappCaller = useDappCaller(context);
+  const sendIntent = useSendDappIntent();
+  const [intentPayload, setIntentPayload] = useState12();
+  const [handleIntentError, setHandleIntentError] = useState12();
+  const [dappArchivist, setDappArchivist] = useState12();
+  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 = DappIntentCaller4.buildIntent(DappIntentCaller4.OsDappName, DappIntentTypes7.Minimize, dappId);
+          await sendIntent(minimizeIntent);
+          await sendIntent(intentPayload);
+        } catch (e) {
+          console.error(e);
+          setHandleIntentError(e);
+        }
+        setIntentPayload(void 0);
+      }
+    },
+    [context, dappId, intentPayload, sendIntent]
+  );
+  useEffect13(() => {
+    const listener = ({ payloads }) => {
+      if (context) {
+        const intentPayload2 = payloads.find(isDappIntent);
+        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 useCallback5,
+  useEffect as useEffect14,
+  useRef as useRef5
+} from "react";
+import { useNavigate as useNavigate6, useParams as useParams4 } from "react-router-dom";
+var useManageDappPathFromRoute = (context, dappName) => {
+  const params = useParams4();
+  const { path: pathParam } = params;
+  const dappMenuCaller = useDappMenuCaller(context, { ignoreProvidedNode: true });
+  const { menuSelection, defaultPath } = useDappMenuDependencies(context);
+  const navigate = useNavigate6();
+  const currentPathRef = useRef5();
+  const updateMenuArchivist = useCallback5(
+    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]
+  );
+  useEffect14(() => {
+    if (context && menuSelection) {
+      const pathIsInUnchanged = DappPathHelpers.detectDuplicateSelections(currentPathRef.current ?? "", menuSelection, defaultPath);
+      if (pathIsInUnchanged) return;
+      const destinationPath = DappPathHelpers.deriveDestinationPath(menuSelection, defaultPath, dappName);
+      navigate(destinationPath);
+      currentPathRef.current = menuSelection === defaultPath ? void 0 : menuSelection;
+    }
+  }, [dappName, context, defaultPath, menuSelection]);
+  usePromise13(async () => {
+    if (context && pathParam !== currentPathRef.current) {
+      await updateMenuArchivist(pathParam);
+      currentPathRef.current = pathParam;
+    }
+  }, [context, pathParam, updateMenuArchivist]);
+};
+
+// 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 DappIntentCaller5, NameTransforms as NameTransforms3 } from "@xyo-network/os-runtime";
+import { useNavigationType, useParams as useParams5 } from "react-router-dom";
+var useManageDappStateFromRoute = (intentPayload, dappName) => {
+  const params = useParams5();
+  const { dappName: dappNameParam } = params;
+  const sendIntent = useSendDappIntent();
+  const navigationType = useNavigationType();
+  const intentCaller = useDappIntentCaller();
+  usePromise14(async () => {
+    const launched = intentPayload?.intent === DappIntentTypes8.Launch;
+    if (launched && dappNameParam === void 0 && sendIntent && navigationType === "POP") {
+      const closeIntent = DappIntentCaller5.buildIntent(DappIntentCaller5.OsDappName, DappIntentTypes8.Close, dappName);
+      await sendIntent(closeIntent);
+    }
+  }, [dappName, dappNameParam, intentPayload, navigationType, sendIntent]);
+  usePromise14(async () => {
+    if (dappNameParam && dappName && sendIntent && intentCaller) {
+      const dappNameParamDeSlugged = new NameTransforms3(dappNameParam).deSlug();
+      const notLaunched = intentPayload?.intent !== DappIntentTypes8.Launch;
+      const paramMatchesDappName = dappNameParamDeSlugged === dappName;
+      if (notLaunched && paramMatchesDappName) {
+        const latestIntent = await intentCaller.latestIntent();
+        const existing = latestIntent && latestIntent.targetDappId === dappNameParamDeSlugged;
+        if (!existing) {
+          const launchIntent = DappIntentCaller5.buildIntent(DappIntentCaller5.OsDappName, DappIntentTypes8.Launch, dappNameParamDeSlugged);
+          await sendIntent(launchIntent);
+          return;
+        }
+      }
+    }
+  }, [dappNameParam, dappName, sendIntent, intentCaller, intentPayload?.intent]);
+};
+
+// src/modules/Dapp/modules/Window/hooks/route/useManageDappBasedOffRoute.tsx
+var useManageDappBasedOffRoute = (intentPayload, dappName, context) => {
+  const handleIntentError = useManageDappIntentRequest(context, dappName);
+  useManageDappStateFromRoute(intentPayload, dappName);
+  useManageDappPathFromRoute(context, dappName);
+  const injectableErrors = useManageDappInjectableParamsFromRoute(context);
+  return [...injectableErrors, handleIntentError];
+};
+
+// src/modules/Dapp/modules/Window/hooks/useDappState.tsx
+import { DappIntentTypes as DappIntentTypes9 } from "@xyo-network/os-model";
+var useDappState = (intentType, context) => {
+  const minimized = intentType === DappIntentTypes9.Minimize;
+  const open = intentType === DappIntentTypes9.Launch;
+  const active = context && open;
+  return {
+    active,
+    minimized,
+    open
+  };
+};
+
+// 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 jsx17 } from "react/jsx-runtime";
+var NodeManifest = () => {
+  const [node] = useProvidedNode();
+  const [nodeManifest] = usePromise15(async () => await node?.manifest(3), [node]);
+  return /* @__PURE__ */ jsx17(Fragment, { children: node ? /* @__PURE__ */ jsx17("pre", { children: JSON.stringify(nodeManifest, null, 2) }) : null });
+};
+
+// src/modules/Dapp/modules/Window/hooks/useDecomposeDappSet.tsx
+var useDecomposeDappSet = (dappSet) => {
+  const { dapp } = dappSet ?? {};
+  const DappComponent = 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/useSkipLoadingScreen.tsx
+import { useMemo as useMemo11 } from "react";
+import { useSearchParams as useSearchParams3 } from "react-router-dom";
+var PARAMS_TO_TARGET = ["username", "utm_source"];
+var useSkipLoadingScreen = () => {
+  const [params] = useSearchParams3();
+  const customer = useDetectCustomer();
+  return useMemo11(() => {
+    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 useWeakArchivistFromNode5 } from "@xyo-network/react-archivist";
+var useSyncOsRegisteredAccessInterfaces = (context) => {
+  const [registeredInterfacesArchivist] = useWeakArchivistFromNode5("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/LoadingFlexbox.tsx
+import {
+  Fade,
+  styled as styled2,
+  Typography as Typography6
+} from "@mui/material";
+import { FlexCol as FlexCol7 } from "@xylabs/react-flexbox";
+import { useEffect as useEffect15, useState as useState14 } from "react";
+
+// src/modules/LoadingOsLogo/LoadingOsLogo.tsx
+import { FlexCol as FlexCol6 } from "@xylabs/react-flexbox";
+import { useState as useState13 } from "react";
+
+// src/modules/LoadingOsLogo/img/index.ts
+import { default as default20 } from "./xyoOS-Icon-2Q4XCUPP.svg";
+
+// src/modules/LoadingOsLogo/LoadingOsLogo.tsx
+import { jsx as jsx18 } from "react/jsx-runtime";
+var LoadingOsLogo = ({
+  widthInPixels,
+  busy,
+  spinsPerSecond = 0.5,
+  ...props
+}) => {
+  const [imageLoaded, setImageLoaded] = useState13(false);
+  if (!imageLoaded) {
+    const img = new Image();
+    img.addEventListener("load", () => setImageLoaded(true));
+    img.src = default20;
+  }
+  return imageLoaded ? /* @__PURE__ */ jsx18(
+    FlexCol6,
+    {
+      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__ */ jsx18(
+        FlexCol6,
+        {
+          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__ */ jsx18("img", { src: default20, height: widthInPixels ?? 22 })
+        }
+      )
+    }
+  ) : null;
+};
+
+// src/modules/Dapp/modules/Window/Trail.tsx
+import { a, useTrail } from "@react-spring/web";
+import React8 from "react";
+import { jsx as jsx19 } from "react/jsx-runtime";
+var TextTrail = ({ open, children }) => {
+  const items = React8.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__ */ jsx19("div", { children: trail.map(({ height, ...style }, index) => /* @__PURE__ */ jsx19(a.div, { style, children: /* @__PURE__ */ jsx19(a.div, { style: { height }, children: items[index] }) }, index)) });
+};
+
+// src/modules/Dapp/modules/Window/LoadingFlexbox.tsx
+import { jsx as jsx20, jsxs as jsxs10 } from "react/jsx-runtime";
+var DappLoadingFlexbox = ({
+  minimize,
+  open,
+  name,
+  ...props
+}) => {
+  const [fadeIn, setFadeIn] = useState14(!open);
+  const [trail, setTrail] = useState14(false);
+  const skipLoadingScreen = useSkipLoadingScreen();
+  useEffect15(() => {
+    if (open) {
+      if (skipLoadingScreen) {
+        setFadeIn(false);
+        return;
+      }
+      const fadeInTimeout = setTimeout(() => {
+        setFadeIn(false);
+      }, 2e3);
+      let trailTimeout = setTimeout(() => {
+        setTrail(true);
+        trailTimeout = setTimeout(() => {
+          setTrail(false);
+        }, 4e3);
+      }, 300);
+      return () => {
+        clearTimeout(fadeInTimeout);
+        clearTimeout(trailTimeout);
+      };
+    }
+    if (!minimize) {
+      setFadeIn(true);
+    }
+  }, [minimize, open, skipLoadingScreen]);
+  return /* @__PURE__ */ jsx20(Fade, { in: fadeIn, unmountOnExit: true, children: /* @__PURE__ */ jsxs10(StyledSplashContainer, { ...props, children: [
+    /* @__PURE__ */ jsx20(LoadingOsLogo, { widthInPixels: 100, busy: true, position: "absolute" }),
+    /* @__PURE__ */ jsxs10(TextTrail, { open: trail, flexDirection: "row", children: [
+      /* @__PURE__ */ jsx20(
+        Typography6,
+        {
+          textAlign: "center",
+          sx: { fontSize: { md: "3em", xs: "2em" } },
+          children: "Loading"
+        }
+      ),
+      /* @__PURE__ */ jsx20(
+        Typography6,
+        {
+          textAlign: "center",
+          sx: { fontSize: { md: "3em", xs: "2em" } },
+          children: name
+        }
+      ),
+      /* @__PURE__ */ jsx20(
+        Typography6,
+        {
+          textAlign: "center",
+          sx: { fontSize: { md: "3em", xs: "2em" } },
+          children: "dApp"
+        }
+      )
+    ] })
+  ] }) });
+};
+var StyledSplashContainer = styled2(FlexCol7, { name: "StyledSplashContainer" })(({ theme }) => {
+  return {
+    background: theme.palette.background.default,
+    color: theme.palette.text.primary,
+    gap: theme.spacing(1),
+    height: "100%",
+    left: 0,
+    position: "absolute",
+    top: 0,
+    width: "100%",
+    zIndex: 999
+  };
+});
+
+// src/modules/Dapp/modules/Window/menu/BottomNavigation.tsx
+import {
+  BottomNavigation,
+  BottomNavigationAction,
+  Paper,
+  styled as styled3
+} from "@mui/material";
+import { useColorSchemeEx } from "@xylabs/react-invertible-theme";
+import { useEffect as useEffect16, useState as useState15 } from "react";
+import { jsx as jsx21 } from "react/jsx-runtime";
+var DappBottomNavigation = ({
+  activePath,
+  menuConfig,
+  menuItems,
+  onPathChange,
+  ...props
+}) => {
+  const [activeIndex, setActiveIndex] = useState15(0);
+  useEffect16(() => {
+    if (menuConfig?.defaultPath && menuItems && activePath) {
+      setActiveIndex(menuItems.findIndex((item) => activePath === item.path));
+    }
+  }, [activePath, menuConfig, menuItems]);
+  return /* @__PURE__ */ jsx21(Paper, { elevation: 3, children: /* @__PURE__ */ jsx21(
+    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__ */ jsx21(
+          StyledBottomNavigationAction,
+          {
+            className: "bottom-nav-action",
+            label: primaryText,
+            icon: /* @__PURE__ */ jsx21(
+              "span",
+              {
+                ref: (ref) => {
+                  if (ref) {
+                    ref.innerHTML = icon ?? "";
+                  }
+                }
+              }
+            )
+          },
+          index
+        );
+      })
+    }
+  ) });
+};
+var StyledBottomNavigationAction = styled3(BottomNavigationAction, { name: "StyledBottomNavigationAction" })(({ theme }) => {
+  const { darkMode } = useColorSchemeEx();
+  return { "&.Mui-selected": { color: darkMode ? theme.palette.primary.main : theme.palette.secondary.main } };
+});
+
+// src/modules/Dapp/modules/Window/menu/Drawer.tsx
+import { BugReport as BugReport2 } from "@mui/icons-material";
+import {
+  Divider as Divider3,
+  Drawer,
+  IconButton as IconButton3,
+  List,
+  ListItem,
+  ListItemButton,
+  ListItemIcon,
+  ListItemText,
+  Stack,
+  styled as styled4,
+  Toolbar as Toolbar2,
+  Tooltip as Tooltip3,
+  Typography as Typography7,
+  useTheme as useTheme6
+} from "@mui/material";
+import { RotationAnimation } from "@xylabs/react-animation";
+import {
+  FlexCol as FlexCol8,
+  FlexGrowRow as FlexGrowRow5,
+  FlexRow as FlexRow7
+} from "@xylabs/react-flexbox";
+import { DarkModeIconButtonForColorScheme as DarkModeIconButtonForColorScheme2, useColorSchemeEx as useColorSchemeEx2 } from "@xylabs/react-invertible-theme";
+import { LinkEx as LinkEx2 } from "@xylabs/react-link";
+import { XyOsMonitor as XyOsMonitor3 } from "@xyo-network/os-runtime";
+import { useEffect as useEffect17, useState as useState16 } from "react";
+import XyoOSLogoBlack from "./xyoOS-Icon-Black-ACSS4SEQ.svg";
+import XyoOSLogoWhite from "./xyoOS-Icon-White-47MP66MD.svg";
+
+// src/modules/Dapp/modules/Window/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 jsx22 } from "react/jsx-runtime";
+var socialLinksData = [
+  {
+    icon: /* @__PURE__ */ jsx22(Facebook, { style: { fontSize: "24px" } }),
+    link: "https://www.facebook.com/OfficialXYO"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(X, { style: { fontSize: "24px" } }),
+    link: "https://twitter.com/OfficialXYO"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(Instagram, { style: { fontSize: "24px" } }),
+    link: "https://www.instagram.com/officialxyo/"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(Telegram, { style: { fontSize: "24px" } }),
+    link: "https://t.me/xyonetwork"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(Reddit, { style: { fontSize: "24px" } }),
+    link: "https://www.reddit.com/r/XYONetwork/"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(YouTube, { style: { fontSize: "24px" } }),
+    link: "https://www.youtube.com/channel/UCyZDqb9pgntVHJVt1pxXtsw"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(LinkedIn, { style: { fontSize: "24px" } }),
+    link: "https://www.linkedin.com/company/officialxyo/"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(FaDiscord, { style: { fontSize: "24px" } }),
+    link: "https://discord.gg/officialxyo"
+  },
+  {
+    icon: /* @__PURE__ */ jsx22(StorefrontRounded, { style: { fontSize: "24px" } }),
+    link: "https://shop.xyo.network"
+  }
+];
+
+// src/modules/Dapp/modules/Window/menu/Drawer.tsx
+import { jsx as jsx23, jsxs as jsxs11 } from "react/jsx-runtime";
+var DappMenuDrawer = ({
+  activePath,
+  context,
+  iconSvg,
+  name,
+  menuConfig,
+  menuItems,
+  onPathChange,
+  version,
+  ...props
+}) => {
+  const [path, setPath] = useState16("");
+  const { darkMode } = useColorSchemeEx2();
+  const theme = useTheme6();
+  const activeColor = darkMode ? theme.palette.primary.main : theme.palette.secondary.main;
+  const logo = darkMode ? XyoOSLogoWhite : XyoOSLogoBlack;
+  useEffect17(() => {
+    if (menuConfig?.defaultPath && menuItems && activePath) {
+      const newPath = menuItems.find((item) => activePath === item.path)?.path ?? "";
+      setPath(newPath);
+    }
+  }, [activePath, menuConfig, menuItems]);
+  const handleChange = (to2) => {
+    XyOsMonitor3.trackEvent("Visit dApp Page", { Page: to2 });
+    setPath(to2);
+    onPathChange?.(to2);
+  };
+  const {
+    closeDebug,
+    debugOpen,
+    openDebug
+  } = useDebugClick();
+  return /* @__PURE__ */ jsx23(
+    Drawer,
+    {
+      variant: "permanent",
+      anchor: "left",
+      PaperProps: {
+        sx: {
+          background: "transparent",
+          borderRight: "none",
+          position: "static"
+        }
+      },
+      sx: { borderRight: `solid ${darkMode ? theme.palette.grey[900] : theme.palette.grey[300]}`, maxWidth: "280px" },
+      ...props,
+      children: /* @__PURE__ */ jsxs11(FlexCol8, { alignItems: "stretch", justifyContent: "space-between", height: "100dvh", children: [
+        /* @__PURE__ */ jsxs11(FlexCol8, { paddingY: 1, paddingX: 2, alignItems: "stretch", children: [
+          /* @__PURE__ */ jsx23(Tooltip3, { title: version, children: /* @__PURE__ */ jsxs11(
+            FlexGrowRow5,
+            {
+              marginBottom: 2,
+              justifyContent: "flex-start",
+              gap: 1,
+              sx: { cursor: "pointer" },
+              children: [
+                iconSvg ? RenderHtml({ htmlString: iconSvg }) : null,
+                /* @__PURE__ */ jsx23(Typography7, { noWrap: true, variant: "h5", letterSpacing: "-1px", fontWeight: "300", children: name })
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ jsx23(DebugDialogWithNode, { closeDebug, debugOpen, context }),
+          /* @__PURE__ */ jsx23(List, { sx: { p: 0 }, children: menuItems?.map(({
+            svgIcon: icon,
+            primaryText,
+            path: pathFromPayload
+          }) => {
+            return /* @__PURE__ */ jsx23(
+              ListItem,
+              {
+                disablePadding: true,
+                sx: {
+                  // Note: setting color here lets it cascade down to both text and svg elements with fill="currentColor"
+                  // see - https://css-tricks.com/cascading-svg-fill-color/
+                  color: pathFromPayload === path ? activeColor : void 0
+                },
+                children: /* @__PURE__ */ jsxs11(ListItemButton, { onClick: () => handleChange(pathFromPayload), children: [
+                  /* @__PURE__ */ jsx23(ListItemIcon, { sx: { color: "inherit" }, children: /* @__PURE__ */ jsx23(
+                    StyledMenuIconWrapSpan,
+                    {
+                      ref: (ref) => {
+                        if (ref) {
+                          ref.innerHTML = icon ?? "";
+                        }
+                      }
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx23(ListItemText, { primary: primaryText })
+                ] })
+              },
+              primaryText
+            );
+          }) })
+        ] }),
+        /* @__PURE__ */ jsxs11(FlexCol8, { children: [
+          /* @__PURE__ */ jsx23(Divider3, { variant: "middle", flexItem: true }),
+          /* @__PURE__ */ jsxs11(FlexCol8, { padding: 2, children: [
+            /* @__PURE__ */ jsxs11(Toolbar2, { sx: { paddingX: 1.5 }, children: [
+              /* @__PURE__ */ jsx23(Tooltip3, { title: "Debug Node View", children: /* @__PURE__ */ jsx23(IconButton3, { onClick: openDebug, children: /* @__PURE__ */ jsx23(BugReport2, { sx: { color: theme.palette.text.primary } }) }) }),
+              /* @__PURE__ */ jsx23(Tooltip3, { title: "Toggle Light/Dark Mode", children: /* @__PURE__ */ jsx23("span", { children: /* @__PURE__ */ jsx23(DarkModeIconButtonForColorScheme2, { defaultLightModeColor: "warning" }) }) })
+            ] }),
+            /* @__PURE__ */ jsx23(FlexRow7, { flexWrap: "wrap", children: socialLinksData.map((social, index) => {
+              return /* @__PURE__ */ jsx23(RotationAnimation, { rotation: 20, children: /* @__PURE__ */ jsx23(
+                IconButton3,
+                {
+                  sx: { color: theme.palette.text.primary },
+                  href: social.link,
+                  target: "_blank",
+                  children: social.icon
+                }
+              ) }, index);
+            }) }),
+            /* @__PURE__ */ jsxs11(FlexRow7, { padding: 1, justifyContent: "center", gap: 0.5, children: [
+              /* @__PURE__ */ jsx23(Typography7, { variant: "body2", color: theme.palette.text.primary, children: "Powered By" }),
+              /* @__PURE__ */ jsx23(
+                "img",
+                {
+                  style: { color: theme.palette.text.primary, fill: theme.palette.text.primary },
+                  src: logo,
+                  width: "auto",
+                  height: "20px"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx23(LinkEx2, { target: "_blank", href: "https://xylabs.com/", children: /* @__PURE__ */ jsx23(Typography7, { variant: "caption", children: "Copyright \xA9 2024 XY Labs, Inc." }) }),
+            /* @__PURE__ */ jsxs11(Stack, { gap: 0.5, flexDirection: "row", children: [
+              /* @__PURE__ */ jsx23(LinkEx2, { target: "_blank", href: "https://xylabs.com/privacy/", children: /* @__PURE__ */ jsx23(Typography7, { variant: "caption", children: "Privacy" }) }),
+              " ",
+              "\u2022",
+              " ",
+              /* @__PURE__ */ jsx23(LinkEx2, { target: "_blank", href: "https://xylabs.com/terms/", children: /* @__PURE__ */ jsx23(Typography7, { variant: "caption", children: "Terms" }) }),
+              " ",
+              "\u2022",
+              " ",
+              /* @__PURE__ */ jsx23(LinkEx2, { target: "_blank", href: "https://xyo.network/", children: /* @__PURE__ */ jsx23(Typography7, { variant: "caption", children: "XYO Website" }) })
+            ] })
+          ] })
+        ] })
+      ] })
+    }
+  );
+};
+var StyledMenuIconWrapSpan = styled4("span", { name: "StyledMenuIconWrapSpan" })(() => ({
+  alignItems: "center",
+  display: "inline-flex",
+  flexDirection: "column"
+}));
+
+// src/modules/Dapp/modules/Window/DappWindow.tsx
+import { Fragment as Fragment2, jsx as jsx24, jsxs as jsxs12 } from "react/jsx-runtime";
+var DappWindow = ({
+  dappSet,
+  xnsNodeUrl,
+  xnsNetwork
+}) => {
+  const {
+    DappComponent,
+    dapp,
+    name,
+    scrollable = true,
+    version
+  } = useDecomposeDappSet(dappSet);
+  const {
+    dappWallet,
+    context,
+    nodeCreateError
+  } = useDappContextCreator(xnsNodeUrl, xnsNetwork, dapp);
+  const { dappIntentType: intentType, intentPayload } = useDappIntentListener(name);
+  const {
+    active,
+    minimized,
+    open
+  } = useDappState(intentType, context);
+  const TypedDappComponent = useMemo12(() => DappComponent, []);
+  const errors = useManageDappBasedOffRoute(intentPayload, name, context);
+  useSyncOsRegisteredAccessInterfaces(context);
+  const {
+    activePath,
+    error: menuError,
+    menuConfig,
+    menuItemsVisible,
+    onPathChange
+  } = useDappMenu(context, name);
+  const resolvedError = nodeCreateError || menuError;
+  return /* @__PURE__ */ jsxs12(Fragment2, { children: [
+    active ? /* @__PURE__ */ jsx24(Helmet, { children: /* @__PURE__ */ jsxs12("title", { children: [
+      activePath ? `${new NameTransforms4(activePath).deSlug()} | ` : "",
+      " ",
+      name,
+      " ",
+      "dApp"
+    ] }) }) : null,
+    /* @__PURE__ */ jsx24(ErrorBoundary, { children: /* @__PURE__ */ jsxs12(
+      DappChrome,
+      {
+        appBar: /* @__PURE__ */ jsx24(Fragment2, { children: /* @__PURE__ */ jsx24(DappBar, { context, name, version, title: activePath ? new NameTransforms4(activePath).deSlug() : "" }) }),
+        height: "100dvh",
+        width: "100dvw",
+        largeScreenMenu: /* @__PURE__ */ jsx24(
+          DappMenuDrawer,
+          {
+            context,
+            name,
+            version,
+            activePath,
+            onPathChange,
+            menuConfig,
+            menuItems: menuItemsVisible
+          }
+        ),
+        smallScreenMenu: /* @__PURE__ */ jsx24(
+          DappBottomNavigation,
+          {
+            activePath,
+            onPathChange,
+            menuConfig,
+            menuItems: menuItemsVisible,
+            sx: { display: menuConfig ? "flex" : "none" }
+          }
+        ),
+        splashScreen: resolvedError ? null : /* @__PURE__ */ jsx24(DappLoadingFlexbox, { minimize: minimized, name, open }),
+        children: [
+          resolvedError || errors?.length > 0 ? /* @__PURE__ */ jsxs12(FlexCol9, { padding: 2, children: [
+            resolvedError ? /* @__PURE__ */ jsx24(ErrorRender3, { error: resolvedError, scope: "DappWindow" }) : null,
+            errors.map((error, index) => /* @__PURE__ */ jsx24(ErrorRender3, { error, scope: "DappWindowErrors" }, index))
+          ] }) : 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__ */ jsxs12(Fragment2, { children: [
+            /* @__PURE__ */ jsx24(
+              FlexCol9,
+              {
+                position: "absolute",
+                top: 0,
+                left: 0,
+                right: 0,
+                bottom: 0,
+                alignItems: "stretch",
+                justifyContent: "stretch",
+                sx: { overflowY: scrollable ? "auto" : "hidden" },
+                children: /* @__PURE__ */ jsx24(TypedDappComponent, { name })
+              }
+            ),
+            /* @__PURE__ */ jsx24(DappAccessFlexbox, { context })
+          ] }) : null }) }) })
+        ]
+      }
+    ) })
+  ] });
+};
+
+// src/modules/Dapp/Container.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+var DappContainer = ({
+  dappSet,
+  xnsNodeUrl,
+  xnsNetwork
+}) => {
+  const { dapp, dappIcon } = dappSet;
+  return /* @__PURE__ */ jsx25(DappIconButton, { dappIcon, dappIconSvg: dapp.params.iconSvg, dappName: dapp?.config.name, children: /* @__PURE__ */ jsx25(DappWindow, { dappSet, xnsNodeUrl, xnsNetwork }) });
+};
+
+// 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",
+      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/Row.tsx
+import {
+  Divider as Divider4,
+  Fade as Fade2,
+  styled as styled5
+} from "@mui/material";
+import { useMemo as useMemo13 } from "react";
+
+// src/modules/Dapp/Page/DividerChip.tsx
+import { Chip as Chip2, CircularProgress } from "@mui/material";
+import { Fragment as Fragment3, jsx as jsx27 } from "react/jsx-runtime";
+var DividerChip = ({ registeredDapps, ...props }) => {
+  return /* @__PURE__ */ jsx27(
+    Chip2,
+    {
+      avatar: registeredDapps === void 0 ? /* @__PURE__ */ jsx27("span", { children: /* @__PURE__ */ jsx27(
+        CircularProgress,
+        {
+          size: "small",
+          sx: { display: "inline" }
+        }
+      ) }) : /* @__PURE__ */ jsx27(Fragment3, {}),
+      label: `${registeredDapps?.length ? "" : "Loading "}Beta dApps`,
+      size: "small",
+      sx: { gap: 0.5 },
+      ...props
+    }
+  );
+};
+
+// src/modules/Dapp/Page/Row.tsx
+import { Fragment as Fragment4, jsx as jsx28, jsxs as jsxs13 } from "react/jsx-runtime";
+var DappsRow = ({
+  chipLabel,
+  installType,
+  registeredDappsSet,
+  xnsNetwork,
+  xnsNodeUrl
+}) => {
+  const filteredRegisteredDappSets = useMemo13(() => DappInstallTypeFilters[installType](registeredDappsSet), [installType, registeredDappsSet]);
+  return /* @__PURE__ */ jsxs13(Fragment4, { children: [
+    /* @__PURE__ */ jsx28(
+      Divider4,
+      {
+        variant: "middle",
+        sx: { marginY: 3 },
+        flexItem: true,
+        children: /* @__PURE__ */ jsx28(
+          DividerChip,
+          {
+            label: `${filteredRegisteredDappSets === void 0 ? "Loading " : ""}${chipLabel}`,
+            registeredDapps: filteredRegisteredDappSets
+          }
+        )
+      }
+    ),
+    filteredRegisteredDappSets?.length ? /* @__PURE__ */ jsx28(Fade2, { in: !!filteredRegisteredDappSets?.length, timeout: 1e3, children: /* @__PURE__ */ jsx28(StyledGridContainer, { children: filteredRegisteredDappSets?.map(
+      (dappSet, index) => /* @__PURE__ */ jsx28(DappContainer, { dappSet, xnsNodeUrl, xnsNetwork }, index)
+    ) }) }) : null
+  ] });
+};
+var StyledGridContainer = styled5("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/network/components/LoadingIndicator.tsx
+import { SignalCellularAltOutlined } from "@mui/icons-material";
+import { Tooltip as Tooltip4, useTheme as useTheme7 } from "@mui/material";
+import { useColorSchemeEx as useColorSchemeEx3 } from "@xylabs/react-invertible-theme";
+import { useMemo as useMemo16 } from "react";
+
+// src/modules/network/hooks/useOsNetwork.tsx
+import { OsPubSubNetworkReadyEvent } from "@xyo-network/os-runtime";
+import { useMemo as useMemo14 } from "react";
+
+// src/modules/network/hooks/lib/createNetworkState.ts
+import { assertEx as assertEx8 } from "@xylabs/assert";
+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 = useMemo14(() => {
+    return createNetworkState(stackReady);
+  }, [context, stackReady]);
+  return networkState;
+};
+
+// src/modules/network/hooks/useXyoPublicNetwork.tsx
+import { OsXyoPublicNetworkReadyEvent } from "@xyo-network/os-runtime";
+import { useMemo as useMemo15 } from "react";
+var useXyoPublicNetwork = () => {
+  const context = useXyOsUiContext();
+  const stackReady = useStackReady(OsXyoPublicNetworkReadyEvent, "xyoPublicNetworkStack", context);
+  const networkState = useMemo15(() => {
+    return createNetworkState(stackReady);
+  }, [context, stackReady]);
+  return networkState;
+};
+
+// src/modules/network/components/StyledLoadingIndicator.tsx
+import { styled as styled6 } from "@mui/material";
+var StyledNetworkLoadingIndicator = styled6("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 jsx29 } from "react/jsx-runtime";
+var WaitingForNetwork = () => /* @__PURE__ */ jsx29(Tooltip4, { title: "Waiting for Network initialization", children: /* @__PURE__ */ jsx29(StyledNetworkLoadingIndicator, {}) });
+var NetworkLoadingIndicator = ({ highContrast }) => {
+  const { darkMode } = useColorSchemeEx3();
+  const theme = useTheme7();
+  const { networkReady } = useOsNetwork();
+  const highContrastSuccessColor = darkMode ? theme.palette.success.dark : theme.palette.success.main;
+  const successColor = highContrast ? highContrastSuccessColor : theme.palette.success.main;
+  const highContrastErrorColor = darkMode ? theme.palette.success.dark : theme.palette.error.main;
+  const errorColor = highContrast ? highContrastErrorColor : theme.palette.error.main;
+  const NetworkComponent = useMemo16(() => {
+    if (networkReady) {
+      const connectionReady = true;
+      return connectionReady ? () => /* @__PURE__ */ jsx29(Tooltip4, { title: "Connected to Network", children: /* @__PURE__ */ jsx29(SignalCellularAltOutlined, { sx: { color: successColor } }) }) : () => /* @__PURE__ */ jsx29(Tooltip4, { title: "Error Connecting to Network", children: /* @__PURE__ */ jsx29(SignalCellularAltOutlined, { sx: { color: errorColor } }) });
+    } else {
+      return WaitingForNetwork;
+    }
+  }, [errorColor, networkReady, successColor]);
+  return /* @__PURE__ */ jsx29(NetworkComponent, {});
+};
+
+// src/modules/network/components/NetworkButton.tsx
+import { NotInterested } from "@mui/icons-material";
+import { Button as Button2 } from "@mui/material";
+import { Fragment as Fragment5, jsx as jsx30, jsxs as jsxs14 } from "react/jsx-runtime";
+var NetworkButton = ({
+  disabled,
+  startIcon,
+  ...props
+}) => {
+  const { networkReady } = useOsNetwork();
+  return /* @__PURE__ */ jsx30(
+    Button2,
+    {
+      disabled: disabled || !networkReady,
+      startIcon: /* @__PURE__ */ jsxs14(Fragment5, { children: [
+        startIcon,
+        networkReady === false ? /* @__PURE__ */ jsx30(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 Fragment6, jsx as jsx31, jsxs as jsxs15 } from "react/jsx-runtime";
+var NetworkReadyFlexBox = ({
+  children,
+  skipCheck,
+  ...props
+}) => {
+  const { networkReady } = useOsNetwork();
+  return /* @__PURE__ */ jsx31(Fragment6, { children: networkReady || skipCheck ? children : /* @__PURE__ */ jsxs15(FlexCol11, { height: "100%", ...props, children: [
+    /* @__PURE__ */ jsx31(LoadingOsLogo, { widthInPixels: 100, busy: true }),
+    /* @__PURE__ */ jsx31(Typography8, { fontFamily: "monospace", children: "Loading XYO Name Service..." })
+  ] }) });
+};
+
+// src/DappPage.tsx
+import { jsx as jsx32, jsxs as jsxs16 } from "react/jsx-runtime";
+var DappTitle = ({
+  subtitle,
+  title,
+  ...props
+}) => {
+  return title ? /* @__PURE__ */ jsxs16(FlexCol12, { alignItems: "flex-start", gap: 1, ...props, children: [
+    /* @__PURE__ */ jsx32(Typography9, { variant: "h3", children: /* @__PURE__ */ jsx32("b", { children: title }) }),
+    /* @__PURE__ */ jsx32(Typography9, { gutterBottom: true, variant: "subtitle2", children: subtitle })
+  ] }) : null;
+};
+var InnerDappPage = ({
+  noScroll,
+  children,
+  subtitle,
+  title,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs16(
+    FlexCol12,
+    {
+      id: "innerPage",
+      sx: {
+        marginX: { sm: 2 },
+        marginY: 2,
+        ...sx
+      },
+      gap: noScroll ? 0 : 2,
+      alignItems: "stretch",
+      justifyContent: "flex-start",
+      ...props,
+      children: [
+        title ? /* @__PURE__ */ jsx32(DappTitle, { subtitle, title, marginX: 1 }) : null,
+        children
+      ]
+    }
+  );
+};
+var DappPage = ({
+  checkNetwork,
+  noScroll,
+  subtitle,
+  title,
+  container,
+  rollbar,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx32(
+    ThrownErrorBoundary,
+    {
+      errorComponent: (error, boundaryName) => /* @__PURE__ */ jsx32(ErrorRenderWithSupportDefault, { errorContext: boundaryName, error, scope: "DappPage" }),
+      rollbar,
+      scope: "DappPage",
+      children: /* @__PURE__ */ jsx32(NetworkReadyFlexBox, { skipCheck: !checkNetwork, children: container ? /* @__PURE__ */ jsx32(Container3, { disableGutters: true, maxWidth: container === true ? "md" : container, children: noScroll ? /* @__PURE__ */ jsx32(
+        FlexCol12,
+        {
+          sx: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+          },
+          children: /* @__PURE__ */ jsx32(InnerDappPage, { noScroll, title, subtitle, ...props, flexGrow: 1 })
+        }
+      ) : /* @__PURE__ */ jsx32(FlexCol12, { width: "100%", height: "100%", alignItems: "stretch", children: /* @__PURE__ */ jsx32(InnerDappPage, { noScroll, title, subtitle, ...props, flexGrow: 1 }) }) }) : noScroll ? /* @__PURE__ */ jsx32(
+        InnerDappPage,
+        {
+          sx: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+          },
+          noScroll,
+          title,
+          subtitle,
+          ...props,
+          flexGrow: 1
+        }
+      ) : /* @__PURE__ */ jsx32(InnerDappPage, { noScroll, title, subtitle, ...props, flexGrow: 1 }) })
+    }
+  );
+};
+
+// src/components/Widgets/StackOfWidgets.tsx
+import {
+  alpha as alpha6,
+  Box as Box3,
+  useTheme as useTheme9
+} from "@mui/material";
+import {
+  animated as animated2,
+  to as interpolate,
+  useSprings
+} from "@react-spring/web";
+import { useState as useState17 } from "react";
+import { useDrag } from "react-use-gesture";
+
+// src/components/Widgets/Types/BarGraph/HorizontalBarGraph.tsx
+import { Typography as Typography10 } from "@mui/material";
+import { FlexCol as FlexCol13, FlexGrowRow as FlexGrowRow6 } from "@xylabs/react-flexbox";
+
+// src/components/Widgets/Types/BarGraph/StyledLinearProgress.tsx
+import {
+  alpha as alpha4,
+  LinearProgress,
+  styled as styled7
+} from "@mui/material";
+var StyledLinearProgress = styled7(LinearProgress, { name: "StyledLinearProgress" })(({ theme }) => ({
+  "& .MuiLinearProgress-bar": { borderRadius: theme.shape.borderRadius },
+  "MozBoxSizing": "border-box",
+  "WebkitBoxSizing": "border-box",
+  "background": "transparent",
+  "borderBottom": `1px solid ${alpha4(theme.palette.text.secondary, 0.3)}`,
+  "boxSizing": "border-box",
+  "height": theme.spacing(0.25)
+}));
+
+// src/components/Widgets/Types/BarGraph/HorizontalBarGraph.tsx
+import { jsx as jsx33, jsxs as jsxs17 } 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.sort(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__ */ jsx33(FlexCol13, { alignItems: "stretch", gap: 0.5, ...props, children: items.slice(0, 5).map((item, index) => /* @__PURE__ */ jsxs17(FlexCol13, { alignItems: "stretch", children: [
+    /* @__PURE__ */ jsxs17(FlexGrowRow6, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx33(Typography10, { variant: "caption", maxWidth: "50%", noWrap: true, children: item.name }),
+      /* @__PURE__ */ jsx33(Typography10, { variant: "caption", maxWidth: "50%", children: item.value })
+    ] }),
+    /* @__PURE__ */ jsx33(StyledLinearProgress, { color: "primary", value: item.value / (topValue * 1.25) * 100, variant: "determinate" })
+  ] }, index)) });
+};
+
+// src/components/Widgets/Types/DataColumns/TwoColTwoStat.tsx
+import { Typography as Typography11, useTheme as useTheme8 } from "@mui/material";
+import { FlexCol as FlexCol14, FlexGrowRow as FlexGrowRow7 } from "@xylabs/react-flexbox";
+import { useEffect as useEffect18 } from "react";
+import { jsx as jsx34, jsxs as jsxs18 } 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 = useTheme8();
+  useEffect18(() => {
+    validateProps(items);
+  }, [items]);
+  return /* @__PURE__ */ jsx34(FlexGrowRow7, { gap: 2, ...props, children: items.map((item, index) => /* @__PURE__ */ jsxs18(FlexCol14, { flexGrow: 1, alignItems: "start", children: [
+    /* @__PURE__ */ jsx34(Typography11, { variant: "h2", fontWeight: theme.typography.fontWeightMedium, children: item.rawInsightValue }),
+    /* @__PURE__ */ jsx34(Typography11, { variant: "body2", children: item.subtitle })
+  ] }, `stat-${index}-${item.unit}`)) });
+};
+
+// src/components/Widgets/Types/Examples/BarGraph.tsx
+import { jsx as jsx35 } from "react/jsx-runtime";
+var ExampleBarGraphWidget = () => {
+  return /* @__PURE__ */ jsx35(WidgetCard, { widgetContent: /* @__PURE__ */ jsx35(HorizontalBarGraph, {}), widgetName: "Friend Locations", timeOfData: 1715713478, widgetPath: "/profile" });
+};
+
+// src/components/Widgets/Types/Tables/BooleanTable.tsx
+import { CircleRounded } from "@mui/icons-material";
+import {
+  alpha as alpha5,
+  Paper as Paper2,
+  styled as styled8,
+  TableRow,
+  Typography as Typography12
+} from "@mui/material";
+import {
+  FlexCol as FlexCol15,
+  FlexGrowRow as FlexGrowRow8,
+  FlexRow as FlexRow8
+} from "@xylabs/react-flexbox";
+import { jsx as jsx36, jsxs as jsxs19 } 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 = styled8(Paper2, { name: "StyledLightTableRow" })(({ theme }) => ({
+  backgroundColor: "transparent",
+  padding: theme.spacing(0.75)
+}));
+var StyledTableColumnTitle = styled8(Typography12, { name: "StyledTableColumnTitle" })(({ theme }) => ({
+  color: theme.palette.text.secondary,
+  fontWeight: theme.typography.fontWeightBold,
+  textTransform: "uppercase"
+}));
+var DefaultTrueOutput = styled8(CircleRounded, { name: "DefaultTrueOutput" })(({ theme }) => ({
+  fill: theme.palette.success.main,
+  fontSize: "10px"
+}));
+var DefaultFalseOutput = styled8(CircleRounded, { name: "DefaultFalseOutput" })(({ theme }) => ({
+  fill: alpha5(theme.palette.text.disabled, 0.5),
+  fontSize: "10px"
+}));
+var defaultTrueOutput = /* @__PURE__ */ jsx36(DefaultTrueOutput, {});
+var defaultFalseOutput = /* @__PURE__ */ jsx36(DefaultFalseOutput, {});
+var BooleanTable = ({
+  items = sampleData2,
+  tableHeaders,
+  trueOutput = defaultTrueOutput,
+  falseOutput = defaultFalseOutput,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs19(FlexCol15, { alignItems: "stretch", ...props, children: [
+    /* @__PURE__ */ jsx36(FlexRow8, { paddingBottom: 0.5, justifyContent: "space-between", children: tableHeaders.map((name) => /* @__PURE__ */ jsx36(StyledTableColumnTitle, { variant: "caption", children: name }, name)) }),
+    /* @__PURE__ */ jsx36(FlexCol15, { alignItems: "stretch", gap: 0.25, children: items.slice(0, 4).map((item, index) => /* @__PURE__ */ jsx36(TableRow, { children: /* @__PURE__ */ jsxs19(FlexGrowRow8, { flexGrow: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx36(Typography12, { variant: "caption", noWrap: true, maxWidth: "70%", children: item.name }),
+      item.value ? trueOutput : falseOutput
+    ] }) }, index)) })
+  ] });
+};
+
+// src/components/Widgets/Types/Examples/BooleanTable.tsx
+import { jsx as jsx37 } from "react/jsx-runtime";
+var ExampleBooleanTableWidget = () => {
+  return /* @__PURE__ */ jsx37(
+    WidgetCard,
+    {
+      widgetContent: /* @__PURE__ */ jsx37(
+        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/components/Widgets/Types/Examples/TwoColTwoStat.tsx
+import { jsx as jsx38 } from "react/jsx-runtime";
+var ExampleTwoColTwoStatWidget = () => {
+  return /* @__PURE__ */ jsx38(
+    WidgetCard,
+    {
+      widgetContent: /* @__PURE__ */ jsx38(
+        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/components/Widgets/StackOfWidgets.tsx
+import { Fragment as Fragment7, jsx as jsx39 } from "react/jsx-runtime";
+var cards = [
+  /* @__PURE__ */ jsx39(ExampleBarGraphWidget, {}, "bar-graph"),
+  /* @__PURE__ */ jsx39(ExampleBooleanTableWidget, {}, "boolean-table"),
+  /* @__PURE__ */ jsx39(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] = useState17(() => /* @__PURE__ */ new Set());
+  const theme = useTheme9();
+  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 + window.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__ */ jsx39(Fragment7, { children: props.map(({
+    x,
+    y,
+    rot,
+    scale
+  }, i) => /* @__PURE__ */ jsx39(
+    animated2.div,
+    {
+      style: {
+        alignItems: "center",
+        display: "flex",
+        height: "300px",
+        justifyContent: "center",
+        position: "absolute",
+        touchAction: "none",
+        width: "300px",
+        willChange: "transform",
+        x,
+        y
+      },
+      children: /* @__PURE__ */ jsx39(
+        animated2.div,
+        {
+          ...bind(i),
+          style: {
+            // WebkitBackdropFilter: 'blur(10px)',
+            // backdropFilter: 'blur(10px)',
+            backgroundColor: alpha6(theme.palette.background.paper, 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__ */ jsx39(
+    Box3,
+    {
+      sx: {
+        alignItems: "center",
+        cursor: "pointer",
+        display: "flex",
+        height: "300px",
+        justifyContent: "center",
+        width: "300px"
+      },
+      children: /* @__PURE__ */ jsx39(Deck, {})
+    }
+  );
+};
+
+// src/components/Widgets/WidgetCardExamples.tsx
+import { jsx as jsx40, jsxs as jsxs20 } from "react/jsx-runtime";
+var WidgetCardExamples = () => {
+  const { darkMode } = useColorSchemeEx4();
+  return /* @__PURE__ */ jsx40(
+    DappPage,
+    {
+      sx: { backgroundImage: darkMode ? `url(${default18})` : `url(${default19})`, backgroundSize: "cover" },
+      container: "xl",
+      title: "Example Widget Cards",
+      children: /* @__PURE__ */ jsxs20(Stack2, { gap: 2, flexDirection: "row", flexWrap: "wrap", children: [
+        /* @__PURE__ */ jsx40(ExampleTwoColTwoStatWidget, {}),
+        /* @__PURE__ */ jsx40(ExampleBarGraphWidget, {}),
+        /* @__PURE__ */ jsx40(ExampleBooleanTableWidget, {}),
+        /* @__PURE__ */ jsx40(StackOfWidgets, {})
+      ] })
+    }
+  );
+};
+
+// src/DappPathSwitcher.tsx
+import { animated as animated3, useTransition } from "@react-spring/web";
+import { ErrorRender as ErrorRender4 } from "@xyo-network/react-error";
+import { Fragment as Fragment8, jsx as jsx41 } from "react/jsx-runtime";
+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__ */ jsx41(Fragment8, { children: transitions((transitionProps, activePath2) => /* @__PURE__ */ jsx41(
+    animated3.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: (() => {
+        const activeIndex = pathToComponent?.findIndex(({ path: componentPath }) => activePath2 === componentPath);
+        const activeItem = pathToComponent && activeIndex !== -1 && activeIndex !== void 0 ? pathToComponent[activeIndex] : void 0;
+        return activeItem ? activeItem.component : /* @__PURE__ */ jsx41(ErrorRender4, { error: new Error(`No component found for path: ${activePath2}`), scope: "DappPathSwitcher" });
+      })()
+    }
+  )) });
+};
+
+// src/dapps/shared/accounts/components/AnimatedComponents/GenericAnimations/ShiftAnimation.tsx
+import { animated as animated4, useSpring as useSpring2 } from "@react-spring/web";
+import { useEffect as useEffect19, useState as useState18 } from "react";
+import { jsx as jsx42 } 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
+    }
+  });
+  useEffect19(() => {
+    if (!isShifted) {
+      return;
+    }
+    const timeoutId = window.setTimeout(() => {
+      setIsShifted(false);
+    }, 5);
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [isShifted]);
+  return /* @__PURE__ */ jsx42(animated4.div, { style: anim, children });
+};
+
+// src/dapps/shared/accounts/components/AnimatedComponents/IconAnimations/TwoToneBulletPoint.tsx
+import { FiberManualRecordRounded } from "@mui/icons-material";
+import {
+  alpha as alpha7,
+  Box as Box4,
+  useTheme as useTheme10
+} from "@mui/material";
+import { jsx as jsx43 } from "react/jsx-runtime";
+var TwoToneBulletPoint = (props) => {
+  const theme = useTheme10();
+  return /* @__PURE__ */ jsx43(Box4, { ...props, children: /* @__PURE__ */ jsx43(
+    FiberManualRecordRounded,
+    {
+      fontSize: "small",
+      sx: {
+        "&:hover": { padding: 0.2 },
+        "backgroundColor": alpha7(theme.palette.secondary.main, 0.2),
+        "borderRadius": 2,
+        "padding": 0.4
+      },
+      color: "primary"
+    }
+  ) });
+};
+
+// src/dapps/shared/accounts/components/AnimatedComponents/IconAnimations/TwoToneBulletPointList.tsx
+import { FlexCol as FlexCol16, FlexGrowRow as FlexGrowRow9 } from "@xylabs/react-flexbox";
+import { jsx as jsx44, jsxs as jsxs21 } from "react/jsx-runtime";
+var TwoToneBulletPointList = ({ list }) => {
+  return /* @__PURE__ */ jsx44(FlexCol16, { alignItems: "flex-start", gap: 1, children: list.map((item, index) => {
+    return /* @__PURE__ */ jsxs21(FlexGrowRow9, { alignItems: "flex-start", justifyContent: "flex-start", gap: 1, children: [
+      /* @__PURE__ */ jsx44(TwoToneBulletPoint, { marginTop: "4px" }),
+      item
+    ] }, index + "bulletPointList");
+  }) });
+};
+
+// src/dapps/shared/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 jsx45 } 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__ */ jsx45(FormControl, { fullWidth: true, children: /* @__PURE__ */ jsx45(LabeledTextFieldWrapper, { label: "Primary Cryptowallet", children: /* @__PURE__ */ jsx45(
+    TextField,
+    {
+      fullWidth: true,
+      variant: "filled",
+      error: valid === false,
+      hiddenLabel: true,
+      onBlur: handleBlur,
+      value: email,
+      onChange: handleChange,
+      size: "small",
+      ...props
+    }
+  ) }) });
+};
+
+// src/dapps/shared/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 jsx46 } 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__ */ jsx46(FormControl2, { fullWidth: true, children: /* @__PURE__ */ jsx46(LabeledTextFieldWrapper2, { label: "Primary Cryptowallet", children: /* @__PURE__ */ jsx46(
+    TextField2,
+    {
+      fullWidth: true,
+      variant: "filled",
+      error: valid === false,
+      hiddenLabel: true,
+      onBlur: handleBlur,
+      value: primaryWallet,
+      onChange: handleChange,
+      size: "small",
+      required: true,
+      ...props
+    }
+  ) }) });
+};
+
+// src/dapps/shared/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 jsx47 } 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__ */ jsx47(FormControl3, { fullWidth: true, children: /* @__PURE__ */ jsx47(LabeledTextFieldWrapper3, { label: "Secondary Cryptowallet", children: /* @__PURE__ */ jsx47(
+    TextField3,
+    {
+      variant: "filled",
+      fullWidth: true,
+      error: valid === false,
+      hiddenLabel: true,
+      onBlur: handleBlur,
+      value: secondaryWallet,
+      onChange: handleChange,
+      size: "small",
+      required: true,
+      ...props
+    }
+  ) }) });
+};
+
+// src/dapps/shared/accounts/components/PaymentMethods.tsx
+import { Grid } from "@mui/material";
+import { FormGroupCreditCardProvider } from "@xyo-network/react-form-credit-card";
+
+// src/dapps/shared/accounts/components/AccountCard.tsx
+import {
+  Card as Card3,
+  CardContent as CardContent4,
+  Divider as Divider5,
+  Typography as Typography13
+} from "@mui/material";
+import { FlexGrowCol as FlexGrowCol4, FlexGrowRow as FlexGrowRow10 } from "@xylabs/react-flexbox";
+import { jsx as jsx48, jsxs as jsxs22 } from "react/jsx-runtime";
+var AccountCard = ({ items, ...props }) => {
+  return /* @__PURE__ */ jsx48(Card3, { ...props, children: /* @__PURE__ */ jsx48(CardContent4, { children: /* @__PURE__ */ jsx48(FlexGrowCol4, { width: "100%", gap: 2, children: items.map((item, index) => {
+    return /* @__PURE__ */ jsxs22(FlexGrowCol4, { gap: 2, width: "100%", alignItems: "stretch", children: [
+      /* @__PURE__ */ jsxs22(
+        FlexGrowRow10,
+        {
+          sx: {
+            alignItems: "stretch",
+            flexDirection: { md: "row", xs: "column" },
+            justifyContent: "space-between"
+          },
+          gap: 2,
+          children: [
+            /* @__PURE__ */ jsxs22(
+              FlexGrowCol4,
+              {
+                alignItems: "flex-start",
+                width: "100%",
+                sx: { maxWidth: { md: "40%", xs: "100%" } },
+                children: [
+                  /* @__PURE__ */ jsx48(Typography13, { variant: "h5", gutterBottom: true, children: item.title }),
+                  /* @__PURE__ */ jsx48(Typography13, { variant: "body1", gutterBottom: true, children: item.desc })
+                ]
+              }
+            ),
+            item?.component
+          ]
+        }
+      ),
+      items.length === 1 || index === items.length - 1 ? null : /* @__PURE__ */ jsx48(Divider5, { flexItem: true })
+    ] }, index);
+  }) }) }) });
+};
+
+// src/dapps/shared/accounts/components/PaymentMethods.tsx
+import { Fragment as Fragment9, jsx as jsx49 } from "react/jsx-runtime";
+var PaymentMethods = () => {
+  return /* @__PURE__ */ jsx49(DappPage, { title: "Payment Methods", children: /* @__PURE__ */ jsx49(Grid, { container: true, spacing: 3, children: /* @__PURE__ */ jsx49(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx49(
+    AccountCard,
+    {
+      sx: { height: "100%" },
+      items: [
+        {
+          // TODO - needs a default implementation
+          component: /* @__PURE__ */ jsx49(FormGroupCreditCardProvider, { children: /* @__PURE__ */ jsx49(Fragment9, {}) }),
+          desc: "Save a credit card to your node to complete credit payments seamlessly.",
+          title: "Credit Card"
+        },
+        {
+          component: /* @__PURE__ */ jsx49(CoinbaseEmailInput, {}),
+          desc: "Use your Coinbase Account receive payments easily.",
+          title: "Coinbase Email"
+        },
+        {
+          component: /* @__PURE__ */ jsx49(PrimaryCryptoWalletInput, {}),
+          desc: "This is the primary crypto wallet on your node.",
+          title: "Primary Crypto Wallet"
+        },
+        {
+          component: /* @__PURE__ */ jsx49(SecondaryCryptoWalletInput, {}),
+          desc: "This is the secondary crypto wallet on your node.",
+          title: "Secondary Crypto Wallet"
+        }
+      ]
+    }
+  ) }) }) });
+};
+
+// src/dapps/shared/accounts/models/CreditCardInput.ts
+import { isPayloadOfSchemaTypeWithMeta } from "@xyo-network/payload-model";
+var CreditCardInputSchema = "network.xyo.credit.card.input";
+var isCreditCardInput = isPayloadOfSchemaTypeWithMeta(CreditCardInputSchema);
+
+// src/dapps/shared/name-service/DomainIcon.tsx
+import { createSvgIcon } from "@mui/material";
+import { jsx as jsx50 } from "react/jsx-runtime";
+var XnsDomainIcon = createSvgIcon(
+  /* @__PURE__ */ jsx50("svg", { id: "Layer_1", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 400 400", children: /* @__PURE__ */ jsx50(
+    "path",
+    {
+      fill: "currentColor",
+      d: "M384.67,118.15c-10.22-25.59-24.44-47.14-42.66-64.65-18.21-17.5-39.36-30.79-63.45-39.86C254.48,4.58,228.67.04,201.11.04c-33.77,0-63.36,5.25-88.78,15.73-25.41,10.49-46.56,24.71-63.45,42.66-16.89,17.95-29.42,38.43-37.6,61.45C3.11,142.91-.62,166.94.08,192c.89,34.48,8.09,60.92,21.6,79.32,13.51,18.4,34.48,27.59,62.92,27.59,8.72,0,17.01-1.23,24.93-3.53v4.75c0,2.43,1.96,4.39,4.39,4.39h37.48c2.43,0,4.39-1.96,4.39-4.39v-115.59l76.94,117.99c.81,1.24,2.19,1.99,3.68,1.99h37.47c2.43,0,4.39-1.96,4.39-4.39V104.6c0-2.43-1.96-4.39-4.39-4.39h-37.47c-2.43,0-4.39,1.96-4.39,4.39v115.59l-76.94-117.99c-.81-1.24-2.19-1.99-3.68-1.99h-37.48c-2.43,0-4.39,1.96-4.39,4.39v135.87c-.62,1.06-1.28,2.06-2,2.99-5.33,6.93-13.24,10.39-23.73,10.39-9.24,0-16.4-2.62-21.46-7.86-5.06-5.24-8.62-12.4-10.66-21.46-2.04-9.06-3.24-19.46-3.6-31.19-.54-27.55,3.55-50.75,12.26-69.59,8.71-18.83,20.49-34.08,35.32-45.72,14.85-11.64,31.15-20.09,48.93-25.33,17.77-5.24,35.46-7.86,53.06-7.86,24.89,0,47.01,3.96,66.38,11.86,19.37,7.91,35.68,19.02,48.92,33.33,13.25,14.31,23.2,31.19,29.86,50.65,6.67,19.46,9.83,40.84,9.47,64.12-.7,23.11-4.89,43.9-12.53,62.39-7.64,18.49-18.31,34.31-32,47.46-13.69,13.15-29.86,23.19-48.52,30.13-18.66,6.93-39.1,10.4-61.32,10.4-12.44,0-24.83-1.38-37.19-4.13-8.79-1.96-17.06-4.49-24.81-7.57-5.09-2.02-10.82.46-12.7,5.61l-8.56,23.42c-1.79,4.91.65,10.33,5.49,12.31,11.06,4.53,22.55,8.02,34.45,10.49,15.02,3.11,30.26,4.66,45.73,4.66,28.97,0,55.63-4.8,79.98-14.4,24.36-9.59,45.51-23.15,63.46-40.66,17.95-17.5,31.81-38.08,41.59-61.72,9.77-23.64,14.66-49.32,14.66-77.05,0-33.06-5.11-62.39-15.33-87.98Z"
+    }
+  ) }),
+  "XNSDomain"
+);
+
+// src/dapps/shared/table/head/components/Head.tsx
+import { InfoOutlined } from "@mui/icons-material";
+import {
+  TableCell,
+  TableHead,
+  Tooltip as Tooltip5
+} from "@mui/material";
+
+// src/dapps/shared/table/head/hooks/useVisibleColumns.tsx
+import { useMediaQuery as useMediaQuery2 } from "@mui/material";
+import { useMemo as useMemo17 } from "react";
+var useVisibleColumns = (tableHeadCells) => {
+  const isMedium = useMediaQuery2((theme) => theme.breakpoints.down("lg"));
+  const VisibleTableCells = useMemo17(() => {
+    return isMedium ? tableHeadCells.filter((cell) => cell.showOnMobile) : tableHeadCells;
+  }, [isMedium, tableHeadCells]);
+  return [VisibleTableCells, isMedium];
+};
+
+// src/dapps/shared/table/head/components/StyledTableRowHeader.tsx
+import { styled as styled9, TableRow as TableRow2 } from "@mui/material";
+var StyledTableRowHeader = styled9(
+  TableRow2,
+  { name: "StyledTableRowHeader" }
+)(({ theme }) => ({ "& .MuiTableCell-root": { backgroundColor: theme.palette.background.paper } }));
+
+// src/dapps/shared/table/head/components/Head.tsx
+import { jsx as jsx51, jsxs as jsxs23 } from "react/jsx-runtime";
+var TableHeadEx = ({ payloads, ...props }) => {
+  const [VisibleTableCells] = useVisibleColumns(payloads);
+  return /* @__PURE__ */ jsx51(TableHead, { ...props, children: /* @__PURE__ */ jsx51(StyledTableRowHeader, { children: VisibleTableCells.map((headCell) => /* @__PURE__ */ jsx51(
+    TableCell,
+    {
+      align: headCell.align ?? "left",
+      padding: headCell.disablePadding ? "none" : "normal",
+      width: headCell.width ?? "auto",
+      children: headCell.tooltip ? /* @__PURE__ */ jsxs23(
+        "span",
+        {
+          style: {
+            alignItems: "center",
+            display: "inline-flex",
+            gap: "4px"
+          },
+          children: [
+            headCell.label,
+            /* @__PURE__ */ jsx51(Tooltip5, { title: headCell.tooltip, children: /* @__PURE__ */ jsx51(InfoOutlined, { sx: { fontSize: "16px" } }) })
+          ]
+        }
+      ) : headCell.label
+    },
+    headCell.id
+  )) }) });
+};
+
+// src/dapps/shared/table/head/Payload.ts
+import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
+
+// src/dapps/shared/table/head/Schema.ts
+var TableHeadCellSchema = "network.xyo.table.cell.head";
+
+// src/dapps/shared/table/head/Payload.ts
+var isTableHeadCell = isPayloadOfSchemaType(TableHeadCellSchema);
+
+// src/dapps/shared/table/NextIteratorFlexbox.tsx
+import { ArrowCircleLeftOutlined, ArrowCircleRightOutlined } from "@mui/icons-material";
+import { IconButton as IconButton4, LinearProgress as LinearProgress2 } from "@mui/material";
+import { FlexRow as FlexRow9 } from "@xylabs/react-flexbox";
+import { jsx as jsx52, jsxs as jsxs24 } from "react/jsx-runtime";
+var NextIteratorFlexbox = ({
+  next: changePage,
+  loading,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs24(FlexRow9, { justifyContent: "space-between", gap: 2, ...props, children: [
+    /* @__PURE__ */ jsx52(
+      LinearProgress2,
+      {
+        sx: {
+          display: "flex",
+          flexGrow: 1,
+          visibility: loading ? "visible" : "hidden"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs24(FlexRow9, { children: [
+      /* @__PURE__ */ jsx52(IconButton4, { onClick: () => {
+        changePage("asc").catch(console.error);
+      }, children: /* @__PURE__ */ jsx52(ArrowCircleLeftOutlined, {}) }),
+      /* @__PURE__ */ jsx52(IconButton4, { onClick: () => {
+        changePage("desc").catch(console.error);
+      }, children: /* @__PURE__ */ jsx52(ArrowCircleRightOutlined, {}) })
+    ] })
+  ] });
+};
+
+// src/settings/Theme/ThemeProvider.tsx
+import { InvertibleCssVarsProvider } from "@xylabs/react-invertible-theme";
+import { useMemo as useMemo18 } from "react";
+
+// src/settings/Theme/ThemeCssVars.ts
+import {
+  alpha as alpha8,
+  darken,
+  experimental_extendTheme as extendTheme,
+  lighten
+} from "@mui/material";
+var defaultIconBackground = "#A060E0";
+var defaultIconBackgroundHover = "#bdade8";
+var DynamicIconBgGradientBuilder = {
+  iconBgGradientBuilder: (baseColor) => `linear-gradient(148deg, ${baseColor} 0%, ${darken(baseColor, 0.3)} 100%);`,
+  iconBgHoverGradientBuilder: (baseColor) => `linear-gradient(148deg, ${lighten(baseColor, 0.5)} 0%, ${lighten(baseColor, 0.2)} 100%);`
+};
+var StaticIconBgGradient = {
+  iconGradient: `linear-gradient(148deg, ${defaultIconBackground} 0%, ${darken(defaultIconBackground, 0.35)} 100%);`,
+  iconGradientHover: `linear-gradient(148deg, ${defaultIconBackgroundHover} 0%, ${darken(defaultIconBackgroundHover, 0.35)} 100%);`
+};
+var lightPalette = {
+  background: {
+    default: "#F4F4F4",
+    paper: "#FFFFFF"
+  },
+  error: {
+    dark: "#AA0E0E",
+    light: "#F15555",
+    main: "#D81111"
+  },
+  ...DynamicIconBgGradientBuilder,
+  ...StaticIconBgGradient,
+  primary: { main: "#100029" },
+  secondary: { main: "#A060E0" },
+  success: {
+    dark: "#347f21",
+    light: "#94dd80",
+    main: "#62bc50"
+  },
+  text: {
+    disabled: "#49454D",
+    primary: "#1D1B1E",
+    secondary: "#49454D"
+  },
+  warning: { main: "#ffc805" }
+};
+var darkPalette = {
+  background: {
+    default: "#121212",
+    paper: "#1E1E1E"
+  },
+  error: { main: "#ffb4ab" },
+  success: { main: "#94dd80" },
+  ...DynamicIconBgGradientBuilder,
+  ...StaticIconBgGradient,
+  primary: { main: "#C9BFFA" },
+  secondary: { main: "#C9C3DA" },
+  text: {
+    disabled: "#a5acdb",
+    primary: "#F4F4F4",
+    secondary: "#daddf2"
+  }
+};
+var ThemeCssVars = extendTheme({
+  colorSchemes: {
+    dark: { palette: darkPalette },
+    light: { palette: lightPalette }
+  },
+  components: {
+    MuiAccordion: {
+      styleOverrides: {
+        root: {
+          "&.Mui-expanded": { "&$expanded": { margin: "4px 0" } },
+          "boxShadow": "none"
+        }
+      }
+    },
+    MuiAccordionSummary: { styleOverrides: { root: { boxShadow: "none" } } },
+    MuiAppBar: {
+      styleOverrides: {
+        root: ({ theme }) => ({
+          WebkitBackdropFilter: "blur(20px)",
+          backdropFilter: "blur(20px)",
+          backgroundColor: alpha8(theme.palette.background.paper, 0.2),
+          boxShadow: "none",
+          color: "#1D1B1E",
+          [theme.getColorSchemeSelector("dark")]: { color: "#CBC4CE" }
+        })
+      }
+    },
+    MuiCard: {
+      defaultProps: { elevation: 0 },
+      styleOverrides: {
+        root: ({ theme }) => ({
+          WebkitBackdropFilter: "blur(20px)",
+          backdropFilter: "blur(20px)",
+          backgroundColor: alpha8(theme.palette.background.paper, 0.7),
+          display: "flex",
+          flexDirection: "column",
+          justifyContent: "space-between"
+        })
+      }
+    },
+    MuiCardContent: {
+      styleOverrides: {
+        root: {
+          // This is to get rid of the extra padding at the end of Card Content that misaligns padding when there's only 1 item
+          "&:last-child": { paddingBottom: "16px" }
+        }
+      }
+    },
+    MuiCardHeader: {
+      styleOverrides: {
+        content: {
+          display: "flex",
+          flexDirection: "column",
+          overflow: "hidden"
+        }
+      }
+    },
+    MuiChip: {
+      styleOverrides: {
+        root: {
+          borderRadius: 4,
+          fontWeight: 400
+        }
+      }
+    },
+    MuiContainer: { styleOverrides: { root: { maxWidth: "xl" } } },
+    MuiFilledInput: {
+      defaultProps: { disableUnderline: true },
+      styleOverrides: {
+        root: ({ theme }) => ({
+          "&.Mui-error": { border: `${theme.palette.error.main} 1px solid` },
+          "border": "transparent 1px solid",
+          "borderRadius": theme.shape.borderRadius
+        })
+      }
+    },
+    MuiLink: {
+      defaultProps: { underline: "none" },
+      styleOverrides: { root: { "&:hover": { filter: "brightness(75%)" } } }
+    },
+    MuiPaper: { defaultProps: { elevation: 0 } },
+    MuiTableCell: {
+      styleOverrides: {
+        body: {
+          fontFamily: "monospace",
+          whiteSpace: "nowrap"
+        },
+        head: {
+          fontWeight: 700,
+          whiteSpace: "nowrap"
+        }
+      }
+    }
+  },
+  spacing: 12,
+  typography: {
+    allVariants: { fontFamily: ["Manrope", "san-serif"].join(",") },
+    body1: {
+      fontSize: "16px",
+      fontWeight: 400
+    },
+    button: {
+      fontSize: "1rem",
+      fontWeight: 500,
+      textTransform: "capitalize"
+    },
+    fontWeightBold: 700,
+    fontWeightLight: 300,
+    fontWeightMedium: 600,
+    fontWeightRegular: 500,
+    h1: { fontSize: "3.2rem" },
+    h2: { fontSize: "2.7rem" },
+    h3: { fontSize: "2.24rem" },
+    h4: { fontSize: "2rem" },
+    h5: { fontSize: "1.5rem" },
+    h6: { fontSize: "1.2rem" },
+    subtitle1: {
+      fontWeight: 300,
+      opacity: "50%",
+      textTransform: "uppercase"
+    },
+    subtitle2: { opacity: "50%" }
+  }
+});
+
+// src/settings/Theme/ThemeProvider.tsx
+import { jsx as jsx53 } from "react/jsx-runtime";
+var AppOsThemeProvider = ({ children }) => {
+  const initialValue = useMemo18(() => {
+    const validValues = ["light", "dark"];
+    const savedValue = localStorage.getItem("mui-mode");
+    if (savedValue && validValues.includes(savedValue)) return savedValue;
+    return "system";
+  }, []);
+  return /* @__PURE__ */ jsx53(InvertibleCssVarsProvider, { theme: ThemeCssVars, defaultMode: initialValue, children });
+};
+
+// src/StyledBuilder.tsx
+import { styled as styled10 } from "@mui/material";
+var StyledDappIconBuilder = (DappIcon) => styled10(DappIcon, {
+  name: "StyledDappIcon",
+  shouldForwardProp: (key) => !["iconSize"].includes(key)
+})(({ iconSize, theme }) => ({
+  color: theme.palette.text.primary,
+  height: iconSize,
+  width: iconSize
+}));
+export {
+  AppOsThemeProvider,
+  BridgeActivityHelper,
+  BrowserLocator,
+  CoinbaseEmailInput,
+  ContainerFlexbox,
+  CreditCardInputSchema,
+  CustomerParams,
+  DappAccessDialog,
+  DappAccessFlexbox,
+  DappAccessRequestResourceHooks,
+  DappBar,
+  DappBottomNavigation,
+  DappChrome,
+  DappChromeLarge,
+  DappContainer,
+  DappInstallTypeFilters,
+  DappIntentResourceHooks,
+  DappMenuDrawer,
+  DappMenuResourceHooks,
+  DappPage,
+  DappPathSwitcher,
+  DappTitle,
+  DappWindow,
+  DappsRow,
+  DebugDialog,
+  DebugDialogWithNode,
+  DefaultComingSoon,
+  EmptyDappBarForPadding,
+  ErrorRenderWithSupport,
+  ErrorRenderWithSupportDefault,
+  GenericPayloadDivinerTags,
+  LazyDebug,
+  LoadingOsLogo,
+  NameServiceRegistrationHooks,
+  NetworkButton,
+  NetworkLoadingIndicator,
+  NetworkReadyFlexBox,
+  NextIteratorFlexbox,
+  OsPalettes,
+  PaymentMethods,
+  PrimaryCryptoWalletInput,
+  RenderHtml,
+  ResourceHooks,
+  SecondaryCryptoWalletInput,
+  ShiftAnimation,
+  StyledDappIconBuilder,
+  StyledGridContainer,
+  TableHeadCellSchema,
+  TableHeadEx,
+  TwoToneBulletPoint,
+  TwoToneBulletPointList,
+  UpperWidgetTrayLayout,
+  WidgetCaller,
+  WidgetCard,
+  WidgetCardExamples,
+  XnsDomainIcon,
+  XyOsBrowserMonitor,
+  XyOsUi,
+  XyOsUiContext,
+  XyOsUiContextProvider,
+  getApiDomain,
+  getNodePaletteByNameCode,
+  isCreditCardInput,
+  isTableHeadCell,
+  useAccountArchivist,
+  useAddDappMenuItems,
+  useBios,
+  useBuildDappAccessRequestResource,
+  useBuildDappMenuResource,
+  useBuildIntentResource,
+  useBuildNameServiceRegistrationsResource,
+  useBuildNameServiceRegistrationsResourceViews,
+  useCleanUpResource,
+  useClearIntents,
+  useDappAccessRequestResourceViews,
+  useDappCaller,
+  useDappContextCreator,
+  useDappIntentCaller,
+  useDappIntentListener,
+  useDappIntentListener2,
+  useDappMenu,
+  useDappMenuCaller,
+  useDappRegistrationResults,
+  useDappRegistry,
+  useDappSeedPhraseRepository,
+  useDappState,
+  useDebugClick,
+  useDecomposeDappSet,
+  useDetectCustomer,
+  useDialogState,
+  useExposedNode,
+  useIntentResourceViews,
+  useKernel,
+  useManageDappBasedOffRoute,
+  useManageDappInjectableParamsFromRoute,
+  useManageDappIntentRequest,
+  useManageDappPathFromRoute,
+  useManageDappStateFromRoute,
+  useMenuResourceViews,
+  useNavigateIntent,
+  useOnWindowResize,
+  useOsNetwork,
+  useOsSettingsCaller,
+  usePhraseFile,
+  useSendDappIntent,
+  useSkipLoadingScreen,
+  useStackReady,
+  useSyncExternalPayloadStore,
+  useSyncOsRegisteredAccessInterfaces,
+  useTabs,
+  useVisibleColumns,
+  useWidgetDapps,
+  useXyOsUiContext,
+  useXyoPublicNetwork
+};
+//# sourceMappingURL=index.mjs.map