@@ -0,0 +1,14 @@
+---
+'@object-ui/console': patch
+---
+
+fix(console): `/forms/NAME` for a form that does not exist renders the console's localized not-found state, not a raw English error (#27446)
+
+Clause-②: no
+Metadata-protocol: none
+
+The internal form route threw `Form metadata not found: view/NAME` for any failed `/meta/view` read, and the page rendered that English text verbatim, whatever the session language.
+
+- **A 404 is "no such form".** The page now draws the console's shared not-found state, with the catch-all route's pack keys (`console.notFound.title`, `console.notFound.description`, `console.notFound.back`) in the session language, and a Go back button. The metadata route answers 404 both for a missing view and for one the caller may not read, so the page says the one thing both mean.
+- **Every other failure keeps the error banner.** A non-404 failure now says `Could not load form metadata (STATUS): view/NAME`, instead of claiming the form was not found.
+- No i18n key is added or changed. The public `/f/:slug` route is unchanged.
@@ -0,0 +1,92 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack-ai/objectstack#27446 — `/forms/NAME` for a form that does not
+ * exist rendered the loader's English throw, `Form metadata not found:
+ * view/NAME`, verbatim in the page body, whatever the session language.
+ *
+ * The internal loader now tells a 404 from the `/meta/view` read apart from
+ * every other load failure, and the page draws the console's shared
+ * not-found state for it — the copy and pack keys of the catch-all route
+ * (`console.notFound.*`) — in the session language. Every other load failure
+ * keeps the error banner (the `CONTROL` case).
+ *
+ * No `I18nProvider` is wrapped around the route, for the reason
+ * `FormPage.chromeI18n-11039.test.tsx` gives: `createI18n` registers the
+ * process-global instance every unwrapped consumer reads.
+ */
+
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { createI18n } from '@object-ui/i18n';
+import { FormPage } from './FormPage';
+
+vi.mock('sonner', () => ({ toast: { success: vi.fn(), error: vi.fn() } }));
+
+/** Answers the `/meta/view` read with `status`; nothing else is reachable. */
+function stubViewRead(status: number) {
+  return vi.fn(async (url: string) => {
+    if (!String(url).includes('/meta/view/no_such_form')) throw new Error(`unstubbed fetch: ${url}`);
+    const body = { error: { code: 'RESOURCE_NOT_FOUND', message: 'Metadata item not found or access denied.' } };
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      statusText: 'Error',
+      json: async () => body,
+      text: async () => JSON.stringify(body),
+    } as unknown as Response;
+  });
+}
+
+function renderMissingForm() {
+  return render(
+    <MemoryRouter initialEntries={['/forms/no_such_form']}>
+      <Routes>
+        <Route path="/forms/:name" element={<FormPage mode="internal" />} />
+      </Routes>
+    </MemoryRouter>,
+  );
+}
+
+function inLanguage(language: string) {
+  createI18n({ defaultLanguage: language, detectBrowserLanguage: false });
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('FormPage: a missing form renders the shared localized not-found state (#27446)', () => {
+  it('zh: the not-found state is the zh pack\'s, and no English reaches the page', async () => {
+    inLanguage('zh');
+    vi.stubGlobal('fetch', stubViewRead(404));
+    renderMissingForm();
+
+    const state = await screen.findByTestId('form-not-found');
+    expect(state).toHaveTextContent('页面不存在');
+    expect(state).toHaveTextContent('你访问的链接与该应用中的任何视图都不匹配。');
+    expect(screen.getByRole('button', { name: '返回' })).toBeInTheDocument();
+    expect(document.body.textContent).not.toMatch(/[A-Za-z]{3,}/);
+  });
+
+  it('en: the same state in English', async () => {
+    inLanguage('en');
+    vi.stubGlobal('fetch', stubViewRead(404));
+    renderMissingForm();
+
+    const state = await screen.findByTestId('form-not-found');
+    expect(state).toHaveTextContent('Page not found');
+    expect(screen.getByRole('button', { name: 'Go back' })).toBeInTheDocument();
+    expect(document.body.textContent).not.toContain('Form metadata not found');
+  });
+
+  it('CONTROL: a load failure that is not a 404 keeps the error banner', async () => {
+    inLanguage('zh');
+    vi.stubGlobal('fetch', stubViewRead(500));
+    renderMissingForm();
+
+    expect(await screen.findByText(/Could not load form metadata \(500\)/)).toBeInTheDocument();
+    expect(screen.queryByTestId('form-not-found')).not.toBeInTheDocument();
+  });
+});
@@ -148,7 +148,17 @@ import {
   mapFieldTypeToFormType,
   resolveFormWidgetType,
 } from '@object-ui/fields';
-import { Tabs, TabsContent, TabsList, TabsTrigger, cn } from '@object-ui/components';
+import {
+  Button,
+  Empty,
+  EmptyDescription,
+  EmptyTitle,
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+  cn,
+} from '@object-ui/components';
 import {
   SchemaRendererContext,
   extractFieldErrors,
@@ -1709,6 +1719,24 @@ export function resolveInternalForm(
   };
 }
 
+/**
+ * The internal route's "no such form" (objectstack-ai/objectstack#27446): the
+ * `/meta/view` read answered 404. The metadata route answers 404 both for a
+ * view that does not exist and for one the caller may not read, on purpose, so
+ * the page says the one thing both mean — nothing here by that name.
+ *
+ * A type of its own, not a message to match, so {@link FormPage} can tell it
+ * from every other load failure and draw the console's shared localized
+ * not-found state for it instead of this English text. The message is kept
+ * for anyone who logs the error; the page never renders it.
+ */
+class FormNotFoundError extends Error {
+  constructor(name: string) {
+    super(`Form metadata not found: view/${name}`);
+    this.name = 'FormNotFoundError';
+  }
+}
+
 /**
  * Internal mode: pull the FormView metadata directly + the target object's
  * schema, and — when the URL names a record (objectui#4278) — that record.
@@ -1733,8 +1761,9 @@ async function loadInternalForm(
   channel?: ApiFetch,
 ): Promise<LoadedForm> {
   const viewRes = await apiFetch(`/meta/view/${encodeURIComponent(name)}`, undefined, channel);
+  if (viewRes.status === 404) throw new FormNotFoundError(name);
   if (!viewRes.ok) {
-    throw new Error(`Form metadata not found: view/${name}`);
+    throw new Error(`Could not load form metadata (${viewRes.status}): view/${name}`);
   }
   const viewBody = await viewRes.json();
   const { label, object: objectName, form } = resolveInternalForm(name, viewBody);
@@ -2336,6 +2365,12 @@ export function FormPage({ mode, recordPath, cancelPath }: FormPageProps) {
 
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
+  /**
+   * The load answered "no such form" ({@link FormNotFoundError}). Its own flag
+   * rather than a string in `error`, because the page draws a localized state
+   * for it and never shows the thrown text (objectstack-ai/objectstack#27446).
+   */
+  const [notFound, setNotFound] = useState(false);
   /**
    * The rows the last submit refused, by field name (objectstack-ai/objectstack#27417).
    * The `error` banner and the outcome toast still say the whole refusal; this
@@ -2421,6 +2456,7 @@ export function FormPage({ mode, recordPath, cancelPath }: FormPageProps) {
     let cancelled = false;
     setLoading(true);
     setError(null);
+    setNotFound(false);
     setFieldErrors({});
     // A `?recordId=` we cannot make sense of never reaches a loader: it is an
     // edit intent this route cannot honour, and #4278 ruling point 2 says
@@ -2446,7 +2482,8 @@ export function FormPage({ mode, recordPath, cancelPath }: FormPageProps) {
           // Clear any previously loaded form: a refusal must not leave an
           // editable form on screen behind the error.
           setLoaded(null);
-          setError(e?.message ?? String(e));
+          if (e instanceof FormNotFoundError) setNotFound(true);
+          else setError(e?.message ?? String(e));
         }
       })
       .finally(() => {
@@ -2818,6 +2855,24 @@ export function FormPage({ mode, recordPath, cancelPath }: FormPageProps) {
       </div>
     );
   }
+  if (notFound && !loaded) {
+    // The console's shared not-found state, the one its catch-all route
+    // (`RouteNotFound` in app-shell's `AppContent`) draws, with the same pack
+    // keys: a form is a view, and a missing one is a URL that matches none.
+    return (
+      <div className="flex min-h-[60vh] w-full items-center justify-center p-8" data-testid="form-not-found">
+        <Empty>
+          <EmptyTitle>{t('console.notFound.title')}</EmptyTitle>
+          <EmptyDescription>{t('console.notFound.description')}</EmptyDescription>
+          <div className="mt-4">
+            <Button variant="outline" onClick={() => navigate(-1)}>
+              {t('console.notFound.back')}
+            </Button>
+          </div>
+        </Empty>
+      </div>
+    );
+  }
   if (error && !loaded) {
     return (
       <div className="mx-auto max-w-2xl p-6">