diff --git a/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionVersions.tsx b/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionVersions.tsx
index e629c1a1a..67f7147a0 100644
--- a/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionVersions.tsx
+++ b/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionVersions.tsx
@@ -1,7 +1,10 @@
 import {
-  getPublicEnvVariables,
-  getSessionTools,
-} from "cyberstorm/security/publicEnvVariables";
+  NimbusAwaitErrorElement,
+  NimbusDefaultRouteErrorBoundary,
+} from "cyberstorm/utils/errors/NimbusErrorBoundary";
+import { handleLoaderError } from "cyberstorm/utils/errors/handleLoaderError";
+import { throwUserFacingPayloadResponse } from "cyberstorm/utils/errors/userFacingErrorResponse";
+import { getLoaderTools } from "cyberstorm/utils/getLoaderTools";
 import { rowSemverCompare } from "cyberstorm/utils/semverCompare";
 import { Suspense } from "react";
 import { Await, type LoaderFunctionArgs } from "react-router";
@@ -14,69 +17,69 @@ import {
   NewTableSort,
   SkeletonBox,
 } from "@thunderstore/cyberstorm";
-import { DapperTs } from "@thunderstore/dapper-ts";
 
-import { columns } from "./Versions";
+import { columns, packageVersionsErrorMappings } from "./Versions";
 import "./Versions.css";
 import { DownloadLink, InstallLink, ModManagerBanner } from "./common";
 
 export async function loader({ params }: LoaderFunctionArgs) {
   if (params.communityId && params.namespaceId && params.packageId) {
-    const publicEnvVariables = getPublicEnvVariables(["VITE_API_URL"]);
-    const dapper = new DapperTs(() => {
+    const { dapper } = getLoaderTools();
+    try {
+      const versions = await dapper.getPackageVersions(
+        params.namespaceId,
+        params.packageId
+      );
+
       return {
-        apiHost: publicEnvVariables.VITE_API_URL,
-        sessionId: undefined,
+        communityId: params.communityId,
+        namespaceId: params.namespaceId,
+        packageId: params.packageId,
+        versions,
       };
-    });
-    return {
-      communityId: params.communityId,
-      namespaceId: params.namespaceId,
-      packageId: params.packageId,
-      versions: dapper.getPackageVersions(params.namespaceId, params.packageId),
-    };
+    } catch (error) {
+      handleLoaderError(error, { mappings: packageVersionsErrorMappings });
+    }
   }
-  return {
-    status: "error",
-    message: "Failed to load versions",
-    versions: [],
-  };
+  throwUserFacingPayloadResponse({
+    headline: "Package not found.",
+    description: "We could not find the requested package.",
+    category: "not_found",
+    status: 404,
+  });
 }
 
-export async function clientLoader({ params }: LoaderFunctionArgs) {
+export function clientLoader({ params }: LoaderFunctionArgs) {
   if (params.communityId && params.namespaceId && params.packageId) {
-    const tools = getSessionTools();
-    const dapper = new DapperTs(() => {
-      return {
-        apiHost: tools?.getConfig().apiHost,
-        sessionId: tools?.getConfig().sessionId,
-      };
-    });
+    const { dapper } = getLoaderTools();
+    const versions = dapper.getPackageVersions(
+      params.namespaceId,
+      params.packageId
+    );
+
     return {
       communityId: params.communityId,
       namespaceId: params.namespaceId,
       packageId: params.packageId,
-      versions: dapper.getPackageVersions(params.namespaceId, params.packageId),
+      versions,
     };
   }
-  return {
-    status: "error",
-    message: "Failed to load versions",
-    versions: [],
-  };
+  throwUserFacingPayloadResponse({
+    headline: "Package not found.",
+    description: "We could not find the requested package.",
+    category: "not_found",
+    status: 404,
+  });
 }
 
 export default function Versions() {
-  const { communityId, namespaceId, packageId, status, message, versions } =
-    useLoaderData<typeof loader | typeof clientLoader>();
-
-  if (status === "error") {
-    return <div>{message}</div>;
-  }
+  const { communityId, namespaceId, packageId, versions } = useLoaderData<
+    typeof loader | typeof clientLoader
+  >();
 
   return (
     <Suspense fallback={<SkeletonBox className="package-versions__skeleton" />}>
-      <Await resolve={versions}>
+      <Await resolve={versions} errorElement={<NimbusAwaitErrorElement />}>
         {(resolvedValue) => (
           <div className="package-versions">
             <ModManagerBanner />
@@ -134,3 +137,7 @@ export default function Versions() {
     </Suspense>
   );
 }
+
+export function ErrorBoundary() {
+  return <NimbusDefaultRouteErrorBoundary />;
+}
diff --git a/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionWithoutCommunityVersions.tsx b/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionWithoutCommunityVersions.tsx
index dda4c7fc5..cdf0ad408 100644
--- a/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionWithoutCommunityVersions.tsx
+++ b/apps/cyberstorm-remix/app/p/tabs/Versions/PackageVersionWithoutCommunityVersions.tsx
@@ -1,7 +1,10 @@
 import {
-  getPublicEnvVariables,
-  getSessionTools,
-} from "cyberstorm/security/publicEnvVariables";
+  NimbusAwaitErrorElement,
+  NimbusDefaultRouteErrorBoundary,
+} from "cyberstorm/utils/errors/NimbusErrorBoundary";
+import { handleLoaderError } from "cyberstorm/utils/errors/handleLoaderError";
+import { throwUserFacingPayloadResponse } from "cyberstorm/utils/errors/userFacingErrorResponse";
+import { getLoaderTools } from "cyberstorm/utils/getLoaderTools";
 import { rowSemverCompare } from "cyberstorm/utils/semverCompare";
 import { Suspense } from "react";
 import { Await, type LoaderFunctionArgs } from "react-router";
@@ -14,68 +17,67 @@ import {
   NewTableSort,
   SkeletonBox,
 } from "@thunderstore/cyberstorm";
-import { DapperTs } from "@thunderstore/dapper-ts";
 
-import { columns } from "./Versions";
+import { columns, packageVersionsErrorMappings } from "./Versions";
 import "./Versions.css";
 import { DownloadLink, InstallLink, ModManagerBanner } from "./common";
 
 export async function loader({ params }: LoaderFunctionArgs) {
   if (params.namespaceId && params.packageId) {
-    const publicEnvVariables = getPublicEnvVariables(["VITE_API_URL"]);
-    const dapper = new DapperTs(() => {
+    const { dapper } = getLoaderTools();
+    try {
+      const versions = await dapper.getPackageVersions(
+        params.namespaceId,
+        params.packageId
+      );
+
       return {
-        apiHost: publicEnvVariables.VITE_API_URL,
-        sessionId: undefined,
+        namespaceId: params.namespaceId,
+        packageId: params.packageId,
+        versions,
       };
-    });
-    return {
-      namespaceId: params.namespaceId,
-      packageId: params.packageId,
-      versions: dapper.getPackageVersions(params.namespaceId, params.packageId),
-    };
+    } catch (error) {
+      handleLoaderError(error, { mappings: packageVersionsErrorMappings });
+    }
   }
-  return {
-    status: "error",
-    message: "Failed to load versions",
-    versions: [],
-  };
+  throwUserFacingPayloadResponse({
+    headline: "Package not found.",
+    description: "We could not find the requested package.",
+    category: "not_found",
+    status: 404,
+  });
 }
 
-export async function clientLoader({ params }: LoaderFunctionArgs) {
+export function clientLoader({ params }: LoaderFunctionArgs) {
   if (params.namespaceId && params.packageId) {
-    const tools = getSessionTools();
-    const dapper = new DapperTs(() => {
-      return {
-        apiHost: tools?.getConfig().apiHost,
-        sessionId: tools?.getConfig().sessionId,
-      };
-    });
+    const { dapper } = getLoaderTools();
+    const versions = dapper.getPackageVersions(
+      params.namespaceId,
+      params.packageId
+    );
+
     return {
       namespaceId: params.namespaceId,
       packageId: params.packageId,
-      versions: dapper.getPackageVersions(params.namespaceId, params.packageId),
+      versions,
     };
   }
-  return {
-    status: "error",
-    message: "Failed to load versions",
-    versions: [],
-  };
+  throwUserFacingPayloadResponse({
+    headline: "Package not found.",
+    description: "We could not find the requested package.",
+    category: "not_found",
+    status: 404,
+  });
 }
 
 export default function Versions() {
-  const { namespaceId, packageId, status, message, versions } = useLoaderData<
+  const { namespaceId, packageId, versions } = useLoaderData<
     typeof loader | typeof clientLoader
   >();
 
-  if (status === "error") {
-    return <div>{message}</div>;
-  }
-
   return (
     <Suspense fallback={<SkeletonBox className="package-versions__skeleton" />}>
-      <Await resolve={versions}>
+      <Await resolve={versions} errorElement={<NimbusAwaitErrorElement />}>
         {(resolvedValue) => (
           <div className="package-versions">
             <ModManagerBanner />
@@ -132,3 +134,7 @@ export default function Versions() {
     </Suspense>
   );
 }
+
+export function ErrorBoundary() {
+  return <NimbusDefaultRouteErrorBoundary />;
+}
diff --git a/apps/cyberstorm-remix/app/p/tabs/Versions/Versions.tsx b/apps/cyberstorm-remix/app/p/tabs/Versions/Versions.tsx
index b34db13d8..7bfbd4cb3 100644
--- a/apps/cyberstorm-remix/app/p/tabs/Versions/Versions.tsx
+++ b/apps/cyberstorm-remix/app/p/tabs/Versions/Versions.tsx
@@ -1,82 +1,91 @@
+import "./Versions.css";
 import {
-  getPublicEnvVariables,
-  getSessionTools,
-} from "cyberstorm/security/publicEnvVariables";
-import { rowSemverCompare } from "cyberstorm/utils/semverCompare";
-import { Suspense } from "react";
-import { Await, type LoaderFunctionArgs } from "react-router";
-import { useLoaderData } from "react-router";
-
-import {
-  Heading,
-  NewLink,
+  NewTableSort,
   NewTable,
   type NewTableLabels,
-  NewTableSort,
+  Heading,
   SkeletonBox,
+  NewLink,
 } from "@thunderstore/cyberstorm";
-import { DapperTs } from "@thunderstore/dapper-ts";
-
-import "./Versions.css";
+import { Await, type LoaderFunctionArgs } from "react-router";
+import { useLoaderData } from "react-router";
+import { Suspense } from "react";
 import { DownloadLink, InstallLink, ModManagerBanner } from "./common";
+import { rowSemverCompare } from "cyberstorm/utils/semverCompare";
+import { handleLoaderError } from "cyberstorm/utils/errors/handleLoaderError";
+import { createNotFoundMapping } from "cyberstorm/utils/errors/loaderMappings";
+import { throwUserFacingPayloadResponse } from "cyberstorm/utils/errors/userFacingErrorResponse";
+import {
+  NimbusAwaitErrorElement,
+  NimbusDefaultRouteErrorBoundary,
+} from "cyberstorm/utils/errors/NimbusErrorBoundary";
+import { getLoaderTools } from "cyberstorm/utils/getLoaderTools";
+
+export const packageVersionsErrorMappings = [
+  createNotFoundMapping(
+    "Package not found.",
+    "We could not find the requested package."
+  ),
+];
 
 export async function loader({ params }: LoaderFunctionArgs) {
   if (params.communityId && params.namespaceId && params.packageId) {
-    const publicEnvVariables = getPublicEnvVariables(["VITE_API_URL"]);
-    const dapper = new DapperTs(() => {
+    const { dapper } = getLoaderTools();
+    try {
+      const versions = await dapper.getPackageVersions(
+        params.namespaceId,
+        params.packageId
+      );
+
       return {
-        apiHost: publicEnvVariables.VITE_API_URL,
-        sessionId: undefined,
+        communityId: params.communityId,
+        namespaceId: params.namespaceId,
+        packageId: params.packageId,
+        versions,
       };
-    });
-    return {
-      communityId: params.communityId,
-      namespaceId: params.namespaceId,
-      packageId: params.packageId,
-      versions: dapper.getPackageVersions(params.namespaceId, params.packageId),
-    };
+    } catch (error) {
+      handleLoaderError(error, { mappings: packageVersionsErrorMappings });
+    }
   }
-  return {
-    status: "error",
-    message: "Failed to load versions",
-    versions: [],
-  };
+  throwUserFacingPayloadResponse({
+    headline: "Package not found.",
+    description: "We could not find the requested package.",
+    category: "not_found",
+    status: 404,
+  });
 }
 
-export async function clientLoader({ params }: LoaderFunctionArgs) {
+export function clientLoader({ params }: LoaderFunctionArgs) {
   if (params.communityId && params.namespaceId && params.packageId) {
-    const tools = getSessionTools();
-    const dapper = new DapperTs(() => {
-      return {
-        apiHost: tools?.getConfig().apiHost,
-        sessionId: tools?.getConfig().sessionId,
-      };
-    });
+    const { dapper } = getLoaderTools();
+    const versions = dapper.getPackageVersions(
+      params.namespaceId,
+      params.packageId
+    );
+
     return {
       communityId: params.communityId,
       namespaceId: params.namespaceId,
       packageId: params.packageId,
-      versions: dapper.getPackageVersions(params.namespaceId, params.packageId),
+      versions,
     };
   }
-  return {
-    status: "error",
-    message: "Failed to load versions",
-    versions: [],
-  };
+  throwUserFacingPayloadResponse({
+    headline: "Package not found.",
+    description: "We could not find the requested package.",
+    category: "not_found",
+    status: 404,
+  });
 }
 
 export default function Versions() {
-  const { communityId, namespaceId, packageId, status, message, versions } =
-    useLoaderData<typeof loader | typeof clientLoader>();
-
-  if (status === "error") {
-    return <div>{message}</div>;
-  }
+  const { communityId, namespaceId, packageId, versions } = useLoaderData<
+    typeof loader | typeof clientLoader
+  >();
 
   return (
     <Suspense fallback={<SkeletonBox className="package-versions__skeleton" />}>
-      <Await resolve={versions}>
+      <Await resolve={versions} errorElement={<NimbusAwaitErrorElement />}>
         {(resolvedValue) => (
           <div className="package-versions">
             <ModManagerBanner />
@@ -135,6 +144,10 @@ export default function Versions() {
   );
 }
 
+export function ErrorBoundary() {
+  return <NimbusDefaultRouteErrorBoundary />;
+}
+
 export const columns: NewTableLabels = [
   {
     value: "Version",