diff --git a/js/app/components/settings/advanced-category-settings.tsx b/js/app/components/settings/advanced-category-settings.tsx
index 608d68a30..453013baf 100644
--- a/js/app/components/settings/advanced-category-settings.tsx
+++ b/js/app/components/settings/advanced-category-settings.tsx
@@ -13,36 +13,12 @@ import {
 import { Check } from "lucide-react-native";
 import { useEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { Platform, ScrollView } from "react-native";
+import { ScrollView } from "react-native";
 import { useStore } from "store";
 import { DEFAULT_URL } from "store/slices/streamplaceSlice";
 import { SettingToggle } from "./components/setting-toggle";
 import { SettingsRowItem } from "./components/settings-navigation-item";
 
-const WEB_BETA_COOKIE = "sp_web_beta";
-const ONE_YEAR_SECONDS = 60 * 60 * 24 * 365;
-
-function isWebBetaEnabledCookie(): boolean {
-  if (typeof document === "undefined") return false;
-  const cookies = document.cookie.split(";");
-  for (const raw of cookies) {
-    const [name, ...rest] = raw.trim().split("=");
-    if (name === WEB_BETA_COOKIE) {
-      return rest.join("=") === "1";
-    }
-  }
-  return false;
-}
-
-function setWebBetaCookie(enabled: boolean) {
-  if (typeof document === "undefined") return;
-  if (enabled) {
-    document.cookie = `${WEB_BETA_COOKIE}=1; path=/; max-age=${ONE_YEAR_SECONDS}; SameSite=Lax`;
-  } else {
-    document.cookie = `${WEB_BETA_COOKIE}=; path=/; max-age=0; SameSite=Lax`;
-  }
-}
-
 type Status = "ready" | "active" | "done";
 
 export function AdvancedCategorySettings() {
@@ -52,7 +28,6 @@ export function AdvancedCategorySettings() {
   const defaultUrl = DEFAULT_URL;
   const [newUrl, setNewUrl] = useState("");
   const [overrideEnabled, setOverrideEnabled] = useState(false);
-  const [webBeta, setWebBeta] = useState(false);
   const { t } = useTranslation("settings");
 
   const fetchBranding = useFetchBranding();
@@ -63,10 +38,6 @@ export function AdvancedCategorySettings() {
     setOverrideEnabled(url !== defaultUrl);
   }, [url, defaultUrl]);
 
-  useEffect(() => {
-    setWebBeta(isWebBetaEnabledCookie());
-  }, []);
-
   const onSubmitUrl = () => {
     if (newUrl) {
       let trimmedUrl = newUrl.endsWith("/") ? newUrl.slice(0, -1) : newUrl;
@@ -82,17 +53,6 @@ export function AdvancedCategorySettings() {
     }
   };
 
-  // Toggling web-beta writes a cookie and reloads. Web context only —
-  // the cookie lives in the browser, and the new web frontend is what
-  // we serve to opted-in users. Native mobile users have their own app
-  // and don't visit the web frontend.
-  const handleWebBetaToggle = (enabled: boolean) => {
-    setWebBetaCookie(enabled);
-    if (typeof window !== "undefined") {
-      window.location.reload();
-    }
-  };
-
   return (
     <ScrollView>
       <View style={[zero.layout.flex.align.center, zero.px[2], zero.py[2]]}>
@@ -107,17 +67,6 @@ export function AdvancedCategorySettings() {
               />
             </MenuGroup>
 
-            {Platform.OS === "web" && (
-              <MenuGroup>
-                <SettingToggle
-                  title={t("try-new-web")}
-                  description={t("try-new-web-description")}
-                  value={webBeta}
-                  onValueChange={handleWebBetaToggle}
-                />
-              </MenuGroup>
-            )}
-
             {overrideEnabled && (
               <View
                 style={[
diff --git a/pkg/api/api.go b/pkg/api/api.go
index 42d2b4a40..3ff8e64d4 100644
--- a/pkg/api/api.go
+++ b/pkg/api/api.go
@@ -31,7 +31,6 @@ import (
 
 	"github.com/streamplace/oatproxy/pkg/oatproxy"
 	"stream.place/streamplace/js/app"
-	web "stream.place/streamplace/js/web"
 	"stream.place/streamplace/pkg/acme"
 	"stream.place/streamplace/pkg/atproto"
 	"stream.place/streamplace/pkg/blob"
@@ -289,14 +288,16 @@ func (a *StreamplaceAPI) Handler(ctx context.Context) (http.Handler, error) {
 			},
 		}
 	} else {
-		// Always load both frontends. The NotFound dispatcher picks one per
-		// request based on the sp_web_beta cookie (or the --frontend CLI
-		// flag, which forces web for everyone).
+		// This build bundles one frontend, the app. The web frontend is
+		// not compiled in, so nothing a request carries can select it.
+		if a.CLI.Frontend == "web" {
+			log.Warn(ctx, "--frontend=web ignored: this build bundles only the app frontend")
+		}
 		frontends, err := a.loadFrontends(ctx)
 		if err != nil {
 			return nil, err
 		}
-		linkingHandler, err := a.NotFoundLinkingHandler(ctx, frontends, a.CLI.Frontend == "web")
+		linkingHandler, err := a.NotFoundLinkingHandler(ctx, frontends)
 		if err != nil {
 			return nil, err
 		}
@@ -356,22 +357,24 @@ func copyHeader(dst, src http.Header) {
 	}
 }
 
-// frontendSet holds a per-frontend linking handler so the NotFound
-// dispatcher can pick which one to serve per request. The legacy RN app
-// and the new Vite web app each get their own; the sp_web_beta cookie
-// opts a user into the new one unless the operator forced it via
-// --frontend=web (in which case forceWeb is true on pick).
+// webBetaCookie is the cookie that used to opt a browser into the web
+// frontend. This build has no web frontend, so the cookie selects nothing;
+// a browser still carrying one (set for a year by a settings toggle that is
+// gone too) has it expired on its next page load, so it cannot take effect
+// on some other build of the node either.
+const webBetaCookie = "sp_web_beta"
+
+// frontendSet holds the linking handler of the one frontend this build
+// bundles: the app. The web frontend is not compiled in.
 type frontendSet struct {
 	app http.HandlerFunc
-	web http.HandlerFunc
 }
 
-func (f *frontendSet) pick(r *http.Request, forceWeb bool) http.HandlerFunc {
-	if forceWeb {
-		return f.web
-	}
-	if c, err := r.Cookie("sp_web_beta"); err == nil && c.Value == "1" {
-		return f.web
+// pick is the frontend for a request: always the app, whatever cookie the
+// request carries.
+func (f *frontendSet) pick(w http.ResponseWriter, r *http.Request) http.HandlerFunc {
+	if _, err := r.Cookie(webBetaCookie); err == nil {
+		http.SetCookie(w, &http.Cookie{Name: webBetaCookie, Value: "", Path: "/", MaxAge: -1, SameSite: http.SameSiteLaxMode})
 	}
 	return f.app
 }
@@ -381,11 +384,7 @@ func (a *StreamplaceAPI) loadFrontends(ctx context.Context) (*frontendSet, error
 	if err != nil {
 		return nil, fmt.Errorf("loading app frontend: %w", err)
 	}
-	webHandler, err := a.buildLinkingHandler(ctx, web.Files)
-	if err != nil {
-		return nil, fmt.Errorf("loading web frontend: %w", err)
-	}
-	return &frontendSet{app: appHandler, web: webHandler}, nil
+	return &frontendSet{app: appHandler}, nil
 }
 
 // assetExtensions are the file types a browser or player asks for by name.
@@ -426,14 +425,12 @@ func (a *StreamplaceAPI) buildLinkingHandler(ctx context.Context, load func() (f
 	return a.notFoundLinkingHandler(ctx, linker, frontendFS)
 }
 
-// NotFoundLinkingHandler dispatches to the per-frontend handler that
-// matches the current request. The sp_web_beta cookie opts users into the
-// new web frontend; forceWeb (driven by --frontend=web) makes it stick
-// for everyone. The dev proxy (--dev-frontend-proxy) is handled upstream
-// and never reaches this handler.
-func (a *StreamplaceAPI) NotFoundLinkingHandler(ctx context.Context, frontends *frontendSet, forceWeb bool) (http.HandlerFunc, error) {
+// NotFoundLinkingHandler serves the bundled frontend for anything no route
+// claimed. The dev proxy (--dev-frontend-proxy) is handled upstream and
+// never reaches this handler.
+func (a *StreamplaceAPI) NotFoundLinkingHandler(ctx context.Context, frontends *frontendSet) (http.HandlerFunc, error) {
 	return func(w http.ResponseWriter, req *http.Request) {
-		frontends.pick(req, forceWeb)(w, req)
+		frontends.pick(w, req)(w, req)
 	}, nil
 }
 
diff --git a/pkg/api/frontends_test.go b/pkg/api/frontends_test.go
index bc6ff5f93..33685f60e 100644
--- a/pkg/api/frontends_test.go
+++ b/pkg/api/frontends_test.go
@@ -8,58 +8,41 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// frontendSet.pick decides which per-frontend handler serves a given
-// request. Cookie wins unless the operator forced web via --frontend=web.
+// This build bundles only the app frontend: no cookie selects anything
+// else, and a browser still carrying the old opt-in cookie has it expired.
 func TestFrontendSetPick(t *testing.T) {
-	t.Run("no cookie, not forced, returns app", func(t *testing.T) {
-		got := serve(&frontendSet{app: appHandler("a"), web: appHandler("w")}, nil, false)
-		require.Equal(t, "a", got)
-	})
-
-	t.Run("cookie = 1, returns web", func(t *testing.T) {
-		r := httptest.NewRequest("GET", "/", nil)
-		r.AddCookie(&http.Cookie{Name: "sp_web_beta", Value: "1"})
-		got := serveRaw(&frontendSet{app: appHandler("a"), web: appHandler("w")}, r, false)
-		require.Equal(t, "w", got)
-	})
-
-	t.Run("cookie = 0, returns app", func(t *testing.T) {
-		r := httptest.NewRequest("GET", "/", nil)
-		r.AddCookie(&http.Cookie{Name: "sp_web_beta", Value: "0"})
-		got := serveRaw(&frontendSet{app: appHandler("a"), web: appHandler("w")}, r, false)
-		require.Equal(t, "a", got)
-	})
+	set := &frontendSet{app: tagHandler("app")}
 
-	t.Run("no cookie, forceWeb is true, returns web", func(t *testing.T) {
-		got := serve(&frontendSet{app: appHandler("a"), web: appHandler("w")}, nil, true)
-		require.Equal(t, "w", got)
+	t.Run("no cookie: the app, and no cookie written", func(t *testing.T) {
+		rec := servePick(set, httptest.NewRequest("GET", "/", nil))
+		require.Equal(t, "app", rec.Body.String())
+		require.Empty(t, rec.Result().Cookies())
 	})
 
-	t.Run("cookie = 0, forceWeb is true, cookie ignored", func(t *testing.T) {
-		r := httptest.NewRequest("GET", "/", nil)
-		r.AddCookie(&http.Cookie{Name: "sp_web_beta", Value: "0"})
-		got := serveRaw(&frontendSet{app: appHandler("a"), web: appHandler("w")}, r, true)
-		require.Equal(t, "w", got)
-	})
+	for _, value := range []string{"1", "0", "anything"} {
+		t.Run("cookie "+value+": the app, and the cookie expired", func(t *testing.T) {
+			r := httptest.NewRequest("GET", "/", nil)
+			r.AddCookie(&http.Cookie{Name: "sp_web_beta", Value: value})
+			rec := servePick(set, r)
+			require.Equal(t, "app", rec.Body.String())
+			cookies := rec.Result().Cookies()
+			require.Len(t, cookies, 1)
+			require.Equal(t, "sp_web_beta", cookies[0].Name)
+			require.Equal(t, "", cookies[0].Value)
+			require.Negative(t, cookies[0].MaxAge)
+			require.Equal(t, "/", cookies[0].Path)
+		})
+	}
 }
 
-// appHandler returns a handler that writes the given tag so tests can
-// assert which frontend was picked.
-func appHandler(tag string) http.HandlerFunc {
+func tagHandler(tag string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		_, _ = w.Write([]byte(tag))
 	}
 }
 
-// serve runs pick with a fresh request. Useful for cases that don't need
-// a cookie.
-func serve(set *frontendSet, _ *http.Cookie, forceWeb bool) string {
-	return serveRaw(set, httptest.NewRequest("GET", "/", nil), forceWeb)
-}
-
-// serveRaw runs pick with the given request and reads back the body.
-func serveRaw(set *frontendSet, r *http.Request, forceWeb bool) string {
+func servePick(set *frontendSet, r *http.Request) *httptest.ResponseRecorder {
 	rec := httptest.NewRecorder()
-	set.pick(r, forceWeb)(rec, r)
-	return rec.Body.String()
+	set.pick(rec, r)(rec, r)
+	return rec
 }
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 13fab0eaa..2599d8197 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -530,7 +530,7 @@ func (cli *CLI) NewCommand(name string) *urfavecli.Command {
 			},
 			&urfavecli.StringFlag{
 				Name:        "frontend",
-				Usage:       "which bundled frontend to serve: 'app' (legacy Expo) or 'web' (Vite)",
+				Usage:       "which bundled frontend to serve. This build bundles only 'app'; 'web' is accepted and ignored",
 				Value:       "app",
 				Destination: &cli.Frontend,
 				Sources:     urfavecli.EnvVars("SP_FRONTEND"),