console: render environment-not-ready flow in the standard layout

The environment-not-ready flow used a stripped custom layout with no
navigation, so users without an enabled environment could not see or
reach account-scoped pages like App Passwords, License, or Usage &
Billing. A blocked or trial-expired organization, by contrast, already
rendered the full BaseLayout with those links visible, making the two
states inconsistent.

Render EnvironmentNotReadyRoutes inside BaseLayout instead. The nav
already handles the no-environment state: region-scoped items hide via
HideIfEnvironmentDisabled while account-scoped Admin items carry
forceShow, so new users now get the same chrome as everyone else. The
logo links back to the enable-region flow while no environment is
ready.

The region-ready toast is preserved in a headless RegionReadyToast
component. Its unmount cleanup reads the unstable toast reference
through a ref instead of an eslint-disable, which the react-compiler
lint rule no longer accepts. The custom layout file is deleted.

Adds a test asserting the Admin nav group renders on the enable-region
page with no enabled environment while region-scoped items stay hidden.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jubrad

console/src/platform/environment-not-ready/EnvironmentNotReadyRoutes.test.tsx

@@ -91,4 +91,16 @@ describe("EnvironmentNotReadyRoutes", () => {
       );
     });
   });
+
+  it("shows account-level navigation without an enabled environment", async () => {
+    await renderRoutes(["/enable-region"]);
+    // Admin items are account-scoped and must stay reachable while no
+    // environment is enabled.
+    expect(await screen.findByText("Admin")).toBeInTheDocument();
+    expect(screen.getByText("App Passwords")).toBeInTheDocument();
+    expect(screen.getByText("Usage & Billing")).toBeInTheDocument();
+    // Region-scoped items are hidden until an environment is ready.
+    expect(screen.queryByText("Clusters")).not.toBeInTheDocument();
+    expect(screen.queryByText("SQL Shell")).not.toBeInTheDocument();
+  });
 });

console/src/platform/environment-not-ready/EnvironmentNotReadyRoutes.tsx

@@ -7,24 +7,100 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
+import { Text, VStack } from "@chakra-ui/react";
+import { useAtomValue } from "jotai";
 import React from "react";
-import { Navigate, Route } from "react-router-dom";
+import { Link, Navigate, Route } from "react-router-dom";
 
+import TextLink from "~/components/TextLink";
 import { User } from "~/external-library-wrappers/frontegg";
+import { useToast } from "~/hooks/useToast";
+import { BaseLayout } from "~/layouts/BaseLayout";
+import { regionPath } from "~/platform/routeHelpers";
 import { SentryRoutes } from "~/sentry";
+import {
+  currentRegionIdAtom,
+  useEnvironmentsWithHealth,
+  useRegionSlug,
+} from "~/store/environments";
 
 import EnableRegion from "./EnableRegion";
-import { EnvironmentNotReadyLayout } from "./Layout";
 import { OnboardingSteps } from "./OnboardingSteps";
 
+const REGION_READY_TOAST_ID = "region-ready-toast";
+
+export const RegionReadyToastBody = (props: {
+  currentRegionId: string;
+  regionPath: string;
+}) => {
+  return (
+    <VStack>
+      <Text textStyle="text-ui-med">{props.currentRegionId} is ready!</Text>
+      <TextLink textStyle="text-small" as={Link} to={props.regionPath}>
+        Go to Materialize Console &rarr;
+      </TextLink>
+    </VStack>
+  );
+};
+
+/**
+ * Pops a toast when the current region becomes healthy while the user is
+ * still in the environment-not-ready flow. Renders nothing.
+ */
+const RegionReadyToast = () => {
+  const toast = useToast();
+  const regionSlug = useRegionSlug();
+  const environments = useEnvironmentsWithHealth();
+  const currentRegionId = useAtomValue(currentRegionIdAtom);
+  const currentEnvironment = environments.get(currentRegionId);
+
+  // The toast reference isn't stable, so the unmount cleanup reads it through
+  // a ref instead of depending on it directly.
+  const toastRef = React.useRef(toast);
+  React.useEffect(() => {
+    toastRef.current = toast;
+  }, [toast]);
+
+  React.useEffect(() => {
+    if (
+      currentEnvironment &&
+      currentEnvironment.state === "enabled" &&
+      currentEnvironment.status.health === "healthy" &&
+      !toast.isActive(REGION_READY_TOAST_ID)
+    ) {
+      toast({
+        id: REGION_READY_TOAST_ID,
+        duration: null, // keep it open
+        position: "top-right",
+        description: (
+          <RegionReadyToastBody
+            currentRegionId={currentRegionId}
+            regionPath={regionPath(regionSlug)}
+          />
+        ),
+      });
+    }
+  }, [currentEnvironment, currentRegionId, regionSlug, toast]);
+
+  React.useEffect(() => {
+    return () => {
+      // Close the toast when this component unmounts
+      toastRef.current.close(REGION_READY_TOAST_ID);
+    };
+  }, []);
+
+  return null;
+};
+
 export const EnvironmentNotReadyRoutes = ({ user }: { user: User }) => {
   return (
-    <EnvironmentNotReadyLayout user={user}>
+    <BaseLayout>
+      <RegionReadyToast />
       <SentryRoutes>
         <Route path="enable-region" element={<EnableRegion user={user} />} />
         <Route path=":step" element={<OnboardingSteps user={user} />} />
         <Route path="*" element={<Navigate to="../enable-region" replace />} />
       </SentryRoutes>
-    </EnvironmentNotReadyLayout>
+    </BaseLayout>
   );
 };